Added Feature to handle reaction add & get message text of a reaction

README.md

@@ -20,10 +20,10 @@ Pack requires go version min. 1.11
 
 The plugin is configured using environment variables:
 
-ENV VAR                          | Default  |  Description                               | Example               
- ------------------------------- |  ------- |  ----------------------------------------- |  ---------------------
-FLYTE_API                        | -        | The API endpoint to use                    | http://localhost:8080
-FLYTE_SLACK_TOKEN                | -        | The Slack Bot API token to use             | token_abc
+| ENV VAR           | Default | Description                    | Example               |
+|-------------------|---------|--------------------------------|-----------------------|
+| FLYTE_API         | -       | The API endpoint to use        | http://localhost:8080 |
+| FLYTE_SLACK_TOKEN | -       | The Slack Bot API token to use | token_abc             |
 
 Example `FLYTE_API=http://localhost:8080 FLYTE_SLACK_TOKEN=token_abc ./flyte-slack`
 
@@ -71,11 +71,28 @@ The returned event payload is the same as the input.
 `SendRichMessageFailed`
 ```json
 {
-  "inputMessage": { ... },
+  "inputMessage": {
+  },
   "error": "..."
 }
 ```
 
+
+### GetReactionMessageInfo
+This command would retrieve the message text of reaction sent by a user. 
+
+```
+{                   "count":  50 , //default value is 100 mandatory
+					"message": "" , 
+					"threadTimestamp":"...", 
+					"reactionUser":"...",  // mandatory list of reactions for a user
+ 					"channelId": "...",
+					"threadTimestamp":"..."
+					}
+```
+
+
+
 ## Events 
 
 ### ReceivedMessage
@@ -95,6 +112,24 @@ The returned event payload is the same as the input.
         "message": "..."
     }
 
+### ReactionAdded
+    {
+        "type":"reaction_added", 
+        "user":"...",  //user that adds the reaction
+        "itemUser":"...",  //user that writes the message, file etc.
+        "item": {
+                "type" :"message", 
+                "channel" :"...", 
+                "file" :"", 
+                "fileComment" :"", 
+                "timestamp" :"..."
+                }, 
+        "reaction" :"...", //value of the reaction
+        "eventTimestamp" :"..." 
+    }
+
+
+
 ## Example Flows
 
 The following flow will allow you to type any message into a Slack channel where this pack is

client/slack.go

@@ -31,6 +31,7 @@ type client interface {
 	SendMessage(message *slack.OutgoingMessage)
 	PostMessage(channel string, opts ...slack.MsgOption) (string, string, error)
 	GetConversations(params *slack.GetConversationsParameters) (channels []slack.Channel, nextCursor string, err error)
+	ListReactions(params slack.ListReactionsParameters) ([]slack.ReactedItem, *slack.Paging, error)
 }
 
 // our slack implementation makes consistent use of channel id
@@ -41,6 +42,7 @@ type Slack interface {
 	// GetConversations is a heavy call used to fetch data about all channels in a workspace
 	// intended to be cached, not called each time this is needed
 	GetConversations() ([]types.Conversation, error)
+	GetReactionMessageText(count int, user string, channelId, threadTimestamp string) (text string)
 }
 
 type slackClient struct {
@@ -69,7 +71,7 @@ func NewSlack(token string) Slack {
 
 const (
 	getConversationsLimit = 1000 // max 1000
-	excludeArchived = true
+	excludeArchived       = true
 )
 
 func (sl *slackClient) GetConversations() ([]types.Conversation, error) {
@@ -147,6 +149,21 @@ func (sl *slackClient) handleMessageEvents() {
 				continue
 			}
 			sl.incomingMessages <- toFlyteMessageEvent(v, u)
+
+		case *slack.ReactionAddedEvent:
+			logger.Debugf("received reaction event for type = %v", v)
+			u, err := sl.client.GetUserInfo(v.User)
+
+			if err != nil {
+				logger.Errorf("cannot get info about user=%s: %v", v.User, err)
+				continue
+			}
+			itemuser, err := sl.client.GetUserInfo(v.ItemUser)
+			if err != nil {
+				logger.Errorf("cannot get info about item user=%v: %v", v.ItemUser, err)
+				continue
+			}
+			sl.incomingMessages <- toFlyteReactionAddedEvent(v, u, itemuser)
 		}
 	}
 }
@@ -208,3 +225,70 @@ func newUser(u *slack.User) user {
 		LastName:  u.Profile.LastName,
 	}
 }
+
+func newReactionEvent(e *slack.ReactionAddedEvent, u *slack.User, itemuser *slack.User) reactionAddedEvent {
+	return reactionAddedEvent{
+		ReactionUser:   newUser(u),
+		ReactionName:   e.Reaction,
+		EventTimestamp: e.EventTimestamp,
+		ItemTimestamp:  e.Item.Timestamp,
+		ItemType:       e.Item.Type,
+		ChannelId:      e.Item.Channel,
+		ItemUser:       newUser(itemuser),
+	}
+
+}
+
+type reactionAddedEvent struct {
+	ReactionUser   user   `json:"user"`
+	ReactionName   string `json:"reaction"`
+	EventTimestamp string `json:"eventTimestamp"`
+	ItemType       string `json:"type"`
+	ItemTimestamp  string `json:"itemTimestamp"`
+	ItemUser       user   `json:"itemUser"`
+	ChannelId      string `json:"channelId"`
+}
+
+func toFlyteReactionAddedEvent(event *slack.ReactionAddedEvent, user *slack.User, itemuser *slack.User) flyte.Event {
+
+	return flyte.Event{
+		EventDef: flyte.EventDef{Name: "ReactionAdded"},
+		Payload:  newReactionEvent(event, user, itemuser),
+	}
+}
+
+func (sl *slackClient) GetReactionMessageText(count int, user string, channelId, threadTimestamp string) (text string) {
+	params := slack.ListReactionsParameters{
+		Count: count,
+		User:  user,
+	}
+	logger.Debugf("Count = %v user = %s channel id= %v  threadTimestamp= %v", count, user, channelId, threadTimestamp)
+
+	reaction, paging, err := sl.client.ListReactions(params)
+	if err != nil {
+		logger.Debugf("Error = %v", err)
+	}
+
+	for i := range reaction {
+		if reaction[i].Type == "message" {
+			if reaction[i].Channel == channelId {
+				if reaction[i].Message.Timestamp == threadTimestamp {
+					logger.Debugf("reaction match found added:  Value of Type = %v , channel = %v Msg Timestamp = %v , Text = %v",
+						reaction[i].Type, reaction[i].Channel, reaction[i].Message.ThreadTimestamp,
+						reaction[i].Message.Text)
+					return reaction[i].Message.Text
+				} else {
+					logger.Debugf("reaction match not found with provided Timestamp")
+				}
+
+			} else {
+				logger.Debugf("reaction match not found with provided Channel")
+			}
+
+		}
+	}
+
+	logger.Debugf("Value of paging  = %v", paging)
+	return ""
+
+}

client/slack_test.go

@@ -321,3 +321,8 @@ func (m *MockClient) PostMessage(channel string, opts ...slack.MsgOption) (strin
 func (m *MockClient) GetConversations(params *slack.GetConversationsParameters) (channels []slack.Channel, nextCursor string, err error) {
 	return nil, "", err
 }
+func (m *MockClient) ListReactions(params slack.ListReactionsParameters) ([]slack.ReactedItem, *slack.Paging, error) {
+	params = params
+	//TODO mock the list reactions
+	return nil, nil, nil
+}

command/reaction_test.go

@@ -0,0 +1,90 @@
+/*
+Copyright (C) 2018 Expedia Group.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package command
+
+import (
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+var ReactionMockSlack *MockSlack
+
+func TestGetReactionListCommandIsPopulated(t *testing.T) {
+
+	command := GetReactionMessageInfo(ReactionMockSlack)
+
+	assert.Equal(t, "GetReactionMessageInfo", command.Name)
+	require.Equal(t, 2, len(command.OutputEvents))
+	assert.Equal(t, "GetReactionMessageInfoSuccess", command.OutputEvents[0].Name)
+	assert.Equal(t, "GetReactionMessageInfoFailed", command.OutputEvents[1].Name)
+}
+
+func TestGetReactionListReturnsGetReactionListSuccess(t *testing.T) {
+
+	BeforeMessage()
+	defer AfterMessage()
+
+	handler := GetReactionMessageInfo(ReactionMockSlack).Handler
+	event := handler([]byte(`{"count": 50 , 
+					"message": "" ,
+					"threadTimestamp":"1645441176.871569",
+					"reactionUser":"UXXXXXX", 
+ 					"channelId": "CXXXXXXX",
+					"threadTimestamp":"1645441176.871569"
+					}`))
+	output := event.Payload.(GetReactionMessageInfoOutput)
+	assert.Equal(t, "GetReactionMessageInfoSuccess", event.EventDef.Name)
+	assert.Equal(t, "", output.Message)
+	assert.Equal(t, "CXXXXXXX", output.ChannelId)
+}
+
+func TestGetReactionListReturnsGetReactionMessageInfoFailedMissingTimestamp(t *testing.T) {
+
+	BeforeMessage()
+	defer AfterMessage()
+
+	handler := GetReactionMessageInfo(ReactionMockSlack).Handler
+	event := handler([]byte(`{"count": 50 , 
+					"message": "" ,
+					"reactionUser":"UXXXXXX", 
+ 					"channelId": "CXXXXXXX",
+					"threadTimestamp":""
+					}`))
+	output := event.Payload.(GetReactionMessageInfoFailed)
+	output = output
+	assert.Equal(t, "GetReactionMessageInfoFailed", event.EventDef.Name)
+	assert.Equal(t, "missing Message Timestamp field", output.Error)
+}
+
+func TestGetReactionListReturnsGetReactionMessageInfoFailedMissingReactionUser(t *testing.T) {
+
+	BeforeMessage()
+	defer AfterMessage()
+
+	handler := GetReactionMessageInfo(ReactionMockSlack).Handler
+	event := handler([]byte(`{"count": 50 , 
+					"message": "" ,
+					"reactionUser":"", 
+ 					"channelId": "CXXXXXXX",
+					"threadTimestamp":"213.4445"
+					}`))
+	output := event.Payload.(GetReactionMessageInfoFailed)
+	output = output
+	assert.Equal(t, "GetReactionMessageInfoFailed", event.EventDef.Name)
+	assert.Equal(t, "missing user id field", output.Error)
+}

command/reactions.go

@@ -0,0 +1,85 @@
+package command
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/ExpediaGroup/flyte-slack/client"
+	"github.com/HotelsDotCom/flyte-client/flyte"
+	"strings"
+)
+
+var (
+	getReactionMessageInfoEventDef       = flyte.EventDef{Name: "GetReactionMessageInfoSuccess"}
+	getReactionMessageInfoFailedEventDef = flyte.EventDef{Name: "GetReactionMessageInfoFailed"}
+)
+
+type GetReactionMessageInfoInput struct {
+	Count           int    `json:"count"`
+	Message         string `json:"message"`
+	ThreadTimestamp string `json:"threadTimestamp"`
+	User            string `json:"reactionUser"`
+	ChannelId       string `json:"channelId"`
+	ItemUser        string `json:"itemUser"`
+}
+
+type GetReactionMessageInfoOutput struct {
+	GetReactionMessageInfoInput
+}
+
+type GetReactionMessageInfoFailed struct {
+	GetReactionMessageInfoOutput
+	Error string `json:"error"`
+}
+
+func GetReactionMessageInfo(slack client.Slack) flyte.Command {
+
+	return flyte.Command{
+		Name:         "GetReactionMessageInfo",
+		OutputEvents: []flyte.EventDef{getReactionMessageInfoEventDef, getReactionMessageInfoFailedEventDef},
+		Handler:      getReactionMessageInfoHandler(slack),
+	}
+}
+
+func getReactionMessageInfoHandler(slack client.Slack) func(json.RawMessage) flyte.Event {
+
+	return func(rawInput json.RawMessage) flyte.Event {
+		input := GetReactionMessageInfoInput{}
+		if err := json.Unmarshal(rawInput, &input); err != nil {
+			return flyte.NewFatalEvent(fmt.Sprintf("input is not valid: %v", err))
+		}
+
+		errorMessages := []string{}
+		if input.ThreadTimestamp == "" {
+			errorMessages = append(errorMessages, "missing Message Timestamp field")
+		}
+		if input.ChannelId == "" {
+			errorMessages = append(errorMessages, "missing channel id field")
+		}
+		if input.User == "" {
+			errorMessages = append(errorMessages, "missing user id field")
+		}
+		if len(errorMessages) != 0 {
+			return getReactionMessageFailedEvent(input.Message, input.ChannelId, strings.Join(errorMessages, ", "))
+		}
+
+		issueSummary := slack.GetReactionMessageText(input.Count, input.User, input.ChannelId, input.ThreadTimestamp)
+		return getReactionMessageSuccessInfoEvent(issueSummary, input.ChannelId)
+	}
+}
+
+func getReactionMessageSuccessInfoEvent(message, channelId string) flyte.Event {
+
+	return flyte.Event{
+		EventDef: getReactionMessageInfoEventDef,
+		Payload:  GetReactionMessageInfoOutput{GetReactionMessageInfoInput: GetReactionMessageInfoInput{Message: message, ChannelId: channelId}},
+	}
+}
+
+func getReactionMessageFailedEvent(message, channelId string, err string) flyte.Event {
+
+	output := GetReactionMessageInfoOutput{GetReactionMessageInfoInput{Message: message, ChannelId: channelId}}
+	return flyte.Event{
+		EventDef: getReactionMessageInfoFailedEventDef,
+		Payload:  GetReactionMessageInfoFailed{GetReactionMessageInfoOutput: output, Error: err},
+	}
+}

command/util_test.go

@@ -49,3 +49,14 @@ func (m *MockSlack) IncomingMessages() <-chan flyte.Event {
 func (m *MockSlack) GetConversations() ([]types.Conversation, error) {
 	return []types.Conversation(nil), nil
 }
+
+func (m *MockSlack) GetReactionMessageText(count int, user string, channelId, threadTimestamp string) (text string) {
+	//TODO Mock this test func
+	count = 50
+	channelId = "CXXXXX"
+	threadTimestamp = "765523.455667"
+	if user == "UXXXXX" {
+		return "This is sample test reaction message for user"
+	}
+	return ""
+}