1438 lines
41 KiB
Go
1438 lines
41 KiB
Go
package dao
|
||
|
||
import (
|
||
"context"
|
||
"encoding/json"
|
||
"fmt"
|
||
"math/rand"
|
||
"strconv"
|
||
"sync"
|
||
"time"
|
||
|
||
v12 "go-common/app/service/live/rc/api/liverpc/v1"
|
||
|
||
"github.com/pkg/errors"
|
||
|
||
"go-common/app/service/live/xlottery/api/grpc/v1"
|
||
"go-common/library/cache/redis"
|
||
"go-common/library/database/sql"
|
||
"go-common/library/log"
|
||
"go-common/library/queue/databus/report"
|
||
)
|
||
|
||
const (
|
||
_userCapsuleCoinMysql = "select normal_score, colorful_score from capsule_%d where uid = ?"
|
||
_addCapsuleCoinMysql = "insert into capsule_%d(uid, normal_score, colorful_score) values(?, ?, ?)"
|
||
_userInfoMysql = "select score from capsule_info_%d where uid = ? and type = ?"
|
||
_addInfoMysql = "insert into capsule_info_%d(uid,type,score) values(?, ?, ?)"
|
||
_updateUserCapsuleMysql = "update capsule_%d set %s_score = %s_score + ? where uid = ?"
|
||
_updateUserInfoMysql = "update capsule_info_%d set score = score + ? where uid = ? and type = ?"
|
||
_transUserCapsuleMysql = "update capsule_%d set colorful_score = 0, normal_score = normal_score + ? where uid = ?"
|
||
_reportCapsuleChangeMysql = "insert into capsule_log_%s(uid, type, score, action, platform, pre_normal_score, pre_colorful_score, cur_normal_score, cur_colorful_score) values(?,?,?,?,?,?,?,?,?)"
|
||
_userCapsuleCoinRedis = "hash:capsule:user:%d"
|
||
_userInfoRedis = "capsule:user:info:%d:%d"
|
||
_openHistoryRedis = "list:capsule:%s:list"
|
||
_openLockRedis = "capsule-pay-%d"
|
||
_capsuleConfRand = "capsule:rand"
|
||
_historyOpenCount = "hash:capsule:count"
|
||
_historyGiftCount = "capsule:gift:count:%d:%s"
|
||
_capsuleNotice = "capsule:notice:%s:%d"
|
||
_whiteUserPrizeRedis = "capsule:white:user:%d"
|
||
)
|
||
const (
|
||
_ = iota
|
||
// CapsulePrizeGift1Type 辣条
|
||
CapsulePrizeGift1Type // 辣条
|
||
// CapsulePrizeTitleType 头衔
|
||
CapsulePrizeTitleType
|
||
// CapsulePrizeStuff1Type 经验原石
|
||
CapsulePrizeStuff1Type
|
||
// CapsulePrizeStuff2Type 经验曜石
|
||
CapsulePrizeStuff2Type
|
||
// CapsulePrizeStuff3Type 贤者之石
|
||
CapsulePrizeStuff3Type
|
||
// CapsulePrizeSmallTvType 小电视
|
||
CapsulePrizeSmallTvType
|
||
// CapsulePrizeGuard3Type 舰长体验
|
||
CapsulePrizeGuard3Type
|
||
// CapsulePrizeGuard2Type 提督体验
|
||
CapsulePrizeGuard2Type
|
||
// CapsulePrizeGuard1Type 总督体验
|
||
CapsulePrizeGuard1Type
|
||
// CapsulePrizeScoreAdd 积分加成卡
|
||
CapsulePrizeScoreAdd
|
||
// CapsulePrizeSmallStar 小星星
|
||
CapsulePrizeSmallStar
|
||
// CapsulePrizeWeekScore 抽奖券
|
||
CapsulePrizeWeekScore
|
||
// CapsulePrizeDanmuColor 弹幕颜色
|
||
CapsulePrizeDanmuColor
|
||
// CapsulePrizeLplScore lpl抽奖券
|
||
CapsulePrizeLplScore
|
||
// CapsulePrizeLplProduct1 lpl实物奖励1
|
||
CapsulePrizeLplProduct1
|
||
// CapsulePrizeLplProduct2 lpl实物奖励2
|
||
CapsulePrizeLplProduct2
|
||
// CapsulePrizeLplProduct3 lpl实物奖励3
|
||
CapsulePrizeLplProduct3
|
||
)
|
||
|
||
const (
|
||
// CapsulePrizeProduct1 .
|
||
CapsulePrizeProduct1 = 100000 // 实物奖励
|
||
// CapsulePrizeProduct2 .
|
||
CapsulePrizeProduct2 = 100001 // 实物奖励
|
||
// CapsulePrizeProduct3 .
|
||
CapsulePrizeProduct3 = 100002
|
||
// CapsulePrizeProduct4 .
|
||
CapsulePrizeProduct4 = 100003 // 实物奖励
|
||
// CapsulePrizeProduct5 .
|
||
CapsulePrizeProduct5 = 100004 // 实物奖励
|
||
// CapsulePrizeProduct6 .
|
||
CapsulePrizeProduct6 = 100005
|
||
)
|
||
|
||
const (
|
||
// CapsulePrizeCoupon1 .
|
||
CapsulePrizeCoupon1 = 200000
|
||
// CapsulePrizeCoupon2 .
|
||
CapsulePrizeCoupon2 = 200001
|
||
// CapsulePrizeCoupon3 .
|
||
CapsulePrizeCoupon3 = 200002
|
||
)
|
||
|
||
const (
|
||
// CapsulePrizeExpire1Day 过期时间24小时
|
||
CapsulePrizeExpire1Day = 1
|
||
// CapsulePrizeExpire3Day 过期时间72小时
|
||
CapsulePrizeExpire3Day = 10
|
||
// CapsulePrizeExpire1Week 过期时间1周
|
||
CapsulePrizeExpire1Week = 20
|
||
// CapsulePrizeExpire3Month 过期时间3个月
|
||
CapsulePrizeExpire3Month = 30
|
||
// CapsulePrizeExpireForever 过期时间永久
|
||
CapsulePrizeExpireForever = 100
|
||
)
|
||
const (
|
||
_ = iota
|
||
// ProTypeNormal 概率
|
||
ProTypeNormal
|
||
// ProTypeFixDay 每天固定数量
|
||
ProTypeFixDay
|
||
// ProTypeFixWeek 每周固定数量
|
||
ProTypeFixWeek
|
||
// ProTypeWhite 白名单
|
||
ProTypeWhite
|
||
)
|
||
const (
|
||
// CapsuleGiftTypeAll gift_type 为全部道具
|
||
CapsuleGiftTypeAll = 1
|
||
)
|
||
const (
|
||
// NormalCoinId 普通扭蛋id
|
||
NormalCoinId = 1
|
||
// ColorfulCoinId 梦幻扭蛋id
|
||
ColorfulCoinId = 2
|
||
// WeekCoinId 梦幻扭蛋id
|
||
WeekCoinId = 3
|
||
// LplCoinId 梦幻扭蛋id
|
||
LplCoinId = 4
|
||
// BlessCoinId 祈福券
|
||
BlessCoinId = 5
|
||
// OpenHistoryNum 开奖历史
|
||
OpenHistoryNum = 30
|
||
// NormalCoinString 普通扭蛋字符串标识，数据库和redis
|
||
NormalCoinString = "normal"
|
||
// ColorfulCoinString 梦幻扭蛋字符串标识，数据库和redis
|
||
ColorfulCoinString = "colorful"
|
||
// WeekCoinString 周星扭蛋字符串标识，数据库和redis
|
||
WeekCoinString = "week"
|
||
// LplCoinString lpl扭蛋字符串标识，数据库和redis
|
||
LplCoinString = "lpl"
|
||
// BlessCoinString 新年祈愿扭蛋字符串标识，数据库和redis
|
||
BlessCoinString = "bless"
|
||
// GetCapsuleDetailFromRoom 接口来源
|
||
GetCapsuleDetailFromRoom = "room"
|
||
// GetCapsuleDetailFromWeb 接口来源
|
||
GetCapsuleDetailFromWeb = "web"
|
||
// GetCapsuleDetailFromH5 接口来源
|
||
GetCapsuleDetailFromH5 = "h5"
|
||
)
|
||
|
||
const (
|
||
//IsBottomPool 是保底奖池
|
||
IsBottomPool = 1
|
||
//CapsuleActionTrans 转换扭蛋
|
||
CapsuleActionTrans = "trans"
|
||
)
|
||
|
||
// CapsuleConf 扭蛋全局配置
|
||
type CapsuleConf struct {
|
||
CoinConfMap map[int64]*CapsuleCoinConf
|
||
CacheTime int64
|
||
ChangeFlag int64
|
||
RwLock sync.RWMutex
|
||
}
|
||
|
||
// CapsuleCoinConf 扭蛋币配置
|
||
type CapsuleCoinConf struct {
|
||
Id int64
|
||
Title string
|
||
GiftType int64
|
||
ChangeNum int64
|
||
StartTime int64
|
||
EndTime int64
|
||
Status int64
|
||
GiftMap map[int64]struct{}
|
||
AreaMap map[int64]struct{}
|
||
PoolConf *CapsulePoolConf
|
||
AllPoolConf []*CapsulePoolConf
|
||
}
|
||
|
||
// CapsulePoolConf 奖池配置
|
||
type CapsulePoolConf struct {
|
||
Id int64
|
||
CoinId int64
|
||
Title string
|
||
Rule string
|
||
StartTime, EndTime int64
|
||
Status int64
|
||
IsBottom int64
|
||
PoolPrize []*CapsulePoolPrize
|
||
}
|
||
|
||
// CapsulePoolPrize 奖池奖品
|
||
type CapsulePoolPrize struct {
|
||
Id, PoolId, Type, Num, ObjectId, Expire int64
|
||
Name, WebImage, MobileImage, Description, JumpUrl string
|
||
ProType int64
|
||
Chance int64
|
||
LoopNum, LimitNum, Weight int64
|
||
WhiteUserMap map[int64]struct{}
|
||
}
|
||
|
||
// HistoryOpenInfo 开奖历史
|
||
type HistoryOpenInfo struct {
|
||
Uid int64 `json:"uid"`
|
||
Name string `json:"name"`
|
||
Date string `json:"date"`
|
||
Num int64 `json:"num"`
|
||
}
|
||
|
||
var (
|
||
// CoinIdIntMap map
|
||
CoinIdIntMap map[int64]string
|
||
// CoinIdStringMap map
|
||
CoinIdStringMap map[string]int64
|
||
// ReprotConfig map
|
||
ReprotConfig map[int64]string
|
||
// PrizeNameMap map
|
||
PrizeNameMap map[int64]string
|
||
// PrizeExpireMap map
|
||
PrizeExpireMap map[int64]string
|
||
// UnLockGetWrong flag
|
||
UnLockGetWrong = "UnLockGetWrong"
|
||
// ErrUnLockGet error
|
||
ErrUnLockGet = errors.New(UnLockGetWrong)
|
||
capsuleConf CapsuleConf
|
||
whitePrizeMap sync.Map
|
||
)
|
||
|
||
func init() {
|
||
CoinIdIntMap = make(map[int64]string)
|
||
CoinIdIntMap[NormalCoinId] = NormalCoinString
|
||
CoinIdIntMap[ColorfulCoinId] = ColorfulCoinString
|
||
CoinIdIntMap[WeekCoinId] = WeekCoinString
|
||
CoinIdIntMap[LplCoinId] = LplCoinString
|
||
CoinIdIntMap[BlessCoinId] = BlessCoinString
|
||
CoinIdStringMap = make(map[string]int64)
|
||
CoinIdStringMap[NormalCoinString] = NormalCoinId
|
||
CoinIdStringMap[ColorfulCoinString] = ColorfulCoinId
|
||
CoinIdStringMap[WeekCoinString] = WeekCoinId
|
||
CoinIdStringMap[LplCoinString] = LplCoinId
|
||
CoinIdStringMap[BlessCoinString] = BlessCoinId
|
||
ReprotConfig = make(map[int64]string)
|
||
ReprotConfig[0] = "未知"
|
||
ReprotConfig[1] = "增加普通扭蛋"
|
||
ReprotConfig[2] = "增加梦幻扭蛋"
|
||
ReprotConfig[3] = "减少普通扭蛋"
|
||
ReprotConfig[4] = "减少梦幻扭蛋"
|
||
ReprotConfig[5] = "梦幻转化普通"
|
||
PrizeNameMap = make(map[int64]string)
|
||
PrizeNameMap[CapsulePrizeGift1Type] = "辣条"
|
||
PrizeNameMap[CapsulePrizeTitleType] = "头衔"
|
||
PrizeNameMap[CapsulePrizeStuff1Type] = "经验原石"
|
||
PrizeNameMap[CapsulePrizeStuff2Type] = "经验曜石"
|
||
PrizeNameMap[CapsulePrizeStuff3Type] = "贤者之石"
|
||
PrizeNameMap[CapsulePrizeSmallTvType] = "小电视抱枕"
|
||
PrizeNameMap[CapsulePrizeGuard3Type] = "舰长体验"
|
||
PrizeNameMap[CapsulePrizeGuard2Type] = "提督体验"
|
||
PrizeNameMap[CapsulePrizeScoreAdd] = "积分加成卡"
|
||
PrizeNameMap[CapsulePrizeSmallStar] = "小星星"
|
||
PrizeNameMap[CapsulePrizeWeekScore] = "抽奖券"
|
||
PrizeNameMap[CapsulePrizeDanmuColor] = "金色弹幕"
|
||
PrizeNameMap[CapsulePrizeLplScore] = "LPL抽奖券"
|
||
PrizeNameMap[CapsulePrizeLplProduct1] = "2019拜年祭小电视猪"
|
||
PrizeNameMap[CapsulePrizeLplProduct2] = "小电视毛绒公仔"
|
||
PrizeNameMap[CapsulePrizeLplProduct3] = "机械之心桌垫"
|
||
PrizeNameMap[CapsulePrizeProduct1] = "迎新礼盒+新年台历"
|
||
PrizeNameMap[CapsulePrizeProduct2] = "新年锦鲤围巾"
|
||
PrizeNameMap[CapsulePrizeProduct3] = "拜年祭挂件+拜年祭立牌+年夜饭挂画"
|
||
PrizeNameMap[CapsulePrizeProduct4] = "拜年祭耳罩"
|
||
PrizeNameMap[CapsulePrizeProduct5] = "小电视猪挂件+小电视猪公仔"
|
||
PrizeNameMap[CapsulePrizeProduct6] = "拜年祭徽章"
|
||
PrizeNameMap[CapsulePrizeCoupon1] = "会员购20元优惠券"
|
||
PrizeNameMap[CapsulePrizeCoupon2] = "会员购40元优惠券"
|
||
PrizeNameMap[CapsulePrizeCoupon3] = "会员购60元优惠券"
|
||
PrizeExpireMap = make(map[int64]string)
|
||
PrizeExpireMap[CapsulePrizeExpire1Day] = "1天"
|
||
PrizeExpireMap[CapsulePrizeExpire3Day] = "3天"
|
||
PrizeExpireMap[CapsulePrizeExpire1Week] = "1周"
|
||
PrizeExpireMap[CapsulePrizeExpire3Month] = "3个月"
|
||
PrizeExpireMap[CapsulePrizeExpireForever] = "永久"
|
||
}
|
||
|
||
// GetCapsuleConf 获取扭蛋币配置
|
||
func (d *Dao) GetCapsuleConf(ctx context.Context) (conf map[int64]*CapsuleCoinConf, err error) {
|
||
capsuleConf.RwLock.RLock()
|
||
tmpConf := capsuleConf.CoinConfMap
|
||
capsuleConf.RwLock.RUnlock()
|
||
if len(tmpConf) == 0 {
|
||
redisChangeFlag, _ := d.GetCapsuleChangeFlag(ctx)
|
||
tmpConf, err = d.RelaodCapsuleConfig(ctx, redisChangeFlag)
|
||
if err != nil || tmpConf == nil || len(tmpConf) == 0 {
|
||
log.Error("[dap.capsule | GetCapsuleConf] CapsuleCoinConf is empty")
|
||
return nil, err
|
||
}
|
||
}
|
||
now := time.Now().Unix()
|
||
conf = make(map[int64]*CapsuleCoinConf)
|
||
for coinId := range CoinIdIntMap {
|
||
if _, ok := tmpConf[coinId]; ok {
|
||
coinConf := tmpConf[coinId]
|
||
if coinConf.AllPoolConf != nil && len(coinConf.AllPoolConf) > 0 {
|
||
for _, poolConf := range coinConf.AllPoolConf {
|
||
if poolConf.StartTime < now && poolConf.EndTime > now {
|
||
if _, ok := conf[coinId]; !ok {
|
||
conf[coinId] = &CapsuleCoinConf{
|
||
Id: coinConf.Id,
|
||
Title: coinConf.Title,
|
||
GiftType: coinConf.GiftType,
|
||
ChangeNum: coinConf.ChangeNum,
|
||
StartTime: coinConf.StartTime,
|
||
EndTime: coinConf.EndTime,
|
||
Status: coinConf.Status,
|
||
GiftMap: coinConf.GiftMap,
|
||
AreaMap: coinConf.AreaMap,
|
||
PoolConf: poolConf,
|
||
AllPoolConf: coinConf.AllPoolConf,
|
||
}
|
||
} else {
|
||
if poolConf.IsBottom != IsBottomPool {
|
||
conf[coinId] = &CapsuleCoinConf{
|
||
Id: coinConf.Id,
|
||
Title: coinConf.Title,
|
||
GiftType: coinConf.GiftType,
|
||
ChangeNum: coinConf.ChangeNum,
|
||
StartTime: coinConf.StartTime,
|
||
EndTime: coinConf.EndTime,
|
||
Status: coinConf.Status,
|
||
GiftMap: coinConf.GiftMap,
|
||
AreaMap: coinConf.AreaMap,
|
||
PoolConf: poolConf,
|
||
AllPoolConf: coinConf.AllPoolConf,
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return conf, nil
|
||
}
|
||
|
||
func getCapsuleTable(Uid int64) int64 {
|
||
return Uid % 10
|
||
}
|
||
|
||
func userKey(uid int64) string {
|
||
return fmt.Sprintf(_userCapsuleCoinRedis, uid)
|
||
}
|
||
|
||
func userInfoKey(uid int64, coinId int64) string {
|
||
return fmt.Sprintf(_userInfoRedis, uid, coinId)
|
||
}
|
||
|
||
func openHistoryKey(coinType string) string {
|
||
return fmt.Sprintf(_openHistoryRedis, coinType)
|
||
}
|
||
|
||
func openTotalCountKey() string {
|
||
return _historyOpenCount
|
||
}
|
||
|
||
func openGiftCountKey(giftId int64, day string) string {
|
||
return fmt.Sprintf(_historyGiftCount, giftId, day)
|
||
}
|
||
|
||
func whiteUserPrizeKey(uid int64) string {
|
||
return fmt.Sprintf(_whiteUserPrizeRedis, uid)
|
||
}
|
||
|
||
// GetUserCapsuleInfo 获取扭蛋币积分
|
||
func (d *Dao) GetUserCapsuleInfo(c context.Context, uid int64) (coinMap map[int64]int64, err error) {
|
||
var (
|
||
isEmpty bool
|
||
uKey string
|
||
normalScore int64
|
||
colorfulScore int64
|
||
)
|
||
uKey = userKey(uid)
|
||
|
||
conn := d.redis.Get(c)
|
||
defer conn.Close()
|
||
uInfo, err := redis.Int64Map(conn.Do("HGETALL", uKey))
|
||
if err != nil {
|
||
if err == redis.ErrNil {
|
||
isEmpty = true
|
||
err = nil
|
||
} else {
|
||
log.Error("[dao.redis_lottery|setUserCapsuleInfoCache] getUserCapsuleInfoCache conn.HMGET(%s) error(%v)", uKey, err)
|
||
return
|
||
}
|
||
|
||
} else if len(uInfo) == 0 {
|
||
isEmpty = true
|
||
}
|
||
coinMap = make(map[int64]int64)
|
||
if isEmpty {
|
||
sqlStr := fmt.Sprintf(_userCapsuleCoinMysql, getCapsuleTable(uid))
|
||
row := d.db.QueryRow(c, sqlStr, uid)
|
||
err = row.Scan(&normalScore, &colorfulScore)
|
||
if err != nil && err != sql.ErrNoRows {
|
||
return
|
||
}
|
||
if err == sql.ErrNoRows {
|
||
sqlStr := fmt.Sprintf(_addCapsuleCoinMysql, getCapsuleTable(uid))
|
||
_, err = d.db.Exec(c, sqlStr, uid, 0, 0)
|
||
if err != nil {
|
||
log.Error("[dao.redis_lottery|GetUserCapsuleInfo] init sql(%s) uid(%d) error(%v)", sqlStr, uid, err)
|
||
return
|
||
}
|
||
normalScore, colorfulScore = 0, 0
|
||
}
|
||
_, err = conn.Do("HMSET", uKey, CoinIdIntMap[NormalCoinId], normalScore, CoinIdIntMap[ColorfulCoinId], colorfulScore)
|
||
if err != nil {
|
||
log.Error("[dao.redis_lottery|GetUserCapsuleInfo] setUserCapsuleInfoCache conn.HMSET(%s) error(%v)", uKey, err)
|
||
}
|
||
coinMap[NormalCoinId] = normalScore
|
||
coinMap[ColorfulCoinId] = colorfulScore
|
||
err = nil
|
||
} else {
|
||
if _, ok := uInfo[CoinIdIntMap[NormalCoinId]]; ok {
|
||
coinMap[NormalCoinId] = uInfo[CoinIdIntMap[NormalCoinId]]
|
||
}
|
||
if _, ok := uInfo[CoinIdIntMap[ColorfulCoinId]]; ok {
|
||
coinMap[ColorfulCoinId] = uInfo[CoinIdIntMap[ColorfulCoinId]]
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
// GetUserInfo 获取扭蛋币详情
|
||
func (d *Dao) GetUserInfo(c context.Context, uid, coinId int64) (coinMap map[int64]int64, err error) {
|
||
if coinId <= ColorfulCoinId {
|
||
coinMap, err = d.GetUserCapsuleInfo(c, uid)
|
||
return
|
||
}
|
||
var (
|
||
isEmpty bool
|
||
uKey string
|
||
score int64
|
||
)
|
||
uKey = userInfoKey(uid, coinId)
|
||
|
||
conn := d.redis.Get(c)
|
||
defer conn.Close()
|
||
score, err = redis.Int64(conn.Do("GET", uKey))
|
||
if err != nil {
|
||
if err == redis.ErrNil {
|
||
isEmpty = true
|
||
err = nil
|
||
} else {
|
||
log.Error("[dao.redis_lottery|GetUserInfo] getUserInfoCache conn.HMGET(%s) error(%v)", uKey, err)
|
||
return
|
||
}
|
||
|
||
}
|
||
coinMap = make(map[int64]int64)
|
||
if isEmpty {
|
||
sqlStr := fmt.Sprintf(_userInfoMysql, getCapsuleTable(uid))
|
||
row := d.db.QueryRow(c, sqlStr, uid, CoinIdIntMap[coinId])
|
||
err = row.Scan(&score)
|
||
if err != nil && err != sql.ErrNoRows {
|
||
log.Error("[dao.redis_lottery|GetUserInfo] getUserInfoFromDB uid(%d) error(%v)", uid, err)
|
||
return
|
||
}
|
||
if err == sql.ErrNoRows {
|
||
sqlStr := fmt.Sprintf(_addInfoMysql, getCapsuleTable(uid))
|
||
_, err = d.db.Exec(c, sqlStr, uid, CoinIdIntMap[coinId], 0)
|
||
if err != nil {
|
||
log.Error("[dao.redis_lottery|GetUserInfo] init sql(%s) uid(%d) error(%v)", sqlStr, uid, err)
|
||
return nil, err
|
||
}
|
||
score = 0
|
||
}
|
||
_, err = conn.Do("SET", uKey, score)
|
||
if err != nil {
|
||
log.Error("[dao.redis_lottery|GetUserInfo] setUserCapsuleInfoCache conn.HMSET(%s) error(%v)", uKey, err)
|
||
}
|
||
coinMap[coinId] = score
|
||
err = nil
|
||
} else {
|
||
coinMap[coinId] = score
|
||
}
|
||
return
|
||
}
|
||
|
||
// GetOpenHistory 获取扭蛋币历史
|
||
func (d *Dao) GetOpenHistory(c context.Context, coinType int64) (ret []*HistoryOpenInfo, err error) {
|
||
hkey := openHistoryKey(CoinIdIntMap[coinType])
|
||
conn := d.redis.Get(c)
|
||
defer conn.Close()
|
||
jsons, err := redis.Strings(conn.Do("LRANGE", hkey, 0, OpenHistoryNum-1))
|
||
if err != nil {
|
||
return
|
||
}
|
||
length := len(jsons)
|
||
if length == 0 {
|
||
return
|
||
}
|
||
ret = make([]*HistoryOpenInfo, length)
|
||
for ix, jsonStr := range jsons {
|
||
var openInfo HistoryOpenInfo
|
||
json.Unmarshal([]byte(jsonStr), &openInfo)
|
||
ret[ix] = &openInfo
|
||
}
|
||
return
|
||
}
|
||
|
||
// GetCoin 获取扭蛋数量
|
||
func (d *Dao) GetCoin(score int64, coinConf *CapsuleCoinConf) (coinNum int64) {
|
||
if coinConf == nil || coinConf.ChangeNum == 0 {
|
||
return 0
|
||
}
|
||
coinNum = score / coinConf.ChangeNum
|
||
return
|
||
}
|
||
|
||
// GetProgress 获取扭蛋币进度
|
||
func (d *Dao) GetProgress(score int64, coinConf *CapsuleCoinConf) (process *v1.Progress) {
|
||
process = &v1.Progress{}
|
||
if coinConf == nil || coinConf.ChangeNum == 0 {
|
||
return
|
||
}
|
||
process.Max = coinConf.ChangeNum
|
||
process.Now = score % coinConf.ChangeNum
|
||
return
|
||
}
|
||
|
||
// UpdateScore 更新扭蛋币积分
|
||
func (d *Dao) UpdateScore(ctx context.Context, uid, coinId, score int64, action, platform string, coinConf *CapsuleCoinConf) (affect int64, err error) {
|
||
var (
|
||
sqlStr, uKey, iKey string
|
||
)
|
||
if action == CapsuleActionTrans {
|
||
sqlStr = fmt.Sprintf(_transUserCapsuleMysql, getCapsuleTable(uid))
|
||
} else {
|
||
sqlStr = fmt.Sprintf(_updateUserCapsuleMysql, getCapsuleTable(uid), CoinIdIntMap[coinId], CoinIdIntMap[coinId])
|
||
}
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
uKey = userKey(uid)
|
||
iKey = userInfoKey(uid, coinId)
|
||
log.Info("trace UpdateScore start")
|
||
affect, err = d.execSqlWithBindParams(ctx, &sqlStr, score, uid)
|
||
log.Info("trace UpdateScore end")
|
||
if err != nil {
|
||
log.Error("[dao.mysql_lottery|updateScore] uid(%d) type(%d) score(%d) error(%v)", uid, coinId, score, err)
|
||
_, e := conn.Do("DEL", uKey, iKey)
|
||
if e != nil {
|
||
log.Error("[dao.redis_lottery|updateScore] conn.DEL(%s, %s) error(%v)", uKey, iKey, e)
|
||
}
|
||
return
|
||
}
|
||
_, e := conn.Do("DEL", uKey, iKey)
|
||
if e != nil {
|
||
log.Error("[dao.redis_lottery|updateScore] conn.DEL(%s, %s) error(%v)", uKey, iKey, e)
|
||
}
|
||
return
|
||
}
|
||
|
||
// UpdateCapsule 更新扭蛋币积分
|
||
func (d *Dao) UpdateCapsule(ctx context.Context, uid, coinId, score int64, action, platform string, coinConf *CapsuleCoinConf) (affect int64, err error) {
|
||
var (
|
||
sqlStr, uKey, iKey string
|
||
)
|
||
sqlStr = fmt.Sprintf(_updateUserInfoMysql, getCapsuleTable(uid))
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
uKey = userKey(uid)
|
||
iKey = userInfoKey(uid, coinId)
|
||
log.Info("trace UpdateCapsule start")
|
||
affect, err = d.execSqlWithBindParams(ctx, &sqlStr, score, uid, CoinIdIntMap[coinId])
|
||
log.Info("trace UpdateCapsule end")
|
||
if err != nil {
|
||
log.Error("[dao.mysql_lottery|UpdateCapsule] uid(%d) type(%d) score(%d) error(%v)", uid, coinId, score, err)
|
||
_, e := conn.Do("DEL", uKey, iKey)
|
||
if e != nil {
|
||
log.Error("[dao.redis_lottery|UpdateCapsule] conn.DEL(%s, %s) error(%v)", uKey, iKey, e)
|
||
}
|
||
return
|
||
}
|
||
_, e := conn.Do("DEL", uKey, iKey)
|
||
if e != nil {
|
||
log.Error("[dao.redis_lottery|UpdateCapsule] conn.DEL(%s, %s) error(%v)", uKey, iKey, e)
|
||
}
|
||
return
|
||
}
|
||
|
||
// ReportCapsuleChange 扭蛋流水
|
||
func (d *Dao) ReportCapsuleChange(ctx context.Context, coinId, uid, score int64, action, platform string, pInfo, cInfo map[int64]int64, coinConf *CapsuleCoinConf) bool {
|
||
if _, ok := pInfo[coinId]; !ok {
|
||
return false
|
||
}
|
||
if _, ok := cInfo[coinId]; !ok {
|
||
return false
|
||
}
|
||
chnageType := coinId
|
||
change := d.GetCoin(cInfo[coinId], coinConf) - d.GetCoin(pInfo[coinId], coinConf)
|
||
if change > 0 {
|
||
d.AddNotice(ctx, uid, coinId, change)
|
||
}
|
||
var normalPreScore, colorPreScore, normalNowScore, colorNowScore int64
|
||
if coinId <= ColorfulCoinId {
|
||
if action == CapsuleActionTrans {
|
||
chnageType = 5
|
||
} else {
|
||
if score < 0 {
|
||
chnageType += 2
|
||
score = -score
|
||
}
|
||
}
|
||
normalPreScore, colorPreScore, normalNowScore, colorNowScore = pInfo[NormalCoinId], pInfo[ColorfulCoinId], cInfo[NormalCoinId], cInfo[ColorfulCoinId]
|
||
} else {
|
||
chnageType = coinId * 10
|
||
if score < 0 {
|
||
chnageType += 1
|
||
}
|
||
normalPreScore, colorPreScore, normalNowScore, colorNowScore = 0, pInfo[coinId], 0, cInfo[coinId]
|
||
}
|
||
|
||
date := time.Now().Format("200601")
|
||
sqlStr := fmt.Sprintf(_reportCapsuleChangeMysql, date)
|
||
affect, _ := d.execSqlWithBindParams(ctx, &sqlStr, uid, chnageType, score, action, platform, normalPreScore, colorPreScore, normalNowScore, colorNowScore)
|
||
var rcontent string
|
||
if _, ok := ReprotConfig[chnageType]; ok {
|
||
rcontent = ReprotConfig[chnageType]
|
||
}
|
||
if rcontent == "" {
|
||
if chnageType%10 == 0 {
|
||
rcontent = "减少" + coinConf.Title
|
||
} else if chnageType%10 == 1 {
|
||
rcontent = "增加" + coinConf.Title
|
||
} else if chnageType%10 == 2 {
|
||
rcontent = "转化" + coinConf.Title
|
||
}
|
||
}
|
||
report.User(&report.UserInfo{
|
||
Platform: platform,
|
||
Business: 101, // 101 102 103 104 105 106
|
||
Type: int(chnageType),
|
||
Oid: uid,
|
||
Action: "capsule_change",
|
||
Ctime: time.Now(),
|
||
Index: []interface{}{
|
||
rcontent,
|
||
score,
|
||
normalNowScore,
|
||
colorNowScore,
|
||
action,
|
||
},
|
||
})
|
||
return affect > 0
|
||
}
|
||
|
||
// PayCoin 支付扭蛋币
|
||
func (d *Dao) PayCoin(ctx context.Context, uid int64, coinConf *CapsuleCoinConf, openCount int64, action, platform string) (status int64, pInfo map[int64]int64, err error) {
|
||
lockKey := fmt.Sprintf(_openLockRedis, uid)
|
||
isGetLock, lockString, err := d.Lock(ctx, lockKey, 10000, 0, 0)
|
||
if err != nil || !isGetLock {
|
||
return
|
||
}
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
userData, err := d.GetUserInfo(ctx, uid, coinConf.Id)
|
||
if err != nil {
|
||
d.UnLock(ctx, lockKey, lockString)
|
||
return
|
||
}
|
||
var score int64
|
||
if _, ok := userData[coinConf.Id]; ok {
|
||
score = userData[coinConf.Id]
|
||
}
|
||
coinNum := d.GetCoin(score, coinConf)
|
||
if coinNum < openCount {
|
||
d.UnLock(ctx, lockKey, lockString)
|
||
return 1, userData, nil
|
||
|
||
}
|
||
value := openCount * coinConf.ChangeNum
|
||
_, err = d.UpdateScore(ctx, uid, coinConf.Id, -value, action, platform, coinConf)
|
||
if err != nil {
|
||
d.UnLock(ctx, lockKey, lockString)
|
||
return
|
||
}
|
||
d.UnLock(ctx, lockKey, lockString)
|
||
return 0, userData, nil
|
||
}
|
||
|
||
// PayCapsule 支付扭蛋币
|
||
func (d *Dao) PayCapsule(ctx context.Context, uid int64, coinConf *CapsuleCoinConf, openCount int64, action, platform string) (status int64, pInfo map[int64]int64, err error) {
|
||
lockKey := fmt.Sprintf(_openLockRedis, uid)
|
||
isGetLock, lockString, err := d.Lock(ctx, lockKey, 10000, 0, 0)
|
||
if err != nil {
|
||
return
|
||
}
|
||
if !isGetLock {
|
||
return 1, nil, nil
|
||
}
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
userData, err := d.GetUserInfo(ctx, uid, coinConf.Id)
|
||
if err != nil {
|
||
d.UnLock(ctx, lockKey, lockString)
|
||
return
|
||
}
|
||
var score int64
|
||
if _, ok := userData[coinConf.Id]; ok {
|
||
score = userData[coinConf.Id]
|
||
}
|
||
coinNum := d.GetCoin(score, coinConf)
|
||
if coinNum < openCount {
|
||
d.UnLock(ctx, lockKey, lockString)
|
||
return 2, userData, nil
|
||
|
||
}
|
||
value := openCount * coinConf.ChangeNum
|
||
_, err = d.UpdateCapsule(ctx, uid, coinConf.Id, -value, action, platform, coinConf)
|
||
if err != nil {
|
||
d.UnLock(ctx, lockKey, lockString)
|
||
return
|
||
}
|
||
d.UnLock(ctx, lockKey, lockString)
|
||
return 0, userData, nil
|
||
}
|
||
|
||
// IsPoolOpen 判断扭蛋池是否开启
|
||
func (d *Dao) IsPoolOpen(coinConf *CapsuleCoinConf, coinId int64) bool {
|
||
if coinConf == nil {
|
||
return false
|
||
}
|
||
if coinConf.PoolConf == nil || len(coinConf.PoolConf.PoolPrize) == 0 {
|
||
return false
|
||
}
|
||
now := time.Now().Unix()
|
||
if coinConf.PoolConf.StartTime < now && coinConf.PoolConf.EndTime > now {
|
||
return true
|
||
}
|
||
return false
|
||
}
|
||
|
||
// GetGift 获取扭蛋奖池奖品
|
||
func (d *Dao) GetGift(ctx context.Context, coinId int64) (gift []*CapsulePoolPrize, err error) {
|
||
coinConfMap, err := d.GetCapsuleConf(ctx)
|
||
if err != nil || len(coinConfMap) == 0 {
|
||
return
|
||
}
|
||
if _, ok := coinConfMap[coinId]; !ok {
|
||
return
|
||
}
|
||
conf := coinConfMap[coinId]
|
||
if conf.PoolConf == nil || len(conf.PoolConf.PoolPrize) == 0 {
|
||
return
|
||
}
|
||
gift = conf.PoolConf.PoolPrize
|
||
return
|
||
}
|
||
|
||
// IncrOpenCount 增加开奖次数
|
||
func (d *Dao) IncrOpenCount(ctx context.Context, coinId int64) (cnt int64) {
|
||
hkey := openTotalCountKey()
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
cnt, err := redis.Int64(conn.Do("HINCRBY", hkey, CoinIdIntMap[coinId], 1))
|
||
if err != nil {
|
||
return
|
||
}
|
||
if cnt > 0 {
|
||
return cnt
|
||
}
|
||
return 0
|
||
}
|
||
|
||
// GetOpenCount 获取开奖次数
|
||
func (d *Dao) GetOpenCount(ctx context.Context, coinId int64) (cnt int64) {
|
||
hkey := openTotalCountKey()
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
cnt, err := redis.Int64(conn.Do("HGET", hkey, CoinIdIntMap[coinId]))
|
||
if err != nil {
|
||
return 0
|
||
}
|
||
if cnt > 0 {
|
||
return cnt
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func getWhiteGift(coinConf *CapsuleCoinConf) (fixPrize []*CapsulePoolPrize) {
|
||
if coinConf == nil || coinConf.PoolConf == nil || len(coinConf.PoolConf.PoolPrize) == 0 {
|
||
return
|
||
}
|
||
fLen := 0
|
||
for _, prize := range coinConf.PoolConf.PoolPrize {
|
||
if prize.ProType == ProTypeWhite {
|
||
fLen++
|
||
}
|
||
}
|
||
if fLen <= 0 {
|
||
return
|
||
}
|
||
fixPrize = make([]*CapsulePoolPrize, fLen)
|
||
fLen = 0
|
||
for _, prize := range coinConf.PoolConf.PoolPrize {
|
||
if prize.ProType == ProTypeWhite {
|
||
fixPrize[fLen] = prize
|
||
fLen++
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
func getFixGift(coinConf *CapsuleCoinConf) (fixPrize []*CapsulePoolPrize) {
|
||
if coinConf == nil || coinConf.PoolConf == nil || len(coinConf.PoolConf.PoolPrize) == 0 {
|
||
return
|
||
}
|
||
fLen := 0
|
||
for _, prize := range coinConf.PoolConf.PoolPrize {
|
||
if prize.ProType == ProTypeFixDay || prize.ProType == ProTypeFixWeek {
|
||
fLen++
|
||
}
|
||
}
|
||
if fLen <= 0 {
|
||
return
|
||
}
|
||
fixPrize = make([]*CapsulePoolPrize, fLen)
|
||
fLen = 0
|
||
for _, prize := range coinConf.PoolConf.PoolPrize {
|
||
if prize.ProType == ProTypeFixDay || prize.ProType == ProTypeFixWeek {
|
||
fixPrize[fLen] = prize
|
||
fLen++
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
func getRandomGift(coinConf *CapsuleCoinConf) (randomPrize []*CapsulePoolPrize) {
|
||
if coinConf == nil || coinConf.PoolConf == nil || len(coinConf.PoolConf.PoolPrize) == 0 {
|
||
return
|
||
}
|
||
rLen := 0
|
||
for _, prize := range coinConf.PoolConf.PoolPrize {
|
||
if prize.ProType == ProTypeNormal {
|
||
rLen++
|
||
}
|
||
}
|
||
if rLen <= 0 {
|
||
return
|
||
}
|
||
randomPrize = make([]*CapsulePoolPrize, rLen)
|
||
rLen = 0
|
||
for _, prize := range coinConf.PoolConf.PoolPrize {
|
||
if prize.ProType == ProTypeNormal {
|
||
randomPrize[rLen] = prize
|
||
rLen++
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
func (d *Dao) checkWhiteLimit(ctx context.Context, uid int64, prize *CapsulePoolPrize) bool {
|
||
if prize == nil || prize.ProType != ProTypeWhite || len(prize.WhiteUserMap) == 0 {
|
||
return false
|
||
}
|
||
if _, ok := prize.WhiteUserMap[uid]; !ok {
|
||
return false
|
||
}
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
dtime := time.Now()
|
||
day := dtime.Format("2006-01-02")
|
||
uKey := whiteUserPrizeKey(uid)
|
||
lastTime, err := redis.Int64(conn.Do("GET", uKey))
|
||
if err != nil {
|
||
if err == redis.ErrNil {
|
||
// 回源数据库
|
||
prizeLog, err := d.GetUserPrizeLog(ctx, prize.Id, uid)
|
||
if err != nil {
|
||
return false
|
||
}
|
||
if prizeLog != nil {
|
||
lastTime = prizeLog.Timestamp
|
||
} else {
|
||
lastTime = 0
|
||
}
|
||
conn.Do("SET", uKey, lastTime, "EX", 30*86400)
|
||
} else {
|
||
return false
|
||
}
|
||
}
|
||
if dtime.Unix()-lastTime < 7*86400 {
|
||
return false
|
||
}
|
||
gKey := openGiftCountKey(prize.Id, day)
|
||
isGetLock, lockString, errLock := d.Lock(ctx, gKey, 1000000, 0, 0)
|
||
if errLock != nil || !isGetLock {
|
||
return false
|
||
}
|
||
mKey := day + strconv.FormatInt(prize.Id, 10)
|
||
_, ok := whitePrizeMap.Load(mKey)
|
||
if ok {
|
||
d.UnLock(ctx, gKey, lockString)
|
||
return false
|
||
}
|
||
// 回源数据库
|
||
prizeLog, errDb := d.GetPrizeDayLog(ctx, prize.Id, day)
|
||
if errDb != nil {
|
||
d.UnLock(ctx, gKey, lockString)
|
||
return false
|
||
}
|
||
if prizeLog != nil {
|
||
whitePrizeMap.Store(mKey, prizeLog.Uid)
|
||
d.UnLock(ctx, gKey, lockString)
|
||
return false
|
||
}
|
||
stutus, errAdd := d.AddPrizeData(ctx, prize.Id, uid, day, dtime.Unix())
|
||
if errAdd != nil || !stutus {
|
||
d.UnLock(ctx, gKey, lockString)
|
||
return false
|
||
}
|
||
whitePrizeMap.Store(mKey, uid)
|
||
conn.Do("DEL", uKey)
|
||
d.UnLock(ctx, gKey, lockString)
|
||
return true
|
||
|
||
}
|
||
|
||
func (d *Dao) checkPrizeLimit(ctx context.Context, prize *CapsulePoolPrize) bool {
|
||
if prize == nil {
|
||
return false
|
||
}
|
||
if prize.ProType != ProTypeFixDay && prize.ProType != ProTypeFixWeek {
|
||
return false
|
||
}
|
||
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
var status bool
|
||
switch prize.ProType {
|
||
case ProTypeFixDay:
|
||
day := time.Now().Format("2006-01-02")
|
||
gKey := openGiftCountKey(prize.Id, day)
|
||
cnt, err := redis.Int64(conn.Do("INCRBY", gKey, 1))
|
||
if err != nil {
|
||
status = false
|
||
break
|
||
}
|
||
status = cnt <= prize.LimitNum
|
||
case ProTypeFixWeek:
|
||
wDay := time.Now().Weekday()
|
||
if wDay == 0 {
|
||
wDay = 7
|
||
}
|
||
diff := time.Duration(wDay)
|
||
day := time.Now().Add(time.Second * 86400 * (diff - 1)).Format("2006-01-02")
|
||
gKey := openGiftCountKey(prize.Id, day)
|
||
cnt, err := redis.Int64(conn.Do("INCRBY", gKey, 1))
|
||
if err != nil {
|
||
status = false
|
||
break
|
||
}
|
||
status = cnt <= prize.LimitNum
|
||
default:
|
||
status = false
|
||
}
|
||
return status
|
||
}
|
||
|
||
func (d *Dao) getWhiteAward(ctx context.Context, uid int64, coinConf *CapsuleCoinConf) (prize *CapsulePoolPrize) {
|
||
whitePrize := getWhiteGift(coinConf)
|
||
if len(whitePrize) == 0 {
|
||
return
|
||
}
|
||
openCount := d.GetOpenCount(ctx, coinConf.Id)
|
||
if openCount == 0 {
|
||
return
|
||
}
|
||
for _, wprize := range whitePrize {
|
||
if !d.checkWhiteLimit(ctx, uid, wprize) {
|
||
continue
|
||
}
|
||
return &CapsulePoolPrize{
|
||
Id: wprize.Id,
|
||
PoolId: wprize.PoolId,
|
||
Type: wprize.Type,
|
||
Num: wprize.Num,
|
||
Name: wprize.Name,
|
||
WebImage: wprize.WebImage,
|
||
MobileImage: wprize.MobileImage,
|
||
Description: wprize.Description,
|
||
ProType: wprize.ProType,
|
||
JumpUrl: wprize.JumpUrl,
|
||
ObjectId: wprize.ObjectId,
|
||
Expire: wprize.Expire,
|
||
Weight: wprize.Weight,
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
func (d *Dao) getFixAward(ctx context.Context, uid, openCount int64, coinConf *CapsuleCoinConf) (prize *CapsulePoolPrize) {
|
||
fixPrize := getFixGift(coinConf)
|
||
if len(fixPrize) == 0 {
|
||
return
|
||
}
|
||
if openCount == 0 {
|
||
return
|
||
}
|
||
var loop int64
|
||
for _, fprize := range fixPrize {
|
||
loop = fprize.LoopNum
|
||
if openCount%loop != 0 {
|
||
continue
|
||
}
|
||
if d.checkPrizeLimit(ctx, fprize) {
|
||
return &CapsulePoolPrize{
|
||
Id: fprize.Id,
|
||
PoolId: fprize.PoolId,
|
||
Type: fprize.Type,
|
||
Num: fprize.Num,
|
||
Name: fprize.Name,
|
||
WebImage: fprize.WebImage,
|
||
MobileImage: fprize.MobileImage,
|
||
Description: fprize.Description,
|
||
ProType: fprize.ProType,
|
||
JumpUrl: fprize.JumpUrl,
|
||
ObjectId: fprize.ObjectId,
|
||
Expire: fprize.Expire,
|
||
Weight: fprize.Weight,
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
func (d *Dao) getRandomAward(ctx context.Context, uid int64, coinConf *CapsuleCoinConf) (prize *CapsulePoolPrize) {
|
||
randomPrize := getRandomGift(coinConf)
|
||
if len(randomPrize) == 0 {
|
||
return
|
||
}
|
||
var start, random, total int64
|
||
for _, prize := range randomPrize {
|
||
if prize == nil {
|
||
rbyte, _ := json.Marshal(randomPrize)
|
||
log.Error("[dao.capsule | getRandomAward] randomPrize error : %s", string(rbyte))
|
||
continue
|
||
}
|
||
total += prize.Chance
|
||
}
|
||
r := rand.New(rand.NewSource(time.Now().UnixNano()))
|
||
random = r.Int63n(total - 1)
|
||
for _, prize := range randomPrize {
|
||
if random >= start && random < start+prize.Chance {
|
||
return &CapsulePoolPrize{
|
||
Id: prize.Id,
|
||
PoolId: prize.PoolId,
|
||
Type: prize.Type,
|
||
Num: prize.Num,
|
||
Name: prize.Name,
|
||
WebImage: prize.WebImage,
|
||
MobileImage: prize.MobileImage,
|
||
Description: prize.Description,
|
||
ProType: prize.ProType,
|
||
JumpUrl: prize.JumpUrl,
|
||
ObjectId: prize.ObjectId,
|
||
Expire: prize.Expire,
|
||
Weight: prize.Weight,
|
||
}
|
||
}
|
||
start += prize.Chance
|
||
}
|
||
return
|
||
}
|
||
|
||
// OpenCapsule 开启扭蛋
|
||
func (d *Dao) OpenCapsule(ctx context.Context, uid int64, coinConf *CapsuleCoinConf, iTime, openCount int64, isGetFixAward bool, entryMap map[int64]bool) (award *CapsulePoolPrize) {
|
||
if iTime == 0 {
|
||
award = d.getWhiteAward(ctx, uid, coinConf)
|
||
if award != nil {
|
||
return award
|
||
}
|
||
}
|
||
if isGetFixAward {
|
||
award = d.getFixAward(ctx, uid, openCount, coinConf)
|
||
if award != nil {
|
||
if _, ok := entryMap[award.Id]; !ok {
|
||
return
|
||
}
|
||
}
|
||
}
|
||
award = d.getRandomAward(ctx, uid, coinConf)
|
||
if award != nil {
|
||
return
|
||
}
|
||
return
|
||
}
|
||
|
||
// LogAward 记录抽奖奖励
|
||
func (d *Dao) LogAward(ctx context.Context, uid int64, coinId int64, awards []*CapsulePoolPrize) {
|
||
if len(awards) == 0 {
|
||
return
|
||
}
|
||
hkey := openHistoryKey(CoinIdIntMap[coinId])
|
||
day := time.Now().Format("2006-01-02")
|
||
logs := make([]interface{}, len(awards)+1)
|
||
logs[0] = hkey
|
||
ll := 1
|
||
for _, award := range awards {
|
||
if award.Type == CapsulePrizeGift1Type {
|
||
continue
|
||
}
|
||
info := HistoryOpenInfo{Uid: uid, Name: award.Name, Num: award.Num, Date: day}
|
||
b, err := json.Marshal(info)
|
||
if err == nil {
|
||
logs[ll] = string(b)
|
||
ll++
|
||
}
|
||
}
|
||
if ll == 1 {
|
||
return
|
||
}
|
||
logs = logs[0:ll]
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
conn.Do("LPUSH", logs...)
|
||
}
|
||
|
||
// AddNotice 增加标记
|
||
func (d *Dao) AddNotice(ctx context.Context, uid, coinId, coinNum int64) {
|
||
nKey := fmt.Sprintf(_capsuleNotice, CoinIdIntMap[coinId], uid)
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
conn.Do("SET", nKey, coinNum, 30*86400)
|
||
|
||
}
|
||
|
||
// ClearNotice 清除标记
|
||
func (d *Dao) ClearNotice(ctx context.Context, uid, coinId int64) {
|
||
nKey := fmt.Sprintf(_capsuleNotice, CoinIdIntMap[coinId], uid)
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
conn.Do("DEL", nKey)
|
||
}
|
||
|
||
// ClearNoticeBoth 清除标记
|
||
func (d *Dao) ClearNoticeBoth(ctx context.Context, uid int64) {
|
||
keys := make([]interface{}, len(CoinIdIntMap))
|
||
var i = 0
|
||
for _, coinType := range CoinIdIntMap {
|
||
keys[i] = fmt.Sprintf(_capsuleNotice, coinType, uid)
|
||
}
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
conn.Do("DEL", keys...)
|
||
}
|
||
|
||
// GetChangeNum 获取扭蛋变化数量
|
||
func (d *Dao) GetChangeNum(ctx context.Context, uid, coinId int64) int64 {
|
||
nKey := fmt.Sprintf(_capsuleNotice, CoinIdIntMap[coinId], uid)
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
change, err := redis.Int64(conn.Do("GET", nKey))
|
||
if err != nil {
|
||
return 0
|
||
}
|
||
return change
|
||
}
|
||
|
||
// SetCapsuleChangeFlag 设置扭蛋配置变化标记
|
||
func (d *Dao) SetCapsuleChangeFlag(ctx context.Context) (status string, err error) {
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
status, err = redis.String(conn.Do("SET", _capsuleConfRand, time.Now().Unix()))
|
||
if err != nil {
|
||
log.Error("[dao.capsule | SetCapsuleChangeFlag] redis set error : %v", err)
|
||
return
|
||
}
|
||
return
|
||
}
|
||
|
||
// GetCapsuleChangeFlag 获取扭蛋配置变化标记
|
||
func (d *Dao) GetCapsuleChangeFlag(ctx context.Context) (changeFlag int64, err error) {
|
||
conn := d.redis.Get(ctx)
|
||
defer conn.Close()
|
||
changeFlag, err = redis.Int64(conn.Do("GET", _capsuleConfRand))
|
||
if err != nil {
|
||
return
|
||
}
|
||
return
|
||
}
|
||
|
||
// GetCapsuleChangeInfo 获取扭蛋配置信息
|
||
func (d *Dao) GetCapsuleChangeInfo(ctx context.Context) (int64, int64) {
|
||
capsuleConf.RwLock.RLock()
|
||
CacheTime := capsuleConf.CacheTime
|
||
ChangeFlag := capsuleConf.ChangeFlag
|
||
capsuleConf.RwLock.RUnlock()
|
||
return CacheTime, ChangeFlag
|
||
}
|
||
|
||
// RelaodCapsuleConfig 重新加载扭蛋配置
|
||
func (d *Dao) RelaodCapsuleConfig(ctx context.Context, changeFlag int64) (conf map[int64]*CapsuleCoinConf, err error) {
|
||
coinMap, err := d.GetCoinMap(ctx)
|
||
if err != nil || len(coinMap) == 0 {
|
||
log.Error("[dao.capsule | RelaodCapsuleConfig] coinMap is empty")
|
||
return
|
||
}
|
||
coinIds := make([]int64, len(coinMap))
|
||
ix := 0
|
||
for _, coinInfo := range coinMap {
|
||
coinIds[ix] = coinInfo.Id
|
||
ix++
|
||
}
|
||
coinConfigMap, err := d.GetCoinConfigMap(ctx, coinIds)
|
||
if err != nil || len(coinConfigMap) == 0 {
|
||
log.Error("[dao.capsule | RelaodCapsuleConfig] CoinConfigMap is empty")
|
||
return
|
||
}
|
||
poolMap, err := d.GetPoolMap(ctx, coinIds)
|
||
if err != nil || len(poolMap) == 0 {
|
||
log.Error("[dao.capsule | RelaodCapsuleConfig] PoolMap is empty")
|
||
return
|
||
}
|
||
poolIds := make([]int64, 0)
|
||
for _, pools := range poolMap {
|
||
for _, pool := range pools {
|
||
poolIds = append(poolIds, pool.Id)
|
||
}
|
||
|
||
}
|
||
poolPrizeMap, err := d.GetPoolPrizeMap(ctx, poolIds)
|
||
if err != nil || len(poolPrizeMap) == 0 {
|
||
log.Error("[dao.capsule | RelaodCapsuleConfig] PoolPrizeMap is empty")
|
||
return
|
||
}
|
||
coinConfMap := make(map[int64]*CapsuleCoinConf)
|
||
ids := make([]int64, 0)
|
||
prizeIds := make([]int64, 0)
|
||
idMap := make(map[int64]struct{})
|
||
for _, prizeList := range poolPrizeMap {
|
||
for _, prize := range prizeList {
|
||
if prize.ObjectId != 0 && prize.Type == CapsulePrizeTitleType {
|
||
if _, ok := idMap[prize.ObjectId]; !ok {
|
||
ids = append(ids, prize.ObjectId)
|
||
idMap[prize.ObjectId] = struct{}{}
|
||
}
|
||
}
|
||
prizeIds = append(prizeIds, prize.Id)
|
||
}
|
||
}
|
||
prizeWhiteMap, err1 := d.GetWhiteUserMap(ctx, prizeIds)
|
||
if err1 != nil {
|
||
log.Error("[dao.capsule | RelaodCapsuleConfig] GetWhiteUserMap error")
|
||
}
|
||
titleMap := make(map[int64]string)
|
||
if len(ids) != 0 {
|
||
TitleData, err1 := RcApi.V1UserTitle.GetTitleByIds(ctx, &v12.UserTitleGetTitleByIdsReq{Ids: ids})
|
||
if err1 != nil {
|
||
log.Error("[dao.capsule | RelaodCapsuleConfig] GetTitleByIds error")
|
||
}
|
||
if TitleData != nil && TitleData.Data != nil {
|
||
titleMap = TitleData.Data
|
||
}
|
||
}
|
||
for coinId, coinConf := range coinMap {
|
||
conf := &CapsuleCoinConf{}
|
||
conf.Status = coinConf.Status
|
||
conf.GiftType = coinConf.GiftType
|
||
conf.Title = coinConf.Title
|
||
conf.EndTime = coinConf.EndTime
|
||
conf.StartTime = coinConf.StartTime
|
||
conf.Id = coinConf.Id
|
||
conf.ChangeNum = coinConf.ChangeNum
|
||
if _, ok := coinConfigMap[coinId]; ok {
|
||
coinConfig := coinConfigMap[coinId]
|
||
gifts := make(map[int64]struct{})
|
||
areas := make(map[int64]struct{})
|
||
for _, config := range coinConfig {
|
||
if config.GiftId > 0 {
|
||
gifts[config.GiftId] = struct{}{}
|
||
}
|
||
if config.AreaV2ParentId > 0 {
|
||
areas[config.AreaV2Id] = struct{}{}
|
||
}
|
||
}
|
||
conf.AreaMap = areas
|
||
conf.GiftMap = gifts
|
||
}
|
||
if _, ok := poolMap[coinId]; ok {
|
||
for _, poolConf := range poolMap[coinId] {
|
||
pool := &CapsulePoolConf{}
|
||
pool.Id = poolConf.Id
|
||
pool.StartTime = poolConf.StartTime
|
||
pool.EndTime = poolConf.EndTime
|
||
pool.Title = poolConf.Title
|
||
pool.Status = poolConf.Status
|
||
pool.Rule = poolConf.Description
|
||
pool.CoinId = poolConf.CoinId
|
||
pool.IsBottom = poolConf.IsBottom
|
||
if _, ok := poolPrizeMap[pool.Id]; ok {
|
||
prizeConfigs := poolPrizeMap[pool.Id]
|
||
pool.PoolPrize = make([]*CapsulePoolPrize, len(poolPrizeMap[pool.Id]))
|
||
for ix, prizeConfig := range prizeConfigs {
|
||
name := PrizeNameMap[prizeConfig.Type]
|
||
if prizeConfig.Type == CapsulePrizeTitleType && titleMap != nil {
|
||
if _, ok := titleMap[prizeConfig.ObjectId]; ok {
|
||
name = titleMap[prizeConfig.ObjectId]
|
||
}
|
||
}
|
||
prize := &CapsulePoolPrize{
|
||
Id: prizeConfig.Id,
|
||
PoolId: prizeConfig.PoolId,
|
||
Type: prizeConfig.Type,
|
||
Num: prizeConfig.Num,
|
||
ObjectId: prizeConfig.ObjectId,
|
||
Expire: prizeConfig.Expire,
|
||
Name: name,
|
||
WebImage: prizeConfig.WebUrl,
|
||
MobileImage: prizeConfig.MobileUrl,
|
||
Description: prizeConfig.Description,
|
||
JumpUrl: prizeConfig.JumpUrl,
|
||
ProType: prizeConfig.ProType,
|
||
Chance: prizeConfig.Chance,
|
||
LoopNum: prizeConfig.LoopNum,
|
||
LimitNum: prizeConfig.LimitNum,
|
||
Weight: prizeConfig.Weight,
|
||
}
|
||
prize.WhiteUserMap = make(map[int64]struct{})
|
||
if prize.ProType == ProTypeWhite {
|
||
if _, ok := prizeWhiteMap[prize.Id]; ok {
|
||
if len(prizeWhiteMap[prize.Id]) > 0 {
|
||
for _, wuid := range prizeWhiteMap[prize.Id] {
|
||
prize.WhiteUserMap[wuid] = struct{}{}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
pool.PoolPrize[ix] = prize
|
||
}
|
||
}
|
||
if conf.AllPoolConf == nil {
|
||
conf.AllPoolConf = make([]*CapsulePoolConf, 0)
|
||
}
|
||
conf.AllPoolConf = append(conf.AllPoolConf, pool)
|
||
}
|
||
|
||
}
|
||
coinConfMap[coinId] = conf
|
||
}
|
||
cacheTime := time.Now().Unix()
|
||
capsuleConf.RwLock.Lock()
|
||
capsuleConf.CacheTime = cacheTime
|
||
capsuleConf.ChangeFlag = changeFlag
|
||
capsuleConf.CoinConfMap = coinConfMap
|
||
capsuleConf.RwLock.Unlock()
|
||
log.Info("[dao.capsule | RelaodCapsuleConfig] reload conf")
|
||
return coinConfMap, nil
|
||
}
|
||
|
||
// GetBottomPrize 获取保底奖品
|
||
func (d *Dao) GetBottomPrize(ctx context.Context, coinConf *CapsuleCoinConf) (bottomPrize *CapsulePoolPrize) {
|
||
if coinConf == nil || coinConf.PoolConf == nil || len(coinConf.PoolConf.PoolPrize) == 0 {
|
||
return nil
|
||
}
|
||
|
||
for _, prize := range coinConf.PoolConf.PoolPrize {
|
||
if bottomPrize == nil || bottomPrize.Weight > prize.Weight {
|
||
bottomPrize = &CapsulePoolPrize{
|
||
Id: prize.Id,
|
||
PoolId: prize.PoolId,
|
||
Type: prize.Type,
|
||
Name: prize.Name,
|
||
WebImage: prize.WebImage,
|
||
MobileImage: prize.MobileImage,
|
||
Description: prize.Description,
|
||
ProType: prize.ProType,
|
||
JumpUrl: prize.JumpUrl,
|
||
ObjectId: prize.ObjectId,
|
||
Expire: prize.Expire,
|
||
Weight: prize.Weight,
|
||
Num: prize.Num,
|
||
}
|
||
}
|
||
}
|
||
return bottomPrize
|
||
}
|
||
|
||
//GetExpireTime 获取过期时间
|
||
func (d *Dao) GetExpireTime(expire int64) time.Time {
|
||
var td time.Time
|
||
if expire == CapsulePrizeExpire1Day {
|
||
year, month, day := time.Now().Date()
|
||
td = time.Date(year, month, day, 0, 0, 0, 0, time.Now().Location()).Add(86400 * time.Second).Add(86400 * time.Second)
|
||
} else if expire == CapsulePrizeExpire3Day {
|
||
year, month, day := time.Now().Date()
|
||
td = time.Date(year, month, day, 0, 0, 0, 0, time.Now().Location()).Add(86400 * time.Second).Add(3 * 86400 * time.Second)
|
||
} else if expire == CapsulePrizeExpire1Week {
|
||
year, month, day := time.Now().Date()
|
||
td = time.Date(year, month, day, 0, 0, 0, 0, time.Now().Location()).Add(86400 * time.Second).Add(6 * 86400 * time.Second)
|
||
} else if expire == CapsulePrizeExpire3Month {
|
||
year, month, day := time.Now().Date()
|
||
td = time.Date(year, month, day, 0, 0, 0, 0, time.Now().Location()).Add(86400 * time.Second).Add(90 * 86400 * time.Second)
|
||
} else if expire == CapsulePrizeExpireForever {
|
||
td = time.Unix(0, 0)
|
||
} else {
|
||
td = time.Unix(0, 0)
|
||
}
|
||
return td
|
||
}
|
||
|
||
// IsAwardEntry 是否是实物奖励
|
||
func (d *Dao) IsAwardEntry(awardType int64) bool {
|
||
if awardType == CapsulePrizeSmallTvType || awardType == CapsulePrizeLplProduct1 || awardType == CapsulePrizeLplProduct2 || awardType == CapsulePrizeLplProduct3 {
|
||
return true
|
||
}
|
||
if awardType >= CapsulePrizeProduct1 && awardType < CapsulePrizeCoupon1 {
|
||
return true
|
||
}
|
||
return false
|
||
}
|
||
|
||
// IsAwardCoupon 是否是会员券
|
||
func (d *Dao) IsAwardCoupon(awardType int64) bool {
|
||
return awardType >= CapsulePrizeCoupon1
|
||
}
|