Use SocketMode for connections

Updates Slacker to use the Events API over the SocketMode communication
protocol, replacing calls to the deprecated RTM API.

A few key functions have changed, notably the NewClient function now
requires both an App and Bot token to be specified. In addition, the
typing indicator is not supported in SocketMode and has been removed
altogether.

Author: arusso

analytics.go

@@ -4,16 +4,15 @@ import (
 	"time"
 
 	"github.com/shomali11/proper"
-	"github.com/slack-go/slack"
 )
 
 // NewCommandEvent creates a new command event
-func NewCommandEvent(command string, parameters *proper.Properties, message *slack.MessageEvent) *CommandEvent {
+func NewCommandEvent(command string, parameters *proper.Properties, event *MessageEvent) *CommandEvent {
 	return &CommandEvent{
 		Timestamp:  time.Now(),
 		Command:    command,
 		Parameters: parameters,
-		Message:    message,
+		Event:      event,
 	}
 }
 
@@ -22,5 +21,5 @@ type CommandEvent struct {
 	Timestamp  time.Time
 	Command    string
 	Parameters *proper.Properties
-	Message    *slack.MessageEvent
+	Event      *MessageEvent
 }

context.go

@@ -4,26 +4,27 @@ import (
 	"context"
 
 	"github.com/slack-go/slack"
+	"github.com/slack-go/slack/socketmode"
 )
 
 // A BotContext interface is used to respond to an event
 type BotContext interface {
 	Context() context.Context
-	Event() *slack.MessageEvent
-	RTM() *slack.RTM
+	Event() *MessageEvent
+	SocketMode() *socketmode.Client
 	Client() *slack.Client
 }
 
 // NewBotContext creates a new bot context
-func NewBotContext(ctx context.Context, event *slack.MessageEvent, client *slack.Client, rtm *slack.RTM) BotContext {
-	return &botContext{ctx: ctx, event: event, client: client, rtm: rtm}
+func NewBotContext(ctx context.Context, client *slack.Client, socketmode *socketmode.Client, evt *MessageEvent) BotContext {
+	return &botContext{ctx: ctx, event: evt, client: client, socketmode: socketmode}
 }
 
 type botContext struct {
-	ctx    context.Context
-	event  *slack.MessageEvent
-	client *slack.Client
-	rtm    *slack.RTM
+	ctx        context.Context
+	event      *MessageEvent
+	client     *slack.Client
+	socketmode *socketmode.Client
 }
 
 // Context returns the context
@@ -32,16 +33,64 @@ func (r *botContext) Context() context.Context {
 }
 
 // Event returns the slack message event
-func (r *botContext) Event() *slack.MessageEvent {
+func (r *botContext) Event() *MessageEvent {
 	return r.event
 }
 
-// RTM returns the RTM client
-func (r *botContext) RTM() *slack.RTM {
-	return r.rtm
+// SocketMode returns the SocketMode client
+func (r *botContext) SocketMode() *socketmode.Client {
+	return r.socketmode
 }
 
 // Client returns the slack client
 func (r *botContext) Client() *slack.Client {
 	return r.client
 }
+
+// MessageEvent contains details common to message based events, including the
+// raw event as returned from Slack along with the corresponding event type.
+// The struct should be kept minimal and only include data that is commonly
+// used to prevent freqeuent type assertions when evaluating the event.
+type MessageEvent struct {
+	// Channel ID where the message was sent
+	Channel string
+
+	// User ID of the sender
+	User string
+
+	// Text is the unalterted text of the message, as returned by Slack
+	Text string
+
+	// TimeStamp is the message timestamp
+	TimeStamp string
+
+	// ThreadTimeStamp is the message thread timestamp.
+	ThreadTimeStamp string
+
+	// Data is the raw event data returned from slack. Using Type, you can assert
+	// this into a slackevents *Event struct.
+	Data interface{}
+
+	// Type is the type of the event, as returned by Slack. For instance,
+	// `app_mention` or `message`
+	Type string
+
+	// BotID holds the Slack User ID for our bot
+	BotID string
+}
+
+// IsThread indicates if a message event took place in a thread.
+func (e *MessageEvent) IsThread() bool {
+	if e.ThreadTimeStamp == "" || e.ThreadTimeStamp == e.TimeStamp {
+		return false
+	}
+	return true
+}
+
+// IsBot indicates if the message was sent by a bot
+func (e *MessageEvent) IsBot() bool {
+	if e.BotID == "" {
+		return false
+	}
+	return true
+}

response.go

@@ -14,7 +14,6 @@ const (
 type ResponseWriter interface {
 	Reply(text string, options ...ReplyOption) error
 	ReportError(err error, options ...ReportErrorOption)
-	Typing()
 }
 
 // NewResponse creates a new response structure
@@ -30,56 +29,43 @@ type response struct {
 func (r *response) ReportError(err error, options ...ReportErrorOption) {
 	defaults := newReportErrorDefaults(options...)
 
-	rtm := r.botCtx.RTM()
-	event := r.botCtx.Event()
-	message := rtm.NewOutgoingMessage(fmt.Sprintf(errorFormat, err.Error()), event.Channel)
+	client := r.botCtx.Client()
+	ev := r.botCtx.Event()
+
+	opts := []slack.MsgOption{
+		slack.MsgOptionText(fmt.Sprintf(errorFormat, err.Error()), false),
+	}
 	if defaults.ThreadResponse {
-		message.ThreadTimestamp = event.ThreadTimestamp
-		if event.ThreadTimestamp == "" {
-			message.ThreadTimestamp = event.EventTimestamp
-		}
+		opts = append(opts, slack.MsgOptionTS(ev.TimeStamp))
+	}
+	_, _, err = client.PostMessage(ev.Channel, opts...)
+	if err != nil {
+		fmt.Printf("failed posting message: %v\n", err)
 	}
-
-	rtm.SendMessage(message)
-}
-
-// Typing send a typing indicator
-func (r *response) Typing() {
-	rtm := r.botCtx.RTM()
-	event := r.botCtx.Event()
-	rtm.SendMessage(rtm.NewTypingMessage(event.Channel))
 }
 
 // Reply send a attachments to the current channel with a message
 func (r *response) Reply(message string, options ...ReplyOption) error {
 	defaults := newReplyDefaults(options...)
 
-	rtm := r.botCtx.RTM()
-	event := r.botCtx.Event()
-	if defaults.ThreadResponse {
-		threadTimestamp := event.ThreadTimestamp
-		if event.ThreadTimestamp == "" {
-			threadTimestamp = event.EventTimestamp
-		}
-		_, _, err := rtm.PostMessage(
-			event.Channel,
-			slack.MsgOptionText(message, false),
-			slack.MsgOptionUser(rtm.GetInfo().User.ID),
-			slack.MsgOptionAsUser(true),
-			slack.MsgOptionAttachments(defaults.Attachments...),
-			slack.MsgOptionBlocks(defaults.Blocks...),
-			slack.MsgOptionTS(threadTimestamp),
-		)
-		return err
+	client := r.botCtx.Client()
+	ev := r.botCtx.Event()
+	if ev == nil {
+		return fmt.Errorf("Unable to get message event details")
 	}
 
-	_, _, err := rtm.PostMessage(
-		event.Channel,
+	opts := []slack.MsgOption{
 		slack.MsgOptionText(message, false),
-		slack.MsgOptionUser(rtm.GetInfo().User.ID),
-		slack.MsgOptionAsUser(true),
 		slack.MsgOptionAttachments(defaults.Attachments...),
 		slack.MsgOptionBlocks(defaults.Blocks...),
+	}
+	if defaults.ThreadResponse {
+		opts = append(opts, slack.MsgOptionTS(ev.TimeStamp))
+	}
+
+	_, _, err := client.PostMessage(
+		ev.Channel,
+		opts...,
 	)
 	return err
 }