game_sync/gamesrv/slotspkg/internal/module/player/db.go

package player

import (
	"encoding/json"
	"github.com/tomas-qstarrs/boost/cast"
	"github.com/tomas-qstarrs/boost/mathx"
	"github.com/tomas-qstarrs/boost/mjson"
	"github.com/tomas-qstarrs/boost/timex"
	"mongo.games.com/game/gamesrv/slotspkg/internal/generic/ddb"
	"mongo.games.com/game/gamesrv/slotspkg/internal/generic/global"
)

type DB struct {
}

var db DB

func (db DB) PushPlayer(uid uint64, data map[string]string) {
	if len(data) == 0 {
		return
	}

	c := ddb.RedimoClient()
	if err := c.HMSET(global.DDB.GamePlayer(uid), data); err != nil {
		panic(err)
	}
}

func (db DB) PullPlayer(uid uint64) map[string]string {
	c := ddb.RedimoClient()
	var (
		err       error
		playerMap = make(map[string]string)
		rocksMap  = make(map[string]string)
		gameMap   = make(map[string]string)
	)

	// Get game map
	gameValMap, err := c.HGETALL(global.DDB.GamePlayer(uid))
	if err != nil {
		panic(err)
	}
	for k, v := range gameValMap {
		gameMap[k] = v.String()
	}

	// Merge
	mergeFields := []string{
		"Char.TagHub",
	}
	mergeField := func(m map[string]string, k string, v string) {
		if mathx.In(k, mergeFields) {
			srcData := []byte(m[k])
			dstData := []byte(v)
			if json.Valid(srcData) && json.Valid(dstData) {
				srcData, err := mjson.Merge(srcData, dstData)
				if err != nil {
					panic(err)
				}
				m[k] = string(srcData)
				return
			}
		}
		m[k] = v
	}

	// merge game map
	for k, v := range gameMap {
		mergeField(playerMap, k, v)
	}

	// merge rocks map
	for k, v := range rocksMap {
		mergeField(playerMap, k, v)
	}

	return playerMap
}

// 按key存储
func (db DB) SaveHashTarget(k, f, v string) {
	value := make(map[string]interface{})
	value[f] = v
	c := ddb.RedimoClient()
	_, err := c.HSET(k, value)
	if err != nil {
		panic(err)
	}
}

// 按key获取
func (db DB) GetHashTarget(k, f string) string {
	c := ddb.RedimoClient()
	val, err := c.HGET(k, f)
	if err != nil {
		panic(err)
	}
	return val.String()
}

// 判断是否存在key
func (db DB) Exist(k string) bool {
	c := ddb.RedimoClient()
	val, err := c.EXISTS(k)
	if err != nil {
		panic(err)
	}
	return val
}

func (db DB) QueryPermission(keyType string, keys ...any) bool {
	var strs []string
	for _, key := range keys {
		str := cast.ToString(key)
		if len(str) == 0 {
			continue
		}

		strs = append(strs, str)
	}
	c := ddb.RedimoClient()
	valMap, err := c.HMGET(keyType, strs...)
	if err != nil {
		panic(err)
	}

	for _, val := range valMap {
		if val.Present() {
			return true
		}
	}

	return false
}

func (db DB) IncrCustomerServiceIDTimes(id int64) {
	c := ddb.RedimoClient()
	_, err := c.HINCRBY(global.DDB.SystemCustomerServiceTotal(), cast.ToString(id), 1)
	if err != nil {
		panic(err)
	}

	_, err = c.HINCRBY(global.DDB.SystemCustomerServiceDaily(timex.Now().Format("2006-01-02")), cast.ToString(id), 1)
	if err != nil {
		panic(err)
	}
}

func (db DB) GetCustomerServiceIDTimes(id int64) (int64, int64) {
	c := ddb.RedimoClient()
	total, err := c.HGET(global.DDB.SystemCustomerServiceTotal(), cast.ToString(id))
	if err != nil {
		panic(err)
	}

	daily, err := c.HGET(global.DDB.SystemCustomerServiceDaily(timex.Now().Format("2006-01-02")), cast.ToString(id))
	if err != nil {
		panic(err)
	}

	return total.Int(), daily.Int()
}

// incrMailID 获取全局自增id
func (db DB) IncrMailID() int64 {
	c := ddb.RedimoClient()
	res, err := c.INCR(global.DDB.SystemMailSN())
	if err != nil {
		panic(err)
	}
	return res
}

// 获取list长度
func (db DB) LLen(k string) int64 {
	c := ddb.RedimoClient()
	l, err := c.LLEN(k)
	if err != nil {
		panic(err)
	}
	return l
}

// 获取List全部数据
func (db DB) LAll(k string) []string {
	c := ddb.RedimoClient()
	vs, err := c.LRANGE(k, 0, -1)
	if err != nil {
		panic(err)
	}
	var res []string
	for _, v := range vs {
		res = append(res, v.String())
	}
	return res
}

// 移除list 指定数量成员
func (db DB) LPop(k string, n int64) {
	c := ddb.RedimoClient()
	for n > 0 {
		_, err := c.LPOP(k)
		if err != nil {
			panic(err)
		}
		n--
	}
}

// list 新增item
func (db DB) RPush(k string, v string) {
	c := ddb.RedimoClient()
	_, err := c.RPUSH(k, v)
	if err != nil {
		panic(err)
	}
}