package database import ( "context" "encoding/gob" "errors" "fmt" "log" "os" "strconv" "sync" "time" "git.yetaga.in/alazyreader/library/media" "github.com/irlndts/go-discogs" ) type DiscogsCache struct { authToken string m sync.Mutex cache []media.Record maxCacheAge time.Duration lastRefresh time.Time client discogs.Discogs username string persistence bool persistFile string } type persistence struct { CachedRecordSlice []media.Record LastRefresh time.Time } func NewDiscogsCache(token string, maxCacheAge time.Duration, username string, persist bool, persistFile string) (*DiscogsCache, error) { client, err := discogs.New(&discogs.Options{ UserAgent: "library.yetaga.in personal collection cache", Token: token, }) if err != nil { return nil, err } cache := &DiscogsCache{ authToken: token, client: client, maxCacheAge: maxCacheAge, username: username, persistence: persist, persistFile: persistFile, } if cache.persistence && cache.persistFile != "" { cache.cache, cache.lastRefresh, err = cache.loadRecordsFromFS(context.Background()) if err != nil { return nil, fmt.Errorf("cache load failed: %w", err) } if time.Now().After(cache.lastRefresh.Add(cache.maxCacheAge)) { log.Printf("cache expired, running refresh...") go func() { err := cache.FlushCache(context.Background()) if err != nil { log.Printf("error loading discogs content: %v", err) } }() } } return cache, nil } func (c *DiscogsCache) FlushCache(ctx context.Context) error { c.m.Lock() defer c.m.Unlock() records, err := c.fetchRecords(ctx, nil) if err != nil { return err } return c.saveRecordsToCache(ctx, records) } func (c *DiscogsCache) GetAllRecords(ctx context.Context) ([]media.Record, error) { c.m.Lock() defer c.m.Unlock() if time.Now().After(c.lastRefresh.Add(c.maxCacheAge)) { records, err := c.fetchRecords(ctx, nil) if err != nil { return c.cache, err } err = c.saveRecordsToCache(ctx, records) return c.cache, err } return c.cache, nil } func (c *DiscogsCache) loadRecordsFromFS(ctx context.Context) ([]media.Record, time.Time, error) { p := &persistence{} f, err := os.Open(c.persistFile) if errors.Is(err, os.ErrNotExist) { log.Printf("%s not found, skipping file load...", c.persistFile) return nil, time.Time{}, nil } if err != nil { return nil, time.Time{}, fmt.Errorf("error opening cache file %s: %w", c.persistFile, err) } err = gob.NewDecoder(f).Decode(p) if err != nil { return nil, time.Time{}, fmt.Errorf("error readhing from cache file %s: %w", c.persistFile, err) } log.Printf("loaded %d records from %s", len(p.CachedRecordSlice), c.persistFile) return p.CachedRecordSlice, p.LastRefresh, nil } func (c *DiscogsCache) saveRecordsToCache(ctx context.Context, records []media.Record) error { c.cache = records c.lastRefresh = time.Now() if c.persistence && c.persistFile != "" { p := persistence{ CachedRecordSlice: c.cache, LastRefresh: c.lastRefresh, } f, err := os.OpenFile(c.persistFile, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0755) if err != nil { return fmt.Errorf("error opening cache file %s: %w", c.persistFile, err) } err = gob.NewEncoder(f).Encode(p) if err != nil { return fmt.Errorf("error writing to cache file %s: %w", c.persistFile, err) } log.Printf("wrote %d records to %s", len(c.cache), c.persistFile) } return nil } func (c *DiscogsCache) fetchRecords(ctx context.Context, pagination *discogs.Pagination) ([]media.Record, error) { records := []media.Record{} if pagination == nil { pagination = getPagination(1) } log.Printf("calling discogs API, page %v", pagination.Page) coll, err := c.client.CollectionItemsByFolder(c.username, 0, pagination) if err != nil { return records, fmt.Errorf("error loading collection: %w", err) } log.Printf("length: %v, first item in list: %s", len(coll.Items), coll.Items[0].BasicInformation.Title) for i := range coll.Items { records = append(records, collectionItemToRecord(&coll.Items[i])) } // recurse down the list if coll.Pagination.URLs.Next != "" { coll, err := c.fetchRecords(ctx, getPagination(pagination.Page+1)) if err != nil { return records, err } records = append(records, coll...) } return records, nil } func getPagination(page int) *discogs.Pagination { return &discogs.Pagination{Page: page, Sort: "added", SortOrder: "asc", PerPage: 100} } func collectionItemToRecord(item *discogs.CollectionItemSource) media.Record { artists := []string{} for _, artist := range item.BasicInformation.Artists { artists = append(artists, artist.Name) } year := strconv.Itoa(item.BasicInformation.Year) if year == "0" { year = "" } return media.Record{ ID: item.ID, AlbumName: item.BasicInformation.Title, Artists: artists, Identifier: item.BasicInformation.Labels[0].Catno, Format: item.BasicInformation.Formats[0].Name, Genre: item.BasicInformation.Genres[0], Label: item.BasicInformation.Labels[0].Name, Year: year, CoverURL: item.BasicInformation.CoverImage, DiscogsURL: fmt.Sprintf("https://www.discogs.com/release/%v", item.ID), } }