You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1165 lines
27 KiB
Go
1165 lines
27 KiB
Go
package campaignuser
|
|
|
|
import (
|
|
"joybuywork/internal/app"
|
|
"joybuywork/internal/consts"
|
|
"joybuywork/internal/consts/ckey"
|
|
"joybuywork/internal/repository/cache"
|
|
"joybuywork/internal/repository/dbcheck"
|
|
"joybuywork/internal/repository/finder"
|
|
"joybuywork/internal/repository/model"
|
|
"joybuywork/internal/repository/mtype"
|
|
"joybuywork/internal/utils"
|
|
"joybuywork/internal/utils/logic"
|
|
"joybuywork/internal/utils/timez"
|
|
"joybuywork/internal/utils/verify"
|
|
pb "joybuywork/proto/go_proto/w_campaign_user"
|
|
"fmt"
|
|
|
|
"gorm.io/gen"
|
|
"gorm.io/gen/field"
|
|
)
|
|
|
|
type List struct {
|
|
logic.Logic
|
|
Req *pb.ListReq
|
|
Res *pb.ListRes
|
|
|
|
diceMap map[int64]*pb.ListRes_Dice
|
|
chopMap map[int64]*pb.ListRes_Chop
|
|
newcomerMap map[int64]*pb.ListRes_Win
|
|
keepDogMap map[int64]*pb.ListRes_Keep
|
|
cashMap map[int64]map[string]*pb.ListRes_Cash
|
|
goldMap map[int64]map[string]*pb.ListRes_Gold
|
|
helpFailMark map[int64]string
|
|
|
|
coinMap map[int64]*pb.ListRes_Coin
|
|
|
|
signMap map[int64]*pb.ListRes_Sign
|
|
|
|
vsMap map[int64]*pb.ListRes_Vs
|
|
|
|
unoMap map[int64]*pb.ListRes_Uno
|
|
}
|
|
|
|
func (s *List) Run() error {
|
|
return logic.Run(s)
|
|
}
|
|
|
|
func (s *List) Exec() (err error) {
|
|
cpn, err := s.campaign()
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
if cpn == nil {
|
|
return
|
|
}
|
|
|
|
err = s.list(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 活动数据
|
|
func (s *List) campaign() (cpn *model.FissionCampaign, err error) {
|
|
cpn, err = finder.Campaign(s.Ctx, s.Req.GetCampaignId(), s.Req.GetCampaignHashId())
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
if cpn == nil || cpn.IsDel == mtype.Yes {
|
|
return
|
|
}
|
|
|
|
tz := utils.STernary[int32](s.Req.GetTOffset(), consts.DefaultTz, cpn.TOffset)
|
|
|
|
s.Req.Start = timez.GMT(s.Req.Start, tz)
|
|
s.Req.End = timez.GMT(s.Req.End, tz)
|
|
|
|
s.Res.TOffset = tz
|
|
s.Res.FissionId = cpn.FissionID
|
|
s.Res.FissionMark = consts.FissionIdMap[cpn.FissionID]
|
|
|
|
return
|
|
}
|
|
|
|
func (s *List) list(cpn *model.FissionCampaign) (err error) {
|
|
m := s.GetDao().FissionUser.SubTable(cpn.ID)
|
|
var cond = []gen.Condition{
|
|
m.IsDel.Eq(mtype.No),
|
|
m.IsView.Eq(mtype.No),
|
|
m.CampaignID.Eq(cpn.ID),
|
|
}
|
|
|
|
if s.Req.GetPid() > 0 {
|
|
cond = append(cond, m.ParentID.Eq(s.Req.GetPid()))
|
|
}
|
|
|
|
if !verify.EmptyString(s.Req.GetUserMark()) {
|
|
cond = append(cond, m.UserMark.Eq(s.Req.GetUserMark()))
|
|
}
|
|
|
|
if s.Req.GetStart() > 0 {
|
|
cond = append(cond, m.CreatedAt.Gte(s.Req.GetStart()))
|
|
}
|
|
|
|
if s.Req.GetEnd() > 0 {
|
|
cond = append(cond, m.CreatedAt.Lte(s.Req.GetEnd()))
|
|
}
|
|
|
|
if s.Req.GetSource() > 0 {
|
|
cond = append(cond, m.Source.Eq(int8(s.Req.GetSource())))
|
|
}
|
|
|
|
if s.Req.GetLangMark() != "" {
|
|
cond = append(cond, m.LangMark.Eq(s.Req.GetLangMark()))
|
|
}
|
|
|
|
if s.Req.GetParentUserMark() != "" {
|
|
var puser *model.FissionUser
|
|
puser, err = cache.NewFissionUser(s.Ctx, cpn.ID).FindBySubUserId(s.Req.GetParentUserMark())
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
if puser == nil {
|
|
cond = append(cond, m.ID.Eq(-1))
|
|
} else {
|
|
cond = append(cond, m.ParentID.Eq(puser.ID))
|
|
}
|
|
}
|
|
|
|
if s.Req.GetPidType() != 0 {
|
|
switch s.Req.GetPidType() {
|
|
case 1:
|
|
cond = append(cond, m.ParentID.Gt(0))
|
|
case 2:
|
|
cond = append(cond, m.ParentID.Eq(0))
|
|
}
|
|
}
|
|
|
|
if s.Req.GetJoinType() != 0 {
|
|
switch s.Req.GetJoinType() {
|
|
case 1:
|
|
cond = append(cond, m.JoinAt.Gt(0))
|
|
case 2:
|
|
cond = append(cond, m.JoinAt.Eq(0))
|
|
}
|
|
}
|
|
|
|
if len(s.Req.GetUserCond()) > 0 {
|
|
for _, v := range s.Req.GetUserCond() {
|
|
switch v {
|
|
case mtype.FissionUserStateDataCondInstall:
|
|
cond = append(cond, m.InstallAt.Gt(0))
|
|
case mtype.FissionUserStateDataCondRegister:
|
|
cond = append(cond, m.RegisterAt.Gt(0))
|
|
default:
|
|
cond = append(cond, m.ID.Eq(0))
|
|
}
|
|
}
|
|
}
|
|
|
|
var orderBys []field.Expr
|
|
if s.Req.OrderByTimeAsc {
|
|
orderBys = append(orderBys, m.CreatedAt)
|
|
}
|
|
orderBys = append(orderBys, m.ID.Desc())
|
|
|
|
list, total, err := s._find(cpn.ID, cond, orderBys)
|
|
if err != nil || total == 0 {
|
|
return
|
|
}
|
|
|
|
//找上级用户数据
|
|
var (
|
|
pids, ids, channelIds, lvIds []int64
|
|
userMap = make(map[int64]string)
|
|
channelMap = make(map[int64]string)
|
|
platformMap = make(map[int64]string)
|
|
lvTitleMap = make(map[int64]string)
|
|
chanceMap = make(map[int64]int32)
|
|
statNumMap = make(map[int64]*model.FissionUserStat)
|
|
userCondMap = make(map[int64][]*pb.ListRes_Cond)
|
|
)
|
|
for _, v := range list {
|
|
ids = append(ids, v.ID)
|
|
statNumMap[v.ID] = nil
|
|
chanceMap[v.ID] = 0
|
|
userMap[v.ID] = v.UserMark
|
|
platformMap[v.ID] = ""
|
|
userCondMap[v.ID] = nil
|
|
|
|
if _, ok := userMap[v.ParentID]; !ok && v.ParentID > 0 {
|
|
userMap[v.ParentID] = ""
|
|
pids = append(pids, v.ParentID)
|
|
}
|
|
|
|
if _, ok := channelMap[v.ChannelID]; !ok && v.ChannelID > 0 {
|
|
channelMap[v.ChannelID] = ""
|
|
channelIds = append(channelIds, v.ChannelID)
|
|
}
|
|
|
|
if _, ok := lvTitleMap[v.UserLevel]; !ok && v.UserLevel > 0 {
|
|
lvTitleMap[v.UserLevel] = ""
|
|
lvIds = append(lvIds, v.UserLevel)
|
|
}
|
|
}
|
|
|
|
err = s._parentMap(cpn.ID, pids, userMap)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s._statMap(ids, statNumMap)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s._channelMap(channelIds, channelMap)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s._chanceMap(cpn, ids, chanceMap)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s._platformMap(cpn, ids, platformMap)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s._lvTitleMap(lvIds, lvTitleMap)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s._conds(cpn.ID, ids, userCondMap)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s._helpMap(cpn, list)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
s.Res.List = make([]*pb.ListRes_One, 0, len(list))
|
|
s.Res.Total = total
|
|
|
|
for _, v := range list {
|
|
one := &pb.ListRes_One{
|
|
Id: v.ID,
|
|
HashId: v.HashID,
|
|
SubUserId: v.SubUserID,
|
|
Parent: userMap[v.ParentID],
|
|
ChildNum: 0,
|
|
IndirectNum: 0,
|
|
IsNew: int32(v.IsNew),
|
|
CreatedAt: v.CreatedAt,
|
|
Chance: chanceMap[v.ID],
|
|
IsHelp: 0,
|
|
Dice: nil,
|
|
ChannelTitle: channelMap[v.ChannelID],
|
|
Source: int32(v.Source),
|
|
EffectNum: 0,
|
|
LangMark: v.LangMark,
|
|
CountryMark: v.UserCountry,
|
|
LvTitle: lvTitleMap[v.UserLevel],
|
|
Platform: platformMap[v.ID],
|
|
UserMark: v.UserMark,
|
|
UserMarkSource: utils.Ternary[int32](v.SubUserID == "", 2, 1),
|
|
Conds: userCondMap[v.ID],
|
|
DeviceId: v.DeviceID,
|
|
JoinAt: v.JoinAt,
|
|
InstallAt: v.InstallAt,
|
|
RegisterAt: v.RegisterAt,
|
|
}
|
|
|
|
if stat, ok := statNumMap[v.ID]; ok && stat != nil {
|
|
one.ChildNum = stat.DirectNum
|
|
one.IndirectNum = stat.IndirectNum
|
|
one.EffectNum = stat.EffectiveNum
|
|
}
|
|
|
|
if v.ParentID > 0 {
|
|
one.IsHelp = utils.Ternary[int32](v.IsHelp == mtype.Yes, 1, 2)
|
|
one.FailMark = s.helpFailMark[v.ID]
|
|
}
|
|
|
|
switch cpn.FissionID {
|
|
case consts.IdDice:
|
|
one.Dice = s.diceMap[v.ID]
|
|
case consts.IdChop:
|
|
one.Chop = s.chopMap[v.ID]
|
|
case consts.IdWinTogether:
|
|
one.Win = s.newcomerMap[v.ID]
|
|
case consts.IdKeep:
|
|
one.KeepDog = s.keepDogMap[v.ID]
|
|
case consts.IdCash:
|
|
if cash, ok := s.cashMap[v.ID][v.LangMark]; ok {
|
|
one.Cash = cash
|
|
}
|
|
case consts.IdGold:
|
|
if gold, ok := s.goldMap[v.ID][v.LangMark]; ok {
|
|
one.Gold = gold
|
|
}
|
|
case consts.IdCoin:
|
|
one.Coin = s.coinMap[v.ID]
|
|
case consts.IdSignIn:
|
|
one.Sign = s.signMap[v.ID]
|
|
case consts.IdVs:
|
|
one.Vs = s.vsMap[v.ID]
|
|
case consts.IdUno:
|
|
one.Uno = s.unoMap[v.ID]
|
|
default:
|
|
|
|
}
|
|
|
|
s.Res.List = append(s.Res.List, one)
|
|
}
|
|
|
|
return
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
func (s *List) _find(campaignId int64, cond []gen.Condition, orderBys []field.Expr) (list []*model.FissionUser, total int64, err error) {
|
|
|
|
m := s.GetDao().FissionUser.SubTable(campaignId)
|
|
offset, limit := utils.PpDbLo(s.Req.GetPage(), s.Req.GetPerPage())
|
|
|
|
total, err = m.WithContext(s.Ctx).Select(m.ID).Where(cond...).Count()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
subId := field.NewInt64("a", "id")
|
|
subQuery := gen.Table(m.WithContext(s.Ctx).Select(m.ID).Where(cond...).Order(orderBys...).Offset(offset).Limit(limit).As("a")).Select(subId)
|
|
|
|
qm := s.GetDao().FissionUser.SubTable(campaignId).As("qm")
|
|
list, err = qm.WithContext(s.Ctx).Where(qm.WithContext(s.Ctx).Columns(qm.ID).In(subQuery)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// 父级数据
|
|
func (s *List) _parentMap(cpnId int64, ids []int64, userMap map[int64]string) (err error) {
|
|
if len(ids) == 0 {
|
|
return
|
|
}
|
|
m := s.GetDao().FissionUser.SubTable(cpnId)
|
|
|
|
//找上级数据
|
|
userList, err := m.WithContext(s.Ctx).Where(m.ID.In(ids...)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
for _, v := range userList {
|
|
userMap[v.ID] = v.UserMark
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 统计数据
|
|
func (s *List) _statMap(ids []int64, statNumMap map[int64]*model.FissionUserStat) (err error) {
|
|
if len(ids) == 0 {
|
|
return
|
|
}
|
|
|
|
//统计数据
|
|
statM := s.GetDao().FissionUserStat
|
|
statList, err := statM.WithContext(s.Ctx).Where(statM.UserID.In(ids...)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
for _, v := range statList {
|
|
statNumMap[v.UserID] = v
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 剩余活动次数
|
|
func (s *List) _chanceMap(cpn *model.FissionCampaign, ids []int64, chanceMap map[int64]int32) (err error) {
|
|
|
|
switch cpn.FissionID {
|
|
case consts.IdBlindBox:
|
|
m := s.GetDao().FissionBlind
|
|
var list []*model.FissionBlind
|
|
list, err = m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
for _, v := range list {
|
|
chanceMap[v.UserID] = v.Chance
|
|
}
|
|
case consts.IdLuckyGrid:
|
|
m := s.GetDao().FissionGrid
|
|
var list []*model.FissionGrid
|
|
list, err = m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
for _, v := range list {
|
|
chanceMap[v.UserID] = v.Chance
|
|
}
|
|
case consts.IdSlotMachine:
|
|
m := s.GetDao().FissionSlot
|
|
var list []*model.FissionSlot
|
|
list, err = m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
for _, v := range list {
|
|
chanceMap[v.UserID] = v.Chance
|
|
}
|
|
case consts.IdPrizeWheel:
|
|
m := s.GetDao().FissionPrizeWheel
|
|
var list []*model.FissionPrizeWheel
|
|
list, err = m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
for _, v := range list {
|
|
chanceMap[v.UserID] = v.Chance
|
|
}
|
|
case consts.IdPrizeAnswer, consts.IdQa, consts.IdQaVideo, consts.IdQaAudio:
|
|
m := s.GetDao().FissionQa
|
|
var list []*model.FissionQa
|
|
list, err = m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
for _, v := range list {
|
|
chanceMap[v.UserID] = v.Chance
|
|
}
|
|
case consts.IdPrizeQuiz:
|
|
m := s.GetDao().FissionQuiz
|
|
var list []*model.FissionQuiz
|
|
list, err = m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
for _, v := range list {
|
|
chanceMap[v.UserID] = v.Chance
|
|
}
|
|
case consts.IdFlip:
|
|
m := s.GetDao().FissionFlip
|
|
var list []*model.FissionFlip
|
|
list, err = m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
for _, v := range list {
|
|
chanceMap[v.UserID] = v.Chance
|
|
}
|
|
case consts.IdBallot:
|
|
m := s.GetDao().FissionBallot
|
|
var list []*model.FissionBallot
|
|
list, err = m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
for _, v := range list {
|
|
chanceMap[v.UserID] = v.Chance
|
|
}
|
|
case consts.IdDice:
|
|
err = s._dice(ids)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
m := s.GetDao().FissionCampaignDice
|
|
var conf *model.FissionCampaignDice
|
|
conf, err = m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID)).Take()
|
|
if err = dbcheck.DbError(err); err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
if conf != nil {
|
|
s.Res.FixDice = int32(conf.FixDice)
|
|
}
|
|
case consts.IdGrow:
|
|
m := s.GetDao().FissionGrow
|
|
var list []*model.FissionGrow
|
|
list, err = m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
for _, v := range list {
|
|
chanceMap[v.UserID] = v.GrowNum
|
|
}
|
|
|
|
case consts.IdChop:
|
|
err = s._chop(ids)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case consts.IdWinTogether:
|
|
|
|
s.newcomerMap = make(map[int64]*pb.ListRes_Win, len(ids))
|
|
|
|
m := s.GetDao().FissionWin
|
|
var list []*model.FissionWin
|
|
list, err = m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
for _, v := range list {
|
|
s.newcomerMap[v.UserID] = &pb.ListRes_Win{
|
|
IsNewcomer: int32(v.IsNewcomer),
|
|
}
|
|
}
|
|
|
|
case consts.IdKeep:
|
|
err = s._keep(ids)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case consts.IdCash:
|
|
err = s._cash(ids)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case consts.IdGold:
|
|
err = s._gold(ids)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case consts.IdCoin:
|
|
err = s._coin(cpn, ids)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case consts.IdSignIn:
|
|
err = s._sign(ids)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case consts.IdVs:
|
|
err = s._vs(ids)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case consts.IdUno:
|
|
err = s._uno(ids)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *List) _sign(ids []int64) (err error) {
|
|
if s.signMap != nil || len(ids) == 0 {
|
|
return
|
|
}
|
|
|
|
playerM := s.GetDao().FissionSign
|
|
list, err := playerM.WithContext(s.Ctx).Where(playerM.UserID.In(ids...)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
s.signMap = make(map[int64]*pb.ListRes_Sign, len(ids))
|
|
for _, v := range list {
|
|
s.signMap[v.UserID] = &pb.ListRes_Sign{
|
|
SignDay: v.SignDay,
|
|
MaxContinue: v.MaxContinue,
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *List) _coin(cpn *model.FissionCampaign, ids []int64) (err error) {
|
|
if s.coinMap != nil || len(ids) == 0 {
|
|
return
|
|
}
|
|
|
|
gmt := utils.Ternary[string](cpn.TOffset < 0, fmt.Sprint(cpn.TOffset), fmt.Sprintf("+%d", cpn.TOffset))
|
|
|
|
m := s.GetDao().FissionCoinScene
|
|
scenes, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
var sceneMap = make(map[int64]string, len(scenes))
|
|
for _, scene := range scenes {
|
|
day, _, _ := timez.GMTStartAndEndTs(cpn.TOffset, scene.OpenTime)
|
|
sceneMap[scene.ID] = fmt.Sprintf("%s(GMT%s)", day, gmt)
|
|
}
|
|
|
|
playerM := s.GetDao().FissionCoin
|
|
list, err := playerM.WithContext(s.Ctx).Where(playerM.UserID.In(ids...)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
s.coinMap = make(map[int64]*pb.ListRes_Coin, len(ids))
|
|
var playerMap = make(map[int64][]*model.FissionCoin, len(ids))
|
|
for _, v := range list {
|
|
playerMap[v.UserID] = append(playerMap[v.UserID], v)
|
|
}
|
|
|
|
for userId, players := range playerMap {
|
|
|
|
var totalUse, totalCoin int32
|
|
var userScenes []*pb.ListRes_CoinScene
|
|
for _, player := range players {
|
|
|
|
userScenes = append(userScenes, &pb.ListRes_CoinScene{
|
|
Title: sceneMap[player.SceneID],
|
|
UseNum: player.UseNum,
|
|
GetCoin: player.GetCoin,
|
|
})
|
|
|
|
totalUse += player.UseNum
|
|
totalCoin += player.GetCoin
|
|
}
|
|
|
|
s.coinMap[userId] = &pb.ListRes_Coin{
|
|
TotalUse: totalUse,
|
|
TotalNum: totalCoin,
|
|
Scenes: userScenes,
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *List) _keep(ids []int64) (err error) {
|
|
if s.keepDogMap != nil || len(ids) == 0 {
|
|
return
|
|
}
|
|
|
|
m := s.GetDao().FissionKeep
|
|
list, err := m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
var rewardMap = make(map[int64]string)
|
|
var rewardIds []int64
|
|
for _, v := range list {
|
|
if _, ok := rewardMap[v.RewardID]; !ok {
|
|
rewardMap[v.RewardID] = ""
|
|
rewardIds = append(rewardIds, v.RewardID)
|
|
}
|
|
}
|
|
|
|
rewardTitleMap, err := s._getRewardTitle(rewardIds)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
s.keepDogMap = make(map[int64]*pb.ListRes_Keep, len(list))
|
|
|
|
for _, v := range list {
|
|
s.keepDogMap[v.UserID] = &pb.ListRes_Keep{
|
|
CollectNum: v.CollectNum,
|
|
RewardTitle: rewardTitleMap[v.RewardID],
|
|
Chance: v.Num,
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *List) _dice(ids []int64) (err error) {
|
|
if s.diceMap != nil || len(ids) == 0 {
|
|
return
|
|
}
|
|
|
|
m := s.GetDao().FissionDice
|
|
list, err := m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
s.diceMap = make(map[int64]*pb.ListRes_Dice, len(list))
|
|
|
|
for _, v := range list {
|
|
s.diceMap[v.UserID] = &pb.ListRes_Dice{
|
|
Chance: v.Chance,
|
|
LuckyChance: 0,
|
|
}
|
|
}
|
|
|
|
pm := s.GetDao().FissionDiceProp
|
|
plist, err := pm.WithContext(s.Ctx).Where(pm.UserID.In(ids...), pm.Mark.Eq(mtype.FissionDicePropMarkFixedRoll)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
for _, v := range plist {
|
|
s.diceMap[v.UserID].LuckyChance = v.Num
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *List) _chop(ids []int64) (err error) {
|
|
if s.chopMap != nil || len(ids) == 0 {
|
|
return
|
|
}
|
|
|
|
m := s.GetDao().FissionChop
|
|
list, err := m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
s.chopMap = make(map[int64]*pb.ListRes_Chop, len(list))
|
|
|
|
var chopMap = make(map[int64]*model.FissionChopReward, len(list))
|
|
var chopRewardMap = make(map[int64]string)
|
|
var chopRewardIds []int64
|
|
for _, v := range list {
|
|
if v.ChopRewardID == 0 {
|
|
continue
|
|
}
|
|
chopRewardIds = append(chopRewardIds, v.ChopRewardID)
|
|
}
|
|
|
|
if len(chopRewardIds) > 0 {
|
|
chopRewardM := s.GetDao().FissionChopReward
|
|
var chopRewardList []*model.FissionChopReward
|
|
chopRewardList, err = chopRewardM.WithContext(s.Ctx).Where(chopRewardM.ID.In(chopRewardIds...)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var rewardIds []int64
|
|
for _, v := range chopRewardList {
|
|
rewardIds = append(rewardIds, v.RewardID)
|
|
chopMap[v.ID] = v
|
|
}
|
|
|
|
var rewardTitleMap map[int64]string
|
|
rewardTitleMap, err = s._getRewardTitle(rewardIds)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
for _, v := range chopRewardList {
|
|
chopRewardMap[v.ID] = rewardTitleMap[v.RewardID]
|
|
}
|
|
}
|
|
|
|
s.chopMap = make(map[int64]*pb.ListRes_Chop, len(list))
|
|
for _, v := range list {
|
|
if chop, ok := chopMap[v.ChopRewardID]; ok {
|
|
s.chopMap[v.UserID] = &pb.ListRes_Chop{
|
|
ChopRewardId: v.ChopRewardID,
|
|
RewardTitle: chopRewardMap[chop.ID],
|
|
Percent: utils.PercentCutZero(chop.Percent),
|
|
}
|
|
} else {
|
|
s.chopMap[v.UserID] = &pb.ListRes_Chop{}
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *List) _channelMap(ids []int64, channelMap map[int64]string) (err error) {
|
|
if len(ids) == 0 {
|
|
return
|
|
}
|
|
|
|
m := s.GetDao().FissionCampaignChannel
|
|
list, err := m.WithContext(s.Ctx).Where(m.ID.In(ids...)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
for _, v := range list {
|
|
channelMap[v.ID] = v.Title
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *List) _platformMap(cpn *model.FissionCampaign, ids []int64, platformMap map[int64]string) (err error) {
|
|
if len(ids) == 0 {
|
|
return
|
|
}
|
|
|
|
m := s.GetDao().FissionUserAttr
|
|
list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.UserID.In(ids...), m.Attr.Eq(mtype.FissionUserAttrMarkPlatform)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
for _, v := range list {
|
|
platformMap[v.UserID] = v.Value
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *List) _lvTitleMap(ids []int64, lvTitleMap map[int64]string) (err error) {
|
|
if len(ids) == 0 {
|
|
return
|
|
}
|
|
m := s.GetDao().FissionUserLevel
|
|
list, err := m.WithContext(s.Ctx).Where(m.ID.In(ids...)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
for _, v := range list {
|
|
lvTitleMap[v.ID] = v.Title
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *List) _conds(cpnId int64, ids []int64, data map[int64][]*pb.ListRes_Cond) (err error) {
|
|
condM := s.GetDao().FissionCampaignCond
|
|
conds, err := condM.WithContext(s.Ctx).Where(condM.CampaignID.Eq(cpnId)).
|
|
Where(
|
|
condM.WithContext(s.Ctx).
|
|
Or(condM.IsDel.Eq(mtype.No)).
|
|
Or(condM.IsDel.Eq(mtype.Yes), condM.DelUse.Eq(mtype.Yes)),
|
|
).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
if len(conds) == 0 {
|
|
return
|
|
}
|
|
|
|
m := s.GetDao().FissionUserCond
|
|
list, err := m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var userCondMap = make(map[int64]map[int64]int64)
|
|
for _, v := range list {
|
|
|
|
if _, ok := userCondMap[v.UserID]; !ok {
|
|
userCondMap[v.UserID] = map[int64]int64{
|
|
v.CondID: v.Num,
|
|
}
|
|
} else {
|
|
userCondMap[v.UserID][v.CondID] = v.Num
|
|
}
|
|
}
|
|
|
|
for _, userId := range ids {
|
|
|
|
for _, cond := range conds {
|
|
one := &pb.ListRes_Cond{
|
|
Desc: cond.Desc,
|
|
Num: 0,
|
|
}
|
|
|
|
if uc, ok := userCondMap[userId]; ok {
|
|
one.Num = uc[cond.ID]
|
|
}
|
|
|
|
data[userId] = append(data[userId], one)
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *List) _helpMap(cpn *model.FissionCampaign, users []*model.FissionUser) (err error) {
|
|
s.helpFailMark = make(map[int64]string, len(users))
|
|
|
|
if len(users) == 0 {
|
|
return
|
|
}
|
|
|
|
key := ckey.FissionUserHelpFailMark(cpn.ID)
|
|
var ids []int64
|
|
for _, user := range users {
|
|
|
|
s.helpFailMark[user.ID] = ""
|
|
if user.ParentID == 0 || user.IsHelp == mtype.Yes {
|
|
continue
|
|
}
|
|
|
|
failMark := app.Redis.Cache.HGet(s.Ctx, key, fmt.Sprint(user.ID)).Val()
|
|
if failMark == "" {
|
|
ids = append(ids, user.ID)
|
|
continue
|
|
}
|
|
|
|
s.helpFailMark[user.ID] = failMark
|
|
}
|
|
|
|
if len(ids) == 0 {
|
|
return
|
|
}
|
|
|
|
m := s.GetDao().FissionCampaignTicket
|
|
tickets, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.Open.Eq(mtype.Yes)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
for _, ticket := range tickets {
|
|
|
|
if ticket.Mark == mtype.FissionCampaignTicketFixed {
|
|
var vals []string
|
|
for _, id := range ids {
|
|
failMark := utils.Ternary[string](ticket.AppEvent == mtype.FissionCampaignTicketAppEventInstall, consts.HelpStatusNotInstall, consts.HelpStatusNotRegister)
|
|
s.helpFailMark[id] = failMark
|
|
vals = append(vals, fmt.Sprint(id), failMark)
|
|
}
|
|
|
|
app.Redis.Cache.HSet(s.Ctx, key, vals)
|
|
|
|
return
|
|
}
|
|
|
|
if ticket.Mark == mtype.FissionCampaignTicketCustom && verify.InArray(cpn.FissionID, consts.IdReferral, consts.IdWinTogether) {
|
|
|
|
if ticket.PreEvent == mtype.FissionCampaignTicketPreEventNone {
|
|
var vals []string
|
|
for _, id := range ids {
|
|
failMark := consts.HelpStatusNotTask
|
|
s.helpFailMark[id] = failMark
|
|
vals = append(vals, fmt.Sprint(id), failMark)
|
|
}
|
|
|
|
app.Redis.Cache.HSet(s.Ctx, key, vals)
|
|
|
|
return
|
|
}
|
|
|
|
switch cpn.FissionID {
|
|
case consts.IdReferral:
|
|
playerM := s.GetDao().FissionReferral
|
|
var list []*model.FissionReferral
|
|
list, err = playerM.WithContext(s.Ctx).Where(playerM.UserID.In(ids...)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
var vals []string
|
|
switch ticket.PreEvent {
|
|
case mtype.FissionCampaignTicketPreEventInstall:
|
|
|
|
for _, v := range list {
|
|
failMark := utils.Ternary[string](v.BindInstall == mtype.Yes, consts.HelpStatusNotTask, consts.HelpStatusNotInstall)
|
|
s.helpFailMark[v.UserID] = failMark
|
|
vals = append(vals, fmt.Sprint(v.UserID), failMark)
|
|
}
|
|
|
|
case mtype.FissionCampaignTicketAppEventRegister:
|
|
for _, v := range list {
|
|
failMark := utils.Ternary[string](v.BindInstall == mtype.Yes, consts.HelpStatusNotTask, consts.HelpStatusNotRegister)
|
|
s.helpFailMark[v.UserID] = failMark
|
|
vals = append(vals, fmt.Sprint(v.UserID), failMark)
|
|
}
|
|
}
|
|
|
|
app.Redis.Cache.HSet(s.Ctx, key, vals)
|
|
|
|
case consts.IdWinTogether:
|
|
playerM := s.GetDao().FissionWin
|
|
var list []*model.FissionWin
|
|
list, err = playerM.WithContext(s.Ctx).Where(playerM.UserID.In(ids...)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
var vals []string
|
|
switch ticket.PreEvent {
|
|
case mtype.FissionCampaignTicketPreEventInstall:
|
|
|
|
for _, v := range list {
|
|
failMark := utils.Ternary[string](v.BindInstall == mtype.Yes, consts.HelpStatusNotTask, consts.HelpStatusNotInstall)
|
|
s.helpFailMark[v.UserID] = failMark
|
|
vals = append(vals, fmt.Sprint(v.UserID), failMark)
|
|
}
|
|
|
|
case mtype.FissionCampaignTicketAppEventRegister:
|
|
for _, v := range list {
|
|
failMark := utils.Ternary[string](v.BindInstall == mtype.Yes, consts.HelpStatusNotTask, consts.HelpStatusNotRegister)
|
|
s.helpFailMark[v.UserID] = failMark
|
|
vals = append(vals, fmt.Sprint(v.UserID), failMark)
|
|
}
|
|
}
|
|
|
|
app.Redis.Cache.HSet(s.Ctx, key, vals)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *List) _getRewardTitle(rewardIds []int64) (data map[int64]string, err error) {
|
|
m := s.GetDao().FissionCampaignReward
|
|
rewards, err := m.WithContext(s.Ctx).Where(m.ID.In(rewardIds...)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var bMap = make(map[int64]string)
|
|
var bIds []int64
|
|
for _, v := range rewards {
|
|
if _, ok := bMap[v.RewardID]; !ok {
|
|
bIds = append(bIds, v.RewardID)
|
|
}
|
|
}
|
|
|
|
rewardM := s.GetDao().Reward
|
|
|
|
list, err := rewardM.WithContext(s.Ctx).Where(rewardM.ID.In(bIds...)).Find()
|
|
for _, v := range list {
|
|
bMap[v.ID] = v.RewardTitle
|
|
}
|
|
|
|
data = make(map[int64]string, len(rewards))
|
|
for _, v := range rewards {
|
|
data[v.ID] = bMap[v.RewardID]
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *List) _cash(ids []int64) (err error) {
|
|
if s.cashMap != nil || len(ids) == 0 {
|
|
return
|
|
}
|
|
|
|
m := s.GetDao().FissionCash
|
|
list, err := m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
s.cashMap = make(map[int64]map[string]*pb.ListRes_Cash, len(list))
|
|
|
|
for _, v := range list {
|
|
if _, ok := s.cashMap[v.ID]; !ok {
|
|
s.cashMap[v.UserID] = map[string]*pb.ListRes_Cash{
|
|
v.Lang: {ExpiredAt: v.ExpiredIn},
|
|
}
|
|
} else {
|
|
s.cashMap[v.UserID][v.Lang] = &pb.ListRes_Cash{ExpiredAt: v.ExpiredIn}
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *List) _gold(ids []int64) (err error) {
|
|
if s.goldMap != nil || len(ids) == 0 {
|
|
return
|
|
}
|
|
|
|
m := s.GetDao().FissionGold
|
|
list, err := m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
s.goldMap = make(map[int64]map[string]*pb.ListRes_Gold, len(list))
|
|
|
|
for _, v := range list {
|
|
if _, ok := s.goldMap[v.ID]; !ok {
|
|
s.goldMap[v.UserID] = map[string]*pb.ListRes_Gold{
|
|
v.Lang: {
|
|
GoldNum: v.GoldNum,
|
|
ExpiredAt: v.ExpiredIn,
|
|
},
|
|
}
|
|
} else {
|
|
s.goldMap[v.UserID][v.Lang] = &pb.ListRes_Gold{
|
|
GoldNum: v.GoldNum,
|
|
ExpiredAt: v.ExpiredIn,
|
|
}
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *List) _vs(ids []int64) (err error) {
|
|
if s.vsMap != nil || len(ids) == 0 {
|
|
return
|
|
}
|
|
|
|
m := s.GetDao().FissionV
|
|
list, err := m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
s.vsMap = make(map[int64]*pb.ListRes_Vs, len(list))
|
|
|
|
for _, v := range list {
|
|
s.vsMap[v.UserID] = &pb.ListRes_Vs{
|
|
Chance: v.Chance,
|
|
VoteNum: v.VoteNum,
|
|
CoinGet: v.CoinGet,
|
|
CoinUse: v.CoinUse,
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *List) _uno(ids []int64) (err error) {
|
|
if s.unoMap != nil || len(ids) == 0 {
|
|
return
|
|
}
|
|
|
|
m := s.GetDao().FissionUno
|
|
list, err := m.WithContext(s.Ctx).Where(m.UserID.In(ids...)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
s.unoMap = make(map[int64]*pb.ListRes_Uno, len(list))
|
|
|
|
for _, v := range list {
|
|
s.unoMap[v.UserID] = &pb.ListRes_Uno{
|
|
Chance: v.Chance,
|
|
ThreeNum: v.ThreeNum,
|
|
FiveNum: v.FiveNum,
|
|
FixNum: v.FixNum,
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|