Socketmode Middleware Design Pattern

examples/sockermode_handler/socketmode_handler.go

@@ -0,0 +1,206 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"strings"
+
+	"github.com/slack-go/slack/slackevents"
+	"github.com/slack-go/slack/socketmode"
+
+	"github.com/slack-go/slack"
+)
+
+func main() {
+	appToken := os.Getenv("SLACK_APP_TOKEN")
+	if appToken == "" {
+
+	}
+
+	if !strings.HasPrefix(appToken, "xapp-") {
+		fmt.Fprintf(os.Stderr, "SLACK_APP_TOKEN must have the prefix \"xapp-\".")
+	}
+
+	botToken := os.Getenv("SLACK_BOT_TOKEN")
+	if botToken == "" {
+		fmt.Fprintf(os.Stderr, "SLACK_BOT_TOKEN must be set.\n")
+		os.Exit(1)
+	}
+
+	if !strings.HasPrefix(botToken, "xoxb-") {
+		fmt.Fprintf(os.Stderr, "SLACK_BOT_TOKEN must have the prefix \"xoxb-\".")
+	}
+
+	api := slack.New(
+		botToken,
+		slack.OptionDebug(true),
+		slack.OptionLog(log.New(os.Stdout, "api: ", log.Lshortfile|log.LstdFlags)),
+		slack.OptionAppLevelToken(appToken),
+	)
+
+	client := socketmode.New(
+		api,
+		socketmode.OptionDebug(true),
+		socketmode.OptionLog(log.New(os.Stdout, "socketmode: ", log.Lshortfile|log.LstdFlags)),
+	)
+
+	socketmodeHandler := socketmode.NewsSocketmodeHandler(client)
+
+	socketmodeHandler.Handle(socketmode.EventTypeConnecting, middlewareConnecting)
+	socketmodeHandler.Handle(socketmode.EventTypeConnectionError, middlewareConnectionError)
+	socketmodeHandler.Handle(socketmode.EventTypeConnected, middlewareConnected)
+
+	//\\ EventTypeEventsAPI //\\
+	// Handle all EventsAPI
+	socketmodeHandler.Handle(socketmode.EventTypeEventsAPI, middlewareEventsAPI)
+
+	// Handle a specific event from EventsAPI
+	socketmodeHandler.HandleEventsAPI(slackevents.AppMention, middlewareAppMentionEvent)
+
+	//\\ EventTypeInteractive //\\
+	// Handle all Interactive Events
+	socketmodeHandler.Handle(socketmode.EventTypeInteractive, middlewareInteractive)
+
+	// Handle a specific Interaction
+	socketmodeHandler.HandleInteraction(slack.InteractionTypeBlockActions, middlewareInteractionTypeBlockActions)
+
+	// Handle all SlashCommand
+	socketmodeHandler.Handle(socketmode.EventTypeSlashCommand, middlewareSlashCommand)
+	socketmodeHandler.HandleSlashCommand("/rocket", middlewareSlashCommand)
+
+	// socketmodeHandler.HandleDefault(middlewareDefault)
+
+	socketmodeHandler.RunEventLoop()
+}
+
+func middlewareConnecting(evt *socketmode.Event, client *socketmode.Client) {
+	fmt.Println("Connecting to Slack with Socket Mode...")
+}
+
+func middlewareConnectionError(evt *socketmode.Event, client *socketmode.Client) {
+	fmt.Println("Connection failed. Retrying later...")
+}
+
+func middlewareConnected(evt *socketmode.Event, client *socketmode.Client) {
+	fmt.Println("Connected to Slack with Socket Mode.")
+}
+
+func middlewareEventsAPI(evt *socketmode.Event, client *socketmode.Client) {
+	fmt.Println("middlewareEventsAPI")
+	eventsAPIEvent, ok := evt.Data.(slackevents.EventsAPIEvent)
+	if !ok {
+		fmt.Printf("Ignored %+v\n", evt)
+		return
+	}
+
+	fmt.Printf("Event received: %+v\n", eventsAPIEvent)
+
+	client.Ack(*evt.Request)
+
+	switch eventsAPIEvent.Type {
+	case slackevents.CallbackEvent:
+		innerEvent := eventsAPIEvent.InnerEvent
+		switch ev := innerEvent.Data.(type) {
+		case *slackevents.AppMentionEvent:
+			fmt.Printf("We have been mentionned in %v", ev.Channel)
+			_, _, err := client.GetApiClient().PostMessage(ev.Channel, slack.MsgOptionText("Yes, hello.", false))
+			if err != nil {
+				fmt.Printf("failed posting message: %v", err)
+			}
+		case *slackevents.MemberJoinedChannelEvent:
+			fmt.Printf("user %q joined to channel %q", ev.User, ev.Channel)
+		}
+	default:
+		client.Debugf("unsupported Events API event received")
+	}
+}
+
+func middlewareAppMentionEvent(evt *socketmode.Event, client *socketmode.Client) {
+
+	eventsAPIEvent, ok := evt.Data.(slackevents.EventsAPIEvent)
+	if !ok {
+		fmt.Printf("Ignored %+v\n", evt)
+		return
+	}
+
+	client.Ack(*evt.Request)
+
+	ev, ok := eventsAPIEvent.InnerEvent.Data.(*slackevents.AppMentionEvent)
+	if !ok {
+		fmt.Printf("Ignored %+v\n", ev)
+		return
+	}
+
+	fmt.Printf("We have been mentionned in %v\n", ev.Channel)
+	_, _, err := client.GetApiClient().PostMessage(ev.Channel, slack.MsgOptionText("Yes, hello.", false))
+	if err != nil {
+		fmt.Printf("failed posting message: %v", err)
+	}
+}
+
+func middlewareInteractive(evt *socketmode.Event, client *socketmode.Client) {
+	callback, ok := evt.Data.(slack.InteractionCallback)
+	if !ok {
+		fmt.Printf("Ignored %+v\n", evt)
+		return
+	}
+
+	fmt.Printf("Interaction received: %+v\n", callback)
+
+	var payload interface{}
+
+	switch callback.Type {
+	case slack.InteractionTypeBlockActions:
+		// See https://api.slack.com/apis/connections/socket-implement#button
+		client.Debugf("button clicked!")
+	case slack.InteractionTypeShortcut:
+	case slack.InteractionTypeViewSubmission:
+		// See https://api.slack.com/apis/connections/socket-implement#modal
+	case slack.InteractionTypeDialogSubmission:
+	default:
+
+	}
+
+	client.Ack(*evt.Request, payload)
+}
+
+func middlewareInteractionTypeBlockActions(evt *socketmode.Event, client *socketmode.Client) {
+	client.Debugf("button clicked!")
+}
+
+func middlewareSlashCommand(evt *socketmode.Event, client *socketmode.Client) {
+	cmd, ok := evt.Data.(slack.SlashCommand)
+	if !ok {
+		fmt.Printf("Ignored %+v\n", evt)
+		return
+	}
+
+	client.Debugf("Slash command received: %+v", cmd)
+
+	payload := map[string]interface{}{
+		"blocks": []slack.Block{
+			slack.NewSectionBlock(
+				&slack.TextBlockObject{
+					Type: slack.MarkdownType,
+					Text: "foo",
+				},
+				nil,
+				slack.NewAccessory(
+					slack.NewButtonBlockElement(
+						"",
+						"somevalue",
+						&slack.TextBlockObject{
+							Type: slack.PlainTextType,
+							Text: "bar",
+						},
+					),
+				),
+			),
+		}}
+	client.Ack(*evt.Request, payload)
+}
+
+func middlewareDefault(evt *socketmode.Event, client *socketmode.Client) {
+	// fmt.Fprintf(os.Stderr, "Unexpected event type received: %s\n", evt.Type)
+}

slackevents/inner_events.go

@@ -319,45 +319,47 @@ func (e MessageEvent) IsEdited() bool {
 		e.Message.Edited != nil
 }
 
+type EventAPIType string
+
 const (
 	// AppMention is an Events API subscribable event
-	AppMention = "app_mention"
+	AppMention = EventAPIType("app_mention")
 	// AppHomeOpened Your Slack app home was opened
-	AppHomeOpened = "app_home_opened"
+	AppHomeOpened = EventAPIType("app_home_opened")
 	// AppUninstalled Your Slack app was uninstalled.
-	AppUninstalled = "app_uninstalled"
+	AppUninstalled = EventAPIType("app_uninstalled")
 	// ChannelCreated is sent when a new channel is created.
-	ChannelCreated = "channel_created"
+	ChannelCreated = EventAPIType("channel_created")
 	// GridMigrationFinished An enterprise grid migration has finished on this workspace.
-	GridMigrationFinished = "grid_migration_finished"
+	GridMigrationFinished = EventAPIType("grid_migration_finished")
 	// GridMigrationStarted An enterprise grid migration has started on this workspace.
-	GridMigrationStarted = "grid_migration_started"
+	GridMigrationStarted = EventAPIType("grid_migration_started")
 	// LinkShared A message was posted containing one or more links relevant to your application
-	LinkShared = "link_shared"
+	LinkShared = EventAPIType("link_shared")
 	// Message A message was posted to a channel, private channel (group), im, or mim
-	Message = "message"
+	Message = EventAPIType("message")
 	// Member Joined Channel
-	MemberJoinedChannel = "member_joined_channel"
+	MemberJoinedChannel = EventAPIType("member_joined_channel")
 	// Member Left Channel
-	MemberLeftChannel = "member_left_channel"
+	MemberLeftChannel = EventAPIType("member_left_channel")
 	// PinAdded An item was pinned to a channel
-	PinAdded = "pin_added"
+	PinAdded = EventAPIType("pin_added")
 	// PinRemoved An item was unpinned from a channel
-	PinRemoved = "pin_removed"
+	PinRemoved = EventAPIType("pin_removed")
 	// ReactionAdded An reaction was added to a message
-	ReactionAdded = "reaction_added"
+	ReactionAdded = EventAPIType("reaction_added")
 	// ReactionRemoved An reaction was removed from a message
-	ReactionRemoved = "reaction_removed"
+	ReactionRemoved = EventAPIType("reaction_removed")
 	// TokensRevoked APP's API tokes are revoked
-	TokensRevoked = "tokens_revoked"
+	TokensRevoked = EventAPIType("tokens_revoked")
 	// EmojiChanged A custom emoji has been added or changed
-	EmojiChanged = "emoji_changed"
+	EmojiChanged = EventAPIType("emoji_changed")
 )
 
 // EventsAPIInnerEventMapping maps INNER Event API events to their corresponding struct
 // implementations. The structs should be instances of the unmarshalling
 // target for the matching event type.
-var EventsAPIInnerEventMapping = map[string]interface{}{
+var EventsAPIInnerEventMapping = map[EventAPIType]interface{}{
 	AppMention:            AppMentionEvent{},
 	AppHomeOpened:         AppHomeOpenedEvent{},
 	AppUninstalled:        AppUninstalledEvent{},

slackevents/parsers.go

@@ -19,7 +19,7 @@ func eventsMap(t string) (interface{}, bool) {
 	// Must parse EventsAPI FIRST as both RTM and EventsAPI
 	// have a type: "Message" event.
 	// TODO: Handle these cases more explicitly.
-	v, exists := EventsAPIInnerEventMapping[t]
+	v, exists := EventsAPIInnerEventMapping[EventAPIType(t)]
 	if exists {
 		return v, exists
 	}

slacktest/data.go

@@ -35,6 +35,12 @@ var okWebResponse = slack.SlackResponse{
 	Ok: true,
 }
 
+var defaultOkJSON = fmt.Sprintf(`
+	{
+		"ok": true
+	}
+	`)
+
 var defaultChannelsListJSON = fmt.Sprintf(`
 	{
 		"ok": true,

slacktest/handlers.go

@@ -107,6 +107,16 @@ func inviteConversationHandler(w http.ResponseWriter, r *http.Request) {
 	_, _ = w.Write([]byte(inviteConversationJSON))
 }
 
+// handle groups.list
+func listGroupsHandler(w http.ResponseWriter, _ *http.Request) {
+	_, _ = w.Write([]byte(defaultGroupsListJSON))
+}
+
+// handle reaction.Add
+func reactionAddHandler(w http.ResponseWriter, _ *http.Request) {
+	_, _ = w.Write([]byte(defaultOkJSON))
+}
+
 // handle chat.postMessage
 func (sts *Server) postMessageHandler(w http.ResponseWriter, r *http.Request) {
 	serverAddr := r.Context().Value(ServerBotHubNameContextKey).(string)

slacktest/server.go

@@ -59,6 +59,7 @@ func NewTestServer(custom ...binder) *Server {
 	s.Handle("/users.lookupByEmail", usersInfoHandler)
 	s.Handle("/bots.info", botsInfoHandler)
 	s.Handle("/auth.test", authTestHandler)
+	s.Handle("/reactions.add", reactionAddHandler)
 
 	httpserver := httptest.NewUnstartedServer(s.mux)
 	addr := httpserver.Listener.Addr().String()

socketmode/client.go

@@ -61,3 +61,8 @@ type Client struct {
 	debug bool
 	log   ilogger
 }
+
+// return a pointer to the slack API client
+func (c Client) GetApiClient() *slack.Client {
+	return &c.apiClient
+}