AoC & Stats are working, I believe

cmd/app.go

@@ -5,6 +5,8 @@ import (
 	"fmt"
 	"os"
 	"strings"
+
+	"github.com/nlopes/slack"
 )
 
 type App struct {
@@ -68,14 +70,17 @@ func (a *App) initialize() error {
 		a.m.setSlackAdminDMId(strings.TrimSpace(slackDMid))
 	}
 
-	if err = a.m.NewSlack(); err != nil {
-		return err
-	}
-
 	go a.watchMessageChannel()
+	go a.watchRTMEventChannel()
 	return nil
 }
 
+func (a *App) MonitorSlackMessages() {
+	for msg := range a.m.IncomingSlackMessages {
+		a.m.SendMessage("slack", "main", slack.Message(*msg))
+	}
+}
+
 func (a *App) watchMessageChannel() {
 	for a.running {
 		msg := <-a.m.messages
@@ -93,5 +98,13 @@ func (a *App) watchMessageChannel() {
 			v.State.ProcessMessage(msg)
 		}
 	}
-	close(a.m.messages)
+}
+
+func (a *App) watchRTMEventChannel() {
+	for a.running {
+		msg := <-a.m.OtherRTMEvents
+		for _, v := range a.plugins {
+			v.State.ProcessRTMEvent(*msg)
+		}
+	}
 }

cmd/model.go

@@ -5,8 +5,8 @@ import (
 	"fmt"
 	"os"
 	"strings"
+	"time"
 
-	goslack "git.bullercodeworks.com/brian/go-slack"
 	"git.bullercodeworks.com/brian/helperbot"
 	"github.com/br0xen/boltease"
 	"github.com/nlopes/slack"
@@ -17,21 +17,29 @@ type BotModel struct {
 
 	messages chan helperbot.Message
 
-	slack *goslack.Slack
+	slackApiToken         string
+	slackApi              *slack.Client
+	slackRTM              *slack.RTM
+	slackRTMLatency       time.Duration
+	slackIdToFriendly     map[string]string
+	IncomingSlackMessages chan *slack.MessageEvent
+	OtherRTMEvents        chan *slack.RTMEvent
 
-	cache map[string][]byte
+	dataCache map[string][]byte
 }
 
 func NewBotModel() (*BotModel, error) {
 	var err error
 	m := new(BotModel)
-	m.cache = make(map[string][]byte)
+	m.dataCache = make(map[string][]byte)
 	m.messages = make(chan helperbot.Message, 100)
 	m.db, err = boltease.Create("helperbot.db", 0600, nil)
 	if err != nil {
 		return nil, err
 	}
-
+	if err = m.NewSlack(); err != nil {
+		return nil, err
+	}
 	return m, nil
 }
 
@@ -58,7 +66,7 @@ func (m *BotModel) GetBytes(path []string) ([]byte, error) {
 	var v []byte
 	var ok bool
 	joinedPath := strings.Join(path, "/")
-	if v, ok = m.cache[joinedPath]; !ok {
+	if v, ok = m.dataCache[joinedPath]; !ok {
 		// Value is not cached, try to pull it from the DB
 		if len(path) > 2 {
 			path, key := path[:len(path)-1], path[len(path)-1]
@@ -66,7 +74,7 @@ func (m *BotModel) GetBytes(path []string) ([]byte, error) {
 			if err != nil {
 				return nil, err
 			}
-			m.cache[joinedPath] = v
+			m.dataCache[joinedPath] = v
 		}
 	}
 	return v, nil
@@ -81,7 +89,7 @@ func (m *BotModel) SetBytes(path []string, val []byte) error {
 			return err
 		}
 		// Update the cache
-		m.cache[joinedPath] = val
+		m.dataCache[joinedPath] = val
 		return nil
 	}
 	return errors.New("Invalid path")

cmd/model_slack.go

@@ -1,7 +1,10 @@
 package main
 
 import (
-	goslack "git.bullercodeworks.com/brian/go-slack"
+	"errors"
+	"fmt"
+	"time"
+
 	"github.com/nlopes/slack"
 )
 
@@ -25,20 +28,37 @@ func (m *BotModel) GetSlackAdminDMId() (string, error) {
 /* End DB Functions */
 
 func (m *BotModel) NewSlack() error {
-	token, err := m.getSlackToken()
+	var err error
+	m.slackApiToken, err = m.getSlackToken()
 	if err != nil {
 		return err
 	}
-	if m.slack, err = goslack.CreateSlack(token); err != nil {
-		return err
-	}
-	m.slack.StartRTM()
+	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 (a *App) MonitorSlackMessages() {
-	for msg := range a.m.slack.IncomingMessages {
-		a.m.SendMessage("slack", "main", slack.Message(*msg))
+func (m *BotModel) HandleRTMEvents() {
+	for msg := range m.slackRTM.IncomingEvents {
+		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
+		}
 	}
 }
 
@@ -47,7 +67,7 @@ func (m *BotModel) SendSlackChannelMessage(msg *slack.Message) error {
 		return m.SendSlackAdminMessage(msg)
 	}
 	// Send message to slack channel
-	m.slack.PostMessage(msg)
+	m.PostSlackMessage(msg)
 	return nil
 }
 
@@ -58,6 +78,124 @@ func (m *BotModel) SendSlackAdminMessage(msg *slack.Message) error {
 	if err != nil {
 		return err
 	}
-	m.slack.PostMessage(msg)
+	m.PostSlackMessage(msg)
 	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.GetSlackUserName(ev.User)
+	m.GetSlackIdName(ev.Channel)
+	m.IncomingSlackMessages <- ev
+}
+
+func (m *BotModel) GetSlackIdName(id string) (string, error) {
+	switch id[0] {
+	case 'U':
+		return m.GetSlackUserName(id)
+	case 'G':
+		return m.GetSlackGroupName(id)
+	case 'C':
+		return m.GetSlackChannelName(id)
+	case 'D':
+		return m.GetSlackIMName(id)
+	}
+	return "", errors.New("Unknown ID Type")
+}
+
+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) GetSlackIMName(id string) (string, error) {
+	if v, ok := m.slackIdToFriendly[id]; ok {
+		return v, nil
+	}
+	c, err := m.slackApi.GetChannelInfo(id)
+	if err != nil {
+		return "", err
+	}
+	m.slackIdToFriendly[id] = c.Name
+	return c.Name, nil
+}
+
+func (m *BotModel) GetSlackChannelName(id string) (string, error) {
+	if v, ok := m.slackIdToFriendly[id]; ok {
+		return v, nil
+	}
+	c, err := m.slackApi.GetChannelInfo(id)
+	if err != nil {
+		return "", err
+	}
+	m.slackIdToFriendly[id] = c.Name
+	return c.Name, nil
+}
+
+func (m *BotModel) GetSlackUserIM(id string) (string, error) {
+	for k, v := range m.slackIdToFriendly {
+		if v == id {
+			return k, nil
+		}
+	}
+	_, _, newId, err := m.slackApi.OpenIMChannel(id)
+	if err != nil {
+		return "", err
+	}
+	m.slackIdToFriendly[id] = newId
+	return newId, nil
+}
+
+func (m *BotModel) GetSlackGroupName(id string) (string, error) {
+	if v, ok := m.slackIdToFriendly[id]; ok {
+		return v, nil
+	}
+	g, err := m.slackApi.GetGroupInfo(id)
+	if err != nil {
+		return "", err
+	}
+	m.slackIdToFriendly[id] = g.Name
+	return g.Name, nil
+}
+
+func (m *BotModel) PostSlackMessage(msg *slack.Message) {
+	m.slackRTM.SendMessage(m.slackRTM.NewOutgoingMessage(msg.Text, msg.Channel))
+}
+
+func (m *BotModel) SendMessageToUser(msg *slack.Message, uid string) error {
+	dmId, err := m.GetSlackUserIM(uid)
+	if err != nil {
+		return err
+	}
+	msg.Channel = dmId
+	m.PostSlackMessage(msg)
+	return nil
+}
+
+func (m *BotModel) GetSlackUserInfo(uid string) (*slack.User, error) {
+	return m.slackApi.GetUserInfo(uid)
+}
+
+func (m *BotModel) GetSlackLatency() time.Duration {
+	return m.slackRTMLatency
+}