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.
1156 lines
29 KiB
Go
1156 lines
29 KiB
Go
package campaign
|
|
|
|
import (
|
|
"joybuywork/internal/app"
|
|
"joybuywork/internal/consts"
|
|
"joybuywork/internal/consts/ckey"
|
|
"joybuywork/internal/repository/cache"
|
|
"joybuywork/internal/repository/finder"
|
|
"joybuywork/internal/repository/model"
|
|
"joybuywork/internal/repository/mtype"
|
|
"joybuywork/internal/service/provider/cachecurd"
|
|
"joybuywork/internal/service/provider/stocks"
|
|
"joybuywork/internal/utils"
|
|
"joybuywork/internal/utils/logic"
|
|
"joybuywork/internal/utils/timez"
|
|
"joybuywork/internal/utils/verify"
|
|
pb "joybuywork/proto/go_proto/w_campaign"
|
|
"joybuywork/proto/go_proto/workerr"
|
|
"fmt"
|
|
"time"
|
|
|
|
"gorm.io/gen/field"
|
|
)
|
|
|
|
type RewardDetail struct {
|
|
logic.Logic
|
|
Req *pb.RewardDetailReq
|
|
Res *pb.RewardDetailRes
|
|
|
|
rewardLangList []*model.RewardLang
|
|
|
|
levelMap map[int64]string
|
|
|
|
helpMap map[int64][]*model.FissionCampaignRewardHelp
|
|
|
|
ruleMap map[int64]*model.FissionCampaignRewardRule
|
|
}
|
|
|
|
func (s *RewardDetail) Run() error {
|
|
return logic.Run(s)
|
|
}
|
|
|
|
func (s *RewardDetail) Exec() (err error) {
|
|
cpn, conf, err := s.campaign()
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.reward(cpn, conf)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.fission(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.task(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *RewardDetail) campaign() (cpn *model.FissionCampaign, conf *model.FissionCampaignConfig, err error) {
|
|
cpn, err = finder.Campaign(s.Ctx, s.Req.GetHashId())
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
if cpn == nil {
|
|
err = workerr.NotFound("not found cpn")
|
|
return
|
|
}
|
|
|
|
conf, err = cache.NewCampaignConfig(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
s.Res.RewardGroup = int32(conf.RewardGroup)
|
|
|
|
return
|
|
}
|
|
|
|
func (s *RewardDetail) task(cpn *model.FissionCampaign) (err error) {
|
|
m := s.GetDao().FissionCampaignReward
|
|
list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.RewardType.Eq(mtype.FissionCampaignRewardTypeTask), m.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
if len(list) == 0 {
|
|
return
|
|
}
|
|
|
|
s._hasTask()
|
|
|
|
titleMap, stockMap, selectMap, err := s._mapData(list, false)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
var rewardIds []int64
|
|
for _, reward := range list {
|
|
rewardIds = append(rewardIds, reward.ID)
|
|
}
|
|
|
|
taskM := s.GetDao().FissionCampaignTask
|
|
tasks, err := taskM.WithContext(s.Ctx).Where(taskM.CampaignID.Eq(cpn.ID), taskM.RewardID.In(rewardIds...)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var condIds []int64
|
|
var condRewardMap = make(map[int64]int64)
|
|
for _, task := range tasks {
|
|
condId := utils.FissionCampaignTaskMarkCondOneCondId(task.TaskMark)
|
|
condIds = append(condIds, condId)
|
|
condRewardMap[condId] = task.RewardID
|
|
|
|
}
|
|
|
|
condM := s.GetDao().FissionCampaignCond
|
|
conds, err := condM.WithContext(s.Ctx).Where(condM.ID.In(condIds...)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var rewardTaskMap = make(map[int64]string, len(conds))
|
|
for _, cond := range conds {
|
|
rewardTaskMap[condRewardMap[cond.ID]] = cond.Desc
|
|
}
|
|
|
|
s.Res.TaskReward = make([]*pb.RewardDetailRes_Reward, 0, len(list))
|
|
for _, reward := range list {
|
|
one := s._one(reward, stockMap[reward.ID], selectMap[reward.ID], titleMap[reward.RewardID], false)
|
|
|
|
one.TaskTitle = rewardTaskMap[reward.ID]
|
|
|
|
s.Res.TaskReward = append(s.Res.TaskReward, one)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *RewardDetail) reward(cpn *model.FissionCampaign, conf *model.FissionCampaignConfig) (err error) {
|
|
if verify.InArray[int64](cpn.FissionID, consts.IdCoin, consts.IdVs, consts.IdUno) {
|
|
return
|
|
}
|
|
|
|
if cpn.FissionID == consts.IdSignIn {
|
|
s._hasAppSign()
|
|
} else {
|
|
s._hasApp()
|
|
}
|
|
|
|
m := s.GetDao().FissionCampaignReward
|
|
list, err := m.WithContext(s.Ctx).Where(
|
|
m.CampaignID.Eq(conf.CampaignID),
|
|
m.RewardType.Eq(mtype.FissionCampaignRewardTypeApp),
|
|
m.IsDel.Eq(mtype.No),
|
|
).Order(m.Step, m.Sort, m.ID).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
if len(list) == 0 {
|
|
return
|
|
}
|
|
|
|
showSelect := verify.InArray[int64](cpn.FissionID, consts.IdKeep)
|
|
|
|
titleMap, stockMap, selectMap, err := s._mapData(list, showSelect)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
switch conf.RewardGroup {
|
|
case mtype.FissionRewardGroupNormal:
|
|
return s._normal(list, stockMap, selectMap, titleMap, showSelect)
|
|
case mtype.FissionRewardGroupUserLevel:
|
|
return s._userLv(cpn, list, stockMap, selectMap, titleMap, showSelect)
|
|
case mtype.FissionRewardGroupLang:
|
|
return s._lang(list, stockMap, selectMap, titleMap, showSelect)
|
|
case mtype.FissionRewardGroupLangAndUserLevel:
|
|
return s._langUserLv(cpn, list, stockMap, selectMap, titleMap, showSelect)
|
|
case mtype.FissionRewardGroupCountry:
|
|
return s._country(list, stockMap, selectMap, titleMap, showSelect)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *RewardDetail) _normal(list []*model.FissionCampaignReward, stockMap, selectMap map[int64]int64, titleMap map[int64]string, showSelect bool) (err error) {
|
|
s.Res.Normal = make([]*pb.RewardDetailRes_Reward, 0, len(list))
|
|
for _, reward := range list {
|
|
s.Res.Normal = append(s.Res.Normal, s._one(reward, stockMap[reward.ID], selectMap[reward.ID], titleMap[reward.RewardID], showSelect))
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *RewardDetail) _userLv(cpn *model.FissionCampaign, list []*model.FissionCampaignReward, stockMap, selectMap map[int64]int64, titleMap map[int64]string, showSelect bool) (err error) {
|
|
m := s.GetDao().FissionUserLevel
|
|
lvList, err := m.WithContext(s.Ctx).Where(m.ProjectID.Eq(cpn.ProjectID), m.DeletedAt.Eq(0)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
lvMap := make(map[int64]string, len(lvList))
|
|
for _, v := range lvList {
|
|
lvMap[v.ID] = v.Title
|
|
}
|
|
|
|
var levelIds []int64
|
|
var levelRewardMap = make(map[int64][]*model.FissionCampaignReward)
|
|
for _, v := range list {
|
|
if _, ok := levelRewardMap[v.LevelID]; !ok {
|
|
levelIds = append(levelIds, v.LevelID)
|
|
}
|
|
|
|
levelRewardMap[v.LevelID] = append(levelRewardMap[v.LevelID], v)
|
|
}
|
|
|
|
s.Res.UserLevel = make([]*pb.RewardDetailRes_UserLevelOne, 0, len(levelIds))
|
|
for _, v := range levelIds {
|
|
one := &pb.RewardDetailRes_UserLevelOne{
|
|
LevelId: v,
|
|
LevelTitle: lvMap[v],
|
|
Rewards: make([]*pb.RewardDetailRes_Reward, 0, len(levelRewardMap[v])),
|
|
}
|
|
for _, reward := range levelRewardMap[v] {
|
|
one.Rewards = append(one.Rewards, s._one(reward, stockMap[reward.ID], selectMap[reward.ID], titleMap[reward.RewardID], showSelect))
|
|
}
|
|
s.Res.UserLevel = append(s.Res.UserLevel, one)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *RewardDetail) _lang(list []*model.FissionCampaignReward, stockMap, selectMap map[int64]int64, titleMap map[int64]string, showSelect bool) (err error) {
|
|
var langMarks []string
|
|
var langRewardMap = make(map[string][]*model.FissionCampaignReward)
|
|
for _, v := range list {
|
|
if _, ok := langRewardMap[v.LangMark]; !ok {
|
|
langMarks = append(langMarks, v.LangMark)
|
|
}
|
|
|
|
langRewardMap[v.LangMark] = append(langRewardMap[v.LangMark], v)
|
|
}
|
|
|
|
s.Res.Langs = make([]*pb.RewardDetailRes_LangOne, 0, len(langMarks))
|
|
for _, v := range langMarks {
|
|
one := &pb.RewardDetailRes_LangOne{
|
|
LangMark: v,
|
|
Rewards: make([]*pb.RewardDetailRes_Reward, 0, len(langRewardMap[v])),
|
|
}
|
|
for _, reward := range langRewardMap[v] {
|
|
one.Rewards = append(one.Rewards, s._one(reward, stockMap[reward.ID], selectMap[reward.ID], titleMap[reward.RewardID], showSelect))
|
|
}
|
|
s.Res.Langs = append(s.Res.Langs, one)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *RewardDetail) _langUserLv(cpn *model.FissionCampaign, list []*model.FissionCampaignReward, stockMap, selectMap map[int64]int64, titleMap map[int64]string, showSelect bool) (err error) {
|
|
m := s.GetDao().FissionUserLevel
|
|
lvList, err := m.WithContext(s.Ctx).Where(m.ProjectID.Eq(cpn.ProjectID), m.DeletedAt.Eq(0)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
lvMap := make(map[int64]string, len(lvList))
|
|
for _, v := range lvList {
|
|
lvMap[v.ID] = v.Title
|
|
}
|
|
|
|
var langMarks []string
|
|
var langUserLv = make(map[string][]int64)
|
|
var langUserLvRewardMap = make(map[string]map[int64][]*model.FissionCampaignReward)
|
|
|
|
for _, v := range list {
|
|
|
|
if _, ok := langUserLv[v.LangMark]; !ok {
|
|
langMarks = append(langMarks, v.LangMark)
|
|
langUserLv[v.LangMark] = nil
|
|
langUserLvRewardMap[v.LangMark] = make(map[int64][]*model.FissionCampaignReward)
|
|
}
|
|
|
|
if _, ok := langUserLvRewardMap[v.LangMark][v.LevelID]; !ok {
|
|
langUserLv[v.LangMark] = append(langUserLv[v.LangMark], v.LevelID)
|
|
}
|
|
|
|
langUserLvRewardMap[v.LangMark][v.LevelID] = append(langUserLvRewardMap[v.LangMark][v.LevelID], v)
|
|
}
|
|
|
|
s.Res.LangUserLevel = make([]*pb.RewardDetailRes_LangUserLevelOne, 0, len(langMarks))
|
|
for _, v := range langMarks {
|
|
one := &pb.RewardDetailRes_LangUserLevelOne{
|
|
LangMark: v,
|
|
LevelList: make([]*pb.RewardDetailRes_UserLevelOne, 0, len(langUserLv[v])),
|
|
}
|
|
|
|
for _, lvId := range langUserLv[v] {
|
|
two := &pb.RewardDetailRes_UserLevelOne{
|
|
LevelId: lvId,
|
|
LevelTitle: lvMap[lvId],
|
|
Rewards: make([]*pb.RewardDetailRes_Reward, 0, len(langUserLvRewardMap[v][lvId])),
|
|
}
|
|
|
|
for _, reward := range langUserLvRewardMap[v][lvId] {
|
|
two.Rewards = append(two.Rewards, s._one(reward, stockMap[reward.ID], selectMap[reward.ID], titleMap[reward.RewardID], showSelect))
|
|
}
|
|
|
|
one.LevelList = append(one.LevelList, two)
|
|
}
|
|
|
|
s.Res.LangUserLevel = append(s.Res.LangUserLevel, one)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *RewardDetail) _country(list []*model.FissionCampaignReward, stockMap, selectMap map[int64]int64, titleMap map[int64]string, showSelect bool) (err error) {
|
|
var countryMarks []string
|
|
var countryRewardMap = make(map[string][]*model.FissionCampaignReward)
|
|
for _, v := range list {
|
|
if _, ok := countryRewardMap[v.CountryMark]; !ok {
|
|
countryMarks = append(countryMarks, v.CountryMark)
|
|
}
|
|
|
|
countryRewardMap[v.CountryMark] = append(countryRewardMap[v.CountryMark], v)
|
|
}
|
|
|
|
s.Res.Country = make([]*pb.RewardDetailRes_CountryOne, 0, len(countryMarks))
|
|
for _, v := range countryMarks {
|
|
one := &pb.RewardDetailRes_CountryOne{
|
|
CountryMark: v,
|
|
Rewards: make([]*pb.RewardDetailRes_Reward, 0, len(countryRewardMap[v])),
|
|
}
|
|
for _, reward := range countryRewardMap[v] {
|
|
one.Rewards = append(one.Rewards, s._one(reward, stockMap[reward.ID], selectMap[reward.ID], titleMap[reward.RewardID], showSelect))
|
|
}
|
|
s.Res.Country = append(s.Res.Country, one)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *RewardDetail) fission(cpn *model.FissionCampaign) (err error) {
|
|
switch cpn.FissionID {
|
|
case consts.IdKeep:
|
|
return s._keep(cpn)
|
|
case consts.IdWinTogether:
|
|
return s._win(cpn)
|
|
case consts.IdReferral:
|
|
return s._referral(cpn)
|
|
case consts.IdCoin:
|
|
return s._coin(cpn)
|
|
case consts.IdCash:
|
|
return s._cash(cpn)
|
|
case consts.IdGold:
|
|
return s._gold(cpn)
|
|
case consts.IdVs:
|
|
return s._vs(cpn)
|
|
case consts.IdUno:
|
|
return s._uno(cpn)
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *RewardDetail) _uno(cpn *model.FissionCampaign) (err error) {
|
|
s._hasUno()
|
|
|
|
m := s.GetDao().FissionCampaignUnoGroup
|
|
list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var rewardIds []int64
|
|
for _, v := range list {
|
|
rewardIds = append(rewardIds, v.RewardID)
|
|
}
|
|
|
|
// 奖品
|
|
rewardM := s.GetDao().FissionCampaignReward
|
|
rewardList, err := rewardM.WithContext(s.Ctx).Where(rewardM.ID.In(rewardIds...)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var rewardMap = make(map[int64]*model.FissionCampaignReward, len(rewardList))
|
|
for _, v := range rewardList {
|
|
rewardMap[v.ID] = v
|
|
}
|
|
|
|
titleMap, stockMap, _, err := s._mapData(rewardList, false)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
s.Res.UnoCards = make([]*pb.RewardDetailRes_UnoCard, 0, len(list))
|
|
|
|
type num struct {
|
|
Mark string `json:"mark"`
|
|
PreIntactNum int64 `json:"pre_intact_num"`
|
|
IntactNum int64 `json:"intact_num"`
|
|
}
|
|
|
|
collectM := s.GetDao().FissionUnoCollect
|
|
var nums []*num
|
|
err = collectM.WithContext(s.Ctx).
|
|
Select(
|
|
collectM.Mark,
|
|
collectM.PreIntactNum.Sum().As("pre_intact_num"),
|
|
collectM.IntactNum.Sum().As("intact_num"),
|
|
).
|
|
Where(collectM.CampaignID.Eq(cpn.ID)).
|
|
Group(collectM.Mark).
|
|
Scan(&nums)
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
// 合并
|
|
var numMap = make(map[string]*num)
|
|
for _, v := range nums {
|
|
numMap[v.Mark] = v
|
|
}
|
|
|
|
for _, v := range list {
|
|
var stock, useStock int64
|
|
var title string
|
|
if reward, ok := rewardMap[v.RewardID]; ok {
|
|
stock, useStock = int64(reward.Stock), stockMap[reward.ID]
|
|
title = titleMap[reward.RewardID]
|
|
}
|
|
|
|
var piNum, iNum int64
|
|
if n, ok := numMap[v.Mark]; ok {
|
|
piNum = n.PreIntactNum
|
|
iNum = n.IntactNum
|
|
}
|
|
|
|
s.Res.UnoCards = append(s.Res.UnoCards, &pb.RewardDetailRes_UnoCard{
|
|
Id: v.ID,
|
|
Mark: v.Mark,
|
|
Title: title,
|
|
Stock: stock,
|
|
Remain: utils.Ternary[int64](stock < useStock, 0, stock-useStock),
|
|
PreIntactNum: piNum,
|
|
IntactNum: iNum,
|
|
})
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *RewardDetail) _vs(cpn *model.FissionCampaign) (err error) {
|
|
s._hasSchedule()
|
|
|
|
conf, err := cache.NewCampaignVs(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
teamM := s.GetDao().FissionCampaignVsTeam
|
|
teamList, err := teamM.WithContext(s.Ctx).Where(teamM.CampaignID.Eq(cpn.ID)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var teamMap = make(map[int64]*model.FissionCampaignVsTeam, len(teamList))
|
|
for _, v := range teamList {
|
|
teamMap[v.ID] = v
|
|
}
|
|
|
|
m := s.GetDao().FissionCampaignVsSchedule
|
|
list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.VsAt.Gt(0)).Order(m.VsAt.Desc()).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var scheduleIds []int64
|
|
for _, v := range list {
|
|
scheduleIds = append(scheduleIds, v.ID)
|
|
}
|
|
|
|
type voteNum struct {
|
|
ScheduleId int64 `json:"schedule_id"`
|
|
WinType int32 `json:"win_type"`
|
|
WinTeamId int64 `json:"win_team_id"`
|
|
Num int64 `json:"num"`
|
|
UserNum int64 `json:"user_num"`
|
|
}
|
|
|
|
var votes []*voteNum
|
|
|
|
voteM := s.GetDao().FissionVsVote
|
|
voteNumField := field.NewUnsafeFieldRaw("free_vote + point_vote")
|
|
err = voteM.WithContext(s.Ctx).
|
|
Select(
|
|
voteM.ScheduleID,
|
|
voteM.WinType,
|
|
voteM.WinTeamID,
|
|
voteNumField.Sum().As("num"),
|
|
voteM.ID.Count().As("user_num"),
|
|
).
|
|
Where(voteM.CampaignID.Eq(cpn.ID), voteM.ScheduleID.In(scheduleIds...)).
|
|
Group(voteM.ScheduleID, voteM.WinType, voteM.WinTeamID).
|
|
Scan(&votes)
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
type num struct {
|
|
ScheduleId int64 `json:"schedule_id"`
|
|
Num int64 `json:"num"`
|
|
}
|
|
|
|
var preRewardNum []*num
|
|
stlM := s.GetDao().FissionVsVoteSettlement
|
|
err = stlM.WithContext(s.Ctx).Select(
|
|
stlM.ScheduleID,
|
|
stlM.ID.Count().As("num"),
|
|
).Where(stlM.ScheduleID.In(scheduleIds...)).Group(stlM.ScheduleID).Scan(&preRewardNum)
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var preRewardNumMap = make(map[int64]int64, len(preRewardNum))
|
|
for _, v := range preRewardNum {
|
|
preRewardNumMap[v.ScheduleId] = v.Num
|
|
}
|
|
|
|
var rewardNum []*num
|
|
err = stlM.WithContext(s.Ctx).Select(
|
|
stlM.ScheduleID,
|
|
stlM.ID.Count().As("num"),
|
|
).Where(stlM.ScheduleID.In(scheduleIds...), stlM.AcceptAt.Gt(0)).Group(stlM.ScheduleID).Scan(&rewardNum)
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var rewardNumMap = make(map[int64]int64, len(rewardNum))
|
|
for _, v := range rewardNum {
|
|
rewardNumMap[v.ScheduleId] = v.Num
|
|
}
|
|
|
|
var voteNumMap = make(map[int64][]*voteNum, len(votes))
|
|
for _, v := range votes {
|
|
voteNumMap[v.ScheduleId] = append(voteNumMap[v.ScheduleId], v)
|
|
}
|
|
|
|
for _, v := range list {
|
|
|
|
stl := v.GetSettlement()
|
|
one := &pb.RewardDetailRes_Schedule{
|
|
Id: v.ID,
|
|
VsAt: v.VsAt,
|
|
VoteStart: v.VoteStart,
|
|
VoteEnd: v.VoteEnd,
|
|
Teams: nil,
|
|
WinType: stl.WinType,
|
|
WinTeamId: stl.WinTeamId,
|
|
PreRewardNum: preRewardNumMap[v.ID],
|
|
RewardNum: rewardNumMap[v.ID],
|
|
Tz: conf.VsTz,
|
|
Votes: nil,
|
|
}
|
|
|
|
var drawNum, drawUserNum int64
|
|
var teamNum = make(map[int64]int64)
|
|
var teamUserNumMap = make(map[int64]int64)
|
|
for _, vote := range voteNumMap[v.ID] {
|
|
switch vote.WinType {
|
|
case mtype.FissionCampaignVsScheduleWinTypeDraw:
|
|
drawNum = vote.Num
|
|
drawUserNum = vote.UserNum
|
|
default:
|
|
teamNum[vote.WinTeamId] = vote.Num
|
|
teamUserNumMap[vote.WinTeamId] = vote.UserNum
|
|
}
|
|
}
|
|
|
|
for _, id := range v.GetVsTeamIds() {
|
|
if team, ok := teamMap[id]; ok {
|
|
one.Teams = append(one.Teams, &pb.RewardDetailRes_Team{
|
|
Id: team.ID,
|
|
Name: team.Name,
|
|
LogoImg: team.LogoImg,
|
|
})
|
|
} else {
|
|
one.Teams = append(one.Teams, &pb.RewardDetailRes_Team{
|
|
Id: id,
|
|
})
|
|
}
|
|
|
|
one.Votes = append(one.Votes, &pb.RewardDetailRes_Vote{
|
|
WinType: mtype.FissionCampaignVsScheduleWinTypeWin,
|
|
WinTeamId: id,
|
|
VoteNum: teamNum[id],
|
|
VoteUserNum: teamUserNumMap[id],
|
|
})
|
|
}
|
|
|
|
if verify.InArray[string](mtype.FissionCampaignVsScheduleOtherVoteDraw, v.GetOtherVote()...) {
|
|
one.Votes = append(one.Votes, &pb.RewardDetailRes_Vote{
|
|
WinType: mtype.FissionCampaignVsScheduleWinTypeDraw,
|
|
VoteNum: drawNum,
|
|
VoteUserNum: drawUserNum,
|
|
})
|
|
}
|
|
|
|
s.Res.Schedules = append(s.Res.Schedules, one)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *RewardDetail) _mapData(list []*model.FissionCampaignReward, showSelect bool) (titleMap map[int64]string, stockMap, selectMap map[int64]int64, err error) {
|
|
var ids, rewardIds []int64
|
|
var existMap = make(map[int64]struct{})
|
|
for _, v := range list {
|
|
ids = append(ids, v.ID)
|
|
if _, ok := existMap[v.RewardID]; !ok {
|
|
rewardIds = append(rewardIds, v.RewardID)
|
|
existMap[v.RewardID] = struct{}{}
|
|
}
|
|
}
|
|
|
|
titleMap, err = s._titleMap(rewardIds)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
stockMap, selectMap = make(map[int64]int64, len(ids)), make(map[int64]int64, len(ids))
|
|
|
|
stock, err := stocks.NewCampaignReward(s.Ctx, ids...)
|
|
if err != nil {
|
|
return
|
|
}
|
|
stockMap, _ = stock.AllUseStock()
|
|
|
|
if !showSelect {
|
|
return
|
|
}
|
|
|
|
selectStock, err := stocks.NewCampaignRewardSelect(s.Ctx, ids...)
|
|
if err != nil {
|
|
return
|
|
}
|
|
selectMap, _ = selectStock.AllUseStock()
|
|
|
|
return
|
|
}
|
|
|
|
func (s *RewardDetail) _one(reward *model.FissionCampaignReward, useStock, selectNum int64, title string, showSelect bool) *pb.RewardDetailRes_Reward {
|
|
stock := int64(reward.Stock)
|
|
|
|
remain := utils.Ternary[int64](showSelect, stock-selectNum, stock-useStock)
|
|
if remain < 0 {
|
|
remain = 0
|
|
}
|
|
|
|
return &pb.RewardDetailRes_Reward{
|
|
Id: reward.ID,
|
|
Title: title,
|
|
Stock: stock,
|
|
Remain: remain,
|
|
Given: useStock,
|
|
CanUp: reward.IsThank == mtype.No,
|
|
IsThank: int32(reward.IsThank),
|
|
SelectNum: selectNum,
|
|
SignDay: reward.SignDay,
|
|
}
|
|
}
|
|
|
|
func (s *RewardDetail) _titleMap(rewardIds []int64) (titleMap map[int64]string, err error) {
|
|
titleMap = make(map[int64]string, len(rewardIds))
|
|
if len(rewardIds) == 0 {
|
|
return
|
|
}
|
|
|
|
rewardM := s.GetDao().Reward
|
|
rewards, err := rewardM.WithContext(s.Ctx).Where(rewardM.ID.In(rewardIds...)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
for _, reward := range rewards {
|
|
titleMap[reward.ID] = reward.RewardTitle
|
|
}
|
|
|
|
for _, reward := range app.FissionFixRewards {
|
|
titleMap[reward.Id] = reward.RewardTitle
|
|
}
|
|
return
|
|
}
|
|
|
|
type RewardDetailNum struct {
|
|
RewardId int64 `json:"reward_id"`
|
|
Num int64 `json:"num"`
|
|
}
|
|
|
|
func (s *RewardDetail) _dbNum(cpnId int64, ids []int64) (numMap map[int64]int64, err error) {
|
|
var nums []*RewardDetailNum
|
|
m := s.GetDao().FissionRewardRecord.SubTable(cpnId)
|
|
err = m.WithContext(s.Ctx).Select(m.RewardID, m.ID.Count().As("num")).Where(m.RewardID.In(ids...)).Group(m.RewardID).Scan(&nums)
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
numMap = make(map[int64]int64, len(ids))
|
|
|
|
for _, num := range nums {
|
|
numMap[num.RewardId] = num.Num
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *RewardDetail) _coin(cpn *model.FissionCampaign) (err error) {
|
|
s._hasPool()
|
|
|
|
m := s.GetDao().FissionCoinScene
|
|
list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID)).Order(m.ID.Desc()).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
s.Res.Pools = make([]*pb.RewardDetailRes_Pool, 0, len(list))
|
|
|
|
gmt := utils.Ternary[string](cpn.TOffset < 0, fmt.Sprint(cpn.TOffset), fmt.Sprintf("+%d", cpn.TOffset))
|
|
|
|
conf, err := cache.NewCampaignCoin(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
l := len(list)
|
|
var notRunId = make(map[int64]struct{})
|
|
for i, scene := range list {
|
|
if i+1 >= l {
|
|
break
|
|
}
|
|
|
|
if scene.OpenTime > time.Now().Unix() && list[i+1].OpenTime > time.Now().Unix() {
|
|
notRunId[scene.ID] = struct{}{}
|
|
}
|
|
|
|
}
|
|
|
|
for _, v := range list {
|
|
day, _, _ := timez.GMTStartAndEndTs(cpn.TOffset, v.OpenTime)
|
|
|
|
var status int32 = 3
|
|
initCoin := v.InitCoin
|
|
userCoin := v.UserCoin
|
|
initUse := v.InitUse
|
|
joinNum := v.JoinNum
|
|
joinUserNum := v.JoinUserNum
|
|
getNum := v.GetNum
|
|
getCoin := v.GetCoin
|
|
|
|
noOpen := v.OpenTime > time.Now().Unix() // 还没到开奖时间
|
|
gotReward := v.RewardTime < time.Now().Unix() // 已经领完奖了
|
|
if noOpen {
|
|
// 进行中
|
|
scene, _ := cachecurd.NewHMap(s.Ctx,
|
|
ckey.FissionCoinSceneData(v.ID),
|
|
cachecurd.SetCoinSceneBuild(cpn.ID, v.ID),
|
|
cachecurd.SetHMapExp(time.Duration(conf.OpenDays+1)*consts.TimeDay),
|
|
)
|
|
|
|
initCoin = conf.InitCoin
|
|
initUse = conf.InitUse
|
|
userCoin, _ = scene.GetInt64(cachecurd.CoinSceneUserCoin)
|
|
joinNum, _ = scene.GetInt64(cachecurd.CoinSceneJoinNum)
|
|
joinUserNum, _ = scene.GetInt64(cachecurd.CoinSceneJoinUserNum)
|
|
|
|
status = 1
|
|
if _, ok := notRunId[v.ID]; ok {
|
|
status = 4
|
|
}
|
|
} else if !gotReward { // 领奖中
|
|
scene, _ := cachecurd.NewHMap(s.Ctx,
|
|
ckey.FissionCoinSceneData(v.ID),
|
|
cachecurd.SetCoinSceneBuild(cpn.ID, v.ID),
|
|
cachecurd.SetHMapExp(time.Duration(conf.OpenDays+1)*consts.TimeDay),
|
|
)
|
|
|
|
userCoin, _ = scene.GetInt64(cachecurd.CoinSceneUserCoin)
|
|
joinNum, _ = scene.GetInt64(cachecurd.CoinSceneJoinNum)
|
|
joinUserNum, _ = scene.GetInt64(cachecurd.CoinSceneJoinUserNum)
|
|
getNum, _ = scene.GetInt64(cachecurd.CoinSceneGetNum)
|
|
getCoin, _ = scene.GetInt64(cachecurd.CoinSceneGetTotal)
|
|
|
|
status = 2
|
|
}
|
|
|
|
var oneUseCoin, joinAvg int64
|
|
if joinNum > 0 {
|
|
oneUseCoin = (userCoin + int64(initCoin)) / (joinNum + int64(initUse))
|
|
joinAvg = (joinNum + int64(initUse)) / joinUserNum
|
|
}
|
|
|
|
s.Res.Pools = append(s.Res.Pools, &pb.RewardDetailRes_Pool{
|
|
Id: v.ID,
|
|
Title: fmt.Sprintf("%s(GMT%s)", day, gmt),
|
|
Status: status,
|
|
InitCoin: initCoin,
|
|
UserCoin: userCoin,
|
|
InitUse: initUse,
|
|
JoinNum: joinNum,
|
|
OneUseCoin: oneUseCoin,
|
|
JoinUserNum: joinUserNum,
|
|
GetNum: getNum,
|
|
JoinAvg: joinAvg,
|
|
GetCoin: getCoin,
|
|
})
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *RewardDetail) _keep(cpn *model.FissionCampaign) (err error) {
|
|
s._hasStep()
|
|
s._showSelect()
|
|
|
|
m := s.GetDao().FissionCampaignReward
|
|
list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.RewardType.Eq(mtype.FissionCampaignRewardTypeGrowStep), m.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
if len(list) == 0 {
|
|
return
|
|
}
|
|
|
|
var ids, rewardIds []int64
|
|
var existMap = make(map[int64]struct{})
|
|
for _, v := range list {
|
|
ids = append(ids, v.ID)
|
|
if _, ok := existMap[v.RewardID]; !ok {
|
|
rewardIds = append(rewardIds, v.RewardID)
|
|
existMap[v.RewardID] = struct{}{}
|
|
}
|
|
}
|
|
|
|
titleMap, err := s._titleMap(rewardIds)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
stockMap, err := s._dbNum(cpn.ID, ids)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
s.Res.StepReward = make([]*pb.RewardDetailRes_Reward, 0, len(list))
|
|
|
|
for _, reward := range list {
|
|
stock, useStock := int64(reward.Stock), stockMap[reward.ID]
|
|
|
|
s.Res.StepReward = append(s.Res.StepReward, &pb.RewardDetailRes_Reward{
|
|
Id: reward.ID,
|
|
Title: titleMap[reward.RewardID],
|
|
Stock: stock,
|
|
Remain: utils.Ternary[int64](stock < stockMap[reward.ID], 0, stock-useStock),
|
|
Given: useStock,
|
|
CanUp: reward.IsThank == mtype.No,
|
|
IsThank: int32(reward.IsThank),
|
|
SelectNum: 0,
|
|
})
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *RewardDetail) _win(cpn *model.FissionCampaign) (err error) {
|
|
s._hasNewcomer()
|
|
s._showAll()
|
|
s._showSelect()
|
|
|
|
conf, err := cache.NewCampaignWin(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
stock, err := stocks.NewCampaign(s.Ctx, cpn.ID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
s.Res.All = int64(conf.RewardLimit)
|
|
s.Res.AllUse, _ = stock.GetUseStock(cpn.ID)
|
|
|
|
m := s.GetDao().FissionCampaignReward
|
|
list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.RewardType.In(mtype.FissionCampaignRewardTypeExtra, mtype.FissionCampaignRewardTypeNewcomer), m.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
if len(list) == 0 {
|
|
return
|
|
}
|
|
|
|
var ids, rewardIds []int64
|
|
var existMap = make(map[int64]struct{})
|
|
var hasExtra bool
|
|
for _, v := range list {
|
|
ids = append(ids, v.ID)
|
|
if _, ok := existMap[v.RewardID]; !ok {
|
|
rewardIds = append(rewardIds, v.RewardID)
|
|
existMap[v.RewardID] = struct{}{}
|
|
}
|
|
|
|
if !hasExtra && v.RewardType == mtype.FissionCampaignRewardTypeExtra {
|
|
hasExtra = true
|
|
}
|
|
}
|
|
|
|
if hasExtra {
|
|
s._hasStep()
|
|
}
|
|
|
|
titleMap, err := s._titleMap(rewardIds)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
stockMap, err := s._dbNum(cpn.ID, ids)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
for _, reward := range list {
|
|
useStock := stockMap[reward.ID]
|
|
|
|
switch reward.RewardType {
|
|
case mtype.FissionCampaignRewardTypeExtra:
|
|
s.Res.ExtraReward = append(s.Res.ExtraReward, &pb.RewardDetailRes_Reward{
|
|
Id: reward.ID,
|
|
Title: titleMap[reward.RewardID],
|
|
Given: useStock,
|
|
CanUp: reward.IsThank == mtype.No,
|
|
IsThank: int32(reward.IsThank),
|
|
SelectNum: 0,
|
|
})
|
|
case mtype.FissionCampaignRewardTypeNewcomer:
|
|
s.Res.NewcomerReward = append(s.Res.NewcomerReward, &pb.RewardDetailRes_Reward{
|
|
Id: reward.ID,
|
|
Title: titleMap[reward.RewardID],
|
|
Given: useStock,
|
|
CanUp: reward.IsThank == mtype.No,
|
|
IsThank: int32(reward.IsThank),
|
|
SelectNum: 0,
|
|
})
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *RewardDetail) _referral(cpn *model.FissionCampaign) (err error) {
|
|
s._showAll()
|
|
s._showSelect()
|
|
|
|
conf, err := cache.NewCampaignReferral(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
stock, err := stocks.NewCampaign(s.Ctx, cpn.ID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
s.Res.All = int64(conf.RewardLimit)
|
|
s.Res.AllUse, _ = stock.GetUseStock(cpn.ID)
|
|
|
|
m := s.GetDao().FissionCampaignReward
|
|
list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.RewardType.In(mtype.FissionCampaignRewardTypeExtra), m.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
if len(list) == 0 {
|
|
return
|
|
}
|
|
|
|
s._hasExtra()
|
|
|
|
var ids, rewardIds []int64
|
|
var existMap = make(map[int64]struct{})
|
|
for _, v := range list {
|
|
ids = append(ids, v.ID)
|
|
if _, ok := existMap[v.RewardID]; !ok {
|
|
rewardIds = append(rewardIds, v.RewardID)
|
|
existMap[v.RewardID] = struct{}{}
|
|
}
|
|
}
|
|
|
|
titleMap, err := s._titleMap(rewardIds)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
stockMap, err := s._dbNum(cpn.ID, ids)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
for _, reward := range list {
|
|
useStock := stockMap[reward.ID]
|
|
|
|
s.Res.ExtraReward = append(s.Res.ExtraReward, &pb.RewardDetailRes_Reward{
|
|
Id: reward.ID,
|
|
Title: titleMap[reward.RewardID],
|
|
Given: useStock,
|
|
CanUp: reward.IsThank == mtype.No,
|
|
IsThank: int32(reward.IsThank),
|
|
SelectNum: 0,
|
|
})
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *RewardDetail) _cash(cpn *model.FissionCampaign) (err error) {
|
|
s._showAll()
|
|
s._showSelect()
|
|
|
|
conf, err := cache.NewCampaignCash(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
stock, err := stocks.NewCampaign(s.Ctx, cpn.ID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
s.Res.All = int64(conf.PriceNum)
|
|
s.Res.AllUse, _ = stock.GetUseStock(cpn.ID)
|
|
|
|
return
|
|
}
|
|
|
|
func (s *RewardDetail) _gold(cpn *model.FissionCampaign) (err error) {
|
|
s._showAll()
|
|
s._showSelect()
|
|
|
|
conf, err := cache.NewCampaignGold(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
stock, err := stocks.NewCampaign(s.Ctx, cpn.ID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
s.Res.All = int64(conf.PriceNum)
|
|
s.Res.AllUse, _ = stock.GetUseStock(cpn.ID)
|
|
|
|
return
|
|
}
|
|
|
|
// 显示额外奖品模块
|
|
func (s *RewardDetail) _hasExtra() {
|
|
s.Res.RewardType = append(s.Res.RewardType, "extra")
|
|
}
|
|
|
|
// 显示活动主奖励模块
|
|
func (s *RewardDetail) _hasApp() {
|
|
s.Res.RewardType = append(s.Res.RewardType, "app")
|
|
}
|
|
|
|
// 显示活动主奖励模块
|
|
func (s *RewardDetail) _hasAppSign() {
|
|
s.Res.RewardType = append(s.Res.RewardType, "app_sign")
|
|
}
|
|
|
|
// 显示任务奖品模块
|
|
func (s *RewardDetail) _hasTask() {
|
|
s.Res.RewardType = append(s.Res.RewardType, "task")
|
|
}
|
|
|
|
// 显示奖池记录模块
|
|
func (s *RewardDetail) _hasPool() {
|
|
s.Res.RewardType = append(s.Res.RewardType, "pool")
|
|
}
|
|
|
|
// 显示阶梯奖品模块
|
|
func (s *RewardDetail) _hasStep() {
|
|
s.Res.RewardType = append(s.Res.RewardType, "step")
|
|
}
|
|
|
|
// 显示新人奖品模块
|
|
func (s *RewardDetail) _hasNewcomer() {
|
|
s.Res.RewardType = append(s.Res.RewardType, "newcomer")
|
|
}
|
|
|
|
// 显示赛程模块
|
|
func (s *RewardDetail) _hasSchedule() {
|
|
s.Res.RewardType = append(s.Res.RewardType, "schedule")
|
|
}
|
|
|
|
// 显示Uno模块
|
|
func (s *RewardDetail) _hasUno() {
|
|
s.Res.RewardType = append(s.Res.RewardType, "uno")
|
|
}
|
|
|
|
// 显示总预算模块
|
|
func (s *RewardDetail) _showAll() {
|
|
s.Res.ShowAll = 1
|
|
}
|
|
|
|
// 显示活动主奖励模块要展示“选择数”的列
|
|
func (s *RewardDetail) _showSelect() {
|
|
s.Res.ShowSelect = 1
|
|
}
|