joybuywork/internal/service/containers/campaign/update.go

package campaign

import (
	"joybuywork/internal/app"
	"joybuywork/internal/consts"
	"joybuywork/internal/consts/ckey"
	"joybuywork/internal/plugins/hashid"
	"joybuywork/internal/plugins/jsonm"
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/dao"
	"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/malls"
	"joybuywork/internal/service/provider/stocks"
	"joybuywork/internal/service/queue/producer"
	"joybuywork/internal/service/queue/types"
	"joybuywork/internal/utils"
	"joybuywork/internal/utils/logic"
	"joybuywork/internal/utils/timez"
	"joybuywork/internal/utils/verify"
	pb "joybuywork/proto/go_proto/w_campaign"
	"joybuywork/proto/go_proto/workerr"
	"fmt"
	"strings"
	"time"

	dlinkpb "gits.branchcn.com/backend/deeplink/proto/go_proto/dlink"
	"gits.branchcn.com/backend/microcode/plugins/derivative/vercontrol"
	"gorm.io/gen/field"
)

type Update struct {
	logic.Logic
	Req *pb.UpdateReq
	Res *pb.UpdateRes

	justUpdatePart bool // 只能更新部分数据数据

	// 统计任务结束时间修改，统计任务的达标条件统计要删除，统计任务的达标条件统计要添加，修改了进行中活动的监听方式
	taskEndChange, taskCondDel, taskCondAdd bool

	helpInstall, helpRegister, helpOpen, helpClick bool

	otherReward    []*model.FissionCampaignReward
	otherRelateIds []int64
	otherRelateMap map[int64]struct{}

	changeTemp bool

	rewardAdd  map[int64]*pb.UpdateReq_OpenAdd
	rewardTask map[int64]*pb.UpdateReq_RewardTask
}

func (s *Update) Run() error {
	return logic.Run(s)
}

func (s *Update) Exec() (err error) {
	cpn, err := s.update()
	if err != nil {
		return
	}

	err = s.updateConfig(cpn)
	if err != nil {
		return
	}

	err = s.updateFission(cpn)
	if err != nil {
		return
	}

	err = s.updateEvent(cpn)
	if err != nil {
		return
	}

	err = s.updateReward(cpn)
	if err != nil {
		return
	}

	err = s.updateRewardAdd(cpn)
	if err != nil {
		return
	}

	err = s.updateRewardTask(cpn)
	if err != nil {
		return
	}

	err = s.updateTask(cpn)
	if err != nil {
		return
	}

	err = s.updatePush(cpn)
	if err != nil {
		return
	}

	err = s.updateChild(cpn)
	if err != nil {
		return
	}

	err = s.syncEvent(cpn)
	if err != nil {
		return
	}

	err = s.syncLinkTemp(cpn)
	if err != nil {
		return
	}

	err = s.saveDelayLinkData(cpn)
	if err != nil {
		return
	}

	return
}

// 更新活动数据
func (s *Update) update() (cpn *model.FissionCampaign, err error) {
	cpn, err = finder.Campaign(s.Ctx, s.Req.GetId(), s.Req.GetHashId())
	if err != nil {
		return nil, s.BE().MysqlError(err)
	}

	if cpn == nil || cpn.IsDel == mtype.Yes {
		return nil, workerr.NotFound("nof found campaign")
	}

	s.otherRelateMap = make(map[int64]struct{})
	s.rewardAdd = make(map[int64]*pb.UpdateReq_OpenAdd)
	s.rewardTask = make(map[int64]*pb.UpdateReq_RewardTask)

	var endTime = timez.GMT(s.Req.GetEndTime(), s.Req.GetTOffset())
	m := s.GetDao().FissionCampaign
	var data = []field.AssignExpr{
		m.Title.Value(s.Req.GetTitle()),
		m.TEnd.Value(s.Req.GetEndTime()),
		m.EndTime.Value(endTime),
	}

	// 待发布状态可以更新的数据
	if cpn.Status == mtype.FissionCampaignStatusWait {
		start := timez.GMT(s.Req.GetStartTime(), s.Req.GetTOffset())

		data = append(data,
			m.TOffset.Value(s.Req.GetTOffset()),
			m.TStart.Value(s.Req.GetStartTime()),
			m.StartTime.Value(start),
		)

		// 已经开始了活动
		if start <= time.Now().Unix() {
			status := utils.Ternary[int8](s.Req.GetConfig().GetHasWhite() == mtype.Yes, mtype.FissionCampaignStatusPubPre, mtype.FissionCampaignStatusPub)
			data = append(data, m.Status.Value(status))
			if cpn.FissionID == consts.IdDice {
				s.AddAfterRun(func() (err error) {
					producer.NewCampaignNotice(s.Ctx).CampaignDiceMap(types.CampaignDiceMap{CampaignId: cpn.ID})
					return
				})
			}
		}
	} else if cpn.Status == mtype.FissionCampaignStatusPubPre {
		// 正式发布
		if s.Req.GetConfig().GetHasWhite() == mtype.No {
			data = append(data, m.Status.Value(mtype.FissionCampaignStatusPub))
		}
	}

	_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(cpn.ID)).UpdateSimple(data...)
	if err != nil {
		return nil, s.BE().MysqlError(err)
	}

	if endTime != cpn.EndTime {
		s.taskEndChange = true
	}

	s.justUpdatePart = cpn.Status != mtype.FissionCampaignStatusWait &&
		!verify.InArray[int64](cpn.FissionID, consts.IdKeep, consts.IdCoin, consts.IdVs, consts.IdUno)

	switch cpn.FissionID {
	case consts.IdKeep:
		invite := s.Req.GetKeepDog()
		s.Req.TargetOption.Fixed = &pb.UpdateReq_Fixed{
			Open:      invite.GetOpenInvite(),
			AppEvent:  invite.GetInvite().GetInviteType(),
			TargetNum: 1,
			Chance:    invite.GetInvite().GetInviteGet(),
			Percent:   0,
		}
	case consts.IdPrizeAnswer:
		s.Req.TargetOption.Fixed = &pb.UpdateReq_Fixed{
			Open:      1,
			AppEvent:  1,
			TargetNum: s.Req.GetQuestionAnswer().GetTargetNum(),
			Chance:    s.Req.GetQuestionAnswer().GetChance(),
			Percent:   0,
		}
	case consts.IdPrizeQuiz:
		s.Req.TargetOption.Fixed = &pb.UpdateReq_Fixed{
			Open:      1,
			AppEvent:  1,
			TargetNum: s.Req.GetQuiz().GetTargetNum(),
			Chance:    s.Req.GetQuiz().GetChance(),
			Percent:   0,
		}
	}

	if !verify.InArray[int64](cpn.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.Res.Id = cpn.ID
		s.Res.HashId = cpn.HashID

		_ = cache.NewCampaign(s.Ctx).Clear(cpn)

		s.OL().User(s.Req.GetUserId(), s.Req.GetIp()).CampaignSave(cpn.ID, s.Req)

		return
	})

	return
}

// 默认的封面图
func (s *Update) _defaultCoverUrl(tempId int64) (url string, err error) {
	temp, err := cache.NewFissionTemp(s.Ctx).FindById(tempId)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if temp == nil {
		return
	}

	group, err := cache.NewFissionTempGroup(s.Ctx).FindById(temp.GroupID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	return group.CoverURL, err
}

// 更新配置
func (s *Update) updateConfig(cpn *model.FissionCampaign) (err error) {
	cc := cache.NewCampaignConfig(s.Ctx)
	conf, err := cc.FindByCampaignId(cpn.ID)
	if err != nil {
		return s.BE().CacheError(err)
	}

	cf := s.Req.GetConfig()
	m := s.GetDao().FissionCampaignConfig

	var data = []field.AssignExpr{
		m.RuleTextColor.Value(cf.GetRuleTextColor()),
		m.RuleBgColor.Value(cf.GetRuleBgColor()),
		m.ShareText.Value(cf.GetShareText()),
		m.ShareImg.Value(cf.GetShareImg()),
		m.HasRank.Value(int8(cf.GetHasRank())),
		m.RankBackgroundColor.Value(cf.GetRankBackgroundColor()),
		m.RankTextColor.Value(cf.GetRankTextColor()),
		m.DownloadPageImage.Value(cf.GetDownloadPageImage()),
		m.IsDefaultDownload.Value(int8(cf.GetIsDefaultDownload())),
		m.WechatPageImage.Value(cf.GetWechatPageImage()),
		m.IsDefaultWechat.Value(int8(cf.GetIsDefaultWechat())),
		m.ImageMain.Value(cf.GetImageMain()),
		m.IsDefaultMain.Value(int8(cf.GetIsDefaultMain())),
		m.ImagePreview.Value(cf.GetImagePreview()),
		m.LinkBtnTextColor.Value(cf.GetLinkBtnTextColor()),
		m.LinkBtnBgColor.Value(cf.GetLinkBtnBgColor()),
		m.LinkTextColor.Value(cf.GetLinkTextColor()),
		m.ShowShare.Value(int8(cf.GetShowShare())),
		m.PageTitle.Value(cf.GetPageTitle()),
		m.DmShow.Value(int8(cf.GetDmShow())),
		m.WebBgImg.Value(cf.GetWebBgImg()),
		m.IconType.Value(int8(cf.GetIconType())),
		m.IconBgColor.Value(cf.GetIconBgColor()),
		m.DlType.Value(int8(cf.GetDlType())),
		m.DlBannerType.Value(int8(cf.GetDlBannerType())),
		m.DlBannerImg.Value(cf.GetDlBannerImg()),
		m.DlBannerAppLogo.Value(cf.GetDlBannerAppLogo()),
		m.DlBannerAppName.Value(cf.GetDlBannerAppName()),
		m.DlBannerAppBtn.Value(cf.GetDlBannerAppBtn()),
		m.DlBannerPosition.Value(int8(cf.GetDlBannerPosition())),
		m.TopicColor.Value(cf.GetTopicColor()),
		m.WindowCover.Value(int8(cf.GetWindowCover())),
		m.PlayRule.Value(cf.GetPlayRule()),
		m.HasLongImg.Value(utils.Ternary[int8](len(s.Req.GetLongImgs()) > 0, mtype.Yes, mtype.No)),
		m.HasWhite.Value(int8(cf.GetHasWhite())),
		m.WhiteList.Value(cf.GetWhiteList()),
		m.PcBg.Value(cf.GetPcBg()),
		m.LinkTempID.Value(cf.GetLinkTempId()),
		m.RuleTimeOpen.Value(int8(cf.GetRuleTimeOpen())),
		m.OutsideTask.Value(int8(cf.GetOutsideTask())),
		m.OpenShare.Value(utils.Ternary[int8](verify.InArray[int64](cpn.FissionID,
			consts.IdSignIn, consts.IdQa, consts.IdQaAudio, consts.IdQaVideo, consts.IdPrizeQuiz, consts.IdPrizeAnswer), int8(cf.GetOpenShare()), 1)),
		m.ShowToUse.Value(int8(cf.GetShowToUse())),
		m.PointsUse.Value(int8(s.Req.GetPointsUse().GetOpen())),
		m.OpenChat.Value(int8(s.Req.GetChat().GetOpen())),
		m.RuleType.Value(int8(cf.GetRuleType())),
		m.RuleOutside.Value(int8(cf.GetRuleOutside())),
		m.DeviceOnce.Value(int8(cf.GetDeviceOnce())),
	}

	defer func() {
		if err != nil {
			return
		}

		_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(conf.ID)).UpdateSimple(data...)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		s.changeTemp = conf.LinkTempID != cf.GetLinkTempId()

		s.AddAfterRun(func() (err error) {
			_ = cache.NewCampaignConfig(s.Ctx).Clear(conf)
			return
		})

	}()

	// 更新长图
	err = s._updateLongImg(conf)
	if err != nil {
		return
	}

	// 更新样式
	err = s._updateStyle(cpn)
	if err != nil {
		return
	}

	err = s._updatePointsUse(cpn)
	if err != nil {
		return
	}

	err = s._updateChat(cpn)
	if err != nil {
		return
	}

	// 社媒分享
	share, _ := jsonm.MarshalToString(cf.GetShare())
	data = append(data, m.Share.Value(share))

	// 开启的挂件
	iconOpen, _ := jsonm.MarshalToString(cf.GetIconOpen())
	data = append(data, m.IconOpen.Value(iconOpen))

	// link_data
	var kvData []*mtype.KV
	for _, v := range s.Req.GetCampaignData() {
		kvData = append(kvData, &mtype.KV{
			Key:   v.Key,
			Value: v.Value,
		})
	}

	kv, _ := jsonm.MarshalToString(kvData)
	data = append(data, m.CampaignData.Value(kv))

	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(cf.GetAdsType()) {
		data = append(data, m.AdsType.Value(int8(cf.GetAdsType())))
		s.OL().User(s.Req.GetUserId(), s.Req.GetIp()).UpdateCampaignAdsType(cpn.ID, conf.AdsType, int8(cf.GetAdsType()))
	}

	// 活动进行中的数据修改
	if s.justUpdatePart {

		// 更新任务名称
		err = s._updateRunningCond(cpn)
		if err != nil {
			return
		}

		return
	}

	project, err := finder.Project(s.Ctx, cpn.ProjectID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	hasWeb := utils.Ternary(len(s.Req.GetRewardsWeb()) > 0 && project.Scene == mtype.ProjectSceneApp, int8(mtype.Yes), mtype.No)
	data = append(data,
		m.HasWeb.Value(hasWeb),
		m.HasWarmUp.Value(int8(cf.GetHasWarmUp())),
		m.WarmUpImg.Value(cf.GetWarmUpImg()),
		m.WarmUpEnd.Value(cf.GetWarmUpEnd()),
	)

	// 重置短链接
	if conf.HasWeb != hasWeb {
		userM := s.GetDao().FissionUser
		_, err = userM.WithContext(s.Ctx).Where(userM.CampaignID.Eq(cpn.ID)).UpdateSimple(userM.ShareLink.Value(""))
		if err != nil {
			return
		}

		userMS := s.GetDao().FissionUser.SubTable(cpn.ID)
		_, err = userMS.WithContext(s.Ctx).Where(userMS.CampaignID.Eq(cpn.ID)).UpdateSimple(userMS.ShareLink.Value(""))
		if err != nil {
			return
		}
	}

	// 设置奖品的配置
	rewardData, err := s._setRewardConfig(cpn, conf.RewardGroup)
	if err != nil {
		return
	}
	data = append(data, rewardData...)

	// 处理活动目标
	if consts.NewEventCpn(cpn.FissionID) {
		data = append(data,
			m.Target.Value(int8(s.Req.GetTargetOption().GetTarget())),
			m.AppEvent.Value(int8(s.Req.GetTargetOption().GetFixed().GetAppEvent())),
			m.BothType.Value(int8(s.Req.GetTargetOption().GetCustom().GetBothType())),
		)
		if s.Req.GetTargetOption().GetCustom().GetOpen() == mtype.Yes {

			option := utils.Ternary[int8](
				!verify.InArray[int64](cpn.FissionID, consts.IdWinTogether, consts.IdReferral),
				mtype.FissionCampaignConfigTargetOptionTask, mtype.FissionCampaignConfigTargetOptionFriend)

			data = append(data, m.Option.Value(option))
		} else {
			data = append(data, m.Option.Value(mtype.FissionCampaignConfigTargetOptionApp))
		}

		err = s._updateTargetOption(cpn)
		if err != nil {
			return
		}

		return
	}

	data = append(data,
		m.Target.Value(int8(s.Req.GetTarget().GetTarget())),
		m.AppEvent.Value(int8(s.Req.GetTarget().GetAppEvent())),
		m.BothType.Value(int8(s.Req.GetTarget().GetBothType())),
		m.Option.Value(int8(s.Req.GetTarget().GetOption())),
	)

	err = s._updateTargetCond(cpn)
	if err != nil {
		return
	}

	// 以前是事件触发的内容，现在变成了非事件触发，就要把统计任务删掉
	if conf.Option != mtype.FissionCampaignConfigTargetOptionApp && s.Req.GetTarget().GetOption() == mtype.FissionCampaignConfigTargetOptionApp {
		s.taskCondDel = true
	}

	if conf.Option == mtype.FissionCampaignConfigTargetOptionApp &&
		verify.InArray(s.Req.GetTarget().GetOption(),
			mtype.FissionCampaignConfigTargetOptionFriend,
			mtype.FissionCampaignConfigTargetOptionUse,
			mtype.FissionCampaignConfigTargetOptionSelf,
			mtype.FissionCampaignConfigTargetOptionTask,
		) {
		s.taskCondAdd = true
	}

	return
}

// 奖品配置
func (s *Update) _setRewardConfig(cpn *model.FissionCampaign, oldRewardGroup int8) (data []field.AssignExpr, err error) {

	// 切换奖品类型，就要把站内的奖全删了
	if int32(oldRewardGroup) != s.Req.GetRewards().GetRewardGroup() {
		m := s.GetDao().FissionCampaignReward
		_, err = m.WithContext(s.Ctx).Where(
			m.CampaignID.Eq(cpn.ID),
			m.RewardType.Eq(mtype.FissionCampaignRewardTypeApp),
			m.IsDel.Eq(mtype.No),
		).UpdateSimple(m.IsDel.Value(mtype.Yes))
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	m := s.GetDao().FissionCampaignConfig
	data = append(data, m.RewardGroup.Value(int8(s.Req.GetRewards().GetRewardGroup())))

	switch s.Req.GetRewards().GetRewardGroup() {
	case mtype.FissionRewardGroupLang:
		var lang = finder.Lang{
			Default: mtype.FissionLangTypeToMark[cpn.GetLangTypes()[0]],
			Support: make([]string, 0, len(s.Req.GetRewards().GetLangs())),
		}

		for _, v := range s.Req.GetRewards().GetLangs() {
			lang.Support = append(lang.Support, v.GetLangMark())
		}

		dft, spt := lang.DST()
		data = append(data, m.DefaultRewardMark.Value(dft), m.SupportRewardMark.Value(spt))
	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())
		}

		dft, spt := level.DST()
		data = append(data, m.DefaultRewardMark.Value(dft), m.SupportRewardMark.Value(spt))

	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)
		}
		dft, spt := langLevel.DST()
		data = append(data, m.DefaultRewardMark.Value(dft), m.SupportRewardMark.Value(spt))

	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())
		}

		dft, spt := country.DST()
		data = append(data, m.DefaultRewardMark.Value(dft), m.SupportRewardMark.Value(spt))
	}

	// 更新等级关系
	err = s._updateLvRelated(cpn, oldRewardGroup)
	if err != nil {
		return
	}

	return
}

func (s *Update) _updateLvRelated(cpn *model.FissionCampaign, oldRewardGroup int8) (err error) {
	m := s.GetDao().FissionUserLevelRelated
	if verify.InArray(oldRewardGroup, mtype.FissionRewardGroupUserLevel, mtype.FissionRewardGroupLangAndUserLevel) &&
		!verify.InArray(s.Req.GetRewards().GetRewardGroup(), mtype.FissionRewardGroupUserLevel, mtype.FissionRewardGroupLangAndUserLevel) {
		_, err = m.WithContext(s.Ctx).
			Where(m.RelateID.Eq(cpn.ID), m.RelateTable.Eq(s.GetDao().FissionCampaign.TableName())).
			UpdateSimple(m.CancelTime.Value(time.Now().Unix()))
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		return
	}

	list, err := m.WithContext(s.Ctx).Where(m.RelateID.Eq(cpn.ID), m.RelateTable.Eq(s.GetDao().FissionCampaign.TableName())).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var oldMap = make(map[int64]*model.FissionUserLevelRelated, len(list))
	for _, v := range list {
		oldMap[v.LevelID] = v
	}

	var add []*model.FissionUserLevelRelated
	var cancelIds, orIds []int64

	var fn = func(list []*pb.UpdateReq_UserLevelOne) {
		for _, v := range list {
			old, ok := oldMap[v.GetLevelId()]
			if !ok {
				add = append(add, withdefault.FissionUserLevelRelated(&model.FissionUserLevelRelated{
					LevelID:     v.GetLevelId(),
					RelateID:    cpn.ID,
					RelateTable: s.GetDao().FissionCampaign.TableName(),
					CancelTime:  0,
				}))
				continue
			}

			if old.CancelTime > 0 {
				orIds = append(orIds, old.ID)
			}

			delete(oldMap, v.GetLevelId())
		}
	}

	switch s.Req.GetRewards().GetRewardGroup() {
	case mtype.FissionRewardGroupUserLevel:
		fn(s.Req.GetRewards().GetUserLevel().GetLevelList())
	case mtype.FissionRewardGroupLangAndUserLevel:
		for _, v := range s.Req.GetRewards().GetLangUserLevel() {
			fn(v.GetLevelList())
		}
	}

	for _, v := range oldMap {
		cancelIds = append(cancelIds, v.ID)
	}

	if len(add) > 0 {
		err = m.WithContext(s.Ctx).Create(add...)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	if len(orIds) > 0 {
		_, err = m.WithContext(s.Ctx).Where(m.ID.In(orIds...)).UpdateSimple(m.CancelTime.Value(0))
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	if len(cancelIds) > 0 {
		_, err = m.WithContext(s.Ctx).Where(m.ID.In(cancelIds...)).UpdateSimple(m.CancelTime.Value(time.Now().Unix()))
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	return
}

// 更新目标配置
func (s *Update) _updateTargetOption(cpn *model.FissionCampaign) (err error) {
	m := s.GetDao().FissionCampaignTicket
	tickets, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID)).Find()
	if err != nil {
		return
	}

	var ticketMap = make(map[string]*model.FissionCampaignTicket, len(tickets))
	for _, ticket := range tickets {
		ticketMap[ticket.Mark] = ticket
	}

	taskM := s.GetDao().FissionCampaignTask
	oldTasks, err := taskM.WithContext(s.Ctx).Where(taskM.CampaignID.Eq(cpn.ID), taskM.IsDel.Eq(mtype.No)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var rewardIds []int64
	var oldTaskMap = make(map[string]*model.FissionCampaignTask, len(oldTasks))
	for _, oldTask := range oldTasks {
		oldTaskMap[oldTask.TaskMark] = oldTask
		if oldTask.RewardID > 0 {
			rewardIds = append(rewardIds, oldTask.RewardID)
		}
	}

	var rewardMap = make(map[int64]*model.FissionCampaignReward, len(rewardIds))
	rewardM := s.GetDao().FissionCampaignReward
	if len(rewardIds) > 0 {
		var rewards []*model.FissionCampaignReward
		rewards, err = rewardM.WithContext(s.Ctx).Where(rewardM.ID.In(rewardIds...)).Find()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		for _, reward := range rewards {
			rewardMap[reward.ID] = reward
		}
	}

	var addTicket []*model.FissionCampaignTicket
	var tasks []*model.FissionCampaignTask
	var addReward []*model.FissionCampaignReward
	var delRewardIds []int64
	fixedAddTicket, fixedAddTask, err := s._updateTargetOptionFixed(cpn, ticketMap[mtype.FissionCampaignTicketFixed], oldTaskMap)
	if err != nil {
		return
	}
	addTicket = append(addTicket, fixedAddTicket...)
	tasks = append(tasks, fixedAddTask...)

	customAddTicket, customAddTask, customAddReward, customDelRewardIds, err := s._updateTargetOptionCustom(cpn, ticketMap[mtype.FissionCampaignTicketCustom], oldTaskMap, rewardMap)
	if err != nil {
		return
	}

	addTicket = append(addTicket, customAddTicket...)
	tasks = append(tasks, customAddTask...)
	addReward = append(addReward, customAddReward...)
	delRewardIds = append(delRewardIds, customDelRewardIds...)

	if len(addTicket) > 0 {
		err = m.WithContext(s.Ctx).Create(addTicket...)
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	if len(tasks) > 0 {
		err = taskM.WithContext(s.Ctx).Create(tasks...)
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	if len(addReward) > 0 {
		err = rewardM.WithContext(s.Ctx).Create(addReward...)
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	if len(delRewardIds) > 0 {
		_, err = rewardM.WithContext(s.Ctx).Where(rewardM.ID.In(delRewardIds...)).UpdateSimple(rewardM.IsDel.Value(mtype.Yes))
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	return
}

// 更新邀请规则
func (s *Update) _updateTargetOptionFixed(cpn *model.FissionCampaign, fixedTicket *model.FissionCampaignTicket, oldTaskMap map[string]*model.FissionCampaignTask) (addTicket []*model.FissionCampaignTicket, tasks []*model.FissionCampaignTask, err error) {

	var fixed = s.Req.GetTargetOption().GetFixed()
	if fixedTicket == nil {

		if fixed.GetOpen() == mtype.No {
			return
		}

		addTicket = append(addTicket, 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(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)

		return
	}

	if fixedTicket.Open == mtype.No && fixed.GetOpen() == mtype.No {
		return
	}

	taskM := s.GetDao().FissionCampaignTask
	m := s.GetDao().FissionCampaignTicket

	_, err = m.WithContext(s.Ctx).
		Where(m.ID.Eq(fixedTicket.ID)).
		UpdateSimple(
			m.Open.Value(int8(fixed.GetOpen())),
			m.AppEvent.Value(int8(fixed.GetAppEvent())),
		)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	s.AddAfterRun(func() (err error) {
		_ = cache.NewCampaignTicket(s.Ctx).Clear(fixedTicket)
		return
	})

	var task *model.FissionCampaignTask
	switch fixedTicket.AppEvent {
	case mtype.FissionCampaignTicketAppEventInstall:
		task = oldTaskMap[mtype.FissionCampaignTaskMarkInstall]
	case mtype.FissionCampaignTicketAppEventRegister:
		task = oldTaskMap[mtype.FissionCampaignTaskMarkRegister]
	}

	if task == nil {

		one := withdefault.FissionCampaignTask(&model.FissionCampaignTask{
			CampaignID:  cpn.ID,
			TaskType:    0,
			TaskMark:    "",
			PropMark:    mtype.FissionCampaignTaskPropMarkChance,
			Num:         utils.Ternary[int32](verify.InArray(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)

		return
	}

	var appEvent = utils.STernary(fixed.GetAppEvent(), 0, int32(fixedTicket.AppEvent))
	var taskType int8
	var taskMark string
	switch appEvent {
	case mtype.FissionCampaignTicketAppEventInstall:
		taskType = mtype.FissionCampaignTaskTypeInstall
		taskMark = mtype.FissionCampaignTaskMarkInstall
	case mtype.FissionCampaignTicketAppEventRegister:
		taskType = mtype.FissionCampaignTaskTypeRegister
		taskMark = mtype.FissionCampaignTaskMarkRegister
	}

	var isDel int8 = mtype.No
	if fixed.GetOpen() == mtype.No {
		isDel = mtype.Yes
	}

	_, err = taskM.WithContext(s.Ctx).Where(taskM.ID.Eq(task.ID)).UpdateSimple(
		taskM.TaskType.Value(taskType),
		taskM.TaskMark.Value(taskMark),
		taskM.Chance.Value(fixed.GetChance()),
		taskM.ChanceLimit.Value(fixed.GetChanceLimit()),
		taskM.IsDel.Value(isDel),
		taskM.Percent.Value(fixed.GetPercent()),
	)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	return
}

func (s *Update) _updateTargetOptionCustom(cpn *model.FissionCampaign, customTicket *model.FissionCampaignTicket, oldTaskMap map[string]*model.FissionCampaignTask, rewardMap map[int64]*model.FissionCampaignReward) (addTicket []*model.FissionCampaignTicket, tasks []*model.FissionCampaignTask, addReward []*model.FissionCampaignReward, delRewardIds []int64, err error) {

	condM := s.GetDao().FissionCampaignCond
	taskM := s.GetDao().FissionCampaignTask
	rewardM := s.GetDao().FissionCampaignReward
	var custom = s.Req.GetTargetOption().GetCustom()
	var targetCond = make([]*model.FissionCampaignCond, 0, len(custom.GetCond()))
	var delCond []int64
	var delTaskIds []int64
	defer func() {
		if err != nil {
			return
		}

		if len(delTaskIds) > 0 {
			_, err = taskM.WithContext(s.Ctx).Where(
				taskM.ID.In(delTaskIds...),
			).UpdateSimple(taskM.IsDel.Value(mtype.Yes))
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}
		}

		if len(delCond) > 0 {
			_, err = condM.WithContext(s.Ctx).Where(
				condM.CampaignID.Eq(cpn.ID),
				condM.ID.In(delCond...),
			).UpdateSimple(condM.IsDel.Value(mtype.Yes))
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}
		}

		if len(targetCond) > 0 {
			err = condM.WithContext(s.Ctx).Create(targetCond...)
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}
		}

		if (customTicket == nil || customTicket.Open == mtype.No) && custom.GetOpen() == mtype.Yes {
			s.taskCondAdd = true
		} else if customTicket != nil && customTicket.Open == mtype.Yes && custom.GetOpen() == mtype.No {
			s.taskCondDel = true
		}
	}()

	if customTicket == nil {
		if custom.GetOpen() == mtype.No {
			return
		}

		addTicket = append(addTicket, &model.FissionCampaignTicket{
			CampaignID: cpn.ID,
			Mark:       mtype.FissionCampaignTicketCustom,
			Open:       mtype.Yes,
			BothType:   int8(custom.GetBothType()),
		})

		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()),
				TriggetType:     int8(cond.GetTriggerType()),
				EventType:       int8(cond.GetEventType()),
				ViewType:        int8(cond.GetViewType()),
				WatchSec:        cond.GetWatchSec(),
				OpenJump:        int8(cond.GetOpenJump()),
				WebURL:          cond.GetWebUrl(),
				ExtraParam:      cond.GetExtraParam(),
				GoShow:          int8(cond.GetGoShow()),
				AdsStrategyID:   cond.GetAdsStrategyId(),
				IsSuper:         int8(cond.GetIsSuper()),
				Sort:            cond.GetSort(),
				OpenPush:        int8(cond.GetOpenPush()),
				PcParam:         cond.GetPcParam(),
				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()),
				}))
			}
		}

		return
	}

	if customTicket.Open == mtype.No && custom.GetOpen() == mtype.No {
		return
	}

	list, err := condM.WithContext(s.Ctx).Where(condM.CampaignID.Eq(cpn.ID), condM.IsDel.Eq(mtype.No), condM.RewardID.Eq(0)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	// 旧条件
	var oldCond = make(map[int64]*model.FissionCampaignCond, len(list))
	for _, cond := range list {
		oldCond[cond.ID] = cond
	}

	m := s.GetDao().FissionCampaignTicket

	_, err = m.WithContext(s.Ctx).
		Where(m.ID.Eq(customTicket.ID)).
		UpdateSimple(
			m.Open.Value(int8(custom.GetOpen())),
			m.BothType.Value(int8(custom.GetBothType())),
			m.PreEvent.Value(int8(custom.GetPreEvent())),
		)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	s.AddAfterRun(func() (err error) {
		_ = cache.NewCampaignTicket(s.Ctx).Clear(customTicket)
		return
	})

	if customTicket.Open == mtype.Yes && custom.GetOpen() == mtype.No {
		for _, v := range list {
			delCond = append(delCond, v.ID)
			if customTicket.BothType == mtype.FissionCampaignTicketBothTypeOne {
				if task, ok := oldTaskMap[utils.FissionCampaignTaskMarkCondOneVal(v.ID)]; ok {
					delTaskIds = append(delTaskIds, task.ID)

					if reward, ok1 := rewardMap[task.RewardID]; ok1 {
						delRewardIds = append(delRewardIds, reward.ID)
					}

				}
			}
		}

		if customTicket.BothType == mtype.FissionCampaignTicketBothTypeAll {
			if task, ok := oldTaskMap[mtype.FissionCampaignTaskMarkCondAll]; ok {
				delTaskIds = append(delTaskIds, task.ID)
				if reward, ok1 := rewardMap[task.RewardID]; ok1 {
					delRewardIds = append(delRewardIds, reward.ID)
				}
			}
		}

		return
	}

	var condCache []*model.FissionCampaignCond
	s.AddAfterRun(func() (err error) {
		_ = cache.NewCampaignCond(s.Ctx).Clear(condCache...)
		return
	})

	for _, cond := range custom.GetCond() {
		//用户ID限制
		ll, _ := jsonm.ToSliceString(cond.GetLevelIds())
		//语言限制
		lm, _ := jsonm.ToSliceString(cond.GetLangMarks())
		old, ok1 := oldCond[cond.GetId()]
		if !ok1 { // 要创建条件数据和任务数据
			condId := hashid.IdBigint()
			targetCond = append(targetCond, &model.FissionCampaignCond{
				ID:              condId,
				CampaignID:      cpn.ID,
				ProjectID:       cpn.ProjectID,
				Event:           cond.GetEvent(),
				EventKey:        cond.GetEventKey(),
				EventVal:        cond.GetEventVal(),
				Desc:            cond.GetDesc(),
				IfCond:          int8(cond.GetIfCond()),
				TriggetType:     int8(cond.GetTriggerType()),
				EventType:       int8(cond.GetEventType()),
				ViewType:        int8(cond.GetViewType()),
				WatchSec:        cond.GetWatchSec(),
				OpenJump:        int8(cond.GetOpenJump()),
				WebURL:          cond.GetWebUrl(),
				ExtraParam:      cond.GetExtraParam(),
				GoShow:          int8(cond.GetGoShow()),
				AdsStrategyID:   cond.GetAdsStrategyId(),
				IsSuper:         int8(cond.GetIsSuper()),
				Sort:            cond.GetSort(),
				OpenPush:        int8(cond.GetOpenPush()),
				PcParam:         cond.GetPcParam(),
				GoText:          cond.GetGoText(),
				ClickEffectOpen: int8(cond.GetClickEffectOpen()),
				ClickEffect:     cond.GetClickEffect(),
				ClickEffectUnit: cond.GetClickEffectUnit(),
				PullInvite:      int8(cond.GetPullInvite()),
			})

			if custom.GetBothType() == mtype.FissionCampaignTicketBothTypeOne {
				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(),
					})
				}

				tasks = append(tasks, withdefault.FissionCampaignTask(&model.FissionCampaignTask{
					CampaignID:  cpn.ID,
					TaskType:    mtype.FissionCampaignTaskTypeCondOne,
					TaskMark:    utils.FissionCampaignTaskMarkCondOneVal(condId),
					PropMark:    propMark,
					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()),
				}))
			}

			continue
		}

		var upCond = []field.AssignExpr{
			condM.Event.Value(cond.GetEvent()),
			condM.EventKey.Value(cond.GetEventKey()),
			condM.EventVal.Value(cond.GetEventVal()),
			condM.Desc.Value(cond.GetDesc()),
			condM.IfCond.Value(int8(cond.GetIfCond())),
			condM.TriggetType.Value(int8(cond.GetTriggerType())),
			condM.EventType.Value(int8(cond.GetEventType())),
			condM.ViewType.Value(int8(cond.GetViewType())),
			condM.WatchSec.Value(cond.GetWatchSec()),
			condM.OpenJump.Value(int8(cond.GetOpenJump())),
			condM.WebURL.Value(cond.GetWebUrl()),
			condM.ExtraParam.Value(cond.GetExtraParam()),
			condM.GoShow.Value(int8(cond.GetGoShow())),
			condM.AdsStrategyID.Value(cond.GetAdsStrategyId()),
			condM.IsSuper.Value(int8(cond.GetIsSuper())),
			condM.Sort.Value(cond.GetSort()),
			condM.OpenPush.Value(int8(cond.GetOpenPush())),
			condM.PcParam.Value(cond.GetPcParam()),
			condM.GoText.Value(cond.GetGoText()),
			condM.ClickEffectOpen.Value(int8(cond.GetClickEffectOpen())),
			condM.ClickEffect.Value(cond.GetClickEffect()),
			condM.ClickEffectUnit.Value(cond.GetClickEffectUnit()),
			condM.PullInvite.Value(int8(cond.GetPullInvite())),
		}
		_, err = condM.WithContext(s.Ctx).Where(condM.ID.Eq(old.ID)).UpdateSimple(upCond...)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		condCache = append(condCache, old)

		switch customTicket.BothType {
		case mtype.FissionCampaignTicketBothTypeOne:

			switch custom.GetBothType() {
			case mtype.FissionCampaignTicketBothTypeOne:
				task, ok := oldTaskMap[utils.FissionCampaignTaskMarkCondOneVal(old.ID)]
				if ok {
					var rewardId int64
					var propMark = cond.GetPropMark()
					switch propMark {
					case mtype.FissionCampaignTaskPropMarkReward:

						reward := rewardMap[task.RewardID]

						if reward == nil || reward.RewardID != cond.GetReward().GetRewardId() {
							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,
							})
							if reward != nil {
								delRewardIds = append(delRewardIds, reward.ID)
							}
						} else {
							_, err = rewardM.WithContext(s.Ctx).Where(rewardM.ID.Eq(reward.ID)).UpdateSimple(rewardM.Stock.Value(cond.GetReward().GetStock()))
							if err != nil {
								err = s.BE().MysqlError(err)
								return
							}
							rewardId = reward.ID

							s.AddAfterRun(func() (err error) {
								st, _ := stocks.NewCampaignReward(s.Ctx, reward.ID)
								st.Clear()
								return
							})
						}

					case mtype.FissionCampaignTaskPropMarkPoint:

						reward := rewardMap[task.RewardID]

						if reward == nil {
							rewardId = hashid.IdBigint()
							s._otherAppendReward(&model.FissionCampaignReward{
								ID:         rewardId,
								CampaignID: cpn.ID,
								RewardType: mtype.FissionCampaignRewardTypeTask,
								RewardNum:  cond.GetChance(),
								PropMark:   mtype.FissionCampaignRewardPropMarkPoint,
								ExpiredDay: cond.GetExpiredDay(),
							})
						} else {
							_, err = rewardM.WithContext(s.Ctx).Where(rewardM.ID.Eq(reward.ID)).UpdateSimple(
								rewardM.RewardNum.Value(cond.GetChance()),
								rewardM.ExpiredDay.Value(cond.GetExpiredDay()),
							)
							if err != nil {
								err = s.BE().MysqlError(err)
								return
							}
							rewardId = reward.ID
						}
					}

					_, err = taskM.WithContext(s.Ctx).Where(taskM.ID.Eq(task.ID)).UpdateSimple(
						taskM.PropMark.Value(propMark),
						taskM.Chance.Value(cond.GetChance()),
						taskM.TaskLimit.Value(cond.GetTaskLimit()),
						taskM.DayLimit.Value(cond.GetDayLimit()),
						taskM.LevelLimit.Value(ll),
						taskM.LangMarks.Value(lm),
						taskM.WeekLimit.Value(cond.GetWeekLimit()),
						taskM.WeekNum.Value(int8(cond.GetWeekNum())),
						taskM.HasPre.Value(int8(cond.GetHasPre())),
						taskM.PreCond.Value(cond.GetPreCond()),
						taskM.ExpiredMin.Value(cond.GetExpiredMin()),
						taskM.RewardID.Value(rewardId),
						taskM.AwardMode.Value(int8(cond.GetAwardMode())),
					)
					if err != nil {
						err = s.BE().MysqlError(err)
						return
					}

				} else {
					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(),
						})
					}

					tasks = append(tasks, withdefault.FissionCampaignTask(&model.FissionCampaignTask{
						CampaignID:  cpn.ID,
						TaskType:    mtype.FissionCampaignTaskTypeCondOne,
						TaskMark:    utils.FissionCampaignTaskMarkCondOneVal(old.ID),
						PropMark:    propMark,
						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()),
					}))
				}

			case mtype.FissionCampaignTicketBothTypeAll:
				task, ok := oldTaskMap[utils.FissionCampaignTaskMarkCondOneVal(old.ID)]
				if ok {
					delTaskIds = append(delTaskIds, task.ID)
					if task.RewardID > 0 {
						delRewardIds = append(delRewardIds, task.RewardID)
					}
				}
			}
		case mtype.FissionCampaignTicketBothTypeAll:
			switch custom.GetBothType() {
			case mtype.FissionCampaignTicketBothTypeOne:
				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(),
					})
				}

				tasks = append(tasks, withdefault.FissionCampaignTask(&model.FissionCampaignTask{
					CampaignID:  cpn.ID,
					TaskType:    mtype.FissionCampaignTaskTypeCondOne,
					TaskMark:    utils.FissionCampaignTaskMarkCondOneVal(old.ID),
					PropMark:    propMark,
					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()),
				}))
			}

		}

		delete(oldCond, old.ID)
	}

	switch customTicket.BothType {
	case mtype.FissionCampaignTicketBothTypeOne:
		switch custom.GetBothType() {
		case mtype.FissionCampaignTicketBothTypeOne: // 如果旧的数据已经不在新的数据里面，并且以前的数据还是任意条件，那旧要把任务都删了
			for id := range oldCond {
				delCond = append(delCond, id)
				if task, ok := oldTaskMap[utils.FissionCampaignTaskMarkCondOneVal(id)]; ok {
					delTaskIds = append(delTaskIds, task.ID)
					if task.RewardID > 0 {
						delRewardIds = append(delRewardIds, task.RewardID)
					}
				}
			}
		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.FissionCampaignTicketBothTypeAll:
		switch custom.GetBothType() {
		case mtype.FissionCampaignTicketBothTypeOne: // 从所有任务完成切换到任意任务完成,要把所有任务完成产生的任务数据删掉
			if task, ok := oldTaskMap[mtype.FissionCampaignTaskMarkCondAll]; ok {
				delTaskIds = append(delTaskIds, task.ID)
				if task.RewardID > 0 {
					delRewardIds = append(delRewardIds, task.RewardID)
				}
			}
		case mtype.FissionCampaignTicketBothTypeAll: // 所有任务完成 都没切换的时候，要更新任务数据
			task, ok := oldTaskMap[mtype.FissionCampaignTaskMarkCondAll]
			if ok {
				var rewardId int64
				var propMark = custom.GetBothAll().GetPropMark()
				switch propMark {
				case mtype.FissionCampaignTaskPropMarkReward:

					reward := rewardMap[task.RewardID]

					if reward == nil || reward.RewardID != custom.GetBothAll().GetReward().GetRewardId() {
						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,
						})
						if reward != nil {
							delRewardIds = append(delRewardIds, reward.ID)
						}
					} else {
						_, err = rewardM.WithContext(s.Ctx).Where(rewardM.ID.Eq(reward.ID)).UpdateSimple(
							rewardM.Stock.Value(custom.GetBothAll().GetReward().GetStock()),
						)
						if err != nil {
							err = s.BE().MysqlError(err)
							return
						}
						rewardId = reward.ID

						s.AddAfterRun(func() (err error) {
							st, _ := stocks.NewCampaignReward(s.Ctx, reward.ID)
							st.Clear()
							return
						})
					}
				case mtype.FissionCampaignTaskPropMarkPoint:
					reward := rewardMap[task.RewardID]

					if reward == nil {
						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(),
						})
					} else {
						_, err = rewardM.WithContext(s.Ctx).Where(rewardM.ID.Eq(reward.ID)).UpdateSimple(
							rewardM.RewardNum.Value(custom.GetBothAll().GetChance()),
							rewardM.ExpiredDay.Value(custom.GetBothAll().GetExpiredDay()),
						)
						if err != nil {
							err = s.BE().MysqlError(err)
							return
						}
						rewardId = reward.ID
					}
				}

				ll, _ := jsonm.ToSliceString(custom.GetBothAll().GetLevelIds())
				lm, _ := jsonm.ToSliceString(custom.GetBothAll().GetLangMarks())
				_, err = taskM.WithContext(s.Ctx).Where(taskM.ID.Eq(task.ID)).
					UpdateSimple(
						taskM.PropMark.Value(propMark),
						taskM.Chance.Value(custom.GetBothAll().GetChance()),
						taskM.TaskLimit.Value(custom.GetBothAll().GetTaskLimit()),
						taskM.DayLimit.Value(custom.GetBothAll().GetDayLimit()),
						taskM.LevelLimit.Value(ll),
						taskM.LangMarks.Value(lm),
						taskM.WeekLimit.Value(custom.GetBothAll().GetWeekLimit()),
						taskM.WeekNum.Value(int8(custom.GetBothAll().GetWeekNum())),
						taskM.RewardID.Value(rewardId),
					)
				if err != nil {
					err = s.BE().MysqlError(err)
					return
				}
			} else {
				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,
				}))
			}

		}
	}

	return
}

// 更新目标配置（即将弃用）
func (s *Update) _updateTargetCond(cpn *model.FissionCampaign) (err error) {
	// 目标配置
	condM := s.GetDao().FissionCampaignCond
	list, err := condM.WithContext(s.Ctx).Where(condM.CampaignID.Eq(cpn.ID), condM.IsDel.Eq(mtype.No), condM.RewardID.Eq(0)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	// 旧条件
	var oldCond = make(map[int64]*model.FissionCampaignCond, len(list))
	for _, cond := range list {
		oldCond[cond.ID] = cond
	}

	target := s.Req.GetTarget()

	var condCache []*model.FissionCampaignCond
	defer s.AddAfterRun(func() (err error) {
		_ = cache.NewCampaignCond(s.Ctx).Clear(condCache...)
		return
	})
	var addCond []*model.FissionCampaignCond
	var newIdx int
	var newCond = make(map[int]*pb.UpdateReq_Cond)
	for _, cond := range target.GetCond() {
		tt := int8(utils.NewGlobalTrigger(cpn.FissionID, cond.GetTriggerType()))
		old, ok := oldCond[cond.GetId()]
		if !ok {
			addCond = append(addCond, &model.FissionCampaignCond{
				ID:          hashid.IdBigint(),
				CampaignID:  cpn.ID,
				ProjectID:   cpn.ProjectID,
				Event:       cond.GetEvent(),
				EventKey:    cond.GetEventKey(),
				EventVal:    cond.GetEventVal(),
				Desc:        cond.GetDesc(),
				IfCond:      int8(cond.GetIfCond()),
				TriggetType: tt,
				EventType:   int8(cond.GetEventType()),
			})
			newCond[newIdx] = cond
			newIdx++
			continue
		}

		var upCond = []field.AssignExpr{
			condM.Event.Value(cond.GetEvent()),
			condM.EventKey.Value(cond.GetEventKey()),
			condM.EventVal.Value(cond.GetEventVal()),
			condM.Desc.Value(cond.GetDesc()),
			condM.IfCond.Value(int8(cond.GetIfCond())),
			condM.TriggetType.Value(tt),
			condM.EventType.Value(int8(cond.GetEventType())),
		}
		_, err = condM.WithContext(s.Ctx).Where(condM.ID.Eq(old.ID)).UpdateSimple(upCond...)
		if err != nil {
			return s.BE().MysqlError(err)
		}

		delete(oldCond, cond.GetId())
		condCache = append(condCache, old)
	}

	var del []int64
	for id := range oldCond {
		del = append(del, id)
	}

	if len(addCond) > 0 {
		err = condM.WithContext(s.Ctx).Create(addCond...)
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	if len(del) > 0 {
		_, err = condM.WithContext(s.Ctx).Where(condM.ID.In(del...), condM.CampaignID.Eq(cpn.ID)).UpdateSimple(condM.IsDel.Value(mtype.Yes))
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	return
}

func (s *Update) _updateRunningCond(cpn *model.FissionCampaign) (err error) {

	m := s.GetDao().FissionCampaignCond
	if !consts.NewEventCpn(cpn.FissionID) {
		var condCache = make([]*model.FissionCampaignCond, 0, len(s.Req.GetTarget().GetCond()))
		defer s.AddAfterRun(func() (err error) {
			_ = cache.NewCampaignCond(s.Ctx).Clear(condCache...)
			return
		})
		for _, cond := range s.Req.GetTarget().GetCond() {
			_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(cond.GetId())).UpdateSimple(
				m.Desc.Value(cond.GetDesc()),
				m.ViewType.Value(int8(cond.GetViewType())),
				m.GoText.Value(cond.GetGoText()),
			)
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}

			condCache = append(condCache, &model.FissionCampaignCond{ID: cond.GetId()})
		}
		return
	}

	ticketM := s.GetDao().FissionCampaignTicket
	ticket, err := ticketM.WithContext(s.Ctx).Where(
		ticketM.CampaignID.Eq(cpn.ID),
		ticketM.Open.Eq(mtype.Yes),
		ticketM.Mark.Eq(mtype.FissionCampaignTicketCustom),
	).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if ticket == nil {
		return
	}

	var ids []int64
	var reqCond = s.Req.GetTargetOption().GetCustom().GetCond()
	for _, v := range reqCond {
		ids = append(ids, v.GetId())
	}

	list, err := m.WithContext(s.Ctx).Where(m.ID.In(ids...)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var oldCondMap = make(map[int64]*model.FissionCampaignCond)
	for _, cond := range list {
		oldCondMap[cond.ID] = cond
	}

	var condCache = make([]*model.FissionCampaignCond, 0, len(list))
	defer s.AddAfterRun(func() (err error) {
		_ = cache.NewCampaignCond(s.Ctx).Clear(condCache...)
		return
	})

	taskM := s.GetDao().FissionCampaignTask

	var addCond []*model.FissionCampaignCond
	defer func() {
		if len(addCond) > 0 && err == nil {
			err = m.WithContext(s.Ctx).Create(addCond...)
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}

			if len(cpn.GetLangTypes()) > 1 {
				s.Res.AddTask = true
			}
		}
	}()

	var addTask []*model.FissionCampaignTask
	defer func() {
		if len(addTask) > 0 && err == nil {
			err = taskM.WithContext(s.Ctx).Create(addTask...)
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}
		}
	}()

	var taskMark = make(map[string]*pb.UpdateReq_Cond, len(reqCond))
	for _, cond := range reqCond {

		taskMark[utils.FissionCampaignTaskMarkCondOneVal(cond.GetId())] = cond

		old, ok := oldCondMap[cond.GetId()]
		if !ok {
			aCond := 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(cond.GetTriggerType()),
				EventType:       int8(cond.GetEventType()),
				ViewType:        int8(cond.GetViewType()),
				WatchSec:        cond.GetWatchSec(),
				OpenJump:        int8(cond.GetOpenJump()),
				WebURL:          cond.GetWebUrl(),
				ExtraParam:      cond.GetExtraParam(),
				GoShow:          int8(cond.GetGoShow()),
				AdsStrategyID:   cond.GetAdsStrategyId(),
				Sort:            cond.GetSort(),
				OpenPush:        int8(cond.GetOpenPush()),
				PcParam:         cond.GetPcParam(),
				GoText:          cond.GetGoText(),
				ClickEffectOpen: int8(cond.GetClickEffectOpen()),
				ClickEffect:     cond.GetClickEffect(),
				ClickEffectUnit: cond.GetClickEffectUnit(),
				PullInvite:      int8(cond.GetPullInvite()),
			})

			if ticket.BothType == mtype.FissionCampaignTicketBothTypeOne {
				//用户ID限制
				ll, _ := jsonm.ToSliceString(cond.GetLevelIds())
				//语言限制
				lm, _ := jsonm.ToSliceString(cond.GetLangMarks())

				addTask = append(addTask, withdefault.FissionCampaignTask(&model.FissionCampaignTask{
					CampaignID:  cpn.ID,
					TaskType:    mtype.FissionCampaignTaskTypeCondOne,
					TaskMark:    utils.FissionCampaignTaskMarkCondOneVal(aCond.ID),
					PropMark:    mtype.FissionCampaignTaskPropMarkChance,
					Num:         1,
					Chance:      cond.GetChance(),
					ChanceLimit: 0,
					TaskLimit:   cond.GetTaskLimit(),
					DayLimit:    cond.GetDayLimit(),
					LevelLimit:  ll,
					LangMarks:   lm,
					WeekLimit:   cond.GetWeekLimit(),
					WeekNum:     int8(cond.GetWeekNum()),
					AwardMode:   int8(cond.GetAwardMode()),
				}))
			}

			addCond = append(addCond, aCond)

			continue
		}

		var upData []field.AssignExpr

		if old.Desc != cond.GetDesc() {
			upData = append(upData, m.Desc.Value(cond.GetDesc()))
		}

		if old.EventVal != cond.GetEventVal() {
			upData = append(upData, m.EventVal.Value(cond.GetEventVal()))
		}

		if old.OpenJump != int8(cond.GetOpenJump()) {
			upData = append(upData, m.OpenJump.Value(int8(cond.GetOpenJump())))
		}

		if old.WebURL != cond.GetWebUrl() {
			upData = append(upData, m.WebURL.Value(cond.GetWebUrl()))
		}

		if old.ExtraParam != cond.GetExtraParam() {
			upData = append(upData, m.ExtraParam.Value(cond.GetExtraParam()))
		}

		if old.PcParam != cond.GetPcParam() {
			upData = append(upData, m.PcParam.Value(cond.GetPcParam()))
		}

		if old.TriggetType != int8(cond.GetTriggerType()) {
			upData = append(upData, m.TriggetType.Value(int8(cond.GetTriggerType())))
			s.OL().User(s.Req.GetUserId(), s.Req.GetIp()).UpdateRunningTriggetType(old.ID, old.TriggetType, cond.GetTriggerType())
		}

		if old.ViewType != int8(cond.GetViewType()) {
			upData = append(upData, m.ViewType.Value(int8(cond.GetViewType())))
		}

		if old.GoShow != int8(cond.GetGoShow()) {
			upData = append(upData, m.GoShow.Value(int8(cond.GetGoShow())))
		}

		if old.GoText != cond.GetGoText() {
			upData = append(upData, m.GoText.Value(cond.GetGoText()))
		}

		if old.AdsStrategyID != cond.GetAdsStrategyId() {
			upData = append(upData, m.AdsStrategyID.Value(cond.GetAdsStrategyId()))
			s.OL().User(s.Req.GetUserId(), s.Req.GetIp()).UpdateRunningAdsStrategy(old.ID, old.AdsStrategyID, cond.GetAdsStrategyId())
		}

		if old.WatchSec != cond.GetWatchSec() {
			upData = append(upData, m.WatchSec.Value(cond.GetWatchSec()))
		}

		if old.Sort != cond.GetSort() {
			upData = append(upData, m.Sort.Value(cond.GetSort()))
		}

		if old.OpenPush != int8(cond.GetOpenPush()) {
			upData = append(upData, m.OpenPush.Value(int8(cond.GetOpenPush())))
		}

		if old.ClickEffectOpen != int8(cond.GetClickEffectOpen()) {
			upData = append(upData, m.ClickEffectOpen.Value(int8(cond.GetClickEffectOpen())))
		}

		if old.ClickEffect != cond.GetClickEffect() {
			upData = append(upData, m.ClickEffect.Value(cond.GetClickEffect()))
		}

		if old.ClickEffectUnit != cond.GetClickEffectUnit() {
			upData = append(upData, m.ClickEffectUnit.Value(cond.GetClickEffectUnit()))
		}

		if old.PullInvite != int8(cond.GetPullInvite()) {
			upData = append(upData, m.PullInvite.Value(int8(cond.GetPullInvite())))
		}

		if len(upData) > 0 {
			_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(cond.GetId())).UpdateSimple(upData...)
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}
			condCache = append(condCache, old)
		}
	}

	// 更新限制

	switch ticket.BothType {
	case mtype.FissionCampaignTicketBothTypeAll:
		var task *model.FissionCampaignTask
		task, err = taskM.WithContext(s.Ctx).Where(
			taskM.CampaignID.Eq(cpn.ID),
			taskM.TaskMark.Eq(mtype.FissionCampaignTaskMarkCondAll),
			taskM.IsDel.Eq(mtype.No)).Take()
		if err = dbcheck.DbError(err); err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		var operateLogKvs []string
		var up []field.AssignExpr
		ba := s.Req.GetTargetOption().GetCustom().GetBothAll()
		dayLimit, taskLimit, levelLimit := ba.GetDayLimit(), ba.GetTaskLimit(), ba.GetLevelIds()
		if task != nil {
			if task.DayLimit != dayLimit {
				up = append(up, taskM.DayLimit.Value(dayLimit))
				operateLogKvs = append(operateLogKvs,
					"day",
					fmt.Sprintf("%d->%d", task.DayLimit, dayLimit),
				)
			}

			if task.TaskLimit != taskLimit {
				up = append(up, taskM.TaskLimit.Value(taskLimit))
				operateLogKvs = append(operateLogKvs,
					"task",
					fmt.Sprintf("%d->%d", task.TaskLimit, taskLimit),
				)
			}

			if !verify.SliceEq(task.GetLevelLimit(), levelLimit) {
				ll, _ := jsonm.ToSliceString(levelLimit)
				up = append(up, taskM.LevelLimit.Value(ll))
				operateLogKvs = append(operateLogKvs,
					"level",
					fmt.Sprintf("%s->%s", task.LevelLimit, ll),
				)
			}

			if !verify.SliceEq(task.GetLangMarks(), ba.GetLangMarks()) {
				lm, _ := jsonm.ToSliceString(ba.GetLangMarks())
				up = append(up, taskM.LangMarks.Value(lm))
				operateLogKvs = append(operateLogKvs,
					"lang",
					fmt.Sprintf("%s->%s", task.LangMarks, lm),
				)
			}

			if task.WeekLimit != ba.GetWeekLimit() || task.WeekNum != int8(ba.GetWeekNum()) {
				up = append(up, taskM.WeekLimit.Value(ba.GetWeekLimit()), taskM.WeekNum.Value(int8(ba.GetWeekNum())))
				operateLogKvs = append(operateLogKvs,
					"week",
					fmt.Sprintf("%d_%d->%d_%d", task.WeekLimit, task.WeekNum, ba.GetWeekLimit(), ba.GetWeekNum()),
				)
			}

			if len(up) > 0 {
				_, err = taskM.WithContext(s.Ctx).Where(taskM.ID.Eq(task.ID)).UpdateSimple(up...)
				if err != nil {
					err = s.BE().MysqlError(err)
					return
				}
				s.OL().User(s.Req.GetUserId(), s.Req.GetIp()).TaskLimitRule(task.ID, operateLogKvs)
			}
		}

	case mtype.FissionCampaignTicketBothTypeOne:
		var tasks []*model.FissionCampaignTask
		tasks, err = taskM.WithContext(s.Ctx).Where(taskM.CampaignID.Eq(cpn.ID), taskM.IsDel.Eq(mtype.No)).Find()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		for _, task := range tasks {
			cond, ok := taskMark[task.TaskMark]
			if !ok {
				continue
			}

			var operateLogKvs []string
			var up []field.AssignExpr

			if task.AwardMode != int8(cond.GetAwardMode()) {
				up = append(up, taskM.AwardMode.Value(int8(cond.GetAwardMode())))
			}

			if task.DayLimit != cond.GetDayLimit() {
				up = append(up, taskM.DayLimit.Value(cond.GetDayLimit()))
				operateLogKvs = append(operateLogKvs,
					"day",
					fmt.Sprintf("%d->%d", task.DayLimit, cond.GetDayLimit()),
				)
			}

			if task.TaskLimit != cond.GetTaskLimit() {
				up = append(up, taskM.TaskLimit.Value(cond.GetTaskLimit()))
				operateLogKvs = append(operateLogKvs,
					"task",
					fmt.Sprintf("%d->%d", task.TaskLimit, cond.GetTaskLimit()),
				)
			}

			if !verify.SliceEq(task.GetLevelLimit(), cond.GetLevelIds()) {
				ll, _ := jsonm.ToSliceString(cond.GetLevelIds())
				up = append(up, taskM.LevelLimit.Value(ll))
				operateLogKvs = append(operateLogKvs,
					"level",
					fmt.Sprintf("%s->%s", task.LevelLimit, ll),
				)
			}

			if !verify.SliceEq(task.GetLangMarks(), cond.GetLangMarks()) {
				lm, _ := jsonm.ToSliceString(cond.GetLangMarks())
				up = append(up, taskM.LangMarks.Value(lm))
				operateLogKvs = append(operateLogKvs,
					"lang",
					fmt.Sprintf("%s->%s", task.LangMarks, lm),
				)
			}

			if task.WeekLimit != cond.GetWeekLimit() || task.WeekNum != int8(cond.GetWeekNum()) {
				up = append(up, taskM.WeekLimit.Value(cond.GetWeekLimit()), taskM.WeekNum.Value(int8(cond.GetWeekNum())))
				operateLogKvs = append(operateLogKvs,
					"week",
					fmt.Sprintf("%d_%d->%d_%d", task.WeekLimit, task.WeekNum, cond.GetWeekLimit(), cond.GetWeekNum()),
				)
			}

			if len(up) > 0 {
				_, err = taskM.WithContext(s.Ctx).Where(taskM.ID.Eq(task.ID)).UpdateSimple(up...)
				if err != nil {
					err = s.BE().MysqlError(err)
					return
				}
				s.OL().User(s.Req.GetUserId(), s.Req.GetIp()).TaskLimitRule(task.ID, operateLogKvs)
			}
		}
	}

	return
}

// 创建玩法特有数据
func (s *Update) updateFission(cpn *model.FissionCampaign) (err error) {
	switch cpn.FissionID {
	case consts.IdPrizeWheel: //大转盘
		return s.updatePrizeWheel(cpn)
	case consts.IdSlotMachine: //老虎机
		return s.updateSlotMachine(cpn)
	case consts.IdLuckyGrid: //九宫格
		return s.updateLuckyGrid(cpn)
	case consts.IdBlindBox: //盲盒
		return s.updateBlindBox(cpn)
	case consts.IdReferral: //老带新
		return s.updateReferral(cpn)
	case consts.IdWinTogether: //一起赢
		return s.updateWinTogether(cpn)
	case consts.IdPrizeAnswer, consts.IdQa, consts.IdQaAudio, consts.IdQaVideo: //趣味问答
		return s.updatePrizeAnswer(cpn)
	case consts.IdPrizeQuiz: //有奖竞猜
		return s.updatePrizeQuiz(cpn)
	case consts.IdSignIn: //签到
		return s.updateSignIn(cpn)
	case consts.IdDice: //大富翁
		return s.updateDice(cpn)
	case consts.IdGrow: //农场
		return s.updateGrow(cpn)
	case consts.IdBallot: //抽签
		return s.updateBallot(cpn)
	case consts.IdChop: //砍一刀
		return s.updateChop(cpn)
	case consts.IdCash: //现金抽奖
		return s.updateCash(cpn)
	case consts.IdFlip: //翻牌活动
		return s.updateFlip(cpn)
	case consts.IdKeep: //激励养成
		return s.updateKeep(cpn)
	case consts.IdGold: //金币任务
		return s.updateGold(cpn)
	case consts.IdCoin: //金币池
		return s.updateCoin(cpn)
	case consts.IdVs:
		return s.updateVs(cpn)
	case consts.IdUno:
		return s.updateUno(cpn)
	case consts.IdGashapon: //扭蛋机
		return s.updateGashapon(cpn)
	default:

	}

	return
}

// 更新赛事竞猜配置
func (s *Update) updatePrizeQuiz(cpn *model.FissionCampaign) (err error) {
	quiz := s.Req.GetQuiz()

	cc := cache.NewCampaignQuiz(s.Ctx)
	fcq, err := cc.FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if fcq == nil {
		return workerr.NotFound("not found fcq")
	}

	m := s.GetDao().FissionCampaignQuiz
	var data = []field.AssignExpr{
		m.OpenPrize.Value(timez.GMT(quiz.GetOpenPrize(), s.Req.GetTOffset())),
		m.TOpen.Value(quiz.GetOpenPrize()),
	}

	defer func() {
		if err != nil {
			return
		}

		_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(fcq.ID)).UpdateSimple(data...)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		_ = cc.Clear(fcq)
	}()

	if cpn.Status != mtype.FissionCampaignStatusWait { //不是待发布状态只能改正确选项
		//选项更新
		optionM := s.GetDao().FissionCampaignQuizOption
		for _, v := range quiz.GetOptions() {
			_, err = optionM.WithContext(s.Ctx).Where(optionM.ID.Eq(v.GetId())).UpdateSimple(optionM.IsRight.Value(int8(v.GetIsRight())))
			if err != nil {
				return s.BE().MysqlError(err)
			}
		}

		return
	}

	data = append(data,
		m.TargetNum.Value(quiz.GetTargetNum()),
		m.InitChance.Value(quiz.GetInitChance()),
		m.Chance.Value(quiz.GetChance()),
		m.RewardRule.Value(int8(quiz.GetRewardRule())),
		m.Title.Value(quiz.GetTitle()),
	)

	//更新了初始投票机会，要处理玩家数据，预防有一些人没开始就进入游戏了，要同步一下数据
	if fcq.InitChance != quiz.GetInitChance() {
		fqM := s.GetDao().FissionQuiz
		_, err = fqM.WithContext(s.Ctx).Where(fqM.CampaignID.Eq(cpn.ID)).UpdateSimple(fqM.Chance.Value(quiz.GetInitChance()))
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	var optAdd []*model.FissionCampaignQuizOption
	var optDel []int64
	var optNewIds = make(map[int64]*pb.UpdateReq_QuizOption)
	for _, v := range quiz.GetOptions() {

		if v.GetId() > 0 {
			//修改数据
			optNewIds[v.GetId()] = v
			continue
		}

		//没有ID就是新增数据
		optAdd = append(optAdd, withdefault.FissionCampaignQuizOption(&model.FissionCampaignQuizOption{
			CampaignID: cpn.ID,
			Title:      v.GetTitle(),
			ImgURL:     v.GetImgUrl(),
			IsRight:    int8(v.GetIsRight()),
		}))
	}

	//选项更新
	optionM := s.GetDao().FissionCampaignQuizOption
	options, err := optionM.WithContext(s.Ctx).Where(optionM.CampaignID.Eq(cpn.ID), optionM.IsDel.Eq(mtype.No)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	for _, v := range options {
		option, ok := optNewIds[v.ID]
		if !ok {
			optDel = append(optDel, v.ID)
			continue
		}

		var uData = []field.AssignExpr{
			optionM.Title.Value(option.GetTitle()),
			optionM.ImgURL.Value(option.GetImgUrl()),
			optionM.IsRight.Value(int8(option.GetIsRight())),
		}

		_, err = optionM.WithContext(s.Ctx).Where(optionM.ID.Eq(v.ID)).UpdateSimple(uData...)
		if err != nil {
			return s.BE().MysqlError(err)
		}

	}

	if len(optAdd) > 0 {
		err = optionM.WithContext(s.Ctx).Create(optAdd...)
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	if len(optDel) > 0 {
		_, err = optionM.WithContext(s.Ctx).Where(optionM.ID.In(optDel...)).UpdateSimple(optionM.IsDel.Value(mtype.Yes))
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	return
}

// 更新大转盘
func (s *Update) updatePrizeWheel(cpn *model.FissionCampaign) (err error) {
	var wheel = s.Req.GetPrizeWheel()

	cc := cache.NewCampaignWheel(s.Ctx)
	conf, err := cc.FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if conf == nil {
		return workerr.NotFound("not found wheel conf")
	}

	confM := s.GetDao().FissionCampaignWheel
	var data = []field.AssignExpr{
		confM.DayChance.Value(wheel.GetDayChance()),
	}

	defer func() {
		if err != nil {
			return
		}
		_, err = confM.WithContext(s.Ctx).Where(confM.ID.Eq(conf.ID)).UpdateSimple(data...)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		_ = cc.Clear(conf)
	}()

	if cpn.Status != mtype.FissionCampaignStatusWait { //不是待发布状态不能修改配置
		return
	}

	data = append(data,
		confM.TargetNum.Value(wheel.GetTargetNum()),
		confM.InitChance.Value(wheel.GetInitChance()),
		confM.Chance.Value(wheel.GetChance()),
	)

	//更新了初次抽奖机会，要处理玩家数据，预防有一些人没开始就进入游戏了，要同步一下数据
	if conf.InitChance != wheel.GetInitChance() {
		fpwM := s.GetDao().FissionPrizeWheel
		_, err = fpwM.WithContext(s.Ctx).Where(fpwM.CampaignID.Eq(cpn.ID)).UpdateSimple(fpwM.Chance.Value(wheel.GetInitChance()))
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	return
}

// 更新老虎机
func (s *Update) updateSlotMachine(cpn *model.FissionCampaign) (err error) {
	var slot = s.Req.GetSlot()

	cc := cache.NewCampaignSlot(s.Ctx)
	conf, err := cc.FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if conf == nil {
		return workerr.NotFound("not found slot conf")
	}

	confM := s.GetDao().FissionCampaignSlot
	var data = []field.AssignExpr{
		confM.DayChance.Value(slot.GetDayChance()),
	}

	defer func() {
		if err != nil {
			return
		}
		_, err = confM.WithContext(s.Ctx).Where(confM.ID.Eq(conf.ID)).UpdateSimple(data...)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		_ = cc.Clear(conf)
	}()

	if cpn.Status != mtype.FissionCampaignStatusWait { //不是待发布状态不能修改配置
		return
	}

	data = append(data,
		confM.TargetNum.Value(slot.GetTargetNum()),
		confM.InitChance.Value(slot.GetInitChance()),
		confM.Chance.Value(slot.GetChance()),
	)

	//更新了初次抽奖机会，要处理玩家数据，预防有一些人没开始就进入游戏了，要同步一下数据
	if conf.InitChance != slot.GetInitChance() {
		fpwM := s.GetDao().FissionSlot
		_, err = fpwM.WithContext(s.Ctx).Where(fpwM.CampaignID.Eq(cpn.ID)).UpdateSimple(fpwM.Chance.Value(slot.GetInitChance()))
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	return
}

// 更新九宫格
func (s *Update) updateLuckyGrid(cpn *model.FissionCampaign) (err error) {
	var grid = s.Req.GetGrid()

	cc := cache.NewCampaignGrid(s.Ctx)
	conf, err := cc.FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if conf == nil {
		return workerr.NotFound("not found grid conf")
	}

	confM := s.GetDao().FissionCampaignGrid
	var data = []field.AssignExpr{
		confM.DayChance.Value(grid.GetDayChance()),
	}

	defer func() {
		if err != nil {
			return
		}
		_, err = confM.WithContext(s.Ctx).Where(confM.ID.Eq(conf.ID)).UpdateSimple(data...)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		_ = cc.Clear(conf)
	}()

	if cpn.Status != mtype.FissionCampaignStatusWait { //不是待发布状态不能修改配置
		return
	}

	data = append(data,
		confM.TargetNum.Value(grid.GetTargetNum()),
		confM.InitChance.Value(grid.GetInitChance()),
		confM.Chance.Value(grid.GetChance()),
	)

	//更新了初次抽奖机会，要处理玩家数据，预防有一些人没开始就进入游戏了，要同步一下数据
	if conf.InitChance != grid.GetInitChance() {
		fpwM := s.GetDao().FissionGrid
		_, err = fpwM.WithContext(s.Ctx).Where(fpwM.CampaignID.Eq(cpn.ID)).UpdateSimple(fpwM.Chance.Value(grid.GetInitChance()))
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	return
}

// 更新盲盒
func (s *Update) updateBlindBox(cpn *model.FissionCampaign) (err error) {
	var blind = s.Req.GetBlind()

	cc := cache.NewCampaignBlind(s.Ctx)
	conf, err := cc.FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if conf == nil {
		return workerr.NotFound("not found blind conf")
	}

	confM := s.GetDao().FissionCampaignBlind
	var data = []field.AssignExpr{
		confM.DayChance.Value(blind.GetDayChance()),
	}

	defer func() {
		if err != nil {
			return
		}
		_, err = confM.WithContext(s.Ctx).Where(confM.ID.Eq(conf.ID)).UpdateSimple(data...)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		_ = cc.Clear(conf)
	}()

	if cpn.Status != mtype.FissionCampaignStatusWait { //不是待发布状态不能修改配置
		return
	}

	data = append(data,
		confM.TargetNum.Value(blind.GetTargetNum()),
		confM.InitChance.Value(blind.GetInitChance()),
		confM.Chance.Value(blind.GetChance()),
	)

	//更新了初次抽奖机会，要处理玩家数据，预防有一些人没开始就进入游戏了，要同步一下数据
	if conf.InitChance != blind.GetInitChance() {
		fpwM := s.GetDao().FissionBlind
		_, err = fpwM.WithContext(s.Ctx).Where(fpwM.CampaignID.Eq(cpn.ID)).UpdateSimple(fpwM.Chance.Value(blind.GetInitChance()))
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	return
}

// 更新趣味问答
func (s *Update) updatePrizeAnswer(cpn *model.FissionCampaign) (err error) {

	qac := s.Req.GetQuestionAnswer()

	cc := cache.NewCampaignQa(s.Ctx)
	m := s.GetDao().FissionCampaignQa
	qa, err := cc.FindByCampaignId(cpn.ID)
	if err != nil {
		return s.BE().CacheError(err)
	}

	if qa == nil {
		return workerr.NotFound("not found qa")
	}

	var data = []field.AssignExpr{
		m.QuestionAskTime.Value(qac.GetQuestionAskTime()),
		m.QaNum.Value(qac.GetQaNum()),
		m.OpenGuide.Value(int8(qac.GetOpenGuide())),
	}

	if cpn.Status == mtype.FissionCampaignStatusWait { //不是待发布状态的直接返回
		data = append(data,
			m.TargetNum.Value(qac.GetTargetNum()),
			m.Chance.Value(qac.GetChance()),
			m.InitChance.Value(qac.GetInitChance()),
			m.DayChance.Value(qac.GetDayChance()),
		)
	}

	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")
		}
		data = append(data, m.QaGroupID.Value(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 guide group params error")
		}
		data = append(data, m.GuideGroupID.Value(group.ID))
	}

	//配置数据更新
	_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(qa.ID)).UpdateSimple(data...)
	if err != nil {
		return s.BE().MysqlError(err)
	}

	s.AddAfterRun(func() (err error) {
		_ = cc.Clear(qa)
		return
	})

	//更新了初次答题机会，要处理玩家数据，预防有一些人没开始就进入游戏了，要同步一下数据
	if qa.InitChance != qac.GetInitChance() {
		fqM := s.GetDao().FissionQa
		_, err = fqM.WithContext(s.Ctx).Where(fqM.CampaignID.Eq(cpn.ID)).UpdateSimple(fqM.Chance.Value(qac.GetInitChance()))
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	if cpn.FissionID != consts.IdPrizeAnswer {
		return
	}

	//问题数据更新
	var addCqq []*model.FissionCampaignQaQuestion
	var delCqq []int64
	var newCqqIds = make(map[int64]*pb.UpdateReq_QaQuestion)
	var sortCqq = make(map[int64]int32)
	for i, v := range qac.GetQuestions() {

		if v.GetId() > 0 {
			sortCqq[v.GetId()] = int32(i)
			//修改数据
			newCqqIds[v.GetId()] = v
			continue
		}

		//没有ID就是新增数据
		addCqq = append(addCqq, withdefault.FissionCampaignQaQuestion(&model.FissionCampaignQaQuestion{
			CampaignID: cpn.ID,
			QaID:       qa.ID,
			Title:      v.GetTitle(),
			Score:      v.GetScore(),
			Sort:       int32(i),
		}))
	}

	cqqM := s.GetDao().FissionCampaignQaQuestion
	cqqL, err := cqqM.WithContext(s.Ctx).Where(cqqM.QaID.Eq(qa.ID), cqqM.IsDel.Eq(mtype.No)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	for _, v := range cqqL {
		cqq, ok := newCqqIds[v.ID]
		if !ok {
			delCqq = append(delCqq, v.ID)
			continue
		}

		var uData = []field.AssignExpr{
			cqqM.Title.Value(cqq.GetTitle()),
			cqqM.Score.Value(cqq.GetScore()),
			cqqM.Sort.Value(sortCqq[cqq.GetId()]),
		}

		_, err = cqqM.WithContext(s.Ctx).Where(cqqM.ID.Eq(v.ID), cqqM.QaID.Eq(qa.ID)).UpdateSimple(uData...)
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	if len(addCqq) > 0 {
		err = cqqM.WithContext(s.Ctx).Create(addCqq...)
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	if len(delCqq) > 0 {
		_, err = cqqM.WithContext(s.Ctx).Where(cqqM.ID.In(delCqq...)).UpdateSimple(cqqM.IsDel.Value(mtype.Yes))
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	//答案数据更新
	var addCqo []*model.FissionCampaignQaOption
	var delCqo []int64
	var newCqoIds = make(map[int64]*pb.UpdateReq_QaOption)
	var idx int
	var qids []int64
	for _, v1 := range qac.GetQuestions() {
		//已有的题目
		if v1.GetId() > 0 {
			qids = append(qids, v1.GetId())

			for _, v := range v1.GetOptions() {
				if v.GetId() > 0 {
					//修改数据
					newCqoIds[v.GetId()] = v
					continue
				}

				//没有ID就是新增数据
				addCqo = append(addCqo, withdefault.FissionCampaignQaOption(&model.FissionCampaignQaOption{
					QuestionID: v1.GetId(),
					Title:      v.GetTitle(),
					IsRight:    int8(v.GetIsRight()),
				}))
			}

			continue
		}

		//新创建的题目
		for _, v := range v1.GetOptions() {
			//没有ID就是新增数据
			addCqo = append(addCqo, withdefault.FissionCampaignQaOption(&model.FissionCampaignQaOption{
				QuestionID: addCqq[idx].ID,
				Title:      v.GetTitle(),
				IsRight:    int8(v.GetIsRight()),
			}))
		}
		//下一个新创建题目的下标
		idx++
	}

	cqoM := s.GetDao().FissionCampaignQaOption
	if len(qids) > 0 {
		var cqoL []*model.FissionCampaignQaOption
		cqoL, err = cqoM.WithContext(s.Ctx).Where(cqoM.QuestionID.In(qids...), cqoM.IsDel.Eq(mtype.No)).Find()
		if err != nil {
			return s.BE().MysqlError(err)
		}

		for _, v := range cqoL {
			cqo, ok := newCqoIds[v.ID]
			if !ok {
				delCqo = append(delCqo, v.ID)
				continue
			}

			var uData = []field.AssignExpr{
				cqoM.Title.Value(cqo.GetTitle()),
				cqoM.IsRight.Value(int8(cqo.GetIsRight())),
			}

			_, err = cqoM.WithContext(s.Ctx).Where(cqoM.ID.Eq(v.ID)).UpdateSimple(uData...)
			if err != nil {
				return s.BE().MysqlError(err)
			}
		}
	}

	if len(addCqo) > 0 {
		err = cqoM.WithContext(s.Ctx).Create(addCqo...)
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	if len(delCqo) > 0 {
		_, err = cqoM.WithContext(s.Ctx).Where(cqoM.ID.In(delCqo...)).UpdateSimple(cqoM.IsDel.Value(mtype.Yes))
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	return
}

// 更新老带新
func (s *Update) updateReferral(cpn *model.FissionCampaign) (err error) {

	cc := cache.NewCampaignReferral(s.Ctx)
	crl, err := cc.FindByCampaignId(cpn.ID)
	if err != nil {
		return s.BE().CacheError(err)
	}

	if crl == nil {
		return workerr.NotFound("not found crl")
	}

	crlM := s.GetDao().FissionCampaignReferral
	var ref = s.Req.GetReferral()

	var data = []field.AssignExpr{
		crlM.RewardLimit.Value(ref.GetRewardLimit()),
		crlM.RewardRule.Value(int8(ref.GetRewardRule())),
		crlM.InviteLimit.Value(ref.GetInviteLimit()),
		crlM.StepLoop.Value(int8(ref.GetStepLoop())),
	}

	_, err = crlM.WithContext(s.Ctx).Where(crlM.ID.Eq(crl.ID)).UpdateSimple(data...)
	if err != nil {
		return s.BE().MysqlError(err)
	}

	if crl.RewardLimit < ref.GetRewardLimit() && cpn.Status != mtype.FissionCampaignStatusWait {

		s.AddAfterRun(func() (err error) {

			_ = app.NewVerControl(s.Ctx, ckey.FissionRewardLimitUpVer(cpn.ID), vercontrol.SetExpire(time.Hour)).Create(time.Now(), func() error {
				producer.NewCampaignNotice(s.Ctx).RewardLimitUp(types.RewardLimitUp{CampaignId: cpn.ID})
				return nil
			})

			return
		})
	}

	s.AddAfterRun(func() (err error) {
		_ = cc.Clear(crl)
		return
	})

	return
}

// 更新一起赢奖励
func (s *Update) updateWinTogether(cpn *model.FissionCampaign) (err error) {

	cc := cache.NewCampaignWin(s.Ctx)
	fcw, err := cc.FindByCampaignId(cpn.ID)
	if err != nil {
		return s.BE().CacheError(err)
	}

	if fcw == nil {
		return workerr.NotFound("not found fcw")
	}

	fcwM := s.GetDao().FissionCampaignWin
	var win = s.Req.GetWin()

	var data = []field.AssignExpr{
		fcwM.RewardLimit.Value(win.GetRewardLimit()),
		fcwM.RewardRule.Value(int8(win.GetRewardRule())),
		fcwM.InviteLimit.Value(win.GetInviteLimit()),
		fcwM.NewcomerCond.Value(int8(win.GetNewcomerCond())),
		fcwM.StepLoop.Value(int8(win.GetStepLoop())),
	}

	_, err = fcwM.WithContext(s.Ctx).Where(fcwM.ID.Eq(fcw.ID)).UpdateSimple(data...)
	if err != nil {
		return s.BE().MysqlError(err)
	}

	if fcw.RewardLimit < win.GetRewardLimit() && cpn.Status != mtype.FissionCampaignStatusWait {
		s.AddAfterRun(func() (err error) {

			_ = app.NewVerControl(s.Ctx, ckey.FissionRewardLimitUpVer(cpn.ID), vercontrol.SetExpire(time.Hour)).Create(time.Now(), func() error {
				producer.NewCampaignNotice(s.Ctx).RewardLimitUp(types.RewardLimitUp{CampaignId: cpn.ID})
				return nil
			})

			return
		})
	}

	s.AddAfterRun(func() (err error) {
		_ = cc.Clear(fcw)
		return
	})

	return
}

func (s *Update) syncEvent(cpn *model.FissionCampaign) (err error) {
	err = cmm.NewCMM(s.Ctx, s.GetDao()).SaveEventCampaignTrigger(cpn.ProjectID)
	if err != nil {
		return
	}

	return
}

// 更新报表任务
func (s *Update) updateTask(cpn *model.FissionCampaign) (err error) {
	m := s.GetDao().FissionArchiveTask

	if s.taskCondAdd {
		var endTime = utils.CampaignArchiveEnd(timez.GMT(s.Req.GetEndTime(), s.Req.GetTOffset())).Unix()
		err = m.WithContext(s.Ctx).Create(withdefault.FissionArchiveTask(&model.FissionArchiveTask{
			CampaignID: cpn.ID,
			EndTime:    endTime,
			Mark:       mtype.FissionArchiveTaskMarkCondHour,
		}), withdefault.FissionArchiveTask(&model.FissionArchiveTask{
			CampaignID: cpn.ID,
			EndTime:    endTime,
			Mark:       mtype.FissionArchiveTaskMarkCondDay,
		}))
		if err != nil {
			return s.BE().MysqlError(err)
		}

		return
	}

	if s.taskCondDel {
		_, err = m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.Mark.In(mtype.FissionArchiveTaskMarkCondHour, mtype.FissionArchiveTaskMarkCondDay)).Delete()
		if err != nil {
			return s.BE().MysqlError(err)
		}

		return
	}

	if s.taskEndChange {
		_, err = m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID)).UpdateSimple(m.EndTime.Value(utils.CampaignArchiveEnd(timez.GMT(s.Req.GetEndTime(), s.Req.GetTOffset())).Unix()))
		if err != nil {
			return s.BE().MysqlError(err)
		}

		return
	}

	err = cmm.NewCMM(s.Ctx, s.GetDao()).AnalyzeCampaign(cpn.ProjectID, cpn.ID, cpn.StartTime, cpn.EndTime, 0)
	if err != nil {
		return
	}

	return
}

// 更新签到
func (s *Update) updateSignIn(cpn *model.FissionCampaign) (err error) {
	cc := cache.NewCampaignSign(s.Ctx)
	conf, err := cc.FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if conf == nil {
		return workerr.NotFound("not found fcs")
	}

	fcsM := s.GetDao().FissionCampaignSign
	var sign = s.Req.GetSign()

	if cpn.Status != mtype.FissionCampaignStatusWait {
		_, err = fcsM.WithContext(s.Ctx).Where(fcsM.ID.Eq(conf.ID)).UpdateSimple(
			fcsM.Color.Value(sign.GetColor()),
			fcsM.SignCycle.Value(sign.GetSignCycle()),
		)
		if err != nil {
			return s.BE().MysqlError(err)
		}

		s.AddAfterRun(func() (err error) {
			return cc.Clear(conf)
		})

		return
	}

	var data = []field.AssignExpr{
		fcsM.SignType.Value(int8(sign.GetSignType())),
		fcsM.IsContinue.Value(int8(sign.GetIsContinue())),
		fcsM.HasCard.Value(int8(sign.GetHasCard())),
		fcsM.InviteNum.Value(sign.GetInviteNum()),
		fcsM.IsLoop.Value(int8(sign.GetIsLoop())),
		fcsM.SignCycle.Value(sign.GetSignCycle()),
		fcsM.RecycleType.Value(int8(sign.GetRecycleType())),
		fcsM.Color.Value(sign.GetColor()),
	}

	_, err = fcsM.WithContext(s.Ctx).Where(fcsM.ID.Eq(conf.ID)).UpdateSimple(data...)
	if err != nil {
		return s.BE().MysqlError(err)
	}

	s.AddAfterRun(func() (err error) {
		return cc.Clear(conf)
	})

	if conf.HasCard == mtype.No && sign.GetHasCard() == mtype.No {
		return
	}

	if conf.HasCard == mtype.No && sign.GetHasCard() == mtype.Yes {
		task := withdefault.FissionCampaignTask(&model.FissionCampaignTask{
			CampaignID: cpn.ID,
			TaskType:   mtype.FissionCampaignTaskTypeInstall,
			TaskMark:   mtype.FissionCampaignTaskMarkInstall,
			PropMark:   mtype.FissionCampaignTaskPropMarkChance,
			Num:        sign.GetInviteNum(),
			Chance:     1,
		})

		err = s.GetDao().FissionCampaignTask.WithContext(s.Ctx).Create(task)
		if err != nil {
			return s.BE().MysqlError(err)
		}

		return
	}

	taskM := s.GetDao().FissionCampaignTask
	task, err := taskM.WithContext(s.Ctx).Where(
		taskM.CampaignID.Eq(cpn.ID),
		taskM.TaskType.Eq(mtype.FissionCampaignTaskTypeInstall),
		taskM.PropMark.Eq(mtype.FissionCampaignTaskPropMarkChance),
	).Take()
	if err != nil {
		return
	}

	if sign.GetHasCard() == mtype.No {
		_, err = taskM.WithContext(s.Ctx).Where(taskM.ID.Eq(task.ID)).UpdateSimple(taskM.IsDel.Value(mtype.Yes))
		if err != nil {
			return s.BE().MysqlError(err)
		}
		return
	}

	_, err = taskM.WithContext(s.Ctx).Where(taskM.ID.Eq(task.ID)).UpdateSimple(taskM.Num.Value(sign.GetInviteNum()))
	if err != nil {
		return s.BE().MysqlError(err)
	}

	return
}

func (s *Update) updateDice(cpn *model.FissionCampaign) (err error) {
	var dice = s.Req.GetDice()
	fcdM := s.GetDao().FissionCampaignDice
	fcd, err := fcdM.WithContext(s.Ctx).Where(fcdM.CampaignID.Eq(cpn.ID)).Take()
	if err = dbcheck.DbError(err); err != nil {
		return s.BE().MysqlError(err)
	}

	if fcd == nil {
		return workerr.NotFound("not found fcd")
	}

	var data = []field.AssignExpr{
		fcdM.InitChance.Value(dice.GetInitChance()),
		fcdM.CustomDice.Value(dice.GetCustomDice()),
		fcdM.DayChance.Value(dice.GetDayChance()),
		fcdM.OpenMapPoint.Value(int8(dice.GetOpenMapPoint())),
		fcdM.OpenInvite.Value(int8(dice.GetOpenInvite())),
		fcdM.Odds.Value(dice.GetOdds()),
		fcdM.PlayImg.Value(dice.GetPlayImg()),
		fcdM.CloudImg.Value(dice.GetCloudImg()),
	}

	mapPoint, _ := jsonm.MarshalToString(&mtype.MapPoint{
		Blank:  dice.GetMapPoint().GetBlank(),
		Again:  dice.GetMapPoint().GetAgain(),
		Normal: dice.GetMapPoint().GetNormal(),
		Supper: dice.GetMapPoint().GetSupper(),
	})

	data = append(data, fcdM.MapPoint.Value(mapPoint))

	// 更新数据
	defer func() {
		_, err = fcdM.WithContext(s.Ctx).Where(fcdM.ID.Eq(fcd.ID)).UpdateSimple(data...)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		_ = cache.NewCampaignDice(s.Ctx).Clear(fcd)

		if fcd.InitChance != dice.GetInitChance() {
			s.OL().User(s.Req.UserId, s.Req.Ip).UpdateRunningDiceInit(fcd.ID, fcd.InitChance, dice.GetInitChance())
		}

		if fcd.DayChance != dice.GetDayChance() {
			s.OL().User(s.Req.UserId, s.Req.Ip).UpdateRunningDiceDay(fcd.ID, fcd.DayChance, dice.GetDayChance())
		}

	}()

	if cpn.Status != mtype.FissionCampaignStatusWait { //不是待发布状态的直接返回
		return
	}

	data = append(data,
		fcdM.FixDiceTarget.Value(dice.GetFixDiceTarget()),
		fcdM.FixDice.Value(int8(dice.GetFixDice())),
		fcdM.FixDiceLimit.Value(dice.GetFixDiceLimit()),
		fcdM.AwardType.Value(int8(dice.GetAwardType())),
		fcdM.RollAgain.Value(int8(dice.GetRollAgain())),
		fcdM.FixDiceCond.Value(int8(dice.GetFixDiceCond())),
	)

	if fcd.FixDice == mtype.No && dice.GetFixDice() == mtype.No {
		return
	}

	ntt := utils.Ternary[int8](dice.GetFixDiceCond() == mtype.FissionCampaignDiceFixDiceCondInstall,
		mtype.FissionCampaignTaskTypeInstall, mtype.FissionCampaignTaskTypeRegister)
	ntm := utils.Ternary[string](dice.GetFixDiceCond() == mtype.FissionCampaignDiceFixDiceCondInstall,
		mtype.FissionCampaignTaskMarkInstall, mtype.FissionCampaignTaskMarkRegister)

	taskM := s.GetDao().FissionCampaignTask
	if fcd.FixDice == mtype.No && dice.GetFixDice() == mtype.Yes {
		err = taskM.WithContext(s.Ctx).Create(&model.FissionCampaignTask{
			CampaignID:  cpn.ID,
			TaskType:    ntt,
			TaskMark:    ntm,
			PropMark:    mtype.FissionCampaignTaskPropMarkFixedRoll,
			Num:         dice.GetFixDiceTarget(),
			Chance:      1,
			ChanceLimit: dice.GetFixDiceLimit(),
			TaskLimit:   0,
		})
		if err != nil {
			return s.BE().MysqlError(err)
		}

		return
	}

	ott := utils.Ternary[string](
		fcd.FixDiceCond == mtype.FissionCampaignDiceFixDiceCondInstall,
		mtype.FissionCampaignTaskMarkInstall, mtype.FissionCampaignTaskMarkRegister)

	task, err := taskM.WithContext(s.Ctx).Where(
		taskM.CampaignID.Eq(cpn.ID),
		taskM.TaskMark.Eq(ott),
		taskM.PropMark.Eq(mtype.FissionCampaignTaskPropMarkFixedRoll),
		taskM.IsDel.Eq(mtype.No),
	).Take()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if fcd.FixDice == mtype.Yes && dice.GetFixDice() == mtype.No {
		_, err = taskM.WithContext(s.Ctx).Where(taskM.ID.Eq(task.ID)).UpdateSimple(taskM.IsDel.Value(mtype.Yes))
		if err != nil {
			return s.BE().MysqlError(err)
		}

		return
	}

	if fcd.FixDice == mtype.Yes && dice.GetFixDice() == mtype.Yes {
		_, err = taskM.WithContext(s.Ctx).Where(taskM.ID.Eq(task.ID)).UpdateSimple(
			taskM.TaskType.Value(ntt),
			taskM.TaskMark.Value(ntm),
			taskM.Num.Value(dice.GetFixDiceTarget()),
			taskM.ChanceLimit.Value(dice.GetFixDiceLimit()),
		)
		if err != nil {
			return s.BE().MysqlError(err)
		}

		return
	}

	return
}

func (s *Update) updateGrow(cpn *model.FissionCampaign) (err error) {
	if cpn.Status != mtype.FissionCampaignStatusWait { //不是待发布状态的直接返回
		return
	}

	confM := s.GetDao().FissionCampaignGrow

	conf, err := confM.WithContext(s.Ctx).Where(confM.CampaignID.Eq(cpn.ID)).Take()
	if err = dbcheck.DbError(err); err != nil {
		return s.BE().MysqlError(err)
	}

	if conf == nil {
		return workerr.NotFound("not found grow conf")
	}
	var grow = s.Req.GetGrow()

	var data = []field.AssignExpr{
		confM.AutoHour.Value(grow.GetAutoHour()),
		confM.AutoNum.Value(grow.GetAutoNum()),
		confM.GrowNum.Value(grow.GetGrowNum()),
		confM.TargetNum.Value(grow.GetTargetNum()),
		confM.Revive.Value(int8(grow.GetRevive())),
		confM.ReviveNum.Value(grow.GetReviveNum()),
		confM.DieHour.Value(grow.GetDieHour()),
		confM.InitNum.Value(grow.GetInitNum()),
	}

	_, err = confM.WithContext(s.Ctx).Where(confM.ID.Eq(conf.ID)).UpdateSimple(data...)
	if err != nil {
		return s.BE().MysqlError(err)
	}

	// 阶段更新
	var stepAdd []*model.FissionCampaignGrowStep
	var stepDel []int64
	var stepNewIds = make(map[int64]*pb.UpdateReq_GrowStep)
	var stepMap = make(map[int64]int32)
	for i, v := range grow.GetSteps() {
		if v.GetId() > 0 {
			//修改数据
			stepNewIds[v.GetId()] = v
			stepMap[v.GetId()] = int32(i + 1)
			continue
		}

		//没有ID就是新增数据
		stepAdd = append(stepAdd, withdefault.FissionCampaignGrowStep(&model.FissionCampaignGrowStep{
			CampaignID: cpn.ID,
			Step:       int32(i + 1),
			Num:        v.GetNum(),
		}))
	}

	stepM := s.GetDao().FissionCampaignGrowStep
	steps, err := stepM.WithContext(s.Ctx).Where(
		stepM.CampaignID.Eq(cpn.ID),
		stepM.IsDel.Eq(mtype.No),
	).Order(stepM.Step).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	for _, v := range steps {
		step, ok := stepNewIds[v.ID]
		if !ok {
			stepDel = append(stepDel, v.ID)
			continue
		}

		_, err = stepM.WithContext(s.Ctx).Where(stepM.ID.Eq(v.ID), stepM.CampaignID.Eq(cpn.ID)).UpdateSimple(stepM.Step.Value(stepMap[v.ID]), stepM.Num.Value(step.GetNum()))
		if err != nil {
			return s.BE().MysqlError(err)
		}

	}

	if len(stepAdd) > 0 {
		err = stepM.WithContext(s.Ctx).Create(stepAdd...)
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	if len(stepDel) > 0 {
		_, err = stepM.WithContext(s.Ctx).Where(stepM.ID.In(stepDel...), stepM.CampaignID.Eq(cpn.ID)).UpdateSimple(stepM.IsDel.Value(mtype.Yes))
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	//更新复活任务
	err = s._updateReviveTask(cpn)
	if err != nil {
		return err
	}

	return
}

func (s *Update) _updateReviveTask(cpn *model.FissionCampaign) error {
	grow := s.Req.GetGrow()
	taskM := s.GetDao().FissionCampaignTask
	task, err := taskM.WithContext(s.Ctx).Where(
		taskM.CampaignID.Eq(cpn.ID),
		taskM.TaskMark.Eq(mtype.FissionCampaignTaskMarkInstall),
		taskM.PropMark.Eq(mtype.FissionCampaignTaskPropMarkRevive),
		taskM.IsDel.Eq(mtype.No),
	).Take()
	if err = dbcheck.DbError(err); err != nil {
		return s.BE().MysqlError(err)
	}

	switch grow.GetRevive() {
	case mtype.Yes:
		//如果没有复活任务则创建复活任务
		if task == nil {
			task = withdefault.FissionCampaignTask(&model.FissionCampaignTask{
				CampaignID: cpn.ID,
				TaskType:   mtype.FissionCampaignTaskTypeInstall,
				TaskMark:   mtype.FissionCampaignTaskMarkInstall,
				PropMark:   mtype.FissionCampaignTaskPropMarkRevive,
				Num:        grow.GetReviveNum(),
				Chance:     1,
			})
			err = taskM.WithContext(s.Ctx).Create(task)
		} else {
			_, err = taskM.WithContext(s.Ctx).Where(taskM.ID.Eq(task.ID)).UpdateSimple(taskM.Num.Value(grow.GetReviveNum()))
		}
		if err != nil {
			return err
		}
	case mtype.No:
		//有任务则删除复活任务
		if task == nil {
			return nil
		}
		_, err = taskM.WithContext(s.Ctx).Where(taskM.ID.Eq(task.ID)).UpdateSimple(taskM.IsDel.Value(mtype.Yes))
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}
	return nil
}

func (s *Update) updateBallot(cpn *model.FissionCampaign) (err error) {
	if cpn.Status != mtype.FissionCampaignStatusWait { //不是待发布状态的直接返回
		return
	}

	cc := cache.NewCampaignBallot(s.Ctx)
	conf, err := cc.FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if conf == nil {
		return workerr.NotFound("not found ballot conf")
	}

	confM := s.GetDao().FissionCampaignBallot
	var ballot = s.Req.GetBallot()
	var data = []field.AssignExpr{
		confM.InitChance.Value(ballot.GetInitChance()),
		confM.DayChance.Value(ballot.GetDayChance()),
	}

	_, err = confM.WithContext(s.Ctx).Where(confM.ID.Eq(conf.ID)).UpdateSimple(data...)
	if err != nil {
		return s.BE().MysqlError(err)
	}

	return
}

func (s *Update) updateChop(cpn *model.FissionCampaign) (err error) {
	if cpn.Status != mtype.FissionCampaignStatusWait { //不是待发布状态的直接返回
		return
	}

	cc := cache.NewCampaignChop(s.Ctx)
	conf, err := cc.FindByCampaignId(cpn.ID)
	if err != nil {
		return s.BE().CacheError(err)
	}

	if conf == nil {
		return workerr.NotFound("not found chop conf")
	}

	confM := s.GetDao().FissionCampaignChop
	var chop = s.Req.GetChop()

	var data []field.AssignExpr

	if conf.ShowBar != int8(chop.GetShowBar()) {
		data = append(data, confM.ShowBar.Value(int8(chop.GetShowBar())))
	}

	if len(data) == 0 {
		return
	}

	_, err = confM.WithContext(s.Ctx).Where(confM.ID.Eq(conf.ID)).UpdateSimple(data...)
	if err != nil {
		return s.BE().MysqlError(err)
	}

	_ = cc.Clear(conf)

	return
}

// 设置延迟深度链接数据
func (s *Update) 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(),
		})
	}

	if len(data.Data) == 0 {
		return
	}

	_, err = app.NewDeepLinkLink().SaveCampaignDataList(s.Ctx, data)
	if err != nil {
		return
	}

	return
}

// 处理奖品数据
func (s *Update) updateReward(cpn *model.FissionCampaign) (err error) {

	// 发布之后
	if s.justUpdatePart {
		return s._updateRunningReward(cpn)
	}

	m := s.GetDao().FissionCampaignReward
	list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.IsDel.Eq(mtype.No)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	var add = s.otherReward
	var delIds []int64
	webAdd, webDelIds, err := s._updateRewards(s.Req.GetRewardsWeb(), list, cpn, mtype.FissionCampaignRewardTypeWeb, consts.CampaignUserType{})
	if err != nil {
		return
	}

	add = append(add, webAdd...)
	delIds = append(delIds, webDelIds...)

	extraAdd, extraDelIds, err := s._updateRewards(s.Req.GetRewardsExtra(), list, cpn, mtype.FissionCampaignRewardTypeExtra, consts.CampaignUserType{})
	if err != nil {
		return
	}

	add = append(add, extraAdd...)
	delIds = append(delIds, extraDelIds...)

	newcomerAdd, newcomerDelIds, err := s._updateRewards(s.Req.GetRewardsNewcomer(), list, cpn, mtype.FissionCampaignRewardTypeNewcomer, consts.CampaignUserType{})
	if err != nil {
		return
	}

	add = append(add, newcomerAdd...)
	delIds = append(delIds, newcomerDelIds...)

	var appAdd []*model.FissionCampaignReward
	var appDelIds []int64
	switch s.Req.GetRewards().GetRewardGroup() {
	case mtype.FissionRewardGroupNormal:
		appAdd, appDelIds, err = s._updateRewards(s.Req.GetRewards().GetNormal(), list, cpn, mtype.FissionCampaignRewardTypeApp, consts.CampaignUserType{})
		if err != nil {
			return
		}

	case mtype.FissionRewardGroupLang:
		var langMarks []string
		for _, langs := range s.Req.GetRewards().GetLangs() {
			var langAdd []*model.FissionCampaignReward
			var langDelIds []int64
			langAdd, langDelIds, err = s._updateRewards(langs.GetRewards(), list, cpn, mtype.FissionCampaignRewardTypeApp, consts.CampaignUserType{LangMark: langs.GetLangMark()})
			if err != nil {
				return
			}

			appAdd = append(appAdd, langAdd...)
			appDelIds = append(appDelIds, langDelIds...)
			langMarks = append(langMarks, langs.GetLangMark())
		}

		_, err = m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.LangMark.NotIn(langMarks...)).UpdateSimple(m.IsDel.Value(mtype.Yes))
		if err != nil {
			return
		}

	case mtype.FissionRewardGroupUserLevel:
		var levelIds []int64
		for _, level := range s.Req.GetRewards().GetUserLevel().GetLevelList() {
			var levelAdd []*model.FissionCampaignReward
			var levelDelIds []int64
			levelAdd, levelDelIds, err = s._updateRewards(level.GetRewards(), list, cpn, mtype.FissionCampaignRewardTypeApp, consts.CampaignUserType{LevelId: level.GetLevelId()})
			if err != nil {
				return
			}
			appAdd = append(appAdd, levelAdd...)
			appDelIds = append(appDelIds, levelDelIds...)
			levelIds = append(levelIds, level.GetLevelId())
		}

		_, err = m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.LevelID.NotIn(levelIds...)).UpdateSimple(m.IsDel.Value(mtype.Yes))
		if err != nil {
			return
		}

	case mtype.FissionRewardGroupLangAndUserLevel:
		var langMarks []string

		for _, lang := range s.Req.GetRewards().GetLangUserLevel() {
			var levelIds []int64
			for _, level := range lang.GetLevelList() {
				var llAdd []*model.FissionCampaignReward
				var llDelIds []int64
				llAdd, llDelIds, err = s._updateRewards(level.GetRewards(), list, cpn, mtype.FissionCampaignRewardTypeApp, consts.CampaignUserType{LevelId: level.GetLevelId(), LangMark: lang.GetLangMark()})
				if err != nil {
					return
				}

				appAdd = append(appAdd, llAdd...)
				appDelIds = append(appDelIds, llDelIds...)
				levelIds = append(levelIds, level.GetLevelId())
			}

			_, err = m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.LangMark.Eq(lang.GetLangMark()), m.LevelID.NotIn(levelIds...)).UpdateSimple(m.IsDel.Value(mtype.Yes))
			if err != nil {
				return
			}

			langMarks = append(langMarks, lang.GetLangMark())
		}

		_, err = m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.LangMark.NotIn(langMarks...), m.LevelID.Gt(0)).UpdateSimple(m.IsDel.Value(mtype.Yes))
		if err != nil {
			return
		}

	case mtype.FissionRewardGroupCountry:
		var countryMarks []string
		for _, country := range s.Req.GetRewards().GetCountry().GetCountryList() {
			var countryAdd []*model.FissionCampaignReward
			var countryDelIds []int64
			countryAdd, countryDelIds, err = s._updateRewards(country.GetRewards(), list, cpn, mtype.FissionCampaignRewardTypeApp, consts.CampaignUserType{CountryMark: country.GetCountryMark()})
			if err != nil {
				return
			}
			appAdd = append(appAdd, countryAdd...)
			appDelIds = append(appDelIds, countryDelIds...)
			countryMarks = append(countryMarks, country.GetCountryMark())
		}

		_, err = m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.CountryMark.NotIn(countryMarks...)).UpdateSimple(m.IsDel.Value(mtype.Yes))
		if err != nil {
			return
		}
	}

	add = append(add, appAdd...)
	delIds = append(delIds, appDelIds...)

	if len(add) > 0 {
		if err = m.WithContext(s.Ctx).Create(add...); err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	if len(delIds) > 0 {
		if _, err = m.WithContext(s.Ctx).Where(m.ID.In(delIds...)).UpdateSimple(m.IsDel.Value(mtype.Yes)); err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	err = s._updateRelated(cpn.ID)
	if err != nil {
		return
	}

	// 更新规则
	err = s._updateRule(cpn.ID)
	if err != nil {
		return
	}

	if cpn.FissionID == consts.IdChop {
		err = s._updateHelp(cpn.ID)
		if err != nil {
			return
		}
	}

	return s._updateHelpTicket(cpn)
}

// 更新奖品数据
func (s *Update) _updateRewards(newList []*pb.UpdateReq_Reward, oldList []*model.FissionCampaignReward, cpn *model.FissionCampaign, rt int8, t consts.CampaignUserType) (add []*model.FissionCampaignReward, delIds []int64, err error) {
	if len(oldList) == 0 && len(newList) == 0 {
		return
	}

	var oldMap = make(map[int64]*model.FissionCampaignReward)
	for _, v := range oldList {
		if v.RewardType == rt && v.LangMark == t.LangMark && v.LevelID == t.LevelId && v.CountryMark == t.CountryMark {
			oldMap[v.ID] = v
		}
	}

	var delStockId []int64
	m := s.GetDao().FissionCampaignReward
	for i, v := range newList {
		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
		}

		hashRule := utils.Ternary[int8](v.GetCampaignLimit() > 0, mtype.Yes, mtype.No)
		sort := int32(i)
		old, ok := oldMap[v.GetId()]
		if !ok {

			one := withdefault.FissionCampaignReward(&model.FissionCampaignReward{
				CampaignID:  cpn.ID,
				Stock:       v.GetStock(),
				Sort:        sort,
				RewardType:  rt,
				Step:        step,
				InviteNum:   v.GetInviteNum(),
				RewardNum:   v.GetRewardNum(),
				IsThank:     int8(v.GetIsThank()),
				Score:       v.GetScore(),
				SignDay:     v.GetSignDay(),
				CollectNum:  v.GetCollectNum(),
				IsSuper:     int8(v.GetIsSuper()),
				RewardID:    v.GetRewardId(),
				LangMark:    t.LangMark,
				LevelID:     t.LevelId,
				Odds:        v.GetOdds(),
				CountryMark: t.CountryMark,
				JumpURL:     v.GetJumpUrl(),
				HasRule:     hashRule,
				InitPercent: v.GetInitPercent(),
				PropMark:    mtype.FissionCampaignRewardPropMarkReward,
				OpenAdd:     int8(v.GetOpenAdd().GetOpen()),
				OpenTask:    int8(v.GetRewardTask().GetOpen()),
			})

			s.rewardAdd[one.ID] = v.GetOpenAdd()
			s.rewardTask[one.ID] = v.GetRewardTask()

			if cpn.FissionID == consts.IdDice {
				one.SetCollectRule(mtype.CollectRule{
					Open:        v.GetCollectRule().GetOpen(),
					InitCollect: v.GetCollectRule().GetInitCollect(),
					SignDay:     v.GetCollectRule().GetSignDay(),
					AddCollect:  v.GetCollectRule().GetAddCollect(),
					ResetType:   v.GetCollectRule().GetResetType(),
				})
			}

			add = append(add, one)

			newList[i].Id = one.ID
			continue
		}

		delete(oldMap, old.ID)
		s.rewardAdd[old.ID] = v.GetOpenAdd()
		s.rewardTask[old.ID] = v.GetRewardTask()

		var upData []field.AssignExpr

		if old.Sort != sort {
			upData = append(upData, m.Sort.Value(sort))
		}

		if old.Step != step {
			upData = append(upData, m.Step.Value(step))
		}

		if old.Score != v.GetScore() {
			upData = append(upData, m.Score.Value(v.GetScore()))
		}

		if old.Odds != v.GetOdds() {
			upData = append(upData, m.Odds.Value(v.GetOdds()))
		}

		if old.Stock != v.GetStock() {
			upData = append(upData, m.Stock.Value(v.GetStock()))
		}

		if old.InitPercent != v.GetInitPercent() {
			upData = append(upData, m.InitPercent.Value(v.GetInitPercent()))
		}

		if old.OpenAdd != int8(v.GetOpenAdd().GetOpen()) {
			upData = append(upData, m.OpenAdd.Value(int8(v.GetOpenAdd().GetOpen())))
		}

		if old.OpenTask != int8(v.GetRewardTask().GetOpen()) {
			upData = append(upData, m.OpenTask.Value(int8(v.GetRewardTask().GetOpen())))
		}

		hasRule := utils.Ternary[int8](v.GetCampaignLimit() > 0, mtype.Yes, mtype.No)
		if old.HasRule != hasRule {
			upData = append(upData, m.HasRule.Value(hasRule))
		}

		if cpn.FissionID == consts.IdDice {
			cr, _ := jsonm.MarshalToString(mtype.CollectRule{
				Open:        v.GetCollectRule().GetOpen(),
				InitCollect: v.GetCollectRule().GetInitCollect(),
				SignDay:     v.GetCollectRule().GetSignDay(),
				AddCollect:  v.GetCollectRule().GetAddCollect(),
				ResetType:   v.GetCollectRule().GetResetType(),
			})

			oldCr, newCr := utils.Md5Any(old.GetCollectRule()), utils.Md5String(cr)
			if oldCr != newCr {
				upData = append(upData, m.CollectRule.Value(cr))
			}
		}

		if old.InviteNum != v.GetInviteNum() {
			upData = append(upData, m.InviteNum.Value(v.GetInviteNum()))
		}

		if old.RewardNum != v.GetRewardNum() {
			upData = append(upData, m.RewardNum.Value(v.GetRewardNum()))
		}

		if old.IsThank != int8(v.GetIsThank()) {
			upData = append(upData, m.IsThank.Value(int8(v.GetIsThank())))
		}

		if old.SignDay != v.GetSignDay() {
			upData = append(upData, m.SignDay.Value(v.GetSignDay()))
		}

		if old.CollectNum != v.GetCollectNum() {
			upData = append(upData, m.CollectNum.Value(v.GetCollectNum()))
		}

		if old.IsSuper != int8(v.GetIsSuper()) {
			upData = append(upData, m.IsSuper.Value(int8(v.GetIsSuper())))
		}

		if old.RewardID != v.GetRewardId() {
			upData = append(upData, m.RewardID.Value(v.GetRewardId()))
		}

		if old.JumpURL != v.GetJumpUrl() {
			upData = append(upData, m.JumpURL.Value(v.GetJumpUrl()))
		}

		if len(upData) == 0 {
			continue
		}

		_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(old.ID)).UpdateSimple(upData...)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		if old.Stock != v.GetStock() && verify.InArray(cpn.Status, mtype.FissionCampaignStatusPubPre, mtype.FissionCampaignStatusPub) {
			delStockId = append(delStockId, old.ID)
			s.OL().User(s.Req.UserId, s.Req.Ip).UpdateRunningStock(old.ID, old.Stock, v.GetStock())
		}

	}

	s.AddAfterRun(func() (err error) {
		if len(delStockId) > 0 {
			stocks.NewCleaner(s.Ctx, delStockId...).ClearAllReward()
		}
		return
	})

	if len(oldMap) == 0 {
		return
	}

	for _, v := range oldMap {
		delIds = append(delIds, v.ID)
	}

	return
}

// 更新奖品库存追加规则
func (s *Update) updateRewardAdd(cpn *model.FissionCampaign) (err error) {

	m := s.GetDao().FissionCampaignRewardAdd
	oldList, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.IsDel.Eq(mtype.No)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	oldMap := make(map[int64]*model.FissionCampaignRewardAdd, len(oldList))
	for _, old := range oldList {
		oldMap[old.RewardID] = old
	}

	list := make([]*model.FissionCampaignRewardAdd, 0)
	for rewardID, add := range s.rewardAdd {
		if add.GetOpen() == mtype.No {
			continue
		}

		var start = timez.GMT(add.GetStart(), cpn.TOffset)
		var end = timez.GMT(add.GetEnd(), cpn.TOffset)

		old, ok := oldMap[rewardID]
		if ok {
			var upData []field.AssignExpr
			if old.DayNum != add.GetDayNum() {
				upData = append(upData, m.DayNum.Value(add.GetDayNum()))
			}
			if old.DayAdd != add.GetDayAdd() {
				upData = append(upData, m.DayAdd.Value(add.GetDayAdd()))
			}

			if old.Start != start {
				upData = append(upData, m.Start.Value(start))
			}

			if old.End != end {
				upData = append(upData, m.End.Value(end))
			}

			if (old.Start != start || old.End != end) && old.FinishAt != 0 {
				upData = append(upData, m.FinishAt.Value(0))
			}

			if len(upData) > 0 {
				if _, err = m.WithContext(s.Ctx).Where(m.ID.Eq(old.ID)).UpdateSimple(upData...); err != nil {
					return s.BE().MysqlError(err)
				}
			}

			delete(oldMap, rewardID)

			continue
		}

		list = append(list, withdefault.FissionCampaignRewardAdd(&model.FissionCampaignRewardAdd{
			CampaignID: cpn.ID,
			RewardID:   rewardID,
			Start:      start,
			End:        end,
			DayNum:     add.GetDayNum(),
			DayAdd:     add.GetDayAdd(),
		}))
	}

	if len(list) > 0 {
		if err = m.WithContext(s.Ctx).Create(list...); err != nil {
			return s.BE().MysqlError(err)
		}
	}

	var delIds []int64
	for _, v := range oldMap {
		delIds = append(delIds, v.ID)
	}

	if len(delIds) > 0 {
		if _, err = m.WithContext(s.Ctx).Where(m.ID.In(delIds...)).UpdateSimple(m.IsDel.Value(mtype.Yes)); err != nil {
			return s.BE().MysqlError(err)
		}
	}

	return
}

// 更新奖品任务
func (s *Update) updateRewardTask(cpn *model.FissionCampaign) (err error) {

	m := s.GetDao().FissionCampaignCond
	oldList, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.IsDel.Eq(mtype.No), m.RewardID.Gt(0)).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	oldMap := make(map[int64]*model.FissionCampaignCond, len(oldList))
	for _, old := range oldList {
		oldMap[old.RewardID] = old
	}

	conds := make([]*model.FissionCampaignCond, 0)
	tasks := make([]*model.FissionCampaignTask, 0)

	for rewardID, add := range s.rewardTask {
		if add.GetOpen() == mtype.No {
			continue
		}

		old, ok := oldMap[rewardID]
		if ok {
			var upData []field.AssignExpr
			if old.Event != add.GetEvent() {
				upData = append(upData, m.Event.Value(add.GetEvent()))
			}

			if old.EventKey != add.GetEventKey() {
				upData = append(upData, m.EventKey.Value(add.GetEventKey()))
			}

			if old.EventVal != add.GetEventVal() {
				upData = append(upData, m.EventVal.Value(add.GetEventVal()))
			}

			if old.EventType != int8(add.GetEventType()) {
				upData = append(upData, m.EventType.Value(int8(add.GetEventType())))
			}

			if old.IfCond != int8(add.GetIfCond()) {
				upData = append(upData, m.IfCond.Value(int8(add.GetIfCond())))
			}

			if old.TriggetType != int8(add.GetTriggerType()) {
				upData = append(upData, m.OpenPush.Value(int8(add.GetOpenPush())))
			}

			if old.OpenPush != int8(add.GetOpenPush()) {
				upData = append(upData, m.OpenPush.Value(int8(add.GetOpenPush())))
			}

			if len(upData) > 0 {
				if _, err = m.WithContext(s.Ctx).Where(m.ID.Eq(old.ID)).UpdateSimple(upData...); err != nil {
					return s.BE().MysqlError(err)
				}
			}

			delete(oldMap, rewardID)

			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:    rewardID,
		})

		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:   rewardID,
		}))
	}

	if len(conds) > 0 {
		if err = m.WithContext(s.Ctx).Create(conds...); err != nil {
			return s.BE().MysqlError(err)
		}
	}

	if len(tasks) > 0 {
		if err = s.GetDao().FissionCampaignTask.WithContext(s.Ctx).Create(tasks...); err != nil {
			return s.BE().MysqlError(err)
		}
	}

	var delIds []int64
	for _, v := range oldMap {
		delIds = append(delIds, v.ID)
	}

	if len(delIds) > 0 {
		if _, err = m.WithContext(s.Ctx).Where(m.ID.In(delIds...)).UpdateSimple(m.IsDel.Value(mtype.Yes)); err != nil {
			return s.BE().MysqlError(err)
		}
	}

	return
}

// 更新奖品关联
func (s *Update) _updateRelated(cpnId int64) (err error) {
	m := s.GetDao().RewardRelated
	list, err := m.WithContext(s.Ctx).Where(m.RelateID.Eq(cpnId), m.RelateTable.Eq(dao.FissionCampaign.TableName())).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	var relateMap = make(map[int64]struct{})
	var oldMap = make(map[int64]*model.RewardRelated)
	for _, v := range list {
		oldMap[v.RewardID] = v
		relateMap[v.RewardID] = struct{}{}
	}

	var orIds []int64
	var add []*model.RewardRelated

	for _, rewardId := range s.otherRelateIds {
		_, ok := relateMap[rewardId]
		if !ok {
			add = append(add, withdefault.RewardRelated(&model.RewardRelated{
				RewardID:    rewardId,
				RelateID:    cpnId,
				RelateTable: dao.FissionCampaign.TableName(),
				CancelTime:  0,
			}))
			relateMap[rewardId] = struct{}{}
			continue
		}

		old, ok1 := oldMap[rewardId]
		if ok1 && old.CancelTime > 0 {
			orIds = append(orIds, old.ID)
		}
		delete(oldMap, rewardId)
	}

	var bfn = func(newList []*pb.UpdateReq_Reward) (err error) {
		for _, v := range newList {
			_, ok := relateMap[v.GetRewardId()]
			if !ok {
				add = append(add, withdefault.RewardRelated(&model.RewardRelated{
					RewardID:    v.GetRewardId(),
					RelateID:    cpnId,
					RelateTable: dao.FissionCampaign.TableName(),
					CancelTime:  0,
				}))
				relateMap[v.GetRewardId()] = struct{}{}
				continue
			}

			old, ok1 := oldMap[v.GetRewardId()]
			if ok1 && old.CancelTime > 0 {
				orIds = append(orIds, old.ID)
			}
			delete(oldMap, v.GetRewardId())
		}
		return
	}

	_ = bfn(s.Req.GetRewardsWeb())
	_ = bfn(s.Req.GetRewardsExtra())
	_ = bfn(s.Req.GetRewardsNewcomer())

	_ = s._switchRewardGroupDo(bfn)

	if len(add) > 0 {
		if err = m.WithContext(s.Ctx).Create(add...); err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	if len(orIds) > 0 {
		if _, err = m.WithContext(s.Ctx).Where(m.ID.In(orIds...)).UpdateSimple(m.CancelTime.Value(0)); err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	if len(oldMap) == 0 {
		return
	}

	var cancelIds []int64
	for _, v := range oldMap {
		cancelIds = append(cancelIds, v.ID)
	}

	if _, err = m.WithContext(s.Ctx).Where(m.ID.In(cancelIds...)).UpdateSimple(m.CancelTime.Value(time.Now().Unix())); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	return
}

// 更具奖品类型处理奖品
func (s *Update) _switchRewardGroupDo(do func(rewards []*pb.UpdateReq_Reward) error) (err error) {
	switch s.Req.GetRewards().GetRewardGroup() {
	case mtype.FissionRewardGroupNormal:
		return do(s.Req.GetRewards().GetNormal())
	case mtype.FissionRewardGroupLang:
		for _, langs := range s.Req.GetRewards().GetLangs() {
			err = do(langs.GetRewards())
			if err != nil {
				return
			}
		}
	case mtype.FissionRewardGroupUserLevel:
		for _, level := range s.Req.GetRewards().GetUserLevel().GetLevelList() {
			err = do(level.GetRewards())
			if err != nil {
				return
			}
		}

	case mtype.FissionRewardGroupLangAndUserLevel:
		for _, lang := range s.Req.GetRewards().GetLangUserLevel() {
			for _, level := range lang.GetLevelList() {
				err = do(level.GetRewards())
				if err != nil {
					return
				}
			}
		}
	case mtype.FissionRewardGroupCountry:
		for _, country := range s.Req.GetRewards().GetCountry().GetCountryList() {
			err = do(country.GetRewards())
			if err != nil {
				return
			}
		}
	}

	return
}

func (s *Update) _updateHelp(cpnId int64) (err error) {
	m := s.GetDao().FissionCampaignTask
	helps, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpnId), m.IsDel.Eq(mtype.No)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var oldMap = make(map[int64]map[int8]*model.FissionCampaignTask)
	for _, v := range helps {
		rewardId := utils.FissionCampaignTaskMarkRewardOneRewardId(v.TaskMark)
		if rewardId <= 0 {
			continue
		}

		if _, ok := oldMap[rewardId]; !ok {
			oldMap[rewardId] = map[int8]*model.FissionCampaignTask{
				v.TaskType: v,
			}
		} else {
			oldMap[rewardId][v.TaskType] = v
		}
	}

	var delIds []int64
	var addTasks []*model.FissionCampaignTask
	var bfn = func(newList []*pb.UpdateReq_Reward) (err error) {
		for _, one := range newList {
			rewardId := one.GetId()
			oldHelps, ok := oldMap[rewardId]
			taskMark := utils.FissionCampaignTaskMarkRewardOneVal(rewardId)
			if !ok {
				if one.GetHelp() == mtype.Yes {
					addTasks = append(addTasks, withdefault.FissionCampaignTask(&model.FissionCampaignTask{
						CampaignID: cpnId,
						TaskType:   mtype.FissionCampaignTaskTypeInstall,
						TaskMark:   taskMark,
						PropMark:   mtype.FissionCampaignTaskPropMarkChance,
						Percent:    one.GetHelpPercent(),
					}))

					s.helpInstall = true
				}
				if one.GetOpen() == mtype.Yes {
					addTasks = append(addTasks, withdefault.FissionCampaignTask(&model.FissionCampaignTask{
						CampaignID:   cpnId,
						TaskType:     mtype.FissionCampaignTaskTypeOpen,
						TaskMark:     taskMark,
						PropMark:     mtype.FissionCampaignTaskPropMarkChance,
						Percent:      one.GetOpenPercent(),
						PercentLimit: one.GetOpenPercentLimit(),
					}))

					s.helpOpen = true
				}
				if one.GetClick() == mtype.Yes {
					addTasks = append(addTasks, withdefault.FissionCampaignTask(&model.FissionCampaignTask{
						CampaignID:   cpnId,
						TaskType:     mtype.FissionCampaignTaskTypeClick,
						TaskMark:     taskMark,
						PropMark:     mtype.FissionCampaignTaskPropMarkChance,
						Percent:      one.GetClickPercent(),
						PercentLimit: one.GetClickPercentLimit(),
					}))

					s.helpClick = true
				}
				if one.GetRegister() == mtype.Yes {
					addTasks = append(addTasks, withdefault.FissionCampaignTask(&model.FissionCampaignTask{
						CampaignID: cpnId,
						TaskType:   mtype.FissionCampaignTaskTypeRegister,
						TaskMark:   taskMark,
						PropMark:   mtype.FissionCampaignTaskPropMarkChance,
						Percent:    one.GetRegisterPercent(),
					}))

					s.helpRegister = true
				}

				continue
			}

			open, exist := oldHelps[mtype.FissionCampaignTaskTypeOpen]
			if exist && one.Open == mtype.No {
				delIds = append(delIds, open.ID)
			} else if !exist && one.Open == mtype.Yes {
				addTasks = append(addTasks, withdefault.FissionCampaignTask(&model.FissionCampaignTask{
					CampaignID:   cpnId,
					TaskType:     mtype.FissionCampaignTaskTypeOpen,
					TaskMark:     taskMark,
					PropMark:     mtype.FissionCampaignTaskPropMarkChance,
					Percent:      one.GetOpenPercent(),
					PercentLimit: one.GetOpenPercentLimit(),
				}))
				s.helpOpen = true
			} else if open != nil {
				_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(open.ID)).UpdateSimple(
					m.Percent.Value(one.GetOpenPercent()),
					m.PercentLimit.Value(one.GetOpenPercentLimit()),
				)
				if err != nil {
					err = s.BE().MysqlError(err)
					return
				}
				s.helpOpen = true
			}

			install, has := oldHelps[mtype.FissionCampaignTaskTypeInstall]
			if has && one.Help == mtype.No {
				delIds = append(delIds, install.ID)
			} else if !has && one.Help == mtype.Yes {
				addTasks = append(addTasks, withdefault.FissionCampaignTask(&model.FissionCampaignTask{
					CampaignID: cpnId,
					TaskType:   mtype.FissionCampaignTaskTypeInstall,
					TaskMark:   taskMark,
					PropMark:   mtype.FissionCampaignTaskPropMarkChance,
					Percent:    one.GetHelpPercent(),
				}))
				s.helpInstall = true
			} else if install != nil {
				_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(install.ID)).UpdateSimple(m.Percent.Value(one.GetHelpPercent()))
				if err != nil {
					err = s.BE().MysqlError(err)
					return
				}
				s.helpInstall = true
			}

			click, has := oldHelps[mtype.FissionCampaignTaskTypeClick]
			if has && one.Click == mtype.No {
				delIds = append(delIds, click.ID)
			} else if !has && one.Click == mtype.Yes {
				addTasks = append(addTasks, withdefault.FissionCampaignTask(&model.FissionCampaignTask{
					CampaignID:   cpnId,
					TaskType:     mtype.FissionCampaignTaskTypeClick,
					TaskMark:     taskMark,
					PropMark:     mtype.FissionCampaignTaskPropMarkChance,
					Percent:      one.GetClickPercent(),
					PercentLimit: one.GetClickPercentLimit(),
				}))
				s.helpClick = true
			} else if click != nil {
				_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(click.ID)).UpdateSimple(
					m.Percent.Value(one.GetClickPercent()),
					m.PercentLimit.Value(one.GetClickPercentLimit()),
				)
				if err != nil {
					err = s.BE().MysqlError(err)
					return
				}
				s.helpClick = true
			}

			register, has := oldHelps[mtype.FissionCampaignTaskTypeRegister]
			if has && one.Register == mtype.No {
				delIds = append(delIds, register.ID)
			} else if !has && one.Register == mtype.Yes {
				addTasks = append(addTasks, withdefault.FissionCampaignTask(&model.FissionCampaignTask{
					CampaignID: cpnId,
					TaskType:   mtype.FissionCampaignTaskTypeRegister,
					TaskMark:   taskMark,
					PropMark:   mtype.FissionCampaignTaskPropMarkChance,
					Percent:    one.GetRegisterPercent(),
				}))
				s.helpRegister = true
			} else if register != nil {
				_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(register.ID)).UpdateSimple(m.Percent.Value(one.GetRegisterPercent()))
				if err != nil {
					err = s.BE().MysqlError(err)
					return
				}
				s.helpRegister = true
			}
		}
		return
	}

	_ = s._switchRewardGroupDo(bfn)

	if len(addTasks) > 0 {
		err = m.WithContext(s.Ctx).Create(addTasks...)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	if len(delIds) > 0 {
		_, err = m.WithContext(s.Ctx).Where(m.ID.In(delIds...)).UpdateSimple(m.IsDel.Value(mtype.Yes))
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	return
}

func (s *Update) updateCash(cpn *model.FissionCampaign) (err error) {
	m := s.GetDao().FissionCampaignCash

	conf, err := cache.NewCampaignCash(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if conf == nil {
		return workerr.NotFound("not found cash conf")
	}

	var cash = s.Req.GetCash()

	var data = []field.AssignExpr{
		m.PriceNum.Value(cash.GetPriceNum()),
		m.LoopNum.Value(cash.GetLoopNum()),
	}

	if cpn.Status == mtype.FissionCampaignStatusWait { //待发布状态可以改所有数据
		data = append(data,
			m.ExpiredDay.Value(cash.GetExpiredDay()),
			m.Price.Value(cash.GetPrice()),
			m.Currency.Value(int8(cash.GetCurrency())),
		)
	}

	if conf.PriceNum != cash.GetPriceNum() {
		s.OL().User(s.Req.UserId, s.Req.Ip).UpdateRunningCashStock(conf.ID, conf.PriceNum, cash.GetPriceNum())

		data = append(data, m.Lack.Value(mtype.No))

		s.AddAfterRun(func() (err error) {
			stocks.NewCleaner(s.Ctx, cpn.ID).ClearCampaign()
			return
		})
	}

	_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(conf.ID)).UpdateSimple(data...)
	if err != nil {
		return s.BE().MysqlError(err)
	}

	s.AddAfterRun(func() (err error) {
		return cache.NewCampaignCash(s.Ctx).Clear(conf)
	})

	return
}

// 更新长图
func (s *Update) _updateLongImg(conf *model.FissionCampaignConfig) (err error) {
	if conf.HasLongImg == mtype.No && len(s.Req.GetLongImgs()) == 0 {
		return
	}

	m := s.GetDao().FissionCampaignLongImg
	if conf.HasLongImg == mtype.Yes && len(s.Req.GetLongImgs()) == 0 {
		_, err = m.WithContext(s.Ctx).Where(m.CampaignID.Eq(conf.CampaignID)).UpdateSimple(m.IsDel.Value(mtype.Yes))
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		return
	}

	list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(conf.CampaignID), m.IsDel.Eq(mtype.No), m.LangID.Eq(0)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var oldMap = make(map[int64]*model.FissionCampaignLongImg)
	for _, v := range list {
		oldMap[v.ID] = v
	}

	zoneM := s.GetDao().FissionCampaignLongImgZone
	var zone []*model.FissionCampaignLongImgZone
	var add = make([]*model.FissionCampaignLongImg, 0)
	var zoneDelIds []int64
	for _, v := range s.Req.GetLongImgs() {
		old, ok := oldMap[v.GetId()]
		if !ok {
			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(),
			})

			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(v.GetTargetType()),
						TargetID:   v.GetTargetId(),
					}))
				}
			}

			add = append(add, one)

			continue
		}

		_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(old.ID)).UpdateSimple(
			m.ClickType.Value(int8(v.GetClickType())),
			m.ImgURL.Value(v.GetImgUrl()),
			m.WebURL.Value(v.GetWebUrl()),
			m.AppParam.Value(v.GetAppParam()),
			m.PcParam.Value(v.GetPcParam()),
			m.TargetType.Value(int8(v.GetTargetType())),
			m.TargetID.Value(v.GetTargetId()),
		)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		delete(oldMap, old.ID)

		switch old.ClickType {
		case mtype.FissionCampaignLongImgClickTypeAll:
			if v.GetClickType() == mtype.FissionCampaignLongImgClickTypeZone {
				for _, hotZone := range v.GetHotZone() {
					zone = append(zone, withdefault.FissionCampaignLongImgZone(&model.FissionCampaignLongImgZone{
						CampaignID: conf.CampaignID,
						ImgID:      old.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(),
					}))
				}
			}
		case mtype.FissionCampaignLongImgClickTypeZone:
			if v.GetClickType() == mtype.FissionCampaignLongImgClickTypeAll {
				_, err = zoneM.WithContext(s.Ctx).Where(zoneM.ImgID.Eq(old.ID)).UpdateSimple(m.IsDel.Value(mtype.Yes))
				if err != nil {
					err = s.BE().MysqlError(err)
					return
				}
			} else if v.GetClickType() == mtype.FissionCampaignLongImgClickTypeZone {
				var zones []*model.FissionCampaignLongImgZone
				zones, err = zoneM.WithContext(s.Ctx).Where(zoneM.ImgID.Eq(old.ID), zoneM.IsDel.Eq(mtype.No)).Find()
				if err != nil {
					err = s.BE().MysqlError(err)
					return
				}

				var oldZoneMap = make(map[int64]*model.FissionCampaignLongImgZone, len(zones))
				for _, click := range zones {
					oldZoneMap[click.ID] = click
				}

				for _, hotZone := range v.GetHotZone() {
					oldZone, ok1 := oldZoneMap[hotZone.GetId()]
					if !ok1 {
						zone = append(zone, withdefault.FissionCampaignLongImgZone(&model.FissionCampaignLongImgZone{
							CampaignID: conf.CampaignID,
							ImgID:      old.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(),
						}))

						continue
					}

					_, err = zoneM.WithContext(s.Ctx).Where(zoneM.ID.Eq(oldZone.ID)).UpdateSimple(
						zoneM.WebURL.Value(hotZone.GetWebUrl()),
						zoneM.AppParam.Value(hotZone.GetAppParam()),
						zoneM.PcParam.Value(hotZone.GetPcParam()),
						zoneM.ClickX.Value(hotZone.GetClickX()),
						zoneM.ClickY.Value(hotZone.GetClickY()),
						zoneM.ClickH.Value(hotZone.GetClickH()),
						zoneM.ClickW.Value(hotZone.GetClickW()),
						zoneM.TargetType.Value(int8(hotZone.GetTargetType())),
						zoneM.TargetID.Value(hotZone.GetTargetId()),
					)
					if err != nil {
						err = s.BE().MysqlError(err)
						return
					}

					delete(oldZoneMap, oldZone.ID)
				}

				for id := range oldZoneMap {
					zoneDelIds = append(zoneDelIds, id)
				}
			}
		}
	}

	var imgDelIds []int64
	for id := range oldMap {
		imgDelIds = append(imgDelIds, id)
	}

	if len(add) > 0 {
		err = m.WithContext(s.Ctx).Create(add...)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	if len(zone) > 0 {
		err = zoneM.WithContext(s.Ctx).Create(zone...)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	if len(imgDelIds) > 0 {
		_, err = m.WithContext(s.Ctx).Where(m.ID.In(imgDelIds...)).UpdateSimple(m.IsDel.Value(mtype.Yes))
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	if len(zoneDelIds) > 0 {
		_, err = zoneM.WithContext(s.Ctx).Where(zoneM.ID.In(zoneDelIds...)).UpdateSimple(zoneM.IsDel.Value(mtype.Yes))
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	return
}

func (s *Update) _updateRunningReward(cpn *model.FissionCampaign) (err error) {
	m := s.GetDao().FissionCampaignReward
	var up = func(list []*pb.UpdateReq_Reward) error {
		var ids []int64
		for _, v := range list {
			ids = append(ids, v.Id)
			s.rewardAdd[v.GetId()] = v.GetOpenAdd()
			s.rewardTask[v.GetId()] = v.GetRewardTask()
		}

		rewards, err1 := m.WithContext(s.Ctx).Where(m.ID.In(ids...), m.CampaignID.Eq(cpn.ID)).Find()
		if err1 != nil {
			return s.BE().MysqlError(err1)
		}
		var oldMap = make(map[int64]*model.FissionCampaignReward, len(rewards))
		for _, v := range rewards {
			oldMap[v.ID] = v
		}

		var stockUpIds []int64
		var delStockId []int64
		for i, reward := range list {
			old, ok := oldMap[reward.GetId()]
			if !ok {
				continue
			}

			var upData []field.AssignExpr

			if old.Step != int32(i) {
				upData = append(upData, m.Sort.Value(int32(i)))
			}

			if old.Score != reward.GetScore() {
				upData = append(upData, m.Score.Value(reward.GetScore()))
			}

			if old.Odds != reward.GetOdds() {
				s.OL().User(s.Req.UserId, s.Req.Ip).UpdateRunningOdds(old.ID, old.Odds, reward.GetOdds())

				upData = append(upData, m.Odds.Value(reward.GetOdds()))
			}

			if old.Stock != reward.GetStock() {
				delStockId = append(delStockId, old.ID)
				s.OL().User(s.Req.UserId, s.Req.Ip).UpdateRunningStock(old.ID, old.Stock, reward.GetStock())

				if old.Stock < reward.GetStock() {
					stockUpIds = append(stockUpIds, old.ID)
				}

				upData = append(upData, m.Stock.Value(reward.GetStock()))
			}

			if old.InitPercent != reward.GetInitPercent() {
				s.OL().User(s.Req.UserId, s.Req.Ip).UpdateRunningInitPercent(old.ID, old.InitPercent, reward.GetInitPercent())

				upData = append(upData, m.InitPercent.Value(reward.GetInitPercent()))
			}

			if old.OpenAdd != int8(reward.GetOpenAdd().GetOpen()) {
				upData = append(upData, m.OpenAdd.Value(int8(reward.GetOpenAdd().GetOpen())))
			}

			if old.OpenTask != int8(reward.GetRewardTask().GetOpen()) {
				upData = append(upData, m.OpenTask.Value(int8(reward.GetRewardTask().GetOpen())))
			}

			hasRule := utils.Ternary[int8](reward.GetCampaignLimit() > 0, mtype.Yes, mtype.No)
			if old.HasRule != hasRule {
				upData = append(upData, m.HasRule.Value(hasRule))
			}

			if cpn.FissionID == consts.IdDice {
				cr, _ := jsonm.MarshalToString(mtype.CollectRule{
					Open:        reward.GetCollectRule().GetOpen(),
					InitCollect: reward.GetCollectRule().GetInitCollect(),
					SignDay:     reward.GetCollectRule().GetSignDay(),
					AddCollect:  reward.GetCollectRule().GetAddCollect(),
					ResetType:   reward.GetCollectRule().GetResetType(),
				})

				oldCr, newCr := utils.Md5Any(old.GetCollectRule()), utils.Md5String(cr)
				if oldCr != newCr {
					upData = append(upData, m.CollectRule.Value(cr))
				}
			}

			if len(upData) == 0 {
				continue
			}

			_, err1 = m.WithContext(s.Ctx).Where(m.ID.Eq(old.ID)).UpdateSimple(upData...)
			if err1 != nil {
				return s.BE().MysqlError(err1)
			}

			s.AddAfterRun(func() (err error) {
				_ = cmm.NewUserAppReward(s.Ctx).Delete(old.CampaignID, int8(s.Req.GetRewards().GetRewardGroup()), old.LangMark, old.LevelID, old.CountryMark)
				return
			})
		}

		s.AddAfterRun(func() (err error) {
			if len(delStockId) > 0 {
				stocks.NewCleaner(s.Ctx, delStockId...).ClearAllReward()
			}

			if verify.InArray[int64](cpn.FissionID, consts.IdGrow) && len(stockUpIds) > 0 {
				_ = app.NewVerControl(s.Ctx, ckey.FissionRewardLimitUpVer(cpn.ID), vercontrol.SetExpire(time.Hour)).Create(time.Now(), func() error {
					producer.NewCampaignNotice(s.Ctx).RewardLimitUp(types.RewardLimitUp{CampaignId: cpn.ID, RewardIds: stockUpIds})
					return nil
				})
			}

			return
		})

		return nil
	}

	err = up(s.Req.GetRewards().GetNormal())
	if err != nil {
		return
	}

	for _, v := range s.Req.GetRewards().GetUserLevel().GetLevelList() {
		err = up(v.GetRewards())
		if err != nil {
			return
		}
	}

	for _, v := range s.Req.GetRewards().GetLangs() {
		err = up(v.GetRewards())
		if err != nil {
			return
		}
	}

	for _, v := range s.Req.GetRewards().GetLangUserLevel() {
		for _, reward := range v.GetLevelList() {
			err = up(reward.GetRewards())
			if err != nil {
				return
			}
		}
	}

	for _, v := range s.Req.GetRewards().GetCountry().GetCountryList() {
		err = up(v.GetRewards())
		if err != nil {
			return
		}
	}

	err = s._updateRule(cpn.ID)
	if err != nil {
		return
	}

	if cpn.FissionID == consts.IdChop {
		err = s._updateHelp(cpn.ID)
		if err != nil {
			return
		}
	}

	return s._updateHelpTicket(cpn)
}

func (s *Update) _updateRule(cpnId int64) (err error) {
	m := s.GetDao().FissionCampaignRewardRule
	list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpnId)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var oldMap = make(map[int64]*model.FissionCampaignRewardRule, len(list))
	for _, v := range list {
		oldMap[v.RewardID] = v
	}

	olUser := s.OL().User(s.Req.GetUserId(), s.Req.GetIp())
	var delIds []int64
	var add []*model.FissionCampaignRewardRule
	var bfn = func(rewards []*pb.UpdateReq_Reward) (err error) {
		for _, v := range rewards {

			old, ok := oldMap[v.GetId()]
			if !ok {
				if v.GetCampaignLimit() > 0 {
					id := hashid.IdBigint()
					add = append(add, withdefault.FissionCampaignRewardRule(&model.FissionCampaignRewardRule{
						CampaignID:    cpnId,
						RewardID:      v.GetId(),
						CampaignLimit: v.GetCampaignLimit(),
					}))
					olUser.UpdateRunningRewardRule(id, 0, v.GetCampaignLimit())
				}
				continue
			}

			if v.GetCampaignLimit() > 0 {
				if v.GetCampaignLimit() != old.CampaignLimit {
					_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(old.ID)).UpdateSimple(m.CampaignLimit.Value(v.GetCampaignLimit()))
					if err != nil {
						err = s.BE().MysqlError(err)
						return
					}
					olUser.UpdateRunningRewardRule(v.GetId(), old.CampaignLimit, v.GetCampaignLimit())
				}
				continue
			}

			delIds = append(delIds, old.ID)
			olUser.UpdateRunningRewardRule(v.GetId(), old.CampaignLimit, 0)
		}
		return
	}

	err = s._switchRewardGroupDo(bfn)
	if err != nil {
		return
	}

	if len(add) > 0 {
		err = m.WithContext(s.Ctx).Create(add...)
		if err != nil {
			err = s.BE().MysqlError(err)
		}
	}

	if len(delIds) > 0 {
		_, err = m.WithContext(s.Ctx).Where(m.ID.In(delIds...)).Delete()
		if err != nil {
			err = s.BE().MysqlError(err)
		}
	}

	s.AddAfterRun(func() (err error) {
		_ = cache.NewCampaignRewardRule(s.Ctx).Clear(list...)
		return
	})

	return
}

func (s *Update) updateFlip(cpn *model.FissionCampaign) (err error) {
	var flip = s.Req.GetFlip()

	cc := cache.NewCampaignFlip(s.Ctx)
	conf, err := cc.FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if conf == nil {
		return workerr.NotFound("not found flip conf")
	}

	confM := s.GetDao().FissionCampaignFlip
	var data []field.AssignExpr
	defer func() {

		if err == nil && len(data) > 0 {
			_, err = confM.WithContext(s.Ctx).Where(confM.ID.Eq(conf.ID)).UpdateSimple(data...)
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}
		}

		_ = cc.Clear(conf)
	}()

	data = append(data,
		confM.CardImg.Value(flip.GetCardImg()),
		confM.DayChance.Value(flip.GetDayChance()),
	)

	if cpn.Status != mtype.FissionCampaignStatusWait { //不是待发布状态不能修改配置
		return
	}

	data = append(data,
		confM.InitChance.Value(flip.GetInitChance()),
	)

	//更新了初次抽奖机会，要处理玩家数据，预防有一些人没开始就进入游戏了，要同步一下数据
	if conf.InitChance != flip.GetInitChance() {
		fpwM := s.GetDao().FissionFlip
		_, err = fpwM.WithContext(s.Ctx).Where(fpwM.CampaignID.Eq(cpn.ID)).UpdateSimple(fpwM.Chance.Value(flip.GetInitChance()))
		if err != nil {
			return s.BE().MysqlError(err)
		}
	}

	return
}

// 助力规则
func (s *Update) _updateHelpTicket(cpn *model.FissionCampaign) (err error) {
	m := s.GetDao().FissionCampaignTicket

	ticket, err := m.WithContext(s.Ctx).Where(
		m.CampaignID.Eq(cpn.ID),
		m.Mark.Eq(mtype.FissionCampaignTicketRewardHelp),
	).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	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 {

		if ticket != nil && ticket.Open == mtype.Yes {
			_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(ticket.ID)).UpdateSimple(m.Open.Value(mtype.No))
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}
		}

		return
	}

	if ticket == nil {
		err = m.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
	}

	_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(ticket.ID)).UpdateSimple(
		m.Open.Value(mtype.Yes),
		m.HelpEvent.Value(strings.Join(helpEvent, ",")),
	)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}
	return
}

func (s *Update) updateKeep(cpn *model.FissionCampaign) (err error) {
	conf, err := cache.NewCampaignKeep(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if conf == nil {
		return workerr.NotFound("not found conf")
	}

	keep := s.Req.GetKeepDog()

	invite, _ := jsonm.MarshalToString(keep.GetInvite())
	talkText, _ := jsonm.MarshalToString(keep.GetTalkText())

	m := s.GetDao().FissionCampaignKeep
	_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(conf.ID)).UpdateSimple(
		m.Collect.Value(keep.GetCollect()),
		m.CollectSecond.Value(keep.GetCollectSecond()),
		m.OpenInvite.Value(int8(keep.GetOpenInvite())),
		m.Invite.Value(invite),
		m.InitGet.Value(keep.GetInitGet()),
		m.SecGet.Value(keep.GetSecGet()),
		m.FeedNum.Value(keep.GetFeedNum()),
		m.FeedCycle.Value(keep.GetFeedCycle()),
		m.TalkText.Value(talkText),
		m.MaxFeed.Value(keep.GetMaxFeed()),
		m.FeedGet.Value(keep.GetFeedGet()),
		m.FeedGetNum.Value(keep.GetFeedGetNum()),
		m.SecGetDayLimit.Value(keep.GetSecGetDayLimit()),
		m.MachineType.Value(int8(keep.GetMachineType())),
		m.OfflineGet.Value(keep.GetOfflineGet()),
		m.OfflineMin.Value(keep.GetOfflineMin()),
		m.OfflineLimit.Value(keep.GetOfflineLimit()),
	)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	s.AddAfterRun(func() (err error) {
		return cache.NewCampaignKeep(s.Ctx).Clear(conf)
	})

	inviteConf := conf.GetInvite()
	if inviteConf != nil && inviteConf.InviteMaxGet > 0 && inviteConf.InviteMaxGet < keep.GetInvite().GetInviteMaxGet() {
		keepM := s.GetDao().FissionKeep
		_, err = keepM.WithContext(s.Ctx).Where(
			keepM.CampaignID.Eq(cpn.ID),
			keepM.InviteLimit.Eq(mtype.Yes),
		).UpdateSimple(keepM.InviteLimit.Value(mtype.No))
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	// 把没有参与离线狗粮机的数据都参与一下
	if conf.MachineType == mtype.FissionCampaignKeepMachineTypeOnline && keep.GetMachineType() == mtype.FissionCampaignKeepMachineTypeOffline {
		keepM := s.GetDao().FissionKeep
		_, err = keepM.WithContext(s.Ctx).Where(
			keepM.CampaignID.Eq(cpn.ID),
			keepM.RewardID.Gt(0),
			keepM.RecordID.Eq(0),
			keepM.ReceiveOffline.Eq(0),
		).UpdateSimple(keepM.ReceiveOffline.Value(time.Now().Unix()))
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	stepM := s.GetDao().FissionCampaignKeepStep
	oldSteps, err := stepM.WithContext(s.Ctx).Where(stepM.CampaignID.Eq(cpn.ID)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var rewardIds []int64
	var oldMap = make(map[int32]*model.FissionCampaignKeepStep)
	for _, v := range oldSteps {
		oldMap[v.Step] = v
		if v.RewardID > 0 {
			rewardIds = append(rewardIds, v.RewardID)
		}
	}

	var rewardMap = make(map[int64]*model.FissionCampaignReward, len(rewardIds))
	if len(rewardIds) > 0 {
		rewardM := s.GetDao().FissionCampaignReward
		var rewards []*model.FissionCampaignReward
		rewards, err = rewardM.WithContext(s.Ctx).Where(rewardM.ID.In(rewardIds...)).Find()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		for _, v := range rewards {
			rewardMap[v.ID] = v
		}
	}

	var delRewardIds []int64
	var steps []*model.FissionCampaignKeepStep
	for _, v := range keep.GetSteps() {
		old, ok := oldMap[v.GetStep()]
		if !ok {
			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)
			continue
		}

		var up = []field.AssignExpr{
			stepM.Percent.Value(v.GetPercent()),
			stepM.RewardType.Value(int8(v.GetRewardType())),
			stepM.RewardNum.Value(v.GetRewardNum()),
			stepM.IsDel.Value(mtype.No),
		}
		if old.RewardType == mtype.FissionCampaignKeepStepRewardTypeProp && 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,
			})

			up = append(up, stepM.RewardID.Value(rewardId))
		} else if old.RewardType == mtype.FissionCampaignKeepStepRewardTypeReward && v.GetRewardType() == mtype.FissionCampaignKeepStepRewardTypeProp {
			delRewardIds = append(delRewardIds, old.RewardID)
			up = append(up, stepM.RewardID.Value(0))
		} else if old.RewardType == mtype.FissionCampaignKeepStepRewardTypeReward && v.GetRewardType() == mtype.FissionCampaignKeepStepRewardTypeReward {
			if rewardMap[old.RewardID].RewardID != v.GetReward().GetRewardId() {
				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,
				})

				delRewardIds = append(delRewardIds, old.RewardID)
				up = append(up, stepM.RewardID.Value(rewardId))
			} else {
				rewardM := s.GetDao().FissionCampaignReward
				_, err = rewardM.WithContext(s.Ctx).Where(rewardM.ID.Eq(old.RewardID)).UpdateSimple(
					rewardM.Stock.Value(v.GetReward().GetStock()),
					rewardM.Step.Value(v.GetStep()),
				)
				if err != nil {
					err = s.BE().MysqlError(err)
					return
				}

				stocks.NewCleaner(s.Ctx, old.RewardID).ClearAllReward()
			}

		}

		_, err = stepM.WithContext(s.Ctx).Where(stepM.ID.Eq(old.ID)).UpdateSimple(up...)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		delete(oldMap, v.GetStep())
	}

	var delIds []int64
	for _, v := range oldMap {
		delIds = append(delIds, v.ID)
	}

	if len(delIds) > 0 {
		_, err = stepM.WithContext(s.Ctx).Where(stepM.ID.In(delIds...)).UpdateSimple(stepM.IsDel.Value(mtype.Yes))
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	if len(steps) > 0 {
		err = stepM.WithContext(s.Ctx).Create(steps...)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	if len(delRewardIds) > 0 {
		rewardM := s.GetDao().FissionCampaignReward
		_, err = rewardM.WithContext(s.Ctx).Where(rewardM.ID.In(delIds...)).UpdateSimple(rewardM.IsDel.Value(mtype.Yes))
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	return
}

func (s *Update) updatePush(cpn *model.FissionCampaign) (err error) {
	m := s.GetDao().FissionCampaignPush
	list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var pushMap = make(map[string]*model.FissionCampaignPush, len(list))
	for _, v := range list {
		pushMap[v.Mark] = v
	}

	var delKey []string
	var add []*model.FissionCampaignPush

	if s.Req.GetPush().GetTaskReset().GetOpen() == mtype.Yes {
		cond, _ := jsonm.ToSliceString(s.Req.GetPush().GetTaskReset().GetPushCond())

		if push, ok := pushMap[mtype.FissionCampaignPushMarkTaskReset]; ok {
			_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(push.ID)).UpdateSimple(m.Cond.Value(cond), m.Open.Value(mtype.Yes))
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}
			delKey = append(delKey, ckey.FissionRewardPushOpenOnce(push.CampaignID, push.Mark))
		} else {
			add = append(add, &model.FissionCampaignPush{
				CampaignID: cpn.ID,
				Mark:       mtype.FissionCampaignPushMarkTaskReset,
				Cond:       cond,
				Open:       mtype.Yes,
			})
			delKey = append(delKey, ckey.FissionRewardPushOpenOnce(cpn.ID, mtype.FissionCampaignPushMarkTaskReset))
		}
	} else {
		if push, ok := pushMap[mtype.FissionCampaignPushMarkTaskReset]; ok && push.Open == mtype.Yes {
			_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(push.ID)).UpdateSimple(m.Open.Value(mtype.No))
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}
			delKey = append(delKey, ckey.FissionRewardPushOpenOnce(push.CampaignID, push.Mark))
		}

	}

	if s.Req.GetPush().GetActive().GetOpen() == mtype.Yes {
		cond, _ := jsonm.ToSliceString(s.Req.GetPush().GetActive().GetPushCond())
		if push, ok := pushMap[mtype.FissionCampaignPushMarkActive]; ok {
			_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(push.ID)).UpdateSimple(m.Cond.Value(cond), m.Open.Value(mtype.Yes))
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}
			delKey = append(delKey, ckey.FissionRewardPushOpenOnce(push.CampaignID, push.Mark))
		} else {
			add = append(add, withdefault.FissionCampaignPush(&model.FissionCampaignPush{
				CampaignID: cpn.ID,
				Mark:       mtype.FissionCampaignPushMarkActive,
				Cond:       cond,
				Open:       mtype.Yes,
			}))
			delKey = append(delKey, ckey.FissionRewardPushOpenOnce(cpn.ID, mtype.FissionCampaignPushMarkActive))
		}
	} else {
		if push, ok := pushMap[mtype.FissionCampaignPushMarkActive]; ok && push.Open == mtype.Yes {
			_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(push.ID)).UpdateSimple(m.Open.Value(mtype.No))
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}
			delKey = append(delKey, ckey.FissionRewardPushOpenOnce(push.CampaignID, push.Mark))
		}
	}

	if s.Req.GetPush().GetOffline().GetOpen() == mtype.Yes {
		cond, _ := jsonm.ToSliceString(s.Req.GetPush().GetOffline().GetPushCond())
		if push, ok := pushMap[mtype.FissionCampaignPushMarkOffline]; ok {
			_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(push.ID)).UpdateSimple(m.Cond.Value(cond), m.Open.Value(mtype.Yes))
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}
			delKey = append(delKey, ckey.FissionRewardPushOpenOnce(push.CampaignID, push.Mark))
		} else {
			add = append(add, &model.FissionCampaignPush{
				CampaignID: cpn.ID,
				Mark:       mtype.FissionCampaignPushMarkOffline,
				Cond:       cond,
				Open:       mtype.Yes,
			})
			delKey = append(delKey, ckey.FissionRewardPushOpenOnce(cpn.ID, mtype.FissionCampaignPushMarkOffline))
		}
	} else {
		if push, ok := pushMap[mtype.FissionCampaignPushMarkOffline]; ok && push.Open == mtype.Yes {
			_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(push.ID)).UpdateSimple(m.Open.Value(mtype.No))
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}
			delKey = append(delKey, ckey.FissionRewardPushOpenOnce(push.CampaignID, push.Mark))
		}
	}

	if s.Req.GetPush().GetVisit().GetOpen() == mtype.Yes {
		if push, ok := pushMap[mtype.FissionCampaignPushMarkVisit]; ok {
			_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(push.ID)).UpdateSimple(m.Open.Value(mtype.Yes))
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}
			delKey = append(delKey, ckey.FissionRewardPushOpenOnce(push.CampaignID, push.Mark))
		} else {
			add = append(add, &model.FissionCampaignPush{
				CampaignID: cpn.ID,
				Mark:       mtype.FissionCampaignPushMarkVisit,
				Cond:       "{}",
				Open:       mtype.Yes,
			})
			delKey = append(delKey, ckey.FissionRewardPushOpenOnce(cpn.ID, mtype.FissionCampaignPushMarkVisit))
		}
	} else {
		if push, ok := pushMap[mtype.FissionCampaignPushMarkVisit]; ok && push.Open == mtype.Yes {
			_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(push.ID)).UpdateSimple(m.Open.Value(mtype.No))
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}
			delKey = append(delKey, ckey.FissionRewardPushOpenOnce(push.CampaignID, push.Mark))
		}
	}

	if len(add) > 0 {
		err = s.GetDao().FissionCampaignPush.WithContext(s.Ctx).Create(add...)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	if len(delKey) > 0 {
		app.Redis.Cache.Del(s.Ctx, delKey...)
	}

	return
}

func (s *Update) syncLinkTemp(cpn *model.FissionCampaign) (err error) {
	if !s.changeTemp {
		return
	}

	_, err = app.NewDeepLinkLink().UpdateCampaignLinkOne(s.Ctx, &dlinkpb.UpdateCampaignLinkOneReq{
		ProjectId:   cpn.ProjectID,
		CampaignId:  cpn.ID,
		TemplateKey: s.Req.GetConfig().GetLinkTempId(),
	})
	if err != nil {
		return
	}

	return
}

// 其他形式的奖品追加
func (s *Update) _otherAppendReward(rewards ...*model.FissionCampaignReward) {
	for _, reward := range rewards {
		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, reward)
	}
}

func (s *Update) updateChild(cpn *model.FissionCampaign) (err error) {
	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
	}

	childM := s.GetDao().FissionCampaignChild
	childs, err := childM.WithContext(s.Ctx).Where(childM.CampaignID.Eq(cpn.ID)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var oldMap = make(map[int64]int64, len(childs))
	for _, v := range childs {
		oldMap[v.ChildID] = v.ID
	}

	cm := cmm.NewCMM(s.Ctx, s.GetDao())
	var add []*model.FissionCampaignChild
	for _, v := range list {
		if _, ok := oldMap[v.ID]; !ok {
			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
			}

			continue
		}

		delete(oldMap, v.ID)
	}

	var delIds []int64
	for _, id := range oldMap {
		delIds = append(delIds, id)
	}

	if len(delIds) > 0 {
		_, err = childM.WithContext(s.Ctx).Where(childM.ID.In(delIds...)).Delete()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	if len(add) > 0 {
		err = childM.WithContext(s.Ctx).Create(add...)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	s.AddAfterRun(func() (err error) {
		return cache.NewCampaignChild(s.Ctx).Clear(childs...)
	})

	return
}

// 更新活动样式
func (s *Update) _updateStyle(cpn *model.FissionCampaign) (err error) {
	cc := cache.NewCampaignStyle(s.Ctx)
	style, err := cc.FindByCampaignId(cpn.ID)
	if err != nil {
		return s.BE().CacheError(err)
	}

	cf := s.Req.GetConfig()
	m := s.GetDao().FissionCampaignStyle

	var data = []field.AssignExpr{
		m.RuleTextColor.Value(cf.GetRuleTextColor()),
		m.RuleBgColor.Value(cf.GetRuleBgColor()),
		m.ShareText.Value(cf.GetShareText()),
		m.ShareImg.Value(cf.GetShareImg()),
		m.RankBackgroundColor.Value(cf.GetRankBackgroundColor()),
		m.RankTextColor.Value(cf.GetRankTextColor()),
		m.DownloadImg.Value(cf.GetDownloadPageImage()),
		m.WechatImg.Value(cf.GetWechatPageImage()),
		m.MainImg.Value(cf.GetImageMain()),
		m.BgImg.Value(cf.GetImagePreview()),
		m.LinkBtnTextColor.Value(cf.GetLinkBtnTextColor()),
		m.LinkBtnBgColor.Value(cf.GetLinkBtnBgColor()),
		m.LinkTextColor.Value(cf.GetLinkTextColor()),
		m.PageTitle.Value(cf.GetPageTitle()),
		m.WebImg.Value(cf.GetWebBgImg()),
		m.IconType.Value(int8(cf.GetIconType())),
		m.IconBgColor.Value(cf.GetIconBgColor()),
		m.DlBannerImg.Value(cf.GetDlBannerImg()),
		m.DlBannerAppLogo.Value(cf.GetDlBannerAppLogo()),
		m.DlBannerAppName.Value(cf.GetDlBannerAppName()),
		m.DlBannerAppBtn.Value(cf.GetDlBannerAppBtn()),
		m.DlBannerPosition.Value(int8(cf.GetDlBannerPosition())),
		m.TopicColor.Value(cf.GetTopicColor()),
		m.PlayRule.Value(cf.GetPlayRule()),
		m.PcBg.Value(cf.GetPcBg()),
		m.IconTextColor.Value(cf.GetIconTextColor()),
		m.RuleImg.Value(cf.GetRuleImg()),
	}

	share, _ := jsonm.MarshalToString(cf.GetShare())
	data = append(data, m.Share.Value(share))

	iconOpen, _ := jsonm.MarshalToString(cf.GetIconOpen())
	data = append(data, m.IconOpen.Value(iconOpen))

	switch cpn.FissionID {
	case consts.IdPrizeWheel:
		custom := s.Req.GetWheelStyle()
		customStyle, _ := jsonm.ToObjString(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(),
		})
		data = append(data, m.CustomStyle.Value(customStyle))
	case consts.IdLuckyGrid:
		custom := s.Req.GetGridStyle()
		customStyle, _ := jsonm.ToObjString(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(),
		})

		data = append(data, m.CustomStyle.Value(customStyle))
	case consts.IdFlip:
		custom := s.Req.GetFlipStyle()
		customStyle, _ := jsonm.ToObjString(mtype.FlipStyle{
			TopicMark:   custom.GetTopicMark(),
			MainImg:     custom.GetMainImg(),
			BgColor:     custom.GetBgColor(),
			ButtonColor: custom.GetButtonColor(),
			PlayImg:     custom.GetPlayImg(),
			CardImg:     custom.GetCardImg(),
		})

		data = append(data, m.CustomStyle.Value(customStyle))
	case consts.IdGashapon:
		custom := s.Req.GetGashaponStyle()
		customStyle, _ := jsonm.ToObjString(mtype.GashaponStyle{
			TopicMark:  custom.GetTopicMark(),
			MainImg:    custom.GetMainImg(),
			BgColor:    custom.GetBgColor(),
			MachineImg: custom.GetMachineImg(),
			PlayImg:    custom.GetPlayImg(),
			EggType:    custom.GetEggType(),
			EggImgs:    custom.GetEggImgs(),
		})

		data = append(data, m.CustomStyle.Value(customStyle))
	}

	_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(style.ID)).UpdateSimple(data...)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	s.AddAfterRun(func() (err error) {
		_ = cc.Clear(style)
		return
	})

	return
}

func (s *Update) updateGold(cpn *model.FissionCampaign) (err error) {
	m := s.GetDao().FissionCampaignGold

	conf, err := cache.NewCampaignGold(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if conf == nil {
		return workerr.NotFound("not found cash conf")
	}

	var gold = s.Req.GetGold()

	var data = []field.AssignExpr{
		m.PriceNum.Value(gold.GetPriceNum()),
		m.GoldNum.Value(gold.GetGoldNum()),
		m.ExpiredDay.Value(gold.GetExpiredDay()),
		m.Price.Value(gold.GetPrice()),
		m.Currency.Value(int8(gold.GetCurrency())),
	}

	if conf.PriceNum != gold.GetPriceNum() {
		s.OL().User(s.Req.UserId, s.Req.Ip).UpdateRunningGoldStock(conf.ID, conf.PriceNum, gold.GetPriceNum())

		data = append(data, m.Lack.Value(mtype.No))

		s.AddAfterRun(func() (err error) {

			stocks.NewCleaner(s.Ctx, cpn.ID).ClearCampaign()

			return
		})
	}

	_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(conf.ID)).UpdateSimple(data...)
	if err != nil {
		return s.BE().MysqlError(err)
	}

	s.AddAfterRun(func() (err error) {
		return cache.NewCampaignGold(s.Ctx).Clear(conf)
	})

	return
}

func (s *Update) updateCoin(cpn *model.FissionCampaign) (err error) {
	m := s.GetDao().FissionCampaignCoin

	conf, err := cache.NewCampaignCoin(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if conf == nil {
		return workerr.NotFound("not found cash conf")
	}

	var coin = s.Req.GetCoin()
	lackBtn, _ := jsonm.ToSliceString(coin.GetLackBtn())
	var data = []field.AssignExpr{
		m.CoinImg.Value(coin.GetCoinImg()),
		m.OpenDays.Value(coin.GetOpenDays()),
		m.OpenLimit.Value(coin.GetOpenLimit()),
		m.InitCoin.Value(coin.GetInitCoin()),
		m.InitUse.Value(coin.GetInitUse()),
		m.UseCoin.Value(coin.GetUseCoin()),
		m.UseLimit.Value(coin.GetUseLimit()),
		m.URLID.Value(coin.GetUrlId()),
		m.LackBtn.Value(lackBtn),
		m.CustomBtnText.Value(coin.GetCustomBtnText()),
		m.CustomWebURL.Value(coin.GetCustomWebUrl()),
		m.CustomExtraParam.Value(coin.GetCustomExtraParam()),
		m.CustomPcParam.Value(coin.GetCustomPcParam()),
	}

	_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(conf.ID)).UpdateSimple(data...)
	if err != nil {
		return s.BE().MysqlError(err)
	}

	s.AddAfterRun(func() (err error) {
		return cache.NewCampaignCoin(s.Ctx).Clear(conf)
	})

	// 创建自定义按钮
	if verify.InArray[int32](mtype.FissionCampaignCoinLackBtnCustom, coin.GetLackBtn()...) && conf.CustomBtnText != coin.GetCustomBtnText() {
		var customBtn *model.FissionCustomBtn
		customBtn, err = cache.NewFissionCustomBtn(s.Ctx).FindByUniq(cpn.ID, coin.GetCustomBtnText())
		if err != nil {
			return s.BE().CacheError(err)
		}

		if customBtn == nil {
			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)
			}
		}

	}

	if coin.GetOpenDays() == conf.OpenDays &&
		coin.GetInitCoin() == conf.InitCoin &&
		coin.GetInitUse() == conf.InitUse &&
		s.Req.GetStartTime() == cpn.TStart {
		return
	}

	sceneM := s.GetDao().FissionCoinScene

	// 如果活动没开始，改了开始时间，要重制场次
	if cpn.Status == mtype.FissionCampaignStatusWait && s.Req.GetStartTime() != cpn.TStart {
		_, err = sceneM.WithContext(s.Ctx).Where(sceneM.CampaignID.Eq(cpn.ID)).Delete()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		start := timez.GMT(s.Req.GetStartTime(), s.Req.GetTOffset())
		_, dayStart, _ := timez.GMTStartAndEndTs(cpn.TOffset, start)
		_, 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)
		}

		return
	}

	// 修改一些场次信息
	diffDay := coin.GetOpenDays() - conf.OpenDays
	scenes, err := sceneM.WithContext(s.Ctx).Where(sceneM.CampaignID.Eq(cpn.ID), sceneM.OpenTime.Gt(time.Now().Unix())).Find()
	if err != nil {
		return
	}

	for _, scene := range scenes {
		var up []field.AssignExpr

		if diffDay != 0 {
			newOpenTime := scene.OpenTime + int64(diffDay*consts.DaySec)

			// 如果开奖大于1天，才可以改时间
			if newOpenTime-scene.OpenTime > consts.DaySec {
				up = append(up, sceneM.OpenTime.Value(newOpenTime), sceneM.RewardTime.Value(newOpenTime+consts.DaySec))
			}
		}

		if coin.GetInitCoin() != conf.InitCoin {
			up = append(up, sceneM.InitCoin.Value(coin.GetInitCoin()))
		}

		if coin.GetInitUse() != conf.InitUse {
			up = append(up, sceneM.InitUse.Value(coin.GetInitUse()))
		}

		_, err = sceneM.WithContext(s.Ctx).Where(sceneM.ID.Eq(scene.ID)).UpdateSimple(up...)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

	}

	return
}

func (s *Update) updateVs(cpn *model.FissionCampaign) (err error) {
	conf, err := cache.NewCampaignVs(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if conf == nil {
		return workerr.NotFound("not found vs conf")
	}

	vs := s.Req.GetVs()

	m := s.GetDao().FissionCampaignV
	var up []field.AssignExpr

	if conf.EachLimitNum != vs.GetEachLimitNum() {
		up = append(up, m.EachLimitNum.Value(vs.GetEachLimitNum()))
	}

	if conf.OpenPoint != int8(vs.GetOpenPoint()) {
		up = append(up, m.OpenPoint.Value(int8(vs.GetOpenPoint())))
	}

	if conf.InitChance != vs.GetInitChance() {
		up = append(up, m.InitChance.Value(vs.GetInitChance()))
	}

	if conf.PointsNum != vs.GetPointsNum() {
		up = append(up, m.PointsNum.Value(vs.GetPointsNum()))
	}

	if conf.MallOpen != int8(vs.GetMallOpen()) {
		up = append(up, m.MallOpen.Value(int8(vs.GetMallOpen())))
	}

	if conf.MallID != vs.GetMallId() {
		up = append(up, m.MallID.Value(vs.GetMallId()))

		var mallRelate *malls.Relate
		mallRelate, err = malls.NewRelate(s.Ctx, cpn.ID, cpn.TableName(), logic.WithDao(s.GetDao()))
		if err != nil {
			return
		}

		err = mallRelate.Related(mtype.RedeemMallRelateSourceCampaign, vs.GetMallId())
		if err != nil {
			return
		}
	}

	if conf.VsTz != vs.GetVsTz() {
		up = append(up, m.VsTz.Value(vs.GetVsTz()))
	}

	if conf.ClaimType != int8(vs.GetClaimType()) {
		up = append(up, m.ClaimType.Value(int8(vs.GetClaimType())))
	}

	if conf.IconMall != vs.GetIconMall() {
		up = append(up, m.IconMall.Value(vs.GetIconMall()))
	}

	if conf.IconReward != vs.GetIconReward() {
		up = append(up, m.IconReward.Value(vs.GetIconReward()))
	}

	if conf.IconSchedule != vs.GetIconSchedule() {
		up = append(up, m.IconSchedule.Value(vs.GetIconSchedule()))
	}

	if len(up) > 0 {
		_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(conf.ID)).UpdateSimple(up...)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		s.AddAfterRun(func() (err error) {
			return cache.NewCampaignVs(s.Ctx).Clear(conf)
		})
	}

	scheduleM := s.GetDao().FissionCampaignVsSchedule
	oldSchedule, err := scheduleM.WithContext(s.Ctx).Where(scheduleM.CampaignID.Eq(cpn.ID)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var oldScheduleMap = make(map[int64]*model.FissionCampaignVsSchedule, len(oldSchedule))
	for _, schedule := range oldSchedule {
		oldScheduleMap[schedule.ID] = schedule
	}

	rewardM := s.GetDao().FissionCampaignReward
	oldRewards, err := rewardM.WithContext(s.Ctx).Where(
		rewardM.CampaignID.Eq(cpn.ID),
		rewardM.RewardType.Eq(mtype.FissionCampaignRewardTypeApp),
		rewardM.IsDel.Eq(mtype.No),
	).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var oldRewardMap = make(map[int64]*model.FissionCampaignReward, len(oldRewards))
	for _, reward := range oldRewards {
		oldRewardMap[reward.ID] = reward
	}

	teamM := s.GetDao().FissionCampaignVsTeam
	oldTeams, err := teamM.WithContext(s.Ctx).Where(teamM.CampaignID.Eq(cpn.ID)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var oldTeamMap = make(map[int64]*model.FissionCampaignVsTeam, len(oldTeams))
	for _, team := range oldTeams {
		oldTeamMap[team.ID] = team
	}

	var emptyId int64 = -1
	var add []*model.FissionCampaignVsSchedule
	var teams []*model.FissionCampaignVsTeam
	for i, schedule := range vs.GetSchedules() {

		for _, pk := range schedule.GetPkTeams() {
			voteStart, _ := timez.YmdHiParse(pk.GetVoteStart(), vs.GetVsTz())
			voteEnd, _ := timez.YmdHiParse(pk.GetVoteEnd(), vs.GetVsTz())
			vsAt, _ := timez.YmdHiParse(pk.GetVsDate(), vs.GetVsTz())

			old, ok := oldScheduleMap[pk.GetId()]
			if !ok {

				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(),
				})

				add = append(add, withdefault.FissionCampaignVsSchedule(&model.FissionCampaignVsSchedule{
					CampaignID: cpn.ID,
					VsIdx:      int32(i),
					RewardID:   rewardId,
					VsTeamIds:  "",
					VsImg:      pk.GetVsImg(),
					VoteStart:  voteStart.Unix(),
					VoteEnd:    voteEnd.Unix(),
					VsAt:       vsAt.Unix(),
					Desc:       pk.GetDesc(),
					OpenOdds:   int8(pk.GetOpenOdds()),
					OddsLeft:   pk.GetOddsLeft(),
					OddsRight:  pk.GetOddsRight(),
					OddsDraw:   pk.GetOddsDraw(),
				}, vsTeamIds, pk.GetOtherVote()))

				continue
			}

			delete(oldScheduleMap, pk.GetId())

			var vsTeamIds []int64
			for _, team := range pk.GetTeams() {
				oldTeam, ok1 := oldTeamMap[team.GetId()]
				if !ok1 {

					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)
					continue
				}

				delete(oldTeamMap, team.GetId())

				var upTeam []field.AssignExpr

				if oldTeam.Name != team.GetName() {
					upTeam = append(upTeam, teamM.Name.Value(team.GetName()))
				}

				if oldTeam.LogoImg != team.GetLogoImg() {
					upTeam = append(upTeam, teamM.LogoImg.Value(team.GetLogoImg()))
				}

				vsTeamIds = append(vsTeamIds, oldTeam.ID)

				if len(upTeam) > 0 {
					_, err = teamM.WithContext(s.Ctx).Where(teamM.ID.Eq(oldTeam.ID)).UpdateSimple(upTeam...)
					if err != nil {
						err = s.BE().MysqlError(err)
						return
					}
				}

			}

			var upSchedule []field.AssignExpr

			if old.VsIdx != int32(i) {
				upSchedule = append(upSchedule, scheduleM.VsIdx.Value(int32(i)))
			}

			if !verify.AllInArray[int64](vsTeamIds, old.GetVsTeamIds()) {
				str, _ := jsonm.ToSliceString(vsTeamIds)
				upSchedule = append(upSchedule, scheduleM.VsTeamIds.Value(str))
			}

			if !verify.AllInArray[string](pk.GetOtherVote(), old.GetOtherVote()) {
				str, _ := jsonm.ToSliceString(pk.GetOtherVote())
				upSchedule = append(upSchedule, scheduleM.OtherVote.Value(str))
			}

			if old.VoteStart != voteStart.Unix() {
				upSchedule = append(upSchedule, scheduleM.VoteStart.Value(voteStart.Unix()))
			}

			if old.VoteEnd != voteEnd.Unix() {
				upSchedule = append(upSchedule, scheduleM.VoteEnd.Value(voteEnd.Unix()))
			}

			if old.VsAt != vsAt.Unix() {
				upSchedule = append(upSchedule, scheduleM.VsAt.Value(vsAt.Unix()))
			}

			if old.VsImg != pk.GetVsImg() {
				upSchedule = append(upSchedule, scheduleM.VsImg.Value(pk.GetVsImg()))
			}

			if old.Desc != pk.GetDesc() {
				upSchedule = append(upSchedule, scheduleM.Desc.Value(pk.GetDesc()))
			}

			if old.OpenOdds != int8(pk.GetOpenOdds()) {
				upSchedule = append(upSchedule, scheduleM.OpenOdds.Value(int8(pk.GetOpenOdds())))
			}

			if old.OddsLeft != pk.GetOddsLeft() {
				upSchedule = append(upSchedule, scheduleM.OddsLeft.Value(pk.GetOddsLeft()))
			}

			if old.OddsRight != pk.GetOddsRight() {
				upSchedule = append(upSchedule, scheduleM.OddsRight.Value(pk.GetOddsRight()))
			}

			if old.OddsDraw != pk.GetOddsDraw() {
				upSchedule = append(upSchedule, scheduleM.OddsDraw.Value(pk.GetOddsDraw()))
			}

			oldReward, ok1 := oldRewardMap[old.RewardID]
			if !ok1 || oldReward.PropMark != pk.GetPropMark() {
				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(),
				})

				upSchedule = append(upSchedule, scheduleM.RewardID.Value(rewardId))
			} else {
				delete(oldRewardMap, old.RewardID)

				var upReward []field.AssignExpr
				switch pk.GetPropMark() {
				case mtype.FissionCampaignRewardPropMarkPoint:
					if oldReward.RewardNum != pk.GetPropNum() {
						upReward = append(upReward, rewardM.RewardNum.Value(pk.GetPropNum()))
					}

					if oldReward.ExpiredDay != pk.GetExpiredDay() {
						upReward = append(upReward, rewardM.ExpiredDay.Value(pk.GetExpiredDay()))
					}

				case mtype.FissionCampaignRewardPropMarkReward:
					if oldReward.RewardID != pk.GetRewardId() {
						upReward = append(upReward, rewardM.RewardID.Value(pk.GetRewardId()))
					}
				}

				if len(upReward) > 0 {
					_, err = rewardM.WithContext(s.Ctx).Where(rewardM.ID.Eq(oldReward.ID)).UpdateSimple(upReward...)
					if err != nil {
						err = s.BE().MysqlError(err)
						return
					}
				}

			}

			if len(upSchedule) > 0 {
				_, err = scheduleM.WithContext(s.Ctx).Where(scheduleM.ID.Eq(old.ID)).UpdateSimple(upSchedule...)
				if err != nil {
					err = s.BE().MysqlError(err)
					return
				}
			}

		}
	}

	if len(add) > 0 {
		if err = scheduleM.WithContext(s.Ctx).Create(add...); err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	if len(teams) > 0 {
		if err = teamM.WithContext(s.Ctx).Create(teams...); err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	var delSchedule []int64
	for id := range oldScheduleMap {
		delSchedule = append(delSchedule, id)
	}

	if len(delSchedule) > 0 {
		_, err = scheduleM.WithContext(s.Ctx).Where(scheduleM.ID.In(delSchedule...)).Delete()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	var delReward []int64
	for id := range oldRewardMap {
		delReward = append(delReward, id)
	}

	if len(delReward) > 0 {
		_, err = rewardM.WithContext(s.Ctx).Where(rewardM.ID.In(delReward...)).UpdateSimple(rewardM.IsDel.Value(mtype.Yes))
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	var delTeam []int64
	for id := range oldTeamMap {
		delTeam = append(delTeam, id)
	}

	if len(delTeam) > 0 {
		_, err = teamM.WithContext(s.Ctx).Where(teamM.ID.In(delTeam...)).Delete()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	return
}

func (s *Update) _updatePointsUse(cpn *model.FissionCampaign) (err error) {
	req := s.Req.GetPointsUse()
	if req.GetOpen() != mtype.Yes {
		return
	}

	pointUse, err := cache.NewCampaignPointsUse(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if pointUse == nil {
		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
	}

	m := s.GetDao().FissionCampaignPointsUse
	var up []field.AssignExpr
	if pointUse.Icon != req.GetIcon() {
		up = append(up, m.Icon.Value(req.GetIcon()))
	}

	if pointUse.URLID != req.GetUrlId() {
		up = append(up, m.URLID.Value(req.GetUrlId()))
	}

	if pointUse.UseNum != req.GetUseNum() {
		up = append(up, m.UseNum.Value(req.GetUseNum()))
	}

	if pointUse.DayLimit != req.GetDayLimit() {
		up = append(up, m.DayLimit.Value(req.GetDayLimit()))
	}

	if pointUse.TotalLimit != req.GetTotalLimit() {
		up = append(up, m.TotalLimit.Value(req.GetTotalLimit()))
	}

	if len(up) == 0 {
		return
	}

	_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(pointUse.ID)).UpdateSimple(up...)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	s.AddAfterRun(func() (err error) {
		return cache.NewCampaignPointsUse(s.Ctx).Clear(pointUse)
	})

	return
}

func (s *Update) _updateChat(cpn *model.FissionCampaign) (err error) {
	req := s.Req.GetChat()
	if req.GetOpen() != mtype.Yes {
		return
	}

	chat, err := cache.NewCampaignChat(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if chat == nil {
		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
	}

	m := s.GetDao().FissionCampaignChat
	var up []field.AssignExpr
	if chat.HeaderImg != req.GetHeaderImg() {
		up = append(up, m.HeaderImg.Value(req.GetHeaderImg()))
	}

	if chat.ChatBg != req.GetChatBg() {
		up = append(up, m.ChatBg.Value(req.GetChatBg()))
	}

	if chat.DayLimit != req.GetDayLimit() {
		up = append(up, m.DayLimit.Value(req.GetDayLimit()))
	}

	if len(up) == 0 {
		return
	}

	_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(chat.ID)).UpdateSimple(up...)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	s.AddAfterRun(func() (err error) {
		return cache.NewCampaignChat(s.Ctx).Clear(chat)
	})

	return
}

func (s *Update) updateUno(cpn *model.FissionCampaign) (err error) {
	conf, err := cache.NewCampaignUno(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if conf == nil {
		return workerr.NotFound("not found uno conf")
	}

	uno := s.Req.GetUno()

	m := s.GetDao().FissionCampaignUno
	var up []field.AssignExpr

	if conf.InitChance != uno.GetInitChance() {
		up = append(up, m.InitChance.Value(uno.GetInitChance()))
	}

	if !verify.AllInArray[string](uno.GetPropMarks(), conf.GetPropMarks()) {
		str, _ := jsonm.ToSliceString(uno.GetPropMarks())
		up = append(up, m.PropMarks.Value(str))
	}

	if len(up) > 0 {
		_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(conf.ID)).UpdateColumnSimple(up...)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		s.AddAfterRun(func() (err error) {
			return cache.NewCampaignUno(s.Ctx).Clear(conf)
		})
	}

	groupM := s.GetDao().FissionCampaignUnoGroup
	groups, err := groupM.WithContext(s.Ctx).Where(groupM.CampaignID.Eq(cpn.ID)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var groupMap = make(map[int64]*model.FissionCampaignUnoGroup, len(groups))
	var rewardIds []int64
	for _, group := range groups {
		groupMap[group.ID] = group
		rewardIds = append(rewardIds, group.RewardID)
	}

	rewardM := s.GetDao().FissionCampaignReward
	rewards, err := rewardM.WithContext(s.Ctx).Where(rewardM.ID.In(rewardIds...)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var rewardMap = make(map[int64]*model.FissionCampaignReward, len(rewards))
	for _, v := range rewards {
		rewardMap[v.ID] = v
	}

	cardM := s.GetDao().FissionCampaignUnoCard
	cards, err := cardM.WithContext(s.Ctx).Where(cardM.CampaignID.Eq(cpn.ID)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var cardMap = make(map[string][]*model.FissionCampaignUnoCard)
	for _, v := range cards {
		cardMap[v.Mark] = append(cardMap[v.Mark], v)
	}

	var addCards []*model.FissionCampaignUnoCard
	var stockIds []int64
	var fn = func(unoG *pb.UpdateReq_UnoGroup) {
		old := groupMap[unoG.GetId()]

		var upG []field.AssignExpr
		if old.Odds != unoG.GetOdds() {
			upG = append(upG, groupM.Odds.Value(unoG.GetOdds()))
		}

		if old.OpenRule != int8(unoG.GetOpenRule()) {
			upG = append(upG, groupM.OpenRule.Value(int8(unoG.GetOpenRule())))
		}

		if old.CustomCard != int8(unoG.GetCustomCard()) {
			upG = append(upG, groupM.CustomCard.Value(int8(unoG.GetCustomCard())))
		}

		oldRule, newRule := old.GetLimitRule(), unoG.GetLimitRule()
		if oldRule.InitNum != newRule.GetInitNum() ||
			oldRule.SignDay != newRule.GetSignDay() ||
			oldRule.AddNum != newRule.GetAddNum() ||
			oldRule.ResetType != newRule.GetResetType() {
			rule, _ := jsonm.ToObjString(newRule)
			upG = append(upG, groupM.LimitRule.Value(rule))
		}

		if len(upG) > 0 {
			_, err = groupM.WithContext(s.Ctx).Where(groupM.ID.Eq(old.ID)).UpdateSimple(upG...)
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}
		}

		var upR []field.AssignExpr
		oldReward := rewardMap[old.RewardID]
		if oldReward.RewardID != unoG.GetReward().GetRewardId() {
			upR = append(upR, rewardM.RewardID.Value(unoG.GetReward().GetRewardId()))
		}

		if oldReward.Stock != unoG.GetReward().GetStock() {
			upR = append(upR, rewardM.Stock.Value(unoG.GetReward().GetStock()))
			stockIds = append(stockIds, oldReward.ID)
		}

		if len(upR) > 0 {
			_, err = rewardM.WithContext(s.Ctx).Where(rewardM.ID.Eq(oldReward.ID)).UpdateColumnSimple(upR...)
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}
		}

		if unoG.GetCustomCard() == mtype.No {
			return
		}

		oldCards, ok := cardMap[old.Mark]
		if !ok {
			for i, card := range unoG.GetCards() {
				addCards = append(addCards, withdefault.FissionCampaignUnoCard(&model.FissionCampaignUnoCard{
					CampaignID: cpn.ID,
					Mark:       old.Mark,
					CardNo:     int32(i) + 1,
					Title:      card.GetTitle(),
					ImgURL:     card.GetImgUrl(),
					WebURL:     card.GetWebUrl(),
					AppParam:   card.GetAppParam(),
					PcParam:    card.GetPcParam(),
				}))
			}

			return
		}

		oldCardMap := make(map[int64]*model.FissionCampaignUnoCard, len(oldCards))
		for _, v := range oldCards {
			oldCardMap[v.ID] = v
		}

		for _, v := range unoG.GetCards() {
			old := oldCardMap[v.GetId()]
			var upC []field.AssignExpr
			if old.Title != v.GetTitle() {
				upC = append(upC, cardM.Title.Value(v.GetTitle()))
			}

			if old.ImgURL != v.GetImgUrl() {
				upC = append(upC, cardM.ImgURL.Value(v.GetImgUrl()))
			}

			if old.AppParam != v.GetAppParam() {
				upC = append(upC, cardM.AppParam.Value(v.GetAppParam()))
			}

			if old.PcParam != v.GetPcParam() {
				upC = append(upC, cardM.PcParam.Value(v.GetPcParam()))
			}
			if old.WebURL != v.GetWebUrl() {
				upC = append(upC, cardM.WebURL.Value(v.GetWebUrl()))
			}

			if len(upC) > 0 {
				_, err = cardM.WithContext(s.Ctx).Where(cardM.ID.Eq(old.ID)).UpdateColumnSimple(upC...)
				if err != nil {
					err = s.BE().MysqlError(err)
					return
				}
			}
		}
	}

	fn(uno.GetRed())
	fn(uno.GetYellow())
	fn(uno.GetBlue())
	fn(uno.GetGreen())

	if len(addCards) > 0 {
		if err = s.GetDao().FissionCampaignUnoCard.WithContext(s.Ctx).Create(addCards...); err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	if len(stockIds) > 0 {
		s.AddAfterRun(func() (err error) {
			stock, _ := stocks.NewCampaignReward(s.Ctx, stockIds...)
			stock.Clear()
			return
		})
	}

	return
}

func (s *Update) updateEvent(cpn *model.FissionCampaign) (err error) {
	m := s.GetDao().FissionCampaignEvent
	list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var eventMap = make(map[string]*model.FissionCampaignEvent, len(list))
	for _, v := range list {
		eventMap[v.Mark] = v
	}

	events := s.Req.GetEvent()

	var delRewardIds []int64
	var clearStockIds []int64
	var add []*model.FissionCampaignEvent

	var rewardFn = func(reward *pb.UpdateReq_EventReward) (eventReward *mtype.EventReward) {
		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,
			})

			eventReward = &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(),
			})
			eventReward = &mtype.EventReward{
				Id:       hashid.IdBigint(),
				PropMark: reward.GetPropMark(),
				RewardId: rewardId,
				Chance:   reward.GetChance(),
			}
		case mtype.FissionCampaignRewardPropMarkChance:
			eventReward = &mtype.EventReward{
				Id:       hashid.IdBigint(),
				PropMark: reward.GetPropMark(),
				Chance:   reward.GetChance(),
			}
		}

		return
	}

	var fn = func(event *pb.UpdateReq_EventOne, mark string) (err error) {
		old, ok := eventMap[mark]
		if event.GetOpen() == mtype.No {
			if ok && old.Open == mtype.Yes {
				_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(old.ID)).UpdateSimple(m.Open.Value(mtype.No))
				if err != nil {
					err = s.BE().MysqlError(err)
					return
				}
			}

			return
		}

		if !ok {
			var rewards = make([]*mtype.EventReward, 0, len(event.GetRewards()))
			for _, reward := range event.GetRewards() {
				rewards = append(rewards, rewardFn(reward))
			}

			add = append(add, withdefault.FissionCampaignEvent(&model.FissionCampaignEvent{
				CampaignID: cpn.ID,
				Mark:       mark,
				Open:       mtype.Yes,
			}, rewards))

			return
		}

		var oldReward = old.GetRewards()
		var oldMap = make(map[int64]*mtype.EventReward, len(oldReward))
		for _, reward := range oldReward {
			oldMap[reward.Id] = reward
		}

		rewardM := s.GetDao().FissionCampaignReward
		var rewards = make([]*mtype.EventReward, 0)
		for _, reward := range event.GetRewards() {

			old, ok := oldMap[reward.GetId()]
			if !ok {
				rewards = append(rewards, rewardFn(reward))
				continue
			}

			if old.PropMark != reward.GetPropMark() {
				if verify.InArray[string](old.PropMark, mtype.FissionCampaignRewardPropMarkPoint, mtype.FissionCampaignRewardPropMarkReward) {
					delRewardIds = append(delRewardIds, old.RewardId)
					clearStockIds = append(clearStockIds, old.RewardId)
				}

				rewards = append(rewards, rewardFn(reward))
				continue
			}

			switch old.PropMark {
			case mtype.FissionCampaignRewardPropMarkReward:
				_, err = rewardM.WithContext(s.Ctx).
					Where(rewardM.ID.Eq(old.RewardId)).
					UpdateSimple(
						rewardM.Stock.Value(reward.GetReward().GetStock()),
						rewardM.RewardID.Value(reward.GetReward().GetRewardId()),
					)
				if err != nil {
					err = s.BE().MysqlError(err)
					return
				}
				clearStockIds = append(clearStockIds, old.RewardId)
			case mtype.FissionCampaignRewardPropMarkPoint:
				_, err = rewardM.WithContext(s.Ctx).
					Where(rewardM.ID.Eq(old.RewardId)).
					UpdateSimple(
						rewardM.RewardNum.Value(reward.GetChance()),
						rewardM.ExpiredDay.Value(reward.GetExpiredDay()),
					)
				if err != nil {
					err = s.BE().MysqlError(err)
					return
				}
				old.Chance = reward.GetChance()
			case mtype.FissionCampaignRewardPropMarkChance:
				old.Chance = reward.GetChance()
			}

			rewards = append(rewards, old)
		}

		old.Open = mtype.Yes
		old.SetRewards(rewards)

		if err = m.WithContext(s.Ctx).Save(old); err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		s.AddAfterRun(func() (err error) {
			return cache.NewCampaignEvent(s.Ctx).Clear(old)
		})

		return
	}

	err = fn(events.GetFirstVisit(), mtype.FissionCampaignEventMarkFirstVisit)
	if err != nil {
		return
	}

	if len(add) > 0 {
		err = s.GetDao().FissionCampaignEvent.WithContext(s.Ctx).Create(add...)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	if len(delRewardIds) > 0 {
		rewardM := s.GetDao().FissionCampaignReward
		_, err = rewardM.WithContext(s.Ctx).Where(rewardM.ID.In(delRewardIds...)).UpdateSimple(rewardM.IsDel.Value(mtype.Yes))
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	s.AddAfterRun(func() (err error) {
		if len(clearStockIds) > 0 {
			stocks.NewCleaner(s.Ctx, clearStockIds...).ClearAllReward()
		}

		return
	})

	return
}

func (s *Update) updateGashapon(cpn *model.FissionCampaign) (err error) {
	var gashapon = s.Req.GetGashapon()

	cc := cache.NewCampaignGashapon(s.Ctx)
	conf, err := cc.FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if conf == nil {
		return workerr.NotFound("not found gashapon conf")
	}

	confM := s.GetDao().FissionCampaignGashapon
	var up []field.AssignExpr

	if conf.DayChance != gashapon.GetDayChance() {
		up = append(up, confM.DayChance.Value(gashapon.GetDayChance()))
	}

	if conf.InitChance != gashapon.GetInitChance() {
		up = append(up, confM.InitChance.Value(gashapon.GetInitChance()))
	}

	if len(up) == 0 {
		return
	}

	_, err = confM.WithContext(s.Ctx).Where(confM.ID.Eq(conf.ID)).UpdateSimple(up...)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	_ = cc.Clear(conf)

	return
}