Implement collectors (Closes #60)

_examples/message_collector/example.go

@@ -1,10 +1,12 @@
 package main
 
 import (
+	"context"
 	"os"
 	"os/signal"
 	"strconv"
 	"syscall"
+	"time"
 
 	"github.com/DisgoOrg/disgo/bot"
 
@@ -54,20 +56,29 @@ func onMessageCreate(event *events.MessageCreateEvent) {
 	}
 	if event.Message.Content == "start" {
 		go func() {
-			ch, cls := event.Channel().CollectMessages(func(message *core.Message) bool {
+			ch, cls := event.Bot().Collectors.NewMessageCollector(func(message *core.Message) bool {
 				return message.ChannelID == event.ChannelID && message.Author.ID == event.Message.Author.ID && message.Content != ""
 			})
 			i := 1
 			str := ">>> "
-			for message := range ch {
-				if i > 3 {
-					cls()
-					_, _ = message.Channel().CreateMessage(core.NewMessageCreateBuilder().SetContent(str).Build())
+			ctx, clsCtx := context.WithTimeout(context.Background(), 20*time.Second)
+			defer clsCtx()
+			for {
+				select {
+				case <-ctx.Done():
+					_, _ = event.Channel().CreateMessage(core.NewMessageCreateBuilder().SetContent("cancelled").Build())
+					return
+
+				case message := <-ch:
+					str += strconv.Itoa(i) + ". " + message.Content + "\n\n"
+
+					if i == 3 {
+						cls()
+						_, _ = message.Channel().CreateMessage(core.NewMessageCreateBuilder().SetContent(str).Build())
+					}
+					i++
 				}
-				str += strconv.Itoa(i) + ". " + message.Content + "\n\n"
-				i++
 			}
 		}()
-
 	}
 }

bot/bot.go

@@ -88,13 +88,18 @@ func buildBot(token string, config Config) (*core.Bot, error) {
 			config.EventManagerConfig = &core.DefaultEventManagerConfig
 		}
 
-		if config.EventManagerConfig.NewMessageCollector == nil {
-			config.EventManagerConfig.NewMessageCollector = collectors.NewMessageCollectorByChannel
-		}
 		config.EventManager = core.NewEventManager(bot, config.EventManagerConfig)
 	}
 	bot.EventManager = config.EventManager
 
+	if config.Collectors == nil {
+		if config.CollectorsConfig == nil {
+			config.CollectorsConfig = &collectors.DefaultConfig
+		}
+		config.Collectors = core.NewCollectors(bot, *config.CollectorsConfig)
+	}
+	bot.Collectors = config.Collectors
+
 	if config.Gateway == nil && config.GatewayConfig != nil {
 		var gatewayRs *discord.Gateway
 		gatewayRs, err = bot.RestServices.GatewayService().GetGateway()

bot/config.go

@@ -19,6 +19,9 @@ type Config struct {
 	EventManager       core.EventManager
 	EventManagerConfig *core.EventManagerConfig
 
+	Collectors       core.Collectors
+	CollectorsConfig *core.CollectorsConfig
+
 	Gateway       gateway.Gateway
 	GatewayConfig *gateway.Config
 
@@ -101,6 +104,18 @@ func WithRawEventsEnabled() ConfigOpt {
 	}
 }
 
+func WithCollectors(collectors core.Collectors) ConfigOpt {
+	return func(config *Config) {
+		config.Collectors = collectors
+	}
+}
+
+func WithCollectorsConfig(collectorsConfig core.CollectorsConfig) ConfigOpt {
+	return func(config *Config) {
+		config.CollectorsConfig = &collectorsConfig
+	}
+}
+
 func WithGateway(gateway gateway.Gateway) ConfigOpt {
 	return func(config *Config) {
 		config.Gateway = gateway

collectors/button_click_collector.go

@@ -0,0 +1,42 @@
+package collectors
+
+import (
+	"github.com/DisgoOrg/disgo/core"
+	"github.com/DisgoOrg/disgo/events"
+)
+
+// NewButtonClickCollector gives you a channel to receive on and a function to close the collector
+//goland:noinspection GoUnusedExportedFunction
+func NewButtonClickCollector(disgo *core.Bot, filter core.ButtonInteractionFilter) (<-chan *core.ButtonInteraction, func()) {
+	ch := make(chan *core.ButtonInteraction)
+
+	col := &ButtonClickCollector{
+		Filter: filter,
+		Chan:   ch,
+	}
+	cls := func() {
+		close(ch)
+		disgo.EventManager.RemoveEventListeners(col)
+	}
+	col.Close = cls
+	disgo.EventManager.AddEventListeners(col)
+
+	return ch, cls
+}
+
+// ButtonClickCollector used to collect core.ButtonInteraction(s) from a core.Message using a ButtonFilter function
+type ButtonClickCollector struct {
+	Filter core.ButtonInteractionFilter
+	Chan   chan<- *core.ButtonInteraction
+	Close  func()
+}
+
+// OnEvent used to get events for the ButtonCollector
+func (c *ButtonClickCollector) OnEvent(e interface{}) {
+	if event, ok := e.(*events.ButtonClickEvent); ok {
+		if !c.Filter(event.ButtonInteraction) {
+			return
+		}
+		c.Chan <- event.ButtonInteraction
+	}
+}

collectors/config.go

@@ -0,0 +1,14 @@
+package collectors
+
+import "github.com/DisgoOrg/disgo/core"
+
+var DefaultConfig = core.CollectorsConfig{
+	NewButtonClickCollectorFunc:           NewButtonClickCollector,
+	NewMessageCollectorFunc:               NewMessageCollector,
+	NewMessageCommandCollectorFunc:        NewMessageCommandCollector,
+	NewMessageReactionAddCollectorFunc:    NewMessageReactionAddCollector,
+	NewMessageReactionRemoveCollectorFunc: NewMessageReactionRemoveCollector,
+	NewSelectMenuSubmitCollectorFunc:      NewSelectMenuSubmitCollector,
+	NewSlashCommandCollectorFunc:          NewSlashCommandCollector,
+	NewUserCommandCollectorFunc:           NewUserCommandCollector,
+}

collectors/message_collector.go

@@ -2,27 +2,16 @@ package collectors
 
 import (
 	"github.com/DisgoOrg/disgo/core"
-	"github.com/DisgoOrg/disgo/discord"
 	"github.com/DisgoOrg/disgo/events"
 )
 
-func NewMessageCollectorByChannel(channel *core.Channel, filter core.MessageFilter) (<-chan *core.Message, func()) {
-	var guildID *discord.Snowflake = nil
-	if guildChannel := channel; channel.IsGuildChannel() {
-		guildID = guildChannel.GuildID
-	}
-	return NewMessageCollector(channel.Bot, channel.ID, guildID, filter)
-}
-
 // NewMessageCollector gives you a channel to receive on and a function to close the collector
-func NewMessageCollector(disgo *core.Bot, channelID discord.Snowflake, guildID *discord.Snowflake, filter core.MessageFilter) (<-chan *core.Message, func()) {
+func NewMessageCollector(disgo *core.Bot, filter core.MessageFilter) (<-chan *core.Message, func()) {
 	ch := make(chan *core.Message)
 
 	collector := &MessageCollector{
-		Filter:    filter,
-		Channel:   ch,
-		ChannelID: channelID,
-		GuildID:   guildID,
+		Filter: filter,
+		Chan:   ch,
 	}
 	cls := func() {
 		close(ch)
@@ -36,30 +25,17 @@ func NewMessageCollector(disgo *core.Bot, channelID discord.Snowflake, guildID *
 
 // MessageCollector collects Message(s) using a MessageFilter function
 type MessageCollector struct {
-	Filter    core.MessageFilter
-	Channel   chan<- *core.Message
-	Close     func()
-	ChannelID discord.Snowflake
-	GuildID   *discord.Snowflake
+	Filter core.MessageFilter
+	Chan   chan<- *core.Message
+	Close  func()
 }
 
 // OnEvent used to get events for the MessageCollector
 func (c *MessageCollector) OnEvent(e interface{}) {
-	switch event := e.(type) {
-	case *events.MessageCreateEvent:
+	if event, ok := e.(*events.MessageCreateEvent); ok {
 		if !c.Filter(event.Message) {
 			return
 		}
-		c.Channel <- event.Message
-
-	case *events.GuildChannelDeleteEvent:
-		if event.ChannelID == c.ChannelID {
-			c.Close()
-		}
-
-	case *events.GuildLeaveEvent:
-		if c.GuildID != nil && event.GuildID == *c.GuildID {
-			c.Close()
-		}
+		c.Chan <- event.Message
 	}
 }

collectors/message_command_collector.go

@@ -0,0 +1,43 @@
+package collectors
+
+import (
+	"github.com/DisgoOrg/disgo/core"
+	"github.com/DisgoOrg/disgo/events"
+)
+
+
+// NewMessageCommandCollector gives you a channel to receive on and a function to close the collector
+//goland:noinspection GoUnusedExportedFunction
+func NewMessageCommandCollector(disgo *core.Bot, filter core.MessageCommandInteractionFilter) (<-chan *core.MessageCommandInteraction, func()) {
+	ch := make(chan *core.MessageCommandInteraction)
+
+	col := &MessageCommandCollector{
+		Filter: filter,
+		Chan:   ch,
+	}
+	cls := func() {
+		close(ch)
+		disgo.EventManager.RemoveEventListeners(col)
+	}
+	col.Close = cls
+	disgo.EventManager.AddEventListeners(col)
+
+	return ch, cls
+}
+
+// MessageCommandCollector used to collect core.MessageCommandInteraction(s) from a core.Message using a ButtonFilter function
+type MessageCommandCollector struct {
+	Filter core.MessageCommandInteractionFilter
+	Chan   chan<- *core.MessageCommandInteraction
+	Close     func()
+}
+
+// OnEvent used to get events for the ButtonCollector
+func (c *MessageCommandCollector) OnEvent(e interface{}) {
+	if event, ok := e.(*events.MessageCommandEvent); ok {
+		if !c.Filter(event.MessageCommandInteraction) {
+			return
+		}
+		c.Chan <- event.MessageCommandInteraction
+	}
+}

collectors/reaction_add_collector.go

@@ -0,0 +1,49 @@
+package collectors
+
+import (
+	"github.com/DisgoOrg/disgo/core"
+	"github.com/DisgoOrg/disgo/events"
+)
+
+// NewMessageReactionAddCollector gives you a channel to receive on and a function to close the collector
+func NewMessageReactionAddCollector(disgo *core.Bot, filter core.MessageReactionAddFilter) (<-chan *core.MessageReactionAdd, func()) {
+	ch := make(chan *core.MessageReactionAdd)
+
+	col := &MessageReactionAddCollector{
+		Filter: filter,
+		Chan:   ch,
+	}
+	cls := func() {
+		close(ch)
+		disgo.EventManager.RemoveEventListeners(col)
+	}
+	col.Close = cls
+	disgo.EventManager.AddEventListeners(col)
+
+	return ch, cls
+}
+
+// MessageReactionAddCollector used to collect discord.MessageReaction(s) from a core.Message using an events.MessageReactionAddFilter function
+type MessageReactionAddCollector struct {
+	Filter core.MessageReactionAddFilter
+	Chan   chan *core.MessageReactionAdd
+	Close  func()
+}
+
+// OnEvent used to get events for the ReactionCollector
+func (c *MessageReactionAddCollector) OnEvent(e interface{}) {
+	if event, ok := e.(*events.MessageReactionAddEvent); ok {
+		messageReactionAdd := &core.MessageReactionAdd{
+			UserID:    event.UserID,
+			ChannelID: event.ChannelID,
+			MessageID: event.MessageID,
+			GuildID:   event.GuildID,
+			Member:    event.Member,
+			Emoji:     event.Emoji,
+		}
+		if !c.Filter(messageReactionAdd) {
+			return
+		}
+		c.Chan <- messageReactionAdd
+	}
+}

collectors/reaction_remove_collector.go

@@ -0,0 +1,48 @@
+package collectors
+
+import (
+	"github.com/DisgoOrg/disgo/core"
+	"github.com/DisgoOrg/disgo/events"
+)
+
+// NewMessageReactionRemoveCollector gives you a channel to receive on and a function to close the collector
+func NewMessageReactionRemoveCollector(disgo *core.Bot, filter core.MessageReactionRemoveFilter) (<-chan *core.MessageReactionRemove, func()) {
+	ch := make(chan *core.MessageReactionRemove)
+
+	col := &MessageReactionRemoveCollector{
+		Filter: filter,
+		Chan:   ch,
+	}
+	cls := func() {
+		close(ch)
+		disgo.EventManager.RemoveEventListeners(col)
+	}
+	col.Close = cls
+	disgo.EventManager.RemoveEventListeners(col)
+
+	return ch, cls
+}
+
+// MessageReactionRemoveCollector used to collect discord.MessageReaction(s) from a core.Message using an events.MessageReactionRemoveFilter function
+type MessageReactionRemoveCollector struct {
+	Filter core.MessageReactionRemoveFilter
+	Chan   chan *core.MessageReactionRemove
+	Close  func()
+}
+
+// OnEvent used to get events for the ReactionCollector
+func (c *MessageReactionRemoveCollector) OnEvent(e interface{}) {
+	if event, ok := e.(*events.MessageReactionRemoveEvent); ok {
+		messageReactionRemove := &core.MessageReactionRemove{
+			UserID:    event.UserID,
+			ChannelID: event.ChannelID,
+			MessageID: event.MessageID,
+			GuildID:   event.GuildID,
+			Emoji:     event.Emoji,
+		}
+		if !c.Filter(messageReactionRemove) {
+			return
+		}
+		c.Chan <- messageReactionRemove
+	}
+}