package main import ( "C" ) import ( "bufio" "errors" "fmt" "os" "sort" "strconv" "strings" "time" aoc "git.bullercodeworks.com/brian/go-adventofcode" "git.bullercodeworks.com/brian/helperbot" "github.com/nlopes/slack" ) /* Plugin State */ type AoCState struct { model helperbot.Model boardId string sessionCookie string sessionNeedsUpdate bool aoc *aoc.AoC lastYear int } 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() } else { s.sessionCookie = aocSession } 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() if len(slackMsg.Channel) == 0 { return } switch slackMsg.Channel[0] { case 'C', 'G': s.ProcessChannelMessage(slackMsg) case 'D': admin, err := s.model.GetSlackAdminDMId() if err != nil { s.SendAdminIdError() return } if slackMsg.Channel == admin { s.ProcessAdminDirectMessage(slackMsg) } else { s.ProcessDirectMessage(slackMsg) } } } } func (s *AoCState) ProcessRTMEvent(msg slack.RTMEvent) {} 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() { _, err := s.getChannelId() // This plugin fails without a channel id if err != nil { return } // Don't do anything until we've done an initial update of all earlier years for _, yr := range s.GetListOfAoCYears() { if yr == s.GetLatestYear() { continue } if !s.sessionNeedsUpdate { fmt.Printf("Startup: Checking if board needs update (%d)\n", yr) s.AoCSilentBoardCheckAndUpdate(yr) } } for { _, err := s.getChannelId() // This plugin fails without a channel id if err != nil { return } for _, yr := range s.GetListOfAoCYears() { if !s.sessionNeedsUpdate { if s.GetLatestYear() != s.lastYear { // Latest year changed. Grab that board first. s.lastYear = s.GetLatestYear() s.AoCBoardCheckAndUpdate(s.lastYear) time.Sleep(time.Minute) } s.AoCBoardCheckAndUpdate(yr) time.Sleep(time.Minute) } } time.Sleep(time.Minute) } s.model.SendMessage(s.Name(), "main", s.BuildMessage("status", "done", "")) } func (s *AoCState) ProcessDirectMessage(slackMsg slack.Message) { msgPts := strings.Fields(slackMsg.Text) if len(msgPts) < 2 || msgPts[0] != "!aoc" { return } switch msgPts[1] { case "help": s.DoHelpCmd(slackMsg) case "ping": s.DoPingCmd(slackMsg) case "top": s.DoTopCmd(slackMsg) } } func (s *AoCState) ProcessAdminDirectMessage(slackMsg slack.Message) { msgPts := strings.Fields(slackMsg.Text) if len(msgPts) < 2 || msgPts[0] != "!aoc" { return } switch msgPts[1] { case "help": s.DoHelpAdminCmd(slackMsg) case "ping": s.DoPingCmd(slackMsg) case "top": s.DoTopCmd(slackMsg) case "session": s.DoSessionCmd(slackMsg) } } func (s *AoCState) ProcessChannelMessage(slackMsg slack.Message) { msgPts := strings.Fields(slackMsg.Text) if len(msgPts) < 2 || msgPts[0] != "!aoc" { return } switch msgPts[1] { case "top": s.DoTopCmd(slackMsg) } } func (s *AoCState) DoHelpCmd(slackMsg slack.Message) { txt := fmt.Sprint(":christmas_tree: AoC Help :christmas_tree:\n", "-- WiP --", ) s.SendSlackMessage(txt, slackMsg.Channel) } func (s *AoCState) DoHelpAdminCmd(slackMsg slack.Message) { txt := fmt.Sprint(":christmas_tree: AoC Help :christmas_tree:\n", "-- WiP --", ) s.SendSlackMessage(txt, slackMsg.Channel) } func (s *AoCState) DoPingCmd(slackMsg slack.Message) { s.SendSlackMessage(":christmas_tree: PONG :christmas_tree:", slackMsg.Channel) } func (s *AoCState) DoSessionCmd(slackMsg slack.Message) { msgPts := strings.Fields(slackMsg.Text) if len(msgPts) == 3 && msgPts[1] == "session" { // Set the session cookie admin, err := s.model.GetSlackAdminDMId() if err != nil { s.SendAdminIdError() return } aocSession := msgPts[2] s.setAoCSessionCookie(strings.TrimSpace(aocSession)) s.sessionCookie = aocSession s.sessionNeedsUpdate = false s.SendSlackMessage(":christmas_tree: New Session: "+s.sessionCookie, admin) } else if len(msgPts) == 2 && msgPts[1] == "session" { // Print the session cookie admin, err := s.model.GetSlackAdminDMId() if err != nil { s.SendAdminIdError() return } // We only send the session cookie to the admin s.SendSlackMessage(":christmas_tree: session: "+s.sessionCookie, admin) } } func (s *AoCState) DoTopCmd(slackMsg slack.Message) { msgPts := strings.Fields(slackMsg.Text) var err error var yr int if len(msgPts) > 2 { yr, err = strconv.Atoi(msgPts[2]) if err != nil { if msgPts[2] == "all" { yr = -1 } } } else { yr = s.GetLatestYear() } 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.SendSlackMessage(txt, slackMsg.Channel) } 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) AoCSilentBoardCheckAndUpdate(yr int) { if s.AoCBoardNeedsUpdate(yr) { l, err := s.aoc.GetLeaderboard(yr) if err != nil { admin, adminErr := s.model.GetSlackAdminDMId() if adminErr != nil { s.SendAdminIdError() return } if err.Error() == "Invalid Session Cookie" { s.sessionNeedsUpdate = true } s.SendSlackMessage(fmt.Sprintf(":warning: AoC Error processing leaderboard (%d) - %s", yr, err.Error()), admin) return } s.model.SendMessage(s.Name(), "main", s.BuildMessage("success", fmt.Sprintf("Received leaderboard (%d)", yr), "")) // Save the leaderboard to the db s.saveLeaderboard(l) } } func (s *AoCState) AoCBoardCheckAndUpdate(yr int) { stYr := strconv.Itoa(yr) channelId, _ := s.getChannelId() if s.AoCBoardNeedsUpdate(yr) { l, err := s.aoc.GetLeaderboard(yr) if err != nil { admin, adminErr := s.model.GetSlackAdminDMId() if adminErr != nil { s.SendAdminIdError() return } if err.Error() == "Invalid Session Cookie" { s.sessionNeedsUpdate = true } s.SendSlackMessage(fmt.Sprintf(":warning: AoC Error processing leaderboard (%d) - %s", yr, err.Error()), admin) return } s.model.SendMessage(s.Name(), "main", s.BuildMessage("success", fmt.Sprintf("Received leaderboard (%d)", yr), "")) // 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 { plural := "star" if v.Stars > 1 { plural = "stars" } mbrAll := s.getMemberAllYears(v.ID) // Gather all stars from all leaderboards var totalStars int for k, m := range mbrAll { if k != stYr { totalStars += m.Stars } } // Add this new one into the total allYearsText := fmt.Sprintf(" (%d for all years)", totalStars+v.Stars) if yr == s.GetLatestYear() { s.SendSlackMessage(fmt.Sprintf(":christmas_tree: %s now has %d %s! :christmas_tree:%s", v.Name, v.Stars, plural, allYearsText), channelId) } else { s.SendSlackMessage(fmt.Sprintf(":christmas_tree: %s now has %d %s! (%d) :christmas_tree:%s", v.Name, v.Stars, plural, yr, allYearsText), channelId) } } } // Save the leaderboard to the db s.saveLeaderboard(l) } } func (s *AoCState) AoCBoardNeedsUpdate(yr int) bool { var freshDt time.Duration if yr == s.GetLatestYear() { freshDt, _ = time.ParseDuration("15m") // AoC asks that we not update more than once every 15 minutes } else { freshDt, _ = time.ParseDuration("1h") } l, err := s.aoc.GetCachedLeaderboard(yr) if err != nil { if err.Error() == "Invalid Year" { return false } // This board is not cached, we need to pull it return true } return time.Since(l.LastFetch) > freshDt } func (s *AoCState) AoCBoardIsNew(yr int) bool { l, err := s.aoc.GetCachedLeaderboard(yr) if err != nil || l == nil { if err.Error() == "Invalid Year" { return false } return true } return false } 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)) s.sessionCookie = 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)) } // Returns true if we have all AoC years saved to the DB func (s *AoCState) haveAllYearsCached() bool { for _, yr := range s.GetListOfAoCYears() { _, err := s.aoc.GetCachedLeaderboard(yr) if err != nil { return false } } return true } /* 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(), "error", s.BuildMessage("error", fmt.Sprintf("Error Saving Member (%s)", v.Name), "")) } } 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) getMemberAllYears(memberId string) map[string]*aoc.Member { ret := make(map[string]*aoc.Member) for _, yr := range s.GetListOfAoCYears() { stYr := strconv.Itoa(yr) m, err := s.getMember(stYr, memberId) if err == nil { ret[stYr] = m } } return ret } 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 } func (s *AoCState) SendAdminIdError() { s.model.SendMessage(s.Name(), "error", s.BuildMessage("error", "Error getting Admin DM Id", "")) } func (s *AoCState) SendSlackMessage(text, dest string) { s.model.SendMessage(s.Name(), "slack", s.BuildMessage("message", text, dest)) } func (s *AoCState) BuildMessage(tp, text, ch string) slack.Message { ret := slack.Message{} ret.Type = tp ret.Text = text ret.Channel = ch return ret }