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

package campaignuser

import (
	"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"
	"joybuywork/internal/utils/timez"
	"joybuywork/internal/utils/verify"
	pb "joybuywork/proto/go_proto/w_campaign_user"

	"gorm.io/gen"
)

type ChildList struct {
	logic.Logic
	Req *pb.ChildListReq
	Res *pb.ChildListRes
}

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

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

	return s.list(cpn)
}

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

	if cpn == nil || cpn.IsDel == mtype.Yes {
		return
	}

	tz := utils.STernary[int32](s.Req.GetTOffset(), consts.DefaultTz, cpn.TOffset)

	s.Req.Start = timez.GMT(s.Req.Start, tz)
	s.Req.End = timez.GMT(s.Req.End, tz)

	s.Res.ChildType = int32(cpn.ChildType)
	s.Res.TOffset = tz

	return
}

// 用户信息
func (s *ChildList) list(cpn *model.FissionCampaign) (err error) {
	list, total, err := s._find(cpn)

	if err != nil || total == 0 {
		return
	}

	s.Res.List = make([]*pb.ChildListRes_One, 0, len(list))
	s.Res.Total = total

	var playerIds, userIds []int64
	var userMap = make(map[int64]string)
	for _, v := range list {

		playerIds = append(playerIds, v.ID)

		if _, ok := userMap[v.UserID]; !ok && v.UserID > 0 {
			userIds = append(userIds, v.UserID)
			userMap[v.UserID] = ""
		}

		if _, ok := userMap[v.ParentID]; !ok && v.ParentID > 0 {
			userIds = append(userIds, v.UserID)
			userMap[v.ParentID] = ""
		}

	}

	err = s._userMap(cpn.Pid, userIds, userMap)
	if err != nil {
		return
	}

	childData, err := s._child(cpn.ID, cpn.ChildType, playerIds)
	if err != nil {
		return
	}

	for _, v := range list {
		one := &pb.ChildListRes_One{
			Id:        v.ID,
			JoinAt:    v.JoinTime,
			SubUserId: userMap[v.UserID],
			Parent:    userMap[v.ParentID],
		}

		switch cpn.ChildType {
		case mtype.FissionCampaignChildTypeBlind:
			one.Blind = &pb.ChildListRes_Num{Num: childData[v.ID]}
		case mtype.FissionCampaignChildTypeInvite:
			one.Invite = &pb.ChildListRes_Num{Num: childData[v.ID]}
		case mtype.FissionCampaignChildTypeSign:
			one.Sign = &pb.ChildListRes_Num{Num: childData[v.ID]}
		case mtype.FissionCampaignChildTypeLucky:
			one.Lottery = &pb.ChildListRes_Num{Num: childData[v.ID]}
		case mtype.FissionCampaignChildTypeTask:

		}

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

	return
}

// 找数据
func (s *ChildList) _find(cpn *model.FissionCampaign) (list []*model.FissionChildUser, total int64, err error) {
	m := s.GetDao().FissionChildUser
	var cond = []gen.Condition{
		m.CampaignID.Eq(cpn.ID),
		m.JoinTime.Gt(0),
	}

	if !verify.EmptyString(s.Req.GetUserMark()) {

		var user *model.FissionUser
		user, err = cache.NewFissionUser(s.Ctx, cpn.ID).FindBySubUserId(s.Req.GetUserMark())
		if err != nil {
			err = s.BE().CacheError(err)
			return
		}

		if user == nil {
			cond = append(cond, m.ID.Eq(-1))
		} else {
			cond = append(cond, m.UserID.Eq(user.ID))
		}

	}

	if s.Req.GetStart() > 0 {
		cond = append(cond, m.JoinTime.Gte(s.Req.GetStart()))
	}

	if s.Req.GetEnd() > 0 {
		cond = append(cond, m.JoinTime.Lte(s.Req.GetEnd()))
	}

	if s.Req.GetPidType() == 0 && s.Req.GetParentUserMark() != "" {
		var puser *model.FissionUser
		puser, err = cache.NewFissionUser(s.Ctx, cpn.ID).FindBySubUserId(s.Req.GetParentUserMark())
		if err != nil {
			err = s.BE().CacheError(err)
			return
		}

		if puser == nil {
			cond = append(cond, m.ID.Eq(-1))
		} else {
			cond = append(cond, m.ParentID.Eq(puser.ID))
		}
	}

	if s.Req.GetPidType() != 0 {
		switch s.Req.GetPidType() {
		case 1:
			cond = append(cond, m.ParentID.Gt(0))
		case 2:
			cond = append(cond, m.ParentID.Eq(0))
		}
	}

	offset, limit := utils.PpDbLo(s.Req.GetPage(), s.Req.GetPerPage())
	list, total, err = m.WithContext(s.Ctx).Where(cond...).Order(m.JoinTime.Desc()).FindByPage(offset, limit)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	return
}

type childListNum struct {
	PlayerId int64
	Num      int64
}

// 用户数据
func (s *ChildList) _child(cpnId int64, childType int8, ids []int64) (childData map[int64]int64, err error) {
	childData = make(map[int64]int64, len(ids))

	var mark string
	switch childType {
	case mtype.FissionCampaignChildTypeBlind:
		mark = mtype.FissionChildUserRecordSourceBlind
	case mtype.FissionCampaignChildTypeInvite:
		mark = mtype.FissionChildUserRecordSourceInviteOne
	case mtype.FissionCampaignChildTypeSign:
		mark = mtype.FissionChildUserRecordSourceSign
	case mtype.FissionCampaignChildTypeLucky:
		mark = mtype.FissionChildUserRecordSourceLucky
	case mtype.FissionCampaignChildTypeTask:

	}

	m := s.GetDao().FissionChildUserRecord
	var nums []*childListNum
	err = m.WithContext(s.Ctx).Select(m.PlayerID, m.ID.Count().As("num")).
		Where(m.CampaignID.Eq(cpnId), m.PlayerID.In(ids...), m.Mark.Eq(mark)).
		Group(m.PlayerID).
		Scan(&nums)

	for _, num := range nums {
		childData[num.PlayerId] = num.Num
	}

	return
}

// 用户数据
func (s *ChildList) _userMap(cpnId int64, ids []int64, userMap map[int64]string) (err error) {
	if len(ids) == 0 {
		return
	}
	m := s.GetDao().FissionUser.SubTable(cpnId)

	//找上级数据
	userList, err := m.WithContext(s.Ctx).Where(m.ID.In(ids...)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}
	for _, v := range userList {
		userMap[v.ID] = v.UserMark
	}

	return
}