New rewrite with svelte and pocketbase

backend/routes.go

@@ -0,0 +1,176 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+	"strings"
+	"os"
+
+	"github.com/pocketbase/pocketbase/core"
+	"github.com/pocketbase/pocketbase/apis"
+)
+
+const frontEndDevPort = "5173"
+const frontEndProdPort = "3000"
+
+type DeckImportCard struct {
+		Name      string 	`json:"name"`
+		Amount    int 		`json:"amount"`
+}
+
+
+type DeckImport struct {
+		Name       				string 						`json:"name"`
+		Url  			 				string 						`json:"url"`
+		SelectedBset  		string 						`json:"selected_bset"`
+		Commander  			 	string 						`json:"commander_name"`
+		Cards 						[]DeckImportCard 	`json:"cards"`
+}
+
+func (app *application) SetupRoutes() {
+	app.pb.OnServe().BindFunc(func(se *core.ServeEvent) error {
+		mode := os.Getenv("GO_ENV")
+		path := ""
+		if mode == "" {
+			log.Fatal("You must the env variable GO_ENV to either 'dev' or 'production'")
+		}
+
+		if mode == "dev" {
+			path = fmt.Sprintf("http://localhost:%s", frontEndDevPort)
+		} else if mode == "production" {
+			path = fmt.Sprintf("http://localhost:%s", frontEndProdPort)
+		} else {
+			log.Fatal(fmt.Sprintf("Error, unrecognized GO_ENV : %s\nSet it to either 'dev' or 'production'", mode))
+		}
+
+		target, err := url.Parse(path)
+		if err != nil {
+			log.Println("[ERROR] failed to parse proxy target URL: %w", err)
+		}
+
+		proxy := httputil.NewSingleHostReverseProxy(target)
+
+		proxy.ErrorHandler = func(w http.ResponseWriter, r *http.Request, err error) {
+			http.Error(w, fmt.Sprintf("proxy error: %v", err), http.StatusBadGateway)
+		}
+
+		// Cache Route 
+		se.Router.GET("/json/{path...}", func(re *core.RequestEvent) error {
+			path := fmt.Sprintf("json/%s",re.Request.PathValue("path"))
+
+			cacheVal := app.pb.Store().Get(path)
+			if cacheVal != nil {
+				return re.JSON(http.StatusOK, cacheVal)
+			} else {
+				return re.JSON(http.StatusNotFound, map[string]string{"message": "json not found in cache"})
+			}
+		})
+
+		// Search API
+		se.Router.GET("/api/search", func(re *core.RequestEvent) error {
+			searchData := app.pb.Store().Get("searchData").([]CacheCarteSearch)
+			search := re.Request.URL.Query().Get("q")
+
+			resultData := filter(searchData, func(card CacheCarteSearch) bool { return strings.Contains(strings.ToLower(card.Name), strings.ToLower(search)) })
+			return re.JSON(http.StatusOK, resultData)
+		})
+
+		// Create deck API
+		se.Router.POST("/api/deck/create", func(re *core.RequestEvent) error {
+			authRecord := re.Auth
+
+			data := DeckImport{}
+			if err := re.BindBody(&data); err != nil {
+				log.Println(err)
+				return re.BadRequestError("Failed to read request data", err)
+			}
+			
+			selectedBrawlset := Brawlset{}
+			err := app.pb.DB().
+					NewQuery(fmt.Sprintf("SELECT id, sets FROM brawlset WHERE sanitized_name = '%v'", data.SelectedBset)).
+					One(&selectedBrawlset)
+			if err != nil {
+				log.Println(err)
+				return re.BadRequestError("No brawlsets with this id", err)
+			}
+		
+			possibleCards := []Carte{}
+			setsIds := []string{} 
+			for _, v := range selectedBrawlset.Sets {
+				setsIds = append(setsIds, fmt.Sprintf("'%s'", v))
+			}
+			query := ""
+			if len(selectedBrawlset.Sets) > 1 {
+				query = fmt.Sprintf("SELECT id, name, color_identity FROM carte WHERE mtg_set IN (%s)", strings.Join(setsIds, ", "))
+			} else {
+				query = fmt.Sprintf("SELECT id, name, color_identity FROM carte WHERE mtg_set = %s", setsIds[0])
+			}
+			err = app.pb.DB().
+					NewQuery(query).
+					All(&possibleCards)
+			if err != nil {
+				log.Println(err)
+				return re.BadRequestError("Error with cards query", err)
+			}
+
+			collection, err := app.pb.FindCollectionByNameOrId("deck")
+			if err != nil {
+					return err
+			}
+			record := core.NewRecord(collection)
+			record.Set("name", data.Name)
+			record.Set("url", data.Url)
+			record.Set("brawlset", selectedBrawlset.ID)
+			record.Set("owner", authRecord.Id)
+
+			for _, c := range possibleCards {
+				if data.Commander == strings.Split(c.Name, " // ")[0] {
+					record.Set("commander", c.ID)
+					record.Set("color_identity", c.ColorIdentity)
+				}
+			}
+
+			cardInDeck := []DeckCard{}
+			for _, v := range data.Cards {
+				cardId := ""
+				for _, c := range possibleCards {
+					if v.Name == strings.Split(c.Name, " // ")[0] {
+						cardId = c.ID
+					}
+				}
+				if cardId == "" {
+					log.Println(fmt.Sprintf("Card not found : %s",v.Name))
+				}
+				cardInDeck = append(cardInDeck, DeckCard{ID: cardId, Amount: v.Amount})
+			}
+			record.Set("cartes", cardInDeck)
+
+			err = app.pb.Save(record)
+			if err != nil {
+				log.Println(err)
+				re.BadRequestError("Problem with creating deck", err)
+			}
+			return re.JSON(http.StatusOK, map[string]string{"message": "deck created"})
+		}).Bind(apis.RequireAuth())
+
+		// Proxy to svelte app
+		se.Router.Any("/{path...}", func(re *core.RequestEvent) error {
+			proxy.ServeHTTP(re.Response, re.Request)
+			return nil
+		})
+
+		return se.Next()
+	})
+}
+
+func filter(ss []CacheCarteSearch, test func(CacheCarteSearch) bool) (ret []CacheCarteSearch) {
+    for _, s := range ss {
+        if test(s) {
+            ret = append(ret, s)
+        }
+    }
+    return
+}