342 lines
9.6 KiB
Go
342 lines
9.6 KiB
Go
package users
|
|
|
|
import (
|
|
"fmt"
|
|
"slices"
|
|
"time"
|
|
|
|
"dk/internal/database"
|
|
"dk/internal/helpers"
|
|
"dk/internal/helpers/scanner"
|
|
|
|
"zombiezen.com/go/sqlite"
|
|
)
|
|
|
|
// User represents a user in the database
|
|
type User struct {
|
|
database.BaseModel
|
|
|
|
ID int `db:"id" json:"id"`
|
|
Username string `db:"username" json:"username"`
|
|
Password string `db:"password" json:"password"`
|
|
Email string `db:"email" json:"email"`
|
|
Verified int `db:"verified" json:"verified"`
|
|
Token string `db:"token" json:"token"`
|
|
Registered int64 `db:"registered" json:"registered"`
|
|
LastOnline int64 `db:"last_online" json:"last_online"`
|
|
Auth int `db:"auth" json:"auth"`
|
|
X int `db:"x" json:"x"`
|
|
Y int `db:"y" json:"y"`
|
|
ClassID int `db:"class_id" json:"class_id"`
|
|
Currently string `db:"currently" json:"currently"`
|
|
Fighting int `db:"fighting" json:"fighting"`
|
|
MonsterID int `db:"monster_id" json:"monster_id"`
|
|
MonsterHP int `db:"monster_hp" json:"monster_hp"`
|
|
MonsterSleep int `db:"monster_sleep" json:"monster_sleep"`
|
|
MonsterImmune int `db:"monster_immune" json:"monster_immune"`
|
|
UberDamage int `db:"uber_damage" json:"uber_damage"`
|
|
UberDefense int `db:"uber_defense" json:"uber_defense"`
|
|
HP int `db:"hp" json:"hp"`
|
|
MP int `db:"mp" json:"mp"`
|
|
TP int `db:"tp" json:"tp"`
|
|
MaxHP int `db:"max_hp" json:"max_hp"`
|
|
MaxMP int `db:"max_mp" json:"max_mp"`
|
|
MaxTP int `db:"max_tp" json:"max_tp"`
|
|
Level int `db:"level" json:"level"`
|
|
Gold int `db:"gold" json:"gold"`
|
|
Exp int `db:"exp" json:"exp"`
|
|
GoldBonus int `db:"gold_bonus" json:"gold_bonus"`
|
|
ExpBonus int `db:"exp_bonus" json:"exp_bonus"`
|
|
Strength int `db:"strength" json:"strength"`
|
|
Dexterity int `db:"dexterity" json:"dexterity"`
|
|
Attack int `db:"attack" json:"attack"`
|
|
Defense int `db:"defense" json:"defense"`
|
|
WeaponID int `db:"weapon_id" json:"weapon_id"`
|
|
ArmorID int `db:"armor_id" json:"armor_id"`
|
|
ShieldID int `db:"shield_id" json:"shield_id"`
|
|
Slot1ID int `db:"slot_1_id" json:"slot_1_id"`
|
|
Slot2ID int `db:"slot_2_id" json:"slot_2_id"`
|
|
Slot3ID int `db:"slot_3_id" json:"slot_3_id"`
|
|
WeaponName string `db:"weapon_name" json:"weapon_name"`
|
|
ArmorName string `db:"armor_name" json:"armor_name"`
|
|
ShieldName string `db:"shield_name" json:"shield_name"`
|
|
Slot1Name string `db:"slot_1_name" json:"slot_1_name"`
|
|
Slot2Name string `db:"slot_2_name" json:"slot_2_name"`
|
|
Slot3Name string `db:"slot_3_name" json:"slot_3_name"`
|
|
DropCode int `db:"drop_code" json:"drop_code"`
|
|
Spells string `db:"spells" json:"spells"`
|
|
Towns string `db:"towns" json:"towns"`
|
|
}
|
|
|
|
func (u *User) GetTableName() string {
|
|
return "users"
|
|
}
|
|
|
|
func (u *User) GetID() int {
|
|
return u.ID
|
|
}
|
|
|
|
func (u *User) SetID(id int) {
|
|
u.ID = id
|
|
}
|
|
|
|
func (u *User) Set(field string, value any) error {
|
|
return database.Set(u, field, value)
|
|
}
|
|
|
|
func (u *User) Save() error {
|
|
return database.Save(u)
|
|
}
|
|
|
|
func (u *User) Delete() error {
|
|
return database.Delete(u)
|
|
}
|
|
|
|
func New() *User {
|
|
now := time.Now().Unix()
|
|
return &User{
|
|
Verified: 0,
|
|
Token: "",
|
|
Registered: now,
|
|
LastOnline: now,
|
|
Auth: 0,
|
|
X: 0,
|
|
Y: 0,
|
|
ClassID: 1,
|
|
Currently: "In Town",
|
|
Fighting: 0,
|
|
HP: 15,
|
|
MP: 0,
|
|
TP: 10,
|
|
MaxHP: 15,
|
|
MaxMP: 0,
|
|
MaxTP: 10,
|
|
Level: 1,
|
|
Gold: 100,
|
|
Exp: 0,
|
|
Strength: 5,
|
|
Dexterity: 5,
|
|
Attack: 5,
|
|
Defense: 5,
|
|
Spells: "",
|
|
Towns: "",
|
|
}
|
|
}
|
|
|
|
var userScanner = scanner.New[User]()
|
|
|
|
func userColumns() string {
|
|
return userScanner.Columns()
|
|
}
|
|
|
|
func scanUser(stmt *sqlite.Stmt) *User {
|
|
user := &User{}
|
|
userScanner.Scan(stmt, user)
|
|
return user
|
|
}
|
|
|
|
func Find(id int) (*User, error) {
|
|
var user *User
|
|
query := `SELECT ` + userColumns() + ` FROM users WHERE id = ?`
|
|
err := database.Query(query, func(stmt *sqlite.Stmt) error {
|
|
user = scanUser(stmt)
|
|
return nil
|
|
}, id)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to find user: %w", err)
|
|
}
|
|
if user == nil {
|
|
return nil, fmt.Errorf("user with ID %d not found", id)
|
|
}
|
|
return user, nil
|
|
}
|
|
|
|
func All() ([]*User, error) {
|
|
var users []*User
|
|
query := `SELECT ` + userColumns() + ` FROM users ORDER BY registered DESC, id DESC`
|
|
err := database.Query(query, func(stmt *sqlite.Stmt) error {
|
|
user := scanUser(stmt)
|
|
users = append(users, user)
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to retrieve all users: %w", err)
|
|
}
|
|
return users, nil
|
|
}
|
|
|
|
func ByUsername(username string) (*User, error) {
|
|
var user *User
|
|
query := `SELECT ` + userColumns() + ` FROM users WHERE LOWER(username) = LOWER(?) LIMIT 1`
|
|
err := database.Query(query, func(stmt *sqlite.Stmt) error {
|
|
user = scanUser(stmt)
|
|
return nil
|
|
}, username)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to find user by username: %w", err)
|
|
}
|
|
if user == nil {
|
|
return nil, fmt.Errorf("user with username '%s' not found", username)
|
|
}
|
|
return user, nil
|
|
}
|
|
|
|
func ByEmail(email string) (*User, error) {
|
|
var user *User
|
|
query := `SELECT ` + userColumns() + ` FROM users WHERE email = ? LIMIT 1`
|
|
err := database.Query(query, func(stmt *sqlite.Stmt) error {
|
|
user = scanUser(stmt)
|
|
return nil
|
|
}, email)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to find user by email: %w", err)
|
|
}
|
|
if user == nil {
|
|
return nil, fmt.Errorf("user with email '%s' not found", email)
|
|
}
|
|
return user, nil
|
|
}
|
|
|
|
func ByLevel(level int) ([]*User, error) {
|
|
var users []*User
|
|
query := `SELECT ` + userColumns() + ` FROM users WHERE level = ? ORDER BY exp DESC, id ASC`
|
|
err := database.Query(query, func(stmt *sqlite.Stmt) error {
|
|
user := scanUser(stmt)
|
|
users = append(users, user)
|
|
return nil
|
|
}, level)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to retrieve users by level: %w", err)
|
|
}
|
|
return users, nil
|
|
}
|
|
|
|
func Online(within time.Duration) ([]*User, error) {
|
|
var users []*User
|
|
cutoff := time.Now().Add(-within).Unix()
|
|
query := `SELECT ` + userColumns() + ` FROM users WHERE last_online >= ? ORDER BY last_online DESC, id ASC`
|
|
err := database.Query(query, func(stmt *sqlite.Stmt) error {
|
|
user := scanUser(stmt)
|
|
users = append(users, user)
|
|
return nil
|
|
}, cutoff)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to retrieve online users: %w", err)
|
|
}
|
|
return users, nil
|
|
}
|
|
|
|
func (u *User) Insert() error {
|
|
columns := `username, password, email, verified, token, registered, last_online, auth,
|
|
x, y, class_id, currently, fighting, monster_id, monster_hp, monster_sleep, monster_immune,
|
|
uber_damage, uber_defense, hp, mp, tp, max_hp, max_mp, max_tp, level, gold, exp,
|
|
gold_bonus, exp_bonus, strength, dexterity, attack, defense, weapon_id, armor_id, shield_id,
|
|
slot_1_id, slot_2_id, slot_3_id, weapon_name, armor_name, shield_name,
|
|
slot_1_name, slot_2_name, slot_3_name, drop_code, spells, towns`
|
|
|
|
values := []any{u.Username, u.Password, u.Email, u.Verified, u.Token,
|
|
u.Registered, u.LastOnline, u.Auth, u.X, u.Y, u.ClassID, u.Currently,
|
|
u.Fighting, u.MonsterID, u.MonsterHP, u.MonsterSleep, u.MonsterImmune,
|
|
u.UberDamage, u.UberDefense, u.HP, u.MP, u.TP, u.MaxHP, u.MaxMP, u.MaxTP,
|
|
u.Level, u.Gold, u.Exp, u.GoldBonus, u.ExpBonus, u.Strength, u.Dexterity,
|
|
u.Attack, u.Defense, u.WeaponID, u.ArmorID, u.ShieldID, u.Slot1ID,
|
|
u.Slot2ID, u.Slot3ID, u.WeaponName, u.ArmorName, u.ShieldName,
|
|
u.Slot1Name, u.Slot2Name, u.Slot3Name, u.DropCode, u.Spells, u.Towns}
|
|
|
|
return database.Insert(u, columns, values...)
|
|
}
|
|
|
|
func (u *User) RegisteredTime() time.Time {
|
|
return time.Unix(u.Registered, 0)
|
|
}
|
|
|
|
func (u *User) LastOnlineTime() time.Time {
|
|
return time.Unix(u.LastOnline, 0)
|
|
}
|
|
|
|
func (u *User) UpdateLastOnline() {
|
|
u.Set("LastOnline", time.Now().Unix())
|
|
}
|
|
|
|
func (u *User) IsVerified() bool {
|
|
return u.Verified == 1
|
|
}
|
|
|
|
func (u *User) IsAdmin() bool {
|
|
return u.Auth >= 4
|
|
}
|
|
|
|
func (u *User) IsModerator() bool {
|
|
return u.Auth >= 3
|
|
}
|
|
|
|
func (u *User) IsFighting() bool {
|
|
return u.Fighting == 1
|
|
}
|
|
|
|
func (u *User) IsAlive() bool {
|
|
return u.HP > 0
|
|
}
|
|
|
|
func (u *User) GetSpellIDs() []int {
|
|
return helpers.StringToInts(u.Spells)
|
|
}
|
|
|
|
func (u *User) SetSpellIDs(spells []int) {
|
|
u.Set("Spells", helpers.IntsToString(spells))
|
|
}
|
|
|
|
func (u *User) HasSpell(spellID int) bool {
|
|
return slices.Contains(u.GetSpellIDs(), spellID)
|
|
}
|
|
|
|
func (u *User) GetTownIDs() []int {
|
|
return helpers.StringToInts(u.Towns)
|
|
}
|
|
|
|
func (u *User) SetTownIDs(towns []int) {
|
|
u.Set("Towns", helpers.IntsToString(towns))
|
|
}
|
|
|
|
func (u *User) HasTownMap(townID int) bool {
|
|
return slices.Contains(u.GetTownIDs(), townID)
|
|
}
|
|
|
|
func (u *User) GetEquipment() map[string]any {
|
|
return map[string]any{
|
|
"weapon": map[string]any{"id": u.WeaponID, "name": u.WeaponName},
|
|
"armor": map[string]any{"id": u.ArmorID, "name": u.ArmorName},
|
|
"shield": map[string]any{"id": u.ShieldID, "name": u.ShieldName},
|
|
"slot1": map[string]any{"id": u.Slot1ID, "name": u.Slot1Name},
|
|
"slot2": map[string]any{"id": u.Slot2ID, "name": u.Slot2Name},
|
|
"slot3": map[string]any{"id": u.Slot3ID, "name": u.Slot3Name},
|
|
}
|
|
}
|
|
|
|
func (u *User) GetStats() map[string]int {
|
|
return map[string]int{
|
|
"level": u.Level,
|
|
"hp": u.HP,
|
|
"mp": u.MP,
|
|
"tp": u.TP,
|
|
"max_hp": u.MaxHP,
|
|
"max_mp": u.MaxMP,
|
|
"max_tp": u.MaxTP,
|
|
"strength": u.Strength,
|
|
"dexterity": u.Dexterity,
|
|
"attack": u.Attack,
|
|
"defense": u.Defense,
|
|
"uber_damage": u.UberDamage,
|
|
"uber_defense": u.UberDefense,
|
|
}
|
|
}
|
|
|
|
func (u *User) GetPosition() (int, int) {
|
|
return u.X, u.Y
|
|
}
|
|
|
|
func (u *User) SetPosition(x, y int) {
|
|
u.Set("X", x)
|
|
u.Set("Y", y)
|
|
}
|