2024-09-05 11:56:51 +00:00
|
|
|
package main
|
|
|
|
|
|
|
|
import (
|
2024-09-05 17:07:14 +00:00
|
|
|
"encoding/csv"
|
|
|
|
"encoding/gob"
|
|
|
|
"encoding/json"
|
2024-09-05 11:56:51 +00:00
|
|
|
"errors"
|
2024-09-05 17:07:14 +00:00
|
|
|
"flag"
|
2024-09-05 11:56:51 +00:00
|
|
|
"fmt"
|
|
|
|
"os"
|
2024-09-05 17:07:14 +00:00
|
|
|
"strconv"
|
2024-09-05 11:56:51 +00:00
|
|
|
"strings"
|
2024-09-05 17:07:14 +00:00
|
|
|
"time"
|
2024-09-05 11:56:51 +00:00
|
|
|
|
2024-09-05 17:07:14 +00:00
|
|
|
"github.com/hrfee/go-discogs"
|
2024-09-05 11:56:51 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
var (
|
|
|
|
CURRENCY = "GBP"
|
|
|
|
USER_AGENT = "discogs-pricer/0.0 +https://git.hrfee.pw/hrfee/discogs-pricer"
|
2024-09-05 17:07:14 +00:00
|
|
|
|
|
|
|
STORE = "./collection.gob"
|
|
|
|
|
|
|
|
PER_PAGE = 75
|
|
|
|
|
|
|
|
NotesFieldID = 4 // Test, otherwise use 3
|
|
|
|
|
|
|
|
noPaToken = errors.New(`put "hrfee:<personal access token>" in ./personal_access_token and re-run.`)
|
2024-09-05 11:56:51 +00:00
|
|
|
)
|
|
|
|
|
2024-09-05 17:07:14 +00:00
|
|
|
type ItemHash string
|
2024-09-05 11:56:51 +00:00
|
|
|
|
|
|
|
type Client struct {
|
2024-09-05 17:07:14 +00:00
|
|
|
Username string
|
|
|
|
c discogs.Discogs
|
|
|
|
StorePath string
|
|
|
|
CollectionCache struct {
|
|
|
|
Items map[ItemHash]CollectionItem // Hash of a load of IDs to Collection Item
|
|
|
|
Order []ItemHash
|
|
|
|
}
|
2024-09-05 11:56:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-05 17:07:14 +00:00
|
|
|
func NewClient(currency string, userAgent string, username, token string, storePath string) (*Client, error) {
|
|
|
|
client := Client{Username: username, StorePath: storePath}
|
2024-09-05 11:56:51 +00:00
|
|
|
var err error
|
|
|
|
client.c, err = discogs.New(&discogs.Options{
|
|
|
|
UserAgent: userAgent,
|
|
|
|
Currency: currency,
|
|
|
|
Token: token,
|
2024-09-05 17:07:14 +00:00
|
|
|
// URL: "http://localhost:8097",
|
2024-09-05 11:56:51 +00:00
|
|
|
})
|
2024-09-05 17:07:14 +00:00
|
|
|
if err == nil {
|
|
|
|
client.ClearCollectionCache()
|
|
|
|
err = client.ReadCollectionCache()
|
|
|
|
}
|
2024-09-05 11:56:51 +00:00
|
|
|
return &client, err
|
|
|
|
}
|
|
|
|
|
2024-09-05 17:07:14 +00:00
|
|
|
// Items, error, and whether or not there's more pages to go.
|
|
|
|
func (c *Client) collection(pageNo int, allocate bool) ([]discogs.CollectionItemSource, error, bool) {
|
|
|
|
fmt.Printf("Getting collection page %d for user %s\n", pageNo, c.Username)
|
|
|
|
cf, err := c.c.CollectionItemsByFolder(c.Username, 0, &discogs.Pagination{
|
|
|
|
Sort: "added",
|
|
|
|
SortOrder: "asc",
|
|
|
|
Page: pageNo,
|
|
|
|
PerPage: PER_PAGE,
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
return []discogs.CollectionItemSource{}, err, false
|
|
|
|
}
|
|
|
|
if allocate {
|
|
|
|
c.CollectionCache.Order = make([]ItemHash, 0, cf.Pagination.Pages*PER_PAGE)
|
|
|
|
}
|
|
|
|
return cf.Items, err, cf.Pagination.Page < cf.Pagination.Pages
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Client) ClearCollectionCache() {
|
|
|
|
c.CollectionCache.Order = []ItemHash{}
|
|
|
|
c.CollectionCache.Items = map[ItemHash]CollectionItem{}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Client) PopulateCollectionCache() error {
|
|
|
|
more := true
|
|
|
|
var err error
|
|
|
|
var p []discogs.CollectionItemSource
|
|
|
|
i := 0
|
|
|
|
for more {
|
|
|
|
p, err, more = c.collection(i, i == 0)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
for i := range p {
|
|
|
|
ci := CollectionItem{p[i]}
|
|
|
|
hash := ci.Hash()
|
|
|
|
if _, ok := c.CollectionCache.Items[hash]; ok {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
c.CollectionCache.Order = append(c.CollectionCache.Order, hash)
|
|
|
|
c.CollectionCache.Items[hash] = ci
|
|
|
|
}
|
|
|
|
i++
|
|
|
|
}
|
|
|
|
return c.StoreCollectionCache()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Client) StoreCollectionCache() error {
|
|
|
|
file, err := os.Create(c.StorePath)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer file.Close()
|
|
|
|
enc := gob.NewEncoder(file)
|
|
|
|
return enc.Encode(c.CollectionCache)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Client) ReadCollectionCache() error {
|
|
|
|
file, err := os.Open(c.StorePath)
|
|
|
|
if err != nil {
|
|
|
|
if errors.Is(err, os.ErrNotExist) {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer file.Close()
|
|
|
|
dec := gob.NewDecoder(file)
|
|
|
|
return dec.Decode(&c.CollectionCache)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Client) CollectionJSON() (string, error) {
|
|
|
|
if c.CollectionCache.Order == nil || len(c.CollectionCache.Order) == 0 {
|
|
|
|
if err := c.PopulateCollectionCache(); err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
if err := c.StoreCollectionCache(); err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
v, _ := json.MarshalIndent(c.CollectionCache.Items, "", "\t")
|
|
|
|
return string(v), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Client) WriteCSVTemplate(path string) error {
|
|
|
|
if c.CollectionCache.Order == nil || len(c.CollectionCache.Order) == 0 {
|
|
|
|
if err := c.PopulateCollectionCache(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if err := c.StoreCollectionCache(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
file, err := os.Create(path)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer file.Close()
|
|
|
|
w := csv.NewWriter(file)
|
|
|
|
w.Write(HeaderRow)
|
|
|
|
for _, ciHash := range c.CollectionCache.Order {
|
|
|
|
w.Write(c.CollectionCache.Items[ciHash].RowFromCollectionItem())
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *Client) TestEditField() {
|
|
|
|
err := c.c.EditFieldsInstance(c.Username, 1, 10191384, 313879623, discogs.NotesField, "a new 2nd value!")
|
|
|
|
fmt.Printf("Error: %v\n", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
var HeaderRow = strings.Split(
|
|
|
|
"Folder ID,Release ID,Instance ID,Artist - Name,Date Added,Price,Purchased Date,Additional Notes",
|
|
|
|
",",
|
|
|
|
)
|
|
|
|
|
|
|
|
type CollectionItem struct {
|
|
|
|
discogs.CollectionItemSource
|
|
|
|
}
|
|
|
|
|
|
|
|
// Not a real hash, but identifies a record uniquely enough.
|
|
|
|
func (ci CollectionItem) Hash() ItemHash {
|
|
|
|
return ItemHash(strconv.Itoa(ci.ID) + "|" + strconv.Itoa(ci.InstanceID))
|
|
|
|
}
|
|
|
|
|
|
|
|
func ParseTime(t string) (time.Time, error) {
|
|
|
|
return time.Parse("2006-01-02T15:04:05-07:00", t)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ci CollectionItem) RawNotes() string {
|
|
|
|
notes := ""
|
|
|
|
for _, n := range ci.Notes {
|
|
|
|
if n.FieldID == discogs.NotesField {
|
|
|
|
notes = n.Value
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return notes
|
|
|
|
}
|
|
|
|
|
|
|
|
type ParsedNotes struct {
|
|
|
|
Price string
|
|
|
|
PurchaseDate time.Time
|
|
|
|
Additional string
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ci CollectionItem) ParseNotes() ParsedNotes {
|
|
|
|
notes := ci.RawNotes()
|
|
|
|
pn := ParsedNotes{}
|
|
|
|
dateString := ""
|
|
|
|
n, err := fmt.Sscanf(notes, "Purchase Price: %s, Purchase Date: %s.%s", &(pn.Price), &dateString, &(pn.Additional))
|
|
|
|
if n <= 0 || err != nil {
|
|
|
|
pn.Additional = notes
|
|
|
|
}
|
|
|
|
pn.PurchaseDate, err = time.Parse("2006-01-02", dateString)
|
|
|
|
if err != nil || dateString == "" || pn.PurchaseDate.IsZero() {
|
|
|
|
pn.PurchaseDate, _ = ParseTime(ci.DateAdded)
|
|
|
|
}
|
|
|
|
return pn
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ci CollectionItem) RowFromCollectionItem() []string {
|
|
|
|
dateAdded, err := ParseTime(ci.DateAdded)
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
notes := ci.ParseNotes()
|
|
|
|
row := []string{
|
|
|
|
strconv.Itoa(ci.FolderID),
|
|
|
|
strconv.Itoa(ci.ID),
|
|
|
|
strconv.Itoa(ci.InstanceID),
|
|
|
|
ci.BasicInformation.Artists[0].Name + " - " + ci.BasicInformation.Title,
|
|
|
|
dateAdded.Format("2006-01-02"),
|
|
|
|
notes.Price,
|
|
|
|
notes.PurchaseDate.Format("2006-01-02"),
|
|
|
|
notes.Additional,
|
|
|
|
}
|
|
|
|
return row
|
|
|
|
}
|
|
|
|
|
2024-09-05 11:56:51 +00:00
|
|
|
func main() {
|
2024-09-05 17:07:14 +00:00
|
|
|
patContent, err := os.ReadFile("personal_access_token")
|
2024-09-05 11:56:51 +00:00
|
|
|
if err != nil {
|
2024-09-05 17:07:14 +00:00
|
|
|
panic(noPaToken)
|
|
|
|
}
|
|
|
|
userAndToken := strings.Split(string(patContent), ":")
|
|
|
|
if len(userAndToken) != 2 {
|
|
|
|
panic(noPaToken)
|
|
|
|
}
|
|
|
|
|
|
|
|
c, err := NewClient(CURRENCY, USER_AGENT, userAndToken[0], strings.TrimSuffix(string(userAndToken[1]), "\n"), STORE)
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
reloadCollection := false
|
|
|
|
printCollection := false
|
|
|
|
csvTemplatePath := ""
|
|
|
|
flag.BoolVar(&reloadCollection, "reload", false, "pass to force reload of collection cache.")
|
|
|
|
flag.BoolVar(&printCollection, "print", false, "pass to print JSON representation of collection.")
|
|
|
|
flag.StringVar(&csvTemplatePath, "template", "", "filepath to write template csv to.")
|
|
|
|
|
|
|
|
flag.Parse()
|
|
|
|
|
|
|
|
args := false
|
|
|
|
flag.Visit(func(*flag.Flag) { args = true })
|
|
|
|
if !args {
|
|
|
|
flag.Usage()
|
2024-09-05 11:56:51 +00:00
|
|
|
}
|
2024-09-05 17:07:14 +00:00
|
|
|
|
|
|
|
if reloadCollection {
|
|
|
|
c.ClearCollectionCache()
|
|
|
|
if err := c.PopulateCollectionCache(); err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if printCollection {
|
|
|
|
v, err := c.CollectionJSON()
|
|
|
|
if err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
fmt.Println(v)
|
|
|
|
}
|
|
|
|
|
|
|
|
if csvTemplatePath != "" {
|
|
|
|
if err := c.WriteCSVTemplate(csvTemplatePath); err != nil {
|
|
|
|
panic(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// c.TestEditField()
|
2024-09-05 11:56:51 +00:00
|
|
|
}
|