1301 lines
40 KiB
Go
1301 lines
40 KiB
Go
package housing
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"time"
|
|
|
|
"zombiezen.com/go/sqlite"
|
|
"zombiezen.com/go/sqlite/sqlitex"
|
|
)
|
|
|
|
// DatabaseHousingManager implements HousingDatabase interface using zombiezen.com/go/sqlite
|
|
type DatabaseHousingManager struct {
|
|
pool *sqlitex.Pool
|
|
}
|
|
|
|
// NewDatabaseHousingManager creates a new database housing manager
|
|
func NewDatabaseHousingManager(pool *sqlitex.Pool) *DatabaseHousingManager {
|
|
return &DatabaseHousingManager{
|
|
pool: pool,
|
|
}
|
|
}
|
|
|
|
// LoadHouseZones retrieves all available house types from database
|
|
func (dhm *DatabaseHousingManager) LoadHouseZones(ctx context.Context) ([]HouseZoneData, error) {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
query := `SELECT id, name, zone_id, cost_coin, cost_status, upkeep_coin, upkeep_status,
|
|
alignment, guild_level, vault_slots, max_items, max_visitors, upkeep_period, description
|
|
FROM houses ORDER BY id`
|
|
|
|
var zones []HouseZoneData
|
|
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
|
ResultFunc: func(stmt *sqlite.Stmt) error {
|
|
zone := HouseZoneData{
|
|
ID: int32(stmt.ColumnInt64(0)),
|
|
Name: stmt.ColumnText(1),
|
|
ZoneID: int32(stmt.ColumnInt64(2)),
|
|
CostCoin: stmt.ColumnInt64(3),
|
|
CostStatus: stmt.ColumnInt64(4),
|
|
UpkeepCoin: stmt.ColumnInt64(5),
|
|
UpkeepStatus: stmt.ColumnInt64(6),
|
|
Alignment: int8(stmt.ColumnInt64(7)),
|
|
GuildLevel: int8(stmt.ColumnInt64(8)),
|
|
VaultSlots: int(stmt.ColumnInt64(9)),
|
|
MaxItems: int(stmt.ColumnInt64(10)),
|
|
MaxVisitors: int(stmt.ColumnInt64(11)),
|
|
UpkeepPeriod: int32(stmt.ColumnInt64(12)),
|
|
}
|
|
|
|
// Handle nullable description field
|
|
if stmt.ColumnType(13) != sqlite.TypeNull {
|
|
zone.Description = stmt.ColumnText(13)
|
|
}
|
|
|
|
zones = append(zones, zone)
|
|
return nil
|
|
},
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to query house zones: %w", err)
|
|
}
|
|
|
|
return zones, nil
|
|
}
|
|
|
|
// LoadHouseZone retrieves a specific house zone from database
|
|
func (dhm *DatabaseHousingManager) LoadHouseZone(ctx context.Context, houseID int32) (*HouseZoneData, error) {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
query := `SELECT id, name, zone_id, cost_coin, cost_status, upkeep_coin, upkeep_status,
|
|
alignment, guild_level, vault_slots, max_items, max_visitors, upkeep_period, description
|
|
FROM houses WHERE id = ?`
|
|
|
|
var zone HouseZoneData
|
|
found := false
|
|
|
|
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
|
Args: []any{houseID},
|
|
ResultFunc: func(stmt *sqlite.Stmt) error {
|
|
found = true
|
|
zone = HouseZoneData{
|
|
ID: int32(stmt.ColumnInt64(0)),
|
|
Name: stmt.ColumnText(1),
|
|
ZoneID: int32(stmt.ColumnInt64(2)),
|
|
CostCoin: stmt.ColumnInt64(3),
|
|
CostStatus: stmt.ColumnInt64(4),
|
|
UpkeepCoin: stmt.ColumnInt64(5),
|
|
UpkeepStatus: stmt.ColumnInt64(6),
|
|
Alignment: int8(stmt.ColumnInt64(7)),
|
|
GuildLevel: int8(stmt.ColumnInt64(8)),
|
|
VaultSlots: int(stmt.ColumnInt64(9)),
|
|
MaxItems: int(stmt.ColumnInt64(10)),
|
|
MaxVisitors: int(stmt.ColumnInt64(11)),
|
|
UpkeepPeriod: int32(stmt.ColumnInt64(12)),
|
|
}
|
|
|
|
// Handle nullable description field
|
|
if stmt.ColumnType(13) != sqlite.TypeNull {
|
|
zone.Description = stmt.ColumnText(13)
|
|
}
|
|
return nil
|
|
},
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to load house zone %d: %w", houseID, err)
|
|
}
|
|
|
|
if !found {
|
|
return nil, fmt.Errorf("house zone %d not found", houseID)
|
|
}
|
|
|
|
return &zone, nil
|
|
}
|
|
|
|
// SaveHouseZone saves a house zone to database
|
|
func (dhm *DatabaseHousingManager) SaveHouseZone(ctx context.Context, zone *HouseZone) error {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
query := `INSERT OR REPLACE INTO houses
|
|
(id, name, zone_id, cost_coin, cost_status, upkeep_coin, upkeep_status,
|
|
alignment, guild_level, vault_slots, max_items, max_visitors, upkeep_period, description)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
|
|
|
|
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
|
Args: []any{
|
|
zone.ID,
|
|
zone.Name,
|
|
zone.ZoneID,
|
|
zone.CostCoin,
|
|
zone.CostStatus,
|
|
zone.UpkeepCoin,
|
|
zone.UpkeepStatus,
|
|
zone.Alignment,
|
|
zone.GuildLevel,
|
|
zone.VaultSlots,
|
|
zone.MaxItems,
|
|
zone.MaxVisitors,
|
|
zone.UpkeepPeriod,
|
|
zone.Description,
|
|
},
|
|
})
|
|
|
|
if err != nil {
|
|
return fmt.Errorf("failed to save house zone %d: %w", zone.ID, err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// DeleteHouseZone removes a house zone from database
|
|
func (dhm *DatabaseHousingManager) DeleteHouseZone(ctx context.Context, houseID int32) error {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
err = sqlitex.Execute(conn, "DELETE FROM houses WHERE id = ?", &sqlitex.ExecOptions{
|
|
Args: []any{houseID},
|
|
})
|
|
|
|
if err != nil {
|
|
return fmt.Errorf("failed to delete house zone %d: %w", houseID, err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// LoadPlayerHouses retrieves all houses owned by a character
|
|
func (dhm *DatabaseHousingManager) LoadPlayerHouses(ctx context.Context, characterID int32) ([]PlayerHouseData, error) {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
query := `SELECT unique_id, char_id, house_id, instance_id, upkeep_due, escrow_coins, escrow_status,
|
|
status, house_name, visit_permission, public_note, private_note, allow_friends, allow_guild,
|
|
require_approval, show_on_directory, allow_decoration, tax_exempt
|
|
FROM character_houses WHERE char_id = ? ORDER BY unique_id`
|
|
|
|
var houses []PlayerHouseData
|
|
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
|
Args: []any{characterID},
|
|
ResultFunc: func(stmt *sqlite.Stmt) error {
|
|
house := PlayerHouseData{
|
|
UniqueID: stmt.ColumnInt64(0),
|
|
CharacterID: int32(stmt.ColumnInt64(1)),
|
|
HouseID: int32(stmt.ColumnInt64(2)),
|
|
InstanceID: int32(stmt.ColumnInt64(3)),
|
|
UpkeepDue: time.Unix(stmt.ColumnInt64(4), 0),
|
|
EscrowCoins: stmt.ColumnInt64(5),
|
|
EscrowStatus: stmt.ColumnInt64(6),
|
|
Status: int8(stmt.ColumnInt64(7)),
|
|
VisitPermission: int8(stmt.ColumnInt64(9)),
|
|
AllowFriends: stmt.ColumnInt64(12) != 0,
|
|
AllowGuild: stmt.ColumnInt64(13) != 0,
|
|
RequireApproval: stmt.ColumnInt64(14) != 0,
|
|
ShowOnDirectory: stmt.ColumnInt64(15) != 0,
|
|
AllowDecoration: stmt.ColumnInt64(16) != 0,
|
|
TaxExempt: stmt.ColumnInt64(17) != 0,
|
|
}
|
|
|
|
// Handle nullable fields
|
|
if stmt.ColumnType(8) != sqlite.TypeNull {
|
|
house.HouseName = stmt.ColumnText(8)
|
|
}
|
|
if stmt.ColumnType(10) != sqlite.TypeNull {
|
|
house.PublicNote = stmt.ColumnText(10)
|
|
}
|
|
if stmt.ColumnType(11) != sqlite.TypeNull {
|
|
house.PrivateNote = stmt.ColumnText(11)
|
|
}
|
|
|
|
houses = append(houses, house)
|
|
return nil
|
|
},
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to query player houses for character %d: %w", characterID, err)
|
|
}
|
|
|
|
return houses, nil
|
|
}
|
|
|
|
// LoadPlayerHouse retrieves a specific player house
|
|
func (dhm *DatabaseHousingManager) LoadPlayerHouse(ctx context.Context, uniqueID int64) (*PlayerHouseData, error) {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
query := `SELECT unique_id, char_id, house_id, instance_id, upkeep_due, escrow_coins, escrow_status,
|
|
status, house_name, visit_permission, public_note, private_note, allow_friends, allow_guild,
|
|
require_approval, show_on_directory, allow_decoration, tax_exempt
|
|
FROM character_houses WHERE unique_id = ?`
|
|
|
|
var house PlayerHouseData
|
|
found := false
|
|
|
|
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
|
Args: []any{uniqueID},
|
|
ResultFunc: func(stmt *sqlite.Stmt) error {
|
|
found = true
|
|
house = PlayerHouseData{
|
|
UniqueID: stmt.ColumnInt64(0),
|
|
CharacterID: int32(stmt.ColumnInt64(1)),
|
|
HouseID: int32(stmt.ColumnInt64(2)),
|
|
InstanceID: int32(stmt.ColumnInt64(3)),
|
|
UpkeepDue: time.Unix(stmt.ColumnInt64(4), 0),
|
|
EscrowCoins: stmt.ColumnInt64(5),
|
|
EscrowStatus: stmt.ColumnInt64(6),
|
|
Status: int8(stmt.ColumnInt64(7)),
|
|
VisitPermission: int8(stmt.ColumnInt64(9)),
|
|
AllowFriends: stmt.ColumnInt64(12) != 0,
|
|
AllowGuild: stmt.ColumnInt64(13) != 0,
|
|
RequireApproval: stmt.ColumnInt64(14) != 0,
|
|
ShowOnDirectory: stmt.ColumnInt64(15) != 0,
|
|
AllowDecoration: stmt.ColumnInt64(16) != 0,
|
|
TaxExempt: stmt.ColumnInt64(17) != 0,
|
|
}
|
|
|
|
// Handle nullable fields
|
|
if stmt.ColumnType(8) != sqlite.TypeNull {
|
|
house.HouseName = stmt.ColumnText(8)
|
|
}
|
|
if stmt.ColumnType(10) != sqlite.TypeNull {
|
|
house.PublicNote = stmt.ColumnText(10)
|
|
}
|
|
if stmt.ColumnType(11) != sqlite.TypeNull {
|
|
house.PrivateNote = stmt.ColumnText(11)
|
|
}
|
|
return nil
|
|
},
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to load player house %d: %w", uniqueID, err)
|
|
}
|
|
|
|
if !found {
|
|
return nil, fmt.Errorf("player house %d not found", uniqueID)
|
|
}
|
|
|
|
return &house, nil
|
|
}
|
|
|
|
// SavePlayerHouse saves a player house to database
|
|
func (dhm *DatabaseHousingManager) SavePlayerHouse(ctx context.Context, house *PlayerHouse) error {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
query := `INSERT OR REPLACE INTO character_houses
|
|
(unique_id, char_id, house_id, instance_id, upkeep_due, escrow_coins, escrow_status,
|
|
status, house_name, visit_permission, public_note, private_note, allow_friends, allow_guild,
|
|
require_approval, show_on_directory, allow_decoration, tax_exempt)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
|
|
|
|
upkeepDueTimestamp := house.UpkeepDue.Unix()
|
|
|
|
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
|
Args: []any{
|
|
house.UniqueID,
|
|
house.CharacterID,
|
|
house.HouseID,
|
|
house.InstanceID,
|
|
upkeepDueTimestamp,
|
|
house.EscrowCoins,
|
|
house.EscrowStatus,
|
|
house.Status,
|
|
house.Settings.HouseName,
|
|
house.Settings.VisitPermission,
|
|
house.Settings.PublicNote,
|
|
house.Settings.PrivateNote,
|
|
boolToInt(house.Settings.AllowFriends),
|
|
boolToInt(house.Settings.AllowGuild),
|
|
boolToInt(house.Settings.RequireApproval),
|
|
boolToInt(house.Settings.ShowOnDirectory),
|
|
boolToInt(house.Settings.AllowDecoration),
|
|
boolToInt(house.Settings.TaxExempt),
|
|
},
|
|
})
|
|
|
|
if err != nil {
|
|
return fmt.Errorf("failed to save player house %d: %w", house.UniqueID, err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// DeletePlayerHouse removes a player house from database
|
|
func (dhm *DatabaseHousingManager) DeletePlayerHouse(ctx context.Context, uniqueID int64) error {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
// Use a savepoint for nested transaction support
|
|
defer sqlitex.Save(conn)(&err)
|
|
|
|
// Delete related data first
|
|
tables := []string{
|
|
"character_house_deposits",
|
|
"character_house_history",
|
|
"character_house_access",
|
|
"character_house_amenities",
|
|
"character_house_items",
|
|
}
|
|
|
|
for _, table := range tables {
|
|
query := fmt.Sprintf("DELETE FROM %s WHERE house_id = ?", table)
|
|
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
|
Args: []any{uniqueID},
|
|
})
|
|
if err != nil {
|
|
return fmt.Errorf("failed to delete from %s: %w", table, err)
|
|
}
|
|
}
|
|
|
|
// Delete the house itself
|
|
err = sqlitex.Execute(conn, "DELETE FROM character_houses WHERE unique_id = ?", &sqlitex.ExecOptions{
|
|
Args: []any{uniqueID},
|
|
})
|
|
if err != nil {
|
|
return fmt.Errorf("failed to delete player house: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// AddPlayerHouse creates a new player house entry
|
|
func (dhm *DatabaseHousingManager) AddPlayerHouse(ctx context.Context, houseData PlayerHouseData) (int64, error) {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
query := `INSERT INTO character_houses
|
|
(char_id, house_id, instance_id, upkeep_due, escrow_coins, escrow_status,
|
|
status, house_name, visit_permission, public_note, private_note, allow_friends, allow_guild,
|
|
require_approval, show_on_directory, allow_decoration, tax_exempt)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
|
|
|
|
upkeepDueTimestamp := houseData.UpkeepDue.Unix()
|
|
|
|
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
|
Args: []any{
|
|
houseData.CharacterID,
|
|
houseData.HouseID,
|
|
houseData.InstanceID,
|
|
upkeepDueTimestamp,
|
|
houseData.EscrowCoins,
|
|
houseData.EscrowStatus,
|
|
houseData.Status,
|
|
houseData.HouseName,
|
|
houseData.VisitPermission,
|
|
houseData.PublicNote,
|
|
houseData.PrivateNote,
|
|
boolToInt(houseData.AllowFriends),
|
|
boolToInt(houseData.AllowGuild),
|
|
boolToInt(houseData.RequireApproval),
|
|
boolToInt(houseData.ShowOnDirectory),
|
|
boolToInt(houseData.AllowDecoration),
|
|
boolToInt(houseData.TaxExempt),
|
|
},
|
|
})
|
|
|
|
if err != nil {
|
|
return 0, fmt.Errorf("failed to create player house: %w", err)
|
|
}
|
|
|
|
// Get the last inserted ID
|
|
return conn.LastInsertRowID(), nil
|
|
}
|
|
|
|
// LoadDeposits retrieves deposit history for a house
|
|
func (dhm *DatabaseHousingManager) LoadDeposits(ctx context.Context, houseID int64) ([]HouseDepositData, error) {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
query := `SELECT house_id, timestamp, amount, last_amount, status, last_status, name, character_id
|
|
FROM character_house_deposits WHERE house_id = ?
|
|
ORDER BY timestamp DESC LIMIT ?`
|
|
|
|
var deposits []HouseDepositData
|
|
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
|
Args: []any{houseID, MaxDepositHistory},
|
|
ResultFunc: func(stmt *sqlite.Stmt) error {
|
|
deposit := HouseDepositData{
|
|
HouseID: stmt.ColumnInt64(0),
|
|
Timestamp: time.Unix(stmt.ColumnInt64(1), 0),
|
|
Amount: stmt.ColumnInt64(2),
|
|
LastAmount: stmt.ColumnInt64(3),
|
|
Status: stmt.ColumnInt64(4),
|
|
LastStatus: stmt.ColumnInt64(5),
|
|
Name: stmt.ColumnText(6),
|
|
CharacterID: int32(stmt.ColumnInt64(7)),
|
|
}
|
|
deposits = append(deposits, deposit)
|
|
return nil
|
|
},
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to query house deposits for house %d: %w", houseID, err)
|
|
}
|
|
|
|
return deposits, nil
|
|
}
|
|
|
|
// SaveDeposit saves a deposit record
|
|
func (dhm *DatabaseHousingManager) SaveDeposit(ctx context.Context, houseID int64, deposit HouseDeposit) error {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
query := `INSERT INTO character_house_deposits
|
|
(house_id, timestamp, amount, last_amount, status, last_status, name, character_id)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
|
|
|
|
timestampUnix := deposit.Timestamp.Unix()
|
|
|
|
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
|
Args: []any{
|
|
houseID,
|
|
timestampUnix,
|
|
deposit.Amount,
|
|
deposit.LastAmount,
|
|
deposit.Status,
|
|
deposit.LastStatus,
|
|
deposit.Name,
|
|
deposit.CharacterID,
|
|
},
|
|
})
|
|
|
|
if err != nil {
|
|
return fmt.Errorf("failed to save house deposit: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// LoadHistory retrieves transaction history for a house
|
|
func (dhm *DatabaseHousingManager) LoadHistory(ctx context.Context, houseID int64) ([]HouseHistoryData, error) {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
query := `SELECT house_id, timestamp, amount, status, reason, name, character_id, pos_flag, type
|
|
FROM character_house_history WHERE house_id = ?
|
|
ORDER BY timestamp DESC LIMIT ?`
|
|
|
|
var history []HouseHistoryData
|
|
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
|
Args: []any{houseID, MaxTransactionHistory},
|
|
ResultFunc: func(stmt *sqlite.Stmt) error {
|
|
entry := HouseHistoryData{
|
|
HouseID: stmt.ColumnInt64(0),
|
|
Timestamp: time.Unix(stmt.ColumnInt64(1), 0),
|
|
Amount: stmt.ColumnInt64(2),
|
|
Status: stmt.ColumnInt64(3),
|
|
Reason: stmt.ColumnText(4),
|
|
Name: stmt.ColumnText(5),
|
|
CharacterID: int32(stmt.ColumnInt64(6)),
|
|
PosFlag: int8(stmt.ColumnInt64(7)),
|
|
Type: int(stmt.ColumnInt64(8)),
|
|
}
|
|
history = append(history, entry)
|
|
return nil
|
|
},
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to query house history for house %d: %w", houseID, err)
|
|
}
|
|
|
|
return history, nil
|
|
}
|
|
|
|
// AddHistory adds a new history entry
|
|
func (dhm *DatabaseHousingManager) AddHistory(ctx context.Context, houseID int64, history HouseHistory) error {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
query := `INSERT INTO character_house_history
|
|
(house_id, timestamp, amount, status, reason, name, character_id, pos_flag, type)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
|
|
|
|
timestampUnix := history.Timestamp.Unix()
|
|
|
|
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
|
Args: []any{
|
|
houseID,
|
|
timestampUnix,
|
|
history.Amount,
|
|
history.Status,
|
|
history.Reason,
|
|
history.Name,
|
|
history.CharacterID,
|
|
history.PosFlag,
|
|
history.Type,
|
|
},
|
|
})
|
|
|
|
if err != nil {
|
|
return fmt.Errorf("failed to add house history: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// LoadHouseAccess retrieves access permissions for a house
|
|
func (dhm *DatabaseHousingManager) LoadHouseAccess(ctx context.Context, houseID int64) ([]HouseAccessData, error) {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
query := `SELECT house_id, character_id, player_name, access_level, permissions, granted_by,
|
|
granted_date, expires_date, notes
|
|
FROM character_house_access WHERE house_id = ?`
|
|
|
|
var accessList []HouseAccessData
|
|
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
|
Args: []any{houseID},
|
|
ResultFunc: func(stmt *sqlite.Stmt) error {
|
|
access := HouseAccessData{
|
|
HouseID: stmt.ColumnInt64(0),
|
|
CharacterID: int32(stmt.ColumnInt64(1)),
|
|
PlayerName: stmt.ColumnText(2),
|
|
AccessLevel: int8(stmt.ColumnInt64(3)),
|
|
Permissions: int32(stmt.ColumnInt64(4)),
|
|
GrantedBy: int32(stmt.ColumnInt64(5)),
|
|
GrantedDate: time.Unix(stmt.ColumnInt64(6), 0),
|
|
ExpiresDate: time.Unix(stmt.ColumnInt64(7), 0),
|
|
}
|
|
|
|
if stmt.ColumnType(8) != sqlite.TypeNull {
|
|
access.Notes = stmt.ColumnText(8)
|
|
}
|
|
|
|
accessList = append(accessList, access)
|
|
return nil
|
|
},
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to query house access for house %d: %w", houseID, err)
|
|
}
|
|
|
|
return accessList, nil
|
|
}
|
|
|
|
// SaveHouseAccess saves access permissions for a house
|
|
func (dhm *DatabaseHousingManager) SaveHouseAccess(ctx context.Context, houseID int64, accessList []HouseAccess) error {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
// Use a savepoint for nested transaction support
|
|
defer sqlitex.Save(conn)(&err)
|
|
|
|
// Delete existing access for this house
|
|
err = sqlitex.Execute(conn, "DELETE FROM character_house_access WHERE house_id = ?", &sqlitex.ExecOptions{
|
|
Args: []any{houseID},
|
|
})
|
|
if err != nil {
|
|
return fmt.Errorf("failed to delete existing house access: %w", err)
|
|
}
|
|
|
|
// Insert all access entries
|
|
insertQuery := `INSERT INTO character_house_access
|
|
(house_id, character_id, player_name, access_level, permissions, granted_by,
|
|
granted_date, expires_date, notes)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
|
|
|
|
for _, access := range accessList {
|
|
grantedDateUnix := access.GrantedDate.Unix()
|
|
expiresDateUnix := access.ExpiresDate.Unix()
|
|
|
|
err = sqlitex.Execute(conn, insertQuery, &sqlitex.ExecOptions{
|
|
Args: []any{
|
|
houseID,
|
|
access.CharacterID,
|
|
access.PlayerName,
|
|
access.AccessLevel,
|
|
access.Permissions,
|
|
access.GrantedBy,
|
|
grantedDateUnix,
|
|
expiresDateUnix,
|
|
access.Notes,
|
|
},
|
|
})
|
|
if err != nil {
|
|
return fmt.Errorf("failed to insert house access for character %d: %w", access.CharacterID, err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// DeleteHouseAccess removes access for a specific character
|
|
func (dhm *DatabaseHousingManager) DeleteHouseAccess(ctx context.Context, houseID int64, characterID int32) error {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
err = sqlitex.Execute(conn,
|
|
"DELETE FROM character_house_access WHERE house_id = ? AND character_id = ?",
|
|
&sqlitex.ExecOptions{
|
|
Args: []any{houseID, characterID},
|
|
})
|
|
|
|
if err != nil {
|
|
return fmt.Errorf("failed to delete house access: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// LoadHouseAmenities retrieves amenities for a house
|
|
func (dhm *DatabaseHousingManager) LoadHouseAmenities(ctx context.Context, houseID int64) ([]HouseAmenityData, error) {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
query := `SELECT house_id, id, type, name, cost, status_cost, purchase_date, x, y, z, heading, is_active
|
|
FROM character_house_amenities WHERE house_id = ?`
|
|
|
|
var amenities []HouseAmenityData
|
|
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
|
Args: []any{houseID},
|
|
ResultFunc: func(stmt *sqlite.Stmt) error {
|
|
amenity := HouseAmenityData{
|
|
HouseID: stmt.ColumnInt64(0),
|
|
ID: int32(stmt.ColumnInt64(1)),
|
|
Type: int(stmt.ColumnInt64(2)),
|
|
Name: stmt.ColumnText(3),
|
|
Cost: stmt.ColumnInt64(4),
|
|
StatusCost: stmt.ColumnInt64(5),
|
|
PurchaseDate: time.Unix(stmt.ColumnInt64(6), 0),
|
|
X: float32(stmt.ColumnFloat(7)),
|
|
Y: float32(stmt.ColumnFloat(8)),
|
|
Z: float32(stmt.ColumnFloat(9)),
|
|
Heading: float32(stmt.ColumnFloat(10)),
|
|
IsActive: stmt.ColumnInt64(11) != 0,
|
|
}
|
|
amenities = append(amenities, amenity)
|
|
return nil
|
|
},
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to query house amenities for house %d: %w", houseID, err)
|
|
}
|
|
|
|
return amenities, nil
|
|
}
|
|
|
|
// SaveHouseAmenity saves a house amenity
|
|
func (dhm *DatabaseHousingManager) SaveHouseAmenity(ctx context.Context, houseID int64, amenity HouseAmenity) error {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
query := `INSERT OR REPLACE INTO character_house_amenities
|
|
(house_id, id, type, name, cost, status_cost, purchase_date, x, y, z, heading, is_active)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
|
|
|
|
purchaseDateUnix := amenity.PurchaseDate.Unix()
|
|
|
|
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
|
Args: []any{
|
|
houseID,
|
|
amenity.ID,
|
|
amenity.Type,
|
|
amenity.Name,
|
|
amenity.Cost,
|
|
amenity.StatusCost,
|
|
purchaseDateUnix,
|
|
amenity.X,
|
|
amenity.Y,
|
|
amenity.Z,
|
|
amenity.Heading,
|
|
boolToInt(amenity.IsActive),
|
|
},
|
|
})
|
|
|
|
if err != nil {
|
|
return fmt.Errorf("failed to save house amenity: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// DeleteHouseAmenity removes a house amenity
|
|
func (dhm *DatabaseHousingManager) DeleteHouseAmenity(ctx context.Context, houseID int64, amenityID int32) error {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
err = sqlitex.Execute(conn,
|
|
"DELETE FROM character_house_amenities WHERE house_id = ? AND id = ?",
|
|
&sqlitex.ExecOptions{
|
|
Args: []any{houseID, amenityID},
|
|
})
|
|
|
|
if err != nil {
|
|
return fmt.Errorf("failed to delete house amenity: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// LoadHouseItems retrieves items placed in a house
|
|
func (dhm *DatabaseHousingManager) LoadHouseItems(ctx context.Context, houseID int64) ([]HouseItemData, error) {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
query := `SELECT house_id, id, item_id, character_id, x, y, z, heading, pitch_x, pitch_y,
|
|
roll_x, roll_y, placed_date, quantity, condition, house
|
|
FROM character_house_items WHERE house_id = ?`
|
|
|
|
var items []HouseItemData
|
|
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
|
Args: []any{houseID},
|
|
ResultFunc: func(stmt *sqlite.Stmt) error {
|
|
item := HouseItemData{
|
|
HouseID: stmt.ColumnInt64(0),
|
|
ID: stmt.ColumnInt64(1),
|
|
ItemID: int32(stmt.ColumnInt64(2)),
|
|
CharacterID: int32(stmt.ColumnInt64(3)),
|
|
X: float32(stmt.ColumnFloat(4)),
|
|
Y: float32(stmt.ColumnFloat(5)),
|
|
Z: float32(stmt.ColumnFloat(6)),
|
|
Heading: float32(stmt.ColumnFloat(7)),
|
|
PitchX: float32(stmt.ColumnFloat(8)),
|
|
PitchY: float32(stmt.ColumnFloat(9)),
|
|
RollX: float32(stmt.ColumnFloat(10)),
|
|
RollY: float32(stmt.ColumnFloat(11)),
|
|
PlacedDate: time.Unix(stmt.ColumnInt64(12), 0),
|
|
Quantity: int32(stmt.ColumnInt64(13)),
|
|
Condition: int8(stmt.ColumnInt64(14)),
|
|
House: stmt.ColumnText(15),
|
|
}
|
|
items = append(items, item)
|
|
return nil
|
|
},
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to query house items for house %d: %w", houseID, err)
|
|
}
|
|
|
|
return items, nil
|
|
}
|
|
|
|
// SaveHouseItem saves a house item
|
|
func (dhm *DatabaseHousingManager) SaveHouseItem(ctx context.Context, houseID int64, item HouseItem) error {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
query := `INSERT OR REPLACE INTO character_house_items
|
|
(house_id, id, item_id, character_id, x, y, z, heading, pitch_x, pitch_y,
|
|
roll_x, roll_y, placed_date, quantity, condition, house)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
|
|
|
|
placedDateUnix := item.PlacedDate.Unix()
|
|
|
|
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
|
Args: []any{
|
|
houseID,
|
|
item.ID,
|
|
item.ItemID,
|
|
item.CharacterID,
|
|
item.X,
|
|
item.Y,
|
|
item.Z,
|
|
item.Heading,
|
|
item.PitchX,
|
|
item.PitchY,
|
|
item.RollX,
|
|
item.RollY,
|
|
placedDateUnix,
|
|
item.Quantity,
|
|
item.Condition,
|
|
item.House,
|
|
},
|
|
})
|
|
|
|
if err != nil {
|
|
return fmt.Errorf("failed to save house item: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// DeleteHouseItem removes a house item
|
|
func (dhm *DatabaseHousingManager) DeleteHouseItem(ctx context.Context, houseID int64, itemID int64) error {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
err = sqlitex.Execute(conn,
|
|
"DELETE FROM character_house_items WHERE house_id = ? AND id = ?",
|
|
&sqlitex.ExecOptions{
|
|
Args: []any{houseID, itemID},
|
|
})
|
|
|
|
if err != nil {
|
|
return fmt.Errorf("failed to delete house item: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// GetNextHouseID returns the next available house unique ID
|
|
func (dhm *DatabaseHousingManager) GetNextHouseID(ctx context.Context) (int64, error) {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
query := "SELECT COALESCE(MAX(unique_id), 0) + 1 FROM character_houses"
|
|
|
|
var nextID int64
|
|
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
|
ResultFunc: func(stmt *sqlite.Stmt) error {
|
|
nextID = stmt.ColumnInt64(0)
|
|
return nil
|
|
},
|
|
})
|
|
|
|
if err != nil {
|
|
return 0, fmt.Errorf("failed to get next house ID: %w", err)
|
|
}
|
|
|
|
return nextID, nil
|
|
}
|
|
|
|
// GetHouseByInstance finds a house by instance ID
|
|
func (dhm *DatabaseHousingManager) GetHouseByInstance(ctx context.Context, instanceID int32) (*PlayerHouseData, error) {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
query := `SELECT unique_id, char_id, house_id, instance_id, upkeep_due, escrow_coins, escrow_status,
|
|
status, house_name, visit_permission, public_note, private_note, allow_friends, allow_guild,
|
|
require_approval, show_on_directory, allow_decoration, tax_exempt
|
|
FROM character_houses WHERE instance_id = ?`
|
|
|
|
var house PlayerHouseData
|
|
found := false
|
|
|
|
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
|
Args: []any{instanceID},
|
|
ResultFunc: func(stmt *sqlite.Stmt) error {
|
|
found = true
|
|
house = PlayerHouseData{
|
|
UniqueID: stmt.ColumnInt64(0),
|
|
CharacterID: int32(stmt.ColumnInt64(1)),
|
|
HouseID: int32(stmt.ColumnInt64(2)),
|
|
InstanceID: int32(stmt.ColumnInt64(3)),
|
|
UpkeepDue: time.Unix(stmt.ColumnInt64(4), 0),
|
|
EscrowCoins: stmt.ColumnInt64(5),
|
|
EscrowStatus: stmt.ColumnInt64(6),
|
|
Status: int8(stmt.ColumnInt64(7)),
|
|
VisitPermission: int8(stmt.ColumnInt64(9)),
|
|
AllowFriends: stmt.ColumnInt64(12) != 0,
|
|
AllowGuild: stmt.ColumnInt64(13) != 0,
|
|
RequireApproval: stmt.ColumnInt64(14) != 0,
|
|
ShowOnDirectory: stmt.ColumnInt64(15) != 0,
|
|
AllowDecoration: stmt.ColumnInt64(16) != 0,
|
|
TaxExempt: stmt.ColumnInt64(17) != 0,
|
|
}
|
|
|
|
// Handle nullable fields
|
|
if stmt.ColumnType(8) != sqlite.TypeNull {
|
|
house.HouseName = stmt.ColumnText(8)
|
|
}
|
|
if stmt.ColumnType(10) != sqlite.TypeNull {
|
|
house.PublicNote = stmt.ColumnText(10)
|
|
}
|
|
if stmt.ColumnType(11) != sqlite.TypeNull {
|
|
house.PrivateNote = stmt.ColumnText(11)
|
|
}
|
|
return nil
|
|
},
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to load house by instance %d: %w", instanceID, err)
|
|
}
|
|
|
|
if !found {
|
|
return nil, fmt.Errorf("house with instance %d not found", instanceID)
|
|
}
|
|
|
|
return &house, nil
|
|
}
|
|
|
|
// UpdateHouseUpkeepDue updates the upkeep due date for a house
|
|
func (dhm *DatabaseHousingManager) UpdateHouseUpkeepDue(ctx context.Context, houseID int64, upkeepDue time.Time) error {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
query := "UPDATE character_houses SET upkeep_due = ? WHERE unique_id = ?"
|
|
upkeepDueTimestamp := upkeepDue.Unix()
|
|
|
|
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
|
Args: []any{upkeepDueTimestamp, houseID},
|
|
})
|
|
|
|
if err != nil {
|
|
return fmt.Errorf("failed to update house upkeep due: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// UpdateHouseEscrow updates the escrow balances for a house
|
|
func (dhm *DatabaseHousingManager) UpdateHouseEscrow(ctx context.Context, houseID int64, coins, status int64) error {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
query := "UPDATE character_houses SET escrow_coins = ?, escrow_status = ? WHERE unique_id = ?"
|
|
|
|
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
|
Args: []any{coins, status, houseID},
|
|
})
|
|
|
|
if err != nil {
|
|
return fmt.Errorf("failed to update house escrow: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// GetHousesForUpkeep returns houses that need upkeep processing
|
|
func (dhm *DatabaseHousingManager) GetHousesForUpkeep(ctx context.Context, cutoffTime time.Time) ([]PlayerHouseData, error) {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
query := `SELECT unique_id, char_id, house_id, instance_id, upkeep_due, escrow_coins, escrow_status,
|
|
status, house_name, visit_permission, public_note, private_note, allow_friends, allow_guild,
|
|
require_approval, show_on_directory, allow_decoration, tax_exempt
|
|
FROM character_houses WHERE upkeep_due <= ? AND status = ?`
|
|
|
|
cutoffTimestamp := cutoffTime.Unix()
|
|
|
|
var houses []PlayerHouseData
|
|
err = sqlitex.Execute(conn, query, &sqlitex.ExecOptions{
|
|
Args: []any{cutoffTimestamp, HouseStatusActive},
|
|
ResultFunc: func(stmt *sqlite.Stmt) error {
|
|
house := PlayerHouseData{
|
|
UniqueID: stmt.ColumnInt64(0),
|
|
CharacterID: int32(stmt.ColumnInt64(1)),
|
|
HouseID: int32(stmt.ColumnInt64(2)),
|
|
InstanceID: int32(stmt.ColumnInt64(3)),
|
|
UpkeepDue: time.Unix(stmt.ColumnInt64(4), 0),
|
|
EscrowCoins: stmt.ColumnInt64(5),
|
|
EscrowStatus: stmt.ColumnInt64(6),
|
|
Status: int8(stmt.ColumnInt64(7)),
|
|
VisitPermission: int8(stmt.ColumnInt64(9)),
|
|
AllowFriends: stmt.ColumnInt64(12) != 0,
|
|
AllowGuild: stmt.ColumnInt64(13) != 0,
|
|
RequireApproval: stmt.ColumnInt64(14) != 0,
|
|
ShowOnDirectory: stmt.ColumnInt64(15) != 0,
|
|
AllowDecoration: stmt.ColumnInt64(16) != 0,
|
|
TaxExempt: stmt.ColumnInt64(17) != 0,
|
|
}
|
|
|
|
// Handle nullable fields
|
|
if stmt.ColumnType(8) != sqlite.TypeNull {
|
|
house.HouseName = stmt.ColumnText(8)
|
|
}
|
|
if stmt.ColumnType(10) != sqlite.TypeNull {
|
|
house.PublicNote = stmt.ColumnText(10)
|
|
}
|
|
if stmt.ColumnType(11) != sqlite.TypeNull {
|
|
house.PrivateNote = stmt.ColumnText(11)
|
|
}
|
|
|
|
houses = append(houses, house)
|
|
return nil
|
|
},
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to query houses for upkeep: %w", err)
|
|
}
|
|
|
|
return houses, nil
|
|
}
|
|
|
|
// GetHouseStatistics returns housing system statistics
|
|
func (dhm *DatabaseHousingManager) GetHouseStatistics(ctx context.Context) (*HousingStatistics, error) {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
stats := &HousingStatistics{
|
|
HousesByType: make(map[int32]int64),
|
|
HousesByAlignment: make(map[int8]int64),
|
|
RevenueByType: make(map[int]int64),
|
|
TopDepositors: make([]PlayerDeposits, 0),
|
|
}
|
|
|
|
// Get basic counts
|
|
queries := []struct {
|
|
query string
|
|
target *int64
|
|
}{
|
|
{"SELECT COUNT(*) FROM character_houses", &stats.TotalHouses},
|
|
{"SELECT COUNT(*) FROM character_houses WHERE status = 0", &stats.ActiveHouses},
|
|
{"SELECT COUNT(*) FROM character_houses WHERE status = 2", &stats.ForelosedHouses},
|
|
{"SELECT COUNT(*) FROM character_house_deposits", &stats.TotalDeposits},
|
|
{"SELECT COUNT(*) FROM character_house_history WHERE pos_flag = 0", &stats.TotalWithdrawals},
|
|
}
|
|
|
|
for _, q := range queries {
|
|
err = sqlitex.Execute(conn, q.query, &sqlitex.ExecOptions{
|
|
ResultFunc: func(stmt *sqlite.Stmt) error {
|
|
*q.target = stmt.ColumnInt64(0)
|
|
return nil
|
|
},
|
|
})
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to get statistics: %w", err)
|
|
}
|
|
}
|
|
|
|
return stats, nil
|
|
}
|
|
|
|
// EnsureHousingTables creates the housing tables if they don't exist
|
|
func (dhm *DatabaseHousingManager) EnsureHousingTables(ctx context.Context) error {
|
|
conn, err := dhm.pool.Take(ctx)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to get database connection: %w", err)
|
|
}
|
|
defer dhm.pool.Put(conn)
|
|
|
|
queries := []string{
|
|
`CREATE TABLE IF NOT EXISTS houses (
|
|
id INTEGER PRIMARY KEY,
|
|
name TEXT NOT NULL,
|
|
zone_id INTEGER NOT NULL,
|
|
cost_coin INTEGER NOT NULL DEFAULT 0,
|
|
cost_status INTEGER NOT NULL DEFAULT 0,
|
|
upkeep_coin INTEGER NOT NULL DEFAULT 0,
|
|
upkeep_status INTEGER NOT NULL DEFAULT 0,
|
|
alignment INTEGER NOT NULL DEFAULT 0,
|
|
guild_level INTEGER NOT NULL DEFAULT 0,
|
|
vault_slots INTEGER NOT NULL DEFAULT 4,
|
|
max_items INTEGER NOT NULL DEFAULT 100,
|
|
max_visitors INTEGER NOT NULL DEFAULT 50,
|
|
upkeep_period INTEGER NOT NULL DEFAULT 604800,
|
|
description TEXT DEFAULT '',
|
|
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
|
|
updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
|
|
)`,
|
|
`CREATE TABLE IF NOT EXISTS character_houses (
|
|
unique_id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
char_id INTEGER NOT NULL,
|
|
house_id INTEGER NOT NULL,
|
|
instance_id INTEGER NOT NULL,
|
|
upkeep_due INTEGER NOT NULL,
|
|
escrow_coins INTEGER NOT NULL DEFAULT 0,
|
|
escrow_status INTEGER NOT NULL DEFAULT 0,
|
|
status INTEGER NOT NULL DEFAULT 0,
|
|
house_name TEXT DEFAULT '',
|
|
visit_permission INTEGER NOT NULL DEFAULT 0,
|
|
public_note TEXT DEFAULT '',
|
|
private_note TEXT DEFAULT '',
|
|
allow_friends INTEGER NOT NULL DEFAULT 1,
|
|
allow_guild INTEGER NOT NULL DEFAULT 0,
|
|
require_approval INTEGER NOT NULL DEFAULT 0,
|
|
show_on_directory INTEGER NOT NULL DEFAULT 1,
|
|
allow_decoration INTEGER NOT NULL DEFAULT 0,
|
|
tax_exempt INTEGER NOT NULL DEFAULT 0,
|
|
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
|
|
FOREIGN KEY (house_id) REFERENCES houses(id)
|
|
)`,
|
|
`CREATE TABLE IF NOT EXISTS character_house_deposits (
|
|
house_id INTEGER NOT NULL,
|
|
timestamp INTEGER NOT NULL,
|
|
amount INTEGER NOT NULL,
|
|
last_amount INTEGER NOT NULL,
|
|
status INTEGER NOT NULL,
|
|
last_status INTEGER NOT NULL,
|
|
name TEXT NOT NULL,
|
|
character_id INTEGER NOT NULL,
|
|
FOREIGN KEY (house_id) REFERENCES character_houses(unique_id) ON DELETE CASCADE
|
|
)`,
|
|
`CREATE TABLE IF NOT EXISTS character_house_history (
|
|
house_id INTEGER NOT NULL,
|
|
timestamp INTEGER NOT NULL,
|
|
amount INTEGER NOT NULL,
|
|
status INTEGER NOT NULL,
|
|
reason TEXT NOT NULL,
|
|
name TEXT NOT NULL,
|
|
character_id INTEGER NOT NULL,
|
|
pos_flag INTEGER NOT NULL,
|
|
type INTEGER NOT NULL,
|
|
FOREIGN KEY (house_id) REFERENCES character_houses(unique_id) ON DELETE CASCADE
|
|
)`,
|
|
`CREATE TABLE IF NOT EXISTS character_house_access (
|
|
house_id INTEGER NOT NULL,
|
|
character_id INTEGER NOT NULL,
|
|
player_name TEXT NOT NULL,
|
|
access_level INTEGER NOT NULL,
|
|
permissions INTEGER NOT NULL,
|
|
granted_by INTEGER NOT NULL,
|
|
granted_date INTEGER NOT NULL,
|
|
expires_date INTEGER NOT NULL,
|
|
notes TEXT DEFAULT '',
|
|
PRIMARY KEY (house_id, character_id),
|
|
FOREIGN KEY (house_id) REFERENCES character_houses(unique_id) ON DELETE CASCADE
|
|
)`,
|
|
`CREATE TABLE IF NOT EXISTS character_house_amenities (
|
|
house_id INTEGER NOT NULL,
|
|
id INTEGER NOT NULL,
|
|
type INTEGER NOT NULL,
|
|
name TEXT NOT NULL,
|
|
cost INTEGER NOT NULL,
|
|
status_cost INTEGER NOT NULL,
|
|
purchase_date INTEGER NOT NULL,
|
|
x REAL NOT NULL,
|
|
y REAL NOT NULL,
|
|
z REAL NOT NULL,
|
|
heading REAL NOT NULL,
|
|
is_active INTEGER NOT NULL DEFAULT 1,
|
|
PRIMARY KEY (house_id, id),
|
|
FOREIGN KEY (house_id) REFERENCES character_houses(unique_id) ON DELETE CASCADE
|
|
)`,
|
|
`CREATE TABLE IF NOT EXISTS character_house_items (
|
|
house_id INTEGER NOT NULL,
|
|
id INTEGER NOT NULL,
|
|
item_id INTEGER NOT NULL,
|
|
character_id INTEGER NOT NULL,
|
|
x REAL NOT NULL,
|
|
y REAL NOT NULL,
|
|
z REAL NOT NULL,
|
|
heading REAL NOT NULL,
|
|
pitch_x REAL NOT NULL DEFAULT 0,
|
|
pitch_y REAL NOT NULL DEFAULT 0,
|
|
roll_x REAL NOT NULL DEFAULT 0,
|
|
roll_y REAL NOT NULL DEFAULT 0,
|
|
placed_date INTEGER NOT NULL,
|
|
quantity INTEGER NOT NULL,
|
|
condition INTEGER NOT NULL,
|
|
house TEXT NOT NULL,
|
|
PRIMARY KEY (house_id, id),
|
|
FOREIGN KEY (house_id) REFERENCES character_houses(unique_id) ON DELETE CASCADE
|
|
)`,
|
|
}
|
|
|
|
for i, query := range queries {
|
|
if err := sqlitex.Execute(conn, query, nil); err != nil {
|
|
return fmt.Errorf("failed to create housing table %d: %w", i+1, err)
|
|
}
|
|
}
|
|
|
|
// Create indexes for better performance
|
|
indexes := []string{
|
|
`CREATE INDEX IF NOT EXISTS idx_character_houses_char_id ON character_houses(char_id)`,
|
|
`CREATE INDEX IF NOT EXISTS idx_character_houses_instance_id ON character_houses(instance_id)`,
|
|
`CREATE INDEX IF NOT EXISTS idx_character_houses_upkeep_due ON character_houses(upkeep_due)`,
|
|
`CREATE INDEX IF NOT EXISTS idx_character_houses_status ON character_houses(status)`,
|
|
`CREATE INDEX IF NOT EXISTS idx_house_deposits_house_id ON character_house_deposits(house_id)`,
|
|
`CREATE INDEX IF NOT EXISTS idx_house_deposits_timestamp ON character_house_deposits(timestamp)`,
|
|
`CREATE INDEX IF NOT EXISTS idx_house_history_house_id ON character_house_history(house_id)`,
|
|
`CREATE INDEX IF NOT EXISTS idx_house_history_timestamp ON character_house_history(timestamp)`,
|
|
`CREATE INDEX IF NOT EXISTS idx_house_access_character_id ON character_house_access(character_id)`,
|
|
`CREATE INDEX IF NOT EXISTS idx_house_items_item_id ON character_house_items(item_id)`,
|
|
`CREATE INDEX IF NOT EXISTS idx_houses_zone_id ON houses(zone_id)`,
|
|
`CREATE INDEX IF NOT EXISTS idx_houses_alignment ON houses(alignment)`,
|
|
}
|
|
|
|
for i, query := range indexes {
|
|
if err := sqlitex.Execute(conn, query, nil); err != nil {
|
|
return fmt.Errorf("failed to create housing index %d: %w", i+1, err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Helper function to convert bool to int for SQLite
|
|
func boolToInt(b bool) int {
|
|
if b {
|
|
return 1
|
|
}
|
|
return 0
|
|
} |