rogueserver/db/account.go

200 lines
4.5 KiB
Go
Raw Normal View History

2023-12-05 10:28:08 -08:00
package db
import (
"database/sql"
2024-04-06 14:43:11 -07:00
"fmt"
"slices"
2023-12-28 16:58:54 -08:00
_ "github.com/go-sql-driver/mysql"
2024-04-14 16:25:36 -07:00
"github.com/pagefaultgames/pokerogue-server/defs"
2023-12-05 10:28:08 -08:00
)
2023-12-28 16:53:59 -08:00
func AddAccountRecord(uuid []byte, username string, key, salt []byte) error {
2023-12-28 18:32:03 -08:00
_, err := handle.Exec("INSERT INTO accounts (uuid, username, hash, salt, registered) VALUES (?, ?, ?, ?, UTC_TIMESTAMP())", uuid, username, key, salt)
2023-12-28 16:53:59 -08:00
if err != nil {
return err
}
return nil
}
func AddAccountSession(username string, token []byte) error {
2023-12-28 18:37:04 -08:00
_, err := handle.Exec("INSERT INTO sessions (uuid, token, expire) SELECT a.uuid, ?, DATE_ADD(UTC_TIMESTAMP(), INTERVAL 1 WEEK) FROM accounts a WHERE a.username = ?", token, username)
2023-12-28 16:53:59 -08:00
if err != nil {
return err
}
_, err = handle.Exec("UPDATE accounts SET lastLoggedIn = UTC_TIMESTAMP() WHERE username = ?", username)
if err != nil {
return err
}
2023-12-28 16:53:59 -08:00
return nil
}
2024-03-15 13:38:32 -07:00
func UpdateAccountLastActivity(uuid []byte) error {
_, err := handle.Exec("UPDATE accounts SET lastActivity = UTC_TIMESTAMP() WHERE uuid = ?", uuid)
if err != nil {
return err
}
return nil
}
2024-04-11 07:13:35 -07:00
func UpdateAccountStats(uuid []byte, stats defs.GameStats, voucherCounts map[string]int) error {
var columns = []string{"playTime", "battles", "classicSessionsPlayed", "sessionsWon", "highestEndlessWave", "highestLevel", "pokemonSeen", "pokemonDefeated", "pokemonCaught", "pokemonHatched", "eggsPulled", "regularVouchers", "plusVouchers", "premiumVouchers", "goldenVouchers"}
2024-04-06 14:43:11 -07:00
var statCols []string
var statValues []interface{}
m, ok := stats.(map[string]interface{})
if !ok {
return fmt.Errorf("expected map[string]interface{}, got %T", stats)
}
for k, v := range m {
value, ok := v.(float64)
if !ok {
return fmt.Errorf("expected float64, got %T", v)
}
if slices.Contains(columns, k) {
statCols = append(statCols, k)
statValues = append(statValues, value)
}
}
2024-04-11 07:13:35 -07:00
for k, v := range voucherCounts {
var column string
switch k {
case "0":
column = "regularVouchers"
case "1":
column = "plusVouchers"
case "2":
column = "premiumVouchers"
case "3":
column = "goldenVouchers"
default:
continue
}
statCols = append(statCols, column)
statValues = append(statValues, v)
}
2024-04-06 14:43:11 -07:00
var statArgs []interface{}
statArgs = append(statArgs, uuid)
for range 2 {
statArgs = append(statArgs, statValues...)
}
query := "INSERT INTO accountStats (uuid"
for _, col := range statCols {
query += ", " + col
}
query += ") VALUES (?"
for range len(statCols) {
query += ", ?"
}
query += ") ON DUPLICATE KEY UPDATE "
for i, col := range statCols {
if i > 0 {
query += ", "
}
query += col + " = ?"
}
_, err := handle.Exec(query, statArgs...)
if err != nil {
return err
}
return nil
}
2024-04-09 19:22:00 -07:00
func FetchAndClaimAccountCompensations(uuid []byte) (map[int]int, error) {
var compensations = make(map[int]int)
results, err := handle.Query("SELECT voucherType, count FROM accountCompensations WHERE uuid = ?", uuid)
if err != nil {
return nil, err
}
defer results.Close()
for results.Next() {
var voucherType int
var count int
err := results.Scan(&voucherType, &count)
if err != nil {
return compensations, err
}
compensations[voucherType] = count
}
_, err = handle.Exec("UPDATE accountCompensations SET claimed = 1 WHERE uuid = ?", uuid)
if err != nil {
return compensations, err
}
return compensations, nil
}
func DeleteClaimedAccountCompensations(uuid []byte) error {
_, err := handle.Exec("DELETE FROM accountCompensations WHERE uuid = ? AND claimed = 1", uuid)
if err != nil {
return err
}
return nil
}
2024-03-18 16:55:02 -07:00
func FetchUsernameFromToken(token []byte) (string, error) {
2023-12-05 10:28:08 -08:00
var username string
2023-12-28 17:09:50 -08:00
err := handle.QueryRow("SELECT a.username FROM accounts a JOIN sessions s ON s.uuid = a.uuid WHERE s.token = ? AND s.expire > UTC_TIMESTAMP()", token).Scan(&username)
2023-12-05 10:28:08 -08:00
if err != nil {
2023-12-28 16:53:59 -08:00
return "", err
2023-12-05 10:28:08 -08:00
}
return username, nil
}
2023-12-28 16:53:59 -08:00
2024-03-18 16:55:02 -07:00
func FetchAccountKeySaltFromUsername(username string) ([]byte, []byte, error) {
2023-12-28 16:53:59 -08:00
var key, salt []byte
2023-12-28 18:32:03 -08:00
err := handle.QueryRow("SELECT hash, salt FROM accounts WHERE username = ?", username).Scan(&key, &salt)
2023-12-28 16:53:59 -08:00
if err != nil {
return nil, nil, err
}
return key, salt, nil
}
2024-04-08 15:15:09 -07:00
func FetchUUIDFromToken(token []byte) ([]byte, error) {
2023-12-28 16:53:59 -08:00
var uuid []byte
err := handle.QueryRow("SELECT uuid FROM sessions WHERE token = ? AND expire > UTC_TIMESTAMP()", token).Scan(&uuid)
if err != nil {
if err == sql.ErrNoRows {
return nil, err
}
return nil, err
}
return uuid, nil
}
func RemoveSessionFromToken(token []byte) error {
_, err := handle.Exec("DELETE FROM sessions WHERE token = ?", token)
if err != nil {
return err
}
return nil
}