pushing code for channel lockdowns

- honestly not sure if its worth adding

bolt.go

@@ -14,7 +14,9 @@ import (
 )
 
 const (
-	TOKEN_ENV_VAR = "DISCORD_TOKEN" //label for token environment variable
+	//Discord auth token must be saved as an environment variable using this label/name
+	//in order for bolt to detect it
+	TOKEN_ENV_VAR = "DISCORD_TOKEN"
 
 	BOT_INTENTS = dg.IntentGuilds |
 		dg.IntentGuildMembers |
@@ -24,12 +26,12 @@ const (
 		dg.IntentGuildMessageReactions
 )
 
-// basic bot structure containing discordgo connection as well as the command map
 type bolt struct {
 	*dg.Session                    //holds discordgo internals
 	commands    map[string]Command //maps trigger phrase to command struct for fast lookup
 	indicator   string             //the indicator used to detect whether a message is a command
 	logLvl      LogLevel           //determines how much the bot logs
+	channels    []string           //optional list of channels that the bot listens in, all channels are used if list is empty
 }
 
 type Bolt interface {
@@ -38,14 +40,14 @@ type Bolt interface {
 	//filtered methods
 	stop() error
 	messageHandler(s *dg.Session, msg *dg.MessageCreate)
-	handleCommand(msgEvent *MessageCreateEvent, s *dg.Session, lg int) error
+	handleCommand(msg *dg.MessageCreate, s *dg.Session, server *dg.Guild, channel *dg.Channel, lg int) error
 	createReply(content, message, channel, guild string) *dg.MessageSend
 	getRemainingTimeout(timeout time.Time) string
-	roleCheck(guild string, roles []string, s *dg.Session, run Command) (bool, error)
-	timeoutCheck(msgID, channelID, guildID string, s *dg.Session, run Command) (bool, error)
+	roleCheck(msg *dg.MessageCreate, s *dg.Session, run Command) (bool, error)
+	timeoutCheck(msg *dg.MessageCreate, s *dg.Session, run Command) (bool, error)
 }
 
-// create a new bolt interface
+// creates and returns a new bolt interface after ensuring token is present and applying option functions
 func New(opts ...Option) (Bolt, error) {
 	_, check := os.LookupEnv(TOKEN_ENV_VAR)
 	if !check {
@@ -66,7 +68,7 @@ func New(opts ...Option) (Bolt, error) {
 	//set default command indicator
 	b.indicator = "."
 
-	//apply options
+	//apply options to bolt
 	for _, opt := range opts {
 		opt(b)
 	}
@@ -74,10 +76,10 @@ func New(opts ...Option) (Bolt, error) {
 	return b, nil
 }
 
-// starts the bot, commands are added and the connection to Discord is opened, this is a BLOCKING call
-// that handles safe shutdown of the bot
+// starts the bot, commands are added and the connection to Discord is opened, this is a BLOCKING
+// call that handles safe shutdown
 func (b *bolt) Start() error {
-	//register commands and open connection
+	//registers the message handler used internally to detect commands
 	b.AddHandler(b.messageHandler)
 
 	err := b.Open()
@@ -104,26 +106,43 @@ func (b *bolt) stop() error {
 
 // adds commands to bot command map for use
 func (b *bolt) AddCommands(cmd ...Command) {
+	//command trigger words are mapped directly to payload functions to prevent
+	//extra loops when searching for the appropriate payload
 	for _, c := range cmd {
 		b.commands[c.Trigger] = c
 	}
 }
 
-// handler function that parses message data, handles logging the message based on logLevel, and executes
-// the payload function in a goroutine
+// internal message handler function. Ensure's the message is a message the bot should interpret
+// and checks to see if it contains a command then executes the proper payload function
 func (b *bolt) messageHandler(s *dg.Session, msg *dg.MessageCreate) {
-	//get server information
-	server, err := s.Guild(msg.GuildID)
-	if err != nil {
-		log.Printf("failed to get guild: %e\n", err)
-		return
-	}
+	//get channel name to, idk if i like this
 	channel, err := s.Channel(msg.ChannelID)
 	if err != nil {
 		log.Printf("failed to get channel from guild: %e\n", err)
 		return
 	}
 
+	if len(b.channels) > 0 {
+		var check bool
+		for _, c := range b.channels {
+			if channel.Name == c {
+				check = true
+			}
+		}
+
+		//not a channel we care about
+		if !check {
+			return
+		}
+	}
+
+	server, err := s.Guild(msg.GuildID)
+	if err != nil {
+		log.Printf("failed to get guild: %e\n", err)
+		return
+	}
+
 	//if there is no content it is likely an image, gif, or sticker, updating message content for
 	//better logging and to avoid confusion
 	if len(msg.Content) == 0 {
@@ -132,7 +151,7 @@ func (b *bolt) messageHandler(s *dg.Session, msg *dg.MessageCreate) {
 
 	//the bot will ignore it's own messages to prevent command loops
 	if msg.Author.ID == s.State.User.ID {
-		if b.logLvl == LogLevelCmd || b.logLvl == LogLevelAll {
+		if b.logLvl == LogLevelCmd {
 			//log command responses
 			log.Printf("< %s | %s | %s > %s\n", server.Name, channel.Name, msg.Author.Username, msg.Content)
 		}
@@ -147,42 +166,29 @@ func (b *bolt) messageHandler(s *dg.Session, msg *dg.MessageCreate) {
 	//does the message have the command indicator
 	lg := len(b.indicator)
 	if msg.Content[:lg] == b.indicator {
-		mCreate := &MessageCreateEvent{
-			AuthorUsername: msg.Author.Username,
-			AuthorID:       msg.Author.ID,
-			AuthorRoles:    msg.Member.Roles,
-			MsgID:          msg.ID,
-			Msg:            msg.Content,
-			MsgChanID:      msg.ChannelID,
-			MsgGuildID:     msg.GuildID,
-			MsgAttachments: msg.Attachments,
+		err := b.handleCommand(msg, s, server, channel, lg)
+		if err != nil {
+			log.Println(err)
+			return
 		}
-
-		if b.logLvl == LogLevelCmd {
-			//log commands
-			log.Printf("< %s | %s | %s > %s\n", mCreate.MsgGuildName, mCreate.MsgChanName, mCreate.AuthorUsername, mCreate.Msg)
-		}
-
-		//handled in its own goroutine to allow for async commands
-		go func() {
-			err := b.handleCommand(mCreate, s, lg)
-			if err != nil {
-				log.Println(err)
-			}
-		}()
 	}
 }
 
 // parses command from message and handles timeout checks, role checks, and command execution. All command responses are sent back to Discord
-func (b *bolt) handleCommand(msgEvent *MessageCreateEvent, s *dg.Session, lg int) error {
-	words := strings.Split(msgEvent.Msg, " ")
+func (b *bolt) handleCommand(msg *dg.MessageCreate, s *dg.Session, server *dg.Guild, channel *dg.Channel, lg int) error {
+	if b.logLvl == LogLevelCmd {
+		//log commands
+		log.Printf("< %s | %s | %s > %s\n", server.Name, channel.Name, msg.Author.Username, msg.Content)
+	}
+
+	words := strings.Split(msg.Content, " ")
 	run, ok := b.commands[words[0][lg:]]
 	if !ok {
 		return nil //command doesn't exist, maybe log or respond to author
 	}
 
 	//has command met its timeout requirements
-	tc, err := b.timeoutCheck(msgEvent.MsgID, msgEvent.MsgChanID, msgEvent.MsgGuildID, s, run)
+	tc, err := b.timeoutCheck(msg, s, run)
 	if err != nil {
 		return fmt.Errorf("failed to calculate timeout for %s\n%e", run.Trigger, err)
 	}
@@ -192,38 +198,32 @@ func (b *bolt) handleCommand(msgEvent *MessageCreateEvent, s *dg.Session, lg int
 
 	//does user have correct permissions
 	if run.Roles != nil {
-		check, err := b.roleCheck(msgEvent.MsgGuildID, msgEvent.AuthorRoles, s, run)
+		check, err := b.roleCheck(msg, s, run)
 		if err != nil {
 			return fmt.Errorf("failed to perform permission checks for %s\n%e", run.Trigger, err)
 		}
 		if !check {
-			reply := b.createReply("you do not have permissions to run that command", msgEvent.MsgID, msgEvent.MsgChanID, msgEvent.MsgGuildID)
-			_, err := s.ChannelMessageSendComplex(msgEvent.MsgChanID, reply)
-			if err != nil {
-				return err
-			}
 			return nil
 		}
 	}
 
-	//populate message struct exposed to client
 	plMsg := Message{
-		Author:    msgEvent.AuthorUsername,
-		ID:        msgEvent.AuthorID,
-		msgID:     msgEvent.MsgID,
+		Author:    msg.Author.Username,
+		ID:        msg.Author.ID,
+		msgID:     msg.ID,
 		Words:     words,
-		Content:   msgEvent.Msg,
-		Channel:   msgEvent.MsgChanName,
-		channelID: msgEvent.MsgChanID,
-		Server:    msgEvent.MsgGuildName,
-		serverID:  msgEvent.MsgGuildID,
+		Content:   msg.Content,
+		Channel:   channel.Name,
+		channelID: msg.ChannelID,
+		Server:    server.Name,
+		serverID:  server.ID,
 		sesh:      b,
 	}
 
 	//check for file attachments
-	if len(msgEvent.MsgAttachments) > 0 {
+	if len(msg.Attachments) > 0 {
 		var att []MessageAttachment
-		for _, a := range msgEvent.MsgAttachments {
+		for _, a := range msg.Attachments {
 			att = append(att, MessageAttachment{
 				ID:           a.ID,
 				URL:          a.URL,
@@ -288,15 +288,15 @@ func (b *bolt) getRemainingTimeout(timeout time.Time) string {
 }
 
 // checks if the author of msg has the correct role to run the requested command
-func (b *bolt) roleCheck(guild string, roles []string, s *dg.Session, run Command) (bool, error) {
+func (b *bolt) roleCheck(msg *dg.MessageCreate, s *dg.Session, run Command) (bool, error) {
 	var found bool
 	//loop thru author roles, there may be a better way to check for this UNION
 	//TODO: improve role search performance to support bigger lists
-	for _, r := range roles {
+	for _, r := range msg.Member.Roles {
 		//get role name from ID
-		n, err := s.State.Role(guild, r)
+		n, err := s.State.Role(msg.GuildID, r)
 		if err != nil {
-			return false, fmt.Errorf("failed to get role from ID %s\n%e", guild, err)
+			return false, fmt.Errorf("failed to get role from ID %s\n%e", msg.GuildID, err)
 		}
 		//does this role exist in command roles
 		check := slices.Contains(run.Roles, n.Name)
@@ -306,8 +306,13 @@ func (b *bolt) roleCheck(guild string, roles []string, s *dg.Session, run Comman
 		}
 	}
 
-	//can't find role, don't run command
+	//can't find role, don't run command, alert user of missing permissions
 	if !found {
+		reply := b.createReply("you do not have permissions to run that command", msg.ID, msg.ChannelID, msg.GuildID)
+		_, err := s.ChannelMessageSendComplex(msg.ChannelID, reply)
+		if err != nil {
+			return false, fmt.Errorf("failed to send permission response: %e", err)
+		}
 		return false, nil
 	}
 
@@ -315,11 +320,11 @@ func (b *bolt) roleCheck(guild string, roles []string, s *dg.Session, run Comman
 }
 
 // check if the command timeout has been met, responding with remaining time if timeout has not been met yet.
-func (b *bolt) timeoutCheck(msgID, channelID, guildID string, s *dg.Session, run Command) (bool, error) {
+func (b *bolt) timeoutCheck(msg *dg.MessageCreate, s *dg.Session, run Command) (bool, error) {
 	wait := run.lastRun.Add(run.Timeout)
 	if !time.Now().After(wait) {
-		reply := b.createReply(fmt.Sprintf("that command cannot be run for another %s", b.getRemainingTimeout(wait)), msgID, channelID, guildID)
-		_, err := s.ChannelMessageSendComplex(channelID, reply)
+		reply := b.createReply(fmt.Sprintf("that command cannot be run for another %s", b.getRemainingTimeout(wait)), msg.ID, msg.ChannelID, msg.GuildID)
+		_, err := s.ChannelMessageSendComplex(msg.ChannelID, reply)
 		if err != nil {
 			return false, fmt.Errorf("failed to send timeout response: %e", err)
 		}

message.go

@@ -1,15 +1,11 @@
 package bolt
 
-import (
-	"fmt"
+import "fmt"
 
-	dg "github.com/bwmarrin/discordgo"
-)
-
-// built-in Discord reactions
+//built-in Discord reactions
 type Reaction string
 
-// a few easy-to-use emojis, Discordgo/Discord API requires them to be saved like this.
+//a few easy-to-use emojis, Discordgo/Discord API requires them to be saved like this.
 const (
 	ReactionThumbsUp          Reaction = "👍"
 	ReactionThumbsDown        Reaction = "👎"
@@ -41,22 +37,10 @@ const (
 	ReactionSpeakingHead      Reaction = "🗣️"
 	ReactionGreenCheck        Reaction = "✅"
 	ReactionDragon            Reaction = "🐉"
+	ReactionLizard            Reaction = "🦎"
+	ReactionTakeAKnee         Reaction = "🧎‍♂️‍➡️"
 )
 
-// struct containing message event fields to prevent passing MessageCreate events and holding up routines
-type MessageCreateEvent struct {
-	AuthorUsername string
-	AuthorID       string
-	AuthorRoles    []string
-	MsgID          string
-	Msg            string
-	MsgChanID      string
-	MsgChanName    string
-	MsgGuildID     string
-	MsgGuildName   string
-	MsgAttachments []*dg.MessageAttachment
-}
-
 // information about attachments to messages
 type MessageAttachment struct {
 	ID           string

option.go

@@ -23,3 +23,10 @@ func WithLogLevel(lvl LogLevel) Option {
 		b.logLvl = lvl
 	}
 }
+
+// restrict the channels the bot listens in and responds to, must be a list of channel names
+func WithListenChannels(channels []string) Option {
+	return func(b *bolt) {
+		b.channels = channels
+	}
+}