Where can I find a good example for replying to incoming messages in socket mode?

[dmellonielet]

I have a Slack app with bot user enabled.

I'm trying to listen to MessageEvent and post a response depending on the content of the message.
An issue I am running into is the app treats the bot response as another message and keeps looping with more responses.

What's a good example I can refer to fully understand how to work with incoming message events, responding in the thread itself?

My code:

package main

import (
	"context"
	"errors"
	"fmt"
	"github.com/slack-go/slack"
	"github.com/slack-go/slack/slackevents"
	"github.com/slack-go/slack/socketmode"
	"log"
	"os"
	"strings"
	"time"
)

func main() {

	token := os.Getenv("SLACK_BOT_TOKEN")
	appToken := os.Getenv("SLACK_APP_TOKEN")

	client := slack.New(token, slack.OptionDebug(true), slack.OptionAppLevelToken(appToken))

	socketClient := socketmode.New(
		client,
		socketmode.OptionDebug(true),
		// Option to set a custom logger
		socketmode.OptionLog(log.New(os.Stdout, "socketmode: ", log.Lshortfile|log.LstdFlags)),
	)

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	go func(ctx context.Context, client *slack.Client, socketClient *socketmode.Client) {
		for {
			select {
			case <-ctx.Done():
				return
			case event := <-socketClient.Events:
				switch event.Type {
				case socketmode.EventTypeEventsAPI:
					eventsAPIEvent, ok := event.Data.(slackevents.EventsAPIEvent)
					if !ok {
						log.Printf("Could not type cast the event to EventsAPIEvent: %v\n", event)
						continue
					}
					socketClient.Ack(*event.Request)
					err := handleEventMessage(eventsAPIEvent, client)
					if err != nil {
						log.Fatal(err)
					}
				}
			}
		}
	}(ctx, client, socketClient)

	socketClient.Run()
}

func handleEventMessage(event slackevents.EventsAPIEvent, client *slack.Client) error {
	switch event.Type {
	case slackevents.CallbackEvent:
		innerEvent := event.InnerEvent
		switch ev := innerEvent.Data.(type) {
		case *slackevents.MessageEvent:
			//messageEvent, ok := innerEvent.Data.(*slackevents.MessageEvent)
			err := handleMessageEvent(ev, client)
			if err != nil {
				return err
			}
		}

	default:
		return errors.New("Unsupported Event Type")
	}
	return nil
}

func handleMessageEvent(event *slackevents.MessageEvent, client *slack.Client) error {
	//logic to match incoming message text
	_, _, err := client.PostMessage(event.Channel, slack.MsgOptionText("sample response", false)) //keeps looping this message
	if err != nil {
		return fmt.Errorf("failed to post message %w", err)
	}
	return nil
}

[matanmarciano]

You should check if ev.BotID is empty string or not

[zerok]

Additionally, you can run an AuthTest request right at the start to learn your bot's BotID 🙂

[matanmarciano]

Yeha that's also an option. But if you want to ignore any bots messages? It depends the use case I guess...
But yeha that's a good point!