Slash commands

.gitignore

@@ -1,2 +1,5 @@
 # IDE-specific metadata
 .idea/
+
+# Environment variables. Useful for examples.
+.env

endpoints.go

@@ -120,6 +120,9 @@ var (
 	EndpointChannelWebhooks = func(cID string) string { return EndpointChannel(cID) + "/webhooks" }
 	EndpointWebhook         = func(wID string) string { return EndpointWebhooks + wID }
 	EndpointWebhookToken    = func(wID, token string) string { return EndpointWebhooks + wID + "/" + token }
+	EndpointWebhookMessage  = func(wID, token, messageID string) string {
+		return EndpointWebhookToken(wID, token) + "/" + "messages/" + messageID
+	}
 
 	EndpointMessageReactionsAll = func(cID, mID string) string {
 		return EndpointChannelMessage(cID, mID) + "/reactions"
@@ -131,6 +134,35 @@ var (
 		return EndpointMessageReactions(cID, mID, eID) + "/" + uID
 	}
 
+	EndpointApplicationGlobalCommands = func(aID string) string {
+		return EndpointApplication(aID) + "/" + "commands"
+	}
+	EndpointApplicationGlobalCommand = func(aID, cID string) string {
+		return EndpointApplicationGlobalCommands(aID) + "/" + cID
+	}
+
+	EndpointApplicationGuildCommands = func(aID, gID string) string {
+		return EndpointApplication(aID) + "/" + "guilds" + "/" + gID + "/" + "commands"
+	}
+	EndpointApplicationGuildCommand = func(aID, gID, cID string) string {
+		return EndpointApplicationGuildCommands(aID, gID) + "/" + cID
+	}
+	EndpointInteraction = func(aID, iToken string) string {
+		return EndpointAPI + "interactions/" + aID + "/" + iToken
+	}
+	EndpointInteractionResponse = func(iID, iToken string) string {
+		return EndpointInteraction(iID, iToken) + "/" + "callback"
+	}
+	EndpointInteractionResponseActions = func(aID, iToken string) string {
+		return EndpointWebhookMessage(aID, iToken, "@original")
+	}
+	EndpointFollowupMessage = func(aID, iToken string) string {
+		return EndpointWebhookToken(aID, iToken)
+	}
+	EndpointFollowupMessageActions = func(aID, iToken, mID string) string {
+		return EndpointWebhookMessage(aID, iToken, mID)
+	}
+
 	EndpointRelationships       = func() string { return EndpointUsers + "@me" + "/relationships" }
 	EndpointRelationship        = func(uID string) string { return EndpointRelationships() + "/" + uID }
 	EndpointRelationshipsMutual = func(uID string) string { return EndpointUsers + uID + "/relationships" }
@@ -144,9 +176,11 @@ var (
 	EndpointEmoji         = func(eID string) string { return EndpointCDN + "emojis/" + eID + ".png" }
 	EndpointEmojiAnimated = func(eID string) string { return EndpointCDN + "emojis/" + eID + ".gif" }
 
-	EndpointOauth2            = EndpointAPI + "oauth2/"
-	EndpointApplications      = EndpointOauth2 + "applications"
-	EndpointApplication       = func(aID string) string { return EndpointApplications + "/" + aID }
-	EndpointApplicationsBot   = func(aID string) string { return EndpointApplications + "/" + aID + "/bot" }
-	EndpointApplicationAssets = func(aID string) string { return EndpointApplications + "/" + aID + "/assets" }
+	EndpointOauth2                  = EndpointAPI + "oauth2/"
+	EndpointOauth2Applications      = EndpointOauth2 + "applications"
+	EndpointApplications            = EndpointAPI + "applications"
+	EndpointApplication             = func(aID string) string { return EndpointApplications + "/" + aID }
+	EndpointOauth2Application       = func(aID string) string { return EndpointOauth2Applications + "/" + aID }
+	EndpointOauth2ApplicationsBot   = func(aID string) string { return EndpointOauth2Applications + "/" + aID + "/bot" }
+	EndpointOauth2ApplicationAssets = func(aID string) string { return EndpointOauth2Applications + "/" + aID + "/assets" }
 )

events.go

@@ -268,3 +268,8 @@ type WebhooksUpdate struct {
 	GuildID   string `json:"guild_id"`
 	ChannelID string `json:"channel_id"`
 }
+
+// InteractionCreate is the data for a InteractionCreate event
+type InteractionCreate struct {
+	*Interaction
+}

examples/slash_commands/main.go

@@ -0,0 +1,120 @@
+package main
+
+import (
+	"flag"
+	dgo "github.com/bwmarrin/discordgo"
+	"log"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+)
+
+var (
+	botToken  = flag.String("bot_tok", "", "Bot token")
+	testGuild = flag.String("test_guild", "", "Guild for testing the bot")
+)
+
+func setup() *dgo.Session {
+	client, err := dgo.New("Bot " + *botToken)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	client.AddHandler(func(*dgo.Session, *dgo.Ready) {
+		log.Println("Bot is up!")
+	})
+
+	return client
+}
+
+func main() {
+	flag.Parse()
+
+	client := setup()
+
+	client.AddHandler(func(s *dgo.Session, i *dgo.InteractionCreate) {
+		log.Println(dgo.InteractionResponseType(i.Interaction.Data.Options[0].Value.(float64)))
+		err := s.InteractionRespond(i.Interaction, &dgo.InteractionResponse{
+			Type: dgo.InteractionResponseType(i.Interaction.Data.Options[0].Value.(float64)),
+			Data: &dgo.InteractionApplicationCommandResponseData{
+				TTS:     false,
+				Content: "here we go",
+				// Flags: 1 << 6,
+			},
+		})
+		log.Println("response", err)
+		time.Sleep(time.Second * 2)
+		err = s.InteractionResponseEdit(i.Interaction, &dgo.WebhookEdit{
+			Content: "here we go!",
+		})
+		log.Println("response edit", err)
+		time.Sleep(time.Second * 2)
+		err = s.InteractionResponseDelete(i.Interaction)
+		log.Println("response delete", err)
+		err = s.InteractionResponseDelete(i.Interaction)
+		log.Println("response delete 2", err)
+
+		followupMessage, err := s.FollowupMessageCreate(i.Interaction, true, &dgo.WebhookParams{
+			Content: "followup messages rule!",
+		})
+		log.Println("followup message create", followupMessage, err)
+		time.Sleep(time.Second * 3)
+		err = s.FollowupMessageEdit(i.Interaction, followupMessage.ID, &dgo.WebhookEdit{
+			Content: "that's true",
+		})
+		log.Println("followup message edit", err)
+		time.Sleep(time.Second * 3)
+		err = s.FollowupMessageDelete(i.Interaction, followupMessage.ID)
+		log.Println("followup message delete", err)
+	})
+
+	if err := client.Open(); err != nil {
+		log.Fatal(err)
+	}
+
+	cmd, err := client.ApplicationCommandCreate(&dgo.ApplicationCommand{
+		Name:        "test-slashes",
+		Description: "Command for testing application commands",
+		Options: []*dgo.ApplicationCommandOption{
+			{
+				Type:        dgo.ApplicationCommandOptionInteger,
+				Name:        "typ",
+				Description: "Response type",
+				Choices: []*dgo.ApplicationCommandOptionChoice{
+					{
+						Name:  "ACK",
+						Value: dgo.InteractionResponseAcknowledge,
+					},
+					{
+						Name:  "ACK with source",
+						Value: dgo.InteractionResponseACKWithSource,
+					},
+					{
+						Name:  "Channel message",
+						Value: dgo.InteractionResponseChannelMessage,
+					},
+					{
+						Name:  "Channel message with source",
+						Value: dgo.InteractionResponseChannelMessageWithSource,
+					},
+				},
+				Required: false,
+			},
+		},
+	}, *testGuild)
+
+	if err != nil {
+		panic(err)
+	}
+
+	log.Println("Old command: ", cmd)
+	log.Println("Created command: ", cmd)
+
+	ch := make(chan os.Signal, 1)
+	signal.Notify(ch, syscall.SIGINT, os.Interrupt)
+	<-ch
+	if err := client.Close(); err != nil {
+		log.Fatal(err)
+	}
+}

interaction.go

@@ -0,0 +1,127 @@
+package discordgo
+
+import (
+	"time"
+)
+
+const InteractionDeadline = time.Second * 3
+
+// ApplicationCommand is representing application's slash command.
+type ApplicationCommand struct {
+	ID            string                      `json:"id,omitempty"`
+	ApplicationID string                      `json:"application_id,omitempty"`
+	Name          string                      `json:"name,omitempty"`
+	Description   string                      `json:"description,omitempty"`
+	Options       []*ApplicationCommandOption `json:"options,omitempty"`
+}
+
+// ApplicationCommandOptionType is type of an slash-command's option.
+type ApplicationCommandOptionType uint8
+
+const (
+	_ = ApplicationCommandOptionType(iota)
+	// ApplicationCommandOptionSubCommand is a type of option for sub-commands.
+	ApplicationCommandOptionSubCommand
+	// ApplicationCommandOptionSubCommand is a type of option for sub-commands groups.
+	ApplicationCommandOptionSubCommandGroup
+	// ApplicationCommandOptionSubCommand is a type of option for string options.
+	ApplicationCommandOptionString
+	// ApplicationCommandOptionSubCommand is a type of option for integer options.
+	ApplicationCommandOptionInteger
+	// ApplicationCommandOptionSubCommand is a type of option for boolean options.
+	ApplicationCommandOptionBoolean
+	// ApplicationCommandOptionSubCommand is a type of option when user id/mention is needed.
+	ApplicationCommandOptionUser
+	// ApplicationCommandOptionSubCommand is a type of option when channel id/mention is needed.
+	ApplicationCommandOptionChannel
+	// ApplicationCommandOptionSubCommand is a type of option when role id/mention is needed.
+	ApplicationCommandOptionRole
+)
+
+// ApplicationCommandOption is representing an option/subcommand/subcommands group.
+type ApplicationCommandOption struct {
+	Type        ApplicationCommandOptionType      `json:"type,omitempty"`
+	Name        string                            `json:"name,omitempty"`
+	Description string                            `json:"description,omitempty"`
+	Default     bool                              `json:"default,omitempty"`
+	Required    bool                              `json:"required,omitempty"`
+	Choices     []*ApplicationCommandOptionChoice `json:"choices,omitempty"`
+	Options     []*ApplicationCommandOption       `json:"options,omitempty"`
+}
+
+// ApplicationCommandOption is representing slash-command's option choice.
+type ApplicationCommandOptionChoice struct {
+	Name  string      `json:"name,omitempty"`
+	Value interface{} `json:"value,omitempty"`
+}
+
+// InteractionType is representing interaction type.
+type InteractionType uint8
+
+const (
+	_ = InteractionType(iota)
+	// InteractionPing is type of interaction for ping.
+	InteractionPing
+	// InteractionApplicationCommand is type of interaction for application commands.
+	InteractionApplicationCommand
+)
+
+// Interaction is representing interaction with application.
+type Interaction struct {
+	ID        string                            `json:"id,omitempty"`
+	Type      InteractionType                   `json:"type,omitempty"`
+	Data      ApplicationCommandInteractionData `json:"data,omitempty"`
+	GuildID   string                            `json:"guild_id,omitempty"`
+	ChannelID string                            `json:"channel_id,omitempty"`
+	Member    *Member                           `json:"member,omitempty"`
+	Token     string                            `json:"token,omitempty"`
+	Version   int                               `json:"version,omitempty"`
+}
+
+// ApplicationCommandInteractionData is representing interaction data for application command
+type ApplicationCommandInteractionData struct {
+	ID      string
+	Name    string
+	Options []*ApplicationCommandInteractionDataOption
+}
+
+// ApplicationCommandInteractionDataOption is representing an option of application's command
+type ApplicationCommandInteractionDataOption struct {
+	Name string `json:"name,omitempty"`
+	// Contains the value specified by InteractionType
+	Value   interface{}                                `json:"value,omitempty"`
+	Options []*ApplicationCommandInteractionDataOption `json:"options,omitempty"`
+}
+
+// InteractionResponseType is type of interaction response
+type InteractionResponseType uint8
+
+const (
+	_ = InteractionResponseType(iota)
+	// InteractionResponsePong is an interaction response type when you need to just ACK a "Ping".
+	InteractionResponsePong
+	// InteractionResponsePong is an interaction response type when you need to ACK a command without sending a message, eating the user's input.
+	InteractionResponseAcknowledge
+	// InteractionResponsePong is an interaction response type when you need to respond with a message, eating the user's input.
+	InteractionResponseChannelMessage
+	// InteractionResponsePong is an interaction response type when you need to respond with a message, showing the user's input.
+	InteractionResponseChannelMessageWithSource
+	// InteractionResponsePong is an interaction response type when you need to ACK a command without sending a message, showing the user's input.
+	InteractionResponseACKWithSource
+)
+
+// InteractionResponse is representing response for interaction with application
+type InteractionResponse struct {
+	Type InteractionResponseType                    `json:"type,omitempty"`
+	Data *InteractionApplicationCommandResponseData `json:"data,omitempty"`
+}
+
+// InteractionApplicationCommandCallbackData is callback data for application command interaction
+type InteractionApplicationCommandResponseData struct {
+	TTS             bool                    `json:"tts,omitempty"`
+	Content         string                  `json:"content,omitempty"`
+	Embeds          []*MessageEmbed         `json:"embeds,omitempty"`
+	AllowedMentions *MessageAllowedMentions `json:"allowed_mentions,omitempty"`
+
+	Flags uint64 `json:"flags,omitempty"`
+}