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.
1518 lines
39 KiB
Go
1518 lines
39 KiB
Go
package campaign
|
|
|
|
import (
|
|
"joybuywork/internal/consts"
|
|
"joybuywork/internal/plugins/jsonm"
|
|
"joybuywork/internal/repository/cache"
|
|
"joybuywork/internal/repository/dbcheck"
|
|
"joybuywork/internal/repository/finder"
|
|
"joybuywork/internal/repository/model"
|
|
"joybuywork/internal/repository/mtype"
|
|
"joybuywork/internal/service/provider"
|
|
"joybuywork/internal/utils"
|
|
"joybuywork/internal/utils/logic"
|
|
"joybuywork/internal/utils/verify"
|
|
pb "joybuywork/proto/go_proto/w_campaign"
|
|
"joybuywork/proto/go_proto/workerr"
|
|
)
|
|
|
|
type campaignLangsPrizeQuiz struct {
|
|
quit *model.FissionCampaignQuiz
|
|
options []*model.FissionCampaignQuizOption
|
|
}
|
|
|
|
type campaignLangsPrizeAnswer struct {
|
|
questions []*model.FissionCampaignQaQuestion
|
|
optionMap map[int64][]*model.FissionCampaignQaOption
|
|
}
|
|
|
|
type campaignLangsRewards struct {
|
|
webIds, extraIds, newcomerIds, ids []int64
|
|
userLevel []*campaignLangsLevelIds
|
|
country []*campaignLangsCountryMarks
|
|
preward *provider.Rewards
|
|
}
|
|
|
|
type campaignLangsLevelIds struct {
|
|
LevelId int64
|
|
ids []int64
|
|
}
|
|
|
|
type campaignLangsCountryMarks struct {
|
|
countryMark string
|
|
ids []int64
|
|
}
|
|
|
|
type Langs struct {
|
|
logic.Logic
|
|
Req *pb.LangsReq
|
|
Res *pb.LangsRes
|
|
|
|
prizeQuiz *campaignLangsPrizeQuiz
|
|
prizeAnswer *campaignLangsPrizeAnswer
|
|
|
|
conds []*model.FissionCampaignCond
|
|
condMap map[int64]*model.FissionCampaignCond
|
|
|
|
levelMap map[int64]string // 等级名称map
|
|
ful finder.FuserLayer
|
|
|
|
rewards map[string]*campaignLangsRewards // 语言对应的奖品数据
|
|
rewardData struct {
|
|
rewardList []*model.FissionCampaignReward
|
|
prewards *provider.Rewards
|
|
} // 依赖的奖品数据
|
|
|
|
// 长图数据
|
|
longImgs map[int64][]*model.FissionCampaignLongImg
|
|
imgZoneMap map[int64][]*model.FissionCampaignLongImgZone
|
|
|
|
// 现金抽奖配置
|
|
cashConf *model.FissionCampaignCash
|
|
|
|
// 金币任务配置
|
|
goldConf *model.FissionCampaignGold
|
|
|
|
// 金币池配置
|
|
coinConf *model.FissionCampaignCoin
|
|
|
|
// 答题配置
|
|
qaConf *model.FissionCampaignQa
|
|
|
|
// 养狗配置
|
|
keepConf *model.FissionCampaignKeep
|
|
|
|
// 题库
|
|
qaGroup map[string]*model.LibraryQaGroup
|
|
defaultQaGroup *model.LibraryQaGroup
|
|
|
|
vsSchedule map[int32][]*model.FissionCampaignVsSchedule
|
|
vsTeam []*model.FissionCampaignVsTeam
|
|
|
|
unoCardMap map[string][]*model.FissionCampaignUnoCard
|
|
|
|
temp *model.FissionTemp
|
|
group *model.FissionTempGroup
|
|
}
|
|
|
|
func (s *Langs) Run() error {
|
|
return logic.Run(s)
|
|
}
|
|
|
|
func (s *Langs) Data() (data jsonm.JsonM) {
|
|
data, _ = jsonm.Marshal(s.Req)
|
|
return
|
|
}
|
|
|
|
func (s *Langs) Exec() (err error) {
|
|
cpn, conf, style, err := s.campaign()
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
notSupport, err := s.setLangs(cpn, conf, style)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.notSupport(cpn, conf, style, notSupport)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Langs) campaign() (cpn *model.FissionCampaign, conf *model.FissionCampaignConfig, style *model.FissionCampaignStyle, err error) {
|
|
cpn, err = finder.Campaign(s.Ctx, s.Req.GetCampaignHashId())
|
|
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
|
|
}
|
|
|
|
style, err = cache.NewCampaignStyle(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
temp, err := cache.NewFissionTemp(s.Ctx).FindById(cpn.TemplateID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
var group *model.FissionTempGroup
|
|
if temp != nil {
|
|
group, err = cache.NewFissionTempGroup(s.Ctx).FindById(temp.GroupID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
}
|
|
|
|
s.rewards = make(map[string]*campaignLangsRewards)
|
|
s.qaGroup = make(map[string]*model.LibraryQaGroup)
|
|
|
|
s.ful = finder.NewFuserLayer(conf)
|
|
|
|
s.Res.HasWeb = conf.HasWeb == mtype.Yes
|
|
s.Res.HasWarn = conf.HasWarmUp == mtype.Yes
|
|
s.Res.HasLongImg = conf.HasLongImg == mtype.Yes
|
|
s.Res.DlType = int32(conf.DlType)
|
|
s.Res.DlBannerType = int32(conf.DlBannerType)
|
|
s.Res.WindowCover = int32(conf.WindowCover)
|
|
s.Res.RewardGroup = int32(conf.RewardGroup)
|
|
s.Res.FissionMark = consts.FissionIdMap[cpn.FissionID]
|
|
s.Res.RuleType = int32(conf.RuleType)
|
|
s.Res.Title = cpn.Title
|
|
s.Res.FissionMarkTitle = consts.FissionTitle[consts.LangZhCn][s.Res.FissionMark]
|
|
|
|
if group != nil {
|
|
s.Res.TempGroupMark = group.Mark
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Langs) setLangs(cpn *model.FissionCampaign, conf *model.FissionCampaignConfig, style *model.FissionCampaignStyle) (notSupport map[string]struct{}, err error) {
|
|
tempM := s.GetDao().FissionTemp
|
|
temp, err := tempM.WithContext(s.Ctx).Where(tempM.ID.Eq(cpn.TemplateID)).Take()
|
|
if err = dbcheck.DbError(err); err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
if temp == nil {
|
|
err = workerr.NotFound("not found temp")
|
|
return
|
|
}
|
|
|
|
m := s.GetDao().FissionCampaignLang
|
|
langs, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.IsDel.Eq(mtype.No)).Order(m.ID).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
// 处理长图数据
|
|
err = s._preLongImgs(conf)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
notSupport = make(map[string]struct{}, len(mtype.MarkToLangType))
|
|
for mark := range mtype.MarkToLangType {
|
|
notSupport[mark] = struct{}{}
|
|
}
|
|
|
|
s.Res.Langs = make([]*pb.LangsRes_Lang, 0, len(langs)+1)
|
|
var appendLang = func(lang *pb.LangsRes_Lang) {
|
|
s.Res.Langs = append(s.Res.Langs, lang)
|
|
delete(notSupport, lang.LangMark)
|
|
}
|
|
|
|
tempMark := mtype.FissionLangTypeToMark[temp.LangType]
|
|
dLang, err := s.dLang(cpn, conf, style, tempMark)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.setReward(cpn, dLang, conf, tempMark, nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
appendLang(dLang)
|
|
|
|
for _, lang := range langs {
|
|
one := s.setLang(cpn, lang)
|
|
|
|
err = s.setReward(cpn, one, conf, lang.LangMark, nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
appendLang(one)
|
|
}
|
|
|
|
if verify.InArray[int8](conf.RewardGroup, mtype.FissionRewardGroupNormal, mtype.FissionRewardGroupUserLevel) {
|
|
return
|
|
}
|
|
|
|
var spMap = make(map[string]struct{})
|
|
for _, v := range cpn.GetLangTypes() {
|
|
spMap[mtype.FissionLangTypeToMark[v]] = struct{}{}
|
|
}
|
|
|
|
for _, mark := range s.ful.GetFirstSupportLang() {
|
|
if _, ok := spMap[mark]; ok {
|
|
continue
|
|
}
|
|
|
|
dLang, err = s.dLang(cpn, conf, style, mark)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.setReward(cpn, dLang, conf, mark, nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
// 待支持的标识
|
|
dLang.Wait = true
|
|
dLang.IsDefault = false
|
|
|
|
appendLang(dLang)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Langs) notSupport(cpn *model.FissionCampaign, conf *model.FissionCampaignConfig, style *model.FissionCampaignStyle, notSupport map[string]struct{}) (err error) {
|
|
s.Res.NotSupport = make([]*pb.LangsRes_Lang, 0, len(notSupport))
|
|
|
|
rlm := cpn.GetLangMarks()[0]
|
|
var rewards *campaignLangsRewards
|
|
for mark := range notSupport {
|
|
var dLang *pb.LangsRes_Lang
|
|
dLang, err = s.dLang(cpn, conf, style, mark)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
dLang.IsDefault = false
|
|
|
|
if !verify.InArray(conf.RewardGroup, mtype.FissionRewardGroupLang, mtype.FissionRewardGroupLangAndUserLevel) {
|
|
rlm = mark
|
|
}
|
|
|
|
// 找活动对应支持的奖品
|
|
rewards, err = s._getRewards(cpn, conf, rlm)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
// 根据模板语言来去翻译数据
|
|
err = s.setReward(cpn, dLang, conf, mark, rewards)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
s.Res.NotSupport = append(s.Res.NotSupport, dLang)
|
|
}
|
|
return
|
|
}
|
|
|
|
// 默认语言处理
|
|
func (s *Langs) setLang(cpn *model.FissionCampaign, lang *model.FissionCampaignLang) (dLang *pb.LangsRes_Lang) {
|
|
dLang = &pb.LangsRes_Lang{
|
|
HashId: lang.HashID,
|
|
IsDefault: false,
|
|
LangMark: lang.LangMark,
|
|
LangType: int32(mtype.MarkToLangType[lang.LangMark]),
|
|
PageTitle: lang.PageTitle,
|
|
ImageMain: lang.ImageMain,
|
|
DownloadPageImage: lang.DownloadPageImage,
|
|
WechatPageImage: lang.WechatPageImage,
|
|
ContentImg: lang.ContentImg,
|
|
WebBgImg: lang.WebBgImg,
|
|
WarmUpImg: lang.WarmUpImg,
|
|
DlBgImg: lang.DlBgImg,
|
|
DlBannerImg: lang.DlBannerImg,
|
|
DlBannerAppLogo: lang.DlBannerAppLogo,
|
|
DlBannerAppName: lang.DlBannerAppName,
|
|
DlBannerAppBtn: lang.DlBannerAppBtn,
|
|
ShareText: lang.ShareText,
|
|
ShareImg: lang.ShareImg,
|
|
Rule: lang.Rule,
|
|
Conds: nil,
|
|
Quit: nil,
|
|
Questions: nil,
|
|
Wait: false,
|
|
Rewards: nil,
|
|
RewardsWeb: nil,
|
|
RewardsExtra: nil,
|
|
RewardsNewcomer: nil,
|
|
LongImgs: nil,
|
|
Cash: nil,
|
|
TOffset: lang.TOffset,
|
|
TStart: cpn.TStart,
|
|
TEnd: cpn.TEnd,
|
|
QaGroup: nil,
|
|
TalkText: nil,
|
|
Gold: nil,
|
|
Coin: nil,
|
|
TopicColor: lang.TopicColor,
|
|
PcBg: lang.PcBg,
|
|
RuleImg: lang.RuleImg,
|
|
Schedules: nil,
|
|
}
|
|
|
|
conds, _ := s._getConds(cpn)
|
|
|
|
var setCondMap = make(map[int64]*mtype.LangCond)
|
|
for _, v := range lang.GetConds() {
|
|
setCondMap[v.CondId] = v
|
|
}
|
|
|
|
for _, cond := range conds {
|
|
one := &pb.LangsRes_Cond{
|
|
CondId: cond.ID,
|
|
Desc: cond.Desc,
|
|
OpenJump: int32(cond.OpenJump),
|
|
WebUrl: cond.WebURL,
|
|
ExtraParam: cond.ExtraParam,
|
|
PcParam: cond.PcParam,
|
|
GoText: cond.GoText,
|
|
}
|
|
|
|
if c, ok := setCondMap[cond.ID]; ok {
|
|
one.Desc = c.Desc
|
|
one.WebUrl = c.WebURL
|
|
one.ExtraParam = c.ExtraParam
|
|
one.PcParam = c.PcParam
|
|
one.GoText = c.GoText
|
|
}
|
|
|
|
dLang.Conds = append(dLang.Conds, one)
|
|
}
|
|
|
|
for _, v := range s.longImgs[lang.ID] {
|
|
one := &pb.LangsRes_LongImg{
|
|
ImgUrl: v.ImgURL,
|
|
WebUrl: v.WebURL,
|
|
AppParam: v.AppParam,
|
|
Id: v.ID,
|
|
ClickType: int32(v.ClickType),
|
|
HotZone: make([]*pb.LangsRes_HotZone, 0, len(s.imgZoneMap[v.ID])),
|
|
TargetType: int32(v.TargetType),
|
|
TargetId: v.TargetID,
|
|
PcParam: v.PcParam,
|
|
LangSourceId: v.LangSourceID,
|
|
}
|
|
|
|
for _, zone := range s.imgZoneMap[v.ID] {
|
|
one.HotZone = append(one.HotZone, &pb.LangsRes_HotZone{
|
|
Id: zone.ID,
|
|
WebUrl: zone.WebURL,
|
|
AppParam: zone.AppParam,
|
|
ClickX: zone.ClickX,
|
|
ClickY: zone.ClickY,
|
|
ClickW: zone.ClickW,
|
|
ClickH: zone.ClickH,
|
|
TargetType: int32(zone.TargetType),
|
|
TargetId: zone.TargetID,
|
|
PcParam: zone.PcParam,
|
|
})
|
|
}
|
|
|
|
dLang.LongImgs = append(dLang.LongImgs, one)
|
|
}
|
|
|
|
switch cpn.FissionID {
|
|
case consts.IdPrizeQuiz:
|
|
if quit := lang.GetQuit(); quit != nil {
|
|
dLang.Quit = &pb.LangsRes_Quit{
|
|
Title: quit.Title,
|
|
Options: make([]*pb.LangsRes_Option, 0, len(quit.Options)),
|
|
}
|
|
|
|
for _, option := range quit.Options {
|
|
dLang.Quit.Options = append(dLang.Quit.Options, &pb.LangsRes_Option{
|
|
OptionId: option.OptionId,
|
|
Title: option.Title,
|
|
ImgUrl: option.ImgUrl,
|
|
})
|
|
}
|
|
}
|
|
case consts.IdQa, consts.IdQaVideo, consts.IdQaAudio:
|
|
if qaGroup := lang.GetQaGroup(); qaGroup != nil {
|
|
var title string
|
|
group, _ := s._getQaGroup(qaGroup.QaGroupId)
|
|
if group != nil {
|
|
title = group.Title
|
|
}
|
|
|
|
conf, _ := s._getQaConf(cpn.ID)
|
|
|
|
dLang.QaGroup = &pb.LangsRes_QaGroup{
|
|
QaGroupId: qaGroup.QaGroupId,
|
|
QaNum: qaGroup.QaNum,
|
|
Title: title,
|
|
OpenGuide: int32(conf.OpenGuide),
|
|
GuideGroupId: qaGroup.GuideGroupId,
|
|
}
|
|
}
|
|
case consts.IdPrizeAnswer:
|
|
|
|
_, tg, _ := s._tempGroup(cpn.TemplateID)
|
|
|
|
if tg.Mark == "answer_tmb" {
|
|
|
|
if qaGroup := lang.GetQaGroup(); qaGroup != nil {
|
|
var title string
|
|
group, _ := s._getQaGroup(qaGroup.QaGroupId)
|
|
if group != nil {
|
|
title = group.Title
|
|
}
|
|
|
|
conf, _ := s._getQaConf(cpn.ID)
|
|
|
|
dLang.QaGroup = &pb.LangsRes_QaGroup{
|
|
QaGroupId: qaGroup.QaGroupId,
|
|
QaNum: qaGroup.QaNum,
|
|
Title: title,
|
|
OpenGuide: int32(conf.OpenGuide),
|
|
GuideGroupId: qaGroup.GuideGroupId,
|
|
}
|
|
}
|
|
|
|
} else {
|
|
for _, question := range lang.GetQuestions() {
|
|
q := &pb.LangsRes_Question{
|
|
QaId: question.QaId,
|
|
Title: question.Title,
|
|
Options: make([]*pb.LangsRes_Option, 0, len(question.Options)),
|
|
}
|
|
|
|
for _, option := range question.Options {
|
|
q.Options = append(q.Options, &pb.LangsRes_Option{
|
|
OptionId: option.OptionId,
|
|
Title: option.Title,
|
|
ImgUrl: option.ImgUrl,
|
|
})
|
|
}
|
|
|
|
dLang.Questions = append(dLang.Questions, q)
|
|
}
|
|
}
|
|
|
|
case consts.IdCash:
|
|
if cash := lang.GetCash(); cash != nil {
|
|
dLang.Cash = &pb.LangsRes_Cash{
|
|
Price: cash.Price,
|
|
Currency: cash.Currency,
|
|
}
|
|
}
|
|
case consts.IdKeep:
|
|
dLang.TalkText = make([]*pb.LangsRes_Talk, 0)
|
|
|
|
_ = jsonm.StrUnmarshal(lang.TalkText, &dLang.TalkText)
|
|
|
|
case consts.IdCoin:
|
|
|
|
var coinConf *model.FissionCampaignCoin
|
|
coinConf, _ = s._getCoinConf(cpn.ID)
|
|
|
|
if verify.InArray[int32](mtype.FissionCampaignCoinLackBtnCustom, coinConf.GetLackBtn()...) {
|
|
if coin := lang.GetLangCoin(); coin != nil {
|
|
dLang.Coin = &pb.LangsRes_Coin{
|
|
CustomBtnText: coin.CustomBtnText,
|
|
CustomWebUrl: coin.CustomWebUrl,
|
|
CustomExtraParam: coin.CustomExtraParam,
|
|
CustomPcParam: coin.CustomPcParam,
|
|
}
|
|
} else {
|
|
dLang.Coin = &pb.LangsRes_Coin{
|
|
CustomBtnText: coinConf.CustomBtnText,
|
|
CustomWebUrl: coinConf.CustomWebURL,
|
|
CustomExtraParam: coinConf.CustomExtraParam,
|
|
CustomPcParam: coinConf.CustomPcParam,
|
|
}
|
|
}
|
|
}
|
|
|
|
case consts.IdVs:
|
|
|
|
langVs := lang.GetVs()
|
|
var langScheduleMap = make(map[int64]*pb.LangsRes_PkTeam, len(langVs))
|
|
|
|
for _, schedule := range langVs {
|
|
for _, pkTeam := range schedule.PkTeams {
|
|
var teams = make([]*pb.LangsRes_Team, 0, len(pkTeam.Teams))
|
|
for _, team := range pkTeam.Teams {
|
|
teams = append(teams, &pb.LangsRes_Team{
|
|
Id: team.Id,
|
|
Name: team.Name,
|
|
LogoImg: team.LogoImg,
|
|
})
|
|
}
|
|
|
|
langScheduleMap[pkTeam.Id] = &pb.LangsRes_PkTeam{
|
|
Id: pkTeam.Id,
|
|
Teams: teams,
|
|
VsImg: pkTeam.VsImg,
|
|
Desc: pkTeam.Desc,
|
|
}
|
|
}
|
|
}
|
|
|
|
vsTeam, _ := s._getVsTeam(cpn.ID)
|
|
var vsTeamMap = make(map[int64]*pb.LangsRes_Team, len(vsTeam))
|
|
for _, v := range vsTeam {
|
|
vsTeamMap[v.ID] = &pb.LangsRes_Team{
|
|
Id: v.ID,
|
|
Name: v.Name,
|
|
LogoImg: v.LogoImg,
|
|
}
|
|
}
|
|
|
|
vsSchedule, _ := s._getVsSchedule(cpn.ID)
|
|
dLang.Schedules = make([]*pb.LangsRes_Schedule, len(vsSchedule))
|
|
for idx, schedules := range vsSchedule {
|
|
one := &pb.LangsRes_Schedule{
|
|
Id: idx,
|
|
PkTeams: make([]*pb.LangsRes_PkTeam, 0, len(schedules)),
|
|
}
|
|
|
|
for _, schedule := range schedules {
|
|
two := &pb.LangsRes_PkTeam{
|
|
Id: schedule.ID,
|
|
Desc: schedule.Desc,
|
|
VsImg: schedule.VsImg,
|
|
}
|
|
|
|
for _, teamId := range schedule.GetVsTeamIds() {
|
|
if teamId > 0 {
|
|
two.Teams = append(two.Teams, vsTeamMap[teamId])
|
|
} else {
|
|
two.Teams = append(two.Teams, &pb.LangsRes_Team{
|
|
Id: teamId,
|
|
})
|
|
}
|
|
}
|
|
|
|
if scd, ok := langScheduleMap[schedule.ID]; ok {
|
|
two.Desc = scd.Desc
|
|
two.VsImg = scd.VsImg
|
|
for i, team := range scd.Teams {
|
|
if team.Id > 0 || two.Teams[i] == nil || two.Teams[i].Id < 0 {
|
|
two.Teams[i] = team
|
|
}
|
|
}
|
|
}
|
|
|
|
one.PkTeams = append(one.PkTeams, two)
|
|
}
|
|
|
|
dLang.Schedules[idx] = one
|
|
}
|
|
case consts.IdUno:
|
|
langUno := lang.GetUno()
|
|
dLang.Uno = &pb.LangsRes_Uno{
|
|
Red: s._unoCard(mtype.FissionCampaignUnoGroupRed, cpn.ID, langUno.Red),
|
|
Yellow: s._unoCard(mtype.FissionCampaignUnoGroupYellow, cpn.ID, langUno.Yellow),
|
|
Blue: s._unoCard(mtype.FissionCampaignUnoGroupBlue, cpn.ID, langUno.Blue),
|
|
Green: s._unoCard(mtype.FissionCampaignUnoGroupGreen, cpn.ID, langUno.Green),
|
|
}
|
|
default:
|
|
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 默认处理
|
|
func (s *Langs) dLang(cpn *model.FissionCampaign, conf *model.FissionCampaignConfig, style *model.FissionCampaignStyle, langMark string) (dLang *pb.LangsRes_Lang, err error) {
|
|
dLang = &pb.LangsRes_Lang{
|
|
HashId: "",
|
|
IsDefault: true,
|
|
LangMark: langMark,
|
|
LangType: int32(mtype.MarkToLangType[langMark]),
|
|
PageTitle: style.PageTitle,
|
|
ImageMain: style.MainImg,
|
|
DownloadPageImage: utils.Ternary[string](style.DownloadImg == "", style.MainImg, style.DownloadImg),
|
|
WechatPageImage: utils.Ternary[string](style.WechatImg == "", style.MainImg, style.WechatImg),
|
|
ContentImg: style.BgImg,
|
|
WebBgImg: style.WechatImg,
|
|
WarmUpImg: style.WarmUpImg,
|
|
DlBgImg: style.DownloadImg,
|
|
DlBannerImg: style.DlBannerImg,
|
|
DlBannerAppLogo: style.DlBannerAppLogo,
|
|
DlBannerAppName: style.DlBannerAppName,
|
|
DlBannerAppBtn: style.DlBannerAppBtn,
|
|
ShareText: style.ShareText,
|
|
ShareImg: style.ShareImg,
|
|
Rule: style.PlayRule,
|
|
Conds: nil,
|
|
Quit: nil,
|
|
Questions: nil,
|
|
Wait: false,
|
|
Rewards: nil,
|
|
RewardsWeb: nil,
|
|
RewardsExtra: nil,
|
|
RewardsNewcomer: nil,
|
|
LongImgs: nil,
|
|
Cash: nil,
|
|
TOffset: cpn.TOffset,
|
|
TStart: cpn.TStart,
|
|
TEnd: cpn.TEnd,
|
|
QaGroup: nil,
|
|
TalkText: nil,
|
|
Gold: nil,
|
|
Coin: nil,
|
|
TopicColor: style.TopicColor,
|
|
PcBg: style.PcBg,
|
|
RuleImg: style.RuleImg,
|
|
Schedules: nil,
|
|
}
|
|
|
|
if conf.Option != mtype.FissionCampaignConfigTargetOptionApp {
|
|
var conds []*model.FissionCampaignCond
|
|
conds, err = s._getConds(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
dLang.Conds = make([]*pb.LangsRes_Cond, 0, len(conds))
|
|
for _, v := range conds {
|
|
dLang.Conds = append(dLang.Conds, &pb.LangsRes_Cond{
|
|
CondId: v.ID,
|
|
Desc: v.Desc,
|
|
OpenJump: int32(v.OpenJump),
|
|
WebUrl: v.WebURL,
|
|
ExtraParam: v.ExtraParam,
|
|
PcParam: v.PcParam,
|
|
GoText: v.GoText,
|
|
})
|
|
}
|
|
}
|
|
|
|
switch cpn.FissionID {
|
|
case consts.IdPrizeQuiz:
|
|
var prizeQuiz *campaignLangsPrizeQuiz
|
|
prizeQuiz, err = s._getPrizeQuiz(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
dLang.Quit = &pb.LangsRes_Quit{
|
|
Title: prizeQuiz.quit.Title,
|
|
Options: make([]*pb.LangsRes_Option, 0, len(prizeQuiz.options)),
|
|
}
|
|
|
|
for _, v := range prizeQuiz.options {
|
|
dLang.Quit.Options = append(dLang.Quit.Options, &pb.LangsRes_Option{
|
|
OptionId: v.ID,
|
|
Title: v.Title,
|
|
ImgUrl: v.ImgURL,
|
|
})
|
|
}
|
|
case consts.IdQa, consts.IdQaVideo, consts.IdQaAudio:
|
|
var qaConf *model.FissionCampaignQa
|
|
qaConf, err = s._getQaConf(cpn.ID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
var qaGroup *model.LibraryQaGroup
|
|
qaGroup, err = s._getDefaultQaGroup(qaConf.QaGroupID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
var guideGroupHashId string
|
|
if qaConf.GuideGroupID > 0 {
|
|
var guideGroup *model.LibraryQaGroup
|
|
guideGroup, err = s._getDefaultQaGroup(qaConf.QaGroupID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if guideGroup != nil {
|
|
guideGroupHashId = guideGroup.HashID
|
|
}
|
|
}
|
|
|
|
dLang.QaGroup = &pb.LangsRes_QaGroup{
|
|
QaGroupId: qaGroup.HashID,
|
|
QaNum: qaConf.QaNum,
|
|
Title: qaGroup.Title,
|
|
OpenGuide: int32(qaConf.OpenGuide),
|
|
GuideGroupId: guideGroupHashId,
|
|
}
|
|
case consts.IdPrizeAnswer:
|
|
|
|
_, tg, _ := s._tempGroup(cpn.TemplateID)
|
|
|
|
if tg.Mark == "answer_tmb" {
|
|
var qaConf *model.FissionCampaignQa
|
|
qaConf, err = s._getQaConf(cpn.ID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
var qaGroup *model.LibraryQaGroup
|
|
qaGroup, err = s._getDefaultQaGroup(qaConf.QaGroupID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
var guideGroupHashId string
|
|
if qaConf.GuideGroupID > 0 {
|
|
var guideGroup *model.LibraryQaGroup
|
|
guideGroup, err = s._getDefaultQaGroup(qaConf.QaGroupID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if guideGroup != nil {
|
|
guideGroupHashId = guideGroup.HashID
|
|
}
|
|
}
|
|
|
|
dLang.QaGroup = &pb.LangsRes_QaGroup{
|
|
QaGroupId: qaGroup.HashID,
|
|
QaNum: qaConf.QaNum,
|
|
Title: qaGroup.Title,
|
|
OpenGuide: int32(qaConf.OpenGuide),
|
|
GuideGroupId: guideGroupHashId,
|
|
}
|
|
} else {
|
|
var prizeAnswer *campaignLangsPrizeAnswer
|
|
prizeAnswer, err = s._getPrizeAnswer(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
dLang.Questions = make([]*pb.LangsRes_Question, 0, len(prizeAnswer.questions))
|
|
|
|
for _, v := range prizeAnswer.questions {
|
|
one := &pb.LangsRes_Question{
|
|
QaId: v.ID,
|
|
Title: v.Title,
|
|
Options: make([]*pb.LangsRes_Option, 0, len(prizeAnswer.optionMap[v.ID])),
|
|
}
|
|
|
|
for _, option := range prizeAnswer.optionMap[v.ID] {
|
|
one.Options = append(one.Options, &pb.LangsRes_Option{
|
|
OptionId: option.ID,
|
|
Title: option.Title,
|
|
})
|
|
}
|
|
|
|
dLang.Questions = append(dLang.Questions, one)
|
|
}
|
|
}
|
|
|
|
case consts.IdCash:
|
|
var cashConf *model.FissionCampaignCash
|
|
cashConf, err = s._getCashConf(cpn.ID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
dLang.Cash = &pb.LangsRes_Cash{
|
|
Price: cashConf.Price,
|
|
Currency: int32(cashConf.Currency),
|
|
}
|
|
case consts.IdKeep:
|
|
var keepConf *model.FissionCampaignKeep
|
|
keepConf, err = s._getKeepConf(cpn.ID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
talks := keepConf.GetKeepTalk()
|
|
dLang.TalkText = make([]*pb.LangsRes_Talk, 0, len(talks))
|
|
for _, v := range talks {
|
|
dLang.TalkText = append(dLang.TalkText, &pb.LangsRes_Talk{
|
|
TextType: v.TextType,
|
|
Content: v.Content,
|
|
})
|
|
}
|
|
case consts.IdGold:
|
|
var goldConf *model.FissionCampaignGold
|
|
goldConf, err = s._getGoldConf(cpn.ID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
dLang.Gold = &pb.LangsRes_Gold{
|
|
Price: goldConf.Price,
|
|
Currency: int32(goldConf.Currency),
|
|
}
|
|
|
|
case consts.IdCoin:
|
|
var coinConf *model.FissionCampaignCoin
|
|
coinConf, err = s._getCoinConf(cpn.ID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
if verify.InArray[int32](mtype.FissionCampaignCoinLackBtnCustom, coinConf.GetLackBtn()...) {
|
|
dLang.Coin = &pb.LangsRes_Coin{
|
|
CustomBtnText: coinConf.CustomBtnText,
|
|
CustomWebUrl: coinConf.CustomWebURL,
|
|
CustomExtraParam: coinConf.CustomExtraParam,
|
|
CustomPcParam: coinConf.CustomPcParam,
|
|
}
|
|
}
|
|
case consts.IdVs:
|
|
var vsTeam []*model.FissionCampaignVsTeam
|
|
vsTeam, err = s._getVsTeam(cpn.ID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
var vsTeamMap = make(map[int64]*pb.LangsRes_Team, len(vsTeam))
|
|
for _, v := range vsTeam {
|
|
vsTeamMap[v.ID] = &pb.LangsRes_Team{
|
|
Id: v.ID,
|
|
Name: v.Name,
|
|
LogoImg: v.LogoImg,
|
|
}
|
|
}
|
|
|
|
var vsSchedule map[int32][]*model.FissionCampaignVsSchedule
|
|
vsSchedule, err = s._getVsSchedule(cpn.ID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
dLang.Schedules = make([]*pb.LangsRes_Schedule, len(vsSchedule))
|
|
for idx, schedules := range vsSchedule {
|
|
one := &pb.LangsRes_Schedule{
|
|
Id: idx,
|
|
PkTeams: make([]*pb.LangsRes_PkTeam, 0, len(schedules)),
|
|
}
|
|
|
|
for _, schedule := range schedules {
|
|
two := &pb.LangsRes_PkTeam{
|
|
Id: schedule.ID,
|
|
Teams: make([]*pb.LangsRes_Team, 0, len(schedule.GetVsTeamIds())),
|
|
VsImg: schedule.VsImg,
|
|
Desc: schedule.Desc,
|
|
}
|
|
|
|
for _, teamId := range schedule.GetVsTeamIds() {
|
|
if teamId > 0 {
|
|
two.Teams = append(two.Teams, vsTeamMap[teamId])
|
|
} else {
|
|
two.Teams = append(two.Teams, &pb.LangsRes_Team{
|
|
Id: teamId,
|
|
})
|
|
}
|
|
}
|
|
|
|
one.PkTeams = append(one.PkTeams, two)
|
|
}
|
|
|
|
dLang.Schedules[idx] = one
|
|
}
|
|
case consts.IdUno:
|
|
dLang.Uno = &pb.LangsRes_Uno{
|
|
Red: s._unoCard(mtype.FissionCampaignUnoGroupRed, cpn.ID, nil),
|
|
Yellow: s._unoCard(mtype.FissionCampaignUnoGroupYellow, cpn.ID, nil),
|
|
Blue: s._unoCard(mtype.FissionCampaignUnoGroupBlue, cpn.ID, nil),
|
|
Green: s._unoCard(mtype.FissionCampaignUnoGroupGreen, cpn.ID, nil),
|
|
}
|
|
default:
|
|
|
|
}
|
|
|
|
dLang.LongImgs = make([]*pb.LangsRes_LongImg, 0, len(s.longImgs[0]))
|
|
for _, v := range s.longImgs[0] {
|
|
one := &pb.LangsRes_LongImg{
|
|
ImgUrl: v.ImgURL,
|
|
WebUrl: v.WebURL,
|
|
AppParam: v.AppParam,
|
|
Id: v.ID,
|
|
ClickType: int32(v.ClickType),
|
|
HotZone: make([]*pb.LangsRes_HotZone, 0, len(s.imgZoneMap[v.ID])),
|
|
TargetType: int32(v.TargetType),
|
|
TargetId: v.TargetID,
|
|
PcParam: v.PcParam,
|
|
LangSourceId: v.ID,
|
|
}
|
|
|
|
for _, click := range s.imgZoneMap[v.ID] {
|
|
one.HotZone = append(one.HotZone, &pb.LangsRes_HotZone{
|
|
Id: click.ID,
|
|
WebUrl: click.WebURL,
|
|
AppParam: click.AppParam,
|
|
ClickX: click.ClickX,
|
|
ClickY: click.ClickY,
|
|
ClickW: click.ClickW,
|
|
ClickH: click.ClickH,
|
|
TargetType: int32(click.TargetType),
|
|
TargetId: click.TargetID,
|
|
PcParam: click.PcParam,
|
|
})
|
|
}
|
|
|
|
dLang.LongImgs = append(dLang.LongImgs, one)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 设置要返回的奖品信息
|
|
func (s *Langs) setReward(cpn *model.FissionCampaign, lang *pb.LangsRes_Lang, conf *model.FissionCampaignConfig, langMark string, rewards *campaignLangsRewards) (err error) {
|
|
if rewards == nil {
|
|
rewards, err = s._getRewards(cpn, conf, langMark)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
|
|
preward := rewards.preward
|
|
|
|
s._appendReward(preward, rewards.webIds, &lang.RewardsWeb, langMark)
|
|
s._appendReward(preward, rewards.extraIds, &lang.RewardsExtra, langMark)
|
|
s._appendReward(preward, rewards.newcomerIds, &lang.RewardsNewcomer, langMark)
|
|
|
|
lang.Rewards = &pb.LangsRes_Rewards{
|
|
Normal: nil,
|
|
UserLevel: nil,
|
|
Langs: nil,
|
|
LangUserLevel: nil,
|
|
Country: nil,
|
|
}
|
|
|
|
switch conf.RewardGroup {
|
|
case mtype.FissionRewardGroupNormal:
|
|
s._appendReward(preward, rewards.ids, &lang.Rewards.Normal, langMark)
|
|
case mtype.FissionRewardGroupLang:
|
|
s._appendReward(preward, rewards.ids, &lang.Rewards.Langs, langMark)
|
|
case mtype.FissionRewardGroupUserLevel:
|
|
s._appendUserLevel(preward, rewards.userLevel, &lang.Rewards.UserLevel, langMark)
|
|
case mtype.FissionRewardGroupLangAndUserLevel:
|
|
s._appendUserLevel(preward, rewards.userLevel, &lang.Rewards.LangUserLevel, langMark)
|
|
case mtype.FissionRewardGroupCountry:
|
|
s._appendCountry(preward, rewards.country, &lang.Rewards.Country, langMark)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Langs) _getPrizeQuiz(cpn *model.FissionCampaign) (prizeQuiz *campaignLangsPrizeQuiz, err error) {
|
|
if s.prizeQuiz == nil {
|
|
s.prizeQuiz = &campaignLangsPrizeQuiz{
|
|
quit: nil,
|
|
options: nil,
|
|
}
|
|
|
|
quitM := s.GetDao().FissionCampaignQuiz
|
|
s.prizeQuiz.quit, err = quitM.WithContext(s.Ctx).Where(quitM.CampaignID.Eq(cpn.ID)).Take()
|
|
if err = dbcheck.DbError(err); err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
optionM := s.GetDao().FissionCampaignQuizOption
|
|
s.prizeQuiz.options, err = optionM.WithContext(s.Ctx).Where(optionM.CampaignID.Eq(cpn.ID), optionM.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
}
|
|
|
|
return s.prizeQuiz, nil
|
|
}
|
|
|
|
func (s *Langs) _getPrizeAnswer(cpn *model.FissionCampaign) (prizeAnswer *campaignLangsPrizeAnswer, err error) {
|
|
if s.prizeAnswer == nil {
|
|
s.prizeAnswer = &campaignLangsPrizeAnswer{
|
|
questions: nil,
|
|
optionMap: make(map[int64][]*model.FissionCampaignQaOption),
|
|
}
|
|
questionM := s.GetDao().FissionCampaignQaQuestion
|
|
s.prizeAnswer.questions, err = questionM.WithContext(s.Ctx).Where(questionM.CampaignID.Eq(cpn.ID), questionM.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
var ids []int64
|
|
for _, v := range s.prizeAnswer.questions {
|
|
ids = append(ids, v.ID)
|
|
}
|
|
|
|
optionM := s.GetDao().FissionCampaignQaOption
|
|
var options []*model.FissionCampaignQaOption
|
|
options, err = optionM.WithContext(s.Ctx).Where(optionM.QuestionID.In(ids...), optionM.IsDel.Eq(mtype.No)).Order(optionM.ID).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
for _, v := range options {
|
|
s.prizeAnswer.optionMap[v.QuestionID] = append(s.prizeAnswer.optionMap[v.QuestionID], v)
|
|
}
|
|
}
|
|
|
|
return s.prizeAnswer, nil
|
|
}
|
|
|
|
func (s *Langs) _getConds(cpn *model.FissionCampaign) (conds []*model.FissionCampaignCond, err error) {
|
|
if s.conds == nil {
|
|
condM := s.GetDao().FissionCampaignCond
|
|
s.conds, err = condM.WithContext(s.Ctx).Where(condM.CampaignID.Eq(cpn.ID), condM.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
s.condMap = make(map[int64]*model.FissionCampaignCond, len(s.conds))
|
|
for _, cond := range s.conds {
|
|
s.condMap[cond.ID] = cond
|
|
}
|
|
|
|
}
|
|
|
|
return s.conds, nil
|
|
}
|
|
|
|
func (s *Langs) _getRewards(cpn *model.FissionCampaign, conf *model.FissionCampaignConfig, langMark string) (rewards *campaignLangsRewards, err error) {
|
|
|
|
if _, ok := s.rewards[langMark]; ok {
|
|
return s.rewards[langMark], nil
|
|
}
|
|
|
|
rewards = &campaignLangsRewards{
|
|
webIds: nil,
|
|
extraIds: nil,
|
|
newcomerIds: nil,
|
|
ids: nil,
|
|
preward: nil,
|
|
}
|
|
|
|
list, prewards, err := s._getRewardData(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
var appList []*model.FissionCampaignReward
|
|
for _, v := range list {
|
|
switch v.RewardType {
|
|
case mtype.FissionCampaignRewardTypeExtra:
|
|
rewards.extraIds = append(rewards.extraIds, v.RewardID)
|
|
case mtype.FissionCampaignRewardTypeNewcomer:
|
|
rewards.newcomerIds = append(rewards.newcomerIds, v.RewardID)
|
|
case mtype.FissionCampaignRewardTypeWeb:
|
|
rewards.webIds = append(rewards.webIds, v.RewardID)
|
|
case mtype.FissionCampaignRewardTypeApp:
|
|
appList = append(appList, v)
|
|
}
|
|
}
|
|
|
|
switch conf.RewardGroup {
|
|
case mtype.FissionRewardGroupNormal:
|
|
rewards.ids = s._rewardIds(appList, nil)
|
|
case mtype.FissionRewardGroupLang:
|
|
mark, _ := s.ful.Lang().Selected(langMark)
|
|
rewards.ids = s._rewardIds(appList, func(lang string) bool { return lang == mark })
|
|
case mtype.FissionRewardGroupUserLevel:
|
|
rewards.userLevel = s._addUserLevel(appList, nil)
|
|
case mtype.FissionRewardGroupLangAndUserLevel:
|
|
mark, _ := s.ful.LangLevel().GetLang(langMark)
|
|
rewards.userLevel = s._addUserLevel(appList, func(lang string) bool { return lang == mark })
|
|
case mtype.FissionRewardGroupCountry:
|
|
rewards.country = s._addCountry(appList, nil)
|
|
}
|
|
|
|
rewards.preward = prewards
|
|
|
|
s.rewards[langMark] = rewards
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Langs) _rewardIds(appList []*model.FissionCampaignReward, langOk func(lang string) bool) (ids []int64) {
|
|
ids = make([]int64, 0, len(appList))
|
|
for _, v := range appList {
|
|
if langOk != nil && !langOk(v.LangMark) {
|
|
continue
|
|
}
|
|
ids = append(ids, v.RewardID)
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *Langs) _addUserLevel(appList []*model.FissionCampaignReward, langOk func(lang string) bool) (userLevel []*campaignLangsLevelIds) {
|
|
var idx int
|
|
var levelIdx = make(map[int64]int)
|
|
var levelIds []int64
|
|
|
|
for _, v := range appList {
|
|
if langOk != nil && !langOk(v.LangMark) {
|
|
continue
|
|
}
|
|
|
|
if lidx, ok := levelIdx[v.LevelID]; ok {
|
|
userLevel[lidx].ids = append(userLevel[lidx].ids, v.RewardID)
|
|
} else {
|
|
userLevel = append(userLevel, &campaignLangsLevelIds{
|
|
LevelId: v.LevelID,
|
|
ids: []int64{v.RewardID},
|
|
})
|
|
levelIdx[v.LevelID] = idx
|
|
idx++
|
|
levelIds = append(levelIds, v.LevelID)
|
|
}
|
|
}
|
|
|
|
if len(levelIds) == 0 {
|
|
return
|
|
}
|
|
|
|
levelM := s.GetDao().FissionUserLevel
|
|
levelList, err := levelM.WithContext(s.Ctx).Where(levelM.ID.In(levelIds...)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
s.levelMap = make(map[int64]string, len(levelList))
|
|
for _, v := range levelList {
|
|
s.levelMap[v.ID] = v.Title
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Langs) _appendReward(preward *provider.Rewards, ids []int64, out *[]*pb.LangsRes_Reward, langMark string) {
|
|
*out = make([]*pb.LangsRes_Reward, 0, len(ids))
|
|
inMap, _ := preward.InfoMap(ids...)
|
|
|
|
for _, rewardId := range ids {
|
|
reward, ok := inMap[rewardId]
|
|
if !ok && reward == nil {
|
|
continue
|
|
}
|
|
|
|
one := &pb.LangsRes_Reward{
|
|
RewardId: reward.Id,
|
|
Title: "",
|
|
ImgUrl: "",
|
|
FindDefault: false,
|
|
}
|
|
|
|
langInfo := preward.AutoLang(rewardId, langMark)
|
|
one.Title, one.ImgUrl, one.FindDefault = langInfo.Title, langInfo.ImgUrl, langInfo.FindDefault
|
|
|
|
*out = append(*out, one)
|
|
}
|
|
}
|
|
|
|
func (s *Langs) _appendUserLevel(preward *provider.Rewards, levelIds []*campaignLangsLevelIds, out *[]*pb.LangsRes_UserLevelOne, langMark string) {
|
|
*out = make([]*pb.LangsRes_UserLevelOne, 0, len(levelIds))
|
|
for _, v := range levelIds {
|
|
one := &pb.LangsRes_UserLevelOne{
|
|
LevelId: v.LevelId,
|
|
LevelTitle: s.levelMap[v.LevelId],
|
|
Rewards: nil,
|
|
}
|
|
s._appendReward(preward, v.ids, &one.Rewards, langMark)
|
|
*out = append(*out, one)
|
|
}
|
|
}
|
|
|
|
func (s *Langs) _appendCountry(preward *provider.Rewards, countryMarks []*campaignLangsCountryMarks, out *[]*pb.LangsRes_CountryOne, langMark string) {
|
|
*out = make([]*pb.LangsRes_CountryOne, 0, len(countryMarks))
|
|
for _, v := range countryMarks {
|
|
one := &pb.LangsRes_CountryOne{
|
|
CountryMark: v.countryMark,
|
|
Rewards: nil,
|
|
}
|
|
s._appendReward(preward, v.ids, &one.Rewards, langMark)
|
|
*out = append(*out, one)
|
|
}
|
|
}
|
|
|
|
func (s *Langs) _addCountry(appList []*model.FissionCampaignReward, langOk func(lang string) bool) (country []*campaignLangsCountryMarks) {
|
|
var idx int
|
|
var countryIdx = make(map[string]int)
|
|
|
|
for _, v := range appList {
|
|
if langOk != nil && !langOk(v.LangMark) {
|
|
continue
|
|
}
|
|
|
|
if lidx, ok := countryIdx[v.CountryMark]; ok {
|
|
country[lidx].ids = append(country[lidx].ids, v.RewardID)
|
|
} else {
|
|
country = append(country, &campaignLangsCountryMarks{
|
|
countryMark: v.CountryMark,
|
|
ids: []int64{v.RewardID},
|
|
})
|
|
countryIdx[v.CountryMark] = idx
|
|
idx++
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Langs) _getRewardData(cpn *model.FissionCampaign) (list []*model.FissionCampaignReward, prewards *provider.Rewards, err error) {
|
|
if len(s.rewardData.rewardList) == 0 {
|
|
m := s.GetDao().FissionCampaignReward
|
|
s.rewardData.rewardList, err = m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
}
|
|
|
|
var idMap = make(map[int64]struct{})
|
|
var ids []int64
|
|
|
|
for _, v := range list {
|
|
if _, ok := idMap[v.RewardID]; !ok {
|
|
ids = append(ids, v.RewardID)
|
|
}
|
|
}
|
|
|
|
s.rewardData.prewards, err = provider.NewRewards(s.Ctx, cpn.ProjectID, ids...)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
}
|
|
|
|
return s.rewardData.rewardList, s.rewardData.prewards, nil
|
|
}
|
|
|
|
func (s *Langs) _preLongImgs(conf *model.FissionCampaignConfig) (err error) {
|
|
if conf.HasLongImg == mtype.No {
|
|
return
|
|
}
|
|
|
|
m := s.GetDao().FissionCampaignLongImg
|
|
imgs, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(conf.CampaignID), m.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
s.longImgs = make(map[int64][]*model.FissionCampaignLongImg)
|
|
|
|
var imgZoneIds []int64
|
|
for _, v := range imgs {
|
|
if v.ClickType == mtype.FissionCampaignLongImgClickTypeZone {
|
|
imgZoneIds = append(imgZoneIds, v.ID)
|
|
}
|
|
s.longImgs[v.LangID] = append(s.longImgs[v.LangID], v)
|
|
}
|
|
|
|
s.imgZoneMap = make(map[int64][]*model.FissionCampaignLongImgZone)
|
|
|
|
if len(imgZoneIds) == 0 {
|
|
return
|
|
}
|
|
|
|
zoneM := s.GetDao().FissionCampaignLongImgZone
|
|
zones, err := zoneM.WithContext(s.Ctx).Where(zoneM.ImgID.In(imgZoneIds...), zoneM.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
for _, v := range zones {
|
|
s.imgZoneMap[v.ImgID] = append(s.imgZoneMap[v.ImgID], v)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Langs) _getCashConf(cpnId int64) (cashConf *model.FissionCampaignCash, err error) {
|
|
if s.cashConf == nil {
|
|
s.cashConf, err = cache.NewCampaignCash(s.Ctx).FindByCampaignId(cpnId)
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
}
|
|
|
|
return s.cashConf, nil
|
|
}
|
|
|
|
func (s *Langs) _getGoldConf(cpnId int64) (cashConf *model.FissionCampaignGold, err error) {
|
|
if s.goldConf == nil {
|
|
s.goldConf, err = cache.NewCampaignGold(s.Ctx).FindByCampaignId(cpnId)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
}
|
|
|
|
return s.goldConf, nil
|
|
}
|
|
|
|
func (s *Langs) _getCoinConf(cpnId int64) (cashConf *model.FissionCampaignCoin, err error) {
|
|
if s.coinConf == nil {
|
|
s.coinConf, err = cache.NewCampaignCoin(s.Ctx).FindByCampaignId(cpnId)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
}
|
|
|
|
return s.coinConf, nil
|
|
}
|
|
|
|
func (s *Langs) _getQaConf(cpnId int64) (qaConf *model.FissionCampaignQa, err error) {
|
|
if s.qaConf == nil {
|
|
m := s.GetDao().FissionCampaignQa
|
|
s.qaConf, err = m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpnId)).Take()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
}
|
|
|
|
return s.qaConf, nil
|
|
}
|
|
|
|
func (s *Langs) _getQaGroup(qaGroupHashId string) (qaGroup *model.LibraryQaGroup, err error) {
|
|
if s.qaGroup[qaGroupHashId] == nil {
|
|
m := s.GetDao().LibraryQaGroup
|
|
s.qaGroup[qaGroupHashId], err = m.WithContext(s.Ctx).Where(m.HashID.Eq(qaGroupHashId)).Take()
|
|
if err = dbcheck.DbError(err); err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
}
|
|
|
|
return s.qaGroup[qaGroupHashId], nil
|
|
}
|
|
|
|
func (s *Langs) _getDefaultQaGroup(qaGroupId int64) (qaGroup *model.LibraryQaGroup, err error) {
|
|
if s.defaultQaGroup == nil {
|
|
m := s.GetDao().LibraryQaGroup
|
|
s.defaultQaGroup, err = m.WithContext(s.Ctx).Where(m.ID.Eq(qaGroupId)).Take()
|
|
if err = dbcheck.DbError(err); err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
}
|
|
|
|
return s.defaultQaGroup, nil
|
|
}
|
|
|
|
func (s *Langs) _getKeepConf(cpnId int64) (qaConf *model.FissionCampaignKeep, err error) {
|
|
if s.keepConf == nil {
|
|
m := s.GetDao().FissionCampaignKeep
|
|
s.keepConf, err = m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpnId)).Take()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
}
|
|
|
|
return s.keepConf, nil
|
|
}
|
|
|
|
func (s *Langs) _getVsTeam(cpnId int64) (teams []*model.FissionCampaignVsTeam, err error) {
|
|
if len(s.vsTeam) == 0 {
|
|
m := s.GetDao().FissionCampaignVsTeam
|
|
s.vsTeam, err = m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpnId)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
}
|
|
|
|
return s.vsTeam, nil
|
|
}
|
|
|
|
func (s *Langs) _getVsSchedule(cpnId int64) (data map[int32][]*model.FissionCampaignVsSchedule, err error) {
|
|
if s.vsSchedule == nil {
|
|
m := s.GetDao().FissionCampaignVsSchedule
|
|
var list []*model.FissionCampaignVsSchedule
|
|
list, err = m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpnId)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
s.vsSchedule = make(map[int32][]*model.FissionCampaignVsSchedule)
|
|
for _, v := range list {
|
|
s.vsSchedule[v.VsIdx] = append(s.vsSchedule[v.VsIdx], v)
|
|
}
|
|
}
|
|
|
|
return s.vsSchedule, nil
|
|
}
|
|
|
|
func (s *Langs) _getUnoCard(mark string, cpnId int64) (data []*model.FissionCampaignUnoCard, err error) {
|
|
if s.unoCardMap == nil {
|
|
s.unoCardMap = make(map[string][]*model.FissionCampaignUnoCard)
|
|
|
|
cardM := s.GetDao().FissionCampaignUnoCard
|
|
var cards []*model.FissionCampaignUnoCard
|
|
cards, err = cardM.WithContext(s.Ctx).Where(cardM.CampaignID.Eq(cpnId)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
for _, v := range cards {
|
|
s.unoCardMap[v.Mark] = append(s.unoCardMap[v.Mark], v)
|
|
}
|
|
}
|
|
|
|
return s.unoCardMap[mark], nil
|
|
}
|
|
|
|
func (s *Langs) _unoCard(mark string, cpnId int64, langCards []*mtype.UnoCard) []*pb.LangsRes_UnoCard {
|
|
var langMap = make(map[int32]*mtype.UnoCard, len(langCards))
|
|
for _, v := range langCards {
|
|
langMap[v.CardNo] = v
|
|
}
|
|
|
|
cards, _ := s._getUnoCard(mark, cpnId)
|
|
|
|
data := make([]*pb.LangsRes_UnoCard, 0, len(cards))
|
|
for _, card := range cards {
|
|
one := &pb.LangsRes_UnoCard{
|
|
Id: card.ID,
|
|
Title: card.Title,
|
|
ImgUrl: card.ImgURL,
|
|
WebUrl: card.WebURL,
|
|
AppParam: card.AppParam,
|
|
PcParam: card.PcParam,
|
|
}
|
|
|
|
if lang, ok := langMap[card.CardNo]; ok {
|
|
one.Title = lang.Title
|
|
one.ImgUrl = lang.ImgURL
|
|
one.WebUrl = lang.WebURL
|
|
one.AppParam = lang.AppParam
|
|
one.PcParam = lang.PcParam
|
|
}
|
|
|
|
data = append(data, one)
|
|
}
|
|
|
|
return data
|
|
}
|
|
|
|
func (s *Langs) _tempGroup(tempId int64) (temp *model.FissionTemp, group *model.FissionTempGroup, err error) {
|
|
if s.temp == nil || s.group == nil {
|
|
|
|
s.temp, err = cache.NewFissionTemp(s.Ctx).FindById(tempId)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
s.group, err = cache.NewFissionTempGroup(s.Ctx).FindById(s.temp.GroupID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
}
|
|
|
|
return s.temp, s.group, nil
|
|
}
|