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.
3511 lines
95 KiB
Go
3511 lines
95 KiB
Go
package campaign
|
|
|
|
import (
|
|
"joybuywork/internal/app"
|
|
"joybuywork/internal/consts"
|
|
"joybuywork/internal/plugins/hashid"
|
|
"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/repository/withdefault"
|
|
"joybuywork/internal/service/cmm"
|
|
"joybuywork/internal/service/provider"
|
|
"joybuywork/internal/service/provider/malls"
|
|
"joybuywork/internal/service/queue/producer"
|
|
"joybuywork/internal/service/queue/types"
|
|
"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"
|
|
"strings"
|
|
"time"
|
|
|
|
dlinkpb "gits.branchcn.com/backend/deeplink/proto/go_proto/dlink"
|
|
linkpb "gits.branchcn.com/backend/shortlink/proto/go_proto/link"
|
|
)
|
|
|
|
type Store struct {
|
|
logic.Logic
|
|
Req *pb.StoreReq
|
|
Res *pb.StoreRes
|
|
|
|
project *model.Project
|
|
temp *model.FissionTemp
|
|
group *model.FissionTempGroup
|
|
|
|
appMark, webMark string
|
|
otherReward []*model.FissionCampaignReward
|
|
otherRelateIds []int64
|
|
otherRelateMap map[int64]struct{}
|
|
|
|
helpInstall, helpRegister, helpOpen, helpClick bool
|
|
|
|
langSourceMap map[string]int64
|
|
|
|
rewardAdd map[int64]*pb.StoreReq_OpenAdd
|
|
rewardTask map[int64]*pb.StoreReq_RewardTask
|
|
}
|
|
|
|
func (s *Store) Run() error {
|
|
return logic.Run(s)
|
|
}
|
|
|
|
func (s *Store) Exec() (err error) {
|
|
err = s.depend()
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
cpn, err := s.create()
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.createConfig(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.createDefault(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.createFission(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.createEvent(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.createReward(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.createRewardAdd(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.createRewardTask(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.createPush(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.createChild(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.copyLangs(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.createLink(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.syncEvent(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s.saveDelayLinkData(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 创建活动
|
|
func (s *Store) create() (cpn *model.FissionCampaign, err error) {
|
|
cpn = withdefault.FissionCampaign(&model.FissionCampaign{
|
|
FissionID: s.temp.FissionID,
|
|
ProjectID: s.project.ID,
|
|
CreatorID: s.Req.GetUserId(),
|
|
TemplateID: s.temp.ID,
|
|
Title: s.Req.GetTitle(),
|
|
StartTime: timez.GMT(s.Req.GetStartTime(), s.Req.GetTOffset()),
|
|
EndTime: timez.GMT(s.Req.GetEndTime(), s.Req.GetTOffset()),
|
|
CoverURL: s.Req.GetCoverUrl(),
|
|
TOffset: s.Req.GetTOffset(),
|
|
TStart: s.Req.GetStartTime(),
|
|
TEnd: s.Req.GetEndTime(),
|
|
Target: utils.Ternary[int8](
|
|
verify.InArray(s.temp.FissionID, consts.IdDice, consts.IdCash, consts.IdGrow),
|
|
int8(s.Req.GetTargetOption().GetTarget()),
|
|
int8(s.Req.GetTarget().GetTarget()),
|
|
),
|
|
ReportType: mtype.FissionCampaignReportTypeNew,
|
|
})
|
|
|
|
cpn.SetLangTypes([]int8{s.temp.LangType})
|
|
|
|
if s.Req.GetCoverUrl() == "" {
|
|
cpn.CoverURL = s.group.CoverURL
|
|
}
|
|
|
|
// 已经开始了活动
|
|
if cpn.StartTime <= time.Now().Unix() {
|
|
cpn.Status = utils.Ternary[int8](s.Req.GetConfig().GetHasWhite() == mtype.Yes, mtype.FissionCampaignStatusPubPre, mtype.FissionCampaignStatusPub)
|
|
if cpn.FissionID == consts.IdDice {
|
|
s.AddAfterRun(func() (err error) {
|
|
producer.NewCampaignNotice(s.Ctx).CampaignDiceMap(types.CampaignDiceMap{CampaignId: cpn.ID})
|
|
return
|
|
})
|
|
}
|
|
}
|
|
|
|
m := s.GetDao().FissionCampaign
|
|
|
|
if err = m.WithContext(s.Ctx).Create(cpn); err != nil {
|
|
return nil, s.BE().MysqlError(err)
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
s.Res.Id = cpn.ID
|
|
s.Res.HashId = cpn.HashID
|
|
return
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
// 创建配置
|
|
func (s *Store) createConfig(cpn *model.FissionCampaign) (err error) {
|
|
// 一般配置
|
|
var reqConf = s.Req.GetConfig()
|
|
var target = s.Req.GetTarget()
|
|
|
|
conf := withdefault.FissionCampaignConfig(&model.FissionCampaignConfig{
|
|
CampaignID: cpn.ID,
|
|
RuleTextColor: reqConf.GetRuleTextColor(),
|
|
RuleBgColor: reqConf.GetRuleBgColor(),
|
|
ShareText: reqConf.GetShareText(),
|
|
ShareImg: reqConf.GetShareImg(),
|
|
HasRank: int8(reqConf.HasRank),
|
|
RankBackgroundColor: reqConf.GetRankBackgroundColor(),
|
|
RankTextColor: reqConf.GetRankTextColor(),
|
|
DownloadPageImage: reqConf.GetDownloadPageImage(),
|
|
IsDefaultDownload: int8(reqConf.GetIsDefaultDownload()),
|
|
WechatPageImage: reqConf.GetWechatPageImage(),
|
|
IsDefaultWechat: int8(reqConf.GetIsDefaultWechat()),
|
|
ImageMain: reqConf.GetImageMain(),
|
|
IsDefaultMain: int8(reqConf.GetIsDefaultMain()),
|
|
ImagePreview: reqConf.GetImagePreview(),
|
|
LinkBtnTextColor: reqConf.GetLinkBtnTextColor(),
|
|
LinkBtnBgColor: reqConf.GetLinkBtnBgColor(),
|
|
LinkTextColor: reqConf.GetLinkTextColor(),
|
|
ShowShare: int8(reqConf.GetShowShare()),
|
|
Share: "",
|
|
CampaignData: "",
|
|
PageTitle: reqConf.GetPageTitle(),
|
|
DmShow: int8(reqConf.GetDmShow()),
|
|
HasWeb: utils.Ternary[int8](len(s.Req.GetRewardsWeb()) > 0, mtype.Yes, mtype.No),
|
|
WebBgImg: reqConf.GetWebBgImg(),
|
|
HasWarmUp: int8(reqConf.GetHasWarmUp()),
|
|
WarmUpImg: reqConf.GetWarmUpImg(),
|
|
WarmUpEnd: reqConf.GetWarmUpEnd(),
|
|
Target: int8(target.GetTarget()),
|
|
Option: int8(target.GetOption()),
|
|
AppEvent: int8(target.GetAppEvent()),
|
|
BothType: int8(target.GetBothType()),
|
|
IconType: int8(reqConf.GetIconType()),
|
|
IconBgColor: reqConf.GetIconBgColor(),
|
|
DlType: int8(reqConf.GetDlType()),
|
|
DlBannerType: int8(reqConf.GetDlBannerType()),
|
|
DlBannerImg: reqConf.GetDlBannerImg(),
|
|
DlBannerAppLogo: reqConf.GetDlBannerAppLogo(),
|
|
DlBannerAppName: reqConf.GetDlBannerAppName(),
|
|
DlBannerAppBtn: reqConf.GetDlBannerAppBtn(),
|
|
DlBannerPosition: int8(reqConf.GetDlBannerPosition()),
|
|
TopicColor: reqConf.GetTopicColor(),
|
|
WindowCover: int8(reqConf.GetWindowCover()),
|
|
RewardGroup: 0,
|
|
SupportRewardMark: "",
|
|
DefaultRewardMark: "",
|
|
PlayRule: reqConf.GetPlayRule(),
|
|
IconOpen: "",
|
|
HasLongImg: utils.Ternary[int8](len(s.Req.GetLongImgs()) > 0, mtype.Yes, mtype.No),
|
|
HasWhite: int8(reqConf.GetHasWhite()),
|
|
WhiteList: reqConf.GetWhiteList(),
|
|
PcBg: reqConf.GetPcBg(),
|
|
AdsType: mtype.FissionCampaignConfigAdsTypeClose,
|
|
LinkTempID: reqConf.GetLinkTempId(),
|
|
RuleTimeOpen: int8(reqConf.GetRuleTimeOpen()),
|
|
OutsideTask: int8(reqConf.GetOutsideTask()),
|
|
OpenShare: utils.Ternary[int8](verify.InArray[int64](cpn.FissionID,
|
|
consts.IdSignIn, consts.IdQa, consts.IdQaAudio, consts.IdQaVideo, consts.IdPrizeQuiz, consts.IdPrizeAnswer), int8(reqConf.GetOpenShare()), 1),
|
|
ShowToUse: int8(reqConf.GetShowToUse()),
|
|
PointsUse: int8(s.Req.GetPointsUse().GetOpen()),
|
|
OpenChat: int8(s.Req.GetChat().GetOpen()),
|
|
RuleType: int8(reqConf.GetRuleType()),
|
|
RuleOutside: int8(reqConf.GetRuleOutside()),
|
|
DeviceOnce: int8(reqConf.GetDeviceOnce()),
|
|
})
|
|
|
|
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 {
|
|
conf.AdsType = int8(reqConf.GetAdsType())
|
|
}
|
|
|
|
// 设置奖品的配置
|
|
s._setRewardConfig(conf)
|
|
|
|
// 设置长图
|
|
err = s._setLongImg(conf)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
// 设置样式
|
|
err = s._createStyle(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s._createPointsUse(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
err = s._createChat(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
if reqConf.GetShare() != nil {
|
|
conf.SetShare(reqConf.GetShare())
|
|
}
|
|
|
|
if reqConf.GetIconOpen() != nil {
|
|
conf.SetIconOpen(reqConf.GetIconOpen())
|
|
}
|
|
|
|
var kvs []*mtype.KV
|
|
for _, v := range s.Req.GetCampaignData() {
|
|
kvs = append(kvs, &mtype.KV{
|
|
Key: v.Key,
|
|
Value: v.Value,
|
|
})
|
|
}
|
|
|
|
conf.SetCampaignData(kvs)
|
|
|
|
//新活动配置
|
|
if consts.NewEventCpn(cpn.FissionID) {
|
|
conf.Target = int8(s.Req.GetTargetOption().GetTarget())
|
|
conf.AppEvent = int8(s.Req.GetTargetOption().GetFixed().GetAppEvent())
|
|
conf.BothType = int8(s.Req.GetTargetOption().GetCustom().GetBothType())
|
|
conf.Option = mtype.FissionCampaignConfigTargetOptionApp
|
|
if s.Req.GetTargetOption().GetCustom().GetOpen() == mtype.Yes {
|
|
conf.Option = utils.Ternary[int8](
|
|
!verify.InArray[int64](cpn.FissionID, consts.IdWinTogether, consts.IdReferral),
|
|
mtype.FissionCampaignConfigTargetOptionTask, mtype.FissionCampaignConfigTargetOptionFriend)
|
|
}
|
|
|
|
// 创建参与票获取规则
|
|
err = s._createTicket(cpn)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
|
|
m := s.GetDao().FissionCampaignConfig
|
|
if err = m.WithContext(s.Ctx).Create(conf); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
//新活动配置完毕，不走下面老活动目标的逻辑
|
|
if consts.NewEventCpn(cpn.FissionID) {
|
|
return
|
|
}
|
|
|
|
// 创建目标条件
|
|
var targetCond = make([]*model.FissionCampaignCond, 0, len(target.GetCond()))
|
|
for _, cond := range target.GetCond() {
|
|
targetCond = append(targetCond, withdefault.FissionCampaignCond(&model.FissionCampaignCond{
|
|
CampaignID: cpn.ID,
|
|
ProjectID: cpn.ProjectID,
|
|
Event: cond.GetEvent(),
|
|
EventKey: cond.GetEventKey(),
|
|
EventVal: cond.GetEventVal(),
|
|
Desc: cond.GetDesc(),
|
|
IfCond: int8(cond.GetIfCond()),
|
|
TriggetType: int8(utils.NewGlobalTrigger(cpn.FissionID, cond.GetTriggerType())),
|
|
}))
|
|
}
|
|
|
|
if len(targetCond) > 0 {
|
|
condM := s.GetDao().FissionCampaignCond
|
|
|
|
err = condM.WithContext(s.Ctx).Create(targetCond...)
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Store) _createTicket(cpn *model.FissionCampaign) (err error) {
|
|
var target = s.Req.GetTargetOption()
|
|
|
|
var ticket []*model.FissionCampaignTicket
|
|
var tasks []*model.FissionCampaignTask
|
|
|
|
var fixed = target.GetFixed()
|
|
if fixed.GetOpen() == mtype.Yes {
|
|
ticket = append(ticket, withdefault.FissionCampaignTicket(&model.FissionCampaignTicket{
|
|
CampaignID: cpn.ID,
|
|
Mark: mtype.FissionCampaignTicketFixed,
|
|
Open: mtype.Yes,
|
|
AppEvent: int8(fixed.GetAppEvent()),
|
|
}))
|
|
|
|
one := withdefault.FissionCampaignTask(&model.FissionCampaignTask{
|
|
CampaignID: cpn.ID,
|
|
TaskType: 0,
|
|
TaskMark: "",
|
|
PropMark: mtype.FissionCampaignTaskPropMarkChance,
|
|
Num: utils.Ternary[int32](verify.InArray[int64](cpn.FissionID, consts.IdReferral, consts.IdWinTogether), 1, fixed.GetTargetNum()),
|
|
Chance: fixed.GetChance(),
|
|
ChanceLimit: fixed.GetChanceLimit(),
|
|
TaskLimit: 0,
|
|
Percent: fixed.GetPercent(),
|
|
})
|
|
|
|
switch fixed.GetAppEvent() {
|
|
case mtype.FissionCampaignTicketAppEventInstall:
|
|
one.TaskType = mtype.FissionCampaignTaskTypeInstall
|
|
one.TaskMark = mtype.FissionCampaignTaskMarkInstall
|
|
case mtype.FissionCampaignTicketAppEventRegister:
|
|
one.TaskType = mtype.FissionCampaignTaskTypeRegister
|
|
one.TaskMark = mtype.FissionCampaignTaskMarkRegister
|
|
}
|
|
|
|
tasks = append(tasks, one)
|
|
}
|
|
|
|
// 创建目标条件
|
|
var targetCond = make([]*model.FissionCampaignCond, 0, len(target.GetCustom().GetCond()))
|
|
var custom = target.GetCustom()
|
|
if custom.GetOpen() == mtype.Yes {
|
|
ticket = append(ticket, withdefault.FissionCampaignTicket(&model.FissionCampaignTicket{
|
|
CampaignID: cpn.ID,
|
|
Mark: mtype.FissionCampaignTicketCustom,
|
|
Open: mtype.Yes,
|
|
BothType: int8(custom.GetBothType()),
|
|
PreEvent: int8(custom.GetPreEvent()),
|
|
}))
|
|
|
|
for _, cond := range custom.GetCond() {
|
|
targetCond = append(targetCond, withdefault.FissionCampaignCond(&model.FissionCampaignCond{
|
|
CampaignID: cpn.ID,
|
|
ProjectID: cpn.ProjectID,
|
|
Event: cond.GetEvent(),
|
|
EventKey: cond.GetEventKey(),
|
|
EventVal: cond.GetEventVal(),
|
|
Desc: cond.GetDesc(),
|
|
IfCond: int8(cond.GetIfCond()),
|
|
Num: 0,
|
|
UserNum: 0,
|
|
Total: 0,
|
|
TriggetType: int8(cond.GetTriggerType()),
|
|
DelUse: 0,
|
|
EventType: int8(cond.GetEventType()),
|
|
ViewType: int8(cond.GetViewType()),
|
|
WatchSec: cond.GetWatchSec(),
|
|
OpenJump: int8(cond.GetOpenJump()),
|
|
WebURL: cond.GetWebUrl(),
|
|
ExtraParam: cond.GetExtraParam(),
|
|
PcParam: cond.GetPcParam(),
|
|
GoShow: int8(cond.GetGoShow()),
|
|
AdsStrategyID: cond.GetAdsStrategyId(),
|
|
IsSuper: int8(cond.GetIsSuper()),
|
|
Sort: cond.GetSort(),
|
|
OpenPush: int8(cond.GetOpenPush()),
|
|
GoText: cond.GetGoText(),
|
|
ClickEffectOpen: int8(cond.GetClickEffectOpen()),
|
|
ClickEffect: cond.GetClickEffect(),
|
|
ClickEffectUnit: cond.GetClickEffectUnit(),
|
|
PullInvite: int8(cond.GetPullInvite()),
|
|
}))
|
|
}
|
|
|
|
switch custom.GetBothType() {
|
|
case mtype.FissionCampaignTicketBothTypeAll:
|
|
var rewardId int64
|
|
var propMark = custom.GetBothAll().GetPropMark()
|
|
switch propMark {
|
|
case mtype.FissionCampaignTaskPropMarkReward:
|
|
rewardId = hashid.IdBigint()
|
|
s._otherAppendReward(&model.FissionCampaignReward{
|
|
ID: rewardId,
|
|
CampaignID: cpn.ID,
|
|
Stock: custom.GetBothAll().GetReward().GetStock(),
|
|
RewardType: mtype.FissionCampaignRewardTypeTask,
|
|
RewardNum: 1,
|
|
RewardID: custom.GetBothAll().GetReward().GetRewardId(),
|
|
PropMark: mtype.FissionCampaignRewardPropMarkReward,
|
|
})
|
|
case mtype.FissionCampaignTaskPropMarkPoint:
|
|
rewardId = hashid.IdBigint()
|
|
s._otherAppendReward(&model.FissionCampaignReward{
|
|
ID: rewardId,
|
|
CampaignID: cpn.ID,
|
|
RewardType: mtype.FissionCampaignRewardTypeTask,
|
|
RewardNum: custom.GetBothAll().GetChance(),
|
|
PropMark: mtype.FissionCampaignRewardPropMarkPoint,
|
|
ExpiredDay: custom.GetBothAll().GetExpiredDay(),
|
|
})
|
|
}
|
|
|
|
ll, _ := jsonm.ToSliceString(custom.GetBothAll().GetLevelIds())
|
|
lm, _ := jsonm.ToSliceString(custom.GetBothAll().GetLangMarks())
|
|
tasks = append(tasks, withdefault.FissionCampaignTask(&model.FissionCampaignTask{
|
|
CampaignID: cpn.ID,
|
|
TaskType: mtype.FissionCampaignTaskTypeCondAll,
|
|
TaskMark: mtype.FissionCampaignTaskMarkCondAll,
|
|
PropMark: propMark,
|
|
Num: 1,
|
|
Chance: custom.GetBothAll().GetChance(),
|
|
ChanceLimit: 0,
|
|
TaskLimit: custom.GetBothAll().GetTaskLimit(),
|
|
DayLimit: custom.GetBothAll().GetDayLimit(),
|
|
LevelLimit: ll,
|
|
LangMarks: lm,
|
|
WeekLimit: custom.GetBothAll().GetWeekLimit(),
|
|
WeekNum: int8(custom.GetBothAll().GetWeekNum()),
|
|
RewardID: rewardId,
|
|
}))
|
|
case mtype.FissionCampaignTicketBothTypeOne:
|
|
for i, cond := range custom.GetCond() {
|
|
var rewardId int64
|
|
var propMark = cond.GetPropMark()
|
|
|
|
switch propMark {
|
|
case mtype.FissionCampaignTaskPropMarkReward:
|
|
rewardId = hashid.IdBigint()
|
|
s._otherAppendReward(&model.FissionCampaignReward{
|
|
ID: rewardId,
|
|
CampaignID: cpn.ID,
|
|
Stock: cond.GetReward().GetStock(),
|
|
RewardType: mtype.FissionCampaignRewardTypeTask,
|
|
RewardNum: 1,
|
|
RewardID: cond.GetReward().GetRewardId(),
|
|
PropMark: mtype.FissionCampaignRewardPropMarkReward,
|
|
})
|
|
case mtype.FissionCampaignTaskPropMarkPoint:
|
|
rewardId = hashid.IdBigint()
|
|
s._otherAppendReward(&model.FissionCampaignReward{
|
|
ID: rewardId,
|
|
CampaignID: cpn.ID,
|
|
RewardType: mtype.FissionCampaignRewardTypeTask,
|
|
RewardNum: cond.GetChance(),
|
|
PropMark: mtype.FissionCampaignRewardPropMarkPoint,
|
|
ExpiredDay: cond.GetExpiredDay(),
|
|
})
|
|
}
|
|
|
|
ll, _ := jsonm.ToSliceString(cond.GetLevelIds())
|
|
lm, _ := jsonm.ToSliceString(cond.GetLangMarks())
|
|
tasks = append(tasks, withdefault.FissionCampaignTask(&model.FissionCampaignTask{
|
|
CampaignID: cpn.ID,
|
|
TaskType: mtype.FissionCampaignTaskTypeCondOne,
|
|
PropMark: propMark,
|
|
TaskMark: utils.FissionCampaignTaskMarkCondOneVal(targetCond[i].ID),
|
|
Num: 1,
|
|
Chance: cond.GetChance(),
|
|
ChanceLimit: 0,
|
|
TaskLimit: cond.GetTaskLimit(),
|
|
DayLimit: cond.GetDayLimit(),
|
|
LevelLimit: ll,
|
|
LangMarks: lm,
|
|
WeekLimit: cond.GetWeekLimit(),
|
|
WeekNum: int8(cond.GetWeekNum()),
|
|
HasPre: int8(cond.GetHasPre()),
|
|
PreCond: cond.GetPreCond(),
|
|
ExpiredMin: cond.GetExpiredMin(),
|
|
RewardID: rewardId,
|
|
AwardMode: int8(cond.GetAwardMode()),
|
|
}))
|
|
}
|
|
}
|
|
}
|
|
|
|
if len(ticket) > 0 {
|
|
ticketM := s.GetDao().FissionCampaignTicket
|
|
err = ticketM.WithContext(s.Ctx).Create(ticket...)
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
}
|
|
|
|
if len(targetCond) > 0 {
|
|
condM := s.GetDao().FissionCampaignCond
|
|
err = condM.WithContext(s.Ctx).Create(targetCond...)
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
}
|
|
|
|
if len(tasks) > 0 {
|
|
taskM := s.GetDao().FissionCampaignTask
|
|
err = taskM.WithContext(s.Ctx).Create(tasks...)
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 奖品配置
|
|
func (s *Store) _setRewardConfig(conf *model.FissionCampaignConfig) {
|
|
conf.RewardGroup = int8(s.Req.GetRewards().GetRewardGroup())
|
|
|
|
switch conf.RewardGroup {
|
|
case mtype.FissionRewardGroupLang:
|
|
var lang = finder.Lang{
|
|
Default: mtype.FissionLangTypeToMark[s.temp.LangType],
|
|
Support: make([]string, 0, len(s.Req.GetRewards().GetLangs())),
|
|
}
|
|
|
|
for _, v := range s.Req.GetRewards().GetLangs() {
|
|
lang.Support = append(lang.Support, v.GetLangMark())
|
|
}
|
|
|
|
conf.DefaultRewardMark, conf.SupportRewardMark = lang.DST()
|
|
case mtype.FissionRewardGroupUserLevel:
|
|
var level = finder.Level{
|
|
Default: s.Req.GetRewards().GetUserLevel().GetDefaultLevelId(),
|
|
Support: make([]int64, 0, len(s.Req.GetRewards().GetUserLevel().GetLevelList())),
|
|
}
|
|
|
|
for _, v := range s.Req.GetRewards().GetUserLevel().GetLevelList() {
|
|
level.Support = append(level.Support, v.GetLevelId())
|
|
}
|
|
|
|
conf.DefaultRewardMark, conf.SupportRewardMark = level.DST()
|
|
|
|
case mtype.FissionRewardGroupLangAndUserLevel:
|
|
var langLevel = finder.LangLevel{
|
|
Default: make([]finder.DefaultLangLevel, 0, len(s.Req.GetRewards().GetLangUserLevel())),
|
|
Support: make([]finder.SupportLangLevel, 0, len(s.Req.GetRewards().GetLangUserLevel())),
|
|
}
|
|
|
|
for _, v := range s.Req.GetRewards().GetLangUserLevel() {
|
|
langLevel.Default = append(langLevel.Default, finder.DefaultLangLevel{
|
|
Lang: v.GetLangMark(),
|
|
Level: v.GetDefaultLevelId(),
|
|
})
|
|
|
|
one := finder.SupportLangLevel{
|
|
Lang: v.GetLangMark(),
|
|
Level: make([]int64, 0, len(v.GetLevelList())),
|
|
}
|
|
for _, level := range v.GetLevelList() {
|
|
one.Level = append(one.Level, level.GetLevelId())
|
|
}
|
|
|
|
langLevel.Support = append(langLevel.Support, one)
|
|
}
|
|
conf.DefaultRewardMark, conf.SupportRewardMark = langLevel.DST()
|
|
case mtype.FissionRewardGroupCountry:
|
|
var country = finder.Country{
|
|
Default: s.Req.GetRewards().GetCountry().GetDefaultCountryMark(),
|
|
Support: make([]string, 0, len(s.Req.GetRewards().GetCountry().GetCountryList())),
|
|
}
|
|
|
|
for _, v := range s.Req.GetRewards().GetCountry().GetCountryList() {
|
|
country.Support = append(country.Support, v.GetCountryMark())
|
|
}
|
|
|
|
conf.DefaultRewardMark, conf.SupportRewardMark = country.DST()
|
|
default:
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// 创建默认数据
|
|
func (s *Store) createDefault(cpn *model.FissionCampaign) (err error) {
|
|
m := s.GetDao().FissionCampaignChannel
|
|
|
|
// 默认站内渠道
|
|
var mark = utils.GetRandEnStr(consts.ChannelMarkLen)
|
|
var chs = []*model.FissionCampaignChannel{
|
|
withdefault.FissionCampaignChannel(&model.FissionCampaignChannel{
|
|
CampaignID: cpn.ID,
|
|
IsDefault: mtype.Yes,
|
|
Mark: mark,
|
|
Title: consts.ChannelDefaultName,
|
|
CType: mtype.FissionCampaignChannelTypeApp,
|
|
}),
|
|
}
|
|
|
|
s.appMark = mark
|
|
|
|
// 创建默认站外渠道
|
|
if s.project.Scene == mtype.ProjectSceneApp {
|
|
var webMark string
|
|
var idx int
|
|
for {
|
|
webMark = utils.GetRandEnStr(consts.ChannelMarkLen)
|
|
if strings.ToLower(webMark) != strings.ToLower(mark) {
|
|
break
|
|
}
|
|
|
|
if idx > 99 {
|
|
return workerr.BusyError
|
|
}
|
|
|
|
idx++
|
|
}
|
|
|
|
s.webMark = webMark
|
|
|
|
chs = append(chs, withdefault.FissionCampaignChannel(&model.FissionCampaignChannel{
|
|
CampaignID: cpn.ID,
|
|
IsDefault: mtype.Yes,
|
|
Mark: webMark,
|
|
Title: consts.ChannelWebDefaultName,
|
|
CType: mtype.FissionCampaignChannelTypeWeb,
|
|
}))
|
|
}
|
|
|
|
err = m.WithContext(s.Ctx).Create(chs...)
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
// 渠道短链
|
|
for _, v := range chs {
|
|
if v.CType == mtype.FissionCampaignChannelTypeWeb {
|
|
var link = blink.NewCampaignLink(s.project.Domain, cpn.HashID, v.Mark).CampaignWebLink()
|
|
res, e := app.NewShortLinkNameLink().CreateShortLink(s.Ctx, &linkpb.CreateShortLinkReq{
|
|
LongLink: link,
|
|
Domain: s.project.Domain,
|
|
})
|
|
if e == nil {
|
|
m.WithContext(s.Ctx).Where(m.ID.Eq(v.ID)).UpdateSimple(m.ShortLink.Value(res.GetShortLink()))
|
|
}
|
|
}
|
|
}
|
|
|
|
archiveEnd := utils.CampaignArchiveEnd(cpn.EndTime)
|
|
|
|
// 统计任务
|
|
var atMarks = []string{mtype.FissionArchiveTaskMarkCampaignHour, mtype.FissionArchiveTaskMarkCampaignDay}
|
|
if s.Req.GetTargetOption().GetCustom().GetOpen() == mtype.Yes ||
|
|
verify.InArray(s.Req.GetTarget().GetOption(), mtype.FissionCampaignConfigTargetOptionUse, mtype.FissionCampaignConfigTargetOptionFriend,
|
|
mtype.FissionCampaignConfigTargetOptionSelf, mtype.FissionCampaignConfigTargetOptionTask) {
|
|
atMarks = append(atMarks, mtype.FissionArchiveTaskMarkCondDay, mtype.FissionArchiveTaskMarkCondHour)
|
|
}
|
|
|
|
var archiveTasks = make([]*model.FissionArchiveTask, 0, len(atMarks))
|
|
for _, v := range atMarks {
|
|
archiveTasks = append(archiveTasks, withdefault.FissionArchiveTask(&model.FissionArchiveTask{
|
|
CampaignID: cpn.ID,
|
|
EndTime: archiveEnd.Unix(),
|
|
Mark: v,
|
|
}))
|
|
}
|
|
|
|
atm := s.GetDao().FissionArchiveTask
|
|
err = atm.WithContext(s.Ctx).Create(archiveTasks...)
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
err = cmm.NewCMM(s.Ctx, s.GetDao()).AnalyzeCampaign(cpn.ProjectID, cpn.ID, cpn.StartTime, cpn.EndTime, 0)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 创建访问链接
|
|
func (s *Store) createLink(cpn *model.FissionCampaign) (err error) {
|
|
res, err := app.NewDeepLinkLink().CreateCampaignLinkOne(s.Ctx, &dlinkpb.CreateCampaignLinkOneReq{
|
|
ProjectId: s.project.ID,
|
|
CampaignId: cpn.ID,
|
|
CreatedTime: cpn.CreatedAt,
|
|
TemplateKey: s.Req.GetConfig().GetLinkTempId(),
|
|
})
|
|
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
codeInfo, err := app.NewDeepLinkLink().CreateCampaignLinkCode(s.Ctx, &dlinkpb.CreateCampaignLinkCodeReq{
|
|
ProjectId: cpn.ProjectID,
|
|
LinkId: res.GetId(),
|
|
Channel: s.webMark,
|
|
RedirectUrl: blink.NewCampaignLink(s.project.Domain, cpn.HashID, s.appMark, blink.SetCwMark(s.webMark)).CampaignCodeLink(),
|
|
})
|
|
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
m := s.GetDao().FissionCampaignChannel
|
|
_, err = m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.Mark.Eq(s.webMark)).UpdateSimple(m.Code.Value(codeInfo.GetCode()))
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 创建玩法特有数据
|
|
func (s *Store) createFission(cpn *model.FissionCampaign) (err error) {
|
|
switch cpn.FissionID {
|
|
case consts.IdPrizeWheel: //大转盘
|
|
return s._createPrizeWheel(cpn)
|
|
case consts.IdSlotMachine: //老虎机
|
|
return s._createSlotMachine(cpn)
|
|
case consts.IdLuckyGrid: //九宫格
|
|
return s._createLuckyGrid(cpn)
|
|
case consts.IdBlindBox: //盲盒
|
|
return s._createBlindBox(cpn)
|
|
case consts.IdReferral: //老带新
|
|
return s._createReferral(cpn)
|
|
case consts.IdPrizeAnswer, consts.IdQa, consts.IdQaAudio, consts.IdQaVideo: //趣味问答
|
|
return s._createPrizeAnswer(cpn)
|
|
case consts.IdPrizeQuiz: //有奖竞猜
|
|
return s._createPrizeQuiz(cpn)
|
|
case consts.IdWinTogether: //一起赢奖励
|
|
return s._createWinTogether(cpn)
|
|
case consts.IdSignIn: //签到
|
|
return s._createSignIn(cpn)
|
|
case consts.IdDice: //大富翁
|
|
return s._createDice(cpn)
|
|
case consts.IdGrow: //农场¬
|
|
return s._createGrow(cpn)
|
|
case consts.IdBallot: //抽签
|
|
return s._createBallot(cpn)
|
|
case consts.IdChop: //砍一刀
|
|
return s._createChop(cpn)
|
|
case consts.IdCash: //现金抽奖
|
|
return s._createCash(cpn)
|
|
case consts.IdFlip: //翻牌活动
|
|
return s._createFlip(cpn)
|
|
case consts.IdKeep: //激励养成
|
|
return s._createKeep(cpn)
|
|
case consts.IdGold: //金币任务
|
|
return s._createGold(cpn)
|
|
case consts.IdCoin: //金币池
|
|
return s._createCoin(cpn)
|
|
case consts.IdVs:
|
|
return s._createVs(cpn)
|
|
case consts.IdUno:
|
|
return s._createUno(cpn)
|
|
case consts.IdGashapon: //扭蛋机
|
|
return s._createGashapon(cpn)
|
|
default:
|
|
|
|
}
|
|
return
|
|
}
|
|
|
|
// 创建大转盘
|
|
func (s *Store) _createPrizeWheel(cpn *model.FissionCampaign) (err error) {
|
|
|
|
wheel := s.Req.GetPrizeWheel()
|
|
|
|
if wheel == nil {
|
|
return s.BE().VerifyError("please set prize_wheel")
|
|
}
|
|
|
|
prizeWheel := withdefault.FissionCampaignWheel(&model.FissionCampaignWheel{
|
|
CampaignID: cpn.ID,
|
|
TargetNum: wheel.GetTargetNum(),
|
|
InitChance: wheel.GetInitChance(),
|
|
Chance: wheel.GetChance(),
|
|
DayChance: wheel.GetDayChance(),
|
|
})
|
|
|
|
m := s.GetDao().FissionCampaignWheel
|
|
|
|
if err = m.WithContext(s.Ctx).Create(prizeWheel); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 创建老虎机
|
|
func (s *Store) _createSlotMachine(cpn *model.FissionCampaign) (err error) {
|
|
slot := s.Req.GetSlot()
|
|
|
|
if slot == nil {
|
|
return s.BE().VerifyError("please set slot")
|
|
}
|
|
|
|
fcs := withdefault.FissionCampaignSlot(&model.FissionCampaignSlot{
|
|
CampaignID: cpn.ID,
|
|
TargetNum: slot.GetTargetNum(),
|
|
InitChance: slot.GetInitChance(),
|
|
Chance: slot.GetChance(),
|
|
DayChance: slot.GetDayChance(),
|
|
})
|
|
|
|
m := s.GetDao().FissionCampaignSlot
|
|
|
|
if err = m.WithContext(s.Ctx).Create(fcs); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 创建九宫格
|
|
func (s *Store) _createLuckyGrid(cpn *model.FissionCampaign) (err error) {
|
|
grid := s.Req.GetGrid()
|
|
|
|
if grid == nil {
|
|
return s.BE().VerifyError("please set grid")
|
|
}
|
|
|
|
fcg := withdefault.FissionCampaignGrid(&model.FissionCampaignGrid{
|
|
CampaignID: cpn.ID,
|
|
TargetNum: grid.GetTargetNum(),
|
|
InitChance: grid.GetInitChance(),
|
|
Chance: grid.GetChance(),
|
|
DayChance: grid.GetDayChance(),
|
|
})
|
|
|
|
m := s.GetDao().FissionCampaignGrid
|
|
|
|
if err = m.WithContext(s.Ctx).Create(fcg); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 创建盲盒
|
|
func (s *Store) _createBlindBox(cpn *model.FissionCampaign) (err error) {
|
|
blind := s.Req.GetBlind()
|
|
|
|
if blind == nil {
|
|
return s.BE().VerifyError("please set blind")
|
|
}
|
|
|
|
fcb := withdefault.FissionCampaignBlind(&model.FissionCampaignBlind{
|
|
CampaignID: cpn.ID,
|
|
TargetNum: blind.GetTargetNum(),
|
|
InitChance: blind.GetInitChance(),
|
|
Chance: blind.GetChance(),
|
|
DayChance: blind.GetDayChance(),
|
|
})
|
|
|
|
m := s.GetDao().FissionCampaignBlind
|
|
|
|
if err = m.WithContext(s.Ctx).Create(fcb); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 创建趣味问答
|
|
func (s *Store) _createPrizeAnswer(cpn *model.FissionCampaign) (err error) {
|
|
qac := s.Req.GetQuestionAnswer()
|
|
|
|
if qac == nil {
|
|
return s.BE().VerifyError("please set question_answer")
|
|
}
|
|
|
|
qa := withdefault.FissionCampaignQa(&model.FissionCampaignQa{
|
|
CampaignID: cpn.ID,
|
|
TargetNum: qac.GetTargetNum(),
|
|
InitChance: qac.GetInitChance(),
|
|
Chance: qac.GetChance(),
|
|
QuestionAskTime: qac.GetQuestionAskTime(),
|
|
QaNum: qac.GetQaNum(),
|
|
DayChance: qac.GetDayChance(),
|
|
OpenGuide: int8(qac.GetOpenGuide()),
|
|
})
|
|
|
|
if qac.GetGroupHashId() != "" {
|
|
var group *model.LibraryQaGroup
|
|
groupM := s.GetDao().LibraryQaGroup
|
|
group, err = groupM.WithContext(s.Ctx).Where(groupM.HashID.Eq(qac.GetGroupHashId()), groupM.DelTime.Eq(0)).Take()
|
|
if err = dbcheck.DbError(err); err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
if group == nil {
|
|
return s.BE().VerifyError("qa group params error")
|
|
}
|
|
qa.QaGroupID = group.ID
|
|
}
|
|
|
|
if qac.GetGuideGroupHashId() != "" {
|
|
var group *model.LibraryQaGroup
|
|
groupM := s.GetDao().LibraryQaGroup
|
|
group, err = groupM.WithContext(s.Ctx).Where(groupM.HashID.Eq(qac.GetGuideGroupHashId()), groupM.DelTime.Eq(0)).Take()
|
|
if err = dbcheck.DbError(err); err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
if group == nil {
|
|
return s.BE().VerifyError("qa group params error")
|
|
}
|
|
qa.GuideGroupID = group.ID
|
|
}
|
|
|
|
//创建数据
|
|
m := s.GetDao().FissionCampaignQa
|
|
if err = m.WithContext(s.Ctx).Create(qa); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
//设置问题
|
|
var qs = make([]*model.FissionCampaignQaQuestion, 0, len(qac.GetQuestions()))
|
|
var ops = make([]*model.FissionCampaignQaOption, 0)
|
|
for i, v := range qac.GetQuestions() {
|
|
qsOne := withdefault.FissionCampaignQaQuestion(&model.FissionCampaignQaQuestion{
|
|
CampaignID: cpn.ID,
|
|
QaID: qa.ID,
|
|
Title: v.GetTitle(),
|
|
Score: v.GetScore(),
|
|
Sort: int32(i),
|
|
})
|
|
|
|
for _, v1 := range v.GetOptions() {
|
|
ops = append(ops, withdefault.FissionCampaignQaOption(&model.FissionCampaignQaOption{
|
|
QuestionID: qsOne.ID,
|
|
Title: v1.GetTitle(),
|
|
IsRight: int8(v1.GetIsRight()),
|
|
}))
|
|
}
|
|
|
|
qs = append(qs, qsOne)
|
|
}
|
|
|
|
if len(qs) > 0 {
|
|
cqqM := s.GetDao().FissionCampaignQaQuestion
|
|
if err = cqqM.WithContext(s.Ctx).Create(qs...); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
}
|
|
|
|
if len(ops) > 0 {
|
|
cqoM := s.GetDao().FissionCampaignQaOption
|
|
if err = cqoM.WithContext(s.Ctx).Create(ops...); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 创建赛事竞猜
|
|
func (s *Store) _createPrizeQuiz(cpn *model.FissionCampaign) (err error) {
|
|
quiz := s.Req.GetQuiz()
|
|
|
|
if quiz == nil {
|
|
return s.BE().VerifyError("please set quiz")
|
|
}
|
|
|
|
fcq := withdefault.FissionCampaignQuiz(&model.FissionCampaignQuiz{
|
|
CampaignID: cpn.ID,
|
|
TargetNum: quiz.GetTargetNum(),
|
|
InitChance: quiz.GetInitChance(),
|
|
Chance: quiz.GetChance(),
|
|
RewardRule: int8(quiz.GetRewardRule()),
|
|
OpenPrize: timez.GMT(quiz.GetOpenPrize(), s.Req.GetTOffset()),
|
|
OpenType: mtype.FissionCampaignQuizOpenTypeWait,
|
|
Title: quiz.GetTitle(),
|
|
TOpen: quiz.GetOpenPrize(),
|
|
})
|
|
|
|
m := s.GetDao().FissionCampaignQuiz
|
|
|
|
if err = m.WithContext(s.Ctx).Create(fcq); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
var options = make([]*model.FissionCampaignQuizOption, 0, len(quiz.GetOptions()))
|
|
for _, v := range quiz.GetOptions() {
|
|
options = append(options, withdefault.FissionCampaignQuizOption(&model.FissionCampaignQuizOption{
|
|
CampaignID: cpn.ID,
|
|
Title: v.GetTitle(),
|
|
ImgURL: v.GetImgUrl(),
|
|
IsRight: int8(v.GetIsRight()),
|
|
}))
|
|
}
|
|
|
|
optionM := s.GetDao().FissionCampaignQuizOption
|
|
|
|
if err = optionM.WithContext(s.Ctx).Create(options...); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 创建老带新
|
|
func (s *Store) _createReferral(cpn *model.FissionCampaign) (err error) {
|
|
rfl := s.Req.GetReferral()
|
|
|
|
if rfl == nil {
|
|
return s.BE().VerifyError("please set referral")
|
|
}
|
|
|
|
referral := withdefault.FissionCampaignReferral(&model.FissionCampaignReferral{
|
|
CampaignID: cpn.ID,
|
|
RewardLimit: rfl.GetRewardLimit(),
|
|
RewardRule: int8(rfl.GetRewardRule()),
|
|
InviteLimit: rfl.GetInviteLimit(),
|
|
StepLoop: int8(rfl.GetStepLoop()),
|
|
})
|
|
|
|
m := s.GetDao().FissionCampaignReferral
|
|
|
|
if err = m.WithContext(s.Ctx).Create(referral); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 创建一起赢你奖励
|
|
func (s *Store) _createWinTogether(cpn *model.FissionCampaign) (err error) {
|
|
win := s.Req.GetWin()
|
|
|
|
if win == nil {
|
|
return s.BE().VerifyError("please set win")
|
|
}
|
|
|
|
fcw := withdefault.FissionCampaignWin(&model.FissionCampaignWin{
|
|
CampaignID: cpn.ID,
|
|
RewardLimit: win.GetRewardLimit(),
|
|
RewardRule: int8(win.GetRewardRule()),
|
|
InviteLimit: win.GetInviteLimit(),
|
|
NewcomerCond: int8(win.GetNewcomerCond()),
|
|
StepLoop: int8(win.GetStepLoop()),
|
|
})
|
|
|
|
m := s.GetDao().FissionCampaignWin
|
|
|
|
if err = m.WithContext(s.Ctx).Create(fcw); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 同步事件推送
|
|
func (s *Store) syncEvent(cpn *model.FissionCampaign) (err error) {
|
|
err = cmm.NewCMM(s.Ctx, s.GetDao()).SaveEventCampaignTrigger(cpn.ProjectID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 创建签到玩法配置
|
|
func (s *Store) _createSignIn(cpn *model.FissionCampaign) (err error) {
|
|
sign := s.Req.GetSign()
|
|
|
|
if sign == nil {
|
|
return s.BE().VerifyError("please set sign")
|
|
}
|
|
|
|
fcs := withdefault.FissionCampaignSign(&model.FissionCampaignSign{
|
|
CampaignID: cpn.ID,
|
|
SignType: int8(sign.GetSignType()),
|
|
IsContinue: int8(sign.GetIsContinue()),
|
|
HasCard: int8(sign.GetHasCard()),
|
|
InviteNum: sign.GetInviteNum(),
|
|
IsLoop: int8(sign.GetIsLoop()),
|
|
SignCycle: sign.GetSignCycle(),
|
|
RecycleType: int8(sign.GetRecycleType()),
|
|
Color: sign.GetColor(),
|
|
})
|
|
|
|
if sign.GetSignType() == mtype.FissionCampaignSignTypeStep {
|
|
fcs.IsContinue = mtype.Yes
|
|
}
|
|
|
|
m := s.GetDao().FissionCampaignSign
|
|
if err = m.WithContext(s.Ctx).Create(fcs); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
if fcs.HasCard == mtype.No {
|
|
return
|
|
}
|
|
|
|
task := withdefault.FissionCampaignTask(&model.FissionCampaignTask{
|
|
CampaignID: cpn.ID,
|
|
TaskType: mtype.FissionCampaignTaskTypeInstall,
|
|
TaskMark: mtype.FissionCampaignTaskMarkInstall,
|
|
PropMark: mtype.FissionCampaignTaskPropMarkChance,
|
|
Num: fcs.InviteNum,
|
|
Chance: 1,
|
|
})
|
|
|
|
err = s.GetDao().FissionCampaignTask.WithContext(s.Ctx).Create(task)
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Store) _createDice(cpn *model.FissionCampaign) (err error) {
|
|
dice := s.Req.GetDice()
|
|
|
|
if dice == nil {
|
|
return s.BE().VerifyError("please set dice")
|
|
}
|
|
|
|
fcd := withdefault.FissionCampaignDice(&model.FissionCampaignDice{
|
|
CampaignID: cpn.ID,
|
|
InitChance: dice.GetInitChance(),
|
|
DayChance: dice.GetDayChance(),
|
|
FixDice: int8(dice.GetFixDice()),
|
|
FixDiceTarget: dice.GetFixDiceTarget(),
|
|
FixDiceLimit: dice.GetFixDiceLimit(),
|
|
FixDiceCond: int8(dice.GetFixDiceCond()),
|
|
CustomDice: dice.GetCustomDice(),
|
|
OpenMapPoint: int8(dice.GetOpenMapPoint()),
|
|
MapPoint: "",
|
|
AwardType: int8(dice.GetAwardType()),
|
|
Odds: dice.GetOdds(),
|
|
OpenInvite: int8(dice.GetOpenInvite()),
|
|
RollAgain: int8(dice.GetRollAgain()),
|
|
PlayImg: dice.GetPlayImg(),
|
|
CloudImg: dice.GetCloudImg(),
|
|
})
|
|
|
|
fcd.SetMapPoint(&mtype.MapPoint{
|
|
Blank: dice.GetMapPoint().GetBlank(),
|
|
Again: dice.GetMapPoint().GetAgain(),
|
|
Normal: dice.GetMapPoint().GetNormal(),
|
|
Supper: dice.GetMapPoint().GetSupper(),
|
|
})
|
|
|
|
m := s.GetDao().FissionCampaignDice
|
|
|
|
if err = m.WithContext(s.Ctx).Create(fcd); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
if fcd.FixDice != mtype.Yes {
|
|
return
|
|
}
|
|
|
|
taskM := s.GetDao().FissionCampaignTask
|
|
|
|
err = taskM.WithContext(s.Ctx).Create(withdefault.FissionCampaignTask(&model.FissionCampaignTask{
|
|
CampaignID: cpn.ID,
|
|
TaskType: utils.Ternary[int8](fcd.FixDiceCond == mtype.FissionCampaignDiceFixDiceCondInstall, mtype.FissionCampaignTaskTypeInstall, mtype.FissionCampaignTaskTypeRegister),
|
|
TaskMark: utils.Ternary[string](fcd.FixDiceCond == mtype.FissionCampaignDiceFixDiceCondInstall, mtype.FissionCampaignTaskMarkInstall, mtype.FissionCampaignTaskMarkRegister),
|
|
PropMark: mtype.FissionCampaignTaskPropMarkFixedRoll,
|
|
Num: dice.GetFixDiceTarget(),
|
|
Chance: 1,
|
|
ChanceLimit: dice.GetFixDiceLimit(),
|
|
TaskLimit: 0,
|
|
}))
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Store) _createGrow(cpn *model.FissionCampaign) (err error) {
|
|
grow := s.Req.GetGrow()
|
|
|
|
if grow == nil {
|
|
return s.BE().VerifyError("please set grow")
|
|
}
|
|
|
|
conf := withdefault.FissionCampaignGrow(&model.FissionCampaignGrow{
|
|
CampaignID: cpn.ID,
|
|
AutoHour: grow.GetAutoHour(),
|
|
AutoNum: grow.GetAutoNum(),
|
|
GrowNum: grow.GetGrowNum(),
|
|
TargetNum: grow.GetTargetNum(),
|
|
Revive: int8(grow.GetRevive()),
|
|
ReviveNum: grow.GetReviveNum(),
|
|
DieHour: grow.GetDieHour(),
|
|
InitNum: grow.GetInitNum(),
|
|
})
|
|
|
|
m := s.GetDao().FissionCampaignGrow
|
|
|
|
if err = m.WithContext(s.Ctx).Create(conf); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
var steps = make([]*model.FissionCampaignGrowStep, 0, len(grow.GetSteps()))
|
|
for i, step := range grow.GetSteps() {
|
|
steps = append(steps, withdefault.FissionCampaignGrowStep(&model.FissionCampaignGrowStep{
|
|
CampaignID: cpn.ID,
|
|
Step: int32(i + 1),
|
|
Num: step.Num,
|
|
}))
|
|
}
|
|
|
|
stepM := s.GetDao().FissionCampaignGrowStep
|
|
if err = stepM.WithContext(s.Ctx).Create(steps...); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
//复活任务
|
|
err = s._createGrowReviveTask(cpn)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Store) _createGrowReviveTask(cpn *model.FissionCampaign) (err error) {
|
|
grow := s.Req.GetGrow()
|
|
|
|
if grow.GetRevive() == mtype.Yes {
|
|
task := withdefault.FissionCampaignTask(&model.FissionCampaignTask{
|
|
CampaignID: cpn.ID,
|
|
TaskType: mtype.FissionCampaignTaskTypeInstall,
|
|
TaskMark: mtype.FissionCampaignTaskMarkInstall,
|
|
PropMark: mtype.FissionCampaignTaskPropMarkRevive,
|
|
Num: grow.GetReviveNum(),
|
|
Chance: 1,
|
|
})
|
|
|
|
taskM := s.GetDao().FissionCampaignTask
|
|
err = taskM.WithContext(s.Ctx).Create(task)
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *Store) _createBallot(cpn *model.FissionCampaign) (err error) {
|
|
ballot := s.Req.GetBallot()
|
|
|
|
if ballot == nil {
|
|
return s.BE().VerifyError("please set ballot")
|
|
}
|
|
|
|
conf := withdefault.FissionCampaignBallot(&model.FissionCampaignBallot{
|
|
CampaignID: cpn.ID,
|
|
InitChance: ballot.GetInitChance(),
|
|
DayChance: ballot.GetDayChance(),
|
|
})
|
|
|
|
m := s.GetDao().FissionCampaignBallot
|
|
|
|
if err = m.WithContext(s.Ctx).Create(conf); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Store) _createChop(cpn *model.FissionCampaign) (err error) {
|
|
chop := s.Req.GetChop()
|
|
|
|
if chop == nil {
|
|
return s.BE().VerifyError("please set chop")
|
|
}
|
|
|
|
conf := withdefault.FissionCampaignChop(&model.FissionCampaignChop{
|
|
CampaignID: cpn.ID,
|
|
ShowBar: int8(chop.GetShowBar()),
|
|
HelpRule: mtype.FissionCampaignChopHelpRuleUniqUser,
|
|
})
|
|
|
|
m := s.GetDao().FissionCampaignChop
|
|
|
|
if err = m.WithContext(s.Ctx).Create(conf); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 设置延迟深度链接数据
|
|
func (s *Store) saveDelayLinkData(cpn *model.FissionCampaign) (err error) {
|
|
var data = &dlinkpb.SaveCampaignDataListReq{
|
|
ProjectId: cpn.ProjectID,
|
|
CampaignId: cpn.ID,
|
|
Data: make([]*dlinkpb.SaveCampaignDataListReq_Data, 0, len(s.Req.GetDelayLinkData())),
|
|
}
|
|
|
|
for _, v := range s.Req.GetDelayLinkData() {
|
|
data.Data = append(data.Data, &dlinkpb.SaveCampaignDataListReq_Data{
|
|
Key: v.GetKey(),
|
|
Val: v.GetValue(),
|
|
})
|
|
}
|
|
|
|
_, err = app.NewDeepLinkLink().SaveCampaignDataList(s.Ctx, data)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 创建奖品
|
|
func (s *Store) createReward(cpn *model.FissionCampaign) (err error) {
|
|
var addRules []*model.FissionCampaignRewardRule
|
|
var addTasks []*model.FissionCampaignTask
|
|
var add = s.otherReward
|
|
var relateIds = s.otherRelateIds
|
|
var relateMap = s.otherRelateMap
|
|
var appendFn = func(rt int8, list []*pb.StoreReq_Reward, t consts.CampaignUserType) {
|
|
for i, one := range list {
|
|
var step int32
|
|
|
|
// 如果是老带新和一起奖励，额外奖或者是阶梯奖励规则，都要设置阶梯
|
|
if (verify.InArray(cpn.FissionID, consts.IdWinTogether, consts.IdReferral) &&
|
|
(rt == mtype.FissionCampaignRewardTypeExtra ||
|
|
(rt == mtype.FissionCampaignRewardTypeApp &&
|
|
(s.Req.GetReferral().GetRewardRule() == mtype.FissionReferralRewardRuleStep ||
|
|
s.Req.GetWin().GetRewardRule() == mtype.FissionReferralRewardRuleStep)))) ||
|
|
cpn.FissionID == consts.IdSignIn {
|
|
step = int32(i) + 1
|
|
}
|
|
|
|
var id = hashid.IdBigint()
|
|
|
|
rewardOne := &model.FissionCampaignReward{
|
|
ID: id,
|
|
CampaignID: cpn.ID,
|
|
Stock: one.GetStock(),
|
|
Sort: int32(i),
|
|
RewardType: rt,
|
|
Step: step,
|
|
InviteNum: one.GetInviteNum(),
|
|
RewardNum: one.GetRewardNum(),
|
|
IsThank: int8(one.GetIsThank()),
|
|
Score: one.GetScore(),
|
|
SignDay: one.GetSignDay(),
|
|
CollectNum: one.GetCollectNum(),
|
|
IsSuper: int8(one.GetIsSuper()),
|
|
RewardID: one.GetRewardId(),
|
|
LangMark: t.LangMark,
|
|
LevelID: t.LevelId,
|
|
Odds: one.GetOdds(),
|
|
CountryMark: t.CountryMark,
|
|
JumpURL: one.GetJumpUrl(),
|
|
HasRule: utils.Ternary[int8](one.GetCampaignLimit() > 0, mtype.Yes, mtype.No),
|
|
InitPercent: one.GetInitPercent(),
|
|
PropMark: mtype.FissionCampaignRewardPropMarkReward,
|
|
OpenAdd: int8(one.GetOpenAdd().GetOpen()),
|
|
OpenTask: int8(one.GetRewardTask().GetOpen()),
|
|
}
|
|
|
|
s.rewardAdd[id] = one.GetOpenAdd()
|
|
s.rewardTask[id] = one.GetRewardTask()
|
|
|
|
if cpn.FissionID == consts.IdDice && rt == mtype.FissionCampaignRewardTypeApp {
|
|
rewardOne.SetCollectRule(mtype.CollectRule{
|
|
Open: one.GetCollectRule().GetOpen(),
|
|
InitCollect: one.GetCollectRule().GetInitCollect(),
|
|
SignDay: one.GetCollectRule().GetSignDay(),
|
|
AddCollect: one.GetCollectRule().GetAddCollect(),
|
|
ResetType: one.GetCollectRule().GetResetType(),
|
|
})
|
|
}
|
|
|
|
add = append(add, rewardOne)
|
|
|
|
addTasks = append(addTasks, s._appendRewardHelp(cpn.ID, id, one)...)
|
|
|
|
if one.GetCampaignLimit() > 0 {
|
|
addRules = append(addRules, withdefault.FissionCampaignRewardRule(&model.FissionCampaignRewardRule{
|
|
CampaignID: cpn.ID,
|
|
RewardID: id,
|
|
CampaignLimit: one.GetCampaignLimit(),
|
|
}))
|
|
}
|
|
|
|
if _, ok := relateMap[one.GetRewardId()]; !ok && one.GetRewardId() > 0 {
|
|
relateMap[one.GetRewardId()] = struct{}{}
|
|
relateIds = append(relateIds, one.GetRewardId())
|
|
}
|
|
}
|
|
}
|
|
|
|
var lvRelateMap = make(map[int64]struct{})
|
|
var lvRelate []*model.FissionUserLevelRelated
|
|
var lvRelateFn = func(lvId int64) {
|
|
if _, ok := lvRelateMap[lvId]; !ok {
|
|
lvRelateMap[lvId] = struct{}{}
|
|
lvRelate = append(lvRelate, withdefault.FissionUserLevelRelated(&model.FissionUserLevelRelated{
|
|
LevelID: lvId,
|
|
RelateID: cpn.ID,
|
|
RelateTable: s.Dao().FissionCampaign.TableName(),
|
|
CancelTime: 0,
|
|
}))
|
|
}
|
|
}
|
|
|
|
appendFn(mtype.FissionCampaignRewardTypeWeb, s.Req.GetRewardsWeb(), consts.CampaignUserType{})
|
|
appendFn(mtype.FissionCampaignRewardTypeNewcomer, s.Req.GetRewardsNewcomer(), consts.CampaignUserType{})
|
|
appendFn(mtype.FissionCampaignRewardTypeExtra, s.Req.GetRewardsExtra(), consts.CampaignUserType{})
|
|
|
|
switch s.Req.GetRewards().GetRewardGroup() {
|
|
case mtype.FissionRewardGroupNormal:
|
|
appendFn(mtype.FissionCampaignRewardTypeApp, s.Req.GetRewards().GetNormal(), consts.CampaignUserType{})
|
|
case mtype.FissionRewardGroupLang:
|
|
for _, lang := range s.Req.GetRewards().GetLangs() {
|
|
appendFn(mtype.FissionCampaignRewardTypeApp, lang.GetRewards(), consts.CampaignUserType{LangMark: lang.GetLangMark()})
|
|
}
|
|
case mtype.FissionRewardGroupUserLevel:
|
|
for _, level := range s.Req.GetRewards().GetUserLevel().GetLevelList() {
|
|
appendFn(mtype.FissionCampaignRewardTypeApp, level.GetRewards(), consts.CampaignUserType{LevelId: level.GetLevelId()})
|
|
lvRelateFn(level.GetLevelId())
|
|
}
|
|
case mtype.FissionRewardGroupLangAndUserLevel:
|
|
for _, lang := range s.Req.GetRewards().GetLangUserLevel() {
|
|
for _, level := range lang.GetLevelList() {
|
|
appendFn(mtype.FissionCampaignRewardTypeApp, level.GetRewards(), consts.CampaignUserType{LangMark: lang.GetLangMark(), LevelId: level.GetLevelId()})
|
|
lvRelateFn(level.GetLevelId())
|
|
}
|
|
}
|
|
case mtype.FissionRewardGroupCountry:
|
|
for _, country := range s.Req.GetRewards().GetCountry().GetCountryList() {
|
|
appendFn(mtype.FissionCampaignRewardTypeApp, country.GetRewards(), consts.CampaignUserType{CountryMark: country.GetCountryMark()})
|
|
}
|
|
}
|
|
|
|
if len(add) == 0 {
|
|
return
|
|
}
|
|
|
|
m := s.GetDao().FissionCampaignReward
|
|
if err = m.WithContext(s.Ctx).Create(add...); err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var relates []*model.RewardRelated
|
|
for _, v := range relateIds {
|
|
relates = append(relates, withdefault.RewardRelated(&model.RewardRelated{
|
|
RewardID: v,
|
|
RelateID: cpn.ID,
|
|
RelateTable: s.GetDao().FissionCampaign.TableName(),
|
|
}))
|
|
}
|
|
|
|
relateM := s.GetDao().RewardRelated
|
|
if err = relateM.WithContext(s.Ctx).Create(relates...); err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
if len(addTasks) > 0 {
|
|
helpM := s.GetDao().FissionCampaignTask
|
|
if err = helpM.WithContext(s.Ctx).Create(addTasks...); err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
}
|
|
|
|
if len(lvRelate) > 0 {
|
|
lvRelateM := s.GetDao().FissionUserLevelRelated
|
|
if err = lvRelateM.WithContext(s.Ctx).Create(lvRelate...); err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
}
|
|
|
|
if len(addRules) > 0 {
|
|
ruleM := s.GetDao().FissionCampaignRewardRule
|
|
err = ruleM.WithContext(s.Ctx).Create(addRules...)
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
}
|
|
|
|
return s._createHelpTicket(cpn)
|
|
}
|
|
|
|
func (s *Store) depend() (err error) {
|
|
project, err := finder.Project(s.Ctx, s.Req.GetProjectId())
|
|
if err != nil {
|
|
return s.BE().CacheError(err)
|
|
}
|
|
|
|
if project == nil || project.IsDel == mtype.Yes {
|
|
return workerr.NotFound("project not found")
|
|
}
|
|
|
|
tempM := s.GetDao().FissionTemp
|
|
|
|
temp, err := tempM.WithContext(s.Ctx).Where(tempM.HashID.Eq(s.Req.GetTemplateId())).Take()
|
|
if err = dbcheck.DbError(err); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
if temp == nil || temp.IsDel == mtype.Yes {
|
|
return workerr.NotFound("The template has been removed. Please use the new template.")
|
|
}
|
|
|
|
group, err := cache.NewFissionTempGroup(s.Ctx).FindById(temp.GroupID)
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
if group.IsPrivate == mtype.Yes && !provider.NewCompanyMade(s.Ctx, project.CompanyID).OkTemp(group.Mark) {
|
|
return workerr.NotFound("group not open")
|
|
}
|
|
|
|
s.project = project
|
|
s.temp = temp
|
|
s.group = group
|
|
s.otherRelateMap = make(map[int64]struct{})
|
|
s.rewardAdd = make(map[int64]*pb.StoreReq_OpenAdd)
|
|
s.rewardTask = make(map[int64]*pb.StoreReq_RewardTask)
|
|
|
|
switch temp.FissionID {
|
|
case consts.IdKeep:
|
|
invite := s.Req.GetKeepDog()
|
|
s.Req.TargetOption.Fixed = &pb.StoreReq_Fixed{
|
|
Open: invite.GetOpenInvite(),
|
|
AppEvent: invite.GetInvite().GetInviteType(),
|
|
TargetNum: 1,
|
|
Chance: invite.GetInvite().GetInviteGet(),
|
|
Percent: 0,
|
|
}
|
|
case consts.IdPrizeQuiz:
|
|
s.Req.TargetOption.Fixed = &pb.StoreReq_Fixed{
|
|
Open: 1,
|
|
AppEvent: 1,
|
|
TargetNum: s.Req.GetQuiz().GetTargetNum(),
|
|
Chance: s.Req.GetQuiz().GetChance(),
|
|
Percent: 0,
|
|
}
|
|
}
|
|
|
|
if !verify.InArray[int64](temp.FissionID, consts.IdReferral, consts.IdWinTogether) {
|
|
if s.Req.TargetOption != nil && s.Req.TargetOption.Custom != nil {
|
|
s.Req.TargetOption.Custom.PreEvent = 0
|
|
}
|
|
}
|
|
|
|
s.AddAfterRun(func() (err error) {
|
|
s.OL().User(s.Req.GetUserId(), s.Req.GetIp()).CampaignSave(s.Res.GetId(), s.Req)
|
|
return
|
|
})
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Store) _createCash(cpn *model.FissionCampaign) (err error) {
|
|
cash := s.Req.GetCash()
|
|
|
|
if cash == nil {
|
|
return s.BE().VerifyError("please set cash")
|
|
}
|
|
|
|
conf := withdefault.FissionCampaignCash(&model.FissionCampaignCash{
|
|
CampaignID: cpn.ID,
|
|
ExpiredDay: cash.GetExpiredDay(),
|
|
Price: cash.GetPrice(),
|
|
PriceNum: cash.GetPriceNum(),
|
|
Currency: int8(cash.GetCurrency()),
|
|
LoopNum: cash.GetLoopNum(),
|
|
})
|
|
|
|
m := s.GetDao().FissionCampaignCash
|
|
|
|
if err = m.WithContext(s.Ctx).Create(conf); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Store) _setLongImg(conf *model.FissionCampaignConfig) (err error) {
|
|
if len(s.Req.GetLongImgs()) == 0 {
|
|
return
|
|
}
|
|
|
|
s.langSourceMap = make(map[string]int64, len(s.Req.GetLongImgs()))
|
|
var zone []*model.FissionCampaignLongImgZone
|
|
var add = make([]*model.FissionCampaignLongImg, 0, len(s.Req.GetLongImgs()))
|
|
for _, v := range s.Req.GetLongImgs() {
|
|
one := withdefault.FissionCampaignLongImg(&model.FissionCampaignLongImg{
|
|
CampaignID: conf.CampaignID,
|
|
ClickType: int8(v.GetClickType()),
|
|
ImgURL: v.GetImgUrl(),
|
|
WebURL: v.GetWebUrl(),
|
|
AppParam: v.GetAppParam(),
|
|
PcParam: v.GetPcParam(),
|
|
TargetType: int8(v.GetTargetType()),
|
|
TargetID: v.GetTargetId(),
|
|
})
|
|
|
|
s.langSourceMap[v.GetImgUrl()] = one.ID
|
|
|
|
if v.GetClickType() == mtype.FissionCampaignLongImgClickTypeZone {
|
|
for _, hotZone := range v.GetHotZone() {
|
|
zone = append(zone, withdefault.FissionCampaignLongImgZone(&model.FissionCampaignLongImgZone{
|
|
CampaignID: conf.CampaignID,
|
|
ImgID: one.ID,
|
|
WebURL: hotZone.GetWebUrl(),
|
|
AppParam: hotZone.GetAppParam(),
|
|
PcParam: hotZone.GetPcParam(),
|
|
ClickX: hotZone.GetClickX(),
|
|
ClickY: hotZone.GetClickY(),
|
|
ClickH: hotZone.GetClickH(),
|
|
ClickW: hotZone.GetClickW(),
|
|
TargetType: int8(hotZone.GetTargetType()),
|
|
TargetID: hotZone.GetTargetId(),
|
|
}))
|
|
}
|
|
}
|
|
|
|
add = append(add, one)
|
|
}
|
|
|
|
err = s.GetDao().FissionCampaignLongImg.WithContext(s.Ctx).Create(add...)
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
if len(zone) == 0 {
|
|
return
|
|
}
|
|
|
|
err = s.GetDao().FissionCampaignLongImgZone.WithContext(s.Ctx).Create(zone...)
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Store) _appendRewardHelp(campaignId, id int64, one *pb.StoreReq_Reward) (addTasks []*model.FissionCampaignTask) {
|
|
taskMark := utils.FissionCampaignTaskMarkRewardOneVal(id)
|
|
|
|
if one.Help == mtype.Yes {
|
|
addTasks = append(addTasks, withdefault.FissionCampaignTask(&model.FissionCampaignTask{
|
|
CampaignID: campaignId,
|
|
TaskType: mtype.FissionCampaignTaskTypeInstall,
|
|
TaskMark: taskMark,
|
|
PropMark: mtype.FissionCampaignTaskPropMarkChance,
|
|
Num: 1,
|
|
Percent: one.HelpPercent,
|
|
}))
|
|
|
|
s.helpInstall = true
|
|
}
|
|
if one.Open == mtype.Yes {
|
|
addTasks = append(addTasks, withdefault.FissionCampaignTask(&model.FissionCampaignTask{
|
|
CampaignID: campaignId,
|
|
TaskType: mtype.FissionCampaignTaskTypeOpen,
|
|
TaskMark: taskMark,
|
|
PropMark: mtype.FissionCampaignTaskPropMarkChance,
|
|
Num: 1,
|
|
Percent: one.OpenPercent,
|
|
PercentLimit: one.OpenPercentLimit,
|
|
}))
|
|
|
|
s.helpOpen = true
|
|
}
|
|
if one.Click == mtype.Yes {
|
|
addTasks = append(addTasks, withdefault.FissionCampaignTask(&model.FissionCampaignTask{
|
|
CampaignID: campaignId,
|
|
TaskType: mtype.FissionCampaignTaskTypeClick,
|
|
TaskMark: taskMark,
|
|
PropMark: mtype.FissionCampaignTaskPropMarkChance,
|
|
Num: 1,
|
|
Percent: one.ClickPercent,
|
|
PercentLimit: one.ClickPercentLimit,
|
|
}))
|
|
|
|
s.helpClick = true
|
|
}
|
|
if one.Register == mtype.Yes {
|
|
addTasks = append(addTasks, withdefault.FissionCampaignTask(&model.FissionCampaignTask{
|
|
CampaignID: campaignId,
|
|
TaskType: mtype.FissionCampaignTaskTypeRegister,
|
|
TaskMark: taskMark,
|
|
PropMark: mtype.FissionCampaignTaskPropMarkChance,
|
|
Num: 1,
|
|
Percent: one.RegisterPercent,
|
|
}))
|
|
|
|
s.helpRegister = true
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Store) _createFlip(cpn *model.FissionCampaign) (err error) {
|
|
flip := s.Req.GetFlip()
|
|
|
|
if flip == nil {
|
|
return s.BE().VerifyError("please set flip")
|
|
}
|
|
|
|
conf := withdefault.FissionCampaignFlip(&model.FissionCampaignFlip{
|
|
CampaignID: cpn.ID,
|
|
InitChance: flip.GetInitChance(),
|
|
CardImg: flip.GetCardImg(),
|
|
DayChance: flip.GetDayChance(),
|
|
})
|
|
|
|
m := s.GetDao().FissionCampaignFlip
|
|
|
|
if err = m.WithContext(s.Ctx).Create(conf); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 助力规则
|
|
func (s *Store) _createHelpTicket(cpn *model.FissionCampaign) (err error) {
|
|
var helpEvent []string
|
|
|
|
if s.helpInstall {
|
|
helpEvent = append(helpEvent, mtype.FissionCampaignTicketHelpEventInstall)
|
|
}
|
|
|
|
if s.helpRegister {
|
|
helpEvent = append(helpEvent, mtype.FissionCampaignTicketHelpEventRegister)
|
|
}
|
|
|
|
if s.helpOpen {
|
|
helpEvent = append(helpEvent, mtype.FissionCampaignTicketHelpEventOpen)
|
|
}
|
|
|
|
if s.helpClick {
|
|
helpEvent = append(helpEvent, mtype.FissionCampaignTicketHelpEventClick)
|
|
}
|
|
|
|
if len(helpEvent) == 0 {
|
|
return
|
|
}
|
|
|
|
err = s.GetDao().FissionCampaignTicket.WithContext(s.Ctx).Create(withdefault.FissionCampaignTicket(&model.FissionCampaignTicket{
|
|
CampaignID: cpn.ID,
|
|
Mark: mtype.FissionCampaignTicketRewardHelp,
|
|
Open: mtype.Yes,
|
|
HelpEvent: strings.Join(helpEvent, ","),
|
|
}))
|
|
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
func (s *Store) copyLangs(cpn *model.FissionCampaign) (err error) {
|
|
if s.Req.GetCopyCampaignId() == "" {
|
|
return
|
|
}
|
|
|
|
source, err := finder.Campaign(s.Ctx, s.Req.GetCopyCampaignId())
|
|
if err != nil {
|
|
err = s.BE().CacheError(err)
|
|
return
|
|
}
|
|
|
|
langMarks := source.GetLangMarks()
|
|
if len(langMarks) <= 1 {
|
|
return
|
|
}
|
|
|
|
copyConds, err := s._copyCond(source.ID, cpn.ID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
copyQt, err := s._copyQuit(cpn, source.ID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
copyQa, err := s._copyQuestion(cpn, source.ID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
copyTalkText, err := s._copyTalkText(cpn, source.ID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
m := s.GetDao().FissionCampaignLang
|
|
langs, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(source.ID), m.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var imgMap = make(map[string][]*model.FissionCampaignLongImg)
|
|
var zoneMap = make(map[string][]*model.FissionCampaignLongImgZone)
|
|
var langMap = make(map[string]*model.FissionCampaignLang)
|
|
for _, lang := range langs {
|
|
langMap[lang.LangMark] = lang
|
|
imgs, zones, err1 := s._copyImg(cpn.ID, source.ID, lang.ID)
|
|
if err1 != nil {
|
|
err = err1
|
|
return
|
|
}
|
|
imgMap[lang.LangMark] = imgs
|
|
zoneMap[lang.LangMark] = zones
|
|
|
|
}
|
|
|
|
var addImgs []*model.FissionCampaignLongImg
|
|
var addZones []*model.FissionCampaignLongImgZone
|
|
var add []*model.FissionCampaignLang
|
|
for _, lang := range langMarks {
|
|
|
|
old, ok := langMap[lang]
|
|
if !ok {
|
|
continue
|
|
}
|
|
|
|
langCond := old.GetConds()
|
|
var condMap = make(map[int64]*mtype.LangCond)
|
|
for _, cond := range langCond {
|
|
condMap[cond.CondId] = cond
|
|
}
|
|
|
|
var conds []*mtype.LangCond
|
|
var quit *mtype.LangQuit
|
|
var questions []*mtype.LangQuestions
|
|
var talks []*mtype.KeepTalk
|
|
for _, cpc := range copyConds {
|
|
|
|
one := cpc.cond
|
|
|
|
if oldCond, ok1 := condMap[cpc.copyId]; ok1 {
|
|
|
|
if one.Desc == "" {
|
|
one.Desc = oldCond.Desc
|
|
}
|
|
|
|
if one.WebURL == "" {
|
|
one.WebURL = oldCond.WebURL
|
|
}
|
|
|
|
if one.ExtraParam == "" {
|
|
one.ExtraParam = oldCond.ExtraParam
|
|
}
|
|
|
|
if one.PcParam == "" {
|
|
one.PcParam = oldCond.PcParam
|
|
}
|
|
|
|
if one.GoText == "" {
|
|
one.GoText = oldCond.GoText
|
|
}
|
|
}
|
|
|
|
conds = append(conds, &one)
|
|
}
|
|
|
|
switch cpn.FissionID {
|
|
case consts.IdPrizeQuiz:
|
|
langQuit := old.GetQuit()
|
|
quit = &mtype.LangQuit{
|
|
Title: copyQt.title,
|
|
Options: make([]*mtype.LangOption, 0, len(copyQt.options)),
|
|
}
|
|
|
|
if quit.Title == "" {
|
|
quit.Title = langQuit.Title
|
|
}
|
|
|
|
var titleMap = make(map[int64]*mtype.LangOption)
|
|
for _, option := range langQuit.Options {
|
|
titleMap[option.OptionId] = option
|
|
}
|
|
|
|
for _, cpo := range copyQt.options {
|
|
one := cpo.option
|
|
if oqo, ok1 := titleMap[cpo.copyId]; ok1 {
|
|
if one.Title == "" {
|
|
one.Title = oqo.Title
|
|
}
|
|
|
|
if one.ImgUrl == "" {
|
|
one.ImgUrl = oqo.ImgUrl
|
|
}
|
|
}
|
|
|
|
quit.Options = append(quit.Options, one)
|
|
}
|
|
case consts.IdPrizeAnswer:
|
|
langQuestions := old.GetQuestions()
|
|
var qMap = make(map[int64]*mtype.LangQuestions)
|
|
var qoMap = make(map[int64]*mtype.LangOption)
|
|
for _, question := range langQuestions {
|
|
qMap[question.QaId] = question
|
|
for _, option := range question.Options {
|
|
qoMap[option.OptionId] = option
|
|
}
|
|
}
|
|
|
|
for _, qa := range copyQa {
|
|
one := qa.qa
|
|
if oqa, ok1 := qMap[qa.copyId]; ok1 {
|
|
if one.Title == "" {
|
|
one.Title = oqa.Title
|
|
}
|
|
|
|
for _, option := range qa.options {
|
|
if oqo, ok2 := qoMap[option.copyId]; ok2 {
|
|
if option.option.Title == "" {
|
|
option.option.Title = oqo.Title
|
|
}
|
|
}
|
|
one.Options = append(one.Options, option.option)
|
|
}
|
|
}
|
|
|
|
questions = append(questions, one)
|
|
}
|
|
|
|
case consts.IdKeep:
|
|
talkText := old.GetKeepTalk()
|
|
var oldTalkTextMap = make(map[int32]string, len(talkText))
|
|
for _, talk := range talkText {
|
|
oldTalkTextMap[talk.TextType] = talk.Content
|
|
}
|
|
|
|
for _, v := range copyTalkText {
|
|
var text = v.content
|
|
if content, ok1 := oldTalkTextMap[v.textType]; ok1 && text == "" {
|
|
text = content
|
|
}
|
|
|
|
talks = append(talks, &mtype.KeepTalk{
|
|
TextType: v.textType,
|
|
Content: text,
|
|
})
|
|
}
|
|
}
|
|
|
|
condsStr, _ := jsonm.ToSliceString(conds)
|
|
quitStr, _ := jsonm.ToObjString(quit)
|
|
questionsStr, _ := jsonm.ToSliceString(questions)
|
|
talksStr, _ := jsonm.ToSliceString(talks)
|
|
|
|
one := withdefault.FissionCampaignLang(&model.FissionCampaignLang{
|
|
CampaignID: cpn.ID,
|
|
LangMark: lang,
|
|
PageTitle: old.PageTitle,
|
|
ImageMain: old.ImageMain,
|
|
DownloadPageImage: old.DownloadPageImage,
|
|
WechatPageImage: old.WechatPageImage,
|
|
ContentImg: old.ContentImg,
|
|
WebBgImg: old.DlBgImg,
|
|
WarmUpImg: old.WarmUpImg,
|
|
DlBgImg: old.DlBgImg,
|
|
DlBannerImg: old.DlBannerImg,
|
|
DlBannerAppLogo: old.DlBannerAppLogo,
|
|
DlBannerAppName: old.DlBannerAppName,
|
|
DlBannerAppBtn: old.DlBannerAppBtn,
|
|
ShareText: old.ShareText,
|
|
ShareImg: old.ShareImg,
|
|
Rule: old.Rule,
|
|
RuleImg: "",
|
|
Conds: condsStr,
|
|
Quit: quitStr,
|
|
Questions: questionsStr,
|
|
QaGroup: old.QaGroup,
|
|
LongImg: old.LongImg,
|
|
Cash: old.Cash,
|
|
Gold: "",
|
|
TOffset: old.TOffset,
|
|
TalkText: talksStr,
|
|
Coin: "",
|
|
TopicColor: "",
|
|
PcBg: "",
|
|
Vs: "[]",
|
|
Uno: utils.Ternary[string](old.Uno != "", old.Uno, "{}"),
|
|
})
|
|
|
|
for _, img := range imgMap[lang] {
|
|
img.LangID = one.ID
|
|
addImgs = append(addImgs, img)
|
|
}
|
|
|
|
addZones = append(addZones, zoneMap[lang]...)
|
|
add = append(add, one)
|
|
|
|
}
|
|
|
|
if len(add) == 0 {
|
|
return
|
|
}
|
|
|
|
err = m.WithContext(s.Ctx).Create(add...)
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
cpnM := s.GetDao().FissionCampaign
|
|
_, err = cpnM.WithContext(s.Ctx).Where(cpnM.ID.Eq(cpn.ID)).UpdateSimple(cpnM.LangTypes.Value(source.LangTypes))
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
if len(addImgs) > 0 {
|
|
err = s.GetDao().FissionCampaignLongImg.WithContext(s.Ctx).Create(addImgs...)
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
}
|
|
|
|
if len(addZones) > 0 {
|
|
err = s.GetDao().FissionCampaignLongImgZone.WithContext(s.Ctx).Create(addZones...)
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
type copyCond struct {
|
|
copyId int64
|
|
cond mtype.LangCond
|
|
}
|
|
|
|
func (s *Store) _copyCond(oldCpnId, cpnId int64) (conds []copyCond, err error) {
|
|
condM := s.GetDao().FissionCampaignCond
|
|
oldCond, err := condM.WithContext(s.Ctx).Where(condM.CampaignID.Eq(oldCpnId), condM.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var titleMap = make(map[string][]*model.FissionCampaignCond)
|
|
for _, cond := range oldCond {
|
|
titleMap[cond.Desc] = append(titleMap[cond.Desc], cond)
|
|
}
|
|
|
|
newCond, err := condM.WithContext(s.Ctx).Where(condM.CampaignID.Eq(cpnId), condM.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var titleIdx = make(map[string]int)
|
|
for _, cond := range newCond {
|
|
one := copyCond{
|
|
copyId: 0,
|
|
cond: mtype.LangCond{
|
|
CondId: cond.ID,
|
|
Desc: cond.Desc,
|
|
WebURL: cond.WebURL,
|
|
ExtraParam: cond.ExtraParam,
|
|
PcParam: cond.PcParam,
|
|
GoText: cond.GoText,
|
|
},
|
|
}
|
|
|
|
if olds, ok := titleMap[cond.Desc]; ok {
|
|
if len(olds) > titleIdx[cond.Desc] {
|
|
old := olds[titleIdx[cond.Desc]]
|
|
|
|
one.copyId = old.ID
|
|
if cond.Desc == old.Desc {
|
|
one.cond.Desc = ""
|
|
}
|
|
|
|
if cond.WebURL == old.WebURL {
|
|
one.cond.WebURL = ""
|
|
}
|
|
|
|
if cond.ExtraParam == old.ExtraParam {
|
|
one.cond.ExtraParam = ""
|
|
}
|
|
|
|
if cond.PcParam == old.PcParam {
|
|
one.cond.PcParam = ""
|
|
}
|
|
|
|
if cond.GoText == old.GoText {
|
|
one.cond.GoText = ""
|
|
}
|
|
|
|
titleIdx[cond.Desc]++
|
|
}
|
|
}
|
|
|
|
conds = append(conds, one)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
type copyQuit struct {
|
|
title string
|
|
options []*copyOption //选项集合
|
|
}
|
|
|
|
type copyOption struct {
|
|
copyId int64
|
|
option *mtype.LangOption
|
|
}
|
|
|
|
func (s *Store) _copyQuit(cpn *model.FissionCampaign, oldCpnId int64) (quit *copyQuit, err error) {
|
|
if cpn.FissionID != consts.IdPrizeQuiz {
|
|
return
|
|
}
|
|
|
|
m := s.GetDao().FissionCampaignQuiz
|
|
conf, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(oldCpnId)).Take()
|
|
if err = dbcheck.DbError(err); err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
quit = ©Quit{
|
|
title: s.Req.GetQuiz().GetTitle(),
|
|
options: nil,
|
|
}
|
|
|
|
if conf.Title == s.Req.GetQuiz().GetTitle() {
|
|
quit.title = ""
|
|
}
|
|
|
|
optionM := s.GetDao().FissionCampaignQuizOption
|
|
oldOption, err := optionM.WithContext(s.Ctx).Where(optionM.CampaignID.Eq(oldCpnId), optionM.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var titleMap = make(map[string][]*model.FissionCampaignQuizOption)
|
|
for _, option := range oldOption {
|
|
titleMap[option.Title] = append(titleMap[option.Title], option)
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
var titleIdx = make(map[string]int)
|
|
for _, option := range options {
|
|
one := ©Option{
|
|
copyId: 0,
|
|
option: &mtype.LangOption{
|
|
OptionId: option.ID,
|
|
Title: option.Title,
|
|
ImgUrl: option.ImgURL,
|
|
},
|
|
}
|
|
|
|
if cpo, ok := titleMap[option.Title]; ok {
|
|
if len(cpo) > titleIdx[option.Title] {
|
|
old := cpo[titleIdx[option.Title]]
|
|
|
|
one.copyId = old.ID
|
|
|
|
if option.Title == old.Title {
|
|
one.option.Title = ""
|
|
}
|
|
|
|
if option.ImgURL == old.ImgURL {
|
|
one.option.ImgUrl = ""
|
|
}
|
|
|
|
titleIdx[option.Title]++
|
|
}
|
|
|
|
}
|
|
|
|
quit.options = append(quit.options, one)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
type copyQuestion struct {
|
|
copyId int64
|
|
qa *mtype.LangQuestions
|
|
options []*copyOption //选项集合
|
|
}
|
|
|
|
func (s *Store) _copyQuestion(cpn *model.FissionCampaign, oldCpnId int64) (questions []*copyQuestion, err error) {
|
|
if cpn.FissionID != consts.IdPrizeAnswer {
|
|
return
|
|
}
|
|
|
|
m := s.GetDao().FissionCampaignQaQuestion
|
|
oldQuestion, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(oldCpnId), m.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var titleMap = make(map[string][]*model.FissionCampaignQaQuestion)
|
|
var oldIds []int64
|
|
for _, old := range oldQuestion {
|
|
oldIds = append(oldIds, old.ID)
|
|
titleMap[old.Title] = append(titleMap[old.Title], old)
|
|
}
|
|
|
|
optionM := s.GetDao().FissionCampaignQaOption
|
|
oldOption, err := optionM.WithContext(s.Ctx).Where(optionM.QuestionID.In(oldIds...), optionM.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var oldOptionMap = make(map[int64][]*model.FissionCampaignQaOption)
|
|
for _, option := range oldOption {
|
|
oldOptionMap[option.QuestionID] = append(oldOptionMap[option.QuestionID], option)
|
|
}
|
|
|
|
question, 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 ids []int64
|
|
for _, v := range question {
|
|
ids = append(ids, v.ID)
|
|
}
|
|
|
|
options, err := optionM.WithContext(s.Ctx).Where(optionM.QuestionID.In(ids...), optionM.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var optionMap = make(map[int64][]*model.FissionCampaignQaOption)
|
|
for _, option := range options {
|
|
optionMap[option.QuestionID] = append(optionMap[option.QuestionID], option)
|
|
}
|
|
|
|
var titleIdx = make(map[string]int)
|
|
questions = make([]*copyQuestion, 0, len(question))
|
|
for _, qa := range question {
|
|
one := ©Question{
|
|
copyId: 0,
|
|
qa: &mtype.LangQuestions{},
|
|
options: make([]*copyOption, 0, len(optionMap[qa.ID])),
|
|
}
|
|
|
|
for _, option := range optionMap[qa.ID] {
|
|
one.options = append(one.options, ©Option{
|
|
copyId: 0,
|
|
option: &mtype.LangOption{
|
|
OptionId: option.ID,
|
|
Title: option.Title,
|
|
},
|
|
})
|
|
}
|
|
|
|
if cpq, ok := titleMap[qa.Title]; ok {
|
|
if len(cpq) > titleIdx[qa.Title] {
|
|
old := cpq[titleIdx[qa.Title]]
|
|
|
|
one.copyId = old.ID
|
|
if qa.Title == old.Title {
|
|
one.qa.Title = ""
|
|
}
|
|
|
|
ops := oldOptionMap[old.ID]
|
|
var opsTitleMap = make(map[string][]*model.FissionCampaignQaOption)
|
|
for _, op := range ops {
|
|
opsTitleMap[op.Title] = append(opsTitleMap[op.Title], op)
|
|
}
|
|
|
|
var opsTitleIdx = make(map[string]int)
|
|
for i, v := range one.options {
|
|
if cpo, ok1 := opsTitleMap[v.option.Title]; ok1 {
|
|
|
|
if len(cpo) > opsTitleIdx[v.option.Title] {
|
|
odo := cpo[opsTitleIdx[v.option.Title]]
|
|
|
|
one.options[i].copyId = odo.ID
|
|
|
|
if v.option.Title == odo.Title {
|
|
one.options[i].option.Title = ""
|
|
}
|
|
}
|
|
|
|
opsTitleIdx[v.option.Title]++
|
|
}
|
|
}
|
|
|
|
titleIdx[qa.Title]++
|
|
}
|
|
}
|
|
|
|
questions = append(questions, one)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Store) _createKeep(cpn *model.FissionCampaign) (err error) {
|
|
keep := s.Req.GetKeepDog()
|
|
|
|
if keep == nil {
|
|
return s.BE().VerifyError("please set keep")
|
|
}
|
|
|
|
invite, _ := jsonm.MarshalToString(keep.GetInvite())
|
|
talkText, _ := jsonm.MarshalToString(keep.GetTalkText())
|
|
|
|
conf := withdefault.FissionCampaignKeep(&model.FissionCampaignKeep{
|
|
CampaignID: cpn.ID,
|
|
Collect: keep.GetCollect(),
|
|
CollectSecond: keep.GetCollectSecond(),
|
|
OpenInvite: int8(keep.GetOpenInvite()),
|
|
Invite: invite,
|
|
InitGet: keep.GetInitGet(),
|
|
SecGet: keep.GetSecGet(),
|
|
FeedNum: keep.GetFeedNum(),
|
|
FeedCycle: keep.GetFeedCycle(),
|
|
TalkText: talkText,
|
|
MaxFeed: keep.GetMaxFeed(),
|
|
FeedGet: keep.GetFeedGet(),
|
|
FeedGetNum: keep.GetFeedGetNum(),
|
|
SecGetDayLimit: keep.GetSecGetDayLimit(),
|
|
MachineType: int8(keep.GetMachineType()),
|
|
OfflineMin: keep.GetOfflineMin(),
|
|
OfflineGet: keep.GetOfflineGet(),
|
|
OfflineLimit: keep.GetOfflineLimit(),
|
|
})
|
|
|
|
m := s.GetDao().FissionCampaignKeep
|
|
if err = m.WithContext(s.Ctx).Create(conf); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
var steps []*model.FissionCampaignKeepStep
|
|
for _, v := range keep.GetSteps() {
|
|
step := withdefault.FissionCampaignKeepStep(&model.FissionCampaignKeepStep{
|
|
CampaignID: cpn.ID,
|
|
Step: v.GetStep(),
|
|
Percent: v.GetPercent(),
|
|
RewardType: int8(v.GetRewardType()),
|
|
RewardID: 0,
|
|
RewardNum: v.GetRewardNum(),
|
|
})
|
|
|
|
if v.GetRewardType() == mtype.FissionCampaignKeepStepRewardTypeReward {
|
|
|
|
rewardId := hashid.IdBigint()
|
|
s._otherAppendReward(&model.FissionCampaignReward{
|
|
ID: rewardId,
|
|
CampaignID: cpn.ID,
|
|
Stock: v.GetReward().GetStock(),
|
|
RewardType: mtype.FissionCampaignRewardTypeGrowStep,
|
|
Step: v.GetStep(),
|
|
RewardNum: 1,
|
|
RewardID: v.GetReward().GetRewardId(),
|
|
PropMark: mtype.FissionCampaignRewardPropMarkReward,
|
|
})
|
|
|
|
step.RewardID = rewardId
|
|
}
|
|
|
|
steps = append(steps, step)
|
|
}
|
|
|
|
err = s.GetDao().FissionCampaignKeepStep.WithContext(s.Ctx).Create(steps...)
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
type copyTalk struct {
|
|
textType int32
|
|
content string
|
|
}
|
|
|
|
func (s *Store) _copyTalkText(cpn *model.FissionCampaign, oldCpnId int64) (talks []*copyTalk, err error) {
|
|
if cpn.FissionID != consts.IdKeep {
|
|
return
|
|
}
|
|
|
|
m := s.GetDao().FissionCampaignKeep
|
|
conf, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(oldCpnId)).Take()
|
|
if err = dbcheck.DbError(err); err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
|
|
return
|
|
}
|
|
|
|
oldTalks := conf.GetKeepTalk()
|
|
var oldMap = make(map[int32]string, len(oldTalks))
|
|
for _, oldTalk := range oldTalks {
|
|
oldMap[oldTalk.TextType] = oldTalk.Content
|
|
}
|
|
|
|
for _, talk := range s.Req.GetKeepDog().GetTalkText() {
|
|
var text string
|
|
content, ok := oldMap[talk.GetTextType()]
|
|
if !ok || content != talk.Content {
|
|
text = talk.Content
|
|
}
|
|
|
|
talks = append(talks, ©Talk{
|
|
textType: talk.GetTextType(),
|
|
content: text,
|
|
})
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Store) createPush(cpn *model.FissionCampaign) (err error) {
|
|
var add []*model.FissionCampaignPush
|
|
if s.Req.GetPush().GetTaskReset().GetOpen() == mtype.Yes {
|
|
cond, _ := jsonm.ToSliceString(s.Req.GetPush().GetTaskReset().GetPushCond())
|
|
add = append(add, &model.FissionCampaignPush{
|
|
CampaignID: cpn.ID,
|
|
Mark: mtype.FissionCampaignPushMarkTaskReset,
|
|
Cond: cond,
|
|
Open: mtype.Yes,
|
|
})
|
|
}
|
|
|
|
if s.Req.GetPush().GetActive().GetOpen() == mtype.Yes {
|
|
cond, _ := jsonm.ToSliceString(s.Req.GetPush().GetActive().GetPushCond())
|
|
add = append(add, withdefault.FissionCampaignPush(&model.FissionCampaignPush{
|
|
CampaignID: cpn.ID,
|
|
Mark: mtype.FissionCampaignPushMarkActive,
|
|
Cond: cond,
|
|
Open: mtype.Yes,
|
|
}))
|
|
}
|
|
|
|
if s.Req.GetPush().GetOffline().GetOpen() == mtype.Yes {
|
|
cond, _ := jsonm.ToSliceString(s.Req.GetPush().GetOffline().GetPushCond())
|
|
add = append(add, &model.FissionCampaignPush{
|
|
CampaignID: cpn.ID,
|
|
Mark: mtype.FissionCampaignPushMarkOffline,
|
|
Cond: cond,
|
|
Open: mtype.Yes,
|
|
})
|
|
}
|
|
|
|
if s.Req.GetPush().GetVisit().GetOpen() == mtype.Yes {
|
|
add = append(add, &model.FissionCampaignPush{
|
|
CampaignID: cpn.ID,
|
|
Mark: mtype.FissionCampaignPushMarkVisit,
|
|
Cond: "{}",
|
|
Open: mtype.Yes,
|
|
})
|
|
}
|
|
|
|
if len(add) > 0 {
|
|
err = s.GetDao().FissionCampaignPush.WithContext(s.Ctx).Create(add...)
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 其他形式的奖品追加
|
|
func (s *Store) _otherAppendReward(reward *model.FissionCampaignReward) {
|
|
if _, ok := s.otherRelateMap[reward.RewardID]; !ok && reward.RewardID > 0 {
|
|
s.otherRelateMap[reward.RewardID] = struct{}{}
|
|
s.otherRelateIds = append(s.otherRelateIds, reward.RewardID)
|
|
}
|
|
|
|
s.otherReward = append(s.otherReward, withdefault.FissionCampaignReward(reward))
|
|
}
|
|
|
|
func (s *Store) createChild(cpn *model.FissionCampaign) (err error) {
|
|
if len(s.Req.GetChild()) == 0 {
|
|
return
|
|
}
|
|
|
|
var hashIds []string
|
|
for _, child := range s.Req.GetChild() {
|
|
if child.GetHashId() == "" {
|
|
continue
|
|
}
|
|
hashIds = append(hashIds, child.GetHashId())
|
|
}
|
|
|
|
m := s.GetDao().FissionCampaign
|
|
list, err := m.WithContext(s.Ctx).Where(m.HashID.In(hashIds...), m.Target.Eq(mtype.FissionCampaignConfigTargetChild), m.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
cm := cmm.NewCMM(s.Ctx, s.GetDao())
|
|
var add []*model.FissionCampaignChild
|
|
for _, v := range list {
|
|
if v.Pid > 0 {
|
|
continue
|
|
}
|
|
|
|
add = append(add, withdefault.FissionCampaignChild(&model.FissionCampaignChild{
|
|
CampaignID: cpn.ID,
|
|
ChildID: v.ID,
|
|
Type: v.ChildType,
|
|
}))
|
|
|
|
var status = v.Status
|
|
|
|
var start, end int64
|
|
if v.TStart > 0 {
|
|
start = timez.GMT(v.TStart, cpn.TOffset)
|
|
if start >= time.Now().Unix() {
|
|
status = mtype.FissionCampaignStatusPub
|
|
}
|
|
}
|
|
|
|
if v.TEnd > 0 {
|
|
end = timez.GMT(v.TEnd, cpn.TOffset)
|
|
if end <= time.Now().Unix() {
|
|
status = mtype.FissionCampaignStatusCancel
|
|
}
|
|
}
|
|
|
|
_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(v.ID)).UpdateSimple(
|
|
m.StartTime.Value(start),
|
|
m.EndTime.Value(end),
|
|
m.Pid.Value(cpn.ID),
|
|
m.Status.Value(status),
|
|
m.TOffset.Value(cpn.TOffset),
|
|
)
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
err = cm.AnalyzeCampaign(v.ProjectID, v.ID, start, end, 0)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
}
|
|
|
|
err = s.GetDao().FissionCampaignChild.WithContext(s.Ctx).Create(add...)
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// 创建活动样式配置
|
|
func (s *Store) _createStyle(cpn *model.FissionCampaign) (err error) {
|
|
// 一般配置
|
|
var reqConf = s.Req.GetConfig()
|
|
|
|
style := withdefault.FissionCampaignStyle(&model.FissionCampaignStyle{
|
|
CampaignID: cpn.ID,
|
|
RuleTextColor: reqConf.GetRuleTextColor(),
|
|
RuleBgColor: reqConf.GetRuleBgColor(),
|
|
ShareText: reqConf.GetShareText(),
|
|
ShareImg: reqConf.GetShareImg(),
|
|
RankBackgroundColor: reqConf.GetRankBackgroundColor(),
|
|
RankTextColor: reqConf.GetRankTextColor(),
|
|
LinkBtnTextColor: reqConf.GetLinkBtnTextColor(),
|
|
LinkBtnBgColor: reqConf.GetLinkBtnBgColor(),
|
|
LinkTextColor: reqConf.GetLinkTextColor(),
|
|
PageTitle: reqConf.GetPageTitle(),
|
|
IconType: int8(reqConf.GetIconType()),
|
|
IconBgColor: reqConf.GetIconBgColor(),
|
|
MainImg: reqConf.GetImageMain(),
|
|
WechatImg: reqConf.GetWechatPageImage(),
|
|
DownloadImg: reqConf.GetDownloadPageImage(),
|
|
WebImg: reqConf.GetWebBgImg(),
|
|
Share: "",
|
|
WarmUpImg: reqConf.GetWarmUpImg(),
|
|
WarmUpEnd: reqConf.GetWarmUpEnd(),
|
|
DlBannerImg: reqConf.GetDlBannerImg(),
|
|
DlBannerAppLogo: reqConf.GetDlBannerAppLogo(),
|
|
DlBannerAppName: reqConf.GetDlBannerAppName(),
|
|
DlBannerAppBtn: reqConf.GetDlBannerAppBtn(),
|
|
DlBannerPosition: int8(reqConf.GetDlBannerPosition()),
|
|
TopicColor: reqConf.GetTopicColor(),
|
|
IconOpen: "",
|
|
PcBg: reqConf.GetPcBg(),
|
|
CustomStyle: "",
|
|
PlayRule: reqConf.GetPlayRule(),
|
|
RuleImg: reqConf.GetRuleImg(),
|
|
BgImg: reqConf.GetImagePreview(),
|
|
IconTextColor: reqConf.GetIconTextColor(),
|
|
})
|
|
|
|
if reqConf.GetShare() != nil {
|
|
style.SetShare(reqConf.GetShare())
|
|
}
|
|
|
|
if reqConf.GetIconOpen() != nil {
|
|
style.SetIconOpen(reqConf.GetIconOpen())
|
|
}
|
|
|
|
switch cpn.FissionID {
|
|
case consts.IdPrizeWheel:
|
|
custom := s.Req.GetWheelStyle()
|
|
style.SetWheelStyle(mtype.WheelStyle{
|
|
TopicMark: custom.GetTopicMark(),
|
|
MainImg: custom.GetMainImg(),
|
|
BgColor: custom.GetBgColor(),
|
|
Bottom1: custom.GetBottom1(),
|
|
Bottom2: custom.GetBottom2(),
|
|
Bottom3: custom.GetBottom3(),
|
|
Pointer: custom.GetPointer(),
|
|
PlayBtn: custom.GetPlayBtn(),
|
|
BorderImg: custom.GetBorderImg(),
|
|
ButtonColor: custom.GetButtonColor(),
|
|
WheelTextColor: custom.GetWheelTextColor(),
|
|
})
|
|
case consts.IdLuckyGrid:
|
|
custom := s.Req.GetGridStyle()
|
|
style.SetGridStyle(mtype.GridStyle{
|
|
TopicMark: custom.GetTopicMark(),
|
|
MainImg: custom.GetMainImg(),
|
|
BgColor: custom.GetBgColor(),
|
|
ButtonColor: custom.GetButtonColor(),
|
|
PlayImg: custom.GetPlayImg(),
|
|
DisablePlayImg: custom.GetDisablePlayImg(),
|
|
MachineImg: custom.GetMachineImg(),
|
|
GridImg: custom.GetGridImg(),
|
|
ActivateImg: custom.GetActivateImg(),
|
|
})
|
|
case consts.IdFlip:
|
|
custom := s.Req.GetFlipStyle()
|
|
style.SetFlipStyle(mtype.FlipStyle{
|
|
TopicMark: custom.GetTopicMark(),
|
|
MainImg: custom.GetMainImg(),
|
|
BgColor: custom.GetBgColor(),
|
|
ButtonColor: custom.GetButtonColor(),
|
|
PlayImg: custom.GetPlayImg(),
|
|
CardImg: custom.GetCardImg(),
|
|
})
|
|
case consts.IdGashapon:
|
|
custom := s.Req.GetGashaponStyle()
|
|
|
|
style.SetGashaponStyle(mtype.GashaponStyle{
|
|
TopicMark: custom.GetTopicMark(),
|
|
MainImg: custom.GetMainImg(),
|
|
BgColor: custom.GetBgColor(),
|
|
MachineImg: custom.GetMachineImg(),
|
|
PlayImg: custom.GetPlayImg(),
|
|
EggType: custom.GetEggType(),
|
|
EggImgs: custom.GetEggImgs(),
|
|
})
|
|
}
|
|
|
|
err = s.GetDao().FissionCampaignStyle.WithContext(s.Ctx).Create(style)
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Store) _createGold(cpn *model.FissionCampaign) (err error) {
|
|
gold := s.Req.GetGold()
|
|
|
|
if gold == nil {
|
|
return s.BE().VerifyError("please set gold")
|
|
}
|
|
|
|
conf := withdefault.FissionCampaignGold(&model.FissionCampaignGold{
|
|
CampaignID: cpn.ID,
|
|
GoldNum: gold.GetGoldNum(),
|
|
ExpiredDay: gold.GetExpiredDay(),
|
|
Price: gold.GetPrice(),
|
|
PriceNum: gold.GetPriceNum(),
|
|
Currency: int8(gold.GetCurrency()),
|
|
})
|
|
|
|
m := s.GetDao().FissionCampaignGold
|
|
|
|
if err = m.WithContext(s.Ctx).Create(conf); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Store) _createCoin(cpn *model.FissionCampaign) (err error) {
|
|
coin := s.Req.GetCoin()
|
|
|
|
if coin == nil {
|
|
return s.BE().VerifyError("please set coin")
|
|
}
|
|
|
|
lackBtn, _ := jsonm.ToSliceString(coin.GetLackBtn())
|
|
conf := withdefault.FissionCampaignCoin(&model.FissionCampaignCoin{
|
|
CampaignID: cpn.ID,
|
|
CoinImg: coin.GetCoinImg(),
|
|
OpenDays: coin.GetOpenDays(),
|
|
OpenLimit: coin.GetOpenLimit(),
|
|
InitCoin: coin.GetInitCoin(),
|
|
InitUse: coin.GetInitUse(),
|
|
UseCoin: coin.GetUseCoin(),
|
|
UseLimit: coin.GetUseLimit(),
|
|
URLID: coin.GetUrlId(),
|
|
LackBtn: lackBtn,
|
|
CustomBtnText: coin.GetCustomBtnText(),
|
|
CustomWebURL: coin.GetCustomWebUrl(),
|
|
CustomExtraParam: coin.GetCustomExtraParam(),
|
|
CustomPcParam: coin.GetCustomPcParam(),
|
|
})
|
|
|
|
m := s.GetDao().FissionCampaignCoin
|
|
if err = m.WithContext(s.Ctx).Create(conf); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
_, dayStart, _ := timez.GMTStartAndEndTs(cpn.TOffset, cpn.StartTime)
|
|
_, nowStart, _ := timez.GMTStartAndEndTs(cpn.TOffset)
|
|
if dayStart < nowStart {
|
|
dayStart = nowStart
|
|
}
|
|
|
|
openTime := dayStart + int64(coin.OpenDays*consts.DaySec)
|
|
rewardTime := openTime + consts.DaySec
|
|
|
|
scene := withdefault.FissionCoinScene(&model.FissionCoinScene{
|
|
CampaignID: cpn.ID,
|
|
OpenTime: openTime,
|
|
InitCoin: coin.GetInitCoin(),
|
|
InitUse: coin.GetInitUse(),
|
|
RewardTime: rewardTime,
|
|
})
|
|
|
|
if err = s.GetDao().FissionCoinScene.WithContext(s.Ctx).Create(scene); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
if !verify.InArray[int32](mtype.FissionCampaignCoinLackBtnCustom, coin.GetLackBtn()...) {
|
|
return
|
|
}
|
|
|
|
customBtn := withdefault.FissionCustomBtn(&model.FissionCustomBtn{
|
|
CampaignID: cpn.ID,
|
|
BtnText: coin.GetCustomBtnText(),
|
|
})
|
|
|
|
if err = s.GetDao().FissionCustomBtn.WithContext(s.Ctx).Create(customBtn); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Store) _copyImg(cpnId, copyId, langId int64) (imgs []*model.FissionCampaignLongImg, zones []*model.FissionCampaignLongImgZone, err error) {
|
|
|
|
if len(s.Req.GetLongImgs()) == 0 {
|
|
return
|
|
}
|
|
|
|
newImgs := s.Req.GetLongImgs()
|
|
|
|
m := s.GetDao().FissionCampaignLongImg
|
|
oldImgs, err := m.WithContext(s.Ctx).
|
|
Where(
|
|
m.CampaignID.Eq(copyId),
|
|
m.LangID.Eq(0),
|
|
m.IsDel.Eq(mtype.No),
|
|
).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var oldMap = make(map[string]*model.FissionCampaignLongImg, len(oldImgs))
|
|
for _, v := range oldImgs {
|
|
oldMap[v.ImgURL] = v
|
|
}
|
|
|
|
langImgs, err := m.WithContext(s.Ctx).
|
|
Where(
|
|
m.CampaignID.Eq(copyId),
|
|
m.LangID.Eq(langId),
|
|
m.IsDel.Eq(mtype.No),
|
|
).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var langMap = make(map[int64]*model.FissionCampaignLongImg, len(langImgs))
|
|
for _, v := range langImgs {
|
|
|
|
if v.LangSourceID > 0 {
|
|
langMap[v.LangSourceID] = v
|
|
|
|
continue
|
|
}
|
|
|
|
one := withdefault.FissionCampaignLongImg(&model.FissionCampaignLongImg{
|
|
CampaignID: cpnId,
|
|
LangID: 0,
|
|
ClickType: v.ClickType,
|
|
ImgURL: v.ImgURL,
|
|
WebURL: v.WebURL,
|
|
AppParam: v.AppParam,
|
|
PcParam: v.PcParam,
|
|
TargetType: v.TargetType,
|
|
TargetID: v.TargetID,
|
|
})
|
|
|
|
if v.ClickType == mtype.FissionCampaignLongImgClickTypeZone {
|
|
zoneM := s.GetDao().FissionCampaignLongImgZone
|
|
|
|
var oldZones []*model.FissionCampaignLongImgZone
|
|
oldZones, err = zoneM.WithContext(s.Ctx).Where(zoneM.CampaignID.Eq(copyId), zoneM.ImgID.Eq(v.ID), zoneM.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
for _, hotZone := range oldZones {
|
|
zones = append(zones, withdefault.FissionCampaignLongImgZone(&model.FissionCampaignLongImgZone{
|
|
CampaignID: cpnId,
|
|
ImgID: one.ID,
|
|
WebURL: hotZone.WebURL,
|
|
AppParam: hotZone.AppParam,
|
|
PcParam: hotZone.PcParam,
|
|
ClickX: hotZone.ClickX,
|
|
ClickY: hotZone.ClickY,
|
|
ClickH: hotZone.ClickH,
|
|
ClickW: hotZone.ClickW,
|
|
TargetType: hotZone.TargetType,
|
|
TargetID: hotZone.TargetID,
|
|
}))
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
for _, v := range newImgs {
|
|
|
|
copyImg, ok := oldMap[v.GetImgUrl()]
|
|
if !ok {
|
|
one := withdefault.FissionCampaignLongImg(&model.FissionCampaignLongImg{
|
|
CampaignID: cpnId,
|
|
LangID: 0,
|
|
LangSourceID: s.langSourceMap[v.GetImgUrl()],
|
|
ClickType: int8(v.GetClickType()),
|
|
ImgURL: v.GetImgUrl(),
|
|
WebURL: v.GetWebUrl(),
|
|
AppParam: v.GetAppParam(),
|
|
PcParam: v.GetPcParam(),
|
|
TargetType: int8(v.GetTargetType()),
|
|
TargetID: v.GetTargetId(),
|
|
})
|
|
|
|
if v.GetClickType() == mtype.FissionCampaignLongImgClickTypeZone {
|
|
for _, hotZone := range v.GetHotZone() {
|
|
zones = append(zones, withdefault.FissionCampaignLongImgZone(&model.FissionCampaignLongImgZone{
|
|
CampaignID: cpnId,
|
|
ImgID: one.ID,
|
|
WebURL: hotZone.GetWebUrl(),
|
|
AppParam: hotZone.GetAppParam(),
|
|
PcParam: hotZone.GetPcParam(),
|
|
ClickX: hotZone.GetClickX(),
|
|
ClickY: hotZone.GetClickY(),
|
|
ClickH: hotZone.GetClickH(),
|
|
ClickW: hotZone.GetClickW(),
|
|
TargetType: int8(hotZone.GetTargetType()),
|
|
TargetID: hotZone.GetTargetId(),
|
|
}))
|
|
}
|
|
}
|
|
|
|
imgs = append(imgs, one)
|
|
|
|
continue
|
|
}
|
|
|
|
old, ok := langMap[copyImg.ID]
|
|
if !ok {
|
|
one := withdefault.FissionCampaignLongImg(&model.FissionCampaignLongImg{
|
|
CampaignID: cpnId,
|
|
LangID: 0,
|
|
LangSourceID: s.langSourceMap[v.GetImgUrl()],
|
|
ClickType: int8(v.GetClickType()),
|
|
ImgURL: v.GetImgUrl(),
|
|
WebURL: v.GetWebUrl(),
|
|
AppParam: v.GetAppParam(),
|
|
PcParam: v.GetPcParam(),
|
|
TargetType: int8(v.GetTargetType()),
|
|
TargetID: v.GetTargetId(),
|
|
})
|
|
|
|
if v.GetClickType() == mtype.FissionCampaignLongImgClickTypeZone {
|
|
for _, hotZone := range v.GetHotZone() {
|
|
zones = append(zones, withdefault.FissionCampaignLongImgZone(&model.FissionCampaignLongImgZone{
|
|
CampaignID: cpnId,
|
|
ImgID: one.ID,
|
|
WebURL: hotZone.GetWebUrl(),
|
|
AppParam: hotZone.GetAppParam(),
|
|
PcParam: hotZone.GetPcParam(),
|
|
ClickX: hotZone.GetClickX(),
|
|
ClickY: hotZone.GetClickY(),
|
|
ClickH: hotZone.GetClickH(),
|
|
ClickW: hotZone.GetClickW(),
|
|
TargetType: int8(hotZone.GetTargetType()),
|
|
TargetID: hotZone.GetTargetId(),
|
|
}))
|
|
}
|
|
}
|
|
|
|
imgs = append(imgs, one)
|
|
|
|
continue
|
|
}
|
|
|
|
var targetType = old.TargetType
|
|
var targetId = old.TargetID
|
|
|
|
if old.TargetID != v.GetTargetId() {
|
|
targetType = int8(v.GetTargetType())
|
|
targetId = v.GetTargetId()
|
|
}
|
|
|
|
one := withdefault.FissionCampaignLongImg(&model.FissionCampaignLongImg{
|
|
CampaignID: cpnId,
|
|
LangID: 0,
|
|
LangSourceID: s.langSourceMap[v.GetImgUrl()],
|
|
ClickType: int8(v.GetClickType()),
|
|
ImgURL: old.ImgURL,
|
|
WebURL: old.WebURL,
|
|
AppParam: old.AppParam,
|
|
PcParam: old.PcParam,
|
|
TargetType: targetType,
|
|
TargetID: targetId,
|
|
})
|
|
|
|
if v.GetClickType() == mtype.FissionCampaignLongImgClickTypeZone {
|
|
|
|
switch old.ClickType {
|
|
case mtype.FissionCampaignLongImgClickTypeZone:
|
|
zoneM := s.GetDao().FissionCampaignLongImgZone
|
|
|
|
var oldZones []*model.FissionCampaignLongImgZone
|
|
oldZones, err = zoneM.WithContext(s.Ctx).Where(zoneM.CampaignID.Eq(copyId), zoneM.ImgID.Eq(old.ID), zoneM.IsDel.Eq(mtype.No)).Find()
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
for _, hotZone := range oldZones {
|
|
zones = append(zones, withdefault.FissionCampaignLongImgZone(&model.FissionCampaignLongImgZone{
|
|
CampaignID: cpnId,
|
|
ImgID: one.ID,
|
|
WebURL: hotZone.WebURL,
|
|
AppParam: hotZone.AppParam,
|
|
PcParam: hotZone.PcParam,
|
|
ClickX: hotZone.ClickX,
|
|
ClickY: hotZone.ClickY,
|
|
ClickH: hotZone.ClickH,
|
|
ClickW: hotZone.ClickW,
|
|
TargetType: hotZone.TargetType,
|
|
TargetID: hotZone.TargetID,
|
|
}))
|
|
}
|
|
|
|
case mtype.FissionCampaignLongImgClickTypeAll:
|
|
for _, hotZone := range v.GetHotZone() {
|
|
zones = append(zones, withdefault.FissionCampaignLongImgZone(&model.FissionCampaignLongImgZone{
|
|
CampaignID: cpnId,
|
|
ImgID: one.ID,
|
|
WebURL: hotZone.GetWebUrl(),
|
|
AppParam: hotZone.GetAppParam(),
|
|
PcParam: hotZone.GetPcParam(),
|
|
ClickX: hotZone.GetClickX(),
|
|
ClickY: hotZone.GetClickY(),
|
|
ClickH: hotZone.GetClickH(),
|
|
ClickW: hotZone.GetClickW(),
|
|
TargetType: int8(hotZone.GetTargetType()),
|
|
TargetID: hotZone.GetTargetId(),
|
|
}))
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Store) _createPointsUse(cpn *model.FissionCampaign) (err error) {
|
|
req := s.Req.GetPointsUse()
|
|
if req.GetOpen() != mtype.Yes {
|
|
return
|
|
}
|
|
|
|
pointUse := withdefault.FissionCampaignPointsUse(&model.FissionCampaignPointsUse{
|
|
CampaignID: cpn.ID,
|
|
Icon: req.GetIcon(),
|
|
URLID: req.GetUrlId(),
|
|
UseNum: req.GetUseNum(),
|
|
DayLimit: req.GetDayLimit(),
|
|
TotalLimit: req.GetTotalLimit(),
|
|
})
|
|
|
|
err = s.GetDao().FissionCampaignPointsUse.WithContext(s.Ctx).Create(pointUse)
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Store) _createChat(cpn *model.FissionCampaign) (err error) {
|
|
req := s.Req.GetChat()
|
|
if req.GetOpen() != mtype.Yes {
|
|
return
|
|
}
|
|
|
|
chat := withdefault.FissionCampaignChat(&model.FissionCampaignChat{
|
|
CampaignID: cpn.ID,
|
|
HeaderImg: req.GetHeaderImg(),
|
|
ChatBg: req.GetChatBg(),
|
|
DayLimit: req.GetDayLimit(),
|
|
})
|
|
|
|
err = s.GetDao().FissionCampaignChat.WithContext(s.Ctx).Create(chat)
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Store) _createVs(cpn *model.FissionCampaign) (err error) {
|
|
vs := s.Req.GetVs()
|
|
|
|
conf := withdefault.FissionCampaignVs(&model.FissionCampaignV{
|
|
CampaignID: cpn.ID,
|
|
InitChance: vs.GetInitChance(),
|
|
EachLimitNum: vs.GetEachLimitNum(),
|
|
OpenPoint: int8(vs.GetOpenPoint()),
|
|
PointsNum: vs.GetPointsNum(),
|
|
MallOpen: int8(vs.GetMallOpen()),
|
|
MallID: vs.GetMallId(),
|
|
VsTz: vs.GetVsTz(),
|
|
ClaimType: int8(vs.GetClaimType()),
|
|
IconMall: vs.GetIconMall(),
|
|
IconReward: vs.GetIconReward(),
|
|
IconSchedule: vs.GetIconSchedule(),
|
|
})
|
|
|
|
m := s.GetDao().FissionCampaignV
|
|
if err = m.WithContext(s.Ctx).Create(conf); err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var emptyId int64 = -1
|
|
var schedules []*model.FissionCampaignVsSchedule
|
|
var teams []*model.FissionCampaignVsTeam
|
|
for i, v := range vs.GetSchedules() {
|
|
for _, pk := range v.GetPkTeams() {
|
|
|
|
var vsTeamIds []int64
|
|
for _, team := range pk.GetTeams() {
|
|
|
|
if team.GetName() == "" && team.GetLogoImg() == "" {
|
|
vsTeamIds = append(vsTeamIds, emptyId)
|
|
emptyId--
|
|
continue
|
|
}
|
|
|
|
one := withdefault.FissionCampaignVsTeam(&model.FissionCampaignVsTeam{
|
|
CampaignID: cpn.ID,
|
|
Name: team.GetName(),
|
|
LogoImg: team.GetLogoImg(),
|
|
})
|
|
|
|
vsTeamIds = append(vsTeamIds, one.ID)
|
|
teams = append(teams, one)
|
|
}
|
|
|
|
var rewardNum int32 = 1
|
|
if pk.GetPropMark() == mtype.FissionCampaignRewardPropMarkPoint {
|
|
rewardNum = pk.GetPropNum()
|
|
}
|
|
|
|
rewardId := hashid.IdBigint()
|
|
s._otherAppendReward(&model.FissionCampaignReward{
|
|
ID: rewardId,
|
|
CampaignID: cpn.ID,
|
|
Stock: -1,
|
|
RewardType: mtype.FissionCampaignRewardTypeApp,
|
|
RewardNum: rewardNum,
|
|
RewardID: pk.GetRewardId(),
|
|
PropMark: pk.GetPropMark(),
|
|
ExpiredDay: pk.GetExpiredDay(),
|
|
})
|
|
|
|
voteStart, _ := timez.YmdHiParse(pk.GetVoteStart(), vs.GetVsTz())
|
|
voteEnd, _ := timez.YmdHiParse(pk.GetVoteEnd(), vs.GetVsTz())
|
|
vsAt, _ := timez.YmdHiParse(pk.GetVsDate(), vs.GetVsTz())
|
|
|
|
schedules = append(schedules, withdefault.FissionCampaignVsSchedule(&model.FissionCampaignVsSchedule{
|
|
CampaignID: cpn.ID,
|
|
VsIdx: int32(i),
|
|
RewardID: rewardId,
|
|
VsTeamIds: "",
|
|
VoteStart: voteStart.Unix(),
|
|
VoteEnd: voteEnd.Unix(),
|
|
VsAt: vsAt.Unix(),
|
|
VsImg: pk.GetVsImg(),
|
|
Desc: pk.GetDesc(),
|
|
OpenOdds: int8(pk.GetOpenOdds()),
|
|
OddsLeft: pk.GetOddsLeft(),
|
|
OddsRight: pk.GetOddsRight(),
|
|
OddsDraw: pk.GetOddsDraw(),
|
|
}, vsTeamIds, pk.GetOtherVote()))
|
|
}
|
|
}
|
|
|
|
if err = s.GetDao().FissionCampaignVsSchedule.WithContext(s.Ctx).Create(schedules...); err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
if err = s.GetDao().FissionCampaignVsTeam.WithContext(s.Ctx).Create(teams...); err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
if vs.GetMallOpen() == mtype.No {
|
|
return
|
|
}
|
|
|
|
relate, err := malls.NewRelate(s.Ctx, cpn.ID, s.GetDao().FissionCampaign.TableName(), logic.WithDao(s.GetDao()))
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
return relate.Related(mtype.RedeemMallRelateSourceCampaign, vs.GetMallId())
|
|
}
|
|
|
|
func (s *Store) _createUno(cpn *model.FissionCampaign) (err error) {
|
|
uno := s.Req.GetUno()
|
|
|
|
conf := withdefault.FissionCampaignUno(&model.FissionCampaignUno{
|
|
CampaignID: cpn.ID,
|
|
InitChance: uno.GetInitChance(),
|
|
}, uno.GetPropMarks())
|
|
|
|
m := s.GetDao().FissionCampaignUno
|
|
if err = m.WithContext(s.Ctx).Create(conf); err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
|
|
var groups []*model.FissionCampaignUnoGroup
|
|
var cards []*model.FissionCampaignUnoCard
|
|
|
|
var fn = func(mark string, unoG *pb.StoreReq_UnoGroup) {
|
|
|
|
rewardId := hashid.IdBigint()
|
|
s._otherAppendReward(&model.FissionCampaignReward{
|
|
ID: rewardId,
|
|
CampaignID: cpn.ID,
|
|
RewardType: mtype.FissionCampaignRewardTypeApp,
|
|
RewardID: unoG.GetReward().GetRewardId(),
|
|
Stock: unoG.GetReward().GetStock(),
|
|
})
|
|
|
|
group := withdefault.FissionCampaignUnoGroup(&model.FissionCampaignUnoGroup{
|
|
CampaignID: cpn.ID,
|
|
Mark: mark,
|
|
Odds: unoG.GetOdds(),
|
|
RewardID: rewardId,
|
|
OpenRule: int8(unoG.GetOpenRule()),
|
|
LimitRule: "",
|
|
CustomCard: int8(unoG.GetCustomCard()),
|
|
}, mtype.UnoLimitRule{
|
|
InitNum: unoG.GetLimitRule().GetInitNum(),
|
|
SignDay: unoG.GetLimitRule().GetSignDay(),
|
|
AddNum: unoG.GetLimitRule().GetAddNum(),
|
|
ResetType: unoG.GetLimitRule().GetResetType(),
|
|
})
|
|
|
|
groups = append(groups, group)
|
|
|
|
if unoG.GetCustomCard() == mtype.No {
|
|
return
|
|
}
|
|
|
|
for i, card := range unoG.GetCards() {
|
|
cards = append(cards, withdefault.FissionCampaignUnoCard(&model.FissionCampaignUnoCard{
|
|
CampaignID: cpn.ID,
|
|
Mark: mark,
|
|
CardNo: int32(i) + 1,
|
|
Title: card.GetTitle(),
|
|
ImgURL: card.GetImgUrl(),
|
|
WebURL: card.GetWebUrl(),
|
|
AppParam: card.GetAppParam(),
|
|
PcParam: card.GetPcParam(),
|
|
}))
|
|
}
|
|
}
|
|
|
|
fn(mtype.FissionCampaignUnoGroupRed, uno.GetRed())
|
|
fn(mtype.FissionCampaignUnoGroupYellow, uno.GetYellow())
|
|
fn(mtype.FissionCampaignUnoGroupBlue, uno.GetBlue())
|
|
fn(mtype.FissionCampaignUnoGroupGreen, uno.GetGreen())
|
|
|
|
if len(groups) > 0 {
|
|
if err = s.GetDao().FissionCampaignUnoGroup.WithContext(s.Ctx).Create(groups...); err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
}
|
|
|
|
if len(cards) > 0 {
|
|
if err = s.GetDao().FissionCampaignUnoCard.WithContext(s.Ctx).Create(cards...); err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Store) createEvent(cpn *model.FissionCampaign) (err error) {
|
|
events := s.Req.GetEvent()
|
|
|
|
var add []*model.FissionCampaignEvent
|
|
|
|
if event := events.GetFirstVisit(); event.GetOpen() == mtype.Yes {
|
|
var rewards = make([]*mtype.EventReward, 0, len(event.GetRewards()))
|
|
for _, reward := range event.GetRewards() {
|
|
switch reward.GetPropMark() {
|
|
case mtype.FissionCampaignRewardPropMarkReward:
|
|
rewardId := hashid.IdBigint()
|
|
s._otherAppendReward(&model.FissionCampaignReward{
|
|
ID: rewardId,
|
|
CampaignID: cpn.ID,
|
|
Stock: reward.GetReward().GetStock(),
|
|
RewardType: mtype.FissionCampaignRewardTypeCampaignEvent,
|
|
RewardNum: 1,
|
|
RewardID: reward.GetReward().GetRewardId(),
|
|
PropMark: mtype.FissionCampaignRewardPropMarkReward,
|
|
})
|
|
|
|
rewards = append(rewards, &mtype.EventReward{
|
|
Id: hashid.IdBigint(),
|
|
PropMark: reward.GetPropMark(),
|
|
RewardId: rewardId,
|
|
})
|
|
case mtype.FissionCampaignRewardPropMarkPoint:
|
|
rewardId := hashid.IdBigint()
|
|
s._otherAppendReward(&model.FissionCampaignReward{
|
|
ID: rewardId,
|
|
CampaignID: cpn.ID,
|
|
Stock: -1,
|
|
RewardType: mtype.FissionCampaignRewardTypeCampaignEvent,
|
|
RewardNum: reward.GetChance(),
|
|
PropMark: mtype.FissionCampaignRewardPropMarkPoint,
|
|
ExpiredDay: reward.GetExpiredDay(),
|
|
})
|
|
rewards = append(rewards, &mtype.EventReward{
|
|
Id: hashid.IdBigint(),
|
|
PropMark: reward.GetPropMark(),
|
|
RewardId: rewardId,
|
|
Chance: reward.GetChance(),
|
|
})
|
|
case mtype.FissionCampaignRewardPropMarkChance:
|
|
rewards = append(rewards, &mtype.EventReward{
|
|
Id: hashid.IdBigint(),
|
|
PropMark: reward.GetPropMark(),
|
|
Chance: reward.GetChance(),
|
|
})
|
|
}
|
|
}
|
|
|
|
add = append(add, withdefault.FissionCampaignEvent(&model.FissionCampaignEvent{
|
|
CampaignID: cpn.ID,
|
|
Mark: mtype.FissionCampaignEventMarkFirstVisit,
|
|
Open: mtype.Yes,
|
|
}, rewards))
|
|
}
|
|
|
|
if len(add) > 0 {
|
|
err = s.GetDao().FissionCampaignEvent.WithContext(s.Ctx).Create(add...)
|
|
if err != nil {
|
|
err = s.BE().MysqlError(err)
|
|
return
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Store) _createGashapon(cpn *model.FissionCampaign) (err error) {
|
|
gashapon := s.Req.GetGashapon()
|
|
|
|
if gashapon == nil {
|
|
return s.BE().VerifyError("please set gashapon")
|
|
}
|
|
|
|
conf := withdefault.FissionCampaignGashapon(&model.FissionCampaignGashapon{
|
|
CampaignID: cpn.ID,
|
|
InitChance: gashapon.GetInitChance(),
|
|
DayChance: gashapon.GetDayChance(),
|
|
})
|
|
|
|
m := s.GetDao().FissionCampaignGashapon
|
|
|
|
if err = m.WithContext(s.Ctx).Create(conf); err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Store) createRewardAdd(cpn *model.FissionCampaign) (err error) {
|
|
var list = make([]*model.FissionCampaignRewardAdd, 0, len(s.rewardAdd))
|
|
for id, add := range s.rewardAdd {
|
|
|
|
if add.GetOpen() == mtype.No {
|
|
continue
|
|
}
|
|
|
|
list = append(list, withdefault.FissionCampaignRewardAdd(&model.FissionCampaignRewardAdd{
|
|
CampaignID: cpn.ID,
|
|
RewardID: id,
|
|
Start: timez.GMT(add.GetStart(), cpn.TOffset),
|
|
End: timez.GMT(add.End, cpn.TOffset),
|
|
DayNum: add.GetDayNum(),
|
|
DayAdd: add.GetDayAdd(),
|
|
}))
|
|
|
|
}
|
|
|
|
if len(list) == 0 {
|
|
return
|
|
}
|
|
|
|
err = s.GetDao().FissionCampaignRewardAdd.WithContext(s.Ctx).Create(list...)
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Store) createRewardTask(cpn *model.FissionCampaign) (err error) {
|
|
var conds = make([]*model.FissionCampaignCond, 0, len(s.rewardTask))
|
|
var tasks = make([]*model.FissionCampaignTask, 0, len(s.rewardTask))
|
|
for id, add := range s.rewardTask {
|
|
|
|
if add.GetOpen() == mtype.No {
|
|
continue
|
|
}
|
|
|
|
one := withdefault.FissionCampaignCond(&model.FissionCampaignCond{
|
|
CampaignID: cpn.ID,
|
|
ProjectID: cpn.ProjectID,
|
|
Event: add.GetEvent(),
|
|
EventKey: add.GetEventKey(),
|
|
EventVal: add.GetEventVal(),
|
|
IfCond: int8(add.GetIfCond()),
|
|
TriggetType: int8(add.GetTriggerType()),
|
|
EventType: int8(add.GetEventType()),
|
|
OpenPush: int8(add.GetOpenPush()),
|
|
RewardID: id,
|
|
})
|
|
|
|
conds = append(conds, one)
|
|
|
|
tasks = append(tasks, withdefault.FissionCampaignTask(&model.FissionCampaignTask{
|
|
CampaignID: cpn.ID,
|
|
TaskType: mtype.FissionCampaignTaskTypeCondOne,
|
|
TaskMark: utils.FissionCampaignTaskMarkCondOneVal(one.ID),
|
|
PropMark: mtype.FissionCampaignTaskPropMarkUnlockReward,
|
|
Num: 1,
|
|
Chance: 1,
|
|
RewardID: id,
|
|
}))
|
|
}
|
|
|
|
if len(conds) == 0 {
|
|
return
|
|
}
|
|
|
|
err = s.GetDao().FissionCampaignCond.WithContext(s.Ctx).Create(conds...)
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
err = s.GetDao().FissionCampaignTask.WithContext(s.Ctx).Create(tasks...)
|
|
if err != nil {
|
|
return s.BE().MysqlError(err)
|
|
}
|
|
|
|
return
|
|
}
|