package discord import ( "encoding/json" "fmt" "time" ) type Opcode int // https://discord.com/developers/docs/topics/opcodes-and-status-codes#gateway-gateway-opcodes // NOTE(ben): I'm not using iota because 5 is missing const ( OpcodeDispatch Opcode = 0 OpcodeHeartbeat Opcode = 1 OpcodeIdentify Opcode = 2 OpcodePresenceUpdate Opcode = 3 OpcodeVoiceStateUpdate Opcode = 4 OpcodeResume Opcode = 6 OpcodeReconnect Opcode = 7 OpcodeRequestGuildMembers Opcode = 8 OpcodeInvalidSession Opcode = 9 OpcodeHello Opcode = 10 OpcodeHeartbeatACK Opcode = 11 ) type Intent int // https://discord.com/developers/docs/topics/gateway#list-of-intents // NOTE(ben): I'm not using iota because the opcode thing made me paranoid const ( IntentGuilds Intent = 1 << 0 IntentGuildMembers Intent = 1 << 1 IntentGuildBans Intent = 1 << 2 IntentGuildEmojisAndStickers Intent = 1 << 3 IntentGuildIntegrations Intent = 1 << 4 IntentGuildWebhooks Intent = 1 << 5 IntentGuildInvites Intent = 1 << 6 IntentGuildVoiceStates Intent = 1 << 7 IntentGuildPresences Intent = 1 << 8 IntentGuildMessages Intent = 1 << 9 IntentGuildMessageReactions Intent = 1 << 10 IntentGuildMessageTyping Intent = 1 << 11 IntentDirectMessages Intent = 1 << 12 IntentDirectMessageReactions Intent = 1 << 13 IntentDirectMessageTyping Intent = 1 << 14 ) type GatewayMessage struct { Opcode Opcode `json:"op"` Data interface{} `json:"d"` SequenceNumber *int `json:"s,omitempty"` EventName *string `json:"t,omitempty"` } func (m *GatewayMessage) ToJSON() []byte { mBytes, err := json.Marshal(m) if err != nil { panic(err) } return mBytes } type Hello struct { HeartbeatIntervalMs int `json:"heartbeat_interval"` } func HelloFromMap(m interface{}) Hello { return Hello{ HeartbeatIntervalMs: int(m.(map[string]interface{})["heartbeat_interval"].(float64)), } } type Identify struct { Token string `json:"token"` Properties IdentifyConnectionProperties `json:"properties"` Intents Intent `json:"intents"` } type IdentifyConnectionProperties struct { OS string `json:"$os"` Browser string `json:"$browser"` Device string `json:"$device"` } type Ready struct { GatewayVersion int `json:"v"` User User `json:"user"` SessionID string `json:"session_id"` } func ReadyFromMap(m interface{}) Ready { mmap := m.(map[string]interface{}) return Ready{ GatewayVersion: int(mmap["v"].(float64)), User: *UserFromMap(mmap["user"], ""), SessionID: mmap["session_id"].(string), } } type Resume struct { Token string `json:"token"` SessionID string `json:"session_id"` SequenceNumber int `json:"seq"` } // https://discord.com/developers/docs/topics/gateway#message-delete type MessageDelete struct { ID string `json:"id"` ChannelID string `json:"channel_id"` GuildID string `json:"guild_id"` } func MessageDeleteFromMap(m interface{}) MessageDelete { mmap := m.(map[string]interface{}) return MessageDelete{ ID: mmap["id"].(string), ChannelID: mmap["channel_id"].(string), GuildID: maybeString(mmap, "guild_id"), } } // https://discord.com/developers/docs/topics/gateway#message-delete type MessageBulkDelete struct { IDs []string `json:"ids"` ChannelID string `json:"channel_id"` GuildID string `json:"guild_id"` } func MessageBulkDeleteFromMap(m interface{}) MessageBulkDelete { mmap := m.(map[string]interface{}) iids := mmap["ids"].([]interface{}) ids := make([]string, len(iids)) for i, iid := range iids { ids[i] = iid.(string) } return MessageBulkDelete{ IDs: ids, ChannelID: mmap["channel_id"].(string), GuildID: maybeString(mmap, "guild_id"), } } type ChannelType int // https://discord.com/developers/docs/resources/channel#channel-object-channel-types const ( ChannelTypeGuildText ChannelType = 0 ChannelTypeDM ChannelType = 1 ChannelTypeGuildVoice ChannelType = 2 ChannelTypeGroupDM ChannelType = 3 ChannelTypeGuildCategory ChannelType = 4 ChannelTypeGuildNews ChannelType = 5 ChannelTypeGuildStore ChannelType = 6 ChannelTypeGuildNewsThread ChannelType = 10 ChannelTypeGuildPublicThread ChannelType = 11 ChannelTypeGuildPrivateThread ChannelType = 12 ChannelTypeGuildStageVoice ChannelType = 13 ) // https://discord.com/developers/docs/topics/permissions#role-object type Role struct { ID string `json:"id"` Name string `json:"name"` // more fields not yet present } func RoleFromMap(m interface{}, k string) *Role { mmap := maybeGetKey(m, k) if mmap == nil { return nil } r := &Role{ ID: mmap["id"].(string), Name: mmap["name"].(string), } return r } // https://discord.com/developers/docs/resources/channel#channel-object type Channel struct { ID string `json:"id"` Type ChannelType `json:"type"` GuildID string `json:"guild_id"` Name string `json:"name"` // More fields not yet present } func ChannelFromMap(m interface{}, k string) *Channel { mmap := maybeGetKey(m, k) if mmap == nil { return nil } c := &Channel{ ID: mmap["id"].(string), Type: ChannelType(mmap["type"].(float64)), GuildID: maybeString(mmap, "guild_id"), Name: maybeString(mmap, "name"), } return c } type MessageType int // https://discord.com/developers/docs/resources/channel#message-object-message-types const ( MessageTypeDefault MessageType = 0 MessageTypeRecipientAdd MessageType = 1 MessageTypeRecipientRemove MessageType = 2 MessageTypeCall MessageType = 3 MessageTypeChannelNameChange MessageType = 4 MessageTypeChannelIconChange MessageType = 5 MessageTypeChannelPinnedMessage MessageType = 6 MessageTypeGuildMemberJoin MessageType = 7 MessageTypeUserPremiumGuildSubscription MessageType = 8 MessageTypeUserPremiumGuildSubscriptionTier1 MessageType = 9 MessageTypeUserPremiumGuildSubscriptionTier2 MessageType = 10 MessageTypeUserPremiumGuildSubscriptionTier3 MessageType = 11 MessageTypeChannelFollowAdd MessageType = 12 MessageTypeGuildDiscoveryDisqualified MessageType = 14 MessageTypeGuildDiscoveryRequalified MessageType = 15 MessageTypeGuildDiscoveryGracePeriodInitialWarning MessageType = 16 MessageTypeGuildDiscoveryGracePeriodFinalWarning MessageType = 17 MessageTypeThreadCreated MessageType = 18 MessageTypeReply MessageType = 19 MessageTypeApplicationCommand MessageType = 20 MessageTypeThreadStarterMessage MessageType = 21 MessageTypeGuildInviteReminder MessageType = 22 ) // https://discord.com/developers/docs/resources/channel#message-object type Message struct { ID string `json:"id"` ChannelID string `json:"channel_id"` GuildID *string `json:"guild_id"` Content string `json:"content"` Author *User `json:"author"` // note that this may not be an actual valid user (see the docs) Timestamp string `json:"timestamp"` Type MessageType `json:"type"` Attachments []Attachment `json:"attachments"` Embeds []Embed `json:"embeds"` originalMap map[string]interface{} } func (m *Message) JumpURL() string { guildStr := "@me" if m.GuildID != nil { guildStr = *m.GuildID } return fmt.Sprintf("https://discord.com/channels/%s/%s/%s", guildStr, m.ChannelID, m.ID) } func (m *Message) Time() time.Time { t, err := time.Parse(time.RFC3339Nano, m.Timestamp) if err != nil { panic(err) } return t } func (m *Message) ShortString() string { return fmt.Sprintf("%s / %s: \"%s\" (%d attachments, %d embeds)", m.Timestamp, m.Author.Username, m.Content, len(m.Attachments), len(m.Embeds)) } func (m *Message) OriginalHasFields(fields ...string) bool { if m.originalMap == nil { // If we don't know, we assume the fields are there. // Usually this is because it came from their API, where we // always have all fields. return true } for _, field := range fields { _, ok := m.originalMap[field] if !ok { return false } } return true } func MessageFromMap(m interface{}, k string) *Message { /* Some gateway events, like MESSAGE_UPDATE, do not contain the entire message body. So we need to be defensive on all fields here, except the most basic identifying information. */ mmap := maybeGetKey(m, k) if mmap == nil { return nil } msg := Message{ ID: mmap["id"].(string), ChannelID: mmap["channel_id"].(string), GuildID: maybeStringP(mmap, "guild_id"), Content: maybeString(mmap, "content"), Author: UserFromMap(m, "author"), Timestamp: maybeString(mmap, "timestamp"), Type: MessageType(maybeInt(mmap, "type")), originalMap: mmap, } if iattachments, ok := mmap["attachments"]; ok { attachments := iattachments.([]interface{}) for _, iattachment := range attachments { msg.Attachments = append(msg.Attachments, *AttachmentFromMap(iattachment, "")) } } if iembeds, ok := mmap["embeds"]; ok { embeds := iembeds.([]interface{}) for _, iembed := range embeds { msg.Embeds = append(msg.Embeds, *EmbedFromMap(iembed)) } } return &msg } // https://discord.com/developers/docs/resources/user#user-object type User struct { ID string `json:"id"` Username string `json:"username"` Discriminator string `json:"discriminator"` Avatar *string `json:"avatar"` IsBot bool `json:"bot"` Locale string `json:"locale"` } func UserFromMap(m interface{}, k string) *User { mmap := maybeGetKey(m, k) if mmap == nil { return nil } u := User{ ID: mmap["id"].(string), Username: mmap["username"].(string), Discriminator: mmap["discriminator"].(string), } if isBot, ok := mmap["bot"]; ok { u.IsBot = isBot.(bool) } return &u } type Guild struct { ID string `json:"id"` // Who cares about the rest tbh } func GuildFromMap(m interface{}, k string) *Guild { mmap := maybeGetKey(m, k) if mmap == nil { return nil } g := Guild{ ID: mmap["id"].(string), } return &g } // https://discord.com/developers/docs/resources/guild#guild-member-object type GuildMember struct { User *User `json:"user"` Nick *string `json:"nick"` // more fields not yet handled here } func (gm *GuildMember) DisplayName() string { if gm.Nick != nil { return *gm.Nick } if gm.User != nil { return gm.User.Username } return "" } func GuildMemberFromMap(m interface{}, k string) *GuildMember { mmap := maybeGetKey(m, k) if mmap == nil { return nil } gm := &GuildMember{ User: UserFromMap(m, "user"), Nick: maybeStringP(mmap, "nick"), } return gm } // https://discord.com/developers/docs/resources/channel#attachment-object type Attachment struct { ID string `json:"id"` Filename string `json:"filename"` ContentType *string `json:"content_type"` Size int `json:"size"` Url string `json:"url"` ProxyUrl string `json:"proxy_url"` Height *int `json:"height"` Width *int `json:"width"` } func AttachmentFromMap(m interface{}, k string) *Attachment { mmap := maybeGetKey(m, k) if mmap == nil { return nil } a := Attachment{ ID: mmap["id"].(string), Filename: mmap["filename"].(string), ContentType: maybeStringP(mmap, "content_type"), Size: int(mmap["size"].(float64)), Url: mmap["url"].(string), ProxyUrl: mmap["proxy_url"].(string), Height: maybeIntP(mmap, "height"), Width: maybeIntP(mmap, "width"), } return &a } // https://discord.com/developers/docs/resources/channel#embed-object type Embed struct { Title *string `json:"title"` Type *string `json:"type"` Description *string `json:"description"` Url *string `json:"url"` Timestamp *string `json:"timestamp"` Color *int `json:"color"` Footer *EmbedFooter `json:"footer"` Image *EmbedImage `json:"image"` Thumbnail *EmbedThumbnail `json:"thumbnail"` Video *EmbedVideo `json:"video"` Provider *EmbedProvider `json:"provider"` Author *EmbedAuthor `json:"author"` Fields []EmbedField `json:"fields"` } type EmbedFooter struct { Text string `json:"text"` IconUrl *string `json:"icon_url"` ProxyIconUrl *string `json:"proxy_icon_url"` } type EmbedImageish struct { Url *string `json:"url"` ProxyUrl *string `json:"proxy_url"` Height *int `json:"height"` Width *int `json:"width"` } type EmbedImage struct { EmbedImageish } type EmbedThumbnail struct { EmbedImageish } type EmbedVideo struct { EmbedImageish } type EmbedProvider struct { Name *string `json:"name"` Url *string `json:"url"` } type EmbedAuthor struct { Name *string `json:"name"` Url *string `json:"url"` IconUrl *string `json:"icon_url"` ProxyIconUrl *string `json:"proxy_icon_url"` } type EmbedField struct { Name string `json:"name"` Value string `json:"value"` Inline *bool `json:"inline"` } func EmbedFromMap(m interface{}) *Embed { mmap := m.(map[string]interface{}) if mmap == nil { return nil } e := Embed{ Title: maybeStringP(mmap, "title"), Type: maybeStringP(mmap, "type"), Description: maybeStringP(mmap, "description"), Url: maybeStringP(mmap, "url"), Timestamp: maybeStringP(mmap, "timestamp"), Color: maybeIntP(mmap, "color"), Footer: EmbedFooterFromMap(mmap, "footer"), Image: EmbedImageFromMap(mmap, "image"), Thumbnail: EmbedThumbnailFromMap(mmap, "thumbnail"), Video: EmbedVideoFromMap(mmap, "video"), Provider: EmbedProviderFromMap(mmap, "provider"), Author: EmbedAuthorFromMap(mmap, "author"), Fields: EmbedFieldsFromMap(mmap, "fields"), } return &e } func EmbedFooterFromMap(m map[string]interface{}, k string) *EmbedFooter { f, ok := m[k] if !ok { return nil } fMap, ok := f.(map[string]interface{}) if !ok { return nil } return &EmbedFooter{ Text: maybeString(fMap, "text"), IconUrl: maybeStringP(fMap, "icon_url"), ProxyIconUrl: maybeStringP(fMap, "proxy_icon_url"), } } func EmbedImageFromMap(m map[string]interface{}, k string) *EmbedImage { val, ok := m[k] if !ok { return nil } valMap, ok := val.(map[string]interface{}) if !ok { return nil } return &EmbedImage{ EmbedImageish: EmbedImageish{ Url: maybeStringP(valMap, "url"), ProxyUrl: maybeStringP(valMap, "proxy_url"), Height: maybeIntP(valMap, "height"), Width: maybeIntP(valMap, "width"), }, } } func EmbedThumbnailFromMap(m map[string]interface{}, k string) *EmbedThumbnail { val, ok := m[k] if !ok { return nil } valMap, ok := val.(map[string]interface{}) if !ok { return nil } return &EmbedThumbnail{ EmbedImageish: EmbedImageish{ Url: maybeStringP(valMap, "url"), ProxyUrl: maybeStringP(valMap, "proxy_url"), Height: maybeIntP(valMap, "height"), Width: maybeIntP(valMap, "width"), }, } } func EmbedVideoFromMap(m map[string]interface{}, k string) *EmbedVideo { val, ok := m[k] if !ok { return nil } valMap, ok := val.(map[string]interface{}) if !ok { return nil } return &EmbedVideo{ EmbedImageish: EmbedImageish{ Url: maybeStringP(valMap, "url"), ProxyUrl: maybeStringP(valMap, "proxy_url"), Height: maybeIntP(valMap, "height"), Width: maybeIntP(valMap, "width"), }, } } func EmbedProviderFromMap(m map[string]interface{}, k string) *EmbedProvider { val, ok := m[k] if !ok { return nil } valMap, ok := val.(map[string]interface{}) if !ok { return nil } return &EmbedProvider{ Name: maybeStringP(valMap, "name"), Url: maybeStringP(valMap, "url"), } } func EmbedAuthorFromMap(m map[string]interface{}, k string) *EmbedAuthor { val, ok := m[k] if !ok { return nil } valMap, ok := val.(map[string]interface{}) if !ok { return nil } return &EmbedAuthor{ Name: maybeStringP(valMap, "name"), Url: maybeStringP(valMap, "url"), } } func EmbedFieldsFromMap(m map[string]interface{}, k string) []EmbedField { val, ok := m[k] if !ok { return nil } valSlice, ok := val.([]interface{}) if !ok { return nil } var result []EmbedField for _, innerVal := range valSlice { valMap, ok := innerVal.(map[string]interface{}) if !ok { continue } result = append(result, EmbedField{ Name: maybeString(valMap, "name"), Value: maybeString(valMap, "value"), Inline: maybeBoolP(valMap, "inline"), }) } return result } // Data is always present on application command and message component interaction types. It is optional for future-proofing against new interaction types. // // Member is sent when the interaction is invoked in a guild, and User is sent when invoked in a DM. // // See https://discord.com/developers/docs/interactions/receiving-and-responding#interaction-object-interaction-structure type Interaction struct { ID string `json:"id"` // id of the interaction ApplicationID string `json:"application_id"` // id of the application this interaction is for Type InteractionType `json:"type"` // the type of interaction Data *InteractionData `json:"data"` // the command data payload GuildID string `json:"guild_id"` // the guild it was sent from ChannelID string `json:"channel_id"` // the channel it was sent from Member *GuildMember `json:"member"` // guild member data for the invoking user, including permissions User *User `json:"user"` // user object for the invoking user, if invoked in a DM Token string `json:"token"` // a continuation token for responding to the interaction Version int `json:"version"` // read-only property, always 1 Message *Message `json:"message"` // for components, the message they were attached to } // https://discord.com/developers/docs/interactions/receiving-and-responding#interaction-object-interaction-type type InteractionType int const ( InteractionTypePing InteractionType = 1 InteractionTypeApplicationCommand InteractionType = 2 InteractionTypeMessageComponent InteractionType = 3 ) // See https://discord.com/developers/docs/interactions/receiving-and-responding#interaction-object-interaction-data-structure type InteractionData struct { // Fields for Application Commands // See https://discord.com/developers/docs/interactions/application-commands#application-command-object-application-command-structure ID string `json:"id"` // the ID of the invoked command Name string `json:"name"` // the name of the invoked command Type ApplicationCommandType `json:"type"` // the type of the invoked command Resolved *ResolvedData `json:"resolved"` // converted users + roles + channels Options []ApplicationCommandInteractionDataOption `json:"options"` // the params + values from the user // Fields for Components // TODO // Fields for User Command and Message Command TargetID string `json:"target_id"` // id the of user or message targetted by a user or message command } // See https://discord.com/developers/docs/interactions/receiving-and-responding#interaction-object-resolved-data-structure type ResolvedData struct { Users map[string]User `json:"users"` Members map[string]GuildMember `json:"members"` // Partial Member objects are missing user, deaf and mute fields. If data for a Member is included, data for its corresponding User will also be included. Roles map[string]Role `json:"roles"` Channels map[string]Channel `json:"channels"` // Partial Channel objects only have id, name, type and permissions fields. Threads will also have thread_metadata and parent_id fields. Messages map[string]Message `json:"messages"` } // See https://discord.com/developers/docs/interactions/receiving-and-responding#interaction-response-object-interaction-response-structure type InteractionResponse struct { Type InteractionCallbackType `json:"type"` // the type of response Data *InteractionCallbackData `json:"data"` // an optional response message } // See https://discord.com/developers/docs/interactions/receiving-and-responding#interaction-response-object-interaction-callback-type type InteractionCallbackType int const ( InteractionCallbackTypePong InteractionCallbackType = 1 // ACK a Ping InteractionCallbackTypeChannelMessageWithSource InteractionCallbackType = 4 // respond to an interaction with a message InteractionCallbackTypeDeferredChannelMessageWithSource InteractionCallbackType = 5 // ACK an interaction and edit a response later, the user sees a loading state InteractionCallbackTypeDeferredUpdateMessage InteractionCallbackType = 6 // for components, ACK an interaction and edit the original message later; the user does not see a loading state InteractionCallbackTypeUpdateMessage InteractionCallbackType = 7 // for components, edit the message the component was attached to ) type InteractionCallbackData struct { TTS bool `json:"bool,omitempty"` Content string `json:"content,omitempty"` Embeds []Embed `json:"embeds,omitempty"` // TODO: Allowed mentions Flags InteractionCallbackDataFlags `json:"flags,omitempty"` // TODO: Components } type InteractionCallbackDataFlags int const ( FlagEphemeral InteractionCallbackDataFlags = 1 << 6 ) type ApplicationCommandType int const ( ApplicationCommandTypeChatInput ApplicationCommandType = 1 // Slash commands; a text-based command that shows up when a user types `/` ApplicationCommandTypeUser ApplicationCommandType = 2 // A UI-based command that shows up when you right click or tap on a user ApplicationCommandTypeMessage ApplicationCommandOptionType = 3 // A UI-based command that shows up when you right click or tap on a message ) // Required `options` must be listed before optional options type ApplicationCommandOption struct { Type ApplicationCommandOptionType `json:"type"` // the type of option Name string `json:"name"` // 1-32 character name Description string `json:"description"` // 1-100 character description Required bool `json:"required"` // if the parameter is required or optional--default false Choices []ApplicationCommandOptionChoice `json:"choices"` // choices for STRING, INTEGER, and NUMBER types for the user to pick from, max 25 Options []ApplicationCommandOption `json:"options"` // if the option is a subcommand or subcommand group type, this nested options will be the parameters } type ApplicationCommandOptionType int const ( ApplicationCommandOptionTypeSubCommand ApplicationCommandOptionType = 1 ApplicationCommandOptionTypeSubCommandGroup ApplicationCommandOptionType = 2 ApplicationCommandOptionTypeString ApplicationCommandOptionType = 3 ApplicationCommandOptionTypeInteger ApplicationCommandOptionType = 4 // Any integer between -2^53 and 2^53 ApplicationCommandOptionTypeBoolean ApplicationCommandOptionType = 5 ApplicationCommandOptionTypeUser ApplicationCommandOptionType = 6 ApplicationCommandOptionTypeChannel ApplicationCommandOptionType = 7 // Includes all channel types + categories ApplicationCommandOptionTypeRole ApplicationCommandOptionType = 8 ApplicationCommandOptionTypeMentionable ApplicationCommandOptionType = 9 // Includes users and roles ApplicationCommandOptionTypeNumber ApplicationCommandOptionType = 10 // Any double between -2^53 and 2^53 ) // If you specify `choices` for an option, they are the only valid values for a user to pick type ApplicationCommandOptionChoice struct { Name string `json:"name"` // 1-100 character choice name Value interface{} `json:"value"` // value of the choice, up to 100 characters if string } // All options have names, and an option can either be a parameter and input // value--in which case Value will be set--or it can denote a subcommand or // group--in which case it will contain a top-level key and another array // of Options. // // Value and Options are mutually exclusive. type ApplicationCommandInteractionDataOption struct { Name string `json:"name"` Type ApplicationCommandOptionType `json:"type"` Value interface{} `json:"value"` // the value of the pair Options []ApplicationCommandInteractionDataOption `json:"options"` // present if this option is a group or subcommand } func InteractionFromMap(m interface{}, k string) *Interaction { mmap := maybeGetKey(m, k) if mmap == nil { return nil } i := &Interaction{ ID: mmap["id"].(string), ApplicationID: mmap["application_id"].(string), Type: InteractionType(mmap["type"].(float64)), Data: InteractionDataFromMap(m, "data"), GuildID: maybeString(mmap, "guild_id"), ChannelID: maybeString(mmap, "channel_id"), Member: GuildMemberFromMap(mmap, "member"), User: UserFromMap(mmap, "user"), Token: mmap["token"].(string), Version: int(mmap["version"].(float64)), Message: MessageFromMap(mmap, "message"), } return i } func InteractionDataFromMap(m interface{}, k string) *InteractionData { mmap := maybeGetKey(m, k) if mmap == nil { return nil } d := &InteractionData{ ID: mmap["id"].(string), Name: mmap["name"].(string), Type: ApplicationCommandType(mmap["type"].(float64)), Resolved: ResolvedDataFromMap(mmap, "resolved"), TargetID: maybeString(mmap, "target_id"), } if ioptions, ok := mmap["options"]; ok { options := ioptions.([]interface{}) for _, ioption := range options { d.Options = append(d.Options, *ApplicationCommandInteractionDataOptionFromMap(ioption, "")) } } return d } func ResolvedDataFromMap(m interface{}, k string) *ResolvedData { mmap := maybeGetKey(m, k) if mmap == nil { return nil } d := &ResolvedData{} if iusers, ok := mmap["users"]; ok { users := iusers.(map[string]interface{}) d.Users = make(map[string]User) for id, iuser := range users { d.Users[id] = *UserFromMap(iuser, "") } } if imembers, ok := mmap["members"]; ok { members := imembers.(map[string]interface{}) d.Members = make(map[string]GuildMember) for id, imember := range members { member := *GuildMemberFromMap(imember, "") user := d.Users[id] member.User = &user d.Members[id] = member } } if iroles, ok := mmap["roles"]; ok { roles := iroles.(map[string]interface{}) d.Roles = make(map[string]Role) for id, irole := range roles { d.Roles[id] = *RoleFromMap(irole, "") } } if ichannels, ok := mmap["channels"]; ok { channels := ichannels.(map[string]interface{}) d.Channels = make(map[string]Channel) for id, ichannel := range channels { d.Channels[id] = *ChannelFromMap(ichannel, "") } } if imessages, ok := mmap["messages"]; ok { messages := imessages.(map[string]interface{}) d.Messages = make(map[string]Message) for id, imessage := range messages { d.Messages[id] = *MessageFromMap(imessage, "") } } return d } func ApplicationCommandInteractionDataOptionFromMap(m interface{}, k string) *ApplicationCommandInteractionDataOption { mmap := maybeGetKey(m, k) if mmap == nil { return nil } o := &ApplicationCommandInteractionDataOption{ Name: mmap["name"].(string), Type: ApplicationCommandOptionType(mmap["type"].(float64)), Value: mmap["value"], } if ioptions, ok := mmap["options"]; ok { options := ioptions.([]interface{}) for _, ioption := range options { o.Options = append(o.Options, *ApplicationCommandInteractionDataOptionFromMap(ioption, "")) } } return o } // If called without a key, returns m. Otherwise, returns m[k]. // If m[k] does not exist, returns nil. // // The intent is to allow the ThingFromMap functions to be flexibly called, // either with the data in question as the root (no key) or as a child of // another object (with a key). func maybeGetKey(m interface{}, k string) map[string]interface{} { if k == "" { return m.(map[string]interface{}) } else { mmap := m.(map[string]interface{}) if mk, ok := mmap[k]; ok { return mk.(map[string]interface{}) } else { return nil } } } func maybeString(m map[string]interface{}, k string) string { val, ok := m[k] if !ok { return "" } return val.(string) } func maybeStringP(m map[string]interface{}, k string) *string { val, ok := m[k] if !ok || val == nil { return nil } strval := val.(string) return &strval } func maybeInt(m map[string]interface{}, k string) int { val, ok := m[k] if !ok { return 0 } return int(val.(float64)) } func maybeIntP(m map[string]interface{}, k string) *int { val, ok := m[k] if !ok || val == nil { return nil } intval := int(val.(float64)) return &intval } func maybeBool(m map[string]interface{}, k string) bool { val, ok := m[k] if !ok { return false } return val.(bool) } func maybeBoolP(m map[string]interface{}, k string) *bool { val, ok := m[k] if !ok || val == nil { return nil } boolval := val.(bool) return &boolval }