helperbot/cmd/helperbot/model_slack.go

package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
	"time"

	"github.com/slack-go/slack"
)

/* DB Functions */
func (m *BotModel) setSlackToken(token string) error {
	return m.SetBytes([]string{"slack", "config", "token"}, []byte(token))
}

func (m *BotModel) getSlackToken() (string, error) {
	return m.GetString([]string{"slack", "config", "token"})
}

func (m *BotModel) setSlackAdminDMId(adminId string) error {
	return m.SetString([]string{"slack", "config", "admin_dm_id"}, adminId)
}

func (m *BotModel) GetSlackAdminDMId() (string, error) {
	return m.GetString([]string{"slack", "config", "admin_dm_id"})
}

/* End DB Functions */

func (m *BotModel) NewSlack() error {
	var err error
	m.slackApiToken, err = m.getSlackToken()
	if err != nil {
		if strings.HasPrefix(err.Error(), "Couldn't find") {
			m.RequestSlackToken()
		} else {
			return err
		}
	}
	var slackDMid string
	slackDMid, err = m.GetSlackAdminDMId()
	if err != nil || slackDMid == "" {
		m.RequestAdminDMId()
	}
	m.IncomingSlackMessages = make(chan *slack.MessageEvent, 50)
	m.OtherRTMEvents = make(chan *slack.RTMEvent, 50)
	m.slackApi = slack.New(m.slackApiToken)
	m.slackIdToFriendly = make(map[string]string)
	m.slackRTM = m.slackApi.NewRTM()
	m.slackRTMLatency = time.Duration(0)
	go m.slackRTM.ManageConnection()
	go m.HandleRTMEvents()
	return nil
}

func (m *BotModel) RequestAdminDMId() {
	reader := bufio.NewReader(os.Stdin)
	fmt.Print("Slack Admin DM ID: ")
	dmId, _ := reader.ReadString('\n')
	m.setSlackAdminDMId(strings.TrimSpace(dmId))
}

func (m *BotModel) RequestSlackToken() {
	reader := bufio.NewReader(os.Stdin)
	fmt.Print("Slack Token: ")
	token, _ := reader.ReadString('\n')
	m.slackApiToken = strings.TrimSpace(token)
	m.setSlackToken(m.slackApiToken)
}

func (m *BotModel) HandleRTMEvents() {
	for msg := range m.slackRTM.IncomingEvents {
		fmt.Printf("RTM Message: %v", msg)

		switch ev := msg.Data.(type) {
		case *slack.MessageEvent:
			m.processMessageEvent(ev)

		case *slack.LatencyReport:
			m.OtherRTMEvents <- &msg

		case *slack.RTMError:
			fmt.Printf("RTM ERROR: (%d) %s", ev.Code, ev.Msg)
			m.OtherRTMEvents <- &msg

		default: // Ignore other events
		}
	}
}

func (m *BotModel) SendSlackChannelMessage(msg string, cid string) error {
	if DebugMode {
		return m.SendSlackAdminMessage(msg)
	}
	// Send message to slack channel
	//m.PostSlackMessage(msg)
	_, _, err := m.slackApi.PostMessage(
		cid,
		slack.MsgOptionText(msg, false),
		slack.MsgOptionAsUser(true),
	)
	return err
}

func (m *BotModel) SendSlackAdminMessage(msg string) error {
	// Send message to slack admin
	dmId, err := m.GetSlackAdminDMId()
	if err != nil {
		return err
	}
	_, _, err = m.slackApi.PostMessage(
		dmId,
		slack.MsgOptionText(msg, false),
		slack.MsgOptionAsUser(true),
	)
	return err
	return nil
}

func (m *BotModel) LoadDirectMessages() {
	/*
		cs, err := m.slackApi.GetIMChannels()
		if err != nil {
			return
		}
		for _, v := range cs {
			uname, err := m.GetSlackUserName(v.User)
			if err != nil {
				uname = v.User
			}
			m.slackIdToFriendly[v.ID] = uname
		}
	*/
}

func (m *BotModel) processMessageEvent(ev *slack.MessageEvent) {
	m.GetSlackChannelName(ev.User)
	m.GetSlackChannelName(ev.Channel)
	m.IncomingSlackMessages <- ev
}

func (m *BotModel) GetSlackUserName(id string) (string, error) {
	if v, ok := m.slackIdToFriendly[id]; ok {
		return v, nil
	}
	user, err := m.slackApi.GetUserInfo(id)
	if err != nil {
		return "", err
	}
	m.slackIdToFriendly[id] = user.Profile.DisplayName
	return user.Profile.DisplayName, nil
}

func (m *BotModel) GetSlackChannelName(id string) (string, error) {
	if v, ok := m.slackIdToFriendly[id]; ok {
		return v, nil
	}
	c, err := m.GetChannelInfo(id)
	if err != nil {
		return "", err
	}
	m.slackIdToFriendly[id] = c.Name
	return c.Name, nil
}

func (m *BotModel) SendMessageToChannel(msg string, cid string) error {
	dmId, err := m.GetSlackChannelName(cid)
	if err != nil {
		return err
	}
	_, _, err = m.slackApi.PostMessage(
		dmId,
		slack.MsgOptionText(msg, false),
		slack.MsgOptionAsUser(true),
	)
	return err
}

func (m *BotModel) GetSlackUserInfo(uid string) (*slack.User, error) {
	return m.slackApi.GetUserInfo(uid)
}

func (m *BotModel) GetSlackLatency() time.Duration {
	return m.slackRTMLatency
}