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 = &copyQuit{
		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 := &copyOption{
			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 := &copyQuestion{
			copyId:  0,
			qa:      &mtype.LangQuestions{},
			options: make([]*copyOption, 0, len(optionMap[qa.ID])),
		}

		for _, option := range optionMap[qa.ID] {
			one.options = append(one.options, &copyOption{
				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, &copyTalk{
			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
}