hanfuit
645b64fe21
服务端（Go）： - GM 塞背包/带属性装备发放：在线角色推送 op14 增量物品行，背包实时刷新，无需回角色选择界面 - GM 改金币/改等级：去掉在线拒绝，落库后推送 op14 钱包/op37 等级状态，在线实时刷新 - 等级端点统一切换到新版 GMSetCharacterLevel（自带在线刷新） - 无限/锁死疲劳模式 + 燃烧疲劳：每房间消耗 2 点、打怪与通关经验双倍 - 燃烧疲劳开关时给所有在线角色推送系统提示（op12 mode 0） - 深渊史诗掉率：GM 全局倍率 + 城镇增益药剂窗口倍率，真实接入掉落结算 启动器（Python/JS）： - 标题栏自绘、窗口 1204x717、禁止拖拽改大小、仅最小化/关闭 - GM 工具：疲劳与燃烧、深渊史诗掉率、拍卖行上架（单一定价对齐） - 拍卖行上架前端对齐服务端单一价格语义，修复 400 报错
295 lines
9.2 KiB
Go
295 lines
9.2 KiB
Go
// 本文件实现 DNF 账号仓储的 MySQL 读写。
|
|
package mysql
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"errors"
|
|
"longheng.io/server/internal/modules/dnf/repository"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
|
|
mysql "github.com/go-sql-driver/mysql"
|
|
"longheng.io/server/internal/platform/db"
|
|
)
|
|
|
|
const (
|
|
mysqlAccountTable = "accounts"
|
|
mysqlLoginAccountTable = "login_accounts"
|
|
mysqlAccountHonorColumn = "honor_exp"
|
|
mysqlAccountHonorDDL = "BIGINT UNSIGNED NOT NULL DEFAULT 0"
|
|
mysqlAccountRepresentNameColumn = "represent_account_name"
|
|
mysqlAccountRepresentNameDDL = "VARCHAR(64) NULL"
|
|
mysqlAccountRepresentNameUniqueKey = "uk_dnf_accounts_represent_account_name"
|
|
)
|
|
|
|
func (s *mysqlAccountStore) FindAccountIDByLoginUsername(ctx context.Context, username string) (string, bool, error) {
|
|
if err := ctxErr(ctx); err != nil {
|
|
return "", false, err
|
|
}
|
|
username = strings.ToLower(strings.TrimSpace(username))
|
|
if username == "" {
|
|
return "", false, nil
|
|
}
|
|
for _, database := range s.router.readDBs {
|
|
table := mysqlTable(database, s.router.tablePrefix, mysqlLoginAccountTable)
|
|
query := "SELECT account_id FROM " + table + " WHERE username = ? AND state = 'active' LIMIT 1"
|
|
var accountID string
|
|
err := s.router.db.QueryRowContext(ctx, query, username).Scan(&accountID)
|
|
if err == nil {
|
|
return strings.TrimSpace(accountID), true, nil
|
|
}
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
continue
|
|
}
|
|
return "", false, err
|
|
}
|
|
return "", false, nil
|
|
}
|
|
|
|
type mysqlAccountStore struct {
|
|
mysqlStoreBase
|
|
}
|
|
|
|
func (s *mysqlAccountStore) ListAccounts(ctx context.Context, search string, limit int) ([]repository.AccountRecord, error) {
|
|
if err := ctxErr(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
search = strings.TrimSpace(search)
|
|
if limit <= 0 {
|
|
limit = 50
|
|
}
|
|
if limit > 200 {
|
|
limit = 200
|
|
}
|
|
pattern := "%" + search + "%"
|
|
records := make([]repository.AccountRecord, 0, limit)
|
|
seen := make(map[string]struct{}, limit)
|
|
for _, database := range s.router.readDBs {
|
|
table := mysqlTable(database, s.router.tablePrefix, mysqlAccountTable)
|
|
query := "SELECT account_id, state, honor_exp, represent_account_name, created_at, updated_at FROM " + table
|
|
args := []any{}
|
|
if search != "" {
|
|
query += " WHERE account_id LIKE ? OR represent_account_name LIKE ?"
|
|
args = append(args, pattern, pattern)
|
|
}
|
|
query += " ORDER BY updated_at DESC, account_id ASC LIMIT ?"
|
|
args = append(args, limit)
|
|
rows, err := s.router.db.QueryContext(ctx, query, args...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for rows.Next() {
|
|
var record repository.AccountRecord
|
|
var representName sql.NullString
|
|
var createdAt, updatedAt sql.NullTime
|
|
if err := rows.Scan(&record.AccountID, &record.State, &record.HonorExp, &representName, &createdAt, &updatedAt); err != nil {
|
|
_ = rows.Close()
|
|
return nil, err
|
|
}
|
|
if _, duplicate := seen[record.AccountID]; duplicate {
|
|
continue
|
|
}
|
|
seen[record.AccountID] = struct{}{}
|
|
if representName.Valid {
|
|
record.RepresentAccountName = strings.TrimSpace(representName.String)
|
|
}
|
|
record.CreatedAt = scanTime(createdAt)
|
|
record.UpdatedAt = scanTime(updatedAt)
|
|
records = append(records, record)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
_ = rows.Close()
|
|
return nil, err
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
sort.SliceStable(records, func(i, j int) bool {
|
|
if !records[i].UpdatedAt.Equal(records[j].UpdatedAt) {
|
|
return records[i].UpdatedAt.After(records[j].UpdatedAt)
|
|
}
|
|
return records[i].AccountID < records[j].AccountID
|
|
})
|
|
if len(records) > limit {
|
|
records = records[:limit]
|
|
}
|
|
return records, nil
|
|
}
|
|
|
|
// Load 按账号 ID 从 MySQL 读取 DNF 账号记录。
|
|
func (s *mysqlAccountStore) Load(ctx context.Context, accountID string) (repository.AccountRecord, bool, error) {
|
|
table, err := s.router.readTable(mysqlAccountTable, accountID)
|
|
if err != nil {
|
|
return repository.AccountRecord{}, false, err
|
|
}
|
|
metadataTable, err := s.router.readTable(mysqlAccountMetadataTable, accountID)
|
|
if err != nil {
|
|
return repository.AccountRecord{}, false, err
|
|
}
|
|
query := s.router.selectQuery("SELECT account_id, state, honor_exp, represent_account_name, created_at, updated_at FROM " + table + " WHERE account_id = ?")
|
|
var record repository.AccountRecord
|
|
var representName sql.NullString
|
|
var createdAt, updatedAt sql.NullTime
|
|
err = s.router.db.QueryRowContext(ctx, query, accountID).Scan(
|
|
&record.AccountID,
|
|
&record.State,
|
|
&record.HonorExp,
|
|
&representName,
|
|
&createdAt,
|
|
&updatedAt,
|
|
)
|
|
if err != nil {
|
|
ok, scanErr := scanErr(err)
|
|
return repository.AccountRecord{}, ok, scanErr
|
|
}
|
|
if representName.Valid {
|
|
record.RepresentAccountName = strings.TrimSpace(representName.String)
|
|
}
|
|
record.Metadata, err = loadStringMap(
|
|
ctx,
|
|
s.router.db,
|
|
s.router.selectQuery("SELECT entry_key, entry_value FROM "+metadataTable+" WHERE account_id = ? ORDER BY entry_key"),
|
|
accountID,
|
|
)
|
|
if err != nil {
|
|
return repository.AccountRecord{}, false, err
|
|
}
|
|
record.CreatedAt = scanTime(createdAt)
|
|
record.UpdatedAt = scanTime(updatedAt)
|
|
return repository.CloneAccount(record), true, nil
|
|
}
|
|
|
|
// Save 保存完整 DNF 账号记录到 MySQL。
|
|
func (s *mysqlAccountStore) Save(ctx context.Context, record repository.AccountRecord) error {
|
|
accountID, err := requireRecordKey(repository.AccountKey, record, "account")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
table, err := s.router.writeTable(mysqlAccountTable, accountID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
metadataTable, err := s.router.writeTable(mysqlAccountMetadataTable, accountID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
updatedAt := timeOrNow(record.UpdatedAt, s.router.now)
|
|
createdAt := record.CreatedAt
|
|
if createdAt.IsZero() {
|
|
createdAt = updatedAt
|
|
}
|
|
representName := strings.TrimSpace(record.RepresentAccountName)
|
|
var representNameArg any
|
|
if representName != "" {
|
|
representNameArg = representName
|
|
}
|
|
columns := []string{"account_id", "state", mysqlAccountHonorColumn, mysqlAccountRepresentNameColumn, "created_at", "updated_at"}
|
|
args := []any{accountID, record.State, record.HonorExp, representNameArg, sqlTime(createdAt), updatedAt}
|
|
updates := []string{
|
|
updateValue("state"),
|
|
updateValue(mysqlAccountHonorColumn),
|
|
updateValue(mysqlAccountRepresentNameColumn),
|
|
keepCreatedAt("created_at"),
|
|
updateValue("updated_at"),
|
|
}
|
|
err = withMySQLWriteExecutor(ctx, s.router.db, func(database SQLDB) error {
|
|
if _, execErr := database.ExecContext(ctx, buildUpsert(table, columns, updates), args...); execErr != nil {
|
|
return execErr
|
|
}
|
|
return replaceStringMap(ctx, database, metadataTable, "account_id", accountID, record.Metadata)
|
|
})
|
|
var mysqlErr *mysql.MySQLError
|
|
if errors.As(err, &mysqlErr) && mysqlErr.Number == 1062 {
|
|
return repository.ErrRepresentAccountNameExists
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (s *mysqlAccountStore) SaveMetadataEntry(
|
|
ctx context.Context,
|
|
accountID string,
|
|
key string,
|
|
value string,
|
|
updatedAt time.Time,
|
|
) error {
|
|
accountID = strings.TrimSpace(accountID)
|
|
key = strings.TrimSpace(key)
|
|
if accountID == "" {
|
|
return db.ErrRecordKeyRequired
|
|
}
|
|
if key == "" {
|
|
return repository.ErrAccountMetadataKeyRequired
|
|
}
|
|
table, err := s.router.writeTable(mysqlAccountTable, accountID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
metadataTable, err := s.router.writeTable(mysqlAccountMetadataTable, accountID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
updatedAt = timeOrNow(updatedAt, s.router.now)
|
|
return withMySQLWriteExecutor(ctx, s.router.db, func(database SQLDB) error {
|
|
updateQuery := "UPDATE " + table + " SET updated_at = ? WHERE account_id = ?"
|
|
if _, err := database.ExecContext(ctx, updateQuery, updatedAt, accountID); err != nil {
|
|
return err
|
|
}
|
|
columns := []string{"account_id", "entry_key", "entry_value"}
|
|
updates := []string{updateValue("entry_value")}
|
|
_, err := database.ExecContext(
|
|
ctx,
|
|
buildUpsert(metadataTable, columns, updates),
|
|
accountID,
|
|
key,
|
|
value,
|
|
)
|
|
return err
|
|
})
|
|
}
|
|
|
|
func (s *mysqlAccountStore) FindAccountIDByPVPTotalTeamName(ctx context.Context, name string) (string, bool, error) {
|
|
if err := ctxErr(ctx); err != nil {
|
|
return "", false, err
|
|
}
|
|
for _, database := range s.router.readDBs {
|
|
table := mysqlTable(database, s.router.tablePrefix, mysqlAccountMetadataTable)
|
|
query := "SELECT account_id FROM " + table + " WHERE entry_key = ? AND LOWER(JSON_UNQUOTE(JSON_EXTRACT(entry_value, '$.name'))) = LOWER(?) LIMIT 1"
|
|
var accountID string
|
|
err := s.router.db.QueryRowContext(ctx, query, "pvp_total_match_team_v1", name).Scan(&accountID)
|
|
if err == nil {
|
|
return accountID, true, nil
|
|
}
|
|
if !errors.Is(err, sql.ErrNoRows) {
|
|
return "", false, err
|
|
}
|
|
}
|
|
return "", false, nil
|
|
}
|
|
|
|
func (s *mysqlAccountStore) FindAccountIDByRepresentName(ctx context.Context, name string) (string, bool, error) {
|
|
if err := ctxErr(ctx); err != nil {
|
|
return "", false, err
|
|
}
|
|
name = strings.TrimSpace(name)
|
|
if name == "" {
|
|
return "", false, nil
|
|
}
|
|
for _, database := range s.router.readDBs {
|
|
table := mysqlTable(database, s.router.tablePrefix, mysqlAccountTable)
|
|
query := "SELECT account_id FROM " + table + " WHERE represent_account_name = ? LIMIT 1"
|
|
var accountID string
|
|
err := s.router.db.QueryRowContext(ctx, query, name).Scan(&accountID)
|
|
if err == nil {
|
|
return accountID, true, nil
|
|
}
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
continue
|
|
}
|
|
return "", false, err
|
|
}
|
|
return "", false, nil
|
|
}
|