helperbot/plugins_src/plugin_aoc.go

package main

import (
	"C"
)
import (
	"bufio"
	"errors"
	"fmt"
	"os"
	"sort"
	"strconv"
	"strings"
	"time"

	aoc "git.bullercodeworks.com/brian/go-adventofcode"
	slack "git.bullercodeworks.com/brian/go-slack"
	"git.bullercodeworks.com/brian/helperbot"
)

/* Plugin State */
type AoCState struct {
	model         helperbot.Model
	boardId       string
	sessionCookie string

	aoc *aoc.AoC
}

var State AoCState

/* Plugin Interface Functions */
func (s *AoCState) Name() string { return "advent-of-code" }
func (s *AoCState) Initialize(m helperbot.Model) error {
	// Initialize AoC stuff
	var err error
	var boardId, aocSession, aocChannelId string
	s.model = m

	boardId, err = s.getAoCBoardId()
	boardId = strings.TrimSpace(boardId)
	if err != nil || boardId == "" {
		s.RequestBoardId()
	}

	aocSession, err = s.getAoCSessionCookie()
	aocSession = strings.TrimSpace(aocSession)
	if err != nil || aocSession == "" {
		s.RequestSessionCookie()
	}

	aocChannelId, err = s.getChannelId()
	aocChannelId = strings.TrimSpace(aocChannelId)
	if err != nil || aocChannelId == "" {
		s.RequestChannelId()
	}

	if err = s.NewAoC(); err != nil {
		return err
	}
	return nil
}

func (s *AoCState) ProcessMessage(m helperbot.Message) {
	if m.GetSource() == "slack" {
		slackMsg := m.GetMessage()
		msgPts := strings.Fields(slackMsg.Text)
		if len(msgPts) < 1 {
			return
		}
		if msgPts[0] != "!aoc" || len(msgPts) < 2 {
			return
		}
		msgPts = msgPts[1:]
		yr, err := strconv.Atoi(msgPts[0])
		if err != nil {
			yr = s.GetLatestYear()
		} else {
			msgPts = msgPts[1:]
		}
		switch msgPts[0] {
		case "ping":
			s.model.SendMessage(s.Name(), "slack", slack.Message{
				Type:    "message",
				Channel: slackMsg.Channel,
				Text:    ":christmas_tree: PONG :christmas_tree:",
			})
		case "top":
			var txt string
			if yr == -1 {
				var err error
				txt, err = s.DoTopForAll()
				if err != nil {
					txt = "Error calculating all-time tops"
				}
			} else {
				txt = s.DoTopForYear(yr)
			}
			s.model.SendMessage(s.Name(), "slack", slack.Message{
				Type:    "message",
				Channel: slackMsg.Channel,
				Text:    txt,
			})
			return
		}
	}
}

func (s *AoCState) Run() {
	go s.runLoop()
}

func (s *AoCState) Exit() {}

/* Other Functions */
func (s *AoCState) NewAoC() error {
	board, err := s.getAoCBoardId()
	if err != nil {
		return err
	}
	sess, err := s.getAoCSessionCookie()
	if err != nil {
		return err
	}
	if s.aoc, err = aoc.NewAoC(board, sess); err != nil {
		return err
	}
	return nil
}

func (s *AoCState) runLoop() {
	for {
		channelId, err := s.getChannelId()
		if err != nil {
			// This plugin fails without a channel id
			return
		}
		for _, yr := range s.GetListOfAoCYears() {
			l, err := s.aoc.GetLeaderboard(yr)
			if err != nil {
				msg := slack.Message{
					Type: "error",
					Text: fmt.Sprintf("Error processing leaderboard (%d)", yr),
					Time: time.Now(),
				}
				s.model.SendMessage(s.Name(), "main", msg)
			} else {
				msg := slack.Message{
					Type: "success",
					Text: fmt.Sprintf("Received leaderboard (%d)", yr),
					Time: time.Now(),
				}
				s.model.SendMessage(s.Name(), "main", msg)
				// Compare the new leaderboard to the saved one
				for _, v := range l.Members {
					mbr, err := s.getMember(l.Event, v.ID)
					if err != nil {
						continue
					}
					if mbr.Stars != v.Stars {
						s.model.SendMessage(s.Name(), "slack", slack.Message{
							Type:    "message",
							Channel: channelId,
							Text:    ":christmas_tree: " + v.Name + " now has " + strconv.Itoa(v.Stars) + " stars! :christmas_tree:",
						})
					}
				}
				// Save the leaderboard to the db
				s.saveLeaderboard(l)
			}
			time.Sleep(time.Minute)
		}
		time.Sleep(time.Minute * 10)
	}
	s.model.SendMessage(s.Name(), "main", slack.Message{
		Type: "status",
		Text: "done",
		Time: time.Now(),
	})
}

func (s *AoCState) DoTopForAll() (string, error) {
	mbrMap := make(map[string]aoc.Member)
	for _, yr := range s.GetListOfAoCYears() {
		l, err := s.aoc.GetLeaderboard(yr)
		if err != nil {
			return "", err
		}
		for k, v := range l.Members {
			if m, ok := mbrMap[k]; ok {
				m.Stars = m.Stars + v.Stars
				m.LocalScore = m.LocalScore + v.LocalScore
				mbrMap[k] = m
			} else {
				mbrMap[k] = v
			}
		}
	}
	var mbrs []aoc.Member
	for _, v := range mbrMap {
		mbrs = append(mbrs, v)
	}

	if len(mbrs) == 0 {
		return "", errors.New("No member data")
	}
	sort.Sort(aoc.ByStarsThenScore(mbrs))
	txt := ":christmas_tree: AoC All-Time Top Five! :christmas_tree:"
	var num int
	for k := 0; k < len(mbrs); k++ {
		v := mbrs[len(mbrs)-k-1]
		txt = fmt.Sprintf("%s\n%s (%d :star:, %d)", txt, v.Name, v.Stars, v.LocalScore)
		num++
		if num >= 5 {
			break
		}
	}
	return txt, nil
}

func (s *AoCState) DoTopForYear(yr int) string {
	mbrs := s.GetMembers(yr)
	if len(mbrs) == 0 {
		return "No data for that year"
	}
	sort.Sort(aoc.ByStarsThenScore(mbrs))
	txt := fmt.Sprintf(":christmas_tree: AoC Top Five for %d! :christmas_tree:", yr)
	var num int
	for k := 0; k < len(mbrs); k++ {
		v := mbrs[len(mbrs)-k-1]
		txt = fmt.Sprintf("%s\n%s (%d :star:, %d)", txt, v.Name, v.Stars, v.LocalScore)
		num++
		if num >= 5 {
			break
		}
	}
	return txt
}

func (s *AoCState) GetMembers(yr int) []aoc.Member {
	var ret []aoc.Member
	l, err := s.aoc.GetLeaderboard(yr)
	if err != nil {
		return ret
	}
	for _, v := range l.Members {
		ret = append(ret, v)
	}
	return ret
}

func (s *AoCState) GetLatestYear() int {
	latestYear := time.Now().Year()
	if time.Now().Month() < 12 {
		latestYear--
	}
	return latestYear
}

func (s *AoCState) GetListOfAoCYears() []int {
	var ret []int
	for k := s.GetLatestYear(); k > 2014; k-- {
		ret = append(ret, k)
	}
	return ret
}

func (s *AoCState) GetAoCBoard(yr int) (*aoc.Leaderboard, error) {
	return s.aoc.GetLeaderboard(yr)
}

func (s *AoCState) RequestBoardId() {
	reader := bufio.NewReader(os.Stdin)
	fmt.Print("Advent of Code Board ID: ")
	boardId, _ := reader.ReadString('\n')
	s.setAoCBoardId(strings.TrimSpace(boardId))
}

func (s *AoCState) RequestSessionCookie() {
	reader := bufio.NewReader(os.Stdin)
	fmt.Print("Advent of Code Session Cookie: ")
	aocSession, _ := reader.ReadString('\n')
	s.setAoCSessionCookie(strings.TrimSpace(aocSession))
}

// The channel that we post updates to
func (s *AoCState) RequestChannelId() {
	reader := bufio.NewReader(os.Stdin)
	fmt.Print("Advent of Code Slack Channel ID: ")
	chn, _ := reader.ReadString('\n')
	s.setChannelId(strings.TrimSpace(chn))
}

/* DB Functions */
func (s *AoCState) setAoCBoardId(brdId string) error {
	return s.model.SetString([]string{"aoc", "config", "board_id"}, brdId)
}

func (s *AoCState) getAoCBoardId() (string, error) {
	return s.model.GetString([]string{"aoc", "config", "board_id"})
}

func (s *AoCState) setAoCSessionCookie(sess string) error {
	return s.model.SetString([]string{"aoc", "config", "session"}, sess)
}

func (s *AoCState) getAoCSessionCookie() (string, error) {
	return s.model.GetString([]string{"aoc", "config", "session"})
}

func (s *AoCState) setChannelId(chn string) error {
	return s.model.SetString([]string{"aoc", "config", "channel_id"}, chn)
}

func (s *AoCState) getChannelId() (string, error) {
	return s.model.GetString([]string{"aoc", "config", "channel_id"})
}

func (s *AoCState) saveLeaderboard(l *aoc.Leaderboard) error {
	err := s.model.SetString([]string{"aoc", "leaderboards", l.Event, "owner_id"}, l.OwnerID)
	if err != nil {
		return err
	}
	err = s.model.SetString([]string{"aoc", "leaderboards", l.Event, "last_fetch"}, l.LastFetch.Format(time.RFC3339))
	if err != nil {
		return err
	}
	for _, v := range l.Members {
		if err = s.saveMember(l.Event, &v); err != nil {
			s.model.SendMessage(s.Name(), "main", slack.Message{
				Type: "error",
				Text: fmt.Sprintf("Error Saving Member (%s)", v.Name),
				Time: time.Now(),
			})
		}
	}
	return nil
}

func (s *AoCState) saveMember(event string, m *aoc.Member) error {
	err := s.model.SetString([]string{"aoc", "leaderboards", event, "members", m.ID, "id"}, m.ID)
	if err != nil {
		return err
	}
	err = s.model.SetString([]string{"aoc", "leaderboards", event, "members", m.ID, "stars"}, strconv.Itoa(m.Stars))
	if err != nil {
		return err
	}
	err = s.model.SetString([]string{"aoc", "leaderboards", event, "members", m.ID, "last_star_ts"}, m.LastStarTs.Format(time.RFC3339))
	if err != nil {
		return err
	}
	err = s.model.SetString([]string{"aoc", "leaderboards", event, "members", m.ID, "name"}, m.Name)
	if err != nil {
		return err
	}
	err = s.model.SetString([]string{"aoc", "leaderboards", event, "members", m.ID, "local_score"}, strconv.Itoa(m.LocalScore))
	if err != nil {
		return err
	}
	err = s.model.SetString([]string{"aoc", "leaderboards", event, "members", m.ID, "global_score"}, strconv.Itoa(m.GlobalScore))
	if err != nil {
		return err
	}

	return nil
}

func (s *AoCState) getMember(event string, memberId string) (*aoc.Member, error) {
	var err error
	var wrk string
	mbr := new(aoc.Member)
	mbrPath := []string{"aoc", "leaderboards", event, "members", memberId}
	mbr.ID, err = s.model.GetString(append(mbrPath, "id"))
	if err != nil {
		return nil, err
	}
	wrk, err = s.model.GetString(append(mbrPath, "stars"))
	if err != nil {
		return nil, err
	}
	mbr.Stars, err = strconv.Atoi(wrk)
	if err != nil {
		return nil, err
	}
	wrk, err = s.model.GetString(append(mbrPath, "last_star_ts"))
	if err != nil {
		return nil, err
	}
	mbr.LastStarTs, err = time.Parse(time.RFC3339, wrk)
	if err != nil {
		return nil, err
	}
	mbr.Name, err = s.model.GetString(append(mbrPath, "name"))
	if err != nil {
		return nil, err
	}
	wrk, err = s.model.GetString(append(mbrPath, "local_score"))
	if err != nil {
		return nil, err
	}
	mbr.LocalScore, err = strconv.Atoi(wrk)
	wrk, err = s.model.GetString(append(mbrPath, "global_score"))
	if err != nil {
		return nil, err
	}
	mbr.GlobalScore, err = strconv.Atoi(wrk)
	return mbr, nil
}