160 lines
3.5 KiB
Go
160 lines
3.5 KiB
Go
package model
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"github.com/go-redis/redis/v8"
|
|
"gorm.io/gorm"
|
|
"samba/pkg/log"
|
|
"samba/stub"
|
|
"samba/util/rdbkey"
|
|
"samba/util/util"
|
|
)
|
|
|
|
const (
|
|
// 最小幸运值
|
|
minLuckyPoint = -100
|
|
// 最大幸运值
|
|
maxLuckyPoint = 100
|
|
)
|
|
|
|
type UserLuckyPoint struct {
|
|
Uid int64 `json:"uid" gorm:"column:uid"`
|
|
// 是否是幸运用户
|
|
LuckyUser bool `json:"lucky_user" gorm:"column:lucky_user"`
|
|
// 玩家基础幸运值
|
|
LuckyPoint int `json:"lucky_point" gorm:"column:lucky_point"`
|
|
// truco的幸运值
|
|
TrucoLP int `json:"truco_lp" gorm:"column:truco_lp"`
|
|
// cacheta幸运值
|
|
CachetaLP int `json:"cacheta_lp" gorm:"column:cacheta_lp"`
|
|
}
|
|
|
|
func (u *UserLuckyPoint) GetLuckyPoint(name string) (point int) {
|
|
defer func() {
|
|
if point > maxLuckyPoint {
|
|
point = maxLuckyPoint
|
|
}
|
|
if point < minLuckyPoint {
|
|
point = minLuckyPoint
|
|
}
|
|
}()
|
|
|
|
switch name {
|
|
case stub.Truco:
|
|
return u.TrucoLP + u.LuckyPoint
|
|
case stub.Cacheta:
|
|
return u.CachetaLP + u.LuckyPoint
|
|
default:
|
|
return u.LuckyPoint
|
|
}
|
|
}
|
|
|
|
func (u *UserLuckyPoint) SetLuckyPoint(name string, point int) {
|
|
switch name {
|
|
case stub.Truco:
|
|
u.TrucoLP = point
|
|
case stub.Cacheta:
|
|
u.CachetaLP = point
|
|
default:
|
|
u.LuckyPoint = point
|
|
}
|
|
}
|
|
|
|
func (u *UserLuckyPoint) IsLuckyUser() bool {
|
|
return u.LuckyUser
|
|
}
|
|
|
|
func (u *UserLuckyPoint) TableName() string {
|
|
return "t_user_lucky_point"
|
|
}
|
|
|
|
type UserLuckyPointOp struct {
|
|
db *gorm.DB
|
|
rdb *redis.Client
|
|
}
|
|
|
|
func NewUserLuckyPointOp() *UserLuckyPointOp {
|
|
return &UserLuckyPointOp{
|
|
db: userDB,
|
|
rdb: rdbBaseInfo,
|
|
}
|
|
}
|
|
|
|
// AddByGameType 根据游戏类型增加幸运值
|
|
func (op *UserLuckyPointOp) AddByGameType(uid int64, name string, inc int) (updated int, err error) {
|
|
var column string
|
|
switch name {
|
|
case stub.Truco:
|
|
column = "truco_lp"
|
|
case stub.Cacheta:
|
|
column = "cacheta_lp"
|
|
case "base":
|
|
column = "lucky_point"
|
|
default:
|
|
return 0, fmt.Errorf("game type %s not support", name)
|
|
}
|
|
model := &UserLuckyPoint{Uid: uid}
|
|
err = op.db.Model(model).
|
|
Where("uid = ?", uid).
|
|
Update(column, gorm.Expr(`
|
|
CASE
|
|
WHEN `+column+` + ? > ? THEN ?
|
|
WHEN `+column+` + ? < ? THEN ?
|
|
ELSE `+column+` + ?
|
|
END`, inc, maxLuckyPoint, maxLuckyPoint,
|
|
inc, minLuckyPoint, minLuckyPoint,
|
|
inc)).Error
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
err = op.db.Where("uid = ?", uid).First(model).Error
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
op.insertRedis(model)
|
|
switch name {
|
|
case stub.Truco:
|
|
return model.TrucoLP, nil
|
|
case stub.Cacheta:
|
|
return model.CachetaLP, nil
|
|
default:
|
|
return model.LuckyPoint, nil
|
|
}
|
|
|
|
}
|
|
|
|
// Add 增加用户的基础幸运值
|
|
func (op *UserLuckyPointOp) Add(uid int64, inc int) (updated int, err error) {
|
|
return op.AddByGameType(uid, "base", inc)
|
|
}
|
|
|
|
// Load 加载用户幸运值
|
|
func (op *UserLuckyPointOp) Load(uid int64) (*UserLuckyPoint, error) {
|
|
lp, err := util.Redis2Struct[UserLuckyPoint](op.rdb, rdbkey.UserLuckyPointKey(uid))
|
|
if err == nil {
|
|
return lp, err
|
|
}
|
|
|
|
lp = &UserLuckyPoint{Uid: uid}
|
|
err = op.db.Where("uid = ?", uid).First(lp).Error
|
|
if err != nil {
|
|
if !errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, fmt.Errorf("load user lucky point err:%v", err)
|
|
}
|
|
if err := op.db.Where("uid = ?", uid).Create(lp).Error; err != nil {
|
|
return nil, fmt.Errorf("create user lucky point err:%v", err)
|
|
}
|
|
}
|
|
op.insertRedis(lp)
|
|
return lp, nil
|
|
}
|
|
|
|
func (op *UserLuckyPointOp) insertRedis(p *UserLuckyPoint) {
|
|
err := util.Struct2Redis(op.rdb, rdbkey.UserLuckyPointKey(p.Uid), p)
|
|
if err != nil {
|
|
log.Error(fmt.Sprintf("insert redis error: %s", err))
|
|
return
|
|
}
|
|
}
|