Set Cache

Also custom errors

aoc.go

@@ -2,12 +2,10 @@ package aoc
 
 import (
 	"encoding/json"
-	"errors"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"strconv"
-	"strings"
 	"time"
 )
 
@@ -19,10 +17,10 @@ type AoC struct {
 
 func NewAoC(boardId, session string) (*AoC, error) {
 	if boardId == "" {
-		return nil, errors.New("Board ID is required")
+		return nil, new(BoardIdRequiredError)
 	}
 	if session == "" {
-		return nil, errors.New("Session key is required")
+		return nil, new(SessionRequiredError)
 	}
 	return &AoC{
 		session: session,
@@ -31,22 +29,32 @@ func NewAoC(boardId, session string) (*AoC, error) {
 	}, nil
 }
 
+func (a *AoC) SetCachedLeaderboard(l *Leaderboard) error {
+	yr, err := strconv.Atoi(l.Event)
+	if err != nil {
+		return new(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, new(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{year: year}
 }
 
 func (a *AoC) GetLeaderboard(year int) (*Leaderboard, error) {
 	if year < 2015 || year > time.Now().Year() {
-		return nil, errors.New("Invalid Year")
+		return nil, new(InvalidYearError)
 	}
 	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 +62,7 @@ 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")
+			return nil, new(SessionError)
 		}
 		return nil, err
 	}
@@ -78,17 +86,15 @@ func (a *AoC) fetchLeaderboard(year int) (*Leaderboard, error) {
 		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")
+	// 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")
+		return nil, fmt.Errorf("error parsing board: %w", err)
-		fmt.Println(err)
-		return nil, err
 	}
 	for k, mbr := range leaderboard.Members {
 		starTs, err := strconv.ParseInt(mbr.RawStarTs, 10, 64)
@@ -104,14 +110,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 +149,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,35 @@
+package aoc
+
+import "fmt"
+
+type SessionRequiredError struct{}
+
+func (e SessionRequiredError) Error() string {
+	return "session key is required"
+}
+
+type SessionError struct{}
+
+func (e SessionError) Error() string {
+	return "invalid session"
+}
+
+type BoardIdRequiredError struct{}
+
+func (e BoardIdRequiredError) Error() string {
+	return "board id is required"
+}
+
+type InvalidYearError struct{}
+
+func (e InvalidYearError) Error() string {
+	return "invalid year"
+}
+
+type LeaderboardNotCachedError struct {
+	year int
+}
+
+func (e LeaderboardNotCachedError) Error() string {
+	return fmt.Sprintf("leaderboard (%d) is not cached", e.year)
+}

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)