package discord import ( "strings" "github.com/diamondburned/arikawa/v3/utils/json" "github.com/pkg/errors" ) // InteractionEvent describes the full incoming interaction event. It may be a // gateway event or a webhook event. // // https://discord.com/developers/docs/topics/gateway#interactions type InteractionEvent struct { ID InteractionID `json:"id"` Data InteractionData `json:"data"` AppID AppID `json:"application_id"` ChannelID ChannelID `json:"channel_id,omitempty"` Token string `json:"token"` Version int `json:"version"` // Message is the message the component was attached to. // Only present for component interactions, not command interactions. Message *Message `json:"message,omitempty"` // Member is only present if this came from a guild. To get a user, use the // Sender method. Member *Member `json:"member,omitempty"` GuildID GuildID `json:"guild_id,omitempty"` // User is only present if this didn't come from a guild. To get a user, use // the Sender method. User *User `json:"user,omitempty"` } // Sender returns the sender of this event from either the Member field or the // User field. If neither of those fields are available, then nil is returned. func (e *InteractionEvent) Sender() *User { if e.User != nil { return e.User } if e.Member != nil { return &e.Member.User } return nil } // SenderID returns the sender's ID. See Sender for more information. If Sender // returns nil, then 0 is returned. func (e *InteractionEvent) SenderID() UserID { if sender := e.Sender(); sender != nil { return sender.ID } return 0 } func (e *InteractionEvent) UnmarshalJSON(b []byte) error { type event InteractionEvent target := struct { Type InteractionDataType `json:"type"` Data json.Raw `json:"data"` *event }{ event: (*event)(e), } if err := json.Unmarshal(b, &target); err != nil { return err } var err error switch target.Type { case PingInteractionType: e.Data = &PingInteraction{} return nil // Ping isn't actually an object. case CommandInteractionType: e.Data = &CommandInteraction{} case ComponentInteractionType: d, err := ParseComponentInteraction(target.Data) if err != nil { return errors.Wrap(err, "failed to unmarshal component interaction event data") } e.Data = d return nil case AutocompleteInteractionType: e.Data = &AutocompleteInteraction{} case ModalInteractionType: e.Data = &ModalInteraction{} default: e.Data = &UnknownInteractionData{ Raw: target.Data, typ: target.Type, } return nil } if err := json.Unmarshal(target.Data, e.Data); err != nil { return errors.Wrap(err, "failed to unmarshal interaction event data") } return err } func (e *InteractionEvent) MarshalJSON() ([]byte, error) { type event InteractionEvent if e.Data == nil { return nil, errors.New("missing InteractionEvent.Data") } if e.Data.InteractionType() == 0 { return nil, errors.New("unexpected 0 InteractionEvent.Data.Type") } v := struct { Type InteractionDataType `json:"type"` *event }{ Type: e.Data.InteractionType(), event: (*event)(e), } return json.Marshal(v) } // InteractionDataType is the type of each Interaction, enumerated in // integers. type InteractionDataType uint const ( PingInteractionType InteractionDataType = iota + 1 CommandInteractionType ComponentInteractionType AutocompleteInteractionType ModalInteractionType ) // InteractionData holds the respose data of an interaction, or more // specifically, the data that Discord sends to us. Type assertions should be // made on it to access the underlying data. // // The following types implement this interface: // // - *PingInteraction // - *AutocompleteInteraction // - *CommandInteraction // - *SelectInteraction (also ComponentInteraction) // - *ButtonInteraction (also ComponentInteraction) // type InteractionData interface { InteractionType() InteractionDataType data() } // PingInteraction is a ping Interaction response. type PingInteraction struct{} // InteractionType implements InteractionData. func (*PingInteraction) InteractionType() InteractionDataType { return PingInteractionType } func (*PingInteraction) data() {} // AutocompleteInteraction is an autocompletion Interaction response. type AutocompleteInteraction struct { CommandID CommandID `json:"id"` // Name of command autocomplete is triggered for. Name string `json:"name"` CommandType CommandType `json:"type"` Version string `json:"version"` Options []AutocompleteOption `json:"options"` } // AutocompleteOption is an autocompletion option in an AutocompleteInteraction. type AutocompleteOption struct { Type CommandOptionType `json:"type"` Name string `json:"name"` Value string `json:"value"` Focused bool `json:"focused"` Options []AutocompleteOption `json:"options"` } // Type implements ComponentInteraction. func (*AutocompleteInteraction) InteractionType() InteractionDataType { return AutocompleteInteractionType } func (*AutocompleteInteraction) data() {} // ComponentInteraction is a union component interaction response types. The // types can be whatever the constructors for this type will return. // // The following types implement this interface: // // - *SelectInteraction // - *ButtonInteraction // type ComponentInteraction interface { InteractionData // ID returns the ID of the component in response. Not all component // interactions will have a component ID. ID() ComponentID // Type returns the type of the component in response. Type() ComponentType resp() } // SelectInteraction is a select component's response. type SelectInteraction struct { CustomID ComponentID `json:"custom_id"` Values []string `json:"values"` } // ID implements ComponentInteraction. func (s *SelectInteraction) ID() ComponentID { return s.CustomID } // Type implements ComponentInteraction. func (s *SelectInteraction) Type() ComponentType { return SelectComponentType } // InteractionType implements InteractionData. func (s *SelectInteraction) InteractionType() InteractionDataType { return ComponentInteractionType } func (s *SelectInteraction) resp() {} func (s *SelectInteraction) data() {} // ButtonInteraction is a button component's response. It is the custom ID of // the button within the component tree. type ButtonInteraction struct { CustomID ComponentID `json:"custom_id"` } // ID implements ComponentInteraction. func (b *ButtonInteraction) ID() ComponentID { return b.CustomID } // Type implements ComponentInteraction. func (b *ButtonInteraction) Type() ComponentType { return ButtonComponentType } // InteractionType implements InteractionData. func (b *ButtonInteraction) InteractionType() InteractionDataType { return ComponentInteractionType } func (b *ButtonInteraction) data() {} func (b *ButtonInteraction) resp() {} // ParseComponentInteraction parses the given bytes as a component response. func ParseComponentInteraction(b []byte) (ComponentInteraction, error) { var t struct { Type ComponentType `json:"component_type"` CustomID ComponentID `json:"custom_id"` } if err := json.Unmarshal(b, &t); err != nil { return nil, errors.Wrap(err, "failed to unmarshal component interaction header") } var d ComponentInteraction switch t.Type { case ButtonComponentType: d = &ButtonInteraction{CustomID: t.CustomID} case SelectComponentType: d = &SelectInteraction{CustomID: t.CustomID} default: d = &UnknownComponent{ Raw: append(json.Raw(nil), b...), id: t.CustomID, typ: t.Type, } return d, nil } if err := json.Unmarshal(b, d); err != nil { return nil, errors.Wrap(err, "failed to unmarshal component interaction data") } return d, nil } // CommandInteractionOptions is a list of interaction options. // Use `Find` to get your named interaction option type CommandInteractionOptions []CommandInteractionOption // CommandInteraction is an application command interaction that Discord sends // to us. type CommandInteraction struct { ID CommandID `json:"id"` Name string `json:"name"` Options CommandInteractionOptions `json:"options"` Resolved struct { // User contains user objects. Users map[UserID]User `json:"users,omitempty"` // Members contains partial member objects (missing User, Deaf and // Mute). Members map[UserID]Member `json:"members,omitempty"` // Role contains role objects. Roles map[RoleID]Role `json:"roles,omitempty"` // Channels contains partial channel objects that only have ID, Name, // Type and Permissions. Threads will also have ThreadMetadata and // ParentID. Channels map[ChannelID]Channel `json:"channels,omitempty"` // Messages contains partial message objects. All fields without // omitempty are presumably present. Messages map[MessageID]Message `json:"messages,omitempty"` } } // InteractionType implements InteractionData. func (*CommandInteraction) InteractionType() InteractionDataType { return CommandInteractionType } func (*CommandInteraction) data() {} // CommandInteractionOption is an option for a Command interaction response. type CommandInteractionOption struct { Type CommandOptionType `json:"type"` Name string `json:"name"` Value json.Raw `json:"value"` Options CommandInteractionOptions `json:"options"` } // Find returns the named command option func (o CommandInteractionOptions) Find(name string) CommandInteractionOption { for _, opt := range o { if strings.EqualFold(opt.Name, name) { return opt } } return CommandInteractionOption{} } // String will return the value if the option's value is a valid string. // Otherwise, it will return the raw JSON value of the other type. func (o CommandInteractionOption) String() string { var value string if err := json.Unmarshal(o.Value, &value); err != nil { return string(o.Value) } return value } // IntValue reads the option's value as an int. func (o CommandInteractionOption) IntValue() (int64, error) { var i int64 err := o.Value.UnmarshalTo(&i) return i, err } // BoolValue reads the option's value as a bool. func (o CommandInteractionOption) BoolValue() (bool, error) { var b bool err := o.Value.UnmarshalTo(&b) return b, err } // SnowflakeValue reads the option's value as a snowflake. func (o CommandInteractionOption) SnowflakeValue() (Snowflake, error) { var id Snowflake err := o.Value.UnmarshalTo(&id) return id, err } // FloatValue reads the option's value as a float64. func (o CommandInteractionOption) FloatValue() (float64, error) { var f float64 err := o.Value.UnmarshalTo(&f) return f, err } // ModalInteraction is the submitted modal form type ModalInteraction struct { CustomID ComponentID `json:"custom_id"` Components ContainerComponents `json:"components"` } // InteractionType implements InteractionData. func (m *ModalInteraction) InteractionType() InteractionDataType { return ModalInteractionType } func (m *ModalInteraction) data() {} // UnknownInteractionData describes an Interaction response with an unknown // type. type UnknownInteractionData struct { json.Raw typ InteractionDataType } // InteractionType implements InteractionData. func (u *UnknownInteractionData) InteractionType() InteractionDataType { return u.typ } func (u *UnknownInteractionData) data() {}