catch session expirations and fail gracefully

refactor guild configuration to support future features

start building snapshots for future "Christmas in July" event

Author: Alextopher

Diff for: advent-of-code.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"fmt"
 	"log"
 	"net/http"
 	"net/url"
@@ -15,39 +16,42 @@ const userAgent = "github.com/Alextopher/aocbot"
 type AdventOfCode struct {
 	sync.RWMutex
 
-	year          string
 	id            string
 	sessionCookie string
 
-	leaderboard *Leaderboard
-	lastUpdated time.Time
+	leaderboards map[string]*Leaderboard
+	lastUpdated  time.Time
 }
 
 // NewAdventOfCode creates a new Advent of Code API
-func NewAdventOfCode(sessionCookie string, year string, id string) *AdventOfCode {
+func NewAdventOfCode(sessionCookie string, id string) *AdventOfCode {
 	return &AdventOfCode{
 		sessionCookie: sessionCookie,
-		year:          year,
+		leaderboards:  make(map[string]*Leaderboard),
 		id:            id,
 	}
 }
 
 // GetLeaderboard gets the most recent leaderboard data from the API
-func (aoc *AdventOfCode) GetLeaderboard() *Leaderboard {
+func (aoc *AdventOfCode) GetLeaderboard(year string) *Leaderboard {
 	if time.Since(aoc.lastUpdated) > 15*time.Minute {
-		aoc.UpdateLeaderboard()
+		aoc.UpdateLeaderboard(year)
 	}
 
 	aoc.RLock()
-	leaderboard := aoc.leaderboard
+	leaderboard, ok := aoc.leaderboards[year]
+	if !ok {
+		log.Println("Leaderboard not found for year: ", year)
+	}
 	aoc.RUnlock()
 
 	return leaderboard
 }
 
 // UpdateLeaderboard updates a leaderboard by getting the latest data from the API
-func (aoc *AdventOfCode) UpdateLeaderboard() error {
-	requestURL := "https://adventofcode.com/" + aoc.year + "/leaderboard/private/view/" + aoc.id + ".json"
+func (aoc *AdventOfCode) UpdateLeaderboard(year string) error {
+	requestURL := "https://adventofcode.com/" + year + "/leaderboard/private/view/" + aoc.id + ".json"
+	fmt.Println(requestURL)
 
 	url, err := url.Parse(requestURL)
 	if err != nil {
@@ -70,17 +74,23 @@ func (aoc *AdventOfCode) UpdateLeaderboard() error {
 		return err
 	}
 
+	// Check the content type of the response, if it's not JSON then we can't parse it
+	contentType := response.Header.Get("Content-Type")
+	if contentType != "application/json" {
+		return ErrInvalidSession
+	}
+
 	leaderboard, err := ParseLeaderboard(response.Body)
 	if err != nil {
 		log.Println("Error while parsing response: ", err)
 		return err
 	}
 
 	aoc.Lock()
-	aoc.leaderboard = leaderboard
+	aoc.leaderboards[year] = leaderboard
 	aoc.lastUpdated = time.Now()
 	aoc.Unlock()
 
-	log.Println("Updated leaderboard for (" + aoc.year + ", " + aoc.id + ")")
+	log.Printf("Updated leaderboard for (%s, %s)\n", aoc.id, year)
 	return nil
 }

Diff for: bot.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"log"
 	"os"
+	"time"
 
 	"github.com/bwmarrin/discordgo"
 )
@@ -30,19 +31,19 @@ func NewBot(session *discordgo.Session, sessionCookie string) *Bot {
 }
 
 // AddGuild adds a guild to the bot
-func (bot *Bot) AddGuild(guildID string, year string, leaderboardID string) (err error) {
+func (bot *Bot) AddGuild(guildID string, guildConfig GuildConfig) (err error) {
 	// Create guild logFile file
 	logFile, err := os.OpenFile(fmt.Sprintf("logs/%s.db", guildID), os.O_APPEND|os.O_CREATE|os.O_RDWR, 0644)
 	if err != nil {
 		return err
 	}
 
-	bot.states[guildID], err = NewGuildState(bot.sessionCookie, year, leaderboardID, logFile)
+	bot.states[guildID], err = NewGuildState(bot.sessionCookie, guildConfig, logFile)
 	if err != nil {
 		return err
 	}
 
-	return bot.states[guildID].adventOfCode.UpdateLeaderboard()
+	return bot.states[guildID].adventOfCode.UpdateLeaderboard(guildConfig.Year)
 }
 
 // Start starts the bot (and waits for it to be ready)
@@ -80,6 +81,12 @@ func (bot *Bot) Sync() {
 func (bot *Bot) CreateRoles(guild *discordgo.Guild) error {
 	True := true
 
+	// Get the guild state
+	guildState, ok := bot.states[guild.ID]
+	if !ok {
+		return ErrNotConfigured
+	}
+
 	// Spoiler role (allows users to access all channels)
 	if !bot.CheckRole(guild, "Spoiler") {
 		_, err := bot.session.GuildRoleCreate(guild.ID, &discordgo.RoleParams{
@@ -117,16 +124,18 @@ func (bot *Bot) CreateRoles(guild *discordgo.Guild) error {
 		}
 	}
 
-	for i := 25; i > 0; i-- {
-		name := fmt.Sprintf("Day %02d", i)
+	if guildState.daily_roles {
+		for i := 25; i > 0; i-- {
+			name := fmt.Sprintf("Day %02d", i)
 
-		if !bot.CheckRole(guild, name) {
-			_, err := bot.session.GuildRoleCreate(guild.ID, &discordgo.RoleParams{
-				Name: name,
-			})
+			if !bot.CheckRole(guild, name) {
+				_, err := bot.session.GuildRoleCreate(guild.ID, &discordgo.RoleParams{
+					Name: name,
+				})
 
-			if err != nil {
-				return err
+				if err != nil {
+					return err
+				}
 			}
 		}
 	}
@@ -203,7 +212,7 @@ func (bot *Bot) SyncMemberRoles(guild *discordgo.Guild, guildMember *discordgo.M
 		return ErrDoesNotExist
 	}
 
-	return bot.syncRoles(guild, guildMember, member)
+	return bot.syncRoles(guild, guildMember, member, guildState.daily_roles)
 }
 
 // SyncAllRoles updates each user's roles to reflect their current star count.
@@ -216,6 +225,7 @@ func (bot *Bot) SyncAllRoles(guild *discordgo.Guild) error {
 	// Get the leaderboard
 	leaderboard := guildState.GetLeaderboard()
 
+	log.Printf("Syncing roles for %s %t\n", guild.Name, guildState.daily_roles)
 	guildState.db.GoForEach(func(discord_id, advent_id string) {
 		member, ok := leaderboard.GetMemberByID(advent_id)
 		if !ok {
@@ -230,7 +240,7 @@ func (bot *Bot) SyncAllRoles(guild *discordgo.Guild) error {
 			return
 		}
 
-		err = bot.syncRoles(guild, guildMember, member)
+		err = bot.syncRoles(guild, guildMember, member, guildState.daily_roles)
 		if err != nil {
 			return
 		}
@@ -240,7 +250,7 @@ func (bot *Bot) SyncAllRoles(guild *discordgo.Guild) error {
 }
 
 // syncRoles reduces code duplication between SyncRoles and SyncAllRoles
-func (bot *Bot) syncRoles(guild *discordgo.Guild, guildMember *discordgo.Member, member *Member) error {
+func (bot *Bot) syncRoles(guild *discordgo.Guild, guildMember *discordgo.Member, member *Member, daily_roles bool) error {
 	stars := member.Stars
 
 	// 10, 20, 30, 40, 50 stars
@@ -251,6 +261,7 @@ func (bot *Bot) syncRoles(guild *discordgo.Guild, guildMember *discordgo.Member,
 			log.Println("Error (syncRoles) adding/removing role: ", err)
 			return err
 		}
+		time.Sleep(1 * time.Second)
 	}
 
 	// Connected
@@ -264,11 +275,12 @@ func (bot *Bot) syncRoles(guild *discordgo.Guild, guildMember *discordgo.Member,
 	for day := 1; day <= 25; day++ {
 		role := fmt.Sprintf("Day %02d", day)
 		shouldAdd := member.CompletionDayLevel[day] != nil && len(member.CompletionDayLevel[day]) > 0
-		err := bot.AddOrRemoveRole(guild, guildMember, role, shouldAdd)
+		err := bot.AddOrRemoveRole(guild, guildMember, role, shouldAdd && daily_roles)
 		if err != nil {
 			log.Println("Error (syncRoles) adding/removing role: ", err)
 			return err
 		}
+		time.Sleep(1 * time.Second)
 	}
 
 	return nil

Diff for: config.go

@@ -5,6 +5,14 @@ import (
 	"io"
 )
 
+// GuildConfig is the config per guild
+type GuildConfig struct {
+	Year          string `json:"year"`
+	Mode          string `json:"mode"`
+	LeaderboardID string `json:"leaderboard_id"`
+	DailyRoles    bool   `json:"daily_roles"`
+}
+
 // Config is the bot config
 type Config struct {
 	// The Discord bot token
@@ -14,11 +22,7 @@ type Config struct {
 	SessionCookie string `json:"session_cookie"`
 
 	// Map guild ids to (year, leaderboard id) pairs
-	Guilds map[string]struct {
-		Year          string `json:"year"`
-		LeaderboardID string `json:"leaderboard_id"`
-		DailyRoles    bool   `json:"daily_roles"`
-	} `json:"guilds"`
+	Guilds map[string]GuildConfig `json:"guilds"`
 }
 
 // ParseConfig parses a config file

Diff for: db.go

@@ -8,8 +8,9 @@ import (
 
 // DatabaseEvent is a single database event
 type DatabaseEvent struct {
-	Create *EventCreate `json:"create,omitempty"`
-	Delete *EventDelete `json:"delete,omitempty"`
+	Create   *EventCreate   `json:"create,omitempty"`
+	Delete   *EventDelete   `json:"delete,omitempty"`
+	Snapshot *EventSnapshot `json:"snapshot,omitempty"`
 }
 
 // EventCreate is a database event for creating a claim
@@ -42,18 +43,38 @@ func NewEventDelete(discordID string) *DatabaseEvent {
 	}
 }
 
-// Keeps an append-only log file of user claims
-// (basically keeps a persistent map[string]string)
+// EventSnapshot is a database event for taking a snapshot of the total scores
+type EventSnapshot struct {
+	Timestamp int64          `json:"timestamp"`
+	Scores    map[string]int `json:"scores"`
+}
+
+// NewEventSnapshot creates a new database event for taking a snapshot of the total scores
+func NewEventSnapshot(timestamp int64, scores map[string]int) *DatabaseEvent {
+	return &DatabaseEvent{
+		Snapshot: &EventSnapshot{
+			Timestamp: timestamp,
+			Scores:    scores,
+		},
+	}
+}
 
-// Database keeps an append-only log file of user name claims and unclaims
+// Database keeps an append-only log file of bot operation
+//
+// - tracks APOD id claims
+// - tracks APOD id unclaims
+// - creates APOD total score snapshots
 type Database struct {
 	sync.RWMutex
 
-	// Where to write new events to
+	// Where we write new events to
 	writer *json.Encoder
 
 	// In-memory, per guild, mapping of discord ids to Advent of Code ids
 	mappings map[string]string
+
+	// Timestamped snapshot of total scores
+	scores map[string]int
 }
 
 // NewDatabase creates a new database
@@ -62,6 +83,7 @@ func NewDatabase(reader io.Reader, writer io.Writer) (*Database, error) {
 	database := &Database{
 		writer:   json.NewEncoder(writer),
 		mappings: make(map[string]string),
+		scores:   make(map[string]int),
 	}
 
 	decoder := json.NewDecoder(reader)
@@ -165,6 +187,34 @@ func (database *Database) CheckClaim(adventID string) bool {
 	return false
 }
 
+// Snapshot takes a snapshot of the total scores
+func (database *Database) Snapshot(timestamp int64, scores map[string]int) error {
+	database.Lock()
+
+	// Take a snapshot of the total scores
+	database.scores = scores
+
+	// Write the event to the database
+	err := database.writer.Encode(NewEventSnapshot(timestamp, scores))
+
+	database.Unlock()
+	return err
+}
+
+// GetScores gets the change in total scores since the last snapshot
+func (database *Database) GetScores(currentScores map[string]int) map[string]int {
+	database.RLock()
+
+	// Get the change in total scores
+	scores := make(map[string]int)
+	for id, score := range currentScores {
+		scores[id] = score - database.scores[id]
+	}
+
+	database.RUnlock()
+	return scores
+}
+
 // GoForEach iterates over each claim and calls a function
 func (database *Database) GoForEach(fn func(discord_id, advent_id string)) {
 	database.RLock()

Diff for: main.go

@@ -39,7 +39,7 @@ func main() {
 
 	// Add guilds
 	for guildID, guildConfig := range config.Guilds {
-		err = bot.AddGuild(guildID, guildConfig.Year, guildConfig.LeaderboardID)
+		err = bot.AddGuild(guildID, guildConfig)
 		if err != nil {
 			log.Fatalln("Error adding guild: ", err)
 		}

Diff for: state.go

@@ -15,22 +15,29 @@ var ErrAlreadyClaimed = errors.New("user is already claimed")
 // ErrDoesNotExist is returned when a user does not exist
 var ErrDoesNotExist = errors.New("user does not exist")
 
+// ErrInvalidSession is returned when the advent of code session is invalid
+var ErrInvalidSession = errors.New("advent of code session has expired, please update the session cookie")
+
 // GuildState keeps track of the state of a single guild
 type GuildState struct {
 	adventOfCode *AdventOfCode
 	db           *Database
+	year         string
+	daily_roles  bool
 }
 
 // NewGuildState creates a new guild state
-func NewGuildState(sessionCookie, year, id string, log *os.File) (*GuildState, error) {
+func NewGuildState(sessionCookie string, config GuildConfig, log *os.File) (*GuildState, error) {
 	database, err := NewDatabase(log, log)
 	if err != nil {
 		return nil, err
 	}
 
 	return &GuildState{
-		adventOfCode: NewAdventOfCode(sessionCookie, year, id),
+		adventOfCode: NewAdventOfCode(sessionCookie, config.LeaderboardID),
 		db:           database,
+		year:         config.Year,
+		daily_roles:  config.DailyRoles,
 	}, nil
 }
 
@@ -90,11 +97,11 @@ func (guildState *GuildState) CloseNames(username string) ([]string, error) {
 
 // GetLeaderboard is wrapper for guildState.adventOfCode.GetLeaderboard()
 func (guildState *GuildState) GetLeaderboard() *Leaderboard {
-	return guildState.adventOfCode.GetLeaderboard()
+	return guildState.adventOfCode.GetLeaderboard(guildState.year)
 }
 
 // UpdateLeaderboard updates the leaderboard before returning it
 func (guildState *GuildState) UpdateLeaderboard() *Leaderboard {
-	guildState.adventOfCode.UpdateLeaderboard()
-	return guildState.adventOfCode.GetLeaderboard()
+	guildState.adventOfCode.UpdateLeaderboard(guildState.year)
+	return guildState.adventOfCode.GetLeaderboard(guildState.year)
 }