shylie/serra
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Trim leading 0 when adding or removing cards as Scryfall don't use them

Browse Source
This commit is contained in:
Corentin Barreau 2023-04-27 12:41:58 +02:00
parent 030bc2c3d8
commit e21e80b4cb
No known key found for this signature in database
GPG Key ID: 924DCF0EF04D31EF
5 changed files with 43 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/serra/add.go
View File

@ -88,8 +88,16 @@ func addCards(cards []string, unique bool, count int64) error {
// Loop over different cards
for _, card := range cards {
// Extract collector number and set name from card input & trim any leading 0 from collector number
collectorNumber := strings.TrimLeft(strings.Split(card, "/")[1], "0")
setName := strings.Split(card, "/")[0]
// Check if card is already in collection
co, _ := coll.storageFind(bson.D{{"set", strings.Split(card, "/")[0]}, {"collectornumber", strings.Split(card, "/")[1]}}, bson.D{})
co, err := coll.storageFind(bson.D{{"set", setName}, {"collectornumber", collectorNumber}}, bson.D{})
if err != nil {
LogMessage(fmt.Sprintf("%v", err), "red")
continue
}
if len(co) >= 1 {
c := co[0]
@ -113,7 +121,7 @@ func addCards(cards []string, unique bool, count int64) error {
// If card is not already in collection, fetching from scyfall
} else {
// Fetch card from scryfall
c, err := fetchCard(card)
c, err := fetchCard(setName, collectorNumber)
if err != nil {
LogMessage(fmt.Sprintf("%v", err), "red")
continue

24
src/serra/missing.go
View File

@ -20,44 +20,46 @@ var missingCmd = &cobra.Command{
Long: `In case you are a set collector, you can generate a list of
cards you dont own (yet) :)`,
SilenceErrors: true,
RunE: func(cmd *cobra.Command, setname []string) error {
RunE: func(cmd *cobra.Command, setName []string) error {
client := storageConnect()
coll := &Collection{client.Database("serra").Collection("cards")}
defer storageDisconnect(client)
// fetch all cards in set
cards, err := coll.storageFind(bson.D{{"set", setname[0]}}, bson.D{{"collectornumber", 1}})
cards, err := coll.storageFind(bson.D{{"set", setName[0]}}, bson.D{{"collectornumber", 1}})
if (err != nil) || len(cards) == 0 {
LogMessage(fmt.Sprintf("Error: Set %s not found or no card in your collection.", setname[0]), "red")
LogMessage(fmt.Sprintf("Error: Set %s not found or no card in your collection.", setName[0]), "red")
return err
}
// fetch set informations
setcoll := &Collection{client.Database("serra").Collection("sets")}
sets, _ := setcoll.storageFindSet(bson.D{{"code", setname[0]}}, bson.D{{"_id", 1}})
sets, _ := setcoll.storageFindSet(bson.D{{"code", setName[0]}}, bson.D{{"_id", 1}})
set := sets[0]
LogMessage(fmt.Sprintf("Missing cards in %s", sets[0].Name), "green")
// generate set with all setnumbers
var complete_set []string
var i int64
var (
completeSet []string
i int64
)
for i = 1; i <= set.CardCount; i++ {
complete_set = append(complete_set, strconv.FormatInt(i, 10))
completeSet = append(completeSet, strconv.FormatInt(i, 10))
}
// iterate over all cards in collection
var in_collection []string
var inCollection []string
for _, c := range cards {
in_collection = append(in_collection, c.CollectorNumber)
inCollection = append(inCollection, c.CollectorNumber)
}
misses := missing(in_collection, complete_set)
misses := missing(inCollection, completeSet)
// Fetch all missing cards
missingCards := []*Card{}
for _, m := range misses {
card, err := fetchCard(fmt.Sprintf("%s/%s", setname[0], m))
card, err := fetchCard(setName[0], m)
if err != nil {
continue
}

11
src/serra/remove.go
View File

@ -36,7 +36,6 @@ var removeCmd = &cobra.Command{
}
func removeCardsInteractive(unique bool, set string) {
if len(set) == 0 {
LogMessage("Error: --set must be given in interactive mode", "red")
os.Exit(1)
@ -64,15 +63,19 @@ func removeCardsInteractive(unique bool, set string) {
}
func removeCards(cards []string, count int64) error {
// Connect to the DB & load the collection
client := storageConnect()
coll := &Collection{client.Database("serra").Collection("cards")}
defer storageDisconnect(client)
// Loop over different cards
for _, card := range cards {
// Extract collector number and set name from input & remove leading zeros
collectorNumber := strings.TrimLeft(strings.Split(card, "/")[1], "0")
setName := strings.Split(card, "/")[0]
// Fetch card from scryfall
c, err := findCardbyCollectornumber(coll, strings.Split(card, "/")[0], strings.Split(card, "/")[1])
c, err := findCardbyCollectornumber(coll, setName, collectorNumber)
if err != nil {
LogMessage(fmt.Sprintf("%v", err), "red")
continue
@ -94,7 +97,7 @@ func removeCards(cards []string, count int64) error {
} else {
modifyCardCount(coll, c, -1, foil)
}
}
return nil
}

12
src/serra/scryfall.go
View File

@ -7,7 +7,6 @@ import (
"io/ioutil"
"log"
"net/http"
"strings"
"time"
"go.mongodb.org/mongo-driver/bson/primitive"
@ -169,20 +168,15 @@ type Set struct {
URI string `json:"uri"`
}
func fetchCard(path string) (*Card, error) {
if !strings.Contains(path, "/") {
return &Card{}, fmt.Errorf("Card must follow format <set>/<number>, for example: ath/15")
}
// TODO better URL Building...
resp, err := http.Get(fmt.Sprintf("https://api.scryfall.com/cards/%s/", path))
func fetchCard(setName, collectorNumber string) (*Card, error) {
resp, err := http.Get(fmt.Sprintf("https://api.scryfall.com/cards/%s/%s/", setName, collectorNumber))
if err != nil {
log.Fatalln(err)
return &Card{}, err
}
if resp.StatusCode != 200 {
return &Card{}, fmt.Errorf("Card %s not found", path)
return &Card{}, fmt.Errorf("Card %s/%s not found", setName, collectorNumber)
}
//We Read the response body on the line below.

20
src/serra/update.go
View File

@ -77,17 +77,17 @@ var updateCmd = &cobra.Command{
)
for _, card := range cards {
bar.Add(1)
updated_card, err := fetchCard(fmt.Sprintf("%s/%s", card.Set, card.CollectorNumber))
updatedCard, err := fetchCard(card.Set, card.CollectorNumber)
if err != nil {
LogMessage(fmt.Sprintf("%v", err), "red")
continue
}
updated_card.Prices.Date = primitive.NewDateTimeFromTime(time.Now())
updatedCard.Prices.Date = primitive.NewDateTimeFromTime(time.Now())
update := bson.M{
"$set": bson.M{"serra_updated": primitive.NewDateTimeFromTime(time.Now()), "prices": updated_card.Prices, "collectornumber": updated_card.CollectorNumber},
"$push": bson.M{"serra_prices": updated_card.Prices},
"$set": bson.M{"serra_updated": primitive.NewDateTimeFromTime(time.Now()), "prices": updatedCard.Prices, "collectornumber": updatedCard.CollectorNumber},
"$push": bson.M{"serra_prices": updatedCard.Prices},
}
coll.storageUpdate(bson.M{"_id": bson.M{"$eq": card.ID}}, update)
}
@ -97,10 +97,10 @@ var updateCmd = &cobra.Command{
// calculate value summary
matchStage := bson.D{{"$match", bson.D{{"set", set.Code}}}}
setvalue, _ := coll.storageAggregate(mongo.Pipeline{matchStage, projectStage, groupStage})
setValue, _ := coll.storageAggregate(mongo.Pipeline{matchStage, projectStage, groupStage})
p := PriceEntry{}
s := setvalue[0]
s := setValue[0]
p.Date = primitive.NewDateTimeFromTime(time.Now())
@ -108,19 +108,19 @@ var updateCmd = &cobra.Command{
mapstructure.Decode(s, &p)
// do the update
set_update := bson.M{
setUpdate := bson.M{
"$set": bson.M{"serra_updated": p.Date},
"$push": bson.M{"serra_prices": p},
}
// fmt.Printf("Set %s%s%s (%s) is now worth %s%.02f EUR%s\n", Pink, set.Name, Reset, set.Code, Yellow, setvalue[0]["value"], Reset)
setscoll.storageUpdate(bson.M{"code": bson.M{"$eq": set.Code}}, set_update)
setscoll.storageUpdate(bson.M{"code": bson.M{"$eq": set.Code}}, setUpdate)
}
totalvalue, _ := coll.storageAggregate(mongo.Pipeline{projectStage, groupStage})
totalValue, _ := coll.storageAggregate(mongo.Pipeline{projectStage, groupStage})
t := PriceEntry{}
t.Date = primitive.NewDateTimeFromTime(time.Now())
mapstructure.Decode(totalvalue[0], &t)
mapstructure.Decode(totalValue[0], &t)
// This is here to be able to fetch currency from
// constructed new priceentry