Merge pull request #84 from osbytes/poll-command

Poll command

Author: adavila0703

internal/devy/bot.go

@@ -2,12 +2,18 @@ package devy
 
 import (
 	"bot/internal/github"
+	"bot/pkg/unicode"
 	"context"
+	"fmt"
 
 	"github.com/bwmarrin/discordgo"
 	"github.com/pkg/errors"
 )
 
+var (
+	pollPrefix = fmt.Sprintf("%s **POLL**", unicode.Emojis[":memo:"])
+)
+
 type Bot struct {
 	discord       *discordgo.Session
 	githubService github.GithubServicer
@@ -30,6 +36,8 @@ func (b Bot) Start(ctx context.Context) error {
 
 	b.discord.AddHandler(b.messageCreate)
 
+	b.discord.AddHandler(b.messageReactionAdd)
+
 	select {
 	case <-ctx.Done():
 		return ctx.Err()

internal/devy/commands.go

@@ -3,6 +3,8 @@ package devy
 import (
 	"bot/pkg/env"
 	"bot/pkg/infra"
+	"bot/pkg/strs"
+	"bot/pkg/unicode"
 	"context"
 	"fmt"
 	"strings"
@@ -16,6 +18,9 @@ var (
 	channelMessageSendF    = channelMessageSend
 	guildMemberRoleRemoveF = guildMemberRoleRemove
 	guildMemberRoleAddF    = guildMemberRoleAdd
+	messageReactionAddF    = messageReactionAdd
+	messageReactionRemoveF = messageReactionRemove
+	channelMessageF        = channelMessage
 )
 
 func channelFromState(s *discordgo.State, channelID string) (*discordgo.Channel, error) {
@@ -34,6 +39,18 @@ func guildMemberRoleRemove(s *discordgo.Session, guildID, userID, roleID string)
 	return s.GuildMemberRoleRemove(guildID, userID, roleID)
 }
 
+func messageReactionAdd(s *discordgo.Session, channelID, messageID, emojiID string) error {
+	return s.MessageReactionAdd(channelID, messageID, emojiID)
+}
+
+func messageReactionRemove(s *discordgo.Session, channelID, messageID, emojiID, userID string) error {
+	return s.MessageReactionRemove(channelID, messageID, emojiID, userID)
+}
+
+func channelMessage(s *discordgo.Session, channelID, messageID string) (*discordgo.Message, error) {
+	return s.ChannelMessage(channelID, messageID)
+}
+
 type CommandHandler func(session *discordgo.Session, message *discordgo.MessageCreate, channel *discordgo.Channel, bot *Bot)
 
 type Command struct {
@@ -95,6 +112,12 @@ var commandMap = map[string]Command{
 		Args:        []string{},
 		Handler:     devyDeveloperCommandHandler,
 	},
+	"!poll": {
+		Name:        "!poll",
+		Description: "creates a poll in the poll channel if specified on devy or the current channel. question and options must be wrapped with double quotes (\"question...\" \"option 1\" \"option 2\")",
+		Args:        []string{"question", "option", "option..."},
+		Handler:     pollCommandHandler,
+	},
 }
 
 func streakCurrentCommandHandler(session *discordgo.Session, message *discordgo.MessageCreate, channel *discordgo.Channel, bot *Bot) {
@@ -266,3 +289,48 @@ func devyDeveloperCommandHandler(session *discordgo.Session, message *discordgo.
 
 	_, _ = channelMessageSendF(session, channel.ID, fmt.Sprintf("%s devy developer role for user %s", action, message.Author.Username))
 }
+
+func pollCommandHandler(session *discordgo.Session, message *discordgo.MessageCreate, channel *discordgo.Channel, bot *Bot) {
+	pollChannelID := env.GetString("DISCORD_POLL_CHANNEL_ID", "")
+	if len(pollChannelID) == 0 {
+		pollChannelID = message.ChannelID
+	}
+
+	arguments := strs.AllBetweenPattern(message.Content, "\"")
+	if len(arguments) <= 2 {
+		_, _ = channelMessageSendF(session, channel.ID, "polls must have more than one option")
+
+		return
+	}
+
+	question := arguments[0]
+	options := arguments[1:]
+
+	emojis := []string{}
+	for _, e := range unicode.Emojis {
+		emojis = append(emojis, e)
+		if len(emojis) == len(options) {
+			break
+		}
+	}
+
+	pollMessageStr := fmt.Sprintf("%s\n\n", question)
+
+	for i, e := range emojis {
+		pollMessageStr += fmt.Sprintf("\t%s\t%s\n", e, options[i])
+	}
+
+	msg, err := channelMessageSendF(session, pollChannelID, fmt.Sprintf("%s\n\n%s", pollPrefix, pollMessageStr))
+	if err != nil {
+		infra.Logger.Error().Err(err).Msg("channel message send")
+
+		_, _ = channelMessageSendF(session, pollChannelID, "something went wrong creating poll")
+
+		return
+	}
+
+	for _, emj := range emojis {
+		_ = messageReactionAddF(session, pollChannelID, msg.ID, emj)
+	}
+
+}

internal/devy/handlers.go

@@ -1,6 +1,7 @@
 package devy
 
 import (
+	"bot/pkg/infra"
 	"strings"
 
 	"github.com/bwmarrin/discordgo"
@@ -64,3 +65,39 @@ func (b *Bot) messageCreate(session *discordgo.Session, message *discordgo.Messa
 	command.Handler(session, message, channel, b)
 
 }
+
+func (b *Bot) messageReactionAdd(session *discordgo.Session, message *discordgo.MessageReactionAdd) {
+	// Ignore all messages created by the bot itself
+	// This isn't required in this specific example but it's a good practice.
+	if message.UserID == session.State.User.ID {
+		return
+	}
+
+	msg, err := channelMessageF(session, message.ChannelID, message.MessageID)
+	if err != nil {
+		infra.Logger.Error().Err(err).Msg("get channel message")
+
+		return
+	}
+
+	if !strings.HasPrefix(msg.Content, pollPrefix) {
+		return
+	}
+
+	// remove emoji if not one of poll emojis
+	// TODO: need a better way to determine if the reaction emoji is one of the poll emojis. This code does not consider that the question itself may contain an emoji and that emoji would be allowed to be used in the reactions
+	if !strings.Contains(msg.Content, message.Emoji.Name) {
+		_ = messageReactionRemoveF(session, message.ChannelID, message.MessageID, message.Emoji.Name, message.UserID)
+
+		return
+	}
+
+	for _, reaction := range msg.Reactions {
+		if reaction.Emoji.Name == message.MessageReaction.Emoji.Name {
+			continue
+		}
+
+		_ = messageReactionRemoveF(session, message.ChannelID, message.MessageID, reaction.Emoji.Name, message.UserID)
+	}
+
+}

pkg/strs/strings.go

@@ -0,0 +1,39 @@
+package strs
+
+// TODO: there is probably a simplification in the logic in this method AllBetweenPattern. We unfortunately can't use a regular expression since go does not support before text matching (?=re) https://github.com/google/re2/wiki/Syntax https://github.com/google/re2/wiki/WhyRE2
+func AllBetweenPattern(str, pattern string) []string {
+	stringsMatched := []string{}
+
+	matchingPatternIdx := 0
+	patternMatched := false
+
+	currentMatch := ""
+
+	for _, char := range str {
+		if byte(char) == pattern[matchingPatternIdx] {
+			matchingPatternIdx++
+
+			if !patternMatched && matchingPatternIdx == len(pattern) {
+				patternMatched = true
+				matchingPatternIdx = 0
+				continue
+			}
+		}
+
+		if patternMatched {
+			currentMatch += string(char)
+
+			if matchingPatternIdx == len(pattern) {
+				patternMatched = false
+				matchingPatternIdx = 0
+
+				matchedStr := currentMatch[:len(currentMatch)-len(pattern)]
+				stringsMatched = append(stringsMatched, matchedStr)
+				currentMatch = ""
+			}
+		}
+
+	}
+
+	return stringsMatched
+}

pkg/strs/strings_test.go

@@ -0,0 +1,59 @@
+package strs
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestAllBetweenPattern(t *testing.T) {
+	type args struct {
+		s       string
+		pattern string
+	}
+	tests := []struct {
+		name string
+		args args
+		want []string
+	}{
+		{
+			name: "no match",
+			args: args{
+				s:       "abcsome text to extractabc",
+				pattern: "abcd",
+			},
+			want: []string{},
+		},
+		{
+			name: "empty string between pattern",
+			args: args{
+				s:       "abcabcabc",
+				pattern: "abc",
+			},
+			want: []string{""},
+		},
+		{
+			name: "multi string pattern single match",
+			args: args{
+				s:       "abcsome text to extractabc",
+				pattern: "abc",
+			},
+			want: []string{"some text to extract"},
+		},
+		{
+			name: "multi string pattern multi match",
+			args: args{
+				s:       "abcsome text to extractabcabcsome other textabc",
+				pattern: "abc",
+			},
+			want: []string{"some text to extract", "some other text"},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := AllBetweenPattern(tt.args.s, tt.args.pattern)
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("AllBetweenPattern() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}