api/common.go

@@ -52,23 +52,17 @@ func Init(mux *http.ServeMux) error {
 	mux.HandleFunc("GET /game/classicsessioncount", handleGameClassicSessionCount)
 
 	// savedata
-	mux.HandleFunc("POST /savedata/update", legacyHandleSaveData) // DEPRECATED: use PUT method
+	mux.HandleFunc("GET /savedata/get", legacyHandleGetSaveData)
-	mux.HandleFunc("GET /savedata/delete", legacyHandleSaveData)  // DEPRECATED: use DELETE method
+	mux.HandleFunc("POST /savedata/update", legacyHandleSaveData)
-	mux.HandleFunc("POST /savedata/clear", legacyHandleSaveData)  // TODO: use clearSessionData
+	mux.HandleFunc("GET /savedata/delete", legacyHandleSaveData) // TODO use deleteSystemSave
+	mux.HandleFunc("POST /savedata/clear", legacyHandleSaveData) // TODO use clearSessionData
 	mux.HandleFunc("GET /savedata/newclear", legacyHandleNewClear)
 
 	// new session
-	mux.HandleFunc("POST /savedata/updateall", handleUpdateAll) // DEPRECATED: use PUT method
+	mux.HandleFunc("POST /savedata/updateall", handleUpdateAll)
-	mux.HandleFunc("PUT /savedata/updateall", handleUpdateAll)
-
-	mux.HandleFunc("GET /savedata/system", handleSystem)
-	mux.HandleFunc("PUT /savedata/system", handleSystem)
-	mux.HandleFunc("DELETE /savedata/system", handleSystem)
 	mux.HandleFunc("POST /savedata/system/verify", handleSystemVerify)
-
+	mux.HandleFunc("GET /savedata/system", handleGetSystemData)
-	mux.HandleFunc("GET /savedata/session", handleSession)
+	mux.HandleFunc("GET /savedata/session", handleGetSessionData)
-	mux.HandleFunc("PUT /savedata/session", handleSession)
-	mux.HandleFunc("DELETE /savedata/session", handleSession)
 
 	// daily
 	mux.HandleFunc("GET /daily/seed", handleDailySeed)

api/daily/common.go

@@ -61,7 +61,7 @@ func Init() error {
 		secret = newSecret
 	}
 
-	seed, err := db.TryAddDailyRun(Seed())
+	seed, err := recordNewDaily()
 	if err != nil {
 		log.Print(err)
 	}
@@ -71,7 +71,7 @@ func Init() error {
 	_, err = scheduler.AddFunc("@daily", func() {
 		time.Sleep(time.Second)
 
-		seed, err = db.TryAddDailyRun(Seed())
+		seed, err = recordNewDaily()
 		if err != nil {
 			log.Printf("error while recording new daily: %s", err)
 		} else {
@@ -99,3 +99,7 @@ func deriveSeed(seedTime time.Time) []byte {
 
 	return hashedSeed[:]
 }
+
+func recordNewDaily() (string, error) {
+	return db.TryAddDailyRun(Seed())
+}

api/endpoints.go

@@ -43,7 +43,7 @@ import (
 func handleAccountInfo(w http.ResponseWriter, r *http.Request) {
 	uuid, err := uuidFromRequest(r)
 	if err != nil {
-		httpError(w, r, err, http.StatusUnauthorized)
+		httpError(w, r, err, http.StatusBadRequest)
 		return
 	}
 
@@ -103,7 +103,7 @@ func handleAccountChangePW(w http.ResponseWriter, r *http.Request) {
 
 	uuid, err := uuidFromRequest(r)
 	if err != nil {
-		httpError(w, r, err, http.StatusUnauthorized)
+		httpError(w, r, err, http.StatusBadRequest)
 		return
 	}
 
@@ -125,8 +125,7 @@ func handleAccountLogout(w http.ResponseWriter, r *http.Request) {
 
 	err = account.Logout(token)
 	if err != nil {
-		// also possible for InternalServerError but that's unlikely unless the server blew up
+		httpError(w, r, err, http.StatusInternalServerError)
-		httpError(w, r, err, http.StatusUnauthorized)
 		return
 	}
 
@@ -147,22 +146,20 @@ func handleGameClassicSessionCount(w http.ResponseWriter, r *http.Request) {
 	w.Write([]byte(strconv.Itoa(classicSessionCount)))
 }
 
-func handleSession(w http.ResponseWriter, r *http.Request) {
+func handleGetSessionData(w http.ResponseWriter, r *http.Request) {
 	uuid, err := uuidFromRequest(r)
-	if err != nil {
-		httpError(w, r, err, http.StatusUnauthorized)
-		return
-	}
-
-	slot, err := strconv.Atoi(r.URL.Query().Get("slot"))
 	if err != nil {
 		httpError(w, r, err, http.StatusBadRequest)
 		return
 	}
 
-	if slot < 0 || slot >= defs.SessionSlotCount {
+	var slot int
-		httpError(w, r, fmt.Errorf("slot id %d out of range", slot), http.StatusBadRequest)
+	if r.URL.Query().Has("slot") {
-		return
+		slot, err = strconv.Atoi(r.URL.Query().Get("slot"))
+		if err != nil {
+			httpError(w, r, err, http.StatusBadRequest)
+			return
+		}
 	}
 
 	if !r.URL.Query().Has("clientSessionId") {
@@ -176,53 +173,76 @@ func handleSession(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	switch r.Method {
+	var save any
-	case "GET":
+	save, err = savedata.Get(uuid, 1, slot)
-		save, err := savedata.GetSession(uuid, slot)
+	if errors.Is(err, sql.ErrNoRows) {
-		if errors.Is(err, sql.ErrNoRows) {
+		http.Error(w, err.Error(), http.StatusNotFound)
-			http.Error(w, err.Error(), http.StatusNotFound)
+		return
-			return
-		}
-
-		if err != nil {
-			httpError(w, r, err, http.StatusInternalServerError)
-			return
-		}
-
-		writeJSON(w, r, save)
-	case "PUT":
-		var session defs.SessionSaveData
-		err = json.NewDecoder(r.Body).Decode(&session)
-		if err != nil {
-			httpError(w, r, fmt.Errorf("failed to decode request body: %s", err), http.StatusBadRequest)
-			return
-		}
-
-		err = savedata.PutSession(uuid, slot, session)
-		if err != nil {
-			httpError(w, r, fmt.Errorf("failed to put session data: %s", err), http.StatusInternalServerError)
-			return
-		}
-
-		w.WriteHeader(http.StatusNoContent)
-	case "DELETE":
-		err := savedata.DeleteSession(uuid, slot)
-		if err != nil {
-			httpError(w, r, err, http.StatusInternalServerError)
-			return
-		}
-
-		w.WriteHeader(http.StatusNoContent)
 	}
+
+	if err != nil {
+		httpError(w, r, err, http.StatusInternalServerError)
+		return
+	}
+
+	writeJSON(w, r, save)
 }
 
 const legacyClientSessionId = "LEGACY_CLIENT"
 
+func legacyHandleGetSaveData(w http.ResponseWriter, r *http.Request) {
+	uuid, err := uuidFromRequest(r)
+	if err != nil {
+		httpError(w, r, err, http.StatusBadRequest)
+		return
+	}
+
+	datatype := -1
+	if r.URL.Query().Has("datatype") {
+		datatype, err = strconv.Atoi(r.URL.Query().Get("datatype"))
+		if err != nil {
+			httpError(w, r, err, http.StatusBadRequest)
+			return
+		}
+	}
+
+	var slot int
+	if r.URL.Query().Has("slot") {
+		slot, err = strconv.Atoi(r.URL.Query().Get("slot"))
+		if err != nil {
+			httpError(w, r, err, http.StatusBadRequest)
+			return
+		}
+	}
+
+	var save any
+	if datatype == 0 {
+		err = db.UpdateActiveSession(uuid, legacyClientSessionId) // we dont have a client id
+		if err != nil {
+			httpError(w, r, fmt.Errorf("failed to update active session: %s", err), http.StatusBadRequest)
+			return
+		}
+	}
+
+	save, err = savedata.Get(uuid, datatype, slot)
+	if errors.Is(err, sql.ErrNoRows) {
+		http.Error(w, err.Error(), http.StatusNotFound)
+		return
+	}
+
+	if err != nil {
+		httpError(w, r, err, http.StatusInternalServerError)
+		return
+	}
+
+	writeJSON(w, r, save)
+}
+
 // FIXME UNFINISHED!!!
 /*func clearSessionData(w http.ResponseWriter, r *http.Request) {
 	uuid, err := uuidFromRequest(r)
 	if err != nil {
-		httpError(w, r, err, http.StatusUnauthorized)
+		httpError(w, r, err, http.StatusBadRequest)
 		return
 	}
 
@@ -246,7 +266,7 @@ const legacyClientSessionId = "LEGACY_CLIENT"
 	save = session
 
 	var active bool
-	active, err = db.IsActiveSession(uuid, legacyClientSessionId) // TODO: unfinished, read token from query
+	active, err = db.IsActiveSession(uuid, legacyClientSessionId) //TODO unfinished, read token from query
 	if err != nil {
 		httpError(w, r, fmt.Errorf("failed to check active session: %s", err), http.StatusBadRequest)
 		return
@@ -305,12 +325,92 @@ const legacyClientSessionId = "LEGACY_CLIENT"
 
 	jsonResponse(w, r, response)
 }
-*/
+
+// FIXME UNFINISHED!!!
+func deleteSystemSave(w http.ResponseWriter, r *http.Request) {
+	uuid, err := uuidFromRequest(r)
+	if err != nil {
+		httpError(w, r, err, http.StatusBadRequest)
+		return
+	}
+
+	datatype := 0
+	if r.URL.Query().Has("datatype") {
+		datatype, err = strconv.Atoi(r.URL.Query().Get("datatype"))
+		if err != nil {
+			httpError(w, r, err, http.StatusBadRequest)
+			return
+		}
+	}
+
+	var slot int
+	if r.URL.Query().Has("slot") {
+		slot, err = strconv.Atoi(r.URL.Query().Get("slot"))
+		if err != nil {
+			httpError(w, r, err, http.StatusBadRequest)
+			return
+		}
+	}
+
+	var active bool
+	active, err = db.IsActiveSession(uuid, legacyClientSessionId) //TODO unfinished, read token from query
+	if err != nil {
+		httpError(w, r, fmt.Errorf("failed to check active session: %s", err), http.StatusInternalServerError)
+		return
+	}
+
+	if !active {
+		httpError(w, r, fmt.Errorf("session out of date: not active"), http.StatusBadRequest)
+		return
+	}
+
+	var trainerId, secretId int
+
+	if r.URL.Query().Has("trainerId") && r.URL.Query().Has("secretId") {
+		trainerId, err = strconv.Atoi(r.URL.Query().Get("trainerId"))
+		if err != nil {
+			httpError(w, r, err, http.StatusBadRequest)
+			return
+		}
+
+		secretId, err = strconv.Atoi(r.URL.Query().Get("secretId"))
+		if err != nil {
+			httpError(w, r, err, http.StatusBadRequest)
+			return
+		}
+	}
+
+	storedTrainerId, storedSecretId, err := db.FetchTrainerIds(uuid)
+	if err != nil {
+		httpError(w, r, err, http.StatusInternalServerError)
+		return
+	}
+
+	if storedTrainerId > 0 || storedSecretId > 0 {
+		if trainerId != storedTrainerId || secretId != storedSecretId {
+			httpError(w, r, fmt.Errorf("session out of date: stored trainer or secret ID does not match"), http.StatusBadRequest)
+			return
+		}
+	} else {
+		if err := db.UpdateTrainerIds(trainerId, secretId, uuid); err != nil {
+			httpError(w, r, err, http.StatusInternalServerError)
+			return
+		}
+	}
+
+	err = savedata.Delete(uuid, datatype, slot)
+	if err != nil {
+		httpError(w, r, err, http.StatusInternalServerError)
+		return
+	}
+
+	w.WriteHeader(http.StatusOK)
+}*/
 
 func legacyHandleSaveData(w http.ResponseWriter, r *http.Request) {
 	uuid, err := uuidFromRequest(r)
 	if err != nil {
-		httpError(w, r, err, http.StatusUnauthorized)
+		httpError(w, r, err, http.StatusBadRequest)
 		return
 	}
 
@@ -338,8 +438,8 @@ func legacyHandleSaveData(w http.ResponseWriter, r *http.Request) {
 	}
 
 	var save any
-	// /savedata/delete specify datatype, but don't expect data in body
+	// /savedata/get and /savedata/delete specify datatype, but don't expect data in body
-	if r.URL.Path != "/savedata/delete" {
+	if r.URL.Path != "/savedata/get" && r.URL.Path != "/savedata/delete" {
 		if datatype == 0 {
 			var system defs.SystemSaveData
 			err = json.NewDecoder(r.Body).Decode(&system)
@@ -363,58 +463,74 @@ func legacyHandleSaveData(w http.ResponseWriter, r *http.Request) {
 	}
 
 	var active bool
-	active, err = db.IsActiveSession(uuid, clientSessionId)
+	if r.URL.Path == "/savedata/get" {
-	if err != nil {
+		if datatype == 0 {
-		httpError(w, r, fmt.Errorf("failed to check active session: %s", err), http.StatusBadRequest)
+			err = db.UpdateActiveSession(uuid, clientSessionId)
-		return
-	}
-
-	// TODO: make this not suck
-	if !active && r.URL.Path != "/savedata/clear" {
-		httpError(w, r, fmt.Errorf("session out of date: not active"), http.StatusBadRequest)
-		return
-	}
-
-	var trainerId, secretId int
-
-	if r.URL.Path != "/savedata/update" || datatype == 1 {
-		if r.URL.Query().Has("trainerId") && r.URL.Query().Has("secretId") {
-			trainerId, err = strconv.Atoi(r.URL.Query().Get("trainerId"))
 			if err != nil {
-				httpError(w, r, err, http.StatusBadRequest)
+				httpError(w, r, fmt.Errorf("failed to update active session: %s", err), http.StatusBadRequest)
-				return
-			}
-
-			secretId, err = strconv.Atoi(r.URL.Query().Get("secretId"))
-			if err != nil {
-				httpError(w, r, err, http.StatusBadRequest)
 				return
 			}
 		}
 	} else {
-		trainerId = save.(defs.SystemSaveData).TrainerId
+		active, err = db.IsActiveSession(uuid, clientSessionId)
-		secretId = save.(defs.SystemSaveData).SecretId
+		if err != nil {
-	}
+			httpError(w, r, fmt.Errorf("failed to check active session: %s", err), http.StatusBadRequest)
-
-	storedTrainerId, storedSecretId, err := db.FetchTrainerIds(uuid)
-	if err != nil {
-		httpError(w, r, err, http.StatusInternalServerError)
-		return
-	}
-
-	if storedTrainerId > 0 || storedSecretId > 0 {
-		if trainerId != storedTrainerId || secretId != storedSecretId {
-			httpError(w, r, fmt.Errorf("session out of date: stored trainer or secret ID does not match"), http.StatusBadRequest)
 			return
 		}
-	} else {
+
-		if err := db.UpdateTrainerIds(trainerId, secretId, uuid); err != nil {
+		// TODO: make this not suck
+		if !active && r.URL.Path != "/savedata/clear" {
+			httpError(w, r, fmt.Errorf("session out of date: not active"), http.StatusBadRequest)
+			return
+		}
+
+		var trainerId, secretId int
+
+		if r.URL.Path != "/savedata/update" || datatype == 1 {
+			if r.URL.Query().Has("trainerId") && r.URL.Query().Has("secretId") {
+				trainerId, err = strconv.Atoi(r.URL.Query().Get("trainerId"))
+				if err != nil {
+					httpError(w, r, err, http.StatusBadRequest)
+					return
+				}
+
+				secretId, err = strconv.Atoi(r.URL.Query().Get("secretId"))
+				if err != nil {
+					httpError(w, r, err, http.StatusBadRequest)
+					return
+				}
+			}
+		} else {
+			trainerId = save.(defs.SystemSaveData).TrainerId
+			secretId = save.(defs.SystemSaveData).SecretId
+		}
+
+		storedTrainerId, storedSecretId, err := db.FetchTrainerIds(uuid)
+		if err != nil {
 			httpError(w, r, err, http.StatusInternalServerError)
 			return
 		}
+
+		if storedTrainerId > 0 || storedSecretId > 0 {
+			if trainerId != storedTrainerId || secretId != storedSecretId {
+				httpError(w, r, fmt.Errorf("session out of date: stored trainer or secret ID does not match"), http.StatusBadRequest)
+				return
+			}
+		} else {
+			if err := db.UpdateTrainerIds(trainerId, secretId, uuid); err != nil {
+				httpError(w, r, err, http.StatusInternalServerError)
+				return
+			}
+		}
 	}
 
 	switch r.URL.Path {
+	case "/savedata/get":
+		save, err = savedata.Get(uuid, datatype, slot)
+		if errors.Is(err, sql.ErrNoRows) {
+			http.Error(w, err.Error(), http.StatusNotFound)
+			return
+		}
 	case "/savedata/update":
 		err = savedata.Update(uuid, slot, save)
 	case "/savedata/delete":
@@ -460,7 +576,7 @@ type CombinedSaveData struct {
 func handleUpdateAll(w http.ResponseWriter, r *http.Request) {
 	uuid, err := uuidFromRequest(r)
 	if err != nil {
-		httpError(w, r, err, http.StatusUnauthorized)
+		httpError(w, r, err, http.StatusBadRequest)
 		return
 	}
 
@@ -470,7 +586,6 @@ func handleUpdateAll(w http.ResponseWriter, r *http.Request) {
 		httpError(w, r, fmt.Errorf("failed to decode request body: %s", err), http.StatusBadRequest)
 		return
 	}
-
 	if data.ClientSessionId == "" {
 		data.ClientSessionId = legacyClientSessionId
 	}
@@ -487,6 +602,9 @@ func handleUpdateAll(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	trainerId := data.System.TrainerId
+	secretId := data.System.SecretId
+
 	storedTrainerId, storedSecretId, err := db.FetchTrainerIds(uuid)
 	if err != nil {
 		httpError(w, r, err, http.StatusInternalServerError)
@@ -494,13 +612,12 @@ func handleUpdateAll(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if storedTrainerId > 0 || storedSecretId > 0 {
-		if data.System.TrainerId != storedTrainerId || data.System.SecretId != storedSecretId {
+		if trainerId != storedTrainerId || secretId != storedSecretId {
 			httpError(w, r, fmt.Errorf("session out of date: stored trainer or secret ID does not match"), http.StatusBadRequest)
 			return
 		}
 	} else {
-		err = db.UpdateTrainerIds(data.System.TrainerId, data.System.SecretId, uuid)
+		if err = db.UpdateTrainerIds(trainerId, secretId, uuid); err != nil {
-		if err != nil {
 			httpError(w, r, err, http.StatusInternalServerError)
 			return
 		}
@@ -511,29 +628,27 @@ func handleUpdateAll(w http.ResponseWriter, r *http.Request) {
 		httpError(w, r, err, http.StatusInternalServerError)
 		return
 	}
-
 	err = savedata.Update(uuid, 0, data.System)
 	if err != nil {
 		httpError(w, r, err, http.StatusInternalServerError)
 		return
 	}
-
 	w.WriteHeader(http.StatusOK)
 }
 
-type SystemVerifyRequest struct {
-	ClientSessionId string `json:"clientSessionId"`
-}
-
 type SystemVerifyResponse struct {
 	Valid      bool                 `json:"valid"`
 	SystemData *defs.SystemSaveData `json:"systemData"`
 }
 
+type SystemVerifyRequest struct {
+	ClientSessionId string `json:"clientSessionId"`
+}
+
 func handleSystemVerify(w http.ResponseWriter, r *http.Request) {
 	uuid, err := uuidFromRequest(r)
 	if err != nil {
-		httpError(w, r, err, http.StatusUnauthorized)
+		httpError(w, r, err, http.StatusBadRequest)
 		return
 	}
 
@@ -582,10 +697,10 @@ func handleSystemVerify(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, r, response)
 }
 
-func handleSystem(w http.ResponseWriter, r *http.Request) {
+func handleGetSystemData(w http.ResponseWriter, r *http.Request) {
 	uuid, err := uuidFromRequest(r)
 	if err != nil {
-		httpError(w, r, err, http.StatusUnauthorized)
+		httpError(w, r, err, http.StatusBadRequest)
 		return
 	}
 
@@ -600,52 +715,26 @@ func handleSystem(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	switch r.Method {
+	var save any //TODO this is always system save data
-	case "GET":
+	save, err = savedata.Get(uuid, 0, 0)
-		save, err := savedata.GetSystem(uuid)
+	if err != nil {
-		if err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
-			if errors.Is(err, sql.ErrNoRows) {
+			http.Error(w, err.Error(), http.StatusNotFound)
-				http.Error(w, err.Error(), http.StatusNotFound)
+		} else {
-			} else {
-				httpError(w, r, err, http.StatusInternalServerError)
-			}
-
-			return
-		}
-
-		// TODO: apply vouchers
-
-		writeJSON(w, r, save)
-	case "PUT":
-		var system defs.SystemSaveData
-		err = json.NewDecoder(r.Body).Decode(&system)
-		if err != nil {
-			httpError(w, r, fmt.Errorf("failed to decode request body: %s", err), http.StatusBadRequest)
-			return
-		}
-
-		err = savedata.PutSystem(uuid, system)
-		if err != nil {
-			httpError(w, r, fmt.Errorf("failed to put system data: %s", err), http.StatusInternalServerError)
-			return
-		}
-
-		w.WriteHeader(http.StatusNoContent)
-	case "DELETE":
-		err := savedata.DeleteSystem(uuid)
-		if err != nil {
 			httpError(w, r, err, http.StatusInternalServerError)
-			return
 		}
 
-		w.WriteHeader(http.StatusNoContent)
+		return
 	}
+	//TODO apply vouchers
+
+	writeJSON(w, r, save)
 }
 
 func legacyHandleNewClear(w http.ResponseWriter, r *http.Request) {
 	uuid, err := uuidFromRequest(r)
 	if err != nil {
-		httpError(w, r, err, http.StatusUnauthorized)
+		httpError(w, r, err, http.StatusBadRequest)
 		return
 	}
 

api/savedata/delete.go

@@ -33,6 +33,8 @@ func Delete(uuid []byte, datatype, slot int) error {
 	}
 
 	switch datatype {
+	case 0: // System
+		err = db.DeleteSystemSaveData(uuid)
 	case 1: // Session
 		if slot < 0 || slot >= defs.SessionSlotCount {
 			err = fmt.Errorf("slot id %d out of range", slot)
@@ -46,6 +48,6 @@ func Delete(uuid []byte, datatype, slot int) error {
 	if err != nil {
 		return err
 	}
-
+	
 	return nil
 }

api/savedata/get.go

@@ -0,0 +1,82 @@
+/*
+	Copyright (C) 2024  Pagefault Games
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU Affero General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU Affero General Public License for more details.
+
+	You should have received a copy of the GNU Affero General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package savedata
+
+import (
+	"fmt"
+	"strconv"
+
+	"github.com/pagefaultgames/rogueserver/db"
+	"github.com/pagefaultgames/rogueserver/defs"
+)
+
+// /savedata/get - get save data
+func Get(uuid []byte, datatype, slot int) (any, error) {
+	switch datatype {
+	case 0: // System
+		system, err := db.ReadSystemSaveData(uuid)
+		if err != nil {
+			return nil, err
+		}
+
+		// TODO this should be a transaction
+		compensations, err := db.FetchAndClaimAccountCompensations(uuid)
+		if err != nil {
+			return nil, fmt.Errorf("failed to fetch compensations: %s", err)
+		}
+
+		var needsUpdate bool
+		for compensationType, amount := range compensations {
+			system.VoucherCounts[strconv.Itoa(compensationType)] += amount
+			if amount > 0 {
+				needsUpdate = true
+			}
+		}
+
+		if needsUpdate {
+			err = db.StoreSystemSaveData(uuid, system)
+			if err != nil {
+				return nil, fmt.Errorf("failed to update system save data: %s", err)
+			}
+			err = db.DeleteClaimedAccountCompensations(uuid)
+			if err != nil {
+				return nil, fmt.Errorf("failed to delete claimed compensations: %s", err)
+			}
+
+			err = db.UpdateAccountStats(uuid, system.GameStats, system.VoucherCounts)
+			if err != nil {
+				return nil, fmt.Errorf("failed to update account stats: %s", err)
+			}
+		}
+
+		return system, nil
+	case 1: // Session
+		if slot < 0 || slot >= defs.SessionSlotCount {
+			return nil, fmt.Errorf("slot id %d out of range", slot)
+		}
+
+		session, err := db.ReadSessionSaveData(uuid, slot)
+		if err != nil {
+			return nil, err
+		}
+
+		return session, nil
+	default:
+		return nil, fmt.Errorf("invalid data type")
+	}
+}

api/savedata/session.go

@@ -1,33 +0,0 @@
-package savedata
-
-import (
-	"github.com/pagefaultgames/rogueserver/db"
-	"github.com/pagefaultgames/rogueserver/defs"
-)
-
-func GetSession(uuid []byte, slot int) (defs.SessionSaveData, error) {
-	session, err := db.ReadSessionSaveData(uuid, slot)
-	if err != nil {
-		return session, err
-	}
-
-	return session, nil
-}
-
-func PutSession(uuid []byte, slot int, data defs.SessionSaveData) error {
-	err := db.StoreSessionSaveData(uuid, data, slot)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func DeleteSession(uuid []byte, slot int) error {
-	err := db.DeleteSessionSaveData(uuid, slot)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}

api/savedata/system.go

@@ -1,79 +0,0 @@
-package savedata
-
-import (
-	"fmt"
-	"strconv"
-
-	"github.com/pagefaultgames/rogueserver/db"
-	"github.com/pagefaultgames/rogueserver/defs"
-)
-
-func GetSystem(uuid []byte) (defs.SystemSaveData, error) {
-	system, err := db.ReadSystemSaveData(uuid)
-	if err != nil {
-		return system, err
-	}
-
-	// TODO: this should be a transaction
-	compensations, err := db.FetchAndClaimAccountCompensations(uuid)
-	if err != nil {
-		return system, fmt.Errorf("failed to fetch compensations: %s", err)
-	}
-
-	var needsUpdate bool
-	for compensationType, amount := range compensations {
-		system.VoucherCounts[strconv.Itoa(compensationType)] += amount
-		if amount > 0 {
-			needsUpdate = true
-		}
-	}
-
-	if needsUpdate {
-		err = db.StoreSystemSaveData(uuid, system)
-		if err != nil {
-			return system, fmt.Errorf("failed to update system save data: %s", err)
-		}
-		err = db.DeleteClaimedAccountCompensations(uuid)
-		if err != nil {
-			return system, fmt.Errorf("failed to delete claimed compensations: %s", err)
-		}
-
-		err = db.UpdateAccountStats(uuid, system.GameStats, system.VoucherCounts)
-		if err != nil {
-			return system, fmt.Errorf("failed to update account stats: %s", err)
-		}
-	}
-
-	return system, nil
-}
-
-func PutSystem(uuid []byte, data defs.SystemSaveData) error {
-	if data.TrainerId == 0 && data.SecretId == 0 {
-		return fmt.Errorf("invalid system data")
-	}
-
-	if data.GameVersion != "1.0.4" {
-		return fmt.Errorf("client version out of date")
-	}
-
-	err := db.UpdateAccountStats(uuid, data.GameStats, data.VoucherCounts)
-	if err != nil {
-		return fmt.Errorf("failed to update account stats: %s", err)
-	}
-
-	err = db.DeleteClaimedAccountCompensations(uuid)
-	if err != nil {
-		return fmt.Errorf("failed to delete claimed compensations: %s", err)
-	}
-
-	return db.StoreSystemSaveData(uuid, data)
-}
-
-func DeleteSystem(uuid []byte) error {
-	err := db.DeleteSystemSaveData(uuid)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}

defs/savedata.go

@@ -107,13 +107,6 @@ type SessionSaveData struct {
 	Trainer        TrainerData              `json:"trainer"`
 	GameVersion    string                   `json:"gameVersion"`
 	Timestamp      int                      `json:"timestamp"`
-	Challenges     []ChallengeData          `json:"challenges"`
-}
-
-type ChallengeData struct {
-	Id       int `json:"id"`
-	Value    int `json:"value"`
-	Severity int `json:"severity"`
 }
 
 type GameMode int