joybuywork/internal/service/containers/campaignuser/mall_list.go

package campaignuser

import (
	"joybuywork/internal/consts"
	"joybuywork/internal/plugins/jsonm"
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/finder"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/service/provider"
	"joybuywork/internal/service/provider/malls"
	"joybuywork/internal/service/provider/stocks"
	"joybuywork/internal/utils/logic"
	pb "joybuywork/proto/go_proto/w_campaign_user"
	"joybuywork/proto/go_proto/workerr"
	"time"
)

type MallList struct {
	logic.Logic

	Req *pb.MallListReq
	Res *pb.MallListRes
}

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

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

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

	mallId, err := s.getMallId(cpn)
	if err != nil {
		return
	}

	return s.list(mallId, user.LangMark)
}

func (s *MallList) user() (cpn *model.FissionCampaign, user *model.FissionUser, err error) {
	cpn, err = finder.Campaign(s.Ctx, s.Req.GetCampaignId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

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

	user, err = finder.FissionUser(s.Ctx, cpn.ID, s.Req.GetUserId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if user == nil {
		err = workerr.UnauthorizedError
		return
	}

	return
}

func (s *MallList) list(mallId int64, langMark string) (err error) {
	mall, err := malls.NewMall(s.Ctx, mallId)
	if err != nil {
		return
	}

	list, err := mall.UpItems()
	if err != nil {
		return
	}

	var showList []*model.RedeemMallItem
	for _, v := range list {
		if v.IsShow() {
			showList = append(showList, v)
		}
	}

	var rewardMap = make(map[int64]struct{})
	var rewardIds []int64
	var ids []int64
	for _, v := range showList {
		ids = append(ids, v.ID)
		if _, ok := rewardMap[v.ID]; !ok {
			rewardMap[v.RewardID] = struct{}{}
			rewardIds = append(rewardIds, v.RewardID)
		}
	}

	useStockMap, err := s._useStock(ids)
	if err != nil {
		return
	}

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

	s.Res.List = make([]*pb.MallListRes_One, 0, len(showList))

	for _, v := range showList {
		info, _ := preward.InfoAutoLang(v.RewardID, langMark)
		s.Res.List = append(s.Res.List, &pb.MallListRes_One{
			Id:       v.ID,
			RewardId: v.RewardID,
			Title:    info.Title,
			ImgUrl:   info.ImgUrl,
			Remain:   v.Stock - useStockMap[v.ID],
			Status:   v.GetStatus(),
			UpRemain: v.UpAt - time.Now().Unix(),
			CoinNum:  v.CoinNum,
		})
	}

	return
}

func (s *MallList) _useStock(ids []int64) (data map[int64]int64, err error) {
	data = make(map[int64]int64)
	if len(ids) == 0 {
		return
	}

	stock, err := stocks.NewMallItem(s.Ctx, ids...)
	if err != nil {
		return
	}

	data, err = stock.AllUseStock()
	if err != nil {
		return
	}

	return
}

func (s *MallList) getMallId(cpn *model.FissionCampaign) (mallId int64, err error) {
	switch cpn.FissionID {
	case consts.IdVs:
		conf, err1 := cache.NewCampaignVs(s.Ctx).FindByCampaignId(cpn.ID)
		if err1 != nil {
			err = s.BE().CacheError(err1)
			return
		}
		mallId = conf.MallID
	}

	return
}