Confessions module

This commit adds a confessions feature that allows users to mark a
"confessional" channel and also to post anonymously to it. The changes
that this comprises of are as follows:

- New discord "slash" commands for both marking a confessional and
  posting to it
- a bunch of stuff in the discord module to register and deregister
  "slash" commands
- New event type to track marked confessionals
- confession module that processes new confession channel links
  and also posts confessions to corresponding confessionals

Not included in this commit:
- a way to cleanup obsolete or reconfigured confession channel links
- access control for the confessional slash commands

Signed-off-by: Ava Affine <ava@sunnypup.io>

internal/discord/commands.go

@@ -0,0 +1,112 @@
+package discord
+
+import (
+	"time"
+
+	"github.com/bwmarrin/discordgo"
+
+	"gitlab.com/whom/bingobot/internal/confession"
+	"gitlab.com/whom/bingobot/internal/logging"
+	"gitlab.com/whom/bingobot/internal/state"
+)
+
+var (
+	// map of guildID to registeredCommands
+	registeredCommands map[string][]*discordgo.ApplicationCommand
+
+	// all commands
+	commandList = []*discordgo.ApplicationCommand{
+		// TODO: Limit usage somehow?
+		// maybe delete this and use the vote module instead
+		&discordgo.ApplicationCommand{
+			Name: "confessional",
+			Description: "mark a channel as a designated confessional for a guild",
+		},
+
+		&discordgo.ApplicationCommand{
+			Name: "confess",
+			Description: "anonymously post a confession in configured channel",
+			Options: []*discordgo.ApplicationCommandOption{
+				&discordgo.ApplicationCommandOption{
+					Name: "confession",
+					Description: "A confession to be posted anonymously",
+					Required: true,
+				},
+			},
+		},
+	}
+
+	commandHandlers = map[string]func(
+		s *discordgo.Session, 
+		i *discordgo.InteractionCreate,
+	) {
+		"confessional": func(s *discordgo.Session, i *discordgo.InteractionCreate) {
+			state.PublishEvent(state.ConfessionsChannelLinkEvent{
+				GuildID: i.GuildID,
+				ChannelID: i.ChannelID,
+				Created: time.Now(),
+			})
+		},
+
+		// handle a confession
+		"confess": func(s *discordgo.Session, i *discordgo.InteractionCreate) {
+			for _, v := range i.ApplicationCommandData().Options {
+				if v.Name == "confession" {
+					confession.MakeConfession(s, i.GuildID, v.StringValue())
+				}
+			}
+		},
+	}
+)
+
+func handleCommand(s *discordgo.Session, e *discordgo.InteractionCreate) {
+	name := e.ApplicationCommandData().Name
+	// TODO: audit log
+	if h, ok := commandHandlers[name]; ok {
+		h(s, e)
+	} else {
+		logging.Debug("no handler for command: %s", name)
+	}
+}
+
+func registerCommands(s *discordgo.Session) {
+	for _, guild := range s.State.Guilds {
+		cmds, err := s.ApplicationCommandBulkOverwrite(
+			s.State.Application.ID,
+			guild.ID,
+			commandList,
+		)
+
+		if err != nil {
+			logging.Error(
+				"Failed to register commands for guild %s: %s",
+				guild.ID, err.Error(),
+			)
+		} else {
+			logging.Info("Registered commands for guild %s", guild.ID)
+			registeredCommands[guild.ID] = cmds
+		}
+	}
+}
+
+func deregisterCommands(s *discordgo.Session) {
+	for guild, commands := range registeredCommands {
+		for _, cmd := range commands {
+			if err := s.ApplicationCommandDelete(
+				s.State.Application.ID,
+				guild,
+				cmd.ID,
+			); err != nil {
+				logging.Error(
+					"Failed to delete %s command (id: %s) from guild %s",
+					cmd.Name, cmd.ID, guild,
+				)
+			} else {
+				logging.Info(
+					"Deregistered command %s (id: %s) from guild %s",
+					cmd.Name, cmd.ID, guild,
+				)
+			}
+		}
+	}
+}

internal/discord/discord.go

@@ -36,10 +36,13 @@ func Connect(token string) error {
 		return fmt.Errorf("failed to open discord session: %s", err)
 	}
 
+	registerCommands(session.s)
+
 	return nil
 }
 
 func Close() {
+	deregisterCommands(session.s)
 	err := session.s.Close()
 
 	if err != nil {

internal/discord/handlers.go

@@ -9,6 +9,7 @@ func addHandlers() {
 	session.s.AddHandler(handleConnect)
 	session.s.AddHandler(handleDisconnect)
 	session.s.AddHandler(handleVoiceStateUpdate)
+	session.s.AddHandler(handleCommand) // handles InteractionCreate
 }
 
 func handleConnect(s *discordgo.Session, e *discordgo.Connect) {