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

package campaign

import (
	"joybuywork/internal/consts"
	"joybuywork/internal/plugins/jsonm"
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/dbcheck"
	"joybuywork/internal/repository/finder"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/service/provider"
	"joybuywork/internal/utils"
	"joybuywork/internal/utils/logic"
	"joybuywork/internal/utils/verify"
	pb "joybuywork/proto/go_proto/w_campaign"
	"joybuywork/proto/go_proto/workerr"
)

type campaignLangsPrizeQuiz struct {
	quit    *model.FissionCampaignQuiz
	options []*model.FissionCampaignQuizOption
}

type campaignLangsPrizeAnswer struct {
	questions []*model.FissionCampaignQaQuestion
	optionMap map[int64][]*model.FissionCampaignQaOption
}

type campaignLangsRewards struct {
	webIds, extraIds, newcomerIds, ids []int64
	userLevel                          []*campaignLangsLevelIds
	country                            []*campaignLangsCountryMarks
	preward                            *provider.Rewards
}

type campaignLangsLevelIds struct {
	LevelId int64
	ids     []int64
}

type campaignLangsCountryMarks struct {
	countryMark string
	ids         []int64
}

type Langs struct {
	logic.Logic
	Req *pb.LangsReq
	Res *pb.LangsRes

	prizeQuiz   *campaignLangsPrizeQuiz
	prizeAnswer *campaignLangsPrizeAnswer

	conds   []*model.FissionCampaignCond
	condMap map[int64]*model.FissionCampaignCond

	levelMap map[int64]string // 等级名称map
	ful      finder.FuserLayer

	rewards    map[string]*campaignLangsRewards // 语言对应的奖品数据
	rewardData struct {
		rewardList []*model.FissionCampaignReward
		prewards   *provider.Rewards
	} // 依赖的奖品数据

	// 长图数据
	longImgs   map[int64][]*model.FissionCampaignLongImg
	imgZoneMap map[int64][]*model.FissionCampaignLongImgZone

	// 现金抽奖配置
	cashConf *model.FissionCampaignCash

	// 金币任务配置
	goldConf *model.FissionCampaignGold

	// 金币池配置
	coinConf *model.FissionCampaignCoin

	// 答题配置
	qaConf *model.FissionCampaignQa

	// 养狗配置
	keepConf *model.FissionCampaignKeep

	// 题库
	qaGroup        map[string]*model.LibraryQaGroup
	defaultQaGroup *model.LibraryQaGroup

	vsSchedule map[int32][]*model.FissionCampaignVsSchedule
	vsTeam     []*model.FissionCampaignVsTeam

	unoCardMap map[string][]*model.FissionCampaignUnoCard

	temp  *model.FissionTemp
	group *model.FissionTempGroup
}

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

func (s *Langs) Data() (data jsonm.JsonM) {
	data, _ = jsonm.Marshal(s.Req)
	return
}

func (s *Langs) Exec() (err error) {
	cpn, conf, style, err := s.campaign()
	if err != nil {
		return
	}

	notSupport, err := s.setLangs(cpn, conf, style)
	if err != nil {
		return
	}

	err = s.notSupport(cpn, conf, style, notSupport)
	if err != nil {
		return
	}

	return
}

func (s *Langs) campaign() (cpn *model.FissionCampaign, conf *model.FissionCampaignConfig, style *model.FissionCampaignStyle, err error) {
	cpn, err = finder.Campaign(s.Ctx, s.Req.GetCampaignHashId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

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

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

	style, err = cache.NewCampaignStyle(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
	}

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

	s.rewards = make(map[string]*campaignLangsRewards)
	s.qaGroup = make(map[string]*model.LibraryQaGroup)

	s.ful = finder.NewFuserLayer(conf)

	s.Res.HasWeb = conf.HasWeb == mtype.Yes
	s.Res.HasWarn = conf.HasWarmUp == mtype.Yes
	s.Res.HasLongImg = conf.HasLongImg == mtype.Yes
	s.Res.DlType = int32(conf.DlType)
	s.Res.DlBannerType = int32(conf.DlBannerType)
	s.Res.WindowCover = int32(conf.WindowCover)
	s.Res.RewardGroup = int32(conf.RewardGroup)
	s.Res.FissionMark = consts.FissionIdMap[cpn.FissionID]
	s.Res.RuleType = int32(conf.RuleType)
	s.Res.Title = cpn.Title
	s.Res.FissionMarkTitle = consts.FissionTitle[consts.LangZhCn][s.Res.FissionMark]

	if group != nil {
		s.Res.TempGroupMark = group.Mark
	}

	return
}

func (s *Langs) setLangs(cpn *model.FissionCampaign, conf *model.FissionCampaignConfig, style *model.FissionCampaignStyle) (notSupport map[string]struct{}, err error) {
	tempM := s.GetDao().FissionTemp
	temp, err := tempM.WithContext(s.Ctx).Where(tempM.ID.Eq(cpn.TemplateID)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

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

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

	// 处理长图数据
	err = s._preLongImgs(conf)
	if err != nil {
		return
	}

	notSupport = make(map[string]struct{}, len(mtype.MarkToLangType))
	for mark := range mtype.MarkToLangType {
		notSupport[mark] = struct{}{}
	}

	s.Res.Langs = make([]*pb.LangsRes_Lang, 0, len(langs)+1)
	var appendLang = func(lang *pb.LangsRes_Lang) {
		s.Res.Langs = append(s.Res.Langs, lang)
		delete(notSupport, lang.LangMark)
	}

	tempMark := mtype.FissionLangTypeToMark[temp.LangType]
	dLang, err := s.dLang(cpn, conf, style, tempMark)
	if err != nil {
		return
	}

	err = s.setReward(cpn, dLang, conf, tempMark, nil)
	if err != nil {
		return
	}

	appendLang(dLang)

	for _, lang := range langs {
		one := s.setLang(cpn, lang)

		err = s.setReward(cpn, one, conf, lang.LangMark, nil)
		if err != nil {
			return
		}

		appendLang(one)
	}

	if verify.InArray[int8](conf.RewardGroup, mtype.FissionRewardGroupNormal, mtype.FissionRewardGroupUserLevel) {
		return
	}

	var spMap = make(map[string]struct{})
	for _, v := range cpn.GetLangTypes() {
		spMap[mtype.FissionLangTypeToMark[v]] = struct{}{}
	}

	for _, mark := range s.ful.GetFirstSupportLang() {
		if _, ok := spMap[mark]; ok {
			continue
		}

		dLang, err = s.dLang(cpn, conf, style, mark)
		if err != nil {
			return
		}

		err = s.setReward(cpn, dLang, conf, mark, nil)
		if err != nil {
			return
		}

		// 待支持的标识
		dLang.Wait = true
		dLang.IsDefault = false

		appendLang(dLang)
	}

	return
}

func (s *Langs) notSupport(cpn *model.FissionCampaign, conf *model.FissionCampaignConfig, style *model.FissionCampaignStyle, notSupport map[string]struct{}) (err error) {
	s.Res.NotSupport = make([]*pb.LangsRes_Lang, 0, len(notSupport))

	rlm := cpn.GetLangMarks()[0]
	var rewards *campaignLangsRewards
	for mark := range notSupport {
		var dLang *pb.LangsRes_Lang
		dLang, err = s.dLang(cpn, conf, style, mark)
		if err != nil {
			return
		}

		dLang.IsDefault = false

		if !verify.InArray(conf.RewardGroup, mtype.FissionRewardGroupLang, mtype.FissionRewardGroupLangAndUserLevel) {
			rlm = mark
		}

		// 找活动对应支持的奖品
		rewards, err = s._getRewards(cpn, conf, rlm)
		if err != nil {
			return
		}

		// 根据模板语言来去翻译数据
		err = s.setReward(cpn, dLang, conf, mark, rewards)
		if err != nil {
			return
		}

		s.Res.NotSupport = append(s.Res.NotSupport, dLang)
	}
	return
}

// 默认语言处理
func (s *Langs) setLang(cpn *model.FissionCampaign, lang *model.FissionCampaignLang) (dLang *pb.LangsRes_Lang) {
	dLang = &pb.LangsRes_Lang{
		HashId:            lang.HashID,
		IsDefault:         false,
		LangMark:          lang.LangMark,
		LangType:          int32(mtype.MarkToLangType[lang.LangMark]),
		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,
		Wait:              false,
		Rewards:           nil,
		RewardsWeb:        nil,
		RewardsExtra:      nil,
		RewardsNewcomer:   nil,
		LongImgs:          nil,
		Cash:              nil,
		TOffset:           lang.TOffset,
		TStart:            cpn.TStart,
		TEnd:              cpn.TEnd,
		QaGroup:           nil,
		TalkText:          nil,
		Gold:              nil,
		Coin:              nil,
		TopicColor:        lang.TopicColor,
		PcBg:              lang.PcBg,
		RuleImg:           lang.RuleImg,
		Schedules:         nil,
	}

	conds, _ := s._getConds(cpn)

	var setCondMap = make(map[int64]*mtype.LangCond)
	for _, v := range lang.GetConds() {
		setCondMap[v.CondId] = v
	}

	for _, cond := range conds {
		one := &pb.LangsRes_Cond{
			CondId:     cond.ID,
			Desc:       cond.Desc,
			OpenJump:   int32(cond.OpenJump),
			WebUrl:     cond.WebURL,
			ExtraParam: cond.ExtraParam,
			PcParam:    cond.PcParam,
			GoText:     cond.GoText,
		}

		if c, ok := setCondMap[cond.ID]; ok {
			one.Desc = c.Desc
			one.WebUrl = c.WebURL
			one.ExtraParam = c.ExtraParam
			one.PcParam = c.PcParam
			one.GoText = c.GoText
		}

		dLang.Conds = append(dLang.Conds, one)
	}

	for _, v := range s.longImgs[lang.ID] {
		one := &pb.LangsRes_LongImg{
			ImgUrl:       v.ImgURL,
			WebUrl:       v.WebURL,
			AppParam:     v.AppParam,
			Id:           v.ID,
			ClickType:    int32(v.ClickType),
			HotZone:      make([]*pb.LangsRes_HotZone, 0, len(s.imgZoneMap[v.ID])),
			TargetType:   int32(v.TargetType),
			TargetId:     v.TargetID,
			PcParam:      v.PcParam,
			LangSourceId: v.LangSourceID,
		}

		for _, zone := range s.imgZoneMap[v.ID] {
			one.HotZone = append(one.HotZone, &pb.LangsRes_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,
				PcParam:    zone.PcParam,
			})
		}

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

	switch cpn.FissionID {
	case consts.IdPrizeQuiz:
		if quit := lang.GetQuit(); quit != nil {
			dLang.Quit = &pb.LangsRes_Quit{
				Title:   quit.Title,
				Options: make([]*pb.LangsRes_Option, 0, len(quit.Options)),
			}

			for _, option := range quit.Options {
				dLang.Quit.Options = append(dLang.Quit.Options, &pb.LangsRes_Option{
					OptionId: option.OptionId,
					Title:    option.Title,
					ImgUrl:   option.ImgUrl,
				})
			}
		}
	case consts.IdQa, consts.IdQaVideo, consts.IdQaAudio:
		if qaGroup := lang.GetQaGroup(); qaGroup != nil {
			var title string
			group, _ := s._getQaGroup(qaGroup.QaGroupId)
			if group != nil {
				title = group.Title
			}

			conf, _ := s._getQaConf(cpn.ID)

			dLang.QaGroup = &pb.LangsRes_QaGroup{
				QaGroupId:    qaGroup.QaGroupId,
				QaNum:        qaGroup.QaNum,
				Title:        title,
				OpenGuide:    int32(conf.OpenGuide),
				GuideGroupId: qaGroup.GuideGroupId,
			}
		}
	case consts.IdPrizeAnswer:

		_, tg, _ := s._tempGroup(cpn.TemplateID)

		if tg.Mark == "answer_tmb" {

			if qaGroup := lang.GetQaGroup(); qaGroup != nil {
				var title string
				group, _ := s._getQaGroup(qaGroup.QaGroupId)
				if group != nil {
					title = group.Title
				}

				conf, _ := s._getQaConf(cpn.ID)

				dLang.QaGroup = &pb.LangsRes_QaGroup{
					QaGroupId:    qaGroup.QaGroupId,
					QaNum:        qaGroup.QaNum,
					Title:        title,
					OpenGuide:    int32(conf.OpenGuide),
					GuideGroupId: qaGroup.GuideGroupId,
				}
			}

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

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

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

	case consts.IdCash:
		if cash := lang.GetCash(); cash != nil {
			dLang.Cash = &pb.LangsRes_Cash{
				Price:    cash.Price,
				Currency: cash.Currency,
			}
		}
	case consts.IdKeep:
		dLang.TalkText = make([]*pb.LangsRes_Talk, 0)

		_ = jsonm.StrUnmarshal(lang.TalkText, &dLang.TalkText)

	case consts.IdCoin:

		var coinConf *model.FissionCampaignCoin
		coinConf, _ = s._getCoinConf(cpn.ID)

		if verify.InArray[int32](mtype.FissionCampaignCoinLackBtnCustom, coinConf.GetLackBtn()...) {
			if coin := lang.GetLangCoin(); coin != nil {
				dLang.Coin = &pb.LangsRes_Coin{
					CustomBtnText:    coin.CustomBtnText,
					CustomWebUrl:     coin.CustomWebUrl,
					CustomExtraParam: coin.CustomExtraParam,
					CustomPcParam:    coin.CustomPcParam,
				}
			} else {
				dLang.Coin = &pb.LangsRes_Coin{
					CustomBtnText:    coinConf.CustomBtnText,
					CustomWebUrl:     coinConf.CustomWebURL,
					CustomExtraParam: coinConf.CustomExtraParam,
					CustomPcParam:    coinConf.CustomPcParam,
				}
			}
		}

	case consts.IdVs:

		langVs := lang.GetVs()
		var langScheduleMap = make(map[int64]*pb.LangsRes_PkTeam, len(langVs))

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

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

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

		vsSchedule, _ := s._getVsSchedule(cpn.ID)
		dLang.Schedules = make([]*pb.LangsRes_Schedule, len(vsSchedule))
		for idx, schedules := range vsSchedule {
			one := &pb.LangsRes_Schedule{
				Id:      idx,
				PkTeams: make([]*pb.LangsRes_PkTeam, 0, len(schedules)),
			}

			for _, schedule := range schedules {
				two := &pb.LangsRes_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.LangsRes_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] == nil || two.Teams[i].Id < 0 {
							two.Teams[i] = team
						}
					}
				}

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

			dLang.Schedules[idx] = one
		}
	case consts.IdUno:
		langUno := lang.GetUno()
		dLang.Uno = &pb.LangsRes_Uno{
			Red:    s._unoCard(mtype.FissionCampaignUnoGroupRed, cpn.ID, langUno.Red),
			Yellow: s._unoCard(mtype.FissionCampaignUnoGroupYellow, cpn.ID, langUno.Yellow),
			Blue:   s._unoCard(mtype.FissionCampaignUnoGroupBlue, cpn.ID, langUno.Blue),
			Green:  s._unoCard(mtype.FissionCampaignUnoGroupGreen, cpn.ID, langUno.Green),
		}
	default:

	}

	return
}

// 默认处理
func (s *Langs) dLang(cpn *model.FissionCampaign, conf *model.FissionCampaignConfig, style *model.FissionCampaignStyle, langMark string) (dLang *pb.LangsRes_Lang, err error) {
	dLang = &pb.LangsRes_Lang{
		HashId:            "",
		IsDefault:         true,
		LangMark:          langMark,
		LangType:          int32(mtype.MarkToLangType[langMark]),
		PageTitle:         style.PageTitle,
		ImageMain:         style.MainImg,
		DownloadPageImage: utils.Ternary[string](style.DownloadImg == "", style.MainImg, style.DownloadImg),
		WechatPageImage:   utils.Ternary[string](style.WechatImg == "", style.MainImg, style.WechatImg),
		ContentImg:        style.BgImg,
		WebBgImg:          style.WechatImg,
		WarmUpImg:         style.WarmUpImg,
		DlBgImg:           style.DownloadImg,
		DlBannerImg:       style.DlBannerImg,
		DlBannerAppLogo:   style.DlBannerAppLogo,
		DlBannerAppName:   style.DlBannerAppName,
		DlBannerAppBtn:    style.DlBannerAppBtn,
		ShareText:         style.ShareText,
		ShareImg:          style.ShareImg,
		Rule:              style.PlayRule,
		Conds:             nil,
		Quit:              nil,
		Questions:         nil,
		Wait:              false,
		Rewards:           nil,
		RewardsWeb:        nil,
		RewardsExtra:      nil,
		RewardsNewcomer:   nil,
		LongImgs:          nil,
		Cash:              nil,
		TOffset:           cpn.TOffset,
		TStart:            cpn.TStart,
		TEnd:              cpn.TEnd,
		QaGroup:           nil,
		TalkText:          nil,
		Gold:              nil,
		Coin:              nil,
		TopicColor:        style.TopicColor,
		PcBg:              style.PcBg,
		RuleImg:           style.RuleImg,
		Schedules:         nil,
	}

	if conf.Option != mtype.FissionCampaignConfigTargetOptionApp {
		var conds []*model.FissionCampaignCond
		conds, err = s._getConds(cpn)
		if err != nil {
			return
		}

		dLang.Conds = make([]*pb.LangsRes_Cond, 0, len(conds))
		for _, v := range conds {
			dLang.Conds = append(dLang.Conds, &pb.LangsRes_Cond{
				CondId:     v.ID,
				Desc:       v.Desc,
				OpenJump:   int32(v.OpenJump),
				WebUrl:     v.WebURL,
				ExtraParam: v.ExtraParam,
				PcParam:    v.PcParam,
				GoText:     v.GoText,
			})
		}
	}

	switch cpn.FissionID {
	case consts.IdPrizeQuiz:
		var prizeQuiz *campaignLangsPrizeQuiz
		prizeQuiz, err = s._getPrizeQuiz(cpn)
		if err != nil {
			return
		}

		dLang.Quit = &pb.LangsRes_Quit{
			Title:   prizeQuiz.quit.Title,
			Options: make([]*pb.LangsRes_Option, 0, len(prizeQuiz.options)),
		}

		for _, v := range prizeQuiz.options {
			dLang.Quit.Options = append(dLang.Quit.Options, &pb.LangsRes_Option{
				OptionId: v.ID,
				Title:    v.Title,
				ImgUrl:   v.ImgURL,
			})
		}
	case consts.IdQa, consts.IdQaVideo, consts.IdQaAudio:
		var qaConf *model.FissionCampaignQa
		qaConf, err = s._getQaConf(cpn.ID)
		if err != nil {
			return
		}

		var qaGroup *model.LibraryQaGroup
		qaGroup, err = s._getDefaultQaGroup(qaConf.QaGroupID)
		if err != nil {
			return
		}

		var guideGroupHashId string
		if qaConf.GuideGroupID > 0 {
			var guideGroup *model.LibraryQaGroup
			guideGroup, err = s._getDefaultQaGroup(qaConf.QaGroupID)
			if err != nil {
				return
			}
			if guideGroup != nil {
				guideGroupHashId = guideGroup.HashID
			}
		}

		dLang.QaGroup = &pb.LangsRes_QaGroup{
			QaGroupId:    qaGroup.HashID,
			QaNum:        qaConf.QaNum,
			Title:        qaGroup.Title,
			OpenGuide:    int32(qaConf.OpenGuide),
			GuideGroupId: guideGroupHashId,
		}
	case consts.IdPrizeAnswer:

		_, tg, _ := s._tempGroup(cpn.TemplateID)

		if tg.Mark == "answer_tmb" {
			var qaConf *model.FissionCampaignQa
			qaConf, err = s._getQaConf(cpn.ID)
			if err != nil {
				return
			}

			var qaGroup *model.LibraryQaGroup
			qaGroup, err = s._getDefaultQaGroup(qaConf.QaGroupID)
			if err != nil {
				return
			}

			var guideGroupHashId string
			if qaConf.GuideGroupID > 0 {
				var guideGroup *model.LibraryQaGroup
				guideGroup, err = s._getDefaultQaGroup(qaConf.QaGroupID)
				if err != nil {
					return
				}
				if guideGroup != nil {
					guideGroupHashId = guideGroup.HashID
				}
			}

			dLang.QaGroup = &pb.LangsRes_QaGroup{
				QaGroupId:    qaGroup.HashID,
				QaNum:        qaConf.QaNum,
				Title:        qaGroup.Title,
				OpenGuide:    int32(qaConf.OpenGuide),
				GuideGroupId: guideGroupHashId,
			}
		} else {
			var prizeAnswer *campaignLangsPrizeAnswer
			prizeAnswer, err = s._getPrizeAnswer(cpn)
			if err != nil {
				return
			}

			dLang.Questions = make([]*pb.LangsRes_Question, 0, len(prizeAnswer.questions))

			for _, v := range prizeAnswer.questions {
				one := &pb.LangsRes_Question{
					QaId:    v.ID,
					Title:   v.Title,
					Options: make([]*pb.LangsRes_Option, 0, len(prizeAnswer.optionMap[v.ID])),
				}

				for _, option := range prizeAnswer.optionMap[v.ID] {
					one.Options = append(one.Options, &pb.LangsRes_Option{
						OptionId: option.ID,
						Title:    option.Title,
					})
				}

				dLang.Questions = append(dLang.Questions, one)
			}
		}

	case consts.IdCash:
		var cashConf *model.FissionCampaignCash
		cashConf, err = s._getCashConf(cpn.ID)
		if err != nil {
			return
		}

		dLang.Cash = &pb.LangsRes_Cash{
			Price:    cashConf.Price,
			Currency: int32(cashConf.Currency),
		}
	case consts.IdKeep:
		var keepConf *model.FissionCampaignKeep
		keepConf, err = s._getKeepConf(cpn.ID)
		if err != nil {
			return
		}

		talks := keepConf.GetKeepTalk()
		dLang.TalkText = make([]*pb.LangsRes_Talk, 0, len(talks))
		for _, v := range talks {
			dLang.TalkText = append(dLang.TalkText, &pb.LangsRes_Talk{
				TextType: v.TextType,
				Content:  v.Content,
			})
		}
	case consts.IdGold:
		var goldConf *model.FissionCampaignGold
		goldConf, err = s._getGoldConf(cpn.ID)
		if err != nil {
			return
		}

		dLang.Gold = &pb.LangsRes_Gold{
			Price:    goldConf.Price,
			Currency: int32(goldConf.Currency),
		}

	case consts.IdCoin:
		var coinConf *model.FissionCampaignCoin
		coinConf, err = s._getCoinConf(cpn.ID)
		if err != nil {
			return
		}

		if verify.InArray[int32](mtype.FissionCampaignCoinLackBtnCustom, coinConf.GetLackBtn()...) {
			dLang.Coin = &pb.LangsRes_Coin{
				CustomBtnText:    coinConf.CustomBtnText,
				CustomWebUrl:     coinConf.CustomWebURL,
				CustomExtraParam: coinConf.CustomExtraParam,
				CustomPcParam:    coinConf.CustomPcParam,
			}
		}
	case consts.IdVs:
		var vsTeam []*model.FissionCampaignVsTeam
		vsTeam, err = s._getVsTeam(cpn.ID)
		if err != nil {
			return
		}

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

		var vsSchedule map[int32][]*model.FissionCampaignVsSchedule
		vsSchedule, err = s._getVsSchedule(cpn.ID)
		if err != nil {
			return
		}

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

			for _, schedule := range schedules {
				two := &pb.LangsRes_PkTeam{
					Id:    schedule.ID,
					Teams: make([]*pb.LangsRes_Team, 0, len(schedule.GetVsTeamIds())),
					VsImg: schedule.VsImg,
					Desc:  schedule.Desc,
				}

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

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

			dLang.Schedules[idx] = one
		}
	case consts.IdUno:
		dLang.Uno = &pb.LangsRes_Uno{
			Red:    s._unoCard(mtype.FissionCampaignUnoGroupRed, cpn.ID, nil),
			Yellow: s._unoCard(mtype.FissionCampaignUnoGroupYellow, cpn.ID, nil),
			Blue:   s._unoCard(mtype.FissionCampaignUnoGroupBlue, cpn.ID, nil),
			Green:  s._unoCard(mtype.FissionCampaignUnoGroupGreen, cpn.ID, nil),
		}
	default:

	}

	dLang.LongImgs = make([]*pb.LangsRes_LongImg, 0, len(s.longImgs[0]))
	for _, v := range s.longImgs[0] {
		one := &pb.LangsRes_LongImg{
			ImgUrl:       v.ImgURL,
			WebUrl:       v.WebURL,
			AppParam:     v.AppParam,
			Id:           v.ID,
			ClickType:    int32(v.ClickType),
			HotZone:      make([]*pb.LangsRes_HotZone, 0, len(s.imgZoneMap[v.ID])),
			TargetType:   int32(v.TargetType),
			TargetId:     v.TargetID,
			PcParam:      v.PcParam,
			LangSourceId: v.ID,
		}

		for _, click := range s.imgZoneMap[v.ID] {
			one.HotZone = append(one.HotZone, &pb.LangsRes_HotZone{
				Id:         click.ID,
				WebUrl:     click.WebURL,
				AppParam:   click.AppParam,
				ClickX:     click.ClickX,
				ClickY:     click.ClickY,
				ClickW:     click.ClickW,
				ClickH:     click.ClickH,
				TargetType: int32(click.TargetType),
				TargetId:   click.TargetID,
				PcParam:    click.PcParam,
			})
		}

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

	return
}

// 设置要返回的奖品信息
func (s *Langs) setReward(cpn *model.FissionCampaign, lang *pb.LangsRes_Lang, conf *model.FissionCampaignConfig, langMark string, rewards *campaignLangsRewards) (err error) {
	if rewards == nil {
		rewards, err = s._getRewards(cpn, conf, langMark)
		if err != nil {
			return
		}
	}

	preward := rewards.preward

	s._appendReward(preward, rewards.webIds, &lang.RewardsWeb, langMark)
	s._appendReward(preward, rewards.extraIds, &lang.RewardsExtra, langMark)
	s._appendReward(preward, rewards.newcomerIds, &lang.RewardsNewcomer, langMark)

	lang.Rewards = &pb.LangsRes_Rewards{
		Normal:        nil,
		UserLevel:     nil,
		Langs:         nil,
		LangUserLevel: nil,
		Country:       nil,
	}

	switch conf.RewardGroup {
	case mtype.FissionRewardGroupNormal:
		s._appendReward(preward, rewards.ids, &lang.Rewards.Normal, langMark)
	case mtype.FissionRewardGroupLang:
		s._appendReward(preward, rewards.ids, &lang.Rewards.Langs, langMark)
	case mtype.FissionRewardGroupUserLevel:
		s._appendUserLevel(preward, rewards.userLevel, &lang.Rewards.UserLevel, langMark)
	case mtype.FissionRewardGroupLangAndUserLevel:
		s._appendUserLevel(preward, rewards.userLevel, &lang.Rewards.LangUserLevel, langMark)
	case mtype.FissionRewardGroupCountry:
		s._appendCountry(preward, rewards.country, &lang.Rewards.Country, langMark)
	}

	return
}

func (s *Langs) _getPrizeQuiz(cpn *model.FissionCampaign) (prizeQuiz *campaignLangsPrizeQuiz, err error) {
	if s.prizeQuiz == nil {
		s.prizeQuiz = &campaignLangsPrizeQuiz{
			quit:    nil,
			options: nil,
		}

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

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

	return s.prizeQuiz, nil
}

func (s *Langs) _getPrizeAnswer(cpn *model.FissionCampaign) (prizeAnswer *campaignLangsPrizeAnswer, err error) {
	if s.prizeAnswer == nil {
		s.prizeAnswer = &campaignLangsPrizeAnswer{
			questions: nil,
			optionMap: make(map[int64][]*model.FissionCampaignQaOption),
		}
		questionM := s.GetDao().FissionCampaignQaQuestion
		s.prizeAnswer.questions, err = questionM.WithContext(s.Ctx).Where(questionM.CampaignID.Eq(cpn.ID), questionM.IsDel.Eq(mtype.No)).Find()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
		var ids []int64
		for _, v := range s.prizeAnswer.questions {
			ids = append(ids, v.ID)
		}

		optionM := s.GetDao().FissionCampaignQaOption
		var options []*model.FissionCampaignQaOption
		options, err = optionM.WithContext(s.Ctx).Where(optionM.QuestionID.In(ids...), optionM.IsDel.Eq(mtype.No)).Order(optionM.ID).Find()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		for _, v := range options {
			s.prizeAnswer.optionMap[v.QuestionID] = append(s.prizeAnswer.optionMap[v.QuestionID], v)
		}
	}

	return s.prizeAnswer, nil
}

func (s *Langs) _getConds(cpn *model.FissionCampaign) (conds []*model.FissionCampaignCond, err error) {
	if s.conds == nil {
		condM := s.GetDao().FissionCampaignCond
		s.conds, err = condM.WithContext(s.Ctx).Where(condM.CampaignID.Eq(cpn.ID), condM.IsDel.Eq(mtype.No)).Find()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		s.condMap = make(map[int64]*model.FissionCampaignCond, len(s.conds))
		for _, cond := range s.conds {
			s.condMap[cond.ID] = cond
		}

	}

	return s.conds, nil
}

func (s *Langs) _getRewards(cpn *model.FissionCampaign, conf *model.FissionCampaignConfig, langMark string) (rewards *campaignLangsRewards, err error) {

	if _, ok := s.rewards[langMark]; ok {
		return s.rewards[langMark], nil
	}

	rewards = &campaignLangsRewards{
		webIds:      nil,
		extraIds:    nil,
		newcomerIds: nil,
		ids:         nil,
		preward:     nil,
	}

	list, prewards, err := s._getRewardData(cpn)
	if err != nil {
		return
	}

	var appList []*model.FissionCampaignReward
	for _, v := range list {
		switch v.RewardType {
		case mtype.FissionCampaignRewardTypeExtra:
			rewards.extraIds = append(rewards.extraIds, v.RewardID)
		case mtype.FissionCampaignRewardTypeNewcomer:
			rewards.newcomerIds = append(rewards.newcomerIds, v.RewardID)
		case mtype.FissionCampaignRewardTypeWeb:
			rewards.webIds = append(rewards.webIds, v.RewardID)
		case mtype.FissionCampaignRewardTypeApp:
			appList = append(appList, v)
		}
	}

	switch conf.RewardGroup {
	case mtype.FissionRewardGroupNormal:
		rewards.ids = s._rewardIds(appList, nil)
	case mtype.FissionRewardGroupLang:
		mark, _ := s.ful.Lang().Selected(langMark)
		rewards.ids = s._rewardIds(appList, func(lang string) bool { return lang == mark })
	case mtype.FissionRewardGroupUserLevel:
		rewards.userLevel = s._addUserLevel(appList, nil)
	case mtype.FissionRewardGroupLangAndUserLevel:
		mark, _ := s.ful.LangLevel().GetLang(langMark)
		rewards.userLevel = s._addUserLevel(appList, func(lang string) bool { return lang == mark })
	case mtype.FissionRewardGroupCountry:
		rewards.country = s._addCountry(appList, nil)
	}

	rewards.preward = prewards

	s.rewards[langMark] = rewards

	return
}

func (s *Langs) _rewardIds(appList []*model.FissionCampaignReward, langOk func(lang string) bool) (ids []int64) {
	ids = make([]int64, 0, len(appList))
	for _, v := range appList {
		if langOk != nil && !langOk(v.LangMark) {
			continue
		}
		ids = append(ids, v.RewardID)
	}
	return
}

func (s *Langs) _addUserLevel(appList []*model.FissionCampaignReward, langOk func(lang string) bool) (userLevel []*campaignLangsLevelIds) {
	var idx int
	var levelIdx = make(map[int64]int)
	var levelIds []int64

	for _, v := range appList {
		if langOk != nil && !langOk(v.LangMark) {
			continue
		}

		if lidx, ok := levelIdx[v.LevelID]; ok {
			userLevel[lidx].ids = append(userLevel[lidx].ids, v.RewardID)
		} else {
			userLevel = append(userLevel, &campaignLangsLevelIds{
				LevelId: v.LevelID,
				ids:     []int64{v.RewardID},
			})
			levelIdx[v.LevelID] = idx
			idx++
			levelIds = append(levelIds, v.LevelID)
		}
	}

	if len(levelIds) == 0 {
		return
	}

	levelM := s.GetDao().FissionUserLevel
	levelList, err := levelM.WithContext(s.Ctx).Where(levelM.ID.In(levelIds...)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	s.levelMap = make(map[int64]string, len(levelList))
	for _, v := range levelList {
		s.levelMap[v.ID] = v.Title
	}

	return
}

func (s *Langs) _appendReward(preward *provider.Rewards, ids []int64, out *[]*pb.LangsRes_Reward, langMark string) {
	*out = make([]*pb.LangsRes_Reward, 0, len(ids))
	inMap, _ := preward.InfoMap(ids...)

	for _, rewardId := range ids {
		reward, ok := inMap[rewardId]
		if !ok && reward == nil {
			continue
		}

		one := &pb.LangsRes_Reward{
			RewardId:    reward.Id,
			Title:       "",
			ImgUrl:      "",
			FindDefault: false,
		}

		langInfo := preward.AutoLang(rewardId, langMark)
		one.Title, one.ImgUrl, one.FindDefault = langInfo.Title, langInfo.ImgUrl, langInfo.FindDefault

		*out = append(*out, one)
	}
}

func (s *Langs) _appendUserLevel(preward *provider.Rewards, levelIds []*campaignLangsLevelIds, out *[]*pb.LangsRes_UserLevelOne, langMark string) {
	*out = make([]*pb.LangsRes_UserLevelOne, 0, len(levelIds))
	for _, v := range levelIds {
		one := &pb.LangsRes_UserLevelOne{
			LevelId:    v.LevelId,
			LevelTitle: s.levelMap[v.LevelId],
			Rewards:    nil,
		}
		s._appendReward(preward, v.ids, &one.Rewards, langMark)
		*out = append(*out, one)
	}
}

func (s *Langs) _appendCountry(preward *provider.Rewards, countryMarks []*campaignLangsCountryMarks, out *[]*pb.LangsRes_CountryOne, langMark string) {
	*out = make([]*pb.LangsRes_CountryOne, 0, len(countryMarks))
	for _, v := range countryMarks {
		one := &pb.LangsRes_CountryOne{
			CountryMark: v.countryMark,
			Rewards:     nil,
		}
		s._appendReward(preward, v.ids, &one.Rewards, langMark)
		*out = append(*out, one)
	}
}

func (s *Langs) _addCountry(appList []*model.FissionCampaignReward, langOk func(lang string) bool) (country []*campaignLangsCountryMarks) {
	var idx int
	var countryIdx = make(map[string]int)

	for _, v := range appList {
		if langOk != nil && !langOk(v.LangMark) {
			continue
		}

		if lidx, ok := countryIdx[v.CountryMark]; ok {
			country[lidx].ids = append(country[lidx].ids, v.RewardID)
		} else {
			country = append(country, &campaignLangsCountryMarks{
				countryMark: v.CountryMark,
				ids:         []int64{v.RewardID},
			})
			countryIdx[v.CountryMark] = idx
			idx++
		}
	}

	return
}

func (s *Langs) _getRewardData(cpn *model.FissionCampaign) (list []*model.FissionCampaignReward, prewards *provider.Rewards, err error) {
	if len(s.rewardData.rewardList) == 0 {
		m := s.GetDao().FissionCampaignReward
		s.rewardData.rewardList, 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)
		}

		var idMap = make(map[int64]struct{})
		var ids []int64

		for _, v := range list {
			if _, ok := idMap[v.RewardID]; !ok {
				ids = append(ids, v.RewardID)
			}
		}

		s.rewardData.prewards, err = provider.NewRewards(s.Ctx, cpn.ProjectID, ids...)
		if err != nil {
			return
		}

	}

	return s.rewardData.rewardList, s.rewardData.prewards, nil
}

func (s *Langs) _preLongImgs(conf *model.FissionCampaignConfig) (err error) {
	if conf.HasLongImg == mtype.No {
		return
	}

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

	s.longImgs = make(map[int64][]*model.FissionCampaignLongImg)

	var imgZoneIds []int64
	for _, v := range imgs {
		if v.ClickType == mtype.FissionCampaignLongImgClickTypeZone {
			imgZoneIds = append(imgZoneIds, v.ID)
		}
		s.longImgs[v.LangID] = append(s.longImgs[v.LangID], v)
	}

	s.imgZoneMap = make(map[int64][]*model.FissionCampaignLongImgZone)

	if len(imgZoneIds) == 0 {
		return
	}

	zoneM := s.GetDao().FissionCampaignLongImgZone
	zones, err := zoneM.WithContext(s.Ctx).Where(zoneM.ImgID.In(imgZoneIds...), zoneM.IsDel.Eq(mtype.No)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	for _, v := range zones {
		s.imgZoneMap[v.ImgID] = append(s.imgZoneMap[v.ImgID], v)
	}

	return
}

func (s *Langs) _getCashConf(cpnId int64) (cashConf *model.FissionCampaignCash, err error) {
	if s.cashConf == nil {
		s.cashConf, err = cache.NewCampaignCash(s.Ctx).FindByCampaignId(cpnId)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	return s.cashConf, nil
}

func (s *Langs) _getGoldConf(cpnId int64) (cashConf *model.FissionCampaignGold, err error) {
	if s.goldConf == nil {
		s.goldConf, err = cache.NewCampaignGold(s.Ctx).FindByCampaignId(cpnId)
		if err != nil {
			err = s.BE().CacheError(err)
			return
		}
	}

	return s.goldConf, nil
}

func (s *Langs) _getCoinConf(cpnId int64) (cashConf *model.FissionCampaignCoin, err error) {
	if s.coinConf == nil {
		s.coinConf, err = cache.NewCampaignCoin(s.Ctx).FindByCampaignId(cpnId)
		if err != nil {
			err = s.BE().CacheError(err)
			return
		}
	}

	return s.coinConf, nil
}

func (s *Langs) _getQaConf(cpnId int64) (qaConf *model.FissionCampaignQa, err error) {
	if s.qaConf == nil {
		m := s.GetDao().FissionCampaignQa
		s.qaConf, err = m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpnId)).Take()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	return s.qaConf, nil
}

func (s *Langs) _getQaGroup(qaGroupHashId string) (qaGroup *model.LibraryQaGroup, err error) {
	if s.qaGroup[qaGroupHashId] == nil {
		m := s.GetDao().LibraryQaGroup
		s.qaGroup[qaGroupHashId], err = m.WithContext(s.Ctx).Where(m.HashID.Eq(qaGroupHashId)).Take()
		if err = dbcheck.DbError(err); err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	return s.qaGroup[qaGroupHashId], nil
}

func (s *Langs) _getDefaultQaGroup(qaGroupId int64) (qaGroup *model.LibraryQaGroup, err error) {
	if s.defaultQaGroup == nil {
		m := s.GetDao().LibraryQaGroup
		s.defaultQaGroup, err = m.WithContext(s.Ctx).Where(m.ID.Eq(qaGroupId)).Take()
		if err = dbcheck.DbError(err); err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	return s.defaultQaGroup, nil
}

func (s *Langs) _getKeepConf(cpnId int64) (qaConf *model.FissionCampaignKeep, err error) {
	if s.keepConf == nil {
		m := s.GetDao().FissionCampaignKeep
		s.keepConf, err = m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpnId)).Take()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	return s.keepConf, nil
}

func (s *Langs) _getVsTeam(cpnId int64) (teams []*model.FissionCampaignVsTeam, err error) {
	if len(s.vsTeam) == 0 {
		m := s.GetDao().FissionCampaignVsTeam
		s.vsTeam, err = m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpnId)).Find()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	return s.vsTeam, nil
}

func (s *Langs) _getVsSchedule(cpnId int64) (data map[int32][]*model.FissionCampaignVsSchedule, err error) {
	if s.vsSchedule == nil {
		m := s.GetDao().FissionCampaignVsSchedule
		var list []*model.FissionCampaignVsSchedule
		list, err = m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpnId)).Find()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

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

	return s.vsSchedule, nil
}

func (s *Langs) _getUnoCard(mark string, cpnId int64) (data []*model.FissionCampaignUnoCard, err error) {
	if s.unoCardMap == nil {
		s.unoCardMap = make(map[string][]*model.FissionCampaignUnoCard)

		cardM := s.GetDao().FissionCampaignUnoCard
		var cards []*model.FissionCampaignUnoCard
		cards, err = cardM.WithContext(s.Ctx).Where(cardM.CampaignID.Eq(cpnId)).Find()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		for _, v := range cards {
			s.unoCardMap[v.Mark] = append(s.unoCardMap[v.Mark], v)
		}
	}

	return s.unoCardMap[mark], nil
}

func (s *Langs) _unoCard(mark string, cpnId int64, langCards []*mtype.UnoCard) []*pb.LangsRes_UnoCard {
	var langMap = make(map[int32]*mtype.UnoCard, len(langCards))
	for _, v := range langCards {
		langMap[v.CardNo] = v
	}

	cards, _ := s._getUnoCard(mark, cpnId)

	data := make([]*pb.LangsRes_UnoCard, 0, len(cards))
	for _, card := range cards {
		one := &pb.LangsRes_UnoCard{
			Id:       card.ID,
			Title:    card.Title,
			ImgUrl:   card.ImgURL,
			WebUrl:   card.WebURL,
			AppParam: card.AppParam,
			PcParam:  card.PcParam,
		}

		if lang, ok := langMap[card.CardNo]; ok {
			one.Title = lang.Title
			one.ImgUrl = lang.ImgURL
			one.WebUrl = lang.WebURL
			one.AppParam = lang.AppParam
			one.PcParam = lang.PcParam
		}

		data = append(data, one)
	}

	return data
}

func (s *Langs) _tempGroup(tempId int64) (temp *model.FissionTemp, group *model.FissionTempGroup, err error) {
	if s.temp == nil || s.group == nil {

		s.temp, err = cache.NewFissionTemp(s.Ctx).FindById(tempId)
		if err != nil {
			err = s.BE().CacheError(err)
			return
		}

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

	return s.temp, s.group, nil
}