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

package campaign

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

type ChildShow struct {
	logic.Logic
	Req *pb.ChildShowReq
	Res *pb.ChildShowRes

	ruleMap map[int64]*model.FissionCampaignRewardRule
}

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

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

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

	return
}

func (s *ChildShow) setCampaign() (cpn *model.FissionCampaign, err error) {
	cpn, err = finder.Campaign(s.Ctx, s.Req.GetId(), s.Req.GetHashId())
	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
	}

	s.AddAfterRun(func() (err error) {
		s.Res.Title = cpn.Title
		s.Res.ChildType = int32(cpn.ChildType)
		s.Res.FissionId = cpn.FissionID
		s.Res.TStart = cpn.TStart
		s.Res.TEnd = cpn.TEnd
		s.Res.PlayType = int32(conf.PlayType)

		return
	})

	return
}

func (s *ChildShow) setRewards(cpn *model.FissionCampaign) (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.Sort).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if len(list) == 0 {
		return
	}

	s.Res.Rewards = make([]*pb.ChildShowRes_Reward, 0, len(list))

	var rewardIds []int64
	for _, v := range list {
		rewardIds = append(rewardIds, v.RewardID)
	}

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

	var langMark string
	if cpn.Pid > 0 {
		var pcpn *model.FissionCampaign
		pcpn, err = cache.NewCampaign(s.Ctx).FindById(cpn.Pid)
		if err != nil {
			err = s.BE().CacheError(err)
			return
		}

		langMark = mtype.FissionLangTypeToMark[pcpn.GetLangTypes()[0]]
	}

	for _, v := range list {
		one := &pb.ChildShowRes_Reward{
			Id:                v.ID,
			RewardId:          v.RewardID,
			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),
			KvData:            nil,
			Title:             "",
			ImgUrl:            "",
			ReceiveType:       0,
			Contact:           "",
			Url:               "",
			Help:              0,
			HelpPercent:       0,
			Click:             0,
			ClickPercent:      0,
			ClickPercentLimit: 0,
			Open:              0,
			OpenPercent:       0,
			OpenPercentLimit:  0,
			LangMark:          "",
			Odds:              v.Odds,
			JumpUrl:           v.JumpURL,
			FormTitle:         "",
			CampaignLimit:     0,
			Register:          0,
			RegisterPercent:   0,
			InitPercent:       v.InitPercent,
			PropMark:          v.PropMark,
		}
		info, _ := preward.InfoAutoLang(v.RewardID, langMark)

		one.ReceiveType = info.ReceiveType
		one.Contact = info.Contact
		one.Url = info.Url
		one.FormTitle = info.FormTitle

		for _, kv := range info.KvData {
			one.KvData = append(one.KvData, &pb.ChildShowRes_KV{
				Key:   kv.Key,
				Value: kv.Value,
			})
		}

		one.Title, one.ImgUrl, one.LangMark = info.Title, info.ImgUrl, info.Mark

		if rule, ok := s.ruleMap[v.ID]; ok {
			one.CampaignLimit = rule.CampaignLimit
		}

		s.Res.Rewards = append(s.Res.Rewards, one)
	}

	return
}

func (s *ChildShow) _ruleMap(cpn *model.FissionCampaign) (err error) {
	ruleM := s.GetDao().FissionCampaignRewardRule
	rules, err := ruleM.WithContext(s.Ctx).Where(ruleM.CampaignID.Eq(cpn.ID)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

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

	s.ruleMap = ruleMap

	return
}