joybuywork/internal/service/w_campaign.go

package service

import (
	"joybuywork/internal/app"
	"joybuywork/internal/config"
	"joybuywork/internal/consts"
	"joybuywork/internal/consts/ckey"
	"joybuywork/internal/plugins/jsonm"
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/dbcheck"
	"joybuywork/internal/repository/finder"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/service/cmm"
	containers "joybuywork/internal/service/containers/campaign"
	"joybuywork/internal/service/provider"
	"joybuywork/internal/service/provider/fissionaction"
	"joybuywork/internal/service/provider/operatelog"
	"joybuywork/internal/service/queue/producer"
	"joybuywork/internal/service/queue/types"
	"joybuywork/internal/utils"
	"joybuywork/internal/utils/blink"
	"joybuywork/internal/utils/logic"
	"joybuywork/internal/utils/timez"
	"joybuywork/internal/utils/verify"
	pb "joybuywork/proto/go_proto/w_campaign"
	"joybuywork/proto/go_proto/workerr"
	"time"

	"gorm.io/gen"
	"gorm.io/gen/field"
)

type WCampaign struct {
	Service
}

// List 活动列表
func (s *WCampaign) List(req *pb.ListReq, res *pb.ListRes) (err error) {
	defer s.checkErr()
	*res = pb.ListRes{}

	container := new(containers.List)
	{
		container.Init(s.ctx)
		container.Req = req
		container.Res = res
	}

	return container.Run()
}

// Status 修改状态
func (s *WCampaign) Status(req *pb.StatusReq, res *pb.StatusRes) (err error) {
	defer s.checkErr()

	cpn, err := finder.Campaign(s.ctx, req.GetId(), req.GetHashId())
	if err != nil {
		return s.BE().CacheError(err)
	}

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

	*res = pb.StatusRes{}

	//活动已经下线了，直接返回成功，什么都不干
	if cpn.Status == mtype.FissionCampaignStatusCancel {
		return
	}

	// 想下线，但是没发布
	if req.Status == mtype.FissionCampaignStatusCancel && !cpn.IsPub() {
		return workerr.CWaitCancelError
	}

	// 想上线，但是不是预发布状态
	if verify.InArray[int32](req.Status, mtype.FissionCampaignStatusPub, mtype.FissionCampaignStatusPubPre) && cpn.Status != mtype.FissionCampaignStatusPubPre {
		return workerr.CPubWaitError
	}

	m := s.GetDao().FissionCampaign
	var up = []field.AssignExpr{
		m.Status.Value(int8(req.GetStatus())),
	}

	if req.PreRunTime > 0 {
		up = append(up, m.PreToRun.Value(timez.GMT(req.PreRunTime, cpn.TOffset)))
	}

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

	err = cache.NewCampaign(s.ctx).Clear(cpn)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	switch req.Status {
	case mtype.FissionCampaignStatusPub:
		var conf *model.FissionCampaignConfig
		conf, err = cache.NewCampaignConfig(s.ctx).FindByCampaignId(cpn.ID)
		if err != nil {
			err = s.BE().CacheError(err)
			return
		}

		confM := s.GetDao().FissionCampaignConfig
		_, err = confM.WithContext(s.ctx).Where(confM.ID.Eq(conf.ID)).UpdateSimple(confM.HasWhite.Value(mtype.No))
		if err != nil {
			return s.BE().MysqlError(err)
		}

		_ = cache.NewCampaignConfig(s.ctx).Clear(conf)

		producer.NewDeepworkNotify(s.ctx).CampaignStart(types.DnCampaignStart{
			CampaignId:     cpn.ID,
			CampaignHashId: cpn.HashID,
			Timestamp:      time.Now().Unix(),
		})

	case mtype.FissionCampaignStatusCancel:
		err = cmm.NewCMM(s.ctx, s.GetDao()).CampaignCancelTask(cpn, true)
		if err != nil {
			return
		}

		producer.NewDeepworkNotify(s.ctx).CampaignEnd(types.DnCampaignEnd{
			CampaignId:     cpn.ID,
			CampaignHashId: cpn.HashID,
			Timestamp:      time.Now().Unix(),
		})
	default:

	}

	return
}

// Destroy 删除活动
func (s *WCampaign) Destroy(req *pb.DestroyReq, res *pb.DestroyRes) (err error) {
	defer s.checkErr()
	cpn, err := finder.Campaign(s.ctx, req.GetId(), req.GetHashId())
	if err != nil {
		return s.BE().CacheError(err)
	}

	*res = pb.DestroyRes{}

	if cpn == nil || cpn.IsDel == mtype.Yes {
		return
	}

	m := s.GetDao().FissionCampaign

	_, err = m.WithContext(s.ctx).Where(m.ID.Eq(cpn.ID)).UpdateSimple(m.IsDel.Value(mtype.Yes))
	if err != nil {
		return s.BE().MysqlError(err)
	}

	err = cache.NewCampaign(s.ctx).Clear(cpn)
	if err != nil {
		return
	}

	// 待发布的活动的一些数据要停止处理
	if cpn.Status == mtype.FissionCampaignStatusWait {
		err = cmm.NewCMM(s.ctx, s.GetDao()).CampaignCancelTask(cpn, true)
		if err != nil {
			return
		}
	}

	producer.NewOplatformOther(s.ctx).OpoCampaignDelete(types.OpoCampaignDelete{
		ProjectId:      cpn.ProjectID,
		CampaignHashId: cpn.HashID,
	}, producer.SetHeaderLang(cpn.GetLangMarks()[0]))

	return
}

// Store 创建活动
func (s *WCampaign) Store(req *pb.StoreReq, res *pb.StoreRes) (err error) {
	defer s.checkErr()
	*res = pb.StoreRes{}

	container := new(containers.Store)
	{
		container.Init(s.ctx, logic.WithTran(), logic.WithOl())
		container.Req = req
		container.Res = res
	}

	err = container.Run()

	return
}

// Share 社媒选项
func (s *WCampaign) Share(req *pb.ShareReq, res *pb.ShareRes) (err error) {
	defer s.checkErr()

	loc, overSea := consts.ShareLocList, consts.ShareOverSeaList

	*res = pb.ShareRes{
		Loc:     make([]*pb.ShareRes_One, 0, len(loc)),
		OverSea: make([]*pb.ShareRes_One, 0, len(overSea)),
	}

	for _, v := range loc {
		if v.Close {
			continue
		}
		res.Loc = append(res.Loc, &pb.ShareRes_One{
			Id:        v.Id,
			Title:     v.Title,
			Logo:      v.Logo,
			Scheme:    v.Scheme,
			IosScheme: v.IosScheme,
		})
	}

	for _, v := range overSea {
		if v.Close {
			continue
		}
		res.OverSea = append(res.OverSea, &pb.ShareRes_One{
			Id:        v.Id,
			Title:     v.Title,
			Logo:      v.Logo,
			Scheme:    v.Scheme,
			IosScheme: v.IosScheme,
		})
	}

	return
}

// Show 活动详情
func (s *WCampaign) Show(req *pb.ShowReq, res *pb.ShowRes) (err error) {
	defer s.checkErr()
	*res = pb.ShowRes{}

	container := new(containers.Show)
	{
		container.Init(s.ctx)
		container.Req = req
		container.Res = res
	}

	err = container.Run()

	return
}

// ChannelList 渠道列表
func (s *WCampaign) ChannelList(req *pb.ChannelListReq, res *pb.ChannelListRes) (err error) {
	defer s.checkErr()

	cpn, err := finder.Campaign(s.ctx, req.GetCampaignId(), req.GetCampaignHashId())
	if err != nil {
		return s.BE().CacheError(err)
	}

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

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

	if project == nil || project.IsDel == mtype.Yes {
		return workerr.NotFound("not found project")
	}

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

	var cll, cwl int
	for _, v := range list {
		switch v.CType {
		case mtype.FissionCampaignChannelTypeApp:
			cll++
		case mtype.FissionCampaignChannelTypeWeb:
			cwl++
		}
	}

	*res = pb.ChannelListRes{
		List:    make([]*pb.ChannelListRes_One, 0, cll),
		WebList: make([]*pb.ChannelListRes_One, 0, cwl),
	}

	for _, v := range list {
		switch v.CType {
		case mtype.FissionCampaignChannelTypeApp:
			var url string
			switch cpn.Target {
			case mtype.FissionCampaignConfigTargetAdsGame:
				url = blink.NewAdsLink(project.Domain, cpn.HashID, v.Mark).CampaignShareLink()
			default:
				url = blink.NewCampaignLink(project.Domain, cpn.HashID, v.Mark).CampaignShareLink()
			}

			res.List = append(res.List, &pb.ChannelListRes_One{
				Id:        v.ID,
				Title:     v.Title,
				IsDefault: int32(v.IsDefault),
				Url:       url,
			})
		case mtype.FissionCampaignChannelTypeWeb:
			url := v.ShortLink
			if url == "" {
				url = blink.NewCampaignLink(project.Domain, cpn.HashID, v.Mark).CampaignWebLink()
			}
			res.WebList = append(res.WebList, &pb.ChannelListRes_One{
				Id:        v.ID,
				Title:     v.Title,
				IsDefault: int32(v.IsDefault),
				Url:       url,
				Code:      v.Code,
			})
		}
	}

	return
}

// ChannelCreate 渠道创建
func (s *WCampaign) ChannelCreate(req *pb.ChannelCreateReq, res *pb.ChannelCreateRes) (err error) {
	defer s.checkErr()

	*res = pb.ChannelCreateRes{}

	container := new(containers.ChannelCreate)
	{
		container.Init(s.ctx, logic.WithTran())
		container.Req = req
		container.Res = res
	}

	return container.Run()
}

// ChannelUpdate 渠道更新
func (s *WCampaign) ChannelUpdate(req *pb.ChannelUpdateReq, res *pb.ChannelUpdateRes) (err error) {
	defer s.checkErr()
	m := s.GetDao().FissionCampaignChannel
	cl, err := m.WithContext(s.ctx).Where(m.ID.Eq(req.GetId())).Take()
	if err = dbcheck.DbError(err); err != nil {
		return s.BE().MysqlError(err)
	}

	if cl == nil || cl.IsDel == mtype.Yes {
		return workerr.NotFound("not found channel")
	}

	if cl.IsDefault == mtype.Yes {
		return workerr.CChanelNotSetError
	}

	*res = pb.ChannelUpdateRes{}

	if cl.Title == req.GetTitle() {
		return
	}

	var title []string
	err = m.WithContext(s.ctx).Where(m.CampaignID.Eq(cl.CampaignID), m.ID.Neq(cl.ID), m.CType.Eq(cl.CType), m.IsDel.Eq(mtype.No)).Pluck(m.Title, &title)
	if err != nil {
		return s.BE().MysqlError(err)
	}

	for _, v := range title {
		if v == req.GetTitle() {
			return workerr.CChanelExistError
		}
	}

	_, err = m.WithContext(s.ctx).Where(m.ID.Eq(cl.ID)).UpdateSimple(m.Title.Value(req.GetTitle()))
	if err != nil {
		return s.BE().MysqlError(err)
	}

	cpn, _ := cache.NewCampaign(s.ctx).FindById(cl.CampaignID)
	cpnM := s.GetDao().FissionCampaign
	cpnM.WithContext(s.ctx).Where(cpnM.ID.Eq(cl.CampaignID)).UpdateSimple(cpnM.UpdatedAt.Value(time.Now().Unix()))
	cache.NewCampaign(s.ctx).Clear(cpn)

	_ = cache.NewCampaignChannel(s.ctx).Clear(cl)

	return
}

// ChannelDestroy 渠道删除
func (s *WCampaign) ChannelDestroy(req *pb.ChannelDestroyReq, res *pb.ChannelDestroyRes) (err error) {
	defer s.checkErr()
	m := s.GetDao().FissionCampaignChannel
	cl, err := m.WithContext(s.ctx).Where(m.ID.Eq(req.GetId())).Take()
	if err = dbcheck.DbError(err); err != nil {
		return s.BE().MysqlError(err)
	}

	if cl == nil || cl.IsDel == mtype.Yes {
		return
	}

	if cl.IsDefault == mtype.Yes {
		return workerr.CChanelNotSetError
	}

	_, err = m.WithContext(s.ctx).Where(m.ID.Eq(cl.ID)).UpdateSimple(m.IsDel.Value(mtype.Yes))
	if err != nil {
		return s.BE().MysqlError(err)
	}

	cpn, _ := cache.NewCampaign(s.ctx).FindById(cl.CampaignID)
	cpnM := s.GetDao().FissionCampaign
	cpnM.WithContext(s.ctx).Where(cpnM.ID.Eq(cl.CampaignID)).UpdateSimple(cpnM.UpdatedAt.Value(time.Now().Unix()))
	cache.NewCampaign(s.ctx).Clear(cpn)

	_ = cache.NewCampaignChannel(s.ctx).Clear(cl)

	*res = pb.ChannelDestroyRes{}
	return
}

// Update 更新活动
func (s *WCampaign) Update(req *pb.UpdateReq, res *pb.UpdateRes) (err error) {
	defer s.checkErr()
	*res = pb.UpdateRes{}

	container := new(containers.Update)
	{
		container.Init(s.ctx, logic.WithTran(), logic.WithOl())
		container.Req = req
		container.Res = res
	}

	err = container.Run()

	return
}

// KvData 获取活动键值对
func (s *WCampaign) KvData(req *pb.KvDataReq, res *pb.KvDataRes) (err error) {
	defer s.checkErr()
	conf, err := cache.NewCampaignConfig(s.ctx).FindByCampaignId(req.GetId())
	if err != nil {
		return s.BE().CacheError(err)
	}

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

	kv := conf.GetCampaignData()

	*res = pb.KvDataRes{
		Kv: make([]*pb.KvDataRes_KV, 0, len(kv)),
	}

	for _, v := range kv {
		res.Kv = append(res.Kv, &pb.KvDataRes_KV{
			Key:   v.Key,
			Value: v.Value,
		})
	}

	return
}

// Cert 认证活动信息
func (s *WCampaign) Cert(req *pb.CertReq, res *pb.CertRes) (err error) {
	defer s.checkErr()
	cpn, err := finder.Campaign(s.ctx, req.GetId(), req.GetHashId())
	if err != nil {
		return s.BE().CacheError(err)
	}

	project, err := finder.Project(s.ctx, req.GetProjectId(), req.GetProjectHashId())
	if err != nil {
		return s.BE().CacheError(err)
	}

	if cpn == nil || cpn.IsDel == mtype.Yes || project == nil || project.IsDel == mtype.Yes || cpn.ProjectID != project.ID {
		return
	}

	*res = pb.CertRes{
		Cert:          true,
		Id:            cpn.ID,
		HashId:        cpn.HashID,
		ProjectId:     project.ID,
		ProjectHashId: project.HashID,
		Title:         cpn.Title,
	}
	return
}

// Barrage 活动弹幕
func (s *WCampaign) Barrage(req *pb.BarrageReq, res *pb.BarrageRes) (err error) {
	defer s.checkErr()
	*res = pb.BarrageRes{}
	container := new(containers.Barrage)
	{
		container.Init(s.ctx)
		container.Req = req
		container.Res = res
	}

	return container.Run()
}

// Option 投票选项
func (s *WCampaign) Option(req *pb.OptionReq, res *pb.OptionRes) (err error) {
	defer s.checkErr()
	cpn, err := finder.Campaign(s.ctx, req.GetId(), req.GetHashId())
	if err != nil {
		return s.BE().CacheError(err)
	}

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

	fcqM := s.GetDao().FissionCampaignQuiz
	fcq, err := fcqM.WithContext(s.ctx).Where(fcqM.CampaignID.Eq(cpn.ID)).Take()
	if err = dbcheck.DbError(err); err != nil {
		return s.BE().MysqlError(err)
	}

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

	optionM := s.GetDao().FissionCampaignQuizOption
	options, err := optionM.WithContext(s.ctx).Where(optionM.CampaignID.Eq(cpn.ID), optionM.IsDel.Eq(mtype.No)).Order(optionM.VoteNum.Desc(), optionM.ID).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}

	*res = pb.OptionRes{}

	var rightId int64
	for _, v := range options {
		res.Options = append(res.Options, &pb.OptionRes_Option{
			Id:      v.ID,
			Title:   v.Title,
			ImgUrl:  v.ImgURL,
			IsRight: int32(v.IsRight),
			VoteNum: v.VoteNum,
		})
		if v.IsRight == mtype.Yes {
			rightId = v.ID
		}
	}

	if fcq.OpenType != mtype.FissionCampaignQuizOpenTypeWait {
		res.RightId = rightId
	}

	return
}

// RelateDdl 活动关联动态下载页
func (s *WCampaign) RelateDdl(req *pb.RelateDdlReq, res *pb.RelateDdlRes) (err error) {
	defer s.checkErr()

	*res = pb.RelateDdlRes{}

	project, err := finder.Project(s.ctx, req.GetProjectHashId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if project == nil || project.IsDel == mtype.Yes {
		err = workerr.NotFound("not found project")
		return
	}

	cpn, err := finder.Campaign(s.ctx, req.GetHashId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if cpn == nil {
		err = workerr.NotFound("not found campaign")
		return
	}

	conf, err := cmm.NewCMM(s.ctx, s.dao).GetFissionConfig(project.ID)
	if err != nil {
		return
	}

	m := s.GetDao().FissionConfig

	// 关闭动态下载页
	if req.GetClose() {
		if conf.DynamicCampaign == cpn.ID {
			_, err = m.WithContext(s.ctx).Where(m.ID.Eq(conf.ID)).UpdateSimple(m.DynamicCampaign.Value(0))
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}
		}

		return
	}

	// 等值不用修改
	if conf.DynamicCampaign == cpn.ID {
		return
	}

	_, err = m.WithContext(s.ctx).Where(m.ID.Eq(conf.ID)).UpdateSimple(m.DynamicCampaign.Value(cpn.ID))
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	return
}

// DdlCampaign 关联动态下载页的活动
func (s *WCampaign) DdlCampaign(req *pb.DdlCampaignReq, res *pb.DdlCampaignRes) (err error) {
	defer s.checkErr()
	project, err := finder.Project(s.ctx, req.GetProjectHashId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if project == nil || project.IsDel == mtype.Yes {
		err = workerr.NotFound("not found project")
		return
	}

	conf, err := cmm.NewCMM(s.ctx, s.dao).GetFissionConfig(project.ID)
	if err != nil {
		return
	}

	if conf.DynamicCampaign == 0 {
		return
	}

	cpn, err := finder.Campaign(s.ctx, conf.DynamicCampaign)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if cpn == nil {
		err = workerr.NotFound("not found campaign")
		return
	}

	*res = pb.DdlCampaignRes{
		HashId: cpn.HashID,
		Title:  cpn.Title,
		Status: int32(cpn.Status),
	}
	return
}

// Langs 活动多语言配置信息
func (s *WCampaign) Langs(req *pb.LangsReq, res *pb.LangsRes) (err error) {
	defer s.checkErr()
	*res = pb.LangsRes{}

	container := new(containers.Langs)
	{
		container.Init(s.ctx)
		container.Req = req
		container.Res = res
	}

	return container.Run()
}

// Lang 活动语言信息
func (s *WCampaign) Lang(req *pb.LangReq, res *pb.LangRes) (err error) {
	defer s.checkErr()
	cpn, err := finder.Campaign(s.ctx, req.GetCampaignId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if cpn == nil {
		err = workerr.NotFound("not found campaign")
		return
	}

	project, err := s.ProjectErrNil(cpn.ProjectID)
	if err != nil {
		return
	}

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

	var langMark = utils.NotExistGetFirst(req.GetLangMark(), cpn.GetLangMarks())
	lang, err := cache.NewCampaignLang(s.ctx).FindByCampaignId(cpn.ID, langMark)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if lang == nil {
		return
	}

	*res = pb.LangRes{
		HashId:            lang.HashID,
		PageTitle:         lang.PageTitle,
		ImageMain:         lang.ImageMain,
		DownloadPageImage: lang.DownloadPageImage,
		WechatPageImage:   lang.WechatPageImage,
		ContentImg:        lang.ContentImg,
		WebBgImg:          lang.WebBgImg,
		WarmUpImg:         lang.WarmUpImg,
		DlBgImg:           lang.DlBgImg,
		DlBannerImg:       lang.DlBannerImg,
		DlBannerAppLogo:   lang.DlBannerAppLogo,
		DlBannerAppName:   lang.DlBannerAppName,
		DlBannerAppBtn:    lang.DlBannerAppBtn,
		ShareText:         lang.ShareText,
		ShareImg:          lang.ShareImg,
		Rule:              lang.Rule,
		Conds:             nil,
		Quit:              nil,
		Questions:         nil,
		LongImgs:          nil,
		Cash:              nil,
		TOffset:           lang.TOffset,
		QaGroup:           nil,
		TalkText:          nil,
		Gold:              nil,
		Coin:              nil,
		TopicColor:        lang.TopicColor,
		PcBg:              lang.PcBg,
		RuleImg:           lang.RuleImg,
	}

	for _, cond := range lang.GetConds() {
		res.Conds = append(res.Conds, &pb.LangRes_Cond{
			CondId:     cond.CondId,
			Desc:       cond.Desc,
			WebUrl:     cond.WebURL,
			ExtraParam: cond.ExtraParam,
			PcParam:    cond.PcParam,
			GoText:     cond.GoText,
		})
	}

	if quit := lang.GetQuit(); quit != nil {
		res.Quit = &pb.LangRes_Quit{
			Title:   quit.Title,
			Options: make([]*pb.LangRes_Option, 0, len(quit.Options)),
		}

		for _, option := range quit.Options {
			res.Quit.Options = append(res.Quit.Options, &pb.LangRes_Option{
				OptionId: option.OptionId,
				Title:    option.Title,
				ImgUrl:   option.ImgUrl,
			})
		}
	}

	for _, question := range lang.GetQuestions() {
		q := &pb.LangRes_Question{
			QaId:    question.QaId,
			Title:   question.Title,
			Options: make([]*pb.LangRes_Option, 0, len(question.Options)),
		}

		for _, option := range question.Options {
			q.Options = append(q.Options, &pb.LangRes_Option{
				OptionId: option.OptionId,
				Title:    option.Title,
				ImgUrl:   option.ImgUrl,
			})
		}

		res.Questions = append(res.Questions, q)
	}

	var targetChannelMap = make(map[int64]*model.FissionCampaignChannel)
	var targetCpnMap = make(map[int64]*model.FissionCampaign)
	if conf.HasLongImg == mtype.Yes {
		imgM := s.GetDao().FissionCampaignLongImg
		var imgs []*model.FissionCampaignLongImg
		imgs, err = imgM.WithContext(s.ctx).Where(imgM.CampaignID.Eq(lang.CampaignID), imgM.LangID.Eq(lang.ID), imgM.IsDel.Eq(mtype.No)).Find()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
		var cpnIds []int64
		var zoneIds []int64
		for _, img := range imgs {
			if img.ClickType == mtype.FissionCampaignLongImgClickTypeAll {
				if img.TargetType == mtype.FissionCampaignLongImgTargetTypeCampaign {
					cpnIds = append(cpnIds, img.TargetID)
				}
				continue
			}
			zoneIds = append(zoneIds, img.ID)
		}

		var zoneMap = make(map[int64][]*model.FissionCampaignLongImgZone, len(zoneIds))
		if len(zoneIds) > 0 {
			zoneM := s.GetDao().FissionCampaignLongImgZone
			var zones []*model.FissionCampaignLongImgZone
			zones, err = zoneM.WithContext(s.ctx).Where(zoneM.ImgID.In(zoneIds...), zoneM.IsDel.Eq(mtype.No)).Find()
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}

			for _, zone := range zones {
				zoneMap[zone.ImgID] = append(zoneMap[zone.ImgID], zone)
				if zone.TargetType == mtype.FissionCampaignLongImgTargetTypeCampaign {
					cpnIds = append(cpnIds, zone.TargetID)
				}
			}
		}

		if len(cpnIds) > 0 {
			cpnM := s.GetDao().FissionCampaign
			var cpns []*model.FissionCampaign
			cpns, err = cpnM.WithContext(s.ctx).Where(cpnM.ID.In(cpnIds...)).Find()
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}

			for _, v := range cpns {
				targetCpnMap[v.ID] = v
			}

			channelM := s.GetDao().FissionCampaignChannel
			var channels []*model.FissionCampaignChannel
			channels, err = channelM.WithContext(s.ctx).Where(channelM.CampaignID.In(cpnIds...), channelM.IsDefault.Eq(mtype.Yes), channelM.IsDel.Eq(mtype.No)).Find()
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}

			for _, channel := range channels {
				targetChannelMap[channel.CampaignID] = channel
			}

		}

		for _, v := range imgs {
			var one = &pb.LangRes_LongImg{
				ImgUrl:     v.ImgURL,
				WebUrl:     v.WebURL,
				AppParam:   v.AppParam,
				Id:         v.ID,
				ClickType:  int32(v.ClickType),
				HotZone:    make([]*pb.LangRes_HotZone, 0, len(zoneMap[v.ID])),
				TargetType: int32(v.TargetType),
				TargetId:   v.TargetID,
				TargetUrl:  "",
				PcParam:    v.PcParam,
			}
			if v.TargetType == mtype.FissionCampaignLongImgTargetTypeCampaign {
				one.TargetUrl = blink.NewCampaignLink(project.Domain, targetCpnMap[v.TargetID].HashID, targetChannelMap[v.TargetID].Mark).CampaignShareLink()
			}

			for _, zone := range zoneMap[v.ID] {
				two := &pb.LangRes_HotZone{
					Id:         zone.ID,
					WebUrl:     zone.WebURL,
					AppParam:   zone.AppParam,
					ClickX:     zone.ClickX,
					ClickY:     zone.ClickY,
					ClickW:     zone.ClickW,
					ClickH:     zone.ClickH,
					TargetType: int32(zone.TargetType),
					TargetId:   zone.TargetID,
					TargetUrl:  "",
					PcParam:    zone.PcParam,
				}

				if zone.TargetType == mtype.FissionCampaignLongImgTargetTypeCampaign {
					two.TargetUrl = blink.NewCampaignLink(project.Domain, targetCpnMap[zone.TargetID].HashID, targetChannelMap[zone.TargetID].Mark).CampaignShareLink()
				}

				one.HotZone = append(one.HotZone, two)
			}

			res.LongImgs = append(res.LongImgs, one)
		}
	}

	if cash := lang.GetCash(); cash != nil {
		res.Cash = &pb.LangRes_Cash{
			Price:    cash.Price,
			Currency: cash.Currency,
		}
	}

	if gold := lang.GetGold(); gold != nil {
		res.Gold = &pb.LangRes_Gold{
			Price:    gold.Price,
			Currency: gold.Currency,
		}
	}

	if coin := lang.GetLangCoin(); coin != nil {
		res.Coin = &pb.LangRes_Coin{
			CustomBtnText:    coin.CustomBtnText,
			CustomWebUrl:     coin.CustomWebUrl,
			CustomExtraParam: coin.CustomExtraParam,
			CustomPcParam:    coin.CustomPcParam,
		}
	}

	if qaGroup := lang.GetQaGroup(); qaGroup != nil {
		var title string
		qaGroupM := s.GetDao().LibraryQaGroup
		group, _ := qaGroupM.WithContext(s.ctx).Where(qaGroupM.HashID.Eq(qaGroup.QaGroupId)).Take()
		if group != nil {
			title = group.Title
		}

		res.QaGroup = &pb.LangRes_QaGroup{
			QaGroupId:    qaGroup.QaGroupId,
			QaNum:        qaGroup.QaNum,
			Title:        title,
			GuideGroupId: qaGroup.GuideGroupId,
		}
	}

	if langVs := lang.GetVs(); langVs != nil {
		var langScheduleMap = make(map[int64]*pb.LangRes_PkTeam, len(langVs))

		for _, schedule := range langVs {
			for _, pkTeam := range schedule.PkTeams {
				var teams = make([]*pb.LangRes_Team, 0, len(pkTeam.Teams))
				for _, team := range pkTeam.Teams {
					teams = append(teams, &pb.LangRes_Team{
						Id:      team.Id,
						Name:    team.Name,
						LogoImg: team.LogoImg,
					})
				}

				langScheduleMap[pkTeam.Id] = &pb.LangRes_PkTeam{
					Id:    pkTeam.Id,
					Teams: teams,
					VsImg: pkTeam.VsImg,
					Desc:  pkTeam.Desc,
				}
			}
		}

		m := s.GetDao().FissionCampaignVsTeam
		vsTeam, err1 := m.WithContext(s.ctx).Where(m.CampaignID.Eq(cpn.ID)).Find()
		if err1 != nil {
			err1 = s.BE().MysqlError(err1)
			return
		}

		var vsTeamMap = make(map[int64]*pb.LangRes_Team, len(vsTeam))
		for _, v := range vsTeam {
			vsTeamMap[v.ID] = &pb.LangRes_Team{
				Id:      v.ID,
				Name:    v.Name,
				LogoImg: v.LogoImg,
			}
		}

		scheduleM := s.GetDao().FissionCampaignVsSchedule
		var list []*model.FissionCampaignVsSchedule
		list, err = scheduleM.WithContext(s.ctx).Where(scheduleM.CampaignID.Eq(cpn.ID)).Find()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		var vsSchedule = make(map[int32][]*model.FissionCampaignVsSchedule)
		for _, v := range list {
			vsSchedule[v.VsIdx] = append(vsSchedule[v.VsIdx], v)
		}

		res.Schedules = make([]*pb.LangRes_Schedule, len(vsSchedule))
		for idx, schedules := range vsSchedule {
			one := &pb.LangRes_Schedule{
				Id:      idx,
				PkTeams: make([]*pb.LangRes_PkTeam, 0, len(schedules)),
			}

			for _, schedule := range schedules {
				two := &pb.LangRes_PkTeam{
					Id:    schedule.ID,
					Desc:  schedule.Desc,
					VsImg: schedule.VsImg,
				}

				for _, teamId := range schedule.GetVsTeamIds() {
					if teamId > 0 {
						two.Teams = append(two.Teams, vsTeamMap[teamId])
					} else {
						two.Teams = append(two.Teams, &pb.LangRes_Team{
							Id: teamId,
						})
					}
				}

				if scd, ok := langScheduleMap[schedule.ID]; ok {
					two.Desc = scd.Desc
					two.VsImg = scd.VsImg
					for i, team := range scd.Teams {
						if team.Id > 0 {
							two.Teams[i] = team
						}
					}
				}

				one.PkTeams = append(one.PkTeams, two)
			}

			res.Schedules[idx] = one
		}
	}

	_ = jsonm.StrUnmarshal(lang.TalkText, &res.TalkText)
	_ = jsonm.StrUnmarshal(lang.Uno, &res.Uno)

	return
}

// SaveLang 保存活动多语言配置信息
func (s *WCampaign) SaveLang(req *pb.SaveLangReq, res *pb.SaveLangRes) (err error) {
	defer s.checkErr()
	*res = pb.SaveLangRes{}

	container := new(containers.SaveLang)
	{
		container.Init(s.ctx, logic.WithTran(), logic.WithOnce(ckey.FissionCampaignLangSaveOnce(req.GetCampaignHashId(), req.GetLangMark())))
		container.Req = req
		container.Res = res
	}

	return container.Run()
}

// DestroyLang 删除活动语言配置信息
func (s *WCampaign) DestroyLang(req *pb.DestroyLangReq, res *pb.DestroyLangRes) (err error) {
	defer s.checkErr()
	m := s.GetDao().FissionCampaignLang
	lang, err := m.WithContext(s.ctx).Where(m.HashID.Eq(req.GetHashId()), m.IsDel.Eq(mtype.No)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if lang == nil || lang.IsDel == mtype.Yes {
		return
	}

	cpn, err := finder.Campaign(s.ctx, lang.CampaignID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

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

	_, err = m.WithContext(s.ctx).Where(m.ID.Eq(lang.ID)).UpdateSimple(m.IsDel.Value(mtype.Yes))
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	lt := mtype.MarkToLangType[lang.LangMark]

	var nlt []int8
	for _, v := range cpn.GetLangTypes() {
		if v == lt {
			continue
		}
		nlt = append(nlt, v)
	}

	nltStr, _ := jsonm.MarshalToString(nlt)

	cpnM := s.GetDao().FissionCampaign
	_, err = cpnM.WithContext(s.ctx).Where(cpnM.ID.Eq(cpn.ID)).UpdateSimple(cpnM.LangTypes.Value(nltStr))
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	_ = cache.NewCampaignLang(s.ctx).Clear(lang)
	_ = cache.NewCampaign(s.ctx).Clear(cpn)

	*res = pb.DestroyLangRes{}
	return
}

// LangSelect 活动语言选择
func (s *WCampaign) LangSelect(req *pb.LangSelectReq, res *pb.LangSelectRes) (err error) {
	defer s.checkErr()

	cpn, err := finder.Campaign(s.ctx, req.GetCampaignHashId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

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

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

	var langMap = make(map[string]bool)
	for _, lang := range langs {
		langMap[lang.LangMark] = true
	}

	*res = pb.LangSelectRes{
		List: make([]*pb.LangSelectRes_One, len(mtype.MarkToLangType)),
	}

	for k, v := range mtype.MarkToLangType {
		res.List[int(v)-1] = &pb.LangSelectRes_One{
			LangType: int32(v),
			LangMark: k,
			Selected: langMap[k],
		}
	}

	return
}

// CampaignInfo 活动信息
func (s *WCampaign) CampaignInfo(req *pb.CampaignInfoReq, res *pb.CampaignInfoRes) (err error) {
	defer s.checkErr()
	cpn, err := finder.Campaign(s.ctx, req.GetCampaignHashId(), req.GetCampaignId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

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

	project, err := s.ProjectErrNil(cpn.ProjectID)
	if err != nil {
		return
	}

	// 默认渠道
	cl, err := cmm.NewCMM(s.ctx, s.GetDao()).UserBindChannel(cpn.ID, "")
	if err != nil {
		return
	}

	var clMark string
	if cl != nil {
		clMark = cl.Mark
	}

	linkObj := blink.NewCampaignLink(project.Domain, cpn.HashID, clMark)

	var pageTitle, shareImg, pcBg string

	switch cpn.Target {
	case mtype.FissionCampaignConfigTargetApp, mtype.FissionCampaignConfigTargetUp, mtype.FissionCampaignConfigTargetRetain:
		langMark := utils.NotExistGetFirst(req.GetLang(), cpn.GetLangMarks())
		if langMark == cpn.GetLangMarks()[0] {
			var style *model.FissionCampaignStyle
			style, err = cache.NewCampaignStyle(s.ctx).FindByCampaignId(cpn.ID)
			if err != nil {
				err = s.BE().CacheError(err)
				return
			}

			pageTitle = style.PageTitle
			shareImg = style.ShareImg
			pcBg = style.PcBg

		} else {
			var lang *model.FissionCampaignLang
			lang, err = cache.NewCampaignLang(s.ctx).FindByCampaignId(cpn.ID, langMark)
			if err != nil {
				err = s.BE().CacheError(err)
				return
			}

			pageTitle = lang.PageTitle
			shareImg = lang.ShareImg
			pcBg = lang.PcBg
		}
	default:
		var conf *model.FissionCampaignConfig
		conf, err = cache.NewCampaignConfig(s.ctx).FindByCampaignId(cpn.ID)
		if err != nil {
			err = s.BE().CacheError(err)
			return
		}
		pageTitle = conf.PageTitle
		shareImg = conf.ShareImg
		pcBg = conf.PcBg
	}

	*res = pb.CampaignInfoRes{
		Id:           cpn.ID,
		HashId:       cpn.HashID,
		Title:        cpn.Title,
		PageTitle:    pageTitle,
		FissionMark:  consts.FissionIdMap[cpn.FissionID],
		FissionTitle: consts.FissionTitle[consts.LangZhCn][consts.FissionIdMap[cpn.FissionID]],
		StartTime:    cpn.TStart,
		EndTime:      cpn.TEnd,
		Status:       int32(cpn.Status),
		TOffset:      cpn.TOffset,
		LangTypes:    cpn.GetLangMarks(),
		ShareImg:     shareImg,
		Link:         linkObj.CampaignShareLink(),
		ImgHost:      config.Config.Upload.Host,
		PcBg:         pcBg,
		Target:       int32(cpn.Target),
		StartAt:      cpn.StartTime,
		EndAt:        cpn.EndTime,
		ProjectId:    cpn.ProjectID,
	}

	return
}

// ShowReward 显示的奖品数据
func (s *WCampaign) ShowReward(req *pb.ShowRewardReq, res *pb.ShowRewardRes) (err error) {
	defer s.checkErr()

	*res = pb.ShowRewardRes{}

	container := new(containers.ShowReward)
	{
		container.Init(s.ctx)
		container.Req = req
		container.Res = res
	}

	return container.Run()
}

// AdsStore 创建Ads活动
func (s *WCampaign) AdsStore(req *pb.AdsStoreReq, res *pb.AdsStoreRes) (err error) {
	defer s.checkErr()
	*res = pb.AdsStoreRes{}

	container := new(containers.AdsStore)
	{
		container.Init(s.ctx, logic.WithTran())
		container.Req = req
		container.Res = res
	}

	return container.Run()
}

// AdsUpdate 更新Ads活动
func (s *WCampaign) AdsUpdate(req *pb.AdsUpdateReq, res *pb.AdsUpdateRes) (err error) {
	defer s.checkErr()
	*res = pb.AdsUpdateRes{}
	container := new(containers.AdsUpdate)
	{
		container.Init(s.ctx, logic.WithTran())
		container.Req = req
		container.Res = res
	}

	return container.Run()
}

// AdsShow Ads活动详情
func (s *WCampaign) AdsShow(req *pb.AdsShowReq, res *pb.AdsShowRes) (err error) {
	defer s.checkErr()
	*res = pb.AdsShowRes{}
	container := new(containers.AdsShow)
	{
		container.Init(s.ctx, logic.WithTran())
		container.Req = req
		container.Res = res
	}

	return container.Run()
}

// CampaignSelect 活动选择列表
func (s *WCampaign) CampaignSelect(req *pb.CampaignSelectReq, res *pb.CampaignSelectRes) (err error) {
	defer s.checkErr()
	project, err := finder.Project(s.ctx, req.GetProjectId(), req.GetProjectHashId())
	if err != nil {
		return s.BE().CacheError(err)
	}

	if project == nil || project.IsDel == mtype.Yes {
		return
	}

	m := s.GetDao().FissionCampaign
	var cond = []gen.Condition{
		m.IsDel.Eq(mtype.No),
		m.ProjectID.Eq(project.ID),
	}

	if len(req.GetTargets()) > 0 {
		var targets = make([]int8, 0, len(req.GetTargets()))
		for _, v := range req.GetTargets() {
			targets = append(targets, int8(v))
		}
		cond = append(cond, m.Target.In(targets...))
	}

	if len(req.GetStatus()) > 0 {
		var status = make([]int8, 0, len(req.GetStatus()))
		for _, v := range req.GetStatus() {
			status = append(status, int8(v))
		}
		cond = append(cond, m.Status.In(status...))
	}

	if req.GetTempHashId() != "" {
		var temp *model.FissionTemp
		tempM := s.GetDao().FissionTemp
		temp, err = tempM.WithContext(s.ctx).Where(tempM.HashID.Eq(req.GetTempHashId())).Take()
		if err = dbcheck.DbError(err); err != nil {
			return s.BE().MysqlError(err)
		}

		if temp == nil {
			cond = append(cond, m.FissionID.Eq(0))
		} else {
			cond = append(cond, m.FissionID.Eq(temp.FissionID))
		}

	}

	if req.GetChildType() > 0 {
		cond = append(cond, m.ChildType.Eq(int8(req.GetChildType())))
	}

	if req.GetChild() {
		cond = append(cond, m.Target.Eq(mtype.FissionCampaignConfigTargetChild))
		if req.GetChildWith() != "" {
			var cpn *model.FissionCampaign
			cpn, err = finder.Campaign(s.ctx, req.GetChildWith())
			if err != nil {
				err = s.BE().CacheError(err)
				return
			}

			if cpn != nil {
				cond = append(cond, m.WithContext(s.ctx).Where(m.Pid.Eq(cpn.ID)).Or(m.Pid.Eq(0)))
			} else {
				cond = append(cond, m.Pid.Eq(-1))
			}

		} else {
			cond = append(cond, m.Pid.Eq(0))
		}
	}

	list, err := m.WithContext(s.ctx).Where(cond...).Order(m.ID.Desc()).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	*res = pb.CampaignSelectRes{
		List: make([]*pb.CampaignSelectRes_One, 0, len(list)),
	}

	for _, v := range list {
		res.List = append(res.List, &pb.CampaignSelectRes_One{
			Id:        v.ID,
			HashId:    v.HashID,
			Title:     v.Title,
			Status:    int32(v.Status),
			ChildType: int32(v.ChildType),
		})
	}
	return
}

// RewardDetail 奖品详情
func (s *WCampaign) RewardDetail(req *pb.RewardDetailReq, res *pb.RewardDetailRes) (err error) {
	defer s.checkErr()
	*res = pb.RewardDetailRes{}
	container := new(containers.RewardDetail)
	{
		container.Init(s.ctx)
		container.Req = req
		container.Res = res
	}

	return container.Run()
}

// UpdateStock 修改奖品库存
func (s *WCampaign) UpdateStock(req *pb.UpdateStockReq, res *pb.UpdateStockRes) (err error) {
	defer s.checkErr()

	m := s.GetDao().FissionCampaignReward
	reward, err := m.WithContext(s.ctx).Where(m.ID.Eq(req.GetId())).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

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

	cpn, err := cache.NewCampaign(s.ctx).FindById(reward.CampaignID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if !cpn.IsPub() {
		err = workerr.VerifyError("campaign not run")
		return
	}

	if reward.Stock == req.GetStock() {
		return
	}

	_, err = m.WithContext(s.ctx).Where(m.ID.Eq(reward.ID)).UpdateSimple(m.Stock.Value(req.GetStock()))
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	_ = app.Redis.Del(s.ctx, ckey.FissionCampaignRewardPool(reward.ID))
	operatelog.NewOperateLog(s.ctx).User(req.GetUserId(), req.GetIp()).UpdateRunningStock(reward.ID, reward.Stock, req.GetStock())

	*res = pb.UpdateStockRes{}
	return
}

// CampaignTz 活动时区数据
func (s *WCampaign) CampaignTz(req *pb.CampaignTzReq, res *pb.CampaignTzRes) (err error) {
	defer s.checkErr()
	cpn, err := cache.NewCampaign(s.ctx).FindById(req.GetId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

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

	if cpn.ChildType != 0 {

		if cpn.Pid == 0 {
			return
		}

		cpn, err = cache.NewCampaign(s.ctx).FindById(cpn.Pid)
		if err != nil {
			err = s.BE().CacheError(err)
			return
		}

	}

	*res = pb.CampaignTzRes{
		List: []*pb.CampaignTzRes_One{
			{
				Mark:    cpn.GetLangMarks()[0],
				TOffset: cpn.TOffset,
			},
		},
	}

	if len(cpn.GetLangTypes()) == 1 {
		return
	}

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

	for _, v := range list {
		res.List = append(res.List, &pb.CampaignTzRes_One{
			Mark:    v.LangMark,
			TOffset: v.TOffset,
		})
	}

	return
}

// CampaignRewardType 活动奖品类型
func (s *WCampaign) CampaignRewardType(req *pb.CampaignRewardTypeReq, res *pb.CampaignRewardTypeRes) (err error) {
	defer s.checkErr()
	m := s.GetDao().FissionCampaignReward
	list, err := m.WithContext(s.ctx).Where(m.CampaignID.Eq(req.GetId())).Find()
	if err != nil {
		return s.BE().MysqlError(err)
	}
	*res = pb.CampaignRewardTypeRes{
		List: make([]*pb.CampaignRewardTypeRes_One, 0, len(list)),
	}

	for _, v := range list {
		res.List = append(res.List, &pb.CampaignRewardTypeRes_One{
			Id:         v.ID,
			RewardType: int32(v.RewardType),
		})
	}

	return
}

// ChildList 子活动列表
func (s *WCampaign) ChildList(req *pb.ChildListReq, res *pb.ChildListRes) (err error) {
	defer s.checkErr()
	project, err := finder.Project(s.ctx, req.GetProjectId(), req.GetProjectHashId())
	if err != nil {
		return s.BE().CacheError(err)
	}

	if project == nil || project.IsDel == mtype.Yes {
		return
	}

	m := s.GetDao().FissionCampaign
	var cond = []gen.Condition{
		m.IsDel.Eq(mtype.No),
		m.ProjectID.Eq(project.ID),
		m.Target.Eq(mtype.FissionCampaignConfigTargetChild),
	}

	if req.GetTitle() != "" {
		cond = append(cond, m.Title.Like(utils.DbAllLike(req.GetTitle())))
	}

	if len(req.GetPids()) > 0 {
		cond = append(cond, m.Pid.In(req.GetPids()...))
	}

	if len(req.GetStatus()) != 0 {
		var status = make([]int8, 0, len(req.GetStatus()))
		for _, v := range req.GetStatus() {
			status = append(status, int8(v))
		}
		cond = append(cond, m.Status.In(status...))
	}

	if len(req.GetChildType()) != 0 {
		var status = make([]int8, 0, len(req.GetChildType()))
		for _, v := range req.GetChildType() {
			status = append(status, int8(v))
		}
		cond = append(cond, m.ChildType.In(status...))
	}

	if len(req.GetFissionId()) != 0 {
		cond = append(cond, m.FissionID.In(req.GetFissionId()...))
	}

	if len(req.GetCampaignId()) != 0 {
		cond = append(cond, m.Pid.In(req.GetCampaignId()...))
	}

	if req.GetStart() > 0 {
		cond = append(cond, m.TStart.Gte(req.GetStart()))
	}

	if req.GetEnd() > 0 {
		cond = append(cond, m.TEnd.Lte(req.GetEnd()))
	}

	offset, limit := utils.PpDbLo(req.GetPage(), req.GetPerPage())
	list, total, err := m.WithContext(s.ctx).Where(cond...).Order(m.ID.Desc()).FindByPage(offset, limit)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	*res = pb.ChildListRes{
		List:  make([]*pb.ChildListRes_One, 0, len(list)),
		Total: total,
	}

	var cpnIds []int64
	var cpnMap = make(map[int64]string)
	for _, v := range list {
		if _, ok := cpnMap[v.Pid]; !ok && v.Pid > 0 {
			cpnIds = append(cpnIds, v.Pid)
			cpnMap[v.Pid] = ""
		}
	}

	if len(cpnIds) > 0 {
		var cpns []*model.FissionCampaign
		cpns, err = m.WithContext(s.ctx).Where(m.ID.In(cpnIds...)).Find()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
		for _, cpn := range cpns {
			cpnMap[cpn.ID] = cpn.Title
		}
	}

	for _, v := range list {
		one := &pb.ChildListRes_One{
			Id:           v.ID,
			HashId:       v.HashID,
			Title:        v.Title,
			FissionId:    v.FissionID,
			FissionMark:  consts.FissionIdMap[v.FissionID],
			StartTime:    v.TStart,
			EndTime:      v.TEnd,
			Status:       int32(v.Status),
			ChildType:    int32(v.ChildType),
			BindCampaign: "",
			HasReport:    0,
		}

		if pTitle, ok := cpnMap[v.Pid]; ok {
			one.BindCampaign = pTitle
			one.HasReport = 1
		}

		res.List = append(res.List, one)
	}

	return
}

// ChildStore 子活动列表
func (s *WCampaign) ChildStore(req *pb.ChildStoreReq, res *pb.ChildStoreRes) (err error) {
	defer s.checkErr()
	*res = pb.ChildStoreRes{}

	container := new(containers.ChildStore)
	{
		container.Init(s.ctx, logic.WithTran(), logic.WithOl())
		container.Req = req
		container.Res = res
	}

	return container.Run()
}

// ChildUpdate 更新子活动
func (s *WCampaign) ChildUpdate(req *pb.ChildUpdateReq, res *pb.ChildUpdateRes) (err error) {
	defer s.checkErr()
	*res = pb.ChildUpdateRes{}

	container := new(containers.ChildUpdate)
	{
		container.Init(s.ctx, logic.WithTran(), logic.WithOl())
		container.Req = req
		container.Res = res
	}

	return container.Run()
}

// ChildShow 子活动活动
func (s *WCampaign) ChildShow(req *pb.ChildShowReq, res *pb.ChildShowRes) (err error) {
	defer s.checkErr()
	*res = pb.ChildShowRes{}

	container := new(containers.ChildShow)
	{
		container.Init(s.ctx)
		container.Req = req
		container.Res = res
	}

	return container.Run()
}

// TaskCenterJump 子活动列表
func (s *WCampaign) TaskCenterJump(req *pb.TaskCenterJumpReq, res *pb.TaskCenterJumpRes) (err error) {
	defer s.checkErr()
	m := s.GetDao().FissionCampaign
	list, err := m.WithContext(s.ctx).Where(m.ID.In(req.GetCpnIds()...)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if len(list) == 0 {
		return
	}

	projectId := list[0].ProjectID

	project, err := cache.NewProject(s.ctx).FindById(projectId)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	channelM := s.GetDao().FissionCampaignChannel
	channels, err := channelM.WithContext(s.ctx).Where(
		channelM.CampaignID.In(req.GetCpnIds()...),
		channelM.CType.Eq(mtype.FissionCampaignChannelTypeApp),
		channelM.IsDefault.Eq(mtype.Yes),
		channelM.IsDel.Eq(mtype.No),
	).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var channelMark = make(map[int64]string, len(channels))
	for _, v := range channels {
		channelMark[v.CampaignID] = v.Mark
	}

	*res = pb.TaskCenterJumpRes{
		List: make([]*pb.TaskCenterJumpRes_One, 0, len(list)),
	}

	for _, v := range list {
		res.List = append(res.List, &pb.TaskCenterJumpRes_One{
			Id: v.ID,
			JumpUrl: blink.NewCampaignLink(
				project.Domain,
				v.HashID,
				channelMark[v.ID],
				blink.SetTaskCenter(req.GetCenterHashId(), req.GetModuleId()),
			).CampaignShareLink(),
		})
	}

	return
}

// CondList 活动任务数据
func (s *WCampaign) CondList(req *pb.CondListReq, res *pb.CondListRes) (err error) {
	defer s.checkErr()

	m := s.GetDao().FissionCampaignCond

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

	*res = pb.CondListRes{
		List: make([]*pb.CondListRes_One, 0, len(list)),
	}

	for _, v := range list {
		res.List = append(res.List, &pb.CondListRes_One{
			Id:    v.ID,
			Desc:  v.Desc,
			Event: v.Event,
			Conds: []*pb.CondListRes_Cond{
				{
					EventKey: v.EventKey,
					EventVal: v.EventVal,
					IfCond:   int32(v.IfCond),
				},
			},
		})
	}

	return
}

// Campaigns 获取活动数据
func (s *WCampaign) Campaigns(req *pb.CampaignsReq, res *pb.CampaignsRes) (err error) {
	defer s.checkErr()

	m := s.GetDao().FissionCampaign
	list, err := m.WithContext(s.ctx).Where(m.ID.In(req.GetCampaignIds()...)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	*res = pb.CampaignsRes{
		List: make([]*pb.CampaignsRes_One, 0, len(list)),
	}

	for _, v := range list {
		res.List = append(res.List, &pb.CampaignsRes_One{
			Id:    v.ID,
			Title: v.Title,
		})
	}

	return
}

// SetLvApi 设置动态用户等级动态api
func (s *WCampaign) SetLvApi(req *pb.SetLvApiReq, res *pb.SetLvApiRes) (err error) {
	defer s.checkErr()

	project, err := finder.Project(s.ctx, req.GetProjectHashId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if project == nil || project.IsDel == mtype.Yes {
		err = workerr.NotFound("not found project")
		return
	}

	conf, err := provider.NewFissionConfig(s.ctx, project)
	if err != nil {
		return
	}

	err = conf.SetLvUrl(req.GetUrlId())
	if err != nil {
		return
	}

	*res = pb.SetLvApiRes{}
	return
}

// GetLvApi 获取动态用户等级动态api
func (s *WCampaign) GetLvApi(req *pb.GetLvApiReq, res *pb.GetLvApiRes) (err error) {
	defer s.checkErr()
	project, err := finder.Project(s.ctx, req.GetProjectHashId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if project == nil || project.IsDel == mtype.Yes {
		err = workerr.NotFound("not found project")
		return
	}

	conf, err := provider.NewFissionConfig(s.ctx, project)
	if err != nil {
		return
	}

	url, err := conf.GetLvUrl()
	if err != nil || url == nil {
		return
	}

	*res = pb.GetLvApiRes{
		UrlId: url.ID,
		Title: url.Title,
	}
	return
}

// VsSettlement 赛事竞猜结算
func (s *WCampaign) VsSettlement(req *pb.VsSettlementReq, res *pb.VsSettlementRes) (err error) {
	defer s.checkErr()

	*res = pb.VsSettlementRes{}
	container := new(containers.VsSettlement)
	{
		container.Init(s.ctx, logic.WithTran())
		container.Req = req
		container.Res = res
	}

	return container.Run()
}

// VsSettlementInfo 赛事竞猜结算
func (s *WCampaign) VsSettlementInfo(req *pb.VsSettlementInfoReq, res *pb.VsSettlementInfoRes) (err error) {
	defer s.checkErr()
	m := s.GetDao().FissionCampaignVsSchedule
	schedule, err := m.WithContext(s.ctx).Where(m.ID.Eq(req.GetScheduleId())).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

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

	slt := schedule.GetSettlement()

	var scoreMap = make(map[int64]string, len(slt.Scores))
	for _, v := range slt.Scores {
		scoreMap[v.TeamId] = v.Score
	}

	var vsTeamIds = schedule.GetVsTeamIds()
	teamM := s.GetDao().FissionCampaignVsTeam
	teams, err := teamM.WithContext(s.ctx).Where(teamM.ID.In(vsTeamIds...)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var teamMap = make(map[int64]*pb.VsSettlementInfoRes_Team, len(teams))
	for _, v := range teams {
		teamMap[v.ID] = &pb.VsSettlementInfoRes_Team{
			Id:      v.ID,
			Name:    v.Name,
			LogoImg: v.LogoImg,
			Score:   scoreMap[v.ID],
		}
	}

	*res = pb.VsSettlementInfoRes{
		WinType:   slt.WinType,
		WinTeamId: slt.WinTeamId,
		Teams:     make([]*pb.VsSettlementInfoRes_Team, 0, len(vsTeamIds)),
	}

	for _, id := range vsTeamIds {
		if _, ok := teamMap[id]; ok {
			res.Teams = append(res.Teams, teamMap[id])
		} else {
			res.Teams = append(res.Teams, &pb.VsSettlementInfoRes_Team{
				Id:    id,
				Score: scoreMap[id],
			})
		}
	}

	return
}

// ActionList 行为列表
func (s *WCampaign) ActionList(req *pb.ActionListReq, res *pb.ActionListRes) (err error) {
	defer s.checkErr()

	cpn, err := cache.NewCampaign(s.ctx).FindById(req.GetCampaignId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

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

	temp, err := cache.NewFissionTemp(s.ctx).FindById(cpn.TemplateID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

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

	pfa := fissionaction.NewActionList(s.ctx, cpn, conf, group)

	*res = pb.ActionListRes{
		ActionTypes: pfa.GetFissionAction(),
	}

	return
}