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

Get rid of the python person I was :P

Browse Source
This commit is contained in:
Florian Baumann 2023-04-26 12:46:57 +02:00
parent 27be6bf772
commit af8a6af2ec
10 changed files with 85 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/serra/add.go
View File

@ -82,14 +82,14 @@ func addCardsInteractive(unique bool, set string) {
} }
func addCards(cards []string, unique bool, count int64) error { func addCards(cards []string, unique bool, count int64) error {
client := storage_connect() client := storageConnect()
coll := &Collection{client.Database("serra").Collection("cards")} coll := &Collection{client.Database("serra").Collection("cards")}
defer storage_disconnect(client) defer storageDisconnect(client)
// Loop over different cards // Loop over different cards
for _, card := range cards { for _, card := range cards {
// Check if card is already in collection // Check if card is already in collection
co, _ := coll.storage_find(bson.D{{"set", strings.Split(card, "/")[0]}, {"collectornumber", strings.Split(card, "/")[1]}}, bson.D{}) co, _ := coll.storageFind(bson.D{{"set", strings.Split(card, "/")[0]}, {"collectornumber", strings.Split(card, "/")[1]}}, bson.D{})
if len(co) >= 1 { if len(co) >= 1 {
c := co[0] c := co[0]
@ -99,7 +99,7 @@ func addCards(cards []string, unique bool, count int64) error {
continue continue
} }
modify_count_of_card(coll, &c, count, foil) modifyCardCount(coll, &c, count, foil)
var total int64 = 0 var total int64 = 0
if foil { if foil {
@ -128,7 +128,7 @@ func addCards(cards []string, unique bool, count int64) error {
c.SerraCount = count c.SerraCount = count
total = c.SerraCount total = c.SerraCount
} }
err = coll.storage_add(c) err = coll.storageAdd(c)
if err != nil { if err != nil {
LogMessage(fmt.Sprintf("%v", err), "red") LogMessage(fmt.Sprintf("%v", err), "red")
continue continue
@ -138,6 +138,6 @@ func addCards(cards []string, unique bool, count int64) error {
LogMessage(fmt.Sprintf("%dx \"%s\" (%s, %.2f%s) added to Collection.", total, c.Name, c.Rarity, c.getValue(foil), getCurrency()), "green") LogMessage(fmt.Sprintf("%dx \"%s\" (%s, %.2f%s) added to Collection.", total, c.Name, c.Rarity, c.getValue(foil), getCurrency()), "green")
} }
} }
storage_disconnect(client) storageDisconnect(client)
return nil return nil
} }

22
src/serra/card.go
View File

@ -31,7 +31,7 @@ otherwise you'll get a list of cards as a search result.`,
RunE: func(cmd *cobra.Command, cards []string) error { RunE: func(cmd *cobra.Command, cards []string) error {
if len(cards) == 0 { if len(cards) == 0 {
card_list := Cards(rarity, set, sortby, name, oracle, cardType) card_list := Cards(rarity, set, sortby, name, oracle, cardType)
show_card_list(card_list, detail) showCardList(card_list, detail)
} else { } else {
ShowCard(cards) ShowCard(cards)
} }
@ -40,9 +40,9 @@ otherwise you'll get a list of cards as a search result.`,
} }
func ShowCard(cardids []string) { func ShowCard(cardids []string) {
client := storage_connect() client := storageConnect()
coll := &Collection{client.Database("serra").Collection("cards")} coll := &Collection{client.Database("serra").Collection("cards")}
defer storage_disconnect(client) defer storageDisconnect(client)
for _, v := range cardids { for _, v := range cardids {
if len(strings.Split(v, "/")) < 2 || strings.Split(v, "/")[1] == "" { if len(strings.Split(v, "/")) < 2 || strings.Split(v, "/")[1] == "" {
@ -50,18 +50,18 @@ func ShowCard(cardids []string) {
continue continue
} }
cards, _ := coll.storage_find(bson.D{{"set", strings.Split(v, "/")[0]}, {"collectornumber", strings.Split(v, "/")[1]}}, bson.D{{"name", 1}}) cards, _ := coll.storageFind(bson.D{{"set", strings.Split(v, "/")[0]}, {"collectornumber", strings.Split(v, "/")[1]}}, bson.D{{"name", 1}})
for _, card := range cards { for _, card := range cards {
show_card_details(&card) showCardDetails(&card)
} }
} }
} }
func Cards(rarity, set, sortby, name, oracle, cardType string) []Card { func Cards(rarity, set, sortby, name, oracle, cardType string) []Card {
client := storage_connect() client := storageConnect()
coll := &Collection{client.Database("serra").Collection("cards")} coll := &Collection{client.Database("serra").Collection("cards")}
defer storage_disconnect(client) defer storageDisconnect(client)
filter := bson.D{} filter := bson.D{}
@ -108,7 +108,7 @@ func Cards(rarity, set, sortby, name, oracle, cardType string) []Card {
filter = append(filter, bson.E{"typeline", bson.D{{"$regex", ".*" + cardType + ".*"}, {"$options", "i"}}}) filter = append(filter, bson.E{"typeline", bson.D{{"$regex", ".*" + cardType + ".*"}, {"$options", "i"}}})
} }
cards, _ := coll.storage_find(filter, sortStage) cards, _ := coll.storageFind(filter, sortStage)
// This is needed because collectornumbers are strings (ie. "23a") but still we // This is needed because collectornumbers are strings (ie. "23a") but still we
// want it to be sorted numerically ... 1,2,3,10,11,100. // want it to be sorted numerically ... 1,2,3,10,11,100.
@ -121,7 +121,7 @@ func Cards(rarity, set, sortby, name, oracle, cardType string) []Card {
return cards return cards
} }
func show_card_list(cards []Card, detail bool) { func showCardList(cards []Card, detail bool) {
var total float64 var total float64
if detail { if detail {
@ -140,7 +140,7 @@ func show_card_list(cards []Card, detail bool) {
} }
func show_card_details(card *Card) error { func showCardDetails(card *Card) error {
fmt.Printf("%s%s%s (%s/%s)\n", Purple, card.Name, Reset, card.Set, card.CollectorNumber) fmt.Printf("%s%s%s (%s/%s)\n", Purple, card.Name, Reset, card.Set, card.CollectorNumber)
fmt.Printf("Added: %s\n", stringToTime(card.SerraCreated)) fmt.Printf("Added: %s\n", stringToTime(card.SerraCreated))
fmt.Printf("Rarity: %s\n", card.Rarity) fmt.Printf("Rarity: %s\n", card.Rarity)
@ -153,7 +153,7 @@ func show_card_details(card *Card) error {
} }
fmt.Printf("\n%sValue History%s\n", Green, Reset) fmt.Printf("\n%sValue History%s\n", Green, Reset)
print_price_history(card.SerraPrices, "* ", false) showPriceHistory(card.SerraPrices, "* ", false)
fmt.Println() fmt.Println()
return nil return nil
} }

8
src/serra/gains.go
View File

@ -43,10 +43,10 @@ var flopsCmd = &cobra.Command{
func Gains(limit float64, sort int) error { func Gains(limit float64, sort int) error {
client := storage_connect() client := storageConnect()
coll := &Collection{client.Database("serra").Collection("cards")} coll := &Collection{client.Database("serra").Collection("cards")}
setcoll := &Collection{client.Database("serra").Collection("sets")} setcoll := &Collection{client.Database("serra").Collection("sets")}
defer storage_disconnect(client) defer storageDisconnect(client)
var old int var old int
if sinceBeginning { if sinceBeginning {
@ -109,7 +109,7 @@ func Gains(limit float64, sort int) error {
bson.D{{"rate", sort}}}}, bson.D{{"rate", sort}}}},
bson.D{{"$limit", 20}}, bson.D{{"$limit", 20}},
} }
raise, _ := coll.storage_aggregate(raise_pipeline) raise, _ := coll.storageAggregate(raise_pipeline)
sraise_pipeline := mongo.Pipeline{ sraise_pipeline := mongo.Pipeline{
bson.D{{"$project", bson.D{{"$project",
@ -157,7 +157,7 @@ func Gains(limit float64, sort int) error {
bson.D{{"rate", sort}}}}, bson.D{{"rate", sort}}}},
bson.D{{"$limit", 10}}, bson.D{{"$limit", 10}},
} }
sraise, _ := setcoll.storage_aggregate(sraise_pipeline) sraise, _ := setcoll.storageAggregate(sraise_pipeline)
// percentage coloring // percentage coloring
var p_color string var p_color string

20
src/serra/helpers.go
View File

@ -16,12 +16,12 @@ type Rarities struct {
Rares, Uncommons, Commons, Mythics float64 Rares, Uncommons, Commons, Mythics float64
} }
func modify_count_of_card(coll *Collection, c *Card, amount int64, foil bool) error { func modifyCardCount(coll *Collection, c *Card, amount int64, foil bool) error {
// find already existing card // find already existing card
sort := bson.D{{"_id", 1}} sort := bson.D{{"_id", 1}}
search_filter := bson.D{{"_id", c.ID}} search_filter := bson.D{{"_id", c.ID}}
stored_cards, err := coll.storage_find(search_filter, sort) stored_cards, err := coll.storageFind(search_filter, sort)
if err != nil { if err != nil {
return err return err
} }
@ -40,7 +40,7 @@ func modify_count_of_card(coll *Collection, c *Card, amount int64, foil bool) er
} }
} }
coll.storage_update(update_filter, update) coll.storageUpdate(update_filter, update)
var total int64 var total int64
if foil { if foil {
@ -52,11 +52,11 @@ func modify_count_of_card(coll *Collection, c *Card, amount int64, foil bool) er
return nil return nil
} }
func find_card_by_setcollectornumber(coll *Collection, setcode string, collectornumber string) (*Card, error) { func findCardbyCollectornumber(coll *Collection, setcode string, collectornumber string) (*Card, error) {
sort := bson.D{{"_id", 1}} sort := bson.D{{"_id", 1}}
search_filter := bson.D{{"set", setcode}, {"collectornumber", collectornumber}} search_filter := bson.D{{"set", setcode}, {"collectornumber", collectornumber}}
stored_cards, err := coll.storage_find(search_filter, sort) stored_cards, err := coll.storageFind(search_filter, sort)
if err != nil { if err != nil {
return &Card{}, err return &Card{}, err
} }
@ -91,9 +91,9 @@ func missing(a, b []string) []string {
return diffs return diffs
} }
func find_set_by_code(coll *Collection, setcode string) (*Set, error) { func findSetByCode(coll *Collection, setcode string) (*Set, error) {
stored_sets, err := coll.storage_find_set(bson.D{{"code", setcode}}, bson.D{{"_id", 1}}) stored_sets, err := coll.storageFindSet(bson.D{{"code", setcode}}, bson.D{{"_id", 1}})
if err != nil { if err != nil {
return &Set{}, err return &Set{}, err
} }
@ -105,7 +105,7 @@ func find_set_by_code(coll *Collection, setcode string) (*Set, error) {
return &stored_sets[0], nil return &stored_sets[0], nil
} }
func convert_mana_symbols(sym []interface{}) string { func convertManaSymbols(sym []interface{}) string {
var mana string var mana string
if len(sym) == 0 { if len(sym) == 0 {
@ -136,7 +136,7 @@ func convert_mana_symbols(sym []interface{}) string {
} }
func convert_rarities(rar []primitive.M) Rarities { func convertRarities(rar []primitive.M) Rarities {
// this is maybe the ugliest way someone could choose to verify, if a rarity type is missing // this is maybe the ugliest way someone could choose to verify, if a rarity type is missing
// [ // [
@ -163,7 +163,7 @@ func convert_rarities(rar []primitive.M) Rarities {
} }
func print_price_history(prices []PriceEntry, prefix string, total bool) { func showPriceHistory(prices []PriceEntry, prefix string, total bool) {
var before float64 var before float64
for _, e := range prices { for _, e := range prices {

8
src/serra/missing.go
View File

@ -21,12 +21,12 @@ var missingCmd = &cobra.Command{
cards you dont own (yet) :)`, cards you dont own (yet) :)`,
SilenceErrors: true, SilenceErrors: true,
RunE: func(cmd *cobra.Command, setname []string) error { RunE: func(cmd *cobra.Command, setname []string) error {
client := storage_connect() client := storageConnect()
coll := &Collection{client.Database("serra").Collection("cards")} coll := &Collection{client.Database("serra").Collection("cards")}
defer storage_disconnect(client) defer storageDisconnect(client)
// fetch all cards in set // fetch all cards in set
cards, err := coll.storage_find(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 { 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 return err
@ -34,7 +34,7 @@ cards you dont own (yet) :)`,
// fetch set informations // fetch set informations
setcoll := &Collection{client.Database("serra").Collection("sets")} setcoll := &Collection{client.Database("serra").Collection("sets")}
sets, _ := setcoll.storage_find_set(bson.D{{"code", setname[0]}}, bson.D{{"_id", 1}}) sets, _ := setcoll.storageFindSet(bson.D{{"code", setname[0]}}, bson.D{{"_id", 1}})
set := sets[0] set := sets[0]
LogMessage(fmt.Sprintf("Missing cards in %s", sets[0].Name), "green") LogMessage(fmt.Sprintf("Missing cards in %s", sets[0].Name), "green")

10
src/serra/remove.go
View File

@ -65,14 +65,14 @@ func removeCardsInteractive(unique bool, set string) {
func removeCards(cards []string, count int64) error { func removeCards(cards []string, count int64) error {
client := storage_connect() client := storageConnect()
coll := &Collection{client.Database("serra").Collection("cards")} coll := &Collection{client.Database("serra").Collection("cards")}
defer storage_disconnect(client) defer storageDisconnect(client)
// Loop over different cards // Loop over different cards
for _, card := range cards { for _, card := range cards {
// Fetch card from scryfall // Fetch card from scryfall
c, err := find_card_by_setcollectornumber(coll, strings.Split(card, "/")[0], strings.Split(card, "/")[1]) c, err := findCardbyCollectornumber(coll, strings.Split(card, "/")[0], strings.Split(card, "/")[1])
if err != nil { if err != nil {
LogMessage(fmt.Sprintf("%v", err), "red") LogMessage(fmt.Sprintf("%v", err), "red")
continue continue
@ -89,10 +89,10 @@ func removeCards(cards []string, count int64) error {
} }
if foil && c.SerraCountFoil == 1 && c.SerraCount == 0 || !foil && c.SerraCount == 1 && c.SerraCountFoil == 0 { if foil && c.SerraCountFoil == 1 && c.SerraCount == 0 || !foil && c.SerraCount == 1 && c.SerraCountFoil == 0 {
coll.storage_remove(bson.M{"_id": c.ID}) coll.storageRemove(bson.M{"_id": c.ID})
LogMessage(fmt.Sprintf("\"%s\" (%.2f%s) removed from the Collection.", c.Name, c.getValue(foil), getCurrency()), "green") LogMessage(fmt.Sprintf("\"%s\" (%.2f%s) removed from the Collection.", c.Name, c.getValue(foil), getCurrency()), "green")
} else { } else {
modify_count_of_card(coll, c, -1, foil) modifyCardCount(coll, c, -1, foil)
} }
} }

30
src/serra/set.go
View File

@ -25,7 +25,7 @@ otherwise you'll get a list of sets as a search result.`,
RunE: func(cmd *cobra.Command, set []string) error { RunE: func(cmd *cobra.Command, set []string) error {
if len(set) == 0 { if len(set) == 0 {
setList := Sets(sortby) setList := Sets(sortby)
show_set_list(setList) showSetList(setList)
} else { } else {
ShowSet(set[0]) ShowSet(set[0])
} }
@ -35,9 +35,9 @@ otherwise you'll get a list of sets as a search result.`,
func Sets(sort string) []primitive.M { func Sets(sort string) []primitive.M {
client := storage_connect() client := storageConnect()
coll := &Collection{client.Database("serra").Collection("cards")} coll := &Collection{client.Database("serra").Collection("cards")}
defer storage_disconnect(client) defer storageDisconnect(client)
groupStage := bson.D{ groupStage := bson.D{
{"$group", bson.D{ {"$group", bson.D{
@ -65,18 +65,18 @@ func Sets(sort string) []primitive.M {
}}} }}}
} }
sets, _ := coll.storage_aggregate(mongo.Pipeline{groupStage, sortStage}) sets, _ := coll.storageAggregate(mongo.Pipeline{groupStage, sortStage})
return sets return sets
} }
func show_set_list(sets []primitive.M) { func showSetList(sets []primitive.M) {
client := storage_connect() client := storageConnect()
setscoll := &Collection{client.Database("serra").Collection("sets")} setscoll := &Collection{client.Database("serra").Collection("sets")}
for _, set := range sets { for _, set := range sets {
setobj, _ := find_set_by_code(setscoll, set["code"].(string)) setobj, _ := findSetByCode(setscoll, set["code"].(string))
fmt.Printf("* %s %s%s%s (%s%s%s)\n", set["release"].(string)[0:4], Purple, set["_id"], Reset, Cyan, set["code"], Reset) fmt.Printf("* %s %s%s%s (%s%s%s)\n", set["release"].(string)[0:4], Purple, set["_id"], Reset, Cyan, set["code"], Reset)
fmt.Printf(" Cards: %s%d/%d%s Total: %.0f \n", Yellow, set["unique"], setobj.CardCount, Reset, set["count"]) fmt.Printf(" Cards: %s%d/%d%s Total: %.0f \n", Yellow, set["unique"], setobj.CardCount, Reset, set["count"])
fmt.Printf(" Value: %s%.2f%s%s\n", Pink, set["value"], getCurrency(), Reset) fmt.Printf(" Value: %s%.2f%s%s\n", Pink, set["value"], getCurrency(), Reset)
@ -86,16 +86,16 @@ func show_set_list(sets []primitive.M) {
func ShowSet(setname string) error { func ShowSet(setname string) error {
client := storage_connect() client := storageConnect()
coll := &Collection{client.Database("serra").Collection("cards")} coll := &Collection{client.Database("serra").Collection("cards")}
defer storage_disconnect(client) defer storageDisconnect(client)
// fetch all cards in set ordered by currently used currency // fetch all cards in set ordered by currently used currency
cardSortCurrency := bson.D{{"prices.usd", -1}} cardSortCurrency := bson.D{{"prices.usd", -1}}
if getCurrency() == "EUR" { if getCurrency() == "EUR" {
cardSortCurrency = bson.D{{"prices.eur", -1}} cardSortCurrency = bson.D{{"prices.eur", -1}}
} }
cards, err := coll.storage_find(bson.D{{"set", setname}}, cardSortCurrency) cards, err := coll.storageFind(bson.D{{"set", setname}}, cardSortCurrency)
if (err != nil) || len(cards) == 0 { if (err != nil) || len(cards) == 0 {
LogMessage(fmt.Sprintf("Error: Set %s not found or no card in your collection.", setname), "red") LogMessage(fmt.Sprintf("Error: Set %s not found or no card in your collection.", setname), "red")
return err return err
@ -103,7 +103,7 @@ func ShowSet(setname string) error {
// fetch set informations // fetch set informations
setcoll := &Collection{client.Database("serra").Collection("sets")} setcoll := &Collection{client.Database("serra").Collection("sets")}
sets, _ := setcoll.storage_find_set(bson.D{{"code", setname}}, bson.D{{"_id", 1}}) sets, _ := setcoll.storageFindSet(bson.D{{"code", setname}}, bson.D{{"_id", 1}})
// set values // set values
matchStage := bson.D{ matchStage := bson.D{
@ -119,7 +119,7 @@ func ShowSet(setname string) error {
{"count", bson.D{{"$sum", bson.D{{"$multiply", bson.A{1.0, "$serra_count"}}}}}}, {"count", bson.D{{"$sum", bson.D{{"$multiply", bson.A{1.0, "$serra_count"}}}}}},
}}, }},
} }
stats, _ := coll.storage_aggregate(mongo.Pipeline{matchStage, groupStage}) stats, _ := coll.storageAggregate(mongo.Pipeline{matchStage, groupStage})
// set rarities // set rarities
matchStage = bson.D{ matchStage = bson.D{
@ -137,9 +137,9 @@ func ShowSet(setname string) error {
{"$sort", bson.D{ {"$sort", bson.D{
{"_id", 1}, {"_id", 1},
}}} }}}
rar, _ := coll.storage_aggregate(mongo.Pipeline{matchStage, groupStage, sortStage}) rar, _ := coll.storageAggregate(mongo.Pipeline{matchStage, groupStage, sortStage})
ri := convert_rarities(rar) ri := convertRarities(rar)
LogMessage(fmt.Sprintf("%s", sets[0].Name), "green") LogMessage(fmt.Sprintf("%s", sets[0].Name), "green")
LogMessage(fmt.Sprintf("Set Cards: %d/%d", len(cards), sets[0].CardCount), "normal") LogMessage(fmt.Sprintf("Set Cards: %d/%d", len(cards), sets[0].CardCount), "normal")
@ -162,7 +162,7 @@ func ShowSet(setname string) error {
LogMessage(fmt.Sprintf("Uncommons: %.0f", ri.Uncommons), "normal") LogMessage(fmt.Sprintf("Uncommons: %.0f", ri.Uncommons), "normal")
LogMessage(fmt.Sprintf("Commons: %.0f", ri.Commons), "normal") LogMessage(fmt.Sprintf("Commons: %.0f", ri.Commons), "normal")
fmt.Printf("\n%sPrice History:%s\n", Pink, Reset) fmt.Printf("\n%sPrice History:%s\n", Pink, Reset)
print_price_history(sets[0].SerraPrices, "* ", true) showPriceHistory(sets[0].SerraPrices, "* ", true)
fmt.Printf("\n%sMost valuable cards%s\n", Pink, Reset) fmt.Printf("\n%sMost valuable cards%s\n", Pink, Reset)

20
src/serra/stats.go
View File

@ -20,12 +20,12 @@ var statsCmd = &cobra.Command{
SilenceErrors: true, SilenceErrors: true,
RunE: func(cmd *cobra.Command, args []string) error { RunE: func(cmd *cobra.Command, args []string) error {
client := storage_connect() client := storageConnect()
coll := &Collection{client.Database("serra").Collection("cards")} coll := &Collection{client.Database("serra").Collection("cards")}
totalcoll := &Collection{client.Database("serra").Collection("total")} totalcoll := &Collection{client.Database("serra").Collection("total")}
defer storage_disconnect(client) defer storageDisconnect(client)
sets, _ := coll.storage_aggregate(mongo.Pipeline{ sets, _ := coll.storageAggregate(mongo.Pipeline{
bson.D{ bson.D{
{"$match", bson.D{ {"$match", bson.D{
{"coloridentity", bson.D{{"$size", 1}}}}}}, {"coloridentity", bson.D{{"$size", 1}}}}}},
@ -43,10 +43,10 @@ var statsCmd = &cobra.Command{
for _, set := range sets { for _, set := range sets {
x, _ := set["_id"].(primitive.A) x, _ := set["_id"].(primitive.A)
s := []interface{}(x) s := []interface{}(x)
fmt.Printf("%s: %s%.0f%s\n", convert_mana_symbols(s), Purple, set["count"], Reset) fmt.Printf("%s: %s%.0f%s\n", convertManaSymbols(s), Purple, set["count"], Reset)
} }
stats, _ := coll.storage_aggregate(mongo.Pipeline{ stats, _ := coll.storageAggregate(mongo.Pipeline{
bson.D{ bson.D{
{"$group", bson.D{ {"$group", bson.D{
{"_id", nil}, {"_id", nil},
@ -73,7 +73,7 @@ var statsCmd = &cobra.Command{
fmt.Printf("Foil: %s%d%s\n", Purple, stats[0]["count_foil"], Reset) fmt.Printf("Foil: %s%d%s\n", Purple, stats[0]["count_foil"], Reset)
fmt.Printf("Etched: %s%d%s\n", Purple, stats[0]["count_etched"], Reset) fmt.Printf("Etched: %s%d%s\n", Purple, stats[0]["count_etched"], Reset)
reserved, _ := coll.storage_aggregate(mongo.Pipeline{ reserved, _ := coll.storageAggregate(mongo.Pipeline{
bson.D{ bson.D{
{"$match", bson.D{ {"$match", bson.D{
{"reserved", true}}}}, {"reserved", true}}}},
@ -90,7 +90,7 @@ var statsCmd = &cobra.Command{
} }
fmt.Printf("Reserved List: %s%d%s\n", Yellow, count_reserved, Reset) fmt.Printf("Reserved List: %s%d%s\n", Yellow, count_reserved, Reset)
rar, _ := coll.storage_aggregate(mongo.Pipeline{ rar, _ := coll.storageAggregate(mongo.Pipeline{
bson.D{ bson.D{
{"$group", bson.D{ {"$group", bson.D{
{"_id", "$rarity"}, {"_id", "$rarity"},
@ -101,7 +101,7 @@ var statsCmd = &cobra.Command{
{"_id", 1}, {"_id", 1},
}}}, }}},
}) })
ri := convert_rarities(rar) ri := convertRarities(rar)
fmt.Printf("\n%sRarity%s\n", Green, Reset) fmt.Printf("\n%sRarity%s\n", Green, Reset)
fmt.Printf("Mythics: %s%.0f%s\n", Pink, ri.Mythics, Reset) fmt.Printf("Mythics: %s%.0f%s\n", Pink, ri.Mythics, Reset)
fmt.Printf("Rares: %s%.0f%s\n", Pink, ri.Rares, Reset) fmt.Printf("Rares: %s%.0f%s\n", Pink, ri.Rares, Reset)
@ -123,10 +123,10 @@ var statsCmd = &cobra.Command{
fmt.Printf("Total: %s%.2f%s%s\n", Pink, total_value, getCurrency(), Reset) fmt.Printf("Total: %s%.2f%s%s\n", Pink, total_value, getCurrency(), Reset)
fmt.Printf("Normal: %s%.2f%s%s\n", Pink, nf_value, getCurrency(), Reset) fmt.Printf("Normal: %s%.2f%s%s\n", Pink, nf_value, getCurrency(), Reset)
fmt.Printf("Foils: %s%.2f%s%s\n", Pink, foil_value, getCurrency(), Reset) fmt.Printf("Foils: %s%.2f%s%s\n", Pink, foil_value, getCurrency(), Reset)
total, _ := totalcoll.storage_find_total() total, _ := totalcoll.storageFindTotal()
fmt.Printf("History: \n") fmt.Printf("History: \n")
print_price_history(total.Value, "* ", true) showPriceHistory(total.Value, "* ", true)
return nil return nil
}, },
} }

22
src/serra/storage.go
View File

@ -45,7 +45,7 @@ func getCurrencyField(foil bool) string {
} }
} }
func storage_connect() *mongo.Client { func storageConnect() *mongo.Client {
uri := getMongoDBURI() uri := getMongoDBURI()
client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(uri)) client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(uri))
@ -58,7 +58,7 @@ func storage_connect() *mongo.Client {
} }
func (coll Collection) storage_add(card *Card) error { func (coll Collection) storageAdd(card *Card) error {
card.SerraUpdated = primitive.NewDateTimeFromTime(time.Now()) card.SerraUpdated = primitive.NewDateTimeFromTime(time.Now())
@ -70,7 +70,7 @@ func (coll Collection) storage_add(card *Card) error {
} }
func (coll Collection) storage_add_set(set *Set) (*mongo.InsertOneResult, error) { func (coll Collection) storageAddSet(set *Set) (*mongo.InsertOneResult, error) {
id, err := coll.InsertOne(context.TODO(), set) id, err := coll.InsertOne(context.TODO(), set)
if err != nil { if err != nil {
@ -80,7 +80,7 @@ func (coll Collection) storage_add_set(set *Set) (*mongo.InsertOneResult, error)
} }
func (coll Collection) storage_add_total(p PriceEntry) error { func (coll Collection) storageAddTotal(p PriceEntry) error {
// create total object if not exists... // create total object if not exists...
coll.InsertOne(context.TODO(), Total{ID: "1", Value: []PriceEntry{}}) coll.InsertOne(context.TODO(), Total{ID: "1", Value: []PriceEntry{}})
@ -101,7 +101,7 @@ func (coll Collection) storage_add_total(p PriceEntry) error {
return nil return nil
} }
func (coll Collection) storage_find(filter, sort bson.D) ([]Card, error) { func (coll Collection) storageFind(filter, sort bson.D) ([]Card, error) {
opts := options.Find().SetSort(sort) opts := options.Find().SetSort(sort)
cursor, err := coll.Find(context.TODO(), filter, opts) cursor, err := coll.Find(context.TODO(), filter, opts)
@ -119,7 +119,7 @@ func (coll Collection) storage_find(filter, sort bson.D) ([]Card, error) {
} }
func (coll Collection) storage_find_set(filter, sort bson.D) ([]Set, error) { func (coll Collection) storageFindSet(filter, sort bson.D) ([]Set, error) {
opts := options.Find().SetSort(sort) opts := options.Find().SetSort(sort)
cursor, err := coll.Find(context.TODO(), filter, opts) cursor, err := coll.Find(context.TODO(), filter, opts)
@ -137,7 +137,7 @@ func (coll Collection) storage_find_set(filter, sort bson.D) ([]Set, error) {
} }
func (coll Collection) storage_find_total() (Total, error) { func (coll Collection) storageFindTotal() (Total, error) {
var total Total var total Total
err := coll.FindOne(context.TODO(), bson.D{{"_id", "1"}}).Decode(&total) err := coll.FindOne(context.TODO(), bson.D{{"_id", "1"}}).Decode(&total)
@ -150,7 +150,7 @@ func (coll Collection) storage_find_total() (Total, error) {
} }
func (coll Collection) storage_remove(filter bson.M) error { func (coll Collection) storageRemove(filter bson.M) error {
_, err := coll.DeleteOne(context.TODO(), filter) _, err := coll.DeleteOne(context.TODO(), filter)
if err != nil { if err != nil {
@ -161,7 +161,7 @@ func (coll Collection) storage_remove(filter bson.M) error {
} }
func (coll Collection) storage_aggregate(pipeline mongo.Pipeline) ([]primitive.M, error) { func (coll Collection) storageAggregate(pipeline mongo.Pipeline) ([]primitive.M, error) {
opts := options.Aggregate() opts := options.Aggregate()
cursor, err := coll.Aggregate( cursor, err := coll.Aggregate(
@ -184,7 +184,7 @@ func (coll Collection) storage_aggregate(pipeline mongo.Pipeline) ([]primitive.M
} }
func (coll Collection) storage_update(filter, update bson.M) error { func (coll Collection) storageUpdate(filter, update bson.M) error {
// Call the driver's UpdateOne() method and pass filter and update to it // Call the driver's UpdateOne() method and pass filter and update to it
_, err := coll.UpdateOne( _, err := coll.UpdateOne(
@ -200,7 +200,7 @@ func (coll Collection) storage_update(filter, update bson.M) error {
return nil return nil
} }
func storage_disconnect(client *mongo.Client) error { func storageDisconnect(client *mongo.Client) error {
if err := client.Disconnect(context.TODO()); err != nil { if err := client.Disconnect(context.TODO()); err != nil {
return err return err
} }

18
src/serra/update.go
View File

@ -24,8 +24,8 @@ var updateCmd = &cobra.Command{
SilenceErrors: true, SilenceErrors: true,
RunE: func(cmd *cobra.Command, args []string) error { RunE: func(cmd *cobra.Command, args []string) error {
client := storage_connect() client := storageConnect()
defer storage_disconnect(client) defer storageDisconnect(client)
// update sets // update sets
setscoll := &Collection{client.Database("serra").Collection("sets")} setscoll := &Collection{client.Database("serra").Collection("sets")}
@ -55,9 +55,9 @@ var updateCmd = &cobra.Command{
// When downloading new sets, PriceList needs to be initialized // When downloading new sets, PriceList needs to be initialized
// This query silently fails if set was already downloaded. Not nice but ok for now. // This query silently fails if set was already downloaded. Not nice but ok for now.
set.SerraPrices = []PriceEntry{} set.SerraPrices = []PriceEntry{}
setscoll.storage_add_set(&set) setscoll.storageAddSet(&set)
cards, _ := coll.storage_find(bson.D{{"set", set.Code}}, bson.D{{"_id", 1}}) cards, _ := coll.storageFind(bson.D{{"set", set.Code}}, bson.D{{"_id", 1}})
// if no cards in collection for this set, skip it // if no cards in collection for this set, skip it
if len(cards) == 0 { if len(cards) == 0 {
@ -91,7 +91,7 @@ var updateCmd = &cobra.Command{
"$set": bson.M{"serra_updated": primitive.NewDateTimeFromTime(time.Now()), "prices": updated_card.Prices, "collectornumber": updated_card.CollectorNumber}, "$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}, "$push": bson.M{"serra_prices": updated_card.Prices},
} }
coll.storage_update(bson.M{"_id": bson.M{"$eq": card.ID}}, update) coll.storageUpdate(bson.M{"_id": bson.M{"$eq": card.ID}}, update)
} }
fmt.Println() fmt.Println()
@ -99,7 +99,7 @@ var updateCmd = &cobra.Command{
// calculate value summary // calculate value summary
matchStage := bson.D{{"$match", bson.D{{"set", set.Code}}}} matchStage := bson.D{{"$match", bson.D{{"set", set.Code}}}}
setvalue, _ := coll.storage_aggregate(mongo.Pipeline{matchStage, projectStage, groupStage}) setvalue, _ := coll.storageAggregate(mongo.Pipeline{matchStage, projectStage, groupStage})
p := PriceEntry{} p := PriceEntry{}
s := setvalue[0] s := setvalue[0]
@ -115,10 +115,10 @@ var updateCmd = &cobra.Command{
"$push": bson.M{"serra_prices": p}, "$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) // 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.storage_update(bson.M{"code": bson.M{"$eq": set.Code}}, set_update) setscoll.storageUpdate(bson.M{"code": bson.M{"$eq": set.Code}}, set_update)
} }
totalvalue, _ := coll.storage_aggregate(mongo.Pipeline{projectStage, groupStage}) totalvalue, _ := coll.storageAggregate(mongo.Pipeline{projectStage, groupStage})
t := PriceEntry{} t := PriceEntry{}
t.Date = primitive.NewDateTimeFromTime(time.Now()) t.Date = primitive.NewDateTimeFromTime(time.Now())
@ -130,7 +130,7 @@ var updateCmd = &cobra.Command{
tmpCard.Prices = t tmpCard.Prices = t
fmt.Printf("\n%sUpdating total value of collection to: %s%.02f%s%s\n", Green, Yellow, tmpCard.getValue(false)+tmpCard.getValue(true), getCurrency(), Reset) fmt.Printf("\n%sUpdating total value of collection to: %s%.02f%s%s\n", Green, Yellow, tmpCard.getValue(false)+tmpCard.getValue(true), getCurrency(), Reset)
totalcoll.storage_add_total(t) totalcoll.storageAddTotal(t)
return nil return nil
}, },