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

package campaignuser

import (
	"joybuywork/internal/app"
	"joybuywork/internal/consts"
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/finder"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/utils"
	"joybuywork/internal/utils/logic"

	pb "joybuywork/proto/go_proto/w_campaign_user"
)

type LotteryLog struct {
	logic.Logic
	Req *pb.LotteryLogReq
	Res *pb.LotteryLogRes
}

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

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

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

	return
}

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

	return
}

func (s *LotteryLog) list(cpn *model.FissionCampaign) (err error) {
	switch cpn.FissionID {
	case consts.IdPrizeWheel:
		return s.wheel(cpn)
	case consts.IdFlip:
		return s.flip(cpn)
	case consts.IdBlindBox:
		return s.blind(cpn)
	case consts.IdLuckyGrid:
		return s.grid(cpn)
	case consts.IdSlotMachine:
		return s.slot(cpn)
	case consts.IdGashapon:
		return s.gashapon(cpn)
	}

	return
}

func (s *LotteryLog) gashapon(cpn *model.FissionCampaign) (err error) {
	m := s.GetDao().FissionGashaponLog
	var list []*model.FissionGashaponLog
	total, err := s._find(m.TableName(), cpn.ID, &list)
	if err != nil || total == 0 {
		return
	}

	s.Res.Total = total

	var taskIds, rewardIds []int64
	for _, v := range list {
		val := v.GetVal()
		switch v.Source {
		case mtype.FissionLogSourceLottery:
			rewardIds = append(rewardIds, val.RewardId)
		case mtype.FissionLogSourceCondOne, mtype.FissionLogSourceManualCondOne:
			taskIds = append(taskIds, val.TaskId)
		}
	}

	taskTitle, err := s._taskTitle(taskIds)
	if err != nil {
		return
	}

	rewardTitle, err := s._rewardTitle(rewardIds)
	if err != nil {
		return
	}

	for _, v := range list {
		val := v.GetVal()
		s.Res.List = append(s.Res.List, &pb.LotteryLogRes_One{
			Id:           v.ID,
			CreatedAt:    v.CreatedAt,
			Type:         int32(v.Type),
			Source:       v.Source,
			TaskTitle:    taskTitle[val.TaskId],
			RewardTitle:  rewardTitle[val.RewardId],
			Chance:       val.Chance,
			PointsUseNum: val.PointsNum,
		})
	}

	return
}

func (s *LotteryLog) slot(cpn *model.FissionCampaign) (err error) {
	m := s.GetDao().FissionSlotLog
	var list []*model.FissionSlotLog
	total, err := s._find(m.TableName(), cpn.ID, &list)
	if err != nil || total == 0 {
		return
	}

	s.Res.Total = total

	var taskIds, rewardIds []int64
	for _, v := range list {
		val := v.GetVal()
		switch v.Source {
		case mtype.FissionLogSourceLottery:
			rewardIds = append(rewardIds, val.RewardId)
		case mtype.FissionLogSourceCondOne, mtype.FissionLogSourceManualCondOne:
			taskIds = append(taskIds, val.TaskId)
		}
	}
	for _, v := range list {
		val := v.GetVal()
		switch v.Source {
		case mtype.FissionLogSourceLottery:
			rewardIds = append(rewardIds, val.RewardId)
		case mtype.FissionLogSourceCondOne, mtype.FissionLogSourceManualCondOne:
			taskIds = append(taskIds, val.TaskId)
		}
	}

	taskTitle, err := s._taskTitle(taskIds)
	if err != nil {
		return
	}

	rewardTitle, err := s._rewardTitle(rewardIds)
	if err != nil {
		return
	}

	for _, v := range list {
		val := v.GetVal()
		s.Res.List = append(s.Res.List, &pb.LotteryLogRes_One{
			Id:           v.ID,
			CreatedAt:    v.CreatedAt,
			Type:         int32(v.Type),
			Source:       v.Source,
			TaskTitle:    taskTitle[val.TaskId],
			RewardTitle:  rewardTitle[val.RewardId],
			Chance:       val.Chance,
			PointsUseNum: val.PointsNum,
		})
	}

	return
}

func (s *LotteryLog) grid(cpn *model.FissionCampaign) (err error) {
	m := s.GetDao().FissionGridLog
	var list []*model.FissionGridLog
	total, err := s._find(m.TableName(), cpn.ID, &list)
	if err != nil || total == 0 {
		return
	}

	s.Res.Total = total

	var taskIds, rewardIds []int64
	for _, v := range list {
		val := v.GetVal()
		switch v.Source {
		case mtype.FissionLogSourceLottery:
			rewardIds = append(rewardIds, val.RewardId)
		case mtype.FissionLogSourceCondOne, mtype.FissionLogSourceManualCondOne:
			taskIds = append(taskIds, val.TaskId)
		}
	}
	for _, v := range list {
		val := v.GetVal()
		switch v.Source {
		case mtype.FissionLogSourceLottery:
			rewardIds = append(rewardIds, val.RewardId)
		case mtype.FissionLogSourceCondOne, mtype.FissionLogSourceManualCondOne:
			taskIds = append(taskIds, val.TaskId)
		}
	}

	taskTitle, err := s._taskTitle(taskIds)
	if err != nil {
		return
	}

	rewardTitle, err := s._rewardTitle(rewardIds)
	if err != nil {
		return
	}

	for _, v := range list {
		val := v.GetVal()
		s.Res.List = append(s.Res.List, &pb.LotteryLogRes_One{
			Id:           v.ID,
			CreatedAt:    v.CreatedAt,
			Type:         int32(v.Type),
			Source:       v.Source,
			TaskTitle:    taskTitle[val.TaskId],
			RewardTitle:  rewardTitle[val.RewardId],
			Chance:       val.Chance,
			PointsUseNum: val.PointsNum,
		})
	}

	return
}

func (s *LotteryLog) blind(cpn *model.FissionCampaign) (err error) {
	m := s.GetDao().FissionBlindLog
	var list []*model.FissionBlindLog
	total, err := s._find(m.TableName(), cpn.ID, &list)
	if err != nil || total == 0 {
		return
	}

	s.Res.Total = total

	var taskIds, rewardIds []int64
	for _, v := range list {
		val := v.GetVal()
		switch v.Source {
		case mtype.FissionLogSourceLottery:
			rewardIds = append(rewardIds, val.RewardId)
		case mtype.FissionLogSourceCondOne, mtype.FissionLogSourceManualCondOne:
			taskIds = append(taskIds, val.TaskId)
		}
	}
	for _, v := range list {
		val := v.GetVal()
		switch v.Source {
		case mtype.FissionLogSourceLottery:
			rewardIds = append(rewardIds, val.RewardId)
		case mtype.FissionLogSourceCondOne, mtype.FissionLogSourceManualCondOne:
			taskIds = append(taskIds, val.TaskId)
		}
	}

	taskTitle, err := s._taskTitle(taskIds)
	if err != nil {
		return
	}

	rewardTitle, err := s._rewardTitle(rewardIds)
	if err != nil {
		return
	}

	for _, v := range list {
		val := v.GetVal()
		s.Res.List = append(s.Res.List, &pb.LotteryLogRes_One{
			Id:           v.ID,
			CreatedAt:    v.CreatedAt,
			Type:         int32(v.Type),
			Source:       v.Source,
			TaskTitle:    taskTitle[val.TaskId],
			RewardTitle:  rewardTitle[val.RewardId],
			Chance:       val.Chance,
			PointsUseNum: val.PointsNum,
		})
	}

	return
}

func (s *LotteryLog) flip(cpn *model.FissionCampaign) (err error) {
	m := s.GetDao().FissionFlipLog
	var list []*model.FissionFlipLog
	total, err := s._find(m.TableName(), cpn.ID, &list)
	if err != nil || total == 0 {
		return
	}

	s.Res.Total = total

	var taskIds, rewardIds []int64
	for _, v := range list {
		val := v.GetVal()
		switch v.Source {
		case mtype.FissionLogSourceLottery:
			rewardIds = append(rewardIds, val.RewardId)
		case mtype.FissionLogSourceCondOne, mtype.FissionLogSourceManualCondOne:
			taskIds = append(taskIds, val.TaskId)
		}
	}
	for _, v := range list {
		val := v.GetVal()
		switch v.Source {
		case mtype.FissionLogSourceLottery:
			rewardIds = append(rewardIds, val.RewardId)
		case mtype.FissionLogSourceCondOne, mtype.FissionLogSourceManualCondOne:
			taskIds = append(taskIds, val.TaskId)
		}
	}

	taskTitle, err := s._taskTitle(taskIds)
	if err != nil {
		return
	}

	rewardTitle, err := s._rewardTitle(rewardIds)
	if err != nil {
		return
	}

	for _, v := range list {
		val := v.GetVal()
		s.Res.List = append(s.Res.List, &pb.LotteryLogRes_One{
			Id:           v.ID,
			CreatedAt:    v.CreatedAt,
			Type:         int32(v.Type),
			Source:       v.Source,
			TaskTitle:    taskTitle[val.TaskId],
			RewardTitle:  rewardTitle[val.RewardId],
			Chance:       val.Chance,
			PointsUseNum: val.PointsNum,
		})
	}

	return
}

func (s *LotteryLog) wheel(cpn *model.FissionCampaign) (err error) {
	m := s.GetDao().FissionPrizeWheelLog
	var list []*model.FissionPrizeWheelLog
	total, err := s._find(m.TableName(), cpn.ID, &list)
	if err != nil || total == 0 {
		return
	}

	s.Res.Total = total

	var taskIds, rewardIds []int64
	for _, v := range list {
		val := v.GetVal()
		switch v.Source {
		case mtype.FissionLogSourceLottery:
			rewardIds = append(rewardIds, val.RewardId)
		case mtype.FissionLogSourceCondOne, mtype.FissionLogSourceManualCondOne:
			taskIds = append(taskIds, val.TaskId)
		}
	}
	for _, v := range list {
		val := v.GetVal()
		switch v.Source {
		case mtype.FissionLogSourceLottery:
			rewardIds = append(rewardIds, val.RewardId)
		case mtype.FissionLogSourceCondOne, mtype.FissionLogSourceManualCondOne:
			taskIds = append(taskIds, val.TaskId)
		}
	}

	taskTitle, err := s._taskTitle(taskIds)
	if err != nil {
		return
	}

	rewardTitle, err := s._rewardTitle(rewardIds)
	if err != nil {
		return
	}

	for _, v := range list {
		val := v.GetVal()
		s.Res.List = append(s.Res.List, &pb.LotteryLogRes_One{
			Id:           v.ID,
			CreatedAt:    v.CreatedAt,
			Type:         int32(v.Type),
			Source:       v.Source,
			TaskTitle:    taskTitle[val.TaskId],
			RewardTitle:  rewardTitle[val.RewardId],
			Chance:       val.Chance,
			PointsUseNum: val.PointsNum,
		})
	}

	return
}

func (s *LotteryLog) _find(tableName string, cpnId int64, list any) (total int64, err error) {
	offset, limit := utils.PpDbLo(s.Req.GetPage(), s.Req.GetPerPage())

	query := app.DB.Client.Table(tableName).WithContext(s.Ctx)

	if s.Req.GetUserHashId() != "" || s.Req.GetSubUserId() != "" {
		var user *model.FissionUser
		if s.Req.GetUserHashId() != "" {
			user, err = cache.NewFissionUser(s.Ctx, cpnId).FindByHashId(s.Req.GetUserHashId())
			if err != nil {
				err = s.BE().CacheError(err)
				return
			}
		} else {
			user, err = cache.NewFissionUser(s.Ctx, cpnId).FindBySubUserId(s.Req.GetSubUserId())
			if err != nil {
				err = s.BE().CacheError(err)
				return
			}
		}

		var userId int64
		if user != nil {
			userId = user.ID
		}

		query = query.Where("user_id = ?", userId)
	}

	if len(s.Req.GetSource()) != 0 {
		query = query.Where("source in ?", s.Req.GetSource())
	}

	err = query.Count(&total).Error
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	err = query.Order("id desc").Offset(offset).Limit(limit).Find(list).Error
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}
	return
}

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

	m := s.GetDao().FissionCampaignTask
	list, err := m.WithContext(s.Ctx).Where(m.ID.In(ids...)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var condIds []int64
	var taskMap = make(map[int64]int64)
	for _, v := range list {
		id := utils.FissionCampaignTaskMarkCondOneCondId(v.TaskMark)
		condIds = append(condIds, id)
		taskMap[v.ID] = id
	}

	condM := s.GetDao().FissionCampaignCond
	conds, err := condM.WithContext(s.Ctx).Where(condM.ID.In(condIds...)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var condMap = make(map[int64]string, len(conds))
	for _, v := range conds {
		condMap[v.ID] = v.Desc
	}

	for _, v := range list {
		data[v.ID] = condMap[taskMap[v.ID]]
	}

	return
}

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

	m := s.GetDao().FissionCampaignReward
	list, err := m.WithContext(s.Ctx).Where(m.ID.In(ids...)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var bids []int64
	var titleMap = make(map[int64]string)
	for _, v := range list {
		if _, ok := titleMap[v.RewardID]; !ok {
			bids = append(bids, v.RewardID)
			titleMap[v.RewardID] = ""
		}
	}

	rewardM := s.GetDao().Reward
	rewards, err := rewardM.WithContext(s.Ctx).Where(rewardM.ID.In(bids...)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	for _, v := range rewards {
		titleMap[v.ID] = v.RewardTitle
	}

	for _, v := range list {
		data[v.ID] = titleMap[v.RewardID]
	}

	return
}