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

package campaign

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

type ShowReward struct {
	logic.Logic
	Req     *pb.ShowRewardReq
	Res     *pb.ShowRewardRes
	helpMap map[int64][]*model.FissionCampaignTask
}

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

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

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

	return
}

func (s *ShowReward) cpn() (cpn *model.FissionCampaign, conf *model.FissionCampaignConfig, err error) {
	cpn, err = finder.Campaign(s.Ctx, s.Req.GetCampaignId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}
	if cpn == nil {
		err = workerr.NotFound("not found campaign")
		return
	}

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

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

	return
}

func (s *ShowReward) set(cpn *model.FissionCampaign, conf *model.FissionCampaignConfig) (err error) {
	m := s.GetDao().FissionCampaignReward
	list, err := m.WithContext(s.Ctx).
		Where(m.CampaignID.Eq(cpn.ID), m.IsDel.Eq(mtype.No)).
		Order(m.Step, m.Sort, m.ID).
		Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var groupMap = make(map[int8][]*model.FissionCampaignReward)
	var rewardIds []int64
	var rewardMap = make(map[int64]*provider.RewardInfo)
	for _, v := range list {
		if _, ok := rewardMap[v.RewardID]; !ok {
			rewardIds = append(rewardIds, v.RewardID)
			rewardMap[v.RewardID] = nil
		}
		groupMap[v.RewardType] = append(groupMap[v.RewardType], v)
	}

	preward, err := provider.NewRewards(s.Ctx, cpn.ProjectID, rewardIds...)
	if err != nil {
		return
	}

	// 获取活动对应的用户等级和用户的语言
	uct, err := cmm.NewCMM(s.Ctx, s.GetDao()).UserCampaignType(cpn, conf, s.Req.GetLangMark(), s.Req.GetLevelMark(), s.Req.GetCountryMark())
	if err != nil {
		return
	}

	showLang := s.Req.GetShowLang()
	s.add(&s.Res.RewardsWeb, groupMap[mtype.FissionCampaignRewardTypeWeb], preward, showLang, nil)
	s.add(&s.Res.RewardsExtra, groupMap[mtype.FissionCampaignRewardTypeExtra], preward, showLang, nil)
	s.add(&s.Res.RewardsNewcomer, groupMap[mtype.FissionCampaignRewardTypeNewcomer], preward, showLang, nil)

	var ok addOk
	switch conf.RewardGroup {
	case mtype.FissionRewardGroupUserLevel:
		ok = func(langMark string, levelId int64, countryMark string) bool { return levelId == uct.LevelId }
	case mtype.FissionRewardGroupLang:
		ok = func(langMark string, levelId int64, countryMark string) bool { return langMark == uct.LangMark }
	case mtype.FissionRewardGroupLangAndUserLevel:
		ok = func(langMark string, levelId int64, countryMark string) bool {
			return langMark == uct.LangMark && levelId == uct.LevelId
		}
	case mtype.FissionRewardGroupCountry:
		ok = func(langMark string, levelId int64, countryMark string) bool { return countryMark == uct.CountryMark }
	}

	s.add(&s.Res.Rewards, groupMap[mtype.FissionCampaignRewardTypeApp], preward, showLang, ok)

	return
}

type addOk func(langMark string, levelId int64, countryMark string) bool

func (s *ShowReward) add(outList *[]*pb.ShowRewardRes_Reward, inList []*model.FissionCampaignReward, preward *provider.Rewards, langMark string, ok addOk) {
	*outList = make([]*pb.ShowRewardRes_Reward, 0, len(inList))
	for _, v := range inList {

		if ok != nil && !ok(v.LangMark, v.LevelID, v.CountryMark) {
			continue
		}

		one := &pb.ShowRewardRes_Reward{
			Id:                v.ID,
			Title:             "",
			ImgUrl:            "",
			Stock:             v.Stock,
			InviteNum:         v.InviteNum,
			RewardNum:         v.RewardNum,
			IsThank:           int32(v.IsThank),
			Score:             v.Score,
			SignDay:           v.SignDay,
			CollectNum:        v.CollectNum,
			IsSuper:           int32(v.IsSuper),
			ReceiveType:       0,
			KvData:            nil,
			Contact:           "",
			Url:               "",
			Help:              0,
			HelpPercent:       0,
			Click:             0,
			ClickPercent:      0,
			ClickPercentLimit: 0,
			Open:              0,
			OpenPercent:       0,
			OpenPercentLimit:  0,
			JumpUrl:           v.JumpURL,
			RewardId:          v.RewardID,
		}

		info, _ := preward.InfoAutoLang(v.RewardID, langMark)
		one.ReceiveType = info.ReceiveType
		one.Contact = info.Contact
		one.Url = info.Url
		one.KvData = make([]*pb.ShowRewardRes_KV, 0, len(info.KvData))
		for _, kv := range info.KvData {
			one.KvData = append(one.KvData, &pb.ShowRewardRes_KV{
				Key:   kv.Key,
				Value: kv.Value,
			})
		}
		one.Title = info.Title
		one.ImgUrl = info.ImgUrl

		for _, help := range s.helpMap[v.ID] {
			switch help.TaskType {
			case mtype.FissionCampaignTaskTypeInstall:
				one.Help = mtype.Yes
				one.HelpPercent = help.Percent
			case mtype.FissionCampaignTaskTypeOpen:
				one.Open = mtype.Yes
				one.OpenPercent = help.Percent
				one.OpenPercentLimit = help.PercentLimit
			case mtype.FissionCampaignTaskTypeClick:
				one.Click = mtype.Yes
				one.ClickPercent = help.Percent
				one.ClickPercentLimit = help.PercentLimit
			case mtype.FissionCampaignTaskTypeRegister:
				one.Register = mtype.Yes
				one.RegisterPercent = help.Percent
			}
		}

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

func (s *ShowReward) _helpMap(cpn *model.FissionCampaign) (err error) {
	var helpMap = make(map[int64][]*model.FissionCampaignTask)

	defer func() {
		s.helpMap = helpMap
	}()

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

	taskM := s.GetDao().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 _, v := range tasks {
		rewardId := utils.FissionCampaignTaskMarkRewardOneRewardId(v.TaskMark)
		helpMap[rewardId] = append(helpMap[rewardId], v)
	}

	return
}