Updates

Also custom errors

aoc.go

@@ -2,12 +2,10 @@ package aoc
 
 import (
 	"encoding/json"
-	"errors"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"strconv"
-	"strings"
 	"time"
 )
 
@@ -15,14 +13,16 @@ type AoC struct {
 	session string
 	boardId string
 	boards  map[int]*Leaderboard
+
+	sessionErr bool
 }
 
 func NewAoC(boardId, session string) (*AoC, error) {
 	if boardId == "" {
-		return nil, errors.New("Board ID is required")
+		return nil, BoardIdRequiredError
 	}
 	if session == "" {
-		return nil, errors.New("Session key is required")
+		return nil, SessionRequiredError
 	}
 	return &AoC{
 		session: session,
@@ -31,22 +31,42 @@ func NewAoC(boardId, session string) (*AoC, error) {
 	}, nil
 }
 
+func (a *AoC) GetSession() string { return a.session }
+func (a *AoC) SetSession(session string) {
+	a.session = session
+	a.sessionErr = false
+}
+func (a *AoC) NeedsNewSession() bool { return a.sessionErr }
+
+func (a *AoC) SetCachedLeaderboard(l *Leaderboard) error {
+	yr, err := strconv.Atoi(l.Event)
+	if err != nil {
+		return InvalidYearError
+	}
+
+	a.boards[yr] = l
+	return nil
+}
+
 func (a *AoC) GetCachedLeaderboard(year int) (*Leaderboard, error) {
 	if year < 2015 || year > time.Now().Year() {
-		return nil, errors.New("Invalid Year")
+		return nil, InvalidYearError
 	}
 	if board, ok := a.boards[year]; ok {
 		return board, nil
 	}
-	return nil, errors.New(fmt.Sprintf("Leaderboard (%d) is not cached", year))
+	return nil, LeaderboardNotCachedError
 }
 
 func (a *AoC) GetLeaderboard(year int) (*Leaderboard, error) {
 	if year < 2015 || year > time.Now().Year() {
-		return nil, errors.New("Invalid Year")
+		return nil, InvalidYearError
+	}
+	if a.sessionErr {
+		return nil, SessionError
 	}
 	if board, ok := a.boards[year]; ok {
-		if time.Since(board.LastFetch) < (time.Minute * 10) {
+		if time.Since(board.LastFetch) < (time.Minute * 15) {
 			return board, nil
 		}
 	}
@@ -54,7 +74,8 @@ func (a *AoC) GetLeaderboard(year int) (*Leaderboard, error) {
 	a.boards[year], err = a.fetchLeaderboard(year)
 	if err != nil {
 		if err.Error() == "invalid character '<' looking for beginning of value" {
-			return nil, errors.New("Invalid Session Cookie")
+			a.sessionErr = true
+			return nil, SessionError
 		}
 		return nil, err
 	}
@@ -72,23 +93,27 @@ func (a *AoC) fetchLeaderboard(year int) (*Leaderboard, error) {
 	client := &http.Client{}
 	boardString := fmt.Sprintf("https://adventofcode.com/%d/leaderboard/private/view/%s.json", year, a.boardId)
 	req, err = http.NewRequest("GET", boardString, nil)
+	if err != nil {
+		return nil, err
+	}
 	req.Header.Add("Cookie", "session="+a.session)
 	resp, err = client.Do(req)
 	if err != nil {
 		return nil, err
 	}
 	defer resp.Body.Close()
-	body, err = ioutil.ReadAll(resp.Body)
+	body, err = io.ReadAll(resp.Body)
 	if err != nil {
 		return nil, err
 	}
 	strBody := string(body)
-	strBody = strings.ReplaceAll(strBody, "\"last_star_ts\":\"0\"", "\"last_star_ts\":0")
 	err = json.Unmarshal([]byte(strBody), &leaderboard)
 	if err != nil {
-		fmt.Println("Error parsing board")
-		fmt.Println(err)
-		return nil, err
+		if err.Error() == "invalid character '<' looking for beginning of value" {
+			a.sessionErr = true
+			return nil, SessionError
+		}
+		return nil, fmt.Errorf("error parsing board: %w", err)
 	}
 	for k, mbr := range leaderboard.Members {
 		starTs, err := strconv.ParseInt(mbr.RawStarTs, 10, 64)
@@ -104,14 +129,14 @@ func (a *AoC) fetchLeaderboard(year int) (*Leaderboard, error) {
 }
 
 type Leaderboard struct {
-	OwnerID   string            `json:"owner_id"`
+	OwnerID   int               `json:"owner_id"`
 	Event     string            `json:"event"`
 	Members   map[string]Member `json:"members"`
 	LastFetch time.Time
 }
 
 type Member struct {
-	ID          string `json:"id"`
+	ID          int    `json:"id"`
 	Name        string `json:"name"`
 	Stars       int    `json:"stars"`
 	RawStarTs   string `json:"last_star_ts"`
@@ -143,3 +168,33 @@ func (a ByStarsThenScore) Less(i, j int) bool {
 	}
 	return a[i].Stars < a[j].Stars
 }
+
+func (m *Member) UnmarshalJSON(data []byte) error {
+	var v map[string]interface{}
+	var err error
+
+	if err = json.Unmarshal(data, &v); err != nil {
+		return err
+	}
+	m.ID = int(v["id"].(float64))
+	m.Name = v["name"].(string)
+	m.Stars = int(v["stars"].(float64))
+
+	switch v["last_star_ts"].(type) {
+	case float64:
+		m.RawStarTs = fmt.Sprintf("%d", int(v["last_star_ts"].(float64)))
+	case int:
+		m.RawStarTs = strconv.Itoa(v["last_star_ts"].(int))
+	case string:
+		m.RawStarTs = v["last_star_ts"].(string)
+	default:
+		m.RawStarTs = "0"
+	}
+	starTs, err := strconv.ParseInt(m.RawStarTs, 10, 64)
+	if err != nil {
+		starTs = 0
+	}
+	m.LastStarTs = time.Unix(starTs, 0)
+
+	return nil
+}

aoc_errors.go

@@ -0,0 +1,13 @@
+package aoc
+
+import (
+	"errors"
+)
+
+var (
+	SessionRequiredError      = errors.New("session key is required")
+	SessionError              = errors.New("invalid session")
+	BoardIdRequiredError      = errors.New("board id is required")
+	InvalidYearError          = errors.New("invalid year")
+	LeaderboardNotCachedError = errors.New("leaderboard is not cached")
+)

cmd/main.go

@@ -16,7 +16,7 @@ func main() {
 	if err != nil {
 		panic(err)
 	}
-	l, err := a.GetLeaderboard(2020)
+	l, err := a.GetLeaderboard(2021)
 	if err != nil {
 		fmt.Println(err)
 		os.Exit(1)