You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
342 lines
9.1 KiB
Go
342 lines
9.1 KiB
Go
package api
|
|
|
|
import (
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"strconv"
|
|
"sync"
|
|
|
|
"github.com/pagefaultgames/pokerogue-server/api/account"
|
|
"github.com/pagefaultgames/pokerogue-server/api/daily"
|
|
"github.com/pagefaultgames/pokerogue-server/api/savedata"
|
|
"github.com/pagefaultgames/pokerogue-server/db"
|
|
"github.com/pagefaultgames/pokerogue-server/defs"
|
|
)
|
|
|
|
type Server struct {
|
|
Debug bool
|
|
Exit *sync.RWMutex
|
|
}
|
|
|
|
/*
|
|
The caller of endpoint handler functions are responsible for extracting the necessary data from the request.
|
|
Handler functions are responsible for checking the validity of this data and returning a result or error.
|
|
Handlers should not return serialized JSON, instead return the struct itself.
|
|
*/
|
|
|
|
func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
|
// kind of misusing the RWMutex but it doesn't matter
|
|
s.Exit.RLock()
|
|
defer s.Exit.RUnlock()
|
|
|
|
if s.Debug {
|
|
w.Header().Set("Access-Control-Allow-Headers", "*")
|
|
w.Header().Set("Access-Control-Allow-Methods", "*")
|
|
w.Header().Set("Access-Control-Allow-Origin", "*")
|
|
|
|
if r.Method == "OPTIONS" {
|
|
w.WriteHeader(http.StatusOK)
|
|
return
|
|
}
|
|
}
|
|
|
|
switch r.URL.Path {
|
|
// /account
|
|
case "/account/info":
|
|
username, err := getUsernameFromRequest(r)
|
|
if err != nil {
|
|
httpError(w, r, err, http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
uuid, err := getUUIDFromRequest(r) // lazy
|
|
if err != nil {
|
|
httpError(w, r, err, http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
response, err := account.Info(username, uuid)
|
|
if err != nil {
|
|
httpError(w, r, err, http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
err = json.NewEncoder(w).Encode(response)
|
|
if err != nil {
|
|
httpError(w, r, fmt.Errorf("failed to encode response json: %s", err), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
case "/account/register":
|
|
err := r.ParseForm()
|
|
if err != nil {
|
|
httpError(w, r, fmt.Errorf("failed to parse request form: %s", err), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
err = account.Register(r.Form.Get("username"), r.Form.Get("password"))
|
|
if err != nil {
|
|
httpError(w, r, err, http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
w.WriteHeader(http.StatusOK)
|
|
case "/account/login":
|
|
err := r.ParseForm()
|
|
if err != nil {
|
|
httpError(w, r, fmt.Errorf("failed to parse request form: %s", err), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
response, err := account.Login(r.Form.Get("username"), r.Form.Get("password"))
|
|
if err != nil {
|
|
httpError(w, r, err, http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
err = json.NewEncoder(w).Encode(response)
|
|
if err != nil {
|
|
httpError(w, r, fmt.Errorf("failed to encode response json: %s", err), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
case "/account/logout":
|
|
token, err := base64.StdEncoding.DecodeString(r.Header.Get("Authorization"))
|
|
if err != nil {
|
|
httpError(w, r, fmt.Errorf("failed to decode token: %s", err), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
err = account.Logout(token)
|
|
if err != nil {
|
|
httpError(w, r, err, http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
w.WriteHeader(http.StatusOK)
|
|
|
|
// /game
|
|
case "/game/playercount":
|
|
w.Write([]byte(strconv.Itoa(playerCount)))
|
|
case "/game/titlestats":
|
|
err := json.NewEncoder(w).Encode(defs.TitleStats{
|
|
PlayerCount: playerCount,
|
|
BattleCount: battleCount,
|
|
})
|
|
if err != nil {
|
|
httpError(w, r, fmt.Errorf("failed to encode response json: %s", err), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
case "/game/classicsessioncount":
|
|
w.Write([]byte(strconv.Itoa(classicSessionCount)))
|
|
|
|
// /savedata
|
|
case "/savedata/get", "/savedata/update", "/savedata/delete", "/savedata/clear":
|
|
uuid, err := getUUIDFromRequest(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
|
|
// /savedata/get and /savedata/delete specify datatype, but don't expect data in body
|
|
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)
|
|
if err != nil {
|
|
httpError(w, r, fmt.Errorf("failed to decode request body: %s", err), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
save = system
|
|
// /savedata/clear doesn't specify datatype, it is assumed to be 1 (session)
|
|
} else if datatype == 1 || r.URL.Path == "/savedata/clear" {
|
|
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
|
|
}
|
|
|
|
save = session
|
|
}
|
|
}
|
|
|
|
var token []byte
|
|
token, err = base64.StdEncoding.DecodeString(r.Header.Get("Authorization"))
|
|
if err != nil {
|
|
httpError(w, r, fmt.Errorf("failed to decode token: %s", err), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
switch r.URL.Path {
|
|
case "/savedata/get":
|
|
err = db.UpdateActiveSession(uuid, token)
|
|
if err != nil {
|
|
httpError(w, r, fmt.Errorf("failed to update active session: %s", err), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
save, err = savedata.Get(uuid, datatype, slot)
|
|
case "/savedata/update":
|
|
var token []byte
|
|
token, err = base64.StdEncoding.DecodeString(r.Header.Get("Authorization"))
|
|
if err != nil {
|
|
httpError(w, r, fmt.Errorf("failed to decode token: %s", err), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
var active bool
|
|
active, err = db.IsActiveSession(token)
|
|
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"), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
err = savedata.Update(uuid, slot, save)
|
|
case "/savedata/delete":
|
|
var active bool
|
|
active, err = db.IsActiveSession(token)
|
|
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"), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
err = savedata.Delete(uuid, datatype, slot)
|
|
case "/savedata/clear":
|
|
var active bool
|
|
active, err = db.IsActiveSession(token)
|
|
if err != nil {
|
|
httpError(w, r, fmt.Errorf("failed to check active session: %s", err), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
if active {
|
|
s, ok := save.(defs.SessionSaveData)
|
|
if !ok {
|
|
httpError(w, r, fmt.Errorf("save data is not type SessionSaveData"), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
// doesn't return a save, but it works
|
|
save, err = savedata.Clear(uuid, slot, daily.Seed(), s)
|
|
} else {
|
|
var response savedata.ClearResponse
|
|
response.Error = "session out of date"
|
|
save = response
|
|
}
|
|
}
|
|
if err != nil {
|
|
httpError(w, r, err, http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
if save == nil || r.URL.Path == "/savedata/update" {
|
|
w.WriteHeader(http.StatusOK)
|
|
return
|
|
}
|
|
|
|
err = json.NewEncoder(w).Encode(save)
|
|
if err != nil {
|
|
httpError(w, r, fmt.Errorf("failed to encode response json: %s", err), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
|
|
// /daily
|
|
case "/daily/seed":
|
|
w.Write([]byte(daily.Seed()))
|
|
case "/daily/rankings":
|
|
var err error
|
|
|
|
var category int
|
|
if r.URL.Query().Has("category") {
|
|
category, err = strconv.Atoi(r.URL.Query().Get("category"))
|
|
if err != nil {
|
|
httpError(w, r, fmt.Errorf("failed to convert category: %s", err), http.StatusBadRequest)
|
|
return
|
|
}
|
|
}
|
|
|
|
page := 1
|
|
if r.URL.Query().Has("page") {
|
|
page, err = strconv.Atoi(r.URL.Query().Get("page"))
|
|
if err != nil {
|
|
httpError(w, r, fmt.Errorf("failed to convert page: %s", err), http.StatusBadRequest)
|
|
return
|
|
}
|
|
}
|
|
|
|
rankings, err := daily.Rankings(category, page)
|
|
if err != nil {
|
|
httpError(w, r, err, http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
err = json.NewEncoder(w).Encode(rankings)
|
|
if err != nil {
|
|
httpError(w, r, fmt.Errorf("failed to encode response json: %s", err), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
case "/daily/rankingpagecount":
|
|
var category int
|
|
if r.URL.Query().Has("category") {
|
|
var err error
|
|
category, err = strconv.Atoi(r.URL.Query().Get("category"))
|
|
if err != nil {
|
|
httpError(w, r, fmt.Errorf("failed to convert category: %s", err), http.StatusBadRequest)
|
|
return
|
|
}
|
|
}
|
|
|
|
count, err := daily.RankingPageCount(category)
|
|
if err != nil {
|
|
httpError(w, r, err, http.StatusInternalServerError)
|
|
}
|
|
|
|
w.Write([]byte(strconv.Itoa(count)))
|
|
}
|
|
}
|
|
|
|
func httpError(w http.ResponseWriter, r *http.Request, err error, code int) {
|
|
log.Printf("%s: %s\n", r.URL.Path, err)
|
|
http.Error(w, err.Error(), code)
|
|
}
|