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.
2481 lines
62 KiB
Go
2481 lines
62 KiB
Go
package campaign
|
|
|
|
import (
|
|
"joybuywork/internal/app"
|
|
"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/blink"
|
|
"joybuywork/internal/utils/logic"
|
|
"joybuywork/internal/utils/timez"
|
|
"joybuywork/internal/utils/verify"
|
|
pb "joybuywork/proto/go_proto/w_campaign"
|
|
"joybuywork/proto/go_proto/workerr"
|
|
|
|
dlinkpb "gits.branchcn.com/backend/deeplink/proto/go_proto/dlink"
|
|
"gorm.io/gen"
|
|
)
|
|
|
|
type Show struct {
|
|
logic.Logic
|
|
Req *pb.ShowReq
|
|
Res *pb.ShowRes
|
|
|
|
rewardLangList []*model.RewardLang
|
|
|
|
levelMap map[int64]string
|
|
|
|
helpMap map[int64][]*model.FissionCampaignTask
|
|
|
|
ruleMap map[int64]*model.FissionCampaignRewardRule
|
|
|
|
rewardAddMap map[int64]*pb.ShowRes_OpenAdd
|
|
rewardTaskMap map[int64]*pb.ShowRes_RewardTask
|
|
}
|
|
|
|
func (s *Show) Run() error {
|
|
return logic.Run(s)
|
|
}
|
|
|
|
func (s *Show) Exec() (err error) {
|
|
cpn, err := s.setCampaign()
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
conf, err := s.setConf(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.setTargetOption(cpn, conf)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.setFission(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.setPush(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.setEvent(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.setChild(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.setDelayLinkData(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
if !s.Req.GetNotReward() {
|
|
err = s.setReward(cpn, conf)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 设置活动数据
|
|
func (s *Show) setCampaign() (cpn *model.FissionCampaign, err error) {
|
|
cpn, err = finder.Campaign(s.Ctx, s.Req.GetId(), s.Req.GetHashId())
|
|
if err != nil {
|
|
return nil, s.BE().CacheError(err)
|
|
}
|
|
|
|
if cpn == nil || cpn.IsDel == mtype.Yes {
|
|
err = workerr.NotFound("campaign not found")
|
|
return
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
s.Res.Id = cpn.ID
|
|
s.Res.HashId = cpn.HashID
|
|
s.Res.Title = cpn.Title
|
|
s.Res.TempId = cpn.TemplateID
|
|
s.Res.ProjectId = cpn.ProjectID
|
|
s.Res.FissionMark = consts.FissionIdMap[cpn.FissionID]
|
|
s.Res.Status = int32(cpn.Status)
|
|
s.Res.CoverUrl = cpn.CoverURL
|
|
s.Res.TOffset = cpn.TOffset
|
|
s.Res.StartTime = cpn.StartTime
|
|
s.Res.TStart = cpn.TStart
|
|
s.Res.EndTime = cpn.EndTime
|
|
s.Res.TEnd = cpn.TEnd
|
|
s.Res.LangMarks = cpn.GetLangMarks()
|
|
s.Res.FissionId = cpn.FissionID
|
|
|
|
return
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
// 设置活动配置数据
|
|
func (s *Show) setConf(cpn *model.FissionCampaign) (conf *model.FissionCampaignConfig, err error) {
|
|
cc := cache.NewCampaignConfig(s.Ctx)
|
|
conf, err = cc.FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
project, err := finder.Project(s.Ctx, cpn.ProjectID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
var targetChannelMap = make(map[int64]*model.FissionCampaignChannel)
|
|
var targetCpnMap = make(map[int64]*model.FissionCampaign)
|
|
var zoneMap = make(map[int64][]*model.FissionCampaignLongImgZone)
|
|
var longImgs []*model.FissionCampaignLongImg
|
|
if conf.HasLongImg == mtype.Yes {
|
|
longImgM := s.GetDao().FissionCampaignLongImg
|
|
longImgs, err = longImgM.WithContext(s.Ctx).Where(
|
|
longImgM.CampaignID.Eq(cpn.ID),
|
|
longImgM.IsDel.Eq(mtype.No),
|
|
longImgM.LangID.Eq(0),
|
|
).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var cpnIds []int64
|
|
var zoneImgIds []int64
|
|
for _, longImg := range longImgs {
|
|
if longImg.ClickType == mtype.FissionCampaignLongImgClickTypeZone {
|
|
zoneImgIds = append(zoneImgIds, longImg.ID)
|
|
}
|
|
|
|
if longImg.TargetType == mtype.FissionCampaignLongImgTargetTypeCampaign {
|
|
cpnIds = append(cpnIds, longImg.TargetID)
|
|
}
|
|
}
|
|
|
|
if len(zoneImgIds) > 0 {
|
|
zoneM := s.GetDao().FissionCampaignLongImgZone
|
|
var zones []*model.FissionCampaignLongImgZone
|
|
zones, err = zoneM.WithContext(s.Ctx).Where(zoneM.ImgID.In(zoneImgIds...), zoneM.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
for _, zone := range zones {
|
|
zoneMap[zone.ImgID] = append(zoneMap[zone.ImgID], zone)
|
|
if zone.TargetType == mtype.FissionCampaignLongImgTargetTypeCampaign {
|
|
cpnIds = append(cpnIds, zone.TargetID)
|
|
}
|
|
}
|
|
}
|
|
|
|
if len(cpnIds) > 0 {
|
|
cpnM := s.GetDao().FissionCampaign
|
|
var cpns []*model.FissionCampaign
|
|
cpns, err = cpnM.WithContext(s.Ctx).Where(cpnM.ID.In(cpnIds...)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
for _, v := range cpns {
|
|
targetCpnMap[v.ID] = v
|
|
}
|
|
|
|
channelM := s.GetDao().FissionCampaignChannel
|
|
var channels []*model.FissionCampaignChannel
|
|
channels, err = channelM.WithContext(s.Ctx).Where(channelM.CampaignID.In(cpnIds...), channelM.IsDefault.Eq(mtype.Yes), channelM.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
for _, channel := range channels {
|
|
targetChannelMap[channel.CampaignID] = channel
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
style, err := cache.NewCampaignStyle(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
var pointsUse *model.FissionCampaignPointsUse
|
|
if conf.PointsUse == mtype.Yes {
|
|
pointsUse, err = cache.NewCampaignPointsUse(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
}
|
|
|
|
chat, err := cache.NewCampaignChat(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
|
|
// 一般配置
|
|
s.Res.Config = &pb.ShowRes_Config{
|
|
RuleTextColor: conf.RuleTextColor,
|
|
RuleBgColor: conf.RuleBgColor,
|
|
ShareText: conf.ShareText,
|
|
ShareImg: conf.ShareImg,
|
|
HasRank: int32(conf.HasRank),
|
|
RankBackgroundColor: conf.RankBackgroundColor,
|
|
RankTextColor: conf.RankTextColor,
|
|
DownloadPageImage: conf.DownloadPageImage,
|
|
IsDefaultDownload: int32(conf.IsDefaultDownload),
|
|
WechatPageImage: conf.WechatPageImage,
|
|
IsDefaultWechat: int32(conf.IsDefaultWechat),
|
|
ImageMain: conf.ImageMain,
|
|
IsDefaultMain: int32(conf.IsDefaultMain),
|
|
ImagePreview: conf.ImagePreview,
|
|
LinkBtnTextColor: conf.LinkBtnTextColor,
|
|
LinkBtnBgColor: conf.LinkBtnBgColor,
|
|
LinkTextColor: conf.LinkTextColor,
|
|
ShowShare: int32(conf.ShowShare),
|
|
Share: conf.GetShare(),
|
|
PlayRule: conf.PlayRule,
|
|
PageTitle: conf.PageTitle,
|
|
DmShow: int32(conf.DmShow),
|
|
WebBgImg: conf.WebBgImg,
|
|
HasWeb: int32(conf.HasWeb),
|
|
HasWarmUp: int32(conf.HasWarmUp),
|
|
WarmUpImg: conf.WarmUpImg,
|
|
WarmUpEnd: conf.WarmUpEnd,
|
|
IconType: int32(conf.IconType),
|
|
IconBgColor: conf.IconBgColor,
|
|
DlType: int32(conf.DlType),
|
|
DlBannerType: int32(conf.DlBannerType),
|
|
DlBannerImg: conf.DlBannerImg,
|
|
DlBannerAppLogo: conf.DlBannerAppLogo,
|
|
DlBannerAppName: conf.DlBannerAppName,
|
|
DlBannerAppBtn: conf.DlBannerAppBtn,
|
|
DlBannerPosition: int32(conf.DlBannerPosition),
|
|
TopicColor: conf.TopicColor,
|
|
WindowCover: int32(conf.WindowCover),
|
|
OpenAd: 0,
|
|
CloseCopyShare: int32(project.CloseCopyShare),
|
|
IconOpen: conf.GetIconOpen(),
|
|
HasWhite: int32(conf.HasWhite),
|
|
WhiteList: conf.WhiteList,
|
|
PcBg: conf.PcBg,
|
|
AdsType: int32(conf.AdsType),
|
|
LinkTempId: conf.LinkTempID,
|
|
RuleTimeOpen: int32(conf.RuleTimeOpen),
|
|
OutsideTask: int32(conf.OutsideTask),
|
|
IconTextColor: "",
|
|
OpenShare: int32(conf.OpenShare),
|
|
ShowToUse: int32(conf.ShowToUse),
|
|
RuleType: int32(conf.RuleType),
|
|
RuleImg: "",
|
|
RuleOutside: int32(conf.RuleOutside),
|
|
DeviceOnce: int32(conf.DeviceOnce),
|
|
}
|
|
|
|
if style != nil {
|
|
switch cpn.FissionID {
|
|
case consts.IdPrizeWheel:
|
|
custom := style.GetWheelStyle()
|
|
s.Res.WheelStyle = &pb.ShowRes_WheelStyle{
|
|
TopicMark: custom.TopicMark,
|
|
MainImg: custom.MainImg,
|
|
BgColor: custom.BgColor,
|
|
Bottom1: custom.Bottom1,
|
|
Bottom2: custom.Bottom2,
|
|
Bottom3: custom.Bottom3,
|
|
Pointer: custom.Pointer,
|
|
PlayBtn: custom.PlayBtn,
|
|
BorderImg: custom.BorderImg,
|
|
ButtonColor: custom.ButtonColor,
|
|
WheelTextColor: custom.WheelTextColor,
|
|
}
|
|
case consts.IdLuckyGrid:
|
|
custom := style.GetGridStyle()
|
|
s.Res.GridStyle = &pb.ShowRes_GridStyle{
|
|
TopicMark: custom.TopicMark,
|
|
MainImg: custom.MainImg,
|
|
BgColor: custom.BgColor,
|
|
ButtonColor: custom.ButtonColor,
|
|
PlayImg: custom.PlayImg,
|
|
DisablePlayImg: custom.DisablePlayImg,
|
|
MachineImg: custom.MachineImg,
|
|
GridImg: custom.GridImg,
|
|
ActivateImg: custom.ActivateImg,
|
|
}
|
|
case consts.IdFlip:
|
|
custom := style.GetFlipStyle()
|
|
s.Res.FlipStyle = &pb.ShowRes_FlipStyle{
|
|
TopicMark: custom.TopicMark,
|
|
MainImg: custom.MainImg,
|
|
BgColor: custom.BgColor,
|
|
ButtonColor: custom.ButtonColor,
|
|
PlayImg: custom.PlayImg,
|
|
CardImg: custom.CardImg,
|
|
}
|
|
case consts.IdGashapon:
|
|
custom := style.GetGashaponStyle()
|
|
s.Res.GashaponStyle = &pb.ShowRes_GashaponStyle{
|
|
TopicMark: custom.TopicMark,
|
|
MainImg: custom.MainImg,
|
|
BgColor: custom.BgColor,
|
|
MachineImg: custom.MachineImg,
|
|
PlayImg: custom.PlayImg,
|
|
EggType: custom.EggType,
|
|
EggImgs: custom.EggImgs,
|
|
}
|
|
}
|
|
|
|
s.Res.Config.IconTextColor = style.IconTextColor
|
|
s.Res.Config.RuleImg = style.RuleImg
|
|
}
|
|
|
|
ads, err := cache.NewProjectAd(s.Ctx).FindByProjectId(cpn.ProjectID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
// 开启广告
|
|
if ads != nil && ads.OpenAd == mtype.Yes {
|
|
if ads.CampaignAd == mtype.Yes && conf.AdsType == mtype.FissionCampaignConfigAdsTypeProject {
|
|
s.Res.Config.OpenAd = mtype.Yes
|
|
} else if conf.AdsType == mtype.FissionCampaignConfigAdsTypeOpen {
|
|
s.Res.Config.OpenAd = mtype.Yes
|
|
}
|
|
}
|
|
|
|
// 键值配置
|
|
cd := conf.GetCampaignData()
|
|
s.Res.CampaignData = make([]*pb.ShowRes_KV, 0, len(cd))
|
|
for _, v := range cd {
|
|
s.Res.CampaignData = append(s.Res.CampaignData, &pb.ShowRes_KV{
|
|
Key: v.Key,
|
|
Value: v.Value,
|
|
})
|
|
}
|
|
|
|
// 社媒配置
|
|
var share = conf.GetShare()
|
|
s.Res.Share = make([]*pb.ShowRes_Share, 0, len(share))
|
|
var shareMap = consts.ShareMap
|
|
for _, v := range share {
|
|
if sh, ok := shareMap[v]; ok {
|
|
s.Res.Share = append(s.Res.Share, &pb.ShowRes_Share{
|
|
Id: sh.Id,
|
|
Title: sh.Title,
|
|
Logo: sh.Logo,
|
|
Scheme: sh.Scheme,
|
|
IosScheme: sh.IosScheme,
|
|
})
|
|
}
|
|
}
|
|
|
|
// 长图
|
|
s.Res.LongImgs = make([]*pb.ShowRes_LongImg, 0, len(longImgs))
|
|
for _, v := range longImgs {
|
|
one := &pb.ShowRes_LongImg{
|
|
ImgUrl: v.ImgURL,
|
|
WebUrl: v.WebURL,
|
|
AppParam: v.AppParam,
|
|
Id: v.ID,
|
|
ClickType: int32(v.ClickType),
|
|
HotZone: make([]*pb.ShowRes_HotZone, 0, len(zoneMap[v.ID])),
|
|
TargetType: int32(v.TargetType),
|
|
TargetId: v.TargetID,
|
|
TargetUrl: "",
|
|
PcParam: v.PcParam,
|
|
}
|
|
|
|
if v.TargetType == mtype.FissionCampaignLongImgTargetTypeCampaign {
|
|
one.TargetUrl = blink.NewCampaignLink(project.Domain, targetCpnMap[v.TargetID].HashID, targetChannelMap[v.TargetID].Mark).CampaignShareLink()
|
|
}
|
|
|
|
for _, zone := range zoneMap[v.ID] {
|
|
two := &pb.ShowRes_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,
|
|
TargetUrl: "",
|
|
PcParam: zone.PcParam,
|
|
}
|
|
|
|
if zone.TargetType == mtype.FissionCampaignLongImgTargetTypeCampaign {
|
|
two.TargetUrl = blink.NewCampaignLink(project.Domain, targetCpnMap[zone.TargetID].HashID, targetChannelMap[zone.TargetID].Mark).CampaignShareLink()
|
|
}
|
|
|
|
one.HotZone = append(one.HotZone, two)
|
|
|
|
}
|
|
|
|
s.Res.LongImgs = append(s.Res.LongImgs, one)
|
|
}
|
|
|
|
if pointsUse != nil {
|
|
s.Res.PointsUse = &pb.ShowRes_PointsUse{
|
|
Open: int32(conf.PointsUse),
|
|
Icon: pointsUse.Icon,
|
|
UrlId: pointsUse.URLID,
|
|
UseNum: pointsUse.UseNum,
|
|
DayLimit: pointsUse.DayLimit,
|
|
TotalLimit: pointsUse.TotalLimit,
|
|
}
|
|
}
|
|
|
|
if chat != nil {
|
|
s.Res.Chat = &pb.ShowRes_Chat{
|
|
Open: int32(conf.OpenChat),
|
|
HeaderImg: chat.HeaderImg,
|
|
ChatBg: chat.ChatBg,
|
|
DayLimit: chat.DayLimit,
|
|
}
|
|
}
|
|
|
|
return
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) setTargetOption(cpn *model.FissionCampaign, conf *model.FissionCampaignConfig) (err error) {
|
|
|
|
condM := s.GetDao().FissionCampaignCond
|
|
var cond = []gen.Condition{
|
|
condM.CampaignID.Eq(cpn.ID),
|
|
condM.RewardID.Eq(0),
|
|
}
|
|
if cpn.Status == mtype.FissionCampaignStatusCancel {
|
|
cond = append(cond, condM.DelUse.Eq(mtype.Yes))
|
|
} else {
|
|
cond = append(cond, condM.IsDel.Eq(mtype.No))
|
|
}
|
|
|
|
list, err := condM.WithContext(s.Ctx).Where(cond...).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
ticketM := s.GetDao().FissionCampaignTicket
|
|
tickets, err := ticketM.WithContext(s.Ctx).Where(ticketM.CampaignID.Eq(cpn.ID)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
taskM := s.GetDao().FissionCampaignTask
|
|
taskList, err := taskM.WithContext(s.Ctx).Where(
|
|
taskM.CampaignID.Eq(cpn.ID),
|
|
taskM.PropMark.In(
|
|
mtype.FissionCampaignTaskPropMarkChance,
|
|
mtype.FissionCampaignTaskPropMarkReward,
|
|
mtype.FissionCampaignTaskPropMarkPoint,
|
|
mtype.FissionCampaignTaskPropMarkUnoThree,
|
|
mtype.FissionCampaignTaskPropMarkUnoFix,
|
|
mtype.FissionCampaignTaskPropMarkUnoFive,
|
|
),
|
|
taskM.IsDel.Eq(mtype.No),
|
|
).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var rewardIds []int64
|
|
var taskMap = make(map[string]*model.FissionCampaignTask, len(taskList))
|
|
for _, task := range taskList {
|
|
taskMap[task.TaskMark] = task
|
|
rewardIds = append(rewardIds, task.RewardID)
|
|
}
|
|
|
|
var rewardMap = make(map[int64]*pb.ShowRes_Reward, len(rewardIds))
|
|
if len(rewardIds) > 0 {
|
|
rewardM := s.GetDao().FissionCampaignReward
|
|
var rewards []*model.FissionCampaignReward
|
|
rewards, err = rewardM.WithContext(s.Ctx).Where(rewardM.ID.In(rewardIds...)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var brids []int64
|
|
for _, reward := range rewards {
|
|
brids = append(brids, reward.RewardID)
|
|
}
|
|
|
|
var preward *provider.Rewards
|
|
preward, err = provider.NewRewards(s.Ctx, cpn.ProjectID, brids...)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
for _, v := range rewards {
|
|
info, _ := preward.InfoAutoLang(v.RewardID)
|
|
rewardMap[v.ID] = &pb.ShowRes_Reward{
|
|
Id: v.ID,
|
|
RewardId: v.RewardID,
|
|
Stock: v.Stock,
|
|
RewardNum: v.RewardNum,
|
|
Title: info.RewardTitle,
|
|
ImgUrl: info.ImgUrl,
|
|
ReceiveType: info.ReceiveType,
|
|
Contact: info.Contact,
|
|
Url: info.Url,
|
|
FormTitle: info.FormTitle,
|
|
LangMark: info.Mark,
|
|
ExpiredDay: v.ExpiredDay,
|
|
}
|
|
|
|
for _, datum := range info.KvData {
|
|
rewardMap[v.ID].KvData = append(rewardMap[v.ID].KvData, &pb.ShowRes_KV{
|
|
Key: datum.Key,
|
|
Value: datum.Value,
|
|
})
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
|
|
if consts.NewEventCpn(cpn.FissionID) {
|
|
s.Res.TargetOption = &pb.ShowRes_TargetOption{
|
|
Target: int32(conf.Target),
|
|
Fixed: nil,
|
|
Custom: nil,
|
|
Option: int32(conf.Option),
|
|
}
|
|
|
|
for _, ticket := range tickets {
|
|
switch ticket.Mark {
|
|
case mtype.FissionCampaignTicketFixed:
|
|
fixed := &pb.ShowRes_Fixed{
|
|
Open: int32(ticket.Open),
|
|
AppEvent: int32(ticket.AppEvent),
|
|
TargetNum: 0,
|
|
Chance: 0,
|
|
ChanceLimit: 0,
|
|
Percent: 0,
|
|
}
|
|
|
|
switch ticket.AppEvent {
|
|
case mtype.FissionCampaignTicketAppEventInstall:
|
|
if task, ok := taskMap[mtype.FissionCampaignTaskMarkInstall]; ok {
|
|
fixed.TargetNum = task.Num
|
|
fixed.Chance = task.Chance
|
|
fixed.ChanceLimit = task.ChanceLimit
|
|
fixed.Percent = task.Percent
|
|
}
|
|
case mtype.FissionCampaignTicketAppEventRegister:
|
|
if task, ok := taskMap[mtype.FissionCampaignTaskMarkRegister]; ok {
|
|
fixed.TargetNum = task.Num
|
|
fixed.Chance = task.Chance
|
|
fixed.ChanceLimit = task.ChanceLimit
|
|
fixed.Percent = task.Percent
|
|
}
|
|
}
|
|
|
|
s.Res.TargetOption.Fixed = fixed
|
|
case mtype.FissionCampaignTicketCustom:
|
|
custom := &pb.ShowRes_Custom{
|
|
Open: int32(ticket.Open),
|
|
BothType: int32(ticket.BothType),
|
|
Cond: nil,
|
|
BothAll: nil,
|
|
PreEvent: int32(ticket.PreEvent),
|
|
}
|
|
|
|
for _, v := range list {
|
|
one := &pb.ShowRes_Cond{
|
|
Id: v.ID,
|
|
Event: v.Event,
|
|
EventKey: v.EventKey,
|
|
EventVal: v.EventVal,
|
|
Desc: v.Desc,
|
|
IfCond: int32(v.IfCond),
|
|
TaskLimit: 0,
|
|
Chance: 0,
|
|
TriggerType: int32(v.TriggetType),
|
|
DayLimit: 0,
|
|
LevelIds: nil,
|
|
EventType: int32(v.EventType),
|
|
ViewType: int32(v.ViewType),
|
|
LangMarks: nil,
|
|
WatchSec: v.WatchSec,
|
|
WeekLimit: 0,
|
|
WeekNum: 0,
|
|
OpenJump: int32(v.OpenJump),
|
|
WebUrl: v.WebURL,
|
|
ExtraParam: v.ExtraParam,
|
|
GoShow: int32(v.GoShow),
|
|
AdsStrategyId: v.AdsStrategyID,
|
|
AdsStrategyTitle: "",
|
|
IsSuper: int32(v.IsSuper),
|
|
HasPre: 0,
|
|
PreCond: 0,
|
|
ExpiredMin: 0,
|
|
Reward: nil,
|
|
PropMark: "",
|
|
Sort: v.Sort,
|
|
OpenPush: int32(v.OpenPush),
|
|
PcParam: v.PcParam,
|
|
AwardMode: 0,
|
|
GoText: v.GoText,
|
|
ClickEffectOpen: int32(v.ClickEffectOpen),
|
|
ClickEffect: v.ClickEffect,
|
|
ClickEffectUnit: v.ClickEffectUnit,
|
|
ExpiredDay: "",
|
|
PullInvite: int32(v.PullInvite),
|
|
}
|
|
|
|
if task, ok := taskMap[utils.FissionCampaignTaskMarkCondOneVal(v.ID)]; ok {
|
|
one.TaskLimit = task.TaskLimit
|
|
one.DayLimit = task.DayLimit
|
|
one.Chance = task.Chance
|
|
one.LevelIds = task.GetLevelLimit()
|
|
one.LangMarks = task.GetLangMarks()
|
|
one.WeekLimit = task.WeekLimit
|
|
one.WeekNum = int32(task.WeekNum)
|
|
one.HasPre = int32(task.HasPre)
|
|
one.PreCond = task.PreCond
|
|
one.ExpiredMin = task.ExpiredMin
|
|
one.PropMark = task.PropMark
|
|
one.Reward = rewardMap[task.RewardID]
|
|
one.AwardMode = int32(task.AwardMode)
|
|
one.ExpiredDay = one.GetReward().GetExpiredDay()
|
|
}
|
|
|
|
custom.Cond = append(custom.Cond, one)
|
|
}
|
|
|
|
if task, ok := taskMap[mtype.FissionCampaignTaskMarkCondAll]; ok {
|
|
custom.BothAll = &pb.ShowRes_BothAll{
|
|
TaskLimit: task.TaskLimit,
|
|
Chance: task.Chance,
|
|
DayLimit: task.DayLimit,
|
|
LevelIds: task.GetLevelLimit(),
|
|
LangMarks: task.GetLangMarks(),
|
|
WeekLimit: task.WeekLimit,
|
|
WeekNum: int32(task.WeekNum),
|
|
Reward: nil,
|
|
PropMark: task.PropMark,
|
|
ExpiredDay: "",
|
|
}
|
|
|
|
if reward, ok1 := rewardMap[task.RewardID]; ok1 && reward != nil {
|
|
custom.BothAll.Reward = reward
|
|
custom.BothAll.ExpiredDay = reward.ExpiredDay
|
|
}
|
|
|
|
}
|
|
s.Res.TargetOption.Custom = custom
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 目标配置
|
|
s.Res.Target = &pb.ShowRes_Target{
|
|
Target: int32(cpn.Target),
|
|
Option: int32(conf.Option),
|
|
AppEvent: int32(conf.AppEvent),
|
|
BothType: int32(conf.BothType),
|
|
Cond: make([]*pb.ShowRes_Cond, 0, len(list)),
|
|
}
|
|
|
|
for _, v := range list {
|
|
one := &pb.ShowRes_Cond{
|
|
Id: v.ID,
|
|
Event: v.Event,
|
|
EventKey: v.EventKey,
|
|
EventVal: v.EventVal,
|
|
Desc: v.Desc,
|
|
IfCond: int32(v.IfCond),
|
|
TriggerType: int32(v.TriggetType),
|
|
EventType: int32(v.EventType),
|
|
}
|
|
|
|
if task, ok := taskMap[utils.FissionCampaignTaskMarkCondOneVal(v.ID)]; ok {
|
|
one.TaskLimit = task.TaskLimit
|
|
one.Chance = task.Chance
|
|
}
|
|
|
|
s.Res.Target.Cond = append(s.Res.Target.Cond, one)
|
|
}
|
|
|
|
return
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
// 设置玩法特有数据
|
|
func (s *Show) setFission(cpn *model.FissionCampaign) (err error) {
|
|
switch cpn.FissionID {
|
|
case consts.IdPrizeWheel: //大转盘
|
|
return s._setPrizeWheel(cpn)
|
|
case consts.IdSlotMachine: //老虎机
|
|
return s._setSlotMachine(cpn)
|
|
case consts.IdLuckyGrid: //九宫格
|
|
return s._setLuckyGrid(cpn)
|
|
case consts.IdBlindBox: //盲盒
|
|
return s._setBlindBox(cpn)
|
|
case consts.IdReferral: //老带新
|
|
return s._setReferral(cpn)
|
|
case consts.IdPrizeAnswer, consts.IdQa, consts.IdQaAudio, consts.IdQaVideo: //趣味问答
|
|
return s._setPrizeAnswer(cpn)
|
|
case consts.IdPrizeQuiz: //有奖竞猜
|
|
return s._setPrizeQuiz(cpn)
|
|
case consts.IdWinTogether: //老带新
|
|
return s._setWinTogether(cpn)
|
|
case consts.IdSignIn: //签到
|
|
return s._setSignIn(cpn)
|
|
case consts.IdDice: //大富翁
|
|
return s._setDice(cpn)
|
|
case consts.IdGrow: //农场
|
|
return s._setGrow(cpn)
|
|
case consts.IdBallot: //抽签
|
|
return s._setBallot(cpn)
|
|
case consts.IdChop: //砍一刀
|
|
return s._setChop(cpn)
|
|
case consts.IdCash: //现金抽奖
|
|
return s._setCash(cpn)
|
|
case consts.IdFlip: //翻牌活动
|
|
return s._setFlip(cpn)
|
|
case consts.IdKeep: //激励养成
|
|
return s._setKeep(cpn)
|
|
case consts.IdGold: //金币任务
|
|
return s._setGold(cpn)
|
|
case consts.IdCoin: //金币池
|
|
return s._setCoin(cpn)
|
|
case consts.IdVs:
|
|
return s._setVs(cpn)
|
|
case consts.IdUno:
|
|
return s._setUno(cpn)
|
|
case consts.IdGashapon: //扭蛋机
|
|
return s._setGashapon(cpn)
|
|
default:
|
|
|
|
}
|
|
return
|
|
}
|
|
|
|
// 设置赛事竞猜
|
|
func (s *Show) _setPrizeQuiz(cpn *model.FissionCampaign) (err error) {
|
|
|
|
fcq, err := cache.NewCampaignQuiz(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
if fcq == nil {
|
|
return workerr.NotFound("not found quiz")
|
|
}
|
|
|
|
optionM := s.GetDao().FissionCampaignQuizOption
|
|
options, err := optionM.WithContext(s.Ctx).Where(optionM.CampaignID.Eq(cpn.ID), optionM.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
s.Res.Quiz = &pb.ShowRes_Quiz{
|
|
TargetNum: fcq.TargetNum,
|
|
InitChance: fcq.InitChance,
|
|
Chance: fcq.Chance,
|
|
RewardRule: int32(fcq.RewardRule),
|
|
OpenPrize: fcq.OpenPrize,
|
|
Title: fcq.Title,
|
|
OpenType: int32(fcq.OpenType),
|
|
Options: make([]*pb.ShowRes_QuizOption, 0, len(options)),
|
|
TOpen: fcq.TOpen,
|
|
}
|
|
|
|
for _, v := range options {
|
|
s.Res.Quiz.Options = append(s.Res.Quiz.Options, &pb.ShowRes_QuizOption{
|
|
Id: v.ID,
|
|
Title: v.Title,
|
|
ImgUrl: v.ImgURL,
|
|
IsRight: int32(v.IsRight),
|
|
VoteNum: v.VoteNum,
|
|
})
|
|
}
|
|
|
|
return
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
// 大转盘数据
|
|
func (s *Show) _setPrizeWheel(cpn *model.FissionCampaign) error {
|
|
cc := cache.NewCampaignWheel(s.Ctx)
|
|
conf, err := cc.FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
return s.BE().CacheError(err)
|
|
}
|
|
|
|
if conf == nil {
|
|
return workerr.NotFound("not found wheel conf")
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
s.Res.PrizeWheel = &pb.ShowRes_LotteryConfig{
|
|
TargetNum: conf.TargetNum,
|
|
InitChance: conf.InitChance,
|
|
Chance: conf.Chance,
|
|
DayChance: conf.DayChance,
|
|
}
|
|
return
|
|
})
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Show) _setReferral(cpn *model.FissionCampaign) (err error) {
|
|
rfl, err := cache.NewCampaignReferral(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
if rfl == nil {
|
|
return workerr.NotFound("not found")
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
s.Res.Referral = &pb.ShowRes_InviteConfig{
|
|
RewardLimit: rfl.RewardLimit,
|
|
RewardRule: int32(rfl.RewardRule),
|
|
InviteLimit: rfl.InviteLimit,
|
|
StepLoop: int32(rfl.StepLoop),
|
|
}
|
|
|
|
return
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) _setSlotMachine(cpn *model.FissionCampaign) (err error) {
|
|
conf, err := cache.NewCampaignSlot(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
if conf == nil {
|
|
return workerr.NotFound("not found blind conf")
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
s.Res.Slot = &pb.ShowRes_LotteryConfig{
|
|
TargetNum: conf.TargetNum,
|
|
InitChance: conf.InitChance,
|
|
Chance: conf.Chance,
|
|
DayChance: conf.DayChance,
|
|
}
|
|
|
|
return
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) _setLuckyGrid(cpn *model.FissionCampaign) (err error) {
|
|
conf, err := cache.NewCampaignGrid(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
if conf == nil {
|
|
return workerr.NotFound("not found grid conf")
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
s.Res.Grid = &pb.ShowRes_LotteryConfig{
|
|
TargetNum: conf.TargetNum,
|
|
InitChance: conf.InitChance,
|
|
Chance: conf.Chance,
|
|
DayChance: conf.DayChance,
|
|
}
|
|
|
|
return
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) _setBlindBox(cpn *model.FissionCampaign) (err error) {
|
|
conf, err := cache.NewCampaignBlind(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
if conf == nil {
|
|
return workerr.NotFound("not found blind conf")
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
s.Res.Blind = &pb.ShowRes_LotteryConfig{
|
|
TargetNum: conf.TargetNum,
|
|
InitChance: conf.InitChance,
|
|
Chance: conf.Chance,
|
|
DayChance: conf.DayChance,
|
|
}
|
|
|
|
return
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) _setPrizeAnswer(cpn *model.FissionCampaign) (err error) {
|
|
qa, err := cache.NewCampaignQa(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
if qa == nil {
|
|
return workerr.NotFound("not found qa")
|
|
}
|
|
|
|
var (
|
|
questions []*model.FissionCampaignQaQuestion
|
|
options []*model.FissionCampaignQaOption
|
|
qoMap = make(map[int64][]*model.FissionCampaignQaOption)
|
|
groupHashId, guideGroupHashId string
|
|
)
|
|
|
|
if cpn.FissionID == consts.IdPrizeAnswer {
|
|
cqqM := s.GetDao().FissionCampaignQaQuestion
|
|
questions, err = cqqM.WithContext(s.Ctx).Where(cqqM.QaID.Eq(qa.ID), cqqM.IsDel.Eq(mtype.No)).Order(cqqM.Sort).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
var qids []int64
|
|
for _, v := range questions {
|
|
qids = append(qids, v.ID)
|
|
}
|
|
|
|
cqoM := s.GetDao().FissionCampaignQaOption
|
|
options, err = cqoM.WithContext(s.Ctx).Where(cqoM.QuestionID.In(qids...), cqoM.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
for _, v := range options {
|
|
qoMap[v.QuestionID] = append(qoMap[v.QuestionID], v)
|
|
}
|
|
}
|
|
|
|
if qa.QaGroupID > 0 {
|
|
var group *model.LibraryQaGroup
|
|
groupM := s.GetDao().LibraryQaGroup
|
|
group, err = groupM.WithContext(s.Ctx).Where(groupM.ID.Eq(qa.QaGroupID)).Take()
|
|
if err = dbcheck.DbError(err); err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
if group != nil {
|
|
groupHashId = group.HashID
|
|
}
|
|
}
|
|
|
|
if qa.GuideGroupID > 0 {
|
|
var group *model.LibraryQaGroup
|
|
groupM := s.GetDao().LibraryQaGroup
|
|
group, err = groupM.WithContext(s.Ctx).Where(groupM.ID.Eq(qa.GuideGroupID)).Take()
|
|
if err = dbcheck.DbError(err); err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
if group != nil {
|
|
guideGroupHashId = group.HashID
|
|
}
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
|
|
s.Res.QuestionAnswer = &pb.ShowRes_QuestionAnswer{
|
|
TargetNum: qa.TargetNum,
|
|
Chance: qa.Chance,
|
|
InitChance: qa.InitChance,
|
|
QuestionAskTime: qa.QuestionAskTime,
|
|
Questions: make([]*pb.ShowRes_QaQuestion, 0, len(questions)),
|
|
GroupHashId: groupHashId,
|
|
QaNum: qa.QaNum,
|
|
DayChance: qa.DayChance,
|
|
OpenGuide: int32(qa.OpenGuide),
|
|
GuideGroupHashId: guideGroupHashId,
|
|
}
|
|
|
|
for _, v := range questions {
|
|
one := &pb.ShowRes_QaQuestion{
|
|
Id: v.ID,
|
|
Title: v.Title,
|
|
Score: v.Score,
|
|
Options: nil,
|
|
}
|
|
|
|
if ops, ok := qoMap[v.ID]; ok {
|
|
one.Options = make([]*pb.ShowRes_QaOption, 0, len(ops))
|
|
for _, op := range ops {
|
|
one.Options = append(one.Options, &pb.ShowRes_QaOption{
|
|
Id: op.ID,
|
|
Title: op.Title,
|
|
IsRight: int32(op.IsRight),
|
|
})
|
|
}
|
|
}
|
|
|
|
s.Res.QuestionAnswer.Questions = append(s.Res.QuestionAnswer.Questions, one)
|
|
}
|
|
|
|
return
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) _setWinTogether(cpn *model.FissionCampaign) (err error) {
|
|
|
|
fcw, err := cache.NewCampaignWin(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
return s.BE().CacheError(err)
|
|
}
|
|
|
|
if fcw == nil {
|
|
return workerr.NotFound("not found fcw")
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
s.Res.Win = &pb.ShowRes_InviteConfig{
|
|
RewardLimit: fcw.RewardLimit,
|
|
RewardRule: int32(fcw.RewardRule),
|
|
InviteLimit: fcw.InviteLimit,
|
|
NewcomerCond: int32(fcw.NewcomerCond),
|
|
StepLoop: int32(fcw.StepLoop),
|
|
}
|
|
|
|
return
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) _setSignIn(cpn *model.FissionCampaign) (err error) {
|
|
conf, err := cache.NewCampaignSign(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
if conf == nil {
|
|
return workerr.NotFound("not found")
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
s.Res.Sign = &pb.ShowRes_Sign{
|
|
SignType: int32(conf.SignType),
|
|
IsContinue: int32(conf.IsContinue),
|
|
HasCard: int32(conf.HasCard),
|
|
InviteNum: conf.InviteNum,
|
|
LimitCardNum: 0,
|
|
IsLoop: int32(conf.IsLoop),
|
|
SignCycle: conf.SignCycle,
|
|
RecycleType: int32(conf.RecycleType),
|
|
Color: conf.Color,
|
|
}
|
|
|
|
return
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) _setDice(cpn *model.FissionCampaign) (err error) {
|
|
m := s.GetDao().FissionCampaignDice
|
|
fcd, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID)).Take()
|
|
if err = dbcheck.DbError(err); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
if fcd == nil {
|
|
return workerr.NotFound("not found")
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
s.Res.Dice = &pb.ShowRes_Dice{
|
|
InitChance: fcd.InitChance,
|
|
DayChance: fcd.DayChance,
|
|
FixDice: int32(fcd.FixDice),
|
|
FixDiceTarget: fcd.FixDiceTarget,
|
|
FixDiceLimit: fcd.FixDiceLimit,
|
|
CustomDice: fcd.CustomDice,
|
|
OpenMapPoint: int32(fcd.OpenMapPoint),
|
|
MapPoint: &pb.ShowRes_MapPoint{
|
|
Blank: fcd.GetMapPoint().Blank,
|
|
Again: fcd.GetMapPoint().Again,
|
|
Normal: fcd.GetMapPoint().Normal,
|
|
Supper: fcd.GetMapPoint().Supper,
|
|
},
|
|
AwardType: int32(fcd.AwardType),
|
|
OpenInvite: int32(fcd.OpenInvite),
|
|
RollAgain: int32(fcd.RollAgain),
|
|
FixDiceCond: int32(fcd.FixDiceCond),
|
|
Odds: fcd.Odds,
|
|
PlayImg: fcd.PlayImg,
|
|
CloudImg: fcd.CloudImg,
|
|
}
|
|
|
|
return
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) _setGrow(cpn *model.FissionCampaign) (err error) {
|
|
m := s.GetDao().FissionCampaignGrow
|
|
conf, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID)).Take()
|
|
if err = dbcheck.DbError(err); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
if conf == nil {
|
|
return workerr.NotFound("not found")
|
|
}
|
|
|
|
stepM := s.GetDao().FissionCampaignGrowStep
|
|
|
|
steps, err := stepM.WithContext(s.Ctx).Where(stepM.CampaignID.Eq(cpn.ID), stepM.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
s.Res.Grow = &pb.ShowRes_Grow{
|
|
AutoHour: conf.AutoHour,
|
|
AutoNum: conf.AutoNum,
|
|
GrowNum: conf.GrowNum,
|
|
TargetNum: conf.TargetNum,
|
|
Revive: int32(conf.Revive),
|
|
ReviveNum: conf.ReviveNum,
|
|
DieHour: conf.DieHour,
|
|
Steps: make([]*pb.ShowRes_GrowStep, 0, len(steps)),
|
|
InitNum: conf.InitNum,
|
|
}
|
|
|
|
for _, step := range steps {
|
|
s.Res.Grow.Steps = append(s.Res.Grow.Steps, &pb.ShowRes_GrowStep{
|
|
Id: step.ID,
|
|
Num: step.Num,
|
|
})
|
|
}
|
|
|
|
return
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) _setBallot(cpn *model.FissionCampaign) (err error) {
|
|
|
|
conf, err := cache.NewCampaignBallot(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
if conf == nil {
|
|
return workerr.NotFound("not found")
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
s.Res.Ballot = &pb.ShowRes_Ballot{
|
|
InitChance: conf.InitChance,
|
|
DayChance: conf.DayChance,
|
|
}
|
|
|
|
return
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) _setChop(cpn *model.FissionCampaign) (err error) {
|
|
conf, err := cache.NewCampaignChop(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
return s.BE().CacheError(err)
|
|
}
|
|
|
|
if conf == nil {
|
|
return workerr.NotFound("not found chop conf")
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
s.Res.Chop = &pb.ShowRes_Chop{
|
|
ShowBar: int32(conf.ShowBar),
|
|
}
|
|
|
|
return
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
// 设置延迟深度链接数据
|
|
func (s *Show) setDelayLinkData(cpn *model.FissionCampaign) (err error) {
|
|
res, err := app.NewDeepLinkLink().GetCampaignDataList(s.Ctx, &dlinkpb.GetCampaignDataListReq{
|
|
ProjectId: cpn.ProjectID,
|
|
CampaignId: cpn.ID,
|
|
})
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
s.Res.DelayLinkData = make([]*pb.ShowRes_KV, 0, len(res.GetList()))
|
|
for _, v := range res.GetList() {
|
|
s.Res.DelayLinkData = append(s.Res.DelayLinkData, &pb.ShowRes_KV{
|
|
Key: v.GetKey(),
|
|
Value: v.GetVal(),
|
|
})
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 设置奖品数据
|
|
func (s *Show) setReward(cpn *model.FissionCampaign, conf *model.FissionCampaignConfig) (err error) {
|
|
err = s._helpMap(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = s._ruleMap(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
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("temp not found")
|
|
return
|
|
}
|
|
|
|
tempMark := mtype.FissionLangTypeToMark[temp.LangType]
|
|
|
|
m := s.GetDao().FissionCampaignReward
|
|
list, err := m.WithContext(s.Ctx).Where(
|
|
m.CampaignID.Eq(conf.CampaignID),
|
|
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
|
|
}
|
|
|
|
err = s._rewardAddMap(cpn.ID, cpn.TOffset)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s._rewardTaskMap(cpn.ID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
var rewardIds []int64
|
|
var rewardInfoMap = make(map[int64]*provider.RewardInfo)
|
|
var webList, extraList, newcomerList, appList []*model.FissionCampaignReward
|
|
for _, v := range list {
|
|
if _, ok := rewardInfoMap[v.RewardID]; !ok {
|
|
rewardInfoMap[v.RewardID] = nil
|
|
rewardIds = append(rewardIds, v.RewardID)
|
|
}
|
|
|
|
switch v.RewardType {
|
|
case mtype.FissionCampaignRewardTypeApp:
|
|
appList = append(appList, v)
|
|
case mtype.FissionCampaignRewardTypeWeb:
|
|
webList = append(webList, v)
|
|
case mtype.FissionCampaignRewardTypeExtra:
|
|
extraList = append(extraList, v)
|
|
case mtype.FissionCampaignRewardTypeNewcomer:
|
|
newcomerList = append(newcomerList, v)
|
|
}
|
|
}
|
|
|
|
preward, err := provider.NewRewards(s.Ctx, cpn.ProjectID, rewardIds...)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
rewardInfoMap, err = preward.InfoMap()
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
langMark := mtype.FissionLangTypeToMark[cpn.GetLangTypes()[0]]
|
|
|
|
s._appendReward(preward, webList, &s.Res.RewardsWeb, langMark)
|
|
s._appendReward(preward, extraList, &s.Res.RewardsExtra, langMark)
|
|
s._appendReward(preward, newcomerList, &s.Res.RewardsNewcomer, langMark)
|
|
|
|
s.Res.Rewards = &pb.ShowRes_Rewards{
|
|
RewardGroup: int32(conf.RewardGroup),
|
|
Normal: nil,
|
|
UserLevel: nil,
|
|
Langs: nil,
|
|
LangUserLevel: nil,
|
|
}
|
|
|
|
ful := finder.NewFuserLayer(conf)
|
|
|
|
switch conf.RewardGroup {
|
|
case mtype.FissionRewardGroupNormal:
|
|
s._appendReward(preward, appList, &s.Res.Rewards.Normal, langMark)
|
|
case mtype.FissionRewardGroupUserLevel:
|
|
var levelMap = make(map[int64]string)
|
|
levelMap, err = s._getLevelMap(cpn.ProjectID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
dlId := ful.Level().Default
|
|
s.Res.Rewards.UserLevel = &pb.ShowRes_UserLevel{
|
|
DefaultLevelId: dlId,
|
|
DefaultLevelTitle: levelMap[dlId],
|
|
LevelList: nil,
|
|
}
|
|
|
|
var levelIds []int64
|
|
var levelRewardMap = make(map[int64][]*model.FissionCampaignReward)
|
|
for _, v := range appList {
|
|
if _, ok := levelRewardMap[v.LevelID]; !ok {
|
|
levelIds = append(levelIds, v.LevelID)
|
|
}
|
|
|
|
levelRewardMap[v.LevelID] = append(levelRewardMap[v.LevelID], v)
|
|
}
|
|
|
|
s._appendUserLevel(preward, levelIds, levelRewardMap, &s.Res.Rewards.UserLevel.LevelList, langMark)
|
|
case mtype.FissionRewardGroupLang:
|
|
var langMarks []string
|
|
var langRewardMap = make(map[string][]*model.FissionCampaignReward)
|
|
for _, v := range appList {
|
|
if _, ok := langRewardMap[v.LangMark]; !ok {
|
|
langMarks = append(langMarks, v.LangMark)
|
|
}
|
|
langRewardMap[v.LangMark] = append(langRewardMap[v.LangMark], v)
|
|
}
|
|
|
|
s.Res.Rewards.Langs = make([]*pb.ShowRes_Lang, 0, len(langMarks))
|
|
for _, mark := range langMarks {
|
|
one := &pb.ShowRes_Lang{
|
|
LangType: int32(mtype.MarkToLangType[mark]),
|
|
LangMark: mark,
|
|
DefaultLang: mark == tempMark,
|
|
Rewards: nil,
|
|
}
|
|
|
|
s._appendReward(preward, langRewardMap[mark], &one.Rewards, mark)
|
|
s.Res.Rewards.Langs = append(s.Res.Rewards.Langs, one)
|
|
}
|
|
case mtype.FissionRewardGroupLangAndUserLevel:
|
|
dms := ful.LangLevel().Default
|
|
var dmMap = make(map[string]int64)
|
|
for _, dm := range dms {
|
|
dmMap[dm.Lang] = dm.Level
|
|
}
|
|
|
|
var langMarks []string
|
|
var langLevelMap = make(map[string][]int64)
|
|
|
|
var levelRewardMap = make(map[string]map[int64][]*model.FissionCampaignReward)
|
|
for _, v := range appList {
|
|
if _, ok := langLevelMap[v.LangMark]; !ok {
|
|
langMarks = append(langMarks, v.LangMark)
|
|
levelRewardMap[v.LangMark] = make(map[int64][]*model.FissionCampaignReward)
|
|
}
|
|
|
|
if _, ok := levelRewardMap[v.LangMark][v.LevelID]; !ok {
|
|
langLevelMap[v.LangMark] = append(langLevelMap[v.LangMark], v.LevelID)
|
|
}
|
|
|
|
levelRewardMap[v.LangMark][v.LevelID] = append(levelRewardMap[v.LangMark][v.LevelID], v)
|
|
}
|
|
|
|
s.Res.Rewards.LangUserLevel = make([]*pb.ShowRes_LangUserLevel, 0, len(langMarks))
|
|
|
|
var levelMap = make(map[int64]string)
|
|
levelMap, err = s._getLevelMap(cpn.ProjectID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
for _, mark := range langMarks {
|
|
var levelIds = langLevelMap[mark]
|
|
|
|
one := &pb.ShowRes_LangUserLevel{
|
|
LangMark: mark,
|
|
LangType: int32(mtype.MarkToLangType[mark]),
|
|
DefaultLang: mark == tempMark,
|
|
DefaultLevelId: dmMap[mark],
|
|
DefaultLevelTitle: levelMap[dmMap[mark]],
|
|
LevelList: make([]*pb.ShowRes_UserLevelOne, 0, len(levelIds)),
|
|
}
|
|
|
|
s._appendUserLevel(preward, levelIds, levelRewardMap[mark], &one.LevelList, mark)
|
|
s.Res.Rewards.LangUserLevel = append(s.Res.Rewards.LangUserLevel, one)
|
|
}
|
|
case mtype.FissionRewardGroupCountry:
|
|
s.Res.Rewards.Country = &pb.ShowRes_Country{
|
|
DefaultCountryMark: ful.Country().Default,
|
|
CountryList: nil,
|
|
}
|
|
|
|
var countryIds []string
|
|
var countryRewardMap = make(map[string][]*model.FissionCampaignReward)
|
|
for _, v := range appList {
|
|
if _, ok := countryRewardMap[v.CountryMark]; !ok {
|
|
countryIds = append(countryIds, v.CountryMark)
|
|
}
|
|
|
|
countryRewardMap[v.CountryMark] = append(countryRewardMap[v.CountryMark], v)
|
|
}
|
|
|
|
s._appendCountry(preward, countryIds, countryRewardMap, &s.Res.Rewards.Country.CountryList, langMark)
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *Show) _appendReward(preward *provider.Rewards, in []*model.FissionCampaignReward, out *[]*pb.ShowRes_Reward, langMark string) {
|
|
*out = make([]*pb.ShowRes_Reward, 0, len(in))
|
|
|
|
for _, v := range in {
|
|
one := &pb.ShowRes_Reward{
|
|
Id: v.ID,
|
|
RewardId: v.RewardID,
|
|
Stock: v.Stock,
|
|
InviteNum: v.InviteNum,
|
|
RewardNum: v.RewardNum,
|
|
IsThank: int32(v.IsThank),
|
|
Score: v.Score,
|
|
SignDay: v.SignDay,
|
|
CollectNum: v.CollectNum,
|
|
IsSuper: int32(v.IsSuper),
|
|
KvData: nil,
|
|
Title: "",
|
|
ImgUrl: "",
|
|
ReceiveType: 0,
|
|
Contact: "",
|
|
Url: "",
|
|
Help: 0,
|
|
HelpPercent: 0,
|
|
Click: 0,
|
|
ClickPercent: 0,
|
|
ClickPercentLimit: 0,
|
|
Open: 0,
|
|
OpenPercent: 0,
|
|
OpenPercentLimit: 0,
|
|
LangMark: "",
|
|
Odds: v.Odds,
|
|
JumpUrl: v.JumpURL,
|
|
FormTitle: "",
|
|
CampaignLimit: 0,
|
|
Register: 0,
|
|
RegisterPercent: 0,
|
|
InitPercent: v.InitPercent,
|
|
CollectRule: nil,
|
|
OpenAdd: nil,
|
|
RewardTask: nil,
|
|
}
|
|
|
|
if add, ok := s.rewardAddMap[v.ID]; ok {
|
|
one.OpenAdd = add
|
|
one.OpenAdd.Open = int32(v.OpenAdd)
|
|
}
|
|
|
|
if task, ok := s.rewardTaskMap[v.ID]; ok {
|
|
one.RewardTask = task
|
|
one.RewardTask.Open = int32(v.OpenTask)
|
|
}
|
|
|
|
if v.CollectRule != "" {
|
|
collectRule := v.GetCollectRule()
|
|
one.CollectRule = &pb.ShowRes_CollectRule{
|
|
Open: collectRule.Open,
|
|
InitCollect: collectRule.InitCollect,
|
|
SignDay: collectRule.SignDay,
|
|
AddCollect: collectRule.AddCollect,
|
|
ResetType: collectRule.ResetType,
|
|
}
|
|
}
|
|
|
|
info, _ := preward.Info(v.RewardID)
|
|
if info != nil {
|
|
one.ReceiveType = info.ReceiveType
|
|
one.Contact = info.Contact
|
|
one.Url = info.Url
|
|
one.FormTitle = info.FormTitle
|
|
|
|
for _, kv := range info.KvData {
|
|
one.KvData = append(one.KvData, &pb.ShowRes_KV{
|
|
Key: kv.Key,
|
|
Value: kv.Value,
|
|
})
|
|
}
|
|
}
|
|
|
|
lang := preward.AutoLang(v.RewardID, langMark)
|
|
one.Title, one.ImgUrl, one.LangMark = lang.Title, lang.ImgUrl, lang.Mark
|
|
|
|
for _, help := range s.helpMap[v.ID] {
|
|
switch help.TaskType {
|
|
case mtype.FissionCampaignTaskTypeInstall:
|
|
one.Help = mtype.Yes
|
|
one.HelpPercent = help.Percent
|
|
case mtype.FissionCampaignTaskTypeOpen:
|
|
one.Open = mtype.Yes
|
|
one.OpenPercent = help.Percent
|
|
one.OpenPercentLimit = help.PercentLimit
|
|
case mtype.FissionCampaignTaskTypeClick:
|
|
one.Click = mtype.Yes
|
|
one.ClickPercent = help.Percent
|
|
one.ClickPercentLimit = help.PercentLimit
|
|
case mtype.FissionCampaignTaskTypeRegister:
|
|
one.Register = mtype.Yes
|
|
one.RegisterPercent = help.Percent
|
|
}
|
|
}
|
|
|
|
if rule, ok := s.ruleMap[v.ID]; ok {
|
|
one.CampaignLimit = rule.CampaignLimit
|
|
}
|
|
|
|
*out = append(*out, one)
|
|
}
|
|
}
|
|
|
|
func (s *Show) _rewardAddMap(campaignID int64, tOffset int32) (err error) {
|
|
m := s.GetDao().FissionCampaignRewardAdd
|
|
list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(campaignID), m.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
s.rewardAddMap = make(map[int64]*pb.ShowRes_OpenAdd, len(list))
|
|
for _, v := range list {
|
|
s.rewardAddMap[v.RewardID] = &pb.ShowRes_OpenAdd{
|
|
Start: timez.STZ(v.Start, tOffset),
|
|
End: timez.STZ(v.End, tOffset),
|
|
DayNum: v.DayNum,
|
|
DayAdd: v.DayAdd,
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) _rewardTaskMap(campaignID int64) (err error) {
|
|
m := s.GetDao().FissionCampaignCond
|
|
list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(campaignID), m.IsDel.Eq(mtype.No), m.RewardID.Gt(0)).Find()
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
s.rewardTaskMap = make(map[int64]*pb.ShowRes_RewardTask, len(list))
|
|
for _, v := range list {
|
|
s.rewardTaskMap[v.RewardID] = &pb.ShowRes_RewardTask{
|
|
Event: v.Event,
|
|
EventKey: v.EventKey,
|
|
EventVal: v.EventVal,
|
|
IfCond: int32(v.IfCond),
|
|
TriggerType: int32(v.TriggetType),
|
|
EventType: int32(v.EventType),
|
|
OpenPush: int32(v.OpenPush),
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) _appendUserLevel(preward *provider.Rewards, levelIds []int64, levelRewardMap map[int64][]*model.FissionCampaignReward, out *[]*pb.ShowRes_UserLevelOne, langMark string) {
|
|
*out = make([]*pb.ShowRes_UserLevelOne, 0, len(levelIds))
|
|
|
|
levelMap, _ := s._getLevelMap(preward.GetProjectId())
|
|
|
|
for _, id := range levelIds {
|
|
one := &pb.ShowRes_UserLevelOne{
|
|
LevelId: id,
|
|
LevelTitle: levelMap[id],
|
|
Rewards: nil,
|
|
}
|
|
|
|
s._appendReward(preward, levelRewardMap[id], &one.Rewards, langMark)
|
|
*out = append(*out, one)
|
|
}
|
|
}
|
|
|
|
func (s *Show) _appendCountry(preward *provider.Rewards, countryMarks []string, countryRewardMap map[string][]*model.FissionCampaignReward, out *[]*pb.ShowRes_CountryOne, langMark string) {
|
|
*out = make([]*pb.ShowRes_CountryOne, 0, len(countryMarks))
|
|
for _, id := range countryMarks {
|
|
one := &pb.ShowRes_CountryOne{
|
|
CountryMark: id,
|
|
Rewards: nil,
|
|
}
|
|
|
|
s._appendReward(preward, countryRewardMap[id], &one.Rewards, langMark)
|
|
*out = append(*out, one)
|
|
}
|
|
}
|
|
|
|
func (s *Show) _getLevelMap(projectId int64) (data map[int64]string, err error) {
|
|
|
|
if s.levelMap != nil {
|
|
return s.levelMap, nil
|
|
}
|
|
|
|
m := s.GetDao().FissionUserLevel
|
|
list, err := m.WithContext(s.Ctx).Where(m.ProjectID.Eq(projectId), m.DeletedAt.Eq(0)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
data = make(map[int64]string, len(list))
|
|
for _, v := range list {
|
|
data[v.ID] = v.Title
|
|
}
|
|
|
|
s.levelMap = data
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) _helpMap(cpn *model.FissionCampaign) (err error) {
|
|
var helpMap = make(map[int64][]*model.FissionCampaignTask)
|
|
|
|
defer func() {
|
|
s.helpMap = helpMap
|
|
}()
|
|
|
|
if cpn.FissionID != consts.IdChop {
|
|
return
|
|
}
|
|
|
|
helpM := s.GetDao().FissionCampaignTask
|
|
helps, err := helpM.WithContext(s.Ctx).Where(helpM.CampaignID.Eq(cpn.ID), helpM.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
for _, v := range helps {
|
|
rewardId := utils.FissionCampaignTaskMarkRewardOneRewardId(v.TaskMark)
|
|
if rewardId <= 0 {
|
|
continue
|
|
}
|
|
|
|
helpMap[rewardId] = append(helpMap[rewardId], v)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) _ruleMap(cpn *model.FissionCampaign) (err error) {
|
|
ruleM := s.GetDao().FissionCampaignRewardRule
|
|
rules, err := ruleM.WithContext(s.Ctx).Where(ruleM.CampaignID.Eq(cpn.ID)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
var ruleMap = make(map[int64]*model.FissionCampaignRewardRule, len(rules))
|
|
for _, v := range rules {
|
|
ruleMap[v.RewardID] = v
|
|
}
|
|
|
|
s.ruleMap = ruleMap
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) _setCash(cpn *model.FissionCampaign) (err error) {
|
|
conf, err := cache.NewCampaignCash(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
if conf == nil {
|
|
return workerr.NotFound("not found")
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
s.Res.Cash = &pb.ShowRes_Cash{
|
|
ExpiredDay: conf.ExpiredDay,
|
|
Price: conf.Price,
|
|
PriceNum: conf.PriceNum,
|
|
SpinCash: make([]*pb.ShowRes_SpinCash, 0, len(consts.FissionCashSpin)),
|
|
Lack: int32(conf.Lack),
|
|
Currency: int32(conf.Currency),
|
|
LoopNum: conf.LoopNum,
|
|
}
|
|
|
|
for _, v := range consts.FissionCashSpin {
|
|
s.Res.Cash.SpinCash = append(s.Res.Cash.SpinCash, &pb.ShowRes_SpinCash{
|
|
Id: v.Id,
|
|
Cash: v.Cash,
|
|
})
|
|
}
|
|
|
|
return
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) _setFlip(cpn *model.FissionCampaign) (err error) {
|
|
conf, err := cache.NewCampaignFlip(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
if conf == nil {
|
|
return workerr.NotFound("not found flip conf")
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
s.Res.Flip = &pb.ShowRes_Flip{
|
|
InitChance: conf.InitChance,
|
|
CardImg: conf.CardImg,
|
|
DayChance: conf.DayChance,
|
|
}
|
|
|
|
return
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) _setKeep(cpn *model.FissionCampaign) (err error) {
|
|
conf, err := cache.NewCampaignKeep(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
if conf == nil {
|
|
return workerr.NotFound("not found conf")
|
|
}
|
|
|
|
m := s.GetDao().FissionCampaignKeepStep
|
|
steps, 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)
|
|
return
|
|
}
|
|
|
|
var rewardIds []int64
|
|
for _, v := range steps {
|
|
if v.RewardID > 0 {
|
|
rewardIds = append(rewardIds, v.RewardID)
|
|
}
|
|
}
|
|
|
|
var rewardMap = make(map[int64]*pb.ShowRes_Reward)
|
|
if len(rewardIds) > 0 {
|
|
rewardM := s.GetDao().FissionCampaignReward
|
|
var rewardList []*model.FissionCampaignReward
|
|
rewardList, err = rewardM.WithContext(s.Ctx).Where(rewardM.ID.In(rewardIds...)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var bIds []int64
|
|
for _, v := range rewardList {
|
|
bIds = append(bIds, v.RewardID)
|
|
}
|
|
|
|
brewards, _ := provider.NewRewards(s.Ctx, cpn.ProjectID, bIds...)
|
|
for _, v := range rewardList {
|
|
info, _ := brewards.InfoAutoLang(v.RewardID)
|
|
rewardMap[v.ID] = &pb.ShowRes_Reward{
|
|
Id: v.ID,
|
|
RewardId: v.RewardID,
|
|
Stock: v.Stock,
|
|
RewardNum: v.RewardNum,
|
|
Title: info.RewardTitle,
|
|
ImgUrl: info.ImgUrl,
|
|
ReceiveType: info.ReceiveType,
|
|
Contact: info.Contact,
|
|
Url: info.Url,
|
|
FormTitle: info.FormTitle,
|
|
LangMark: info.Mark,
|
|
}
|
|
|
|
for _, datum := range info.KvData {
|
|
rewardMap[v.ID].KvData = append(rewardMap[v.ID].KvData, &pb.ShowRes_KV{
|
|
Key: datum.Key,
|
|
Value: datum.Value,
|
|
})
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
s.Res.KeepDog = &pb.ShowRes_Keep{
|
|
Collect: conf.Collect,
|
|
CollectSecond: conf.CollectSecond,
|
|
OpenInvite: int32(conf.OpenInvite),
|
|
Invite: nil,
|
|
InitGet: conf.InitGet,
|
|
SecGet: conf.SecGet,
|
|
FeedNum: conf.FeedNum,
|
|
FeedCycle: conf.FeedCycle,
|
|
MaxFeed: conf.MaxFeed,
|
|
FeedGet: conf.FeedGet,
|
|
FeedGetNum: conf.FeedGetNum,
|
|
TalkText: nil,
|
|
Steps: make([]*pb.ShowRes_KeepStep, 0, len(steps)),
|
|
SecGetDayLimit: conf.SecGetDayLimit,
|
|
MachineType: int32(conf.MachineType),
|
|
OfflineMin: conf.OfflineMin,
|
|
OfflineGet: conf.OfflineGet,
|
|
OfflineLimit: conf.OfflineLimit,
|
|
}
|
|
|
|
_ = jsonm.StrUnmarshal(conf.Invite, &s.Res.KeepDog.Invite)
|
|
_ = jsonm.StrUnmarshal(conf.TalkText, &s.Res.KeepDog.TalkText)
|
|
|
|
for _, v := range steps {
|
|
s.Res.KeepDog.Steps = append(s.Res.KeepDog.Steps, &pb.ShowRes_KeepStep{
|
|
Step: v.Step,
|
|
Percent: v.Percent,
|
|
RewardType: int32(v.RewardType),
|
|
Reward: rewardMap[v.RewardID],
|
|
RewardNum: v.RewardNum,
|
|
})
|
|
}
|
|
|
|
return
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) setPush(cpn *model.FissionCampaign) (err error) {
|
|
m := s.GetDao().FissionCampaignPush
|
|
list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
s.Res.Push = &pb.ShowRes_Push{}
|
|
|
|
for _, v := range list {
|
|
if v.Open == mtype.No {
|
|
continue
|
|
}
|
|
switch v.Mark {
|
|
case mtype.FissionCampaignPushMarkActive:
|
|
s.Res.Push.Active = &pb.ShowRes_PushOne{
|
|
Open: mtype.Yes,
|
|
PushCond: nil,
|
|
}
|
|
|
|
_ = jsonm.StrUnmarshal(v.Cond, &s.Res.Push.Active.PushCond)
|
|
case mtype.FissionCampaignPushMarkTaskReset:
|
|
s.Res.Push.TaskReset = &pb.ShowRes_PushOne{
|
|
Open: mtype.Yes,
|
|
PushCond: nil,
|
|
}
|
|
|
|
_ = jsonm.StrUnmarshal(v.Cond, &s.Res.Push.TaskReset.PushCond)
|
|
|
|
case mtype.FissionCampaignPushMarkOffline:
|
|
s.Res.Push.Offline = &pb.ShowRes_PushOne{
|
|
Open: mtype.Yes,
|
|
PushCond: nil,
|
|
}
|
|
|
|
_ = jsonm.StrUnmarshal(v.Cond, &s.Res.Push.Offline.PushCond)
|
|
case mtype.FissionCampaignPushMarkVisit:
|
|
s.Res.Push.Visit = &pb.ShowRes_PushOne{
|
|
Open: mtype.Yes,
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) setChild(cpn *model.FissionCampaign) (err error) {
|
|
m := s.GetDao().FissionCampaignChild
|
|
list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
if len(list) == 0 {
|
|
return
|
|
}
|
|
|
|
var ids []int64
|
|
for _, v := range list {
|
|
ids = append(ids, v.ChildID)
|
|
}
|
|
|
|
cpnM := s.GetDao().FissionCampaign
|
|
childs, err := cpnM.WithContext(s.Ctx).Where(cpnM.ID.In(ids...)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
s.Res.Child = make([]*pb.ShowRes_Child, 0, len(childs))
|
|
|
|
for _, v := range childs {
|
|
s.Res.Child = append(s.Res.Child, &pb.ShowRes_Child{
|
|
HashId: v.HashID,
|
|
ChildType: int32(v.ChildType),
|
|
})
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) _setGold(cpn *model.FissionCampaign) (err error) {
|
|
conf, err := cache.NewCampaignGold(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
if conf == nil {
|
|
return workerr.NotFound("not found gold conf")
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
s.Res.Gold = &pb.ShowRes_Gold{
|
|
GoldNum: conf.GoldNum,
|
|
ExpiredDay: conf.ExpiredDay,
|
|
Price: conf.Price,
|
|
PriceNum: conf.PriceNum,
|
|
Currency: int32(conf.Currency),
|
|
SpinCash: make([]*pb.ShowRes_SpinCash, 0, len(consts.FissionCashSpin)),
|
|
Lack: int32(conf.Lack),
|
|
}
|
|
|
|
for _, v := range consts.FissionCashSpin {
|
|
s.Res.Gold.SpinCash = append(s.Res.Gold.SpinCash, &pb.ShowRes_SpinCash{
|
|
Id: v.Id,
|
|
Cash: v.Cash,
|
|
})
|
|
}
|
|
|
|
return
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) _setCoin(cpn *model.FissionCampaign) (err error) {
|
|
conf, err := cache.NewCampaignCoin(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
if conf == nil {
|
|
return workerr.NotFound("not found gold conf")
|
|
}
|
|
|
|
var customBtnId int64
|
|
if verify.InArray[int32](mtype.FissionCampaignCoinLackBtnCustom, conf.GetLackBtn()...) {
|
|
var customBtn *model.FissionCustomBtn
|
|
customBtn, err = cache.NewFissionCustomBtn(s.Ctx).FindByUniq(cpn.ID, conf.CustomBtnText)
|
|
if err != nil {
|
|
return s.BE().CacheError(err)
|
|
}
|
|
|
|
if customBtn != nil {
|
|
customBtnId = customBtn.ID
|
|
}
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
s.Res.Coin = &pb.ShowRes_Coin{
|
|
CoinImg: conf.CoinImg,
|
|
OpenDays: conf.OpenDays,
|
|
OpenLimit: conf.OpenLimit,
|
|
InitCoin: conf.InitCoin,
|
|
InitUse: conf.InitUse,
|
|
UseCoin: conf.UseCoin,
|
|
UseLimit: conf.UseLimit,
|
|
UrlId: conf.URLID,
|
|
LackBtn: conf.GetLackBtn(),
|
|
CustomBtnText: conf.CustomBtnText,
|
|
CustomWebUrl: conf.CustomWebURL,
|
|
CustomExtraParam: conf.CustomExtraParam,
|
|
CustomBtnId: customBtnId,
|
|
CustomPcParam: conf.CustomPcParam,
|
|
}
|
|
|
|
return
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) _setVs(cpn *model.FissionCampaign) (err error) {
|
|
conf, err := cache.NewCampaignVs(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
if conf == nil {
|
|
return workerr.NotFound("not found vs conf")
|
|
}
|
|
|
|
m := s.GetDao().FissionCampaignVsSchedule
|
|
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
|
|
rewards, 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(rewards))
|
|
for _, v := range rewards {
|
|
rewardMap[v.ID] = v
|
|
}
|
|
|
|
teamM := s.GetDao().FissionCampaignVsTeam
|
|
teams, 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(teams))
|
|
for _, v := range teams {
|
|
teamMap[v.ID] = v
|
|
}
|
|
|
|
var scheduleMap = make(map[int32][]*pb.ShowRes_PkTeam)
|
|
for _, v := range list {
|
|
one := &pb.ShowRes_PkTeam{
|
|
Id: v.ID,
|
|
Teams: nil,
|
|
VoteStart: v.VoteStart,
|
|
VoteEnd: v.VoteEnd,
|
|
VsAt: v.VsAt,
|
|
VsImg: v.VsImg,
|
|
Desc: v.Desc,
|
|
PropMark: "",
|
|
RewardId: 0,
|
|
PropNum: 0,
|
|
ExpiredDay: "",
|
|
IsSettlement: int32(v.IsSettlement),
|
|
OtherVote: v.GetOtherVote(),
|
|
OpenOdds: int32(v.OpenOdds),
|
|
OddsLeft: v.OddsLeft,
|
|
OddsRight: v.OddsRight,
|
|
OddsDraw: v.OddsDraw,
|
|
Status: v.GetStatus(),
|
|
}
|
|
|
|
for _, id := range v.GetVsTeamIds() {
|
|
if team, ok := teamMap[id]; ok {
|
|
one.Teams = append(one.Teams, &pb.ShowRes_Team{
|
|
Id: team.ID,
|
|
Name: team.Name,
|
|
LogoImg: team.LogoImg,
|
|
})
|
|
} else {
|
|
one.Teams = append(one.Teams, &pb.ShowRes_Team{
|
|
Id: -1,
|
|
})
|
|
}
|
|
}
|
|
|
|
if reward, ok := rewardMap[v.RewardID]; ok {
|
|
one.PropMark = reward.PropMark
|
|
one.RewardId = reward.RewardID
|
|
one.PropNum = reward.RewardNum
|
|
one.ExpiredDay = reward.ExpiredDay
|
|
}
|
|
|
|
scheduleMap[v.VsIdx] = append(scheduleMap[v.VsIdx], one)
|
|
}
|
|
|
|
var schedules = make([]*pb.ShowRes_Schedule, len(scheduleMap))
|
|
for k, v := range scheduleMap {
|
|
schedules[k] = &pb.ShowRes_Schedule{
|
|
Id: k,
|
|
PkTeams: v,
|
|
}
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
s.Res.Vs = &pb.ShowRes_Vs{
|
|
InitChance: conf.InitChance,
|
|
EachLimitNum: conf.EachLimitNum,
|
|
OpenPoint: int32(conf.OpenPoint),
|
|
PointsNum: conf.PointsNum,
|
|
MallOpen: int32(conf.MallOpen),
|
|
MallId: conf.MallID,
|
|
VsTz: conf.VsTz,
|
|
ClaimType: int32(conf.ClaimType),
|
|
Schedules: schedules,
|
|
IconMall: conf.IconMall,
|
|
IconReward: conf.IconReward,
|
|
IconSchedule: conf.IconSchedule,
|
|
}
|
|
return
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) _setUno(cpn *model.FissionCampaign) (err error) {
|
|
conf, err := cache.NewCampaignUno(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
if conf == nil {
|
|
return workerr.NotFound("not found uno conf")
|
|
}
|
|
|
|
m := s.GetDao().FissionCampaignUnoGroup
|
|
groups, 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 _, group := range groups {
|
|
rewardIds = append(rewardIds, group.RewardID)
|
|
}
|
|
|
|
rewardM := s.GetDao().FissionCampaignReward
|
|
rewards, err := rewardM.WithContext(s.Ctx).Where(rewardM.ID.In(rewardIds...)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var bids []int64
|
|
var rewardMap = make(map[int64]*model.FissionCampaignReward, len(rewards))
|
|
for _, v := range rewards {
|
|
rewardMap[v.ID] = v
|
|
bids = append(bids, v.RewardID)
|
|
}
|
|
|
|
preward, err := provider.NewRewards(s.Ctx, cpn.ProjectID, bids...)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
langMark := mtype.FissionLangTypeToMark[cpn.GetLangTypes()[0]]
|
|
|
|
cardM := s.GetDao().FissionCampaignUnoCard
|
|
cards, err := cardM.WithContext(s.Ctx).Where(cardM.CampaignID.Eq(cpn.ID)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var cardMap = make(map[string][]*model.FissionCampaignUnoCard)
|
|
for _, v := range cards {
|
|
cardMap[v.Mark] = append(cardMap[v.Mark], v)
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
s.Res.Uno = &pb.ShowRes_Uno{
|
|
InitChance: conf.InitChance,
|
|
PropMarks: conf.GetPropMarks(),
|
|
Red: nil,
|
|
Yellow: nil,
|
|
Blue: nil,
|
|
Green: nil,
|
|
}
|
|
|
|
for _, v := range groups {
|
|
lr := v.GetLimitRule()
|
|
g := &pb.ShowRes_UnoGroup{
|
|
Id: v.ID,
|
|
Odds: v.Odds,
|
|
Reward: nil,
|
|
OpenRule: int32(v.OpenRule),
|
|
LimitRule: &pb.ShowRes_UnoLimitRule{
|
|
InitNum: lr.InitNum,
|
|
SignDay: lr.SignDay,
|
|
AddNum: lr.AddNum,
|
|
ResetType: lr.ResetType,
|
|
},
|
|
CustomCard: int32(v.CustomCard),
|
|
Cards: make([]*pb.ShowRes_UnoCard, 0, len(cardMap[v.Mark])),
|
|
}
|
|
|
|
for _, cd := range cardMap[v.Mark] {
|
|
g.Cards = append(g.Cards, &pb.ShowRes_UnoCard{
|
|
Id: cd.ID,
|
|
Title: cd.Title,
|
|
ImgUrl: cd.ImgURL,
|
|
WebUrl: cd.WebURL,
|
|
AppParam: cd.AppParam,
|
|
PcParam: cd.PcParam,
|
|
CardNo: cd.CardNo,
|
|
})
|
|
}
|
|
|
|
if r, ok := rewardMap[v.RewardID]; ok {
|
|
info, _ := preward.InfoAutoLang(r.RewardID, langMark)
|
|
g.Reward = &pb.ShowRes_Reward{
|
|
Id: r.ID,
|
|
RewardId: r.RewardID,
|
|
Stock: r.Stock,
|
|
RewardNum: r.RewardNum,
|
|
KvData: make([]*pb.ShowRes_KV, 0, len(info.KvData)),
|
|
Title: info.Title,
|
|
ImgUrl: info.ImgUrl,
|
|
ReceiveType: info.ReceiveType,
|
|
Contact: info.Contact,
|
|
Url: info.Url,
|
|
FormTitle: info.FormTitle,
|
|
}
|
|
for _, datum := range info.KvData {
|
|
g.Reward.KvData = append(g.Reward.KvData, &pb.ShowRes_KV{
|
|
Key: datum.Key,
|
|
Value: datum.Value,
|
|
})
|
|
}
|
|
}
|
|
|
|
switch v.Mark {
|
|
case mtype.FissionCampaignUnoGroupRed:
|
|
s.Res.Uno.Red = g
|
|
case mtype.FissionCampaignUnoGroupYellow:
|
|
s.Res.Uno.Yellow = g
|
|
case mtype.FissionCampaignUnoGroupBlue:
|
|
s.Res.Uno.Blue = g
|
|
case mtype.FissionCampaignUnoGroupGreen:
|
|
s.Res.Uno.Green = g
|
|
}
|
|
}
|
|
|
|
return
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) setEvent(cpn *model.FissionCampaign) (err error) {
|
|
|
|
m := s.GetDao().FissionCampaignEvent
|
|
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 {
|
|
for _, reward := range v.GetRewards() {
|
|
if reward.RewardId > 0 {
|
|
rewardIds = append(rewardIds, reward.RewardId)
|
|
}
|
|
}
|
|
}
|
|
|
|
rewardM := s.GetDao().FissionCampaignReward
|
|
rewards, 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(rewards))
|
|
var brids []int64
|
|
for _, v := range rewards {
|
|
brids = append(brids, v.RewardID)
|
|
rewardMap[v.ID] = v
|
|
}
|
|
|
|
var preward *provider.Rewards
|
|
if len(brids) > 0 {
|
|
preward, err = provider.NewRewards(s.Ctx, cpn.ProjectID, brids...)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
|
|
s.Res.Event = &pb.ShowRes_Event{}
|
|
|
|
var fn = func(rewards []*mtype.EventReward) []*pb.ShowRes_EventReward {
|
|
|
|
r := make([]*pb.ShowRes_EventReward, 0, len(rewards))
|
|
for _, v := range rewards {
|
|
var reward *pb.ShowRes_Reward
|
|
|
|
switch v.PropMark {
|
|
case mtype.FissionCampaignRewardPropMarkReward:
|
|
cr := rewardMap[v.RewardId]
|
|
info, _ := preward.InfoAutoLang(cr.RewardID, cpn.GetLangMarks()[0])
|
|
reward = &pb.ShowRes_Reward{
|
|
Id: cr.ID,
|
|
RewardId: cr.RewardID,
|
|
Stock: cr.Stock,
|
|
RewardNum: cr.RewardNum,
|
|
KvData: make([]*pb.ShowRes_KV, 0, len(info.KvData)),
|
|
Title: info.Title,
|
|
ImgUrl: info.ImgUrl,
|
|
ReceiveType: info.ReceiveType,
|
|
Contact: info.Contact,
|
|
Url: info.Url,
|
|
FormTitle: info.FormTitle,
|
|
}
|
|
|
|
for _, v := range info.KvData {
|
|
reward.KvData = append(reward.KvData, &pb.ShowRes_KV{
|
|
Key: v.Key,
|
|
Value: v.Value,
|
|
})
|
|
}
|
|
|
|
case mtype.FissionCampaignRewardPropMarkPoint:
|
|
cr := rewardMap[v.RewardId]
|
|
reward = &pb.ShowRes_Reward{
|
|
Id: cr.ID,
|
|
RewardId: cr.RewardID,
|
|
Stock: cr.Stock,
|
|
RewardNum: cr.RewardNum,
|
|
ExpiredDay: cr.ExpiredDay,
|
|
}
|
|
case mtype.FissionCampaignRewardPropMarkChance:
|
|
|
|
}
|
|
|
|
r = append(r, &pb.ShowRes_EventReward{
|
|
Id: reward.GetId(),
|
|
PropMark: v.PropMark,
|
|
Reward: reward,
|
|
Chance: v.Chance,
|
|
ExpiredDay: reward.GetExpiredDay(),
|
|
})
|
|
}
|
|
|
|
return r
|
|
}
|
|
|
|
for _, v := range list {
|
|
one := &pb.ShowRes_EventOne{
|
|
Open: int32(v.Open),
|
|
Rewards: fn(v.GetRewards()),
|
|
}
|
|
switch v.Mark {
|
|
case mtype.FissionCampaignEventMarkFirstVisit:
|
|
s.Res.Event.FirstVisit = one
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Show) _setGashapon(cpn *model.FissionCampaign) (err error) {
|
|
conf, err := cache.NewCampaignGashapon(s.Ctx).FindByCampaignId(cpn.ID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
if conf == nil {
|
|
return workerr.NotFound("not found blind conf")
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
s.Res.Gashapon = &pb.ShowRes_LotteryConfig{
|
|
InitChance: conf.InitChance,
|
|
DayChance: conf.DayChance,
|
|
}
|
|
|
|
return
|
|
})
|
|
|
|
return
|
|
|
|
}
|