You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1148 lines
37 KiB
1148 lines
37 KiB
package dao |
|
|
|
import ( |
|
"context" |
|
"fmt" |
|
"strconv" |
|
"strings" |
|
"sync" |
|
"time" |
|
|
|
"github.com/pkg/errors" |
|
|
|
v12 "go-common/app/service/live/rc/api/liverpc/v1" |
|
"go-common/library/cache/redis" |
|
|
|
"go-common/app/job/live/xlottery/internal/model" |
|
"go-common/library/database/sql" |
|
"go-common/library/log" |
|
"go-common/library/queue/databus/report" |
|
) |
|
|
|
// NormalCoinId 普通扭蛋id |
|
const NormalCoinId = 1 |
|
|
|
// ColorfulCoinId 梦幻扭蛋id |
|
const ColorfulCoinId = 2 |
|
|
|
// WeekCoinId 周星扭蛋id |
|
const WeekCoinId = 3 |
|
|
|
// LplCoinId 周星扭蛋id |
|
const LplCoinId = 4 |
|
|
|
// BlessCoinId 祈福抽奖券 |
|
const BlessCoinId = 5 |
|
|
|
// IsBottomPool 是否为保底奖池 |
|
const IsBottomPool = 1 |
|
|
|
// CapsuleActionTrans 转换扭蛋币 |
|
const CapsuleActionTrans = "trans" |
|
|
|
const ( |
|
// NormalCoinString 普通扭蛋字符串标识，数据库和redis |
|
NormalCoinString = "normal" |
|
|
|
// ColorfulCoinString 梦幻扭蛋字符串标识，数据库和redis |
|
ColorfulCoinString = "colorful" |
|
|
|
// WeekCoinString 周星扭蛋字符串标识，数据库和redis |
|
WeekCoinString = "week" |
|
|
|
// LplCoinString 周星扭蛋字符串标识，数据库和redis |
|
LplCoinString = "lpl" |
|
|
|
// BlessCoinString 祈福扭蛋字符串标识，数据库和redis |
|
BlessCoinString = "bless" |
|
) |
|
const ( |
|
_capsuleNotice = "capsule:notice:%s:%d" |
|
_userCapsuleCoinRedis = "hash:capsule:user:%d" |
|
_userInfoRedis = "capsule:user:info:%d:%d" |
|
_capsuleConfRand = "capsule:rand" |
|
_lplSendGiftRedis = "capsule:lpl:send:gift:%s:%d" |
|
) |
|
const ( |
|
_ = iota |
|
// CapsulePrizeGift1Type 辣条 |
|
CapsulePrizeGift1Type // 辣条 |
|
// CapsulePrizeTitleType 头衔 |
|
CapsulePrizeTitleType |
|
// CapsulePrizeStuff1Type 经验原石 |
|
CapsulePrizeStuff1Type |
|
// CapsulePrizeStuff2Type 经验曜石 |
|
CapsulePrizeStuff2Type |
|
// CapsulePrizeStuff3Type 贤者之石 |
|
CapsulePrizeStuff3Type |
|
// CapsulePrizeSmallTvType 小电视 |
|
CapsulePrizeSmallTvType |
|
// CapsulePrizeGuard3Type 舰长体验 |
|
CapsulePrizeGuard3Type |
|
// CapsulePrizeGuard2Type 提督体验 |
|
CapsulePrizeGuard2Type |
|
// CapsulePrizeGuard1Type 总督体验 |
|
CapsulePrizeGuard1Type |
|
) |
|
|
|
const ( |
|
_ = iota |
|
// CapsuleGiftTypeAll gift_type 为全部道具 |
|
CapsuleGiftTypeAll |
|
// CapsuleGiftTypeGold gift_type 为金瓜子道具 |
|
CapsuleGiftTypeGold |
|
// CapsuleGiftTypeSelected gift_type 为指定道具 |
|
CapsuleGiftTypeSelected |
|
) |
|
const ( |
|
_getActiveColorPool = "SELECT id, coin_id, title, rule, start_time, end_time, status FROM capsule_pool WHERE status = 1 AND coin_id = ?" |
|
_getCapsuleMaxId = "SELECT id FROM capsule_%s order by id desc limit 1" |
|
_transCapsule = "UPDATE capsule_%s SET normal_score = normal_score + ?,colorful_score = 0 WHERE uid = ?" |
|
_getChangeNum = "SELECT change_num FROM capsule_coin WHERE id = ?" |
|
_getUserInfoById = "SELECT uid,normal_score,colorful_score FROM capsule_%s WHERE id >= ? AND id < ? and colorful_score > 0" |
|
_getUserInfoByUids = "SELECT uid,normal_score,colorful_score FROM capsule_%s WHERE uid in(%s)" |
|
_getOnCoin = "SELECT id, title, gift_type, change_num, start_time, end_time, status FROM capsule_coin WHERE status = 1" |
|
_getCoinConfigMap = "SELECT coin_id, type, area_v2_parent_id, area_v2_id, gift_id FROM capsule_coin_config WHERE coin_id in (%v) AND status = 1" |
|
_getPoolMap = "SELECT id, coin_id, title, rule, start_time, end_time, status, is_bottom FROM capsule_pool WHERE status = 1 and coin_id in (%v)" |
|
_getPoolPrizeMap = "SELECT id, pool_id, type, num, object_id,expire, web_url, mobile_url, description, jump_url, pro_type, chance, loop_num, limit_num, weight FROM capsule_pool_prize WHERE pool_id in (%s) and status = 1 order by ctime" |
|
_reportCapsuleChangeMysql = "insert into capsule_log_%s(uid, type, score, action, platform, pre_normal_score, pre_colorful_score, cur_normal_score, cur_colorful_score) values(?,?,?,?,?,?,?,?,?)" |
|
_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(?, ?, ?)" |
|
_transUserCapsuleMysql = "update capsule_%d set colorful_score = 0, normal_score = normal_score + ? where uid = ?" |
|
_updateUserCapsuleMysql = "update capsule_%d set %s_score = %s_score + ? where uid = ?" |
|
_updateUserInfoMysql = "update capsule_info_%d set score = score + ? where uid = ? and type = ?" |
|
_getExtraDataMysql = "select item_value, item_extra from capsule_extra_data where uid = ? and type = ?" |
|
_addExtraDataMysql = "insert into capsule_extra_data(uid,type,item_value,item_extra) values(?,?,?,?)" |
|
_getExtraDataByTimeMysql = "select id, uid, type, item_value, item_extra from capsule_extra_data where mtime >= ? and mtime < ?" |
|
_updateExtraValueMysql = "update capsule_extra_data set item_value = ? where id = ?" |
|
_updateExtraMtimeMysql = "update capsule_extra_data set mtime = ? where id = ?" |
|
_updateExtraMysql = "update capsule_extra_data set item_value = ?, item_extra = ? where id = ?" |
|
_getExtraDataMaxIdMysql = "select id from capsule_extra_data order by id desc limit 1" |
|
_getExtraDataByIdMysql = "select id, uid, type, item_value, item_extra from capsule_extra_data where id >= ? and id < ?" |
|
) |
|
|
|
var ( |
|
capsuleConf CapsuleConf |
|
|
|
// ReprotConfig map |
|
ReprotConfig map[int64]string |
|
|
|
// CoinIdIntMap map |
|
CoinIdIntMap map[int64]string |
|
// PrizeNameMap map |
|
PrizeNameMap map[int64]string |
|
) |
|
var ( |
|
// UnLockGetWrong flag |
|
UnLockGetWrong = "UnLockGetWrong" |
|
// ErrUnLockGet error |
|
ErrUnLockGet = errors.New(UnLockGetWrong) |
|
) |
|
|
|
// 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 |
|
} |
|
|
|
func init() { |
|
CoinIdIntMap = make(map[int64]string) |
|
CoinIdIntMap[NormalCoinId] = NormalCoinString |
|
CoinIdIntMap[ColorfulCoinId] = ColorfulCoinString |
|
CoinIdIntMap[WeekCoinId] = WeekCoinString |
|
CoinIdIntMap[LplCoinId] = LplCoinString |
|
CoinIdIntMap[BlessCoinId] = BlessCoinString |
|
PrizeNameMap = make(map[int64]string) |
|
PrizeNameMap[CapsulePrizeGift1Type] = "辣条" |
|
PrizeNameMap[CapsulePrizeTitleType] = "头衔" |
|
PrizeNameMap[CapsulePrizeStuff1Type] = "经验原石" |
|
PrizeNameMap[CapsulePrizeStuff2Type] = "经验曜石" |
|
PrizeNameMap[CapsulePrizeStuff3Type] = "贤者之石" |
|
PrizeNameMap[CapsulePrizeSmallTvType] = "小电视抱枕" |
|
PrizeNameMap[CapsulePrizeGuard3Type] = "舰长体验" |
|
PrizeNameMap[CapsulePrizeGuard2Type] = "提督体验" |
|
ReprotConfig = make(map[int64]string) |
|
ReprotConfig[0] = "未知" |
|
ReprotConfig[1] = "增加普通扭蛋" |
|
ReprotConfig[2] = "增加梦幻扭蛋" |
|
ReprotConfig[3] = "减少普通扭蛋" |
|
ReprotConfig[4] = "减少梦幻扭蛋" |
|
ReprotConfig[5] = "梦幻转化普通" |
|
} |
|
|
|
// GetActiveColorPool 获取奖池 |
|
func (d *Dao) GetActiveColorPool(ctx context.Context) (pool []*model.Pool, err error) { |
|
var rows *sql.Rows |
|
if rows, err = d.db.Query(ctx, _getActiveColorPool, ColorfulCoinId); err != nil { |
|
log.Error("[dao.capsule | GetActiveColorPool]query(%s) error(%v)", _getActiveColorPool, err) |
|
return |
|
} |
|
defer rows.Close() |
|
|
|
for rows.Next() { |
|
p := &model.Pool{} |
|
if err = rows.Scan(&p.Id, &p.CoinId, &p.Title, &p.Description, &p.StartTime, &p.EndTime, &p.Status); err != nil { |
|
log.Error("[dao.capsule | GetActiveColorPool] scan error, err %v", err) |
|
return |
|
} |
|
pool = append(pool, p) |
|
} |
|
return |
|
} |
|
|
|
// GetUserInfoById 获取扭蛋币信息 |
|
func (d *Dao) GetUserInfoById(ctx context.Context, table string, start int64, end int64) (infos [][4]int64, err error) { |
|
var rows *sql.Rows |
|
sqlStr := fmt.Sprintf(_getUserInfoById, table) |
|
if rows, err = d.db.Query(ctx, sqlStr, start, end); err != nil { |
|
log.Error("[dao.capsule | GetUserInfos]query(%s) error(%v)", _getUserInfoById, err) |
|
return |
|
} |
|
defer rows.Close() |
|
infos = make([][4]int64, 0) |
|
for rows.Next() { |
|
p := &model.UserInfo{} |
|
if err = rows.Scan(&p.Uid, &p.NormalScore, &p.ColorfulScore); err != nil { |
|
log.Error("[dao.capsule | GetUserInfos] scan error, err %v", err) |
|
return |
|
} |
|
infos = append(infos, [4]int64{p.Uid, p.NormalScore, p.ColorfulScore, 0}) |
|
} |
|
return |
|
} |
|
|
|
// GetUserInfoByUids 获取扭蛋币信息 |
|
func (d *Dao) GetUserInfoByUids(ctx context.Context, table string, uids []int64) (infos map[int64][2]int64, err error) { |
|
var rows *sql.Rows |
|
uidStrArray := make([]string, len(uids)) |
|
for ix, uid := range uids { |
|
uidStrArray[ix] = strconv.FormatInt(uid, 10) |
|
} |
|
uidStr := strings.Join(uidStrArray, ",") |
|
sqlStr := fmt.Sprintf(_getUserInfoByUids, table, uidStr) |
|
if rows, err = d.db.Query(ctx, sqlStr); err != nil { |
|
log.Error("[dao.capsule | GetUserInfoByUids]query(%s) error(%v)", _getUserInfoByUids, err) |
|
return |
|
} |
|
defer rows.Close() |
|
|
|
infos = make(map[int64][2]int64) |
|
for rows.Next() { |
|
p := &model.UserInfo{} |
|
if err = rows.Scan(&p.Uid, &p.NormalScore, &p.ColorfulScore); err != nil { |
|
log.Error("[dao.capsule | GetUserInfoByUids] scan error, err %v", err) |
|
return |
|
} |
|
infos[p.Uid] = [2]int64{p.NormalScore, p.ColorfulScore} |
|
} |
|
return |
|
} |
|
|
|
// GetTransNum 获取扭蛋币数量 |
|
func (d *Dao) GetTransNum(ctx context.Context, coinId int64) (changeNum int64, err error) { |
|
var rows *sql.Rows |
|
if rows, err = d.db.Query(ctx, _getChangeNum, coinId); err != nil { |
|
log.Error("[dao.capsule | GetTransNum]query(%s) error(%v)", _getChangeNum, err) |
|
return |
|
} |
|
defer rows.Close() |
|
|
|
for rows.Next() { |
|
p := &model.Coin{} |
|
if err = rows.Scan(&p.ChangeNum); err != nil { |
|
log.Error("[dao.capsule | GetTransNum]scan error, err %v", err) |
|
return |
|
} |
|
changeNum = p.ChangeNum |
|
} |
|
return |
|
} |
|
|
|
// TransCapsule 转换扭蛋币 |
|
func (d *Dao) TransCapsule(ctx context.Context, table string, colorChangeNum int64, normalChangeNum int64) (err error) { |
|
var maxId int64 |
|
row := d.db.QueryRow(ctx, fmt.Sprintf(_getCapsuleMaxId, table)) |
|
if err = row.Scan(&maxId); err != nil { |
|
log.Error("[dao.capsule | TransCapsule] query(%s),err(%v)", _getCapsuleMaxId, err) |
|
return |
|
} |
|
log.Info("[dao.capsule | TransCapsule] table: %s, max: %d", table, maxId) |
|
conn := d.redis.Get(ctx) |
|
defer conn.Close() |
|
var i int64 |
|
for i = 0; i <= maxId; i = i + 1000 { |
|
var userInfos [][4]int64 |
|
userInfos, err = d.GetUserInfoById(ctx, table, i, i+1000) |
|
if err != nil { |
|
log.Error("[dao.capsule | TransCapsule] GetUserInfos error %v", err) |
|
return err |
|
} |
|
ulen := len(userInfos) |
|
if ulen < 1 { |
|
continue |
|
} |
|
uids := make([]int64, ulen) |
|
for ix, userInfo := range userInfos { |
|
uid := userInfo[0] |
|
changeScore := userInfo[2] - userInfo[2]%normalChangeNum |
|
_, err = d.db.Exec(ctx, fmt.Sprintf(_transCapsule, table), changeScore, uid) |
|
if err != nil { |
|
log.Error("[dao.capsule | TransCapsule]query(%s) error(%v)", _transCapsule, err) |
|
return |
|
} |
|
userInfos[ix][3] = changeScore |
|
uids[ix] = uid |
|
uKey := userKey(uid) |
|
_, e := conn.Do("DEL", uKey) |
|
if e != nil { |
|
log.Error("redis_lottery|delete score error,%v， uid %v", e, uid) |
|
} |
|
|
|
} |
|
var userMap map[int64][2]int64 |
|
userMap, err = d.GetUserInfoByUids(ctx, table, uids) |
|
if err != nil { |
|
log.Error("[dao.capsule | TransCapsule] GetUserInfoByUids error %v", err) |
|
return err |
|
} |
|
if userMap == nil { |
|
continue |
|
} |
|
for _, userInfo := range userInfos { |
|
changeScore := userInfo[3] |
|
uid := userInfo[0] |
|
if _, ok := userMap[uid]; !ok { |
|
continue |
|
} |
|
report.User(&report.UserInfo{ |
|
Business: 101, |
|
Type: int(1), |
|
Oid: uid, |
|
Action: "capsule_change", |
|
Ctime: time.Now(), |
|
Index: []interface{}{ |
|
"梦幻转化普通", |
|
changeScore, |
|
userMap[uid][0], |
|
userMap[uid][1], |
|
"trans", |
|
}, |
|
}) |
|
date := time.Now().Format("200601") |
|
sqlStr := fmt.Sprintf(_reportCapsuleChangeMysql, date) |
|
_, err := d.execSqlWithBindParams(ctx, &sqlStr, uid, 1, changeScore, "trans", "", userInfo[1], userInfo[2], userMap[uid][0], userMap[uid][1]) |
|
if err != nil { |
|
log.Error("[dao.capsule | TransCapsule] AddCapsuleLog error %v", err) |
|
continue |
|
} |
|
} |
|
} |
|
return |
|
} |
|
|
|
func userKey(uid int64) string { |
|
return fmt.Sprintf(_userCapsuleCoinRedis, uid) |
|
} |
|
|
|
func userInfoKey(uid int64, coinId int64) string { |
|
return fmt.Sprintf(_userInfoRedis, uid, coinId) |
|
} |
|
|
|
// GetCapsuleChangeFlag 获取扭蛋配置变化标记 |
|
func (d *Dao) GetCapsuleChangeFlag(ctx context.Context) (randNum int64, err error) { |
|
conn := d.redis.Get(ctx) |
|
defer conn.Close() |
|
randNum, err = redis.Int64(conn.Do("GET", _capsuleConfRand)) |
|
if err != nil { |
|
log.Error("[dao.redis_lottery|GetCapsuleChangeFlag] conn.GET(%s) error(%v)", _capsuleConfRand, err) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// 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("[dao.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 |
|
} |
|
|
|
//GetCoinMap 批量获取扭蛋币 |
|
func (d *Dao) GetCoinMap(ctx context.Context) (coinMap map[int64]*model.Coin, err error) { |
|
var rows *sql.Rows |
|
if rows, err = d.db.Query(ctx, _getOnCoin); err != nil { |
|
log.Error("[dao.coin | GetCoinMap] query(%s) error(%v)", _getOnCoin, err) |
|
return |
|
} |
|
defer rows.Close() |
|
|
|
coinMap = make(map[int64]*model.Coin) |
|
for rows.Next() { |
|
p := &model.Coin{} |
|
if err = rows.Scan(&p.Id, &p.Title, &p.GiftType, &p.ChangeNum, &p.StartTime, &p.EndTime, &p.Status); err != nil { |
|
log.Error("[dao.coin | GetCoinMap] scan error, err %v", err) |
|
return |
|
} |
|
coinMap[p.Id] = p |
|
} |
|
return |
|
} |
|
|
|
//GetCoinConfigMap 批量获取扭蛋币 |
|
func (d *Dao) GetCoinConfigMap(ctx context.Context, coinIds []int64) (configMap map[int64][]*model.CoinConfig, err error) { |
|
var rows *sql.Rows |
|
stringCoinIds := make([]string, 0) |
|
for _, coinId := range coinIds { |
|
stringCoinIds = append(stringCoinIds, strconv.FormatInt(coinId, 10)) |
|
} |
|
coinString := strings.Join(stringCoinIds, ",") |
|
if rows, err = d.db.Query(ctx, fmt.Sprintf(_getCoinConfigMap, coinString)); err != nil { |
|
log.Error("[dao.coin_config | GetCoinConfigMap]query(%s) error(%v)", _getCoinConfigMap, err) |
|
return |
|
} |
|
defer rows.Close() |
|
|
|
configMap = make(map[int64][]*model.CoinConfig) |
|
for rows.Next() { |
|
d := &model.CoinConfig{} |
|
if err = rows.Scan(&d.CoinId, &d.Type, &d.AreaV2ParentId, &d.AreaV2Id, &d.GiftId); err != nil { |
|
log.Error("[dao.coin_config | GetCoinConfigMap] scan error, err %v", err) |
|
return |
|
} |
|
configMap[d.CoinId] = append(configMap[d.CoinId], d) |
|
} |
|
return |
|
} |
|
|
|
//GetPoolMap 批量奖池信息 |
|
func (d *Dao) GetPoolMap(ctx context.Context, coinIds []int64) (poolMap map[int64][]*model.Pool, err error) { |
|
var rows *sql.Rows |
|
stringCoinIds := make([]string, 0) |
|
for _, coinId := range coinIds { |
|
stringCoinIds = append(stringCoinIds, strconv.FormatInt(coinId, 10)) |
|
} |
|
coinString := strings.Join(stringCoinIds, ",") |
|
if rows, err = d.db.Query(ctx, fmt.Sprintf(_getPoolMap, coinString)); err != nil { |
|
log.Error("[dao.pool | GetPoolMap]query(%s) error(%v)", _getPoolMap, err) |
|
return |
|
} |
|
defer rows.Close() |
|
|
|
poolMap = make(map[int64][]*model.Pool) |
|
for rows.Next() { |
|
d := &model.Pool{} |
|
if err = rows.Scan(&d.Id, &d.CoinId, &d.Title, &d.Description, &d.StartTime, &d.EndTime, &d.Status, &d.IsBottom); err != nil { |
|
log.Error("[dao.pool |GetPoolMap] scan error, err %v", err) |
|
return |
|
} |
|
if _, ok := poolMap[d.CoinId]; !ok { |
|
poolMap[d.CoinId] = make([]*model.Pool, 0) |
|
} |
|
poolMap[d.CoinId] = append(poolMap[d.CoinId], d) |
|
} |
|
return |
|
} |
|
|
|
// GetPoolPrizeMap 批量奖池奖品 |
|
func (d *Dao) GetPoolPrizeMap(ctx context.Context, poolIds []int64) (poolPrizeMap map[int64][]*model.PoolPrize, err error) { |
|
var rows *sql.Rows |
|
stringPoolIds := make([]string, 0) |
|
for _, poolId := range poolIds { |
|
stringPoolIds = append(stringPoolIds, strconv.FormatInt(poolId, 10)) |
|
} |
|
poolString := strings.Join(stringPoolIds, ",") |
|
if rows, err = d.db.Query(ctx, fmt.Sprintf(_getPoolPrizeMap, poolString)); err != nil { |
|
log.Error("[dao.pool_prize | GetPoolPrizeMap] query(%s) error(%v)", _getPoolPrizeMap, err) |
|
return |
|
} |
|
defer rows.Close() |
|
|
|
poolPrizeMap = make(map[int64][]*model.PoolPrize) |
|
for rows.Next() { |
|
d := &model.PoolPrize{} |
|
if err = rows.Scan(&d.Id, &d.PoolId, &d.Type, &d.Num, &d.ObjectId, &d.Expire, &d.WebUrl, &d.MobileUrl, &d.Description, &d.JumpUrl, &d.ProType, &d.Chance, &d.LoopNum, &d.LimitNum, &d.Weight); err != nil { |
|
log.Error("[dao.pool_prize | GetPoolPrizeMap] scan error, err %v", err) |
|
return |
|
} |
|
if _, ok := PrizeNameMap[d.Type]; !ok { |
|
continue |
|
} |
|
poolPrizeMap[d.PoolId] = append(poolPrizeMap[d.PoolId], d) |
|
} |
|
return |
|
} |
|
|
|
// 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) |
|
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{}{} |
|
} |
|
} |
|
} |
|
} |
|
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, |
|
} |
|
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 |
|
} |
|
|
|
func getCapsuleTable(Uid int64) int64 { |
|
return Uid % 10 |
|
} |
|
|
|
// UpdateScore 更新扭蛋币积分 |
|
func (d *Dao) UpdateScore(ctx context.Context, uid, coinId, score int64, action, platform string, userInfo map[int64]int64, coinConf *CapsuleCoinConf) (affect int64, err error) { |
|
var ( |
|
sqlStr, uKey, iKey string |
|
) |
|
if _, ok := userInfo[coinId]; !ok { |
|
userInfo, _ = d.GetUserCapsuleInfo(ctx, uid) |
|
} |
|
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) |
|
affect, err = d.execSqlWithBindParams(ctx, &sqlStr, score, uid) |
|
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) |
|
} |
|
d.ReportCapsuleChange(ctx, coinId, uid, score, action, platform, userInfo, coinConf) |
|
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 |
|
) |
|
userInfo, _ := d.GetUserInfo(ctx, uid, coinId) |
|
sqlStr = fmt.Sprintf(_updateUserInfoMysql, getCapsuleTable(uid)) |
|
conn := d.redis.Get(ctx) |
|
defer conn.Close() |
|
uKey = userKey(uid) |
|
iKey = userInfoKey(uid, coinId) |
|
affect, err = d.execSqlWithBindParams(ctx, &sqlStr, score, uid, CoinIdIntMap[coinId]) |
|
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) |
|
} |
|
d.ReportCapsuleChange(ctx, coinId, uid, score, action, platform, userInfo, coinConf) |
|
return |
|
} |
|
|
|
// 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 { |
|
return d.GetUserCapsuleInfo(c, uid) |
|
} |
|
var ( |
|
isEmpty bool |
|
uKey string |
|
) |
|
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|setUserCapsuleInfoCache] 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 { |
|
return |
|
} |
|
if err == sql.ErrNoRows { |
|
sqlStr := fmt.Sprintf(_addInfoMysql, getCapsuleTable(uid)) |
|
_, err = d.db.Exec(c, sqlStr, uid, CoinIdIntMap[coinId], 0) |
|
if err != nil { |
|
return |
|
} |
|
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 |
|
} |
|
|
|
// ReportCapsuleChange 通知扭蛋积分变换 |
|
func (d *Dao) ReportCapsuleChange(ctx context.Context, coinId, uid, score int64, action, platform string, pInfo map[int64]int64, coinConf *CapsuleCoinConf) bool { |
|
if _, ok := pInfo[coinId]; !ok { |
|
return false |
|
} |
|
chnageType := coinId |
|
cInfo, err := d.GetUserInfo(ctx, uid, coinId) |
|
if err != nil { |
|
return false |
|
} |
|
if _, ok := cInfo[coinId]; !ok { |
|
return false |
|
} |
|
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 |
|
} |
|
|
|
// GetCoin 获取扭蛋数量 |
|
func (d *Dao) GetCoin(score int64, coinConf *CapsuleCoinConf) (coinNum int64) { |
|
if coinConf == nil || coinConf.ChangeNum == 0 { |
|
return 0 |
|
} |
|
coinNum = score / coinConf.ChangeNum |
|
return |
|
} |
|
|
|
// 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() |
|
_, err := conn.Do("SET", nKey, coinNum, "EX", 30*86400) |
|
if err != nil { |
|
log.Error("[dao.redis_lottery|AddNotice] conn.SET(%s) error(%v)", nKey, err) |
|
} |
|
} |
|
|
|
// 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 |
|
} |
|
|
|
// CheckLplFirstGift 检测是否首次送礼 |
|
func (d *Dao) CheckLplFirstGift(ctx context.Context, uid, giftId int64) bool { |
|
var ( |
|
value int64 |
|
extra string |
|
day string |
|
cType string |
|
) |
|
day = time.Now().Format("2006-01-02") |
|
cType = "lpl" + day |
|
nKey := fmt.Sprintf(_lplSendGiftRedis, day, uid) |
|
|
|
conn := d.redis.Get(ctx) |
|
defer conn.Close() |
|
_, err := redis.Int64(conn.Do("GET", nKey)) |
|
log.Info("[dao.redis_lottery|CheckLplFirstGift] conn.GET(%s) error(%v)", nKey, err) |
|
if err == redis.ErrNil { |
|
row := d.db.QueryRow(ctx, _getExtraDataMysql, uid, cType) |
|
err = row.Scan(&value, &extra) |
|
if err == sql.ErrNoRows { |
|
_, err = d.db.Exec(ctx, _addExtraDataMysql, uid, cType, time.Now().Unix(), strconv.FormatInt(giftId, 10)) |
|
if err != nil { |
|
log.Error("[dao.redis_lottery|CheckLplFirstGift] conn.addExtraData(%s) error(%v)", nKey, err) |
|
return false |
|
} |
|
return true |
|
} |
|
if err != nil { |
|
log.Error("[dao.redis_lottery|CheckLplFirstGift] conn.getExtraData(%s) error(%v)", nKey, err) |
|
return false |
|
} |
|
_, err = conn.Do("SET", nKey, 1, "EX", 86400) |
|
if err != nil { |
|
log.Error("[dao.redis_lottery|CheckLplFirstGift] conn.SET(%s) error(%v)", nKey, err) |
|
} |
|
return false |
|
} |
|
if err != nil { |
|
log.Error("[dao.redis_lottery|CheckLplFirstGift] conn.GET(%s) error(%v)", nKey, err) |
|
} |
|
return false |
|
} |
|
|
|
// GetExtraDataByTime 获取数据 |
|
func (d *Dao) GetExtraDataByTime(ctx context.Context, startTime, endTime string) (extraData []*model.ExtraData, err error) { |
|
var rows *sql.Rows |
|
if rows, err = d.db.Query(ctx, _getExtraDataByTimeMysql, startTime, endTime); err != nil { |
|
log.Error("[dao.extra | GetExtraDataByType] query(%s) error (%v)", _getExtraDataByTimeMysql, err) |
|
return |
|
} |
|
log.Info("[dao.extra | GetExtraDataByType] start(%d) end(%s)", startTime, endTime) |
|
defer rows.Close() |
|
extraData = make([]*model.ExtraData, 0) |
|
for rows.Next() { |
|
p := &model.ExtraData{} |
|
if err = rows.Scan(&p.Id, &p.Uid, &p.Type, &p.ItemValue, &p.ItemExtra); err != nil { |
|
log.Error("[dao.extra | GetExtraDataByType] scan error, err %v", err) |
|
return |
|
} |
|
extraData = append(extraData, p) |
|
} |
|
return |
|
} |
|
|
|
// UpdateExtraValueById 更新数据 |
|
func (d *Dao) UpdateExtraValueById(ctx context.Context, id int64, itemValue int64) (status bool, err error) { |
|
res, err := d.db.Exec(ctx, _updateExtraValueMysql, itemValue, id) |
|
if err != nil { |
|
log.Error("[dao.extra | UpdateExtraValue] update(%s) error(%v)", _updateExtraValueMysql, err) |
|
return false, err |
|
} |
|
var rows int64 |
|
rows, err = res.RowsAffected() |
|
if err != nil { |
|
log.Error("[dao.extra | UpdateExtraValue] err %v", err) |
|
return false, err |
|
} |
|
return rows > 0, nil |
|
} |
|
|
|
// UpdateExtraMtimeById 更新时间数据 |
|
func (d *Dao) UpdateExtraMtimeById(ctx context.Context, id int64, mtime string) (status bool, err error) { |
|
res, err := d.db.Exec(ctx, _updateExtraMtimeMysql, mtime, id) |
|
if err != nil { |
|
log.Error("[dao.extra | UpdateExtraMtimeById] update(%s) error(%v)", _updateExtraMtimeMysql, err) |
|
return false, err |
|
} |
|
var rows int64 |
|
rows, err = res.RowsAffected() |
|
if err != nil { |
|
log.Error("[dao.extra | UpdateExtraMtimeById] err %v", err) |
|
return false, err |
|
} |
|
return rows > 0, nil |
|
} |
|
|
|
// UpdateExtraById 更新数据 |
|
func (d *Dao) UpdateExtraById(ctx context.Context, id int64, itemValue int64, itemExtra string) (status bool, err error) { |
|
res, err := d.db.Exec(ctx, _updateExtraMysql, itemValue, itemExtra, id) |
|
if err != nil { |
|
log.Error("[dao.extra | UpdateExtraById] update(%s) error(%v)", _updateExtraMysql, err) |
|
return false, err |
|
} |
|
var rows int64 |
|
rows, err = res.RowsAffected() |
|
if err != nil { |
|
log.Error("[dao.extra | UpdateExtraById] err %v", err) |
|
return false, err |
|
} |
|
return rows > 0, nil |
|
} |
|
|
|
// GetExtraDataByIds 获取数据 |
|
func (d *Dao) GetExtraDataByIds(ctx context.Context, start, end int64) (extraData []*model.ExtraData, err error) { |
|
var rows *sql.Rows |
|
if rows, err = d.db.Query(ctx, _getExtraDataByIdMysql, start, end); err != nil { |
|
log.Error("[dao.capsule | GetExtraDataByIds]query(%s) error(%v)", _getUserInfoById, err) |
|
return |
|
} |
|
defer rows.Close() |
|
extraData = make([]*model.ExtraData, 0) |
|
for rows.Next() { |
|
p := &model.ExtraData{} |
|
if err = rows.Scan(&p.Id, &p.Uid, &p.Type, &p.ItemValue, &p.ItemExtra); err != nil { |
|
log.Error("[dao.capsule | GetExtraDataByIds] scan error, err %v", err) |
|
return |
|
} |
|
extraData = append(extraData, p) |
|
} |
|
return |
|
} |
|
|
|
// GetCouponData 添加数据 |
|
func (d *Dao) GetCouponData(ctx context.Context) (extraData []*model.ExtraData, err error) { |
|
var i, maxId int64 |
|
row := d.db.QueryRow(ctx, _getExtraDataMaxIdMysql) |
|
if err = row.Scan(&maxId); err != nil { |
|
log.Error("[dao.capsule | GetCouponData] query(%s),err(%v)", _getExtraDataMaxIdMysql, err) |
|
return |
|
} |
|
extraData = make([]*model.ExtraData, 0) |
|
for i = 0; i < maxId; i = i + 10000 { |
|
var curExtraData []*model.ExtraData |
|
curExtraData, err = d.GetExtraDataByIds(ctx, i, i+10000) |
|
if err != nil { |
|
return |
|
} |
|
for _, extra := range curExtraData { |
|
if extra.ItemValue != 0 { |
|
continue |
|
} |
|
if !strings.HasPrefix(extra.Type, "CouponRetry") { |
|
continue |
|
} |
|
extraData = append(extraData, extra) |
|
} |
|
|
|
} |
|
return |
|
}
|
|
|