joybuywork/internal/service/containers/campaignstat/report_info.go

package campaignstat

import (
	"joybuywork/internal/consts"
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/dbcheck"
	"joybuywork/internal/repository/finder"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/service/provider/fissionaction"
	"joybuywork/internal/utils/logic"
	"joybuywork/internal/utils/verify"
	pb "joybuywork/proto/go_proto/w_campaign_stat"
	"joybuywork/proto/go_proto/workerr"
)

type ReportInfo struct {
	logic.Logic
	Req *pb.ReportInfoReq
	Res *pb.ReportInfoRes
}

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

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

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

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

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

	return s.events(cpn, conf)
}

// 活动数据
func (s *ReportInfo) campaign() (cpn *model.FissionCampaign, conf *model.FissionCampaignConfig, err error) {
	cpn, err = finder.Campaign(s.Ctx, s.Req.GetHashId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

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

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

	s.Res.HashId = cpn.HashID
	s.Res.Title = cpn.Title
	s.Res.CoverUrl = cpn.CoverURL
	s.Res.FissionMark = consts.FissionIdMap[cpn.FissionID]
	s.Res.StartTime = cpn.TStart
	s.Res.EndTime = cpn.TEnd
	s.Res.Status = int32(cpn.Status)
	s.Res.TOffset = cpn.TOffset
	s.Res.Target = int32(cpn.Target)
	s.Res.RewardType = []string{"app"}

	return
}

// 语言时区
func (s *ReportInfo) langOffset(cpn *model.FissionCampaign) (err error) {
	if len(cpn.GetLangMarks()) == 1 {
		return
	}

	m := s.GetDao().FissionCampaignLang
	langs, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.IsDel.Eq(mtype.No)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	s.Res.LangOffset = make([]*pb.ReportInfoRes_LangOffset, 0, len(langs)+2)

	s.Res.LangOffset = append(s.Res.LangOffset, &pb.ReportInfoRes_LangOffset{
		TOffset:  cpn.TOffset,
		LangMark: "",
	}, &pb.ReportInfoRes_LangOffset{
		TOffset:  cpn.TOffset,
		LangMark: cpn.GetLangMarks()[0],
	})

	for _, lang := range langs {
		s.Res.LangOffset = append(s.Res.LangOffset, &pb.ReportInfoRes_LangOffset{
			TOffset:  lang.TOffset,
			LangMark: lang.LangMark,
		})
	}

	return
}

func (s *ReportInfo) events(cpn *model.FissionCampaign, conf *model.FissionCampaignConfig) (err error) {
	temp, err := cache.NewFissionTemp(s.Ctx).FindById(cpn.TemplateID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	group, err := cache.NewFissionTempGroup(s.Ctx).FindById(temp.GroupID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	pfa := fissionaction.NewActionList(s.Ctx, cpn, conf, group)
	fixDms := pfa.GetFixDimension()

	s.Res.FixDimensions = make([]*pb.ReportInfoRes_Dimension, 0, len(fixDms))
	for _, v := range fixDms {
		s.Res.FixDimensions = append(s.Res.FixDimensions, &pb.ReportInfoRes_Dimension{
			Key: v,
		})
	}

	actions := pfa.GetFissionAction()
	s.Res.Events = make([]*pb.ReportInfoRes_Event, 0, len(actions))
	for _, v := range actions {

		dms := pfa.GetDimension(v)
		one := &pb.ReportInfoRes_Event{
			Type:       v,
			Dimensions: make([]*pb.ReportInfoRes_Dimension, 0, len(dms)),
		}

		for _, d := range dms {
			one.Dimensions = append(one.Dimensions, &pb.ReportInfoRes_Dimension{
				Key: d,
			})
		}

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

	return
}

func (s *ReportInfo) ticket(cpn *model.FissionCampaign) (err error) {
	m := s.GetDao().FissionCampaignTicket

	list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.Open.Eq(mtype.Yes)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	for _, v := range list {
		switch v.Mark {
		case mtype.FissionCampaignTicketCustom:
			s.Res.OpenCustom = 1
		case mtype.FissionCampaignTicketFixed:
			s.Res.OpenFixed = 1
		}
	}

	if verify.InArray[int64](cpn.FissionID, consts.IdWinTogether, consts.IdReferral) {
		s.Res.OpenFixed = 1
	}

	return
}

func (s *ReportInfo) fission(cpn *model.FissionCampaign) (err error) {
	switch cpn.FissionID {
	case consts.IdKeep:
		return s._keep(cpn)
	case consts.IdReferral:
		return s._referral(cpn)
	case consts.IdWinTogether:
		return s._win(cpn)
	}

	return
}

func (s *ReportInfo) _keep(cpn *model.FissionCampaign) (err error) {
	s.Res.RewardType = append(s.Res.RewardType, "step")
	s.Res.ShowSelect = 1

	return
}

func (s *ReportInfo) _referral(cpn *model.FissionCampaign) (err error) {
	s.Res.ShowAll = 1

	m := s.GetDao().FissionCampaignReward
	info, err := m.WithContext(s.Ctx).Select(m.ID).Where(m.CampaignID.Eq(cpn.ID), m.RewardType.Eq(mtype.FissionCampaignRewardTypeExtra), m.IsDel.Eq(mtype.No)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if info != nil {
		s.Res.RewardType = append(s.Res.RewardType, "extra")
	}

	return
}

func (s *ReportInfo) _win(cpn *model.FissionCampaign) (err error) {
	s.Res.RewardType = append(s.Res.RewardType, "newcomer")
	s.Res.ShowAll = 1

	m := s.GetDao().FissionCampaignReward
	info, err := m.WithContext(s.Ctx).Select(m.ID).Where(m.CampaignID.Eq(cpn.ID), m.RewardType.Eq(mtype.FissionCampaignRewardTypeExtra), m.IsDel.Eq(mtype.No)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if info != nil {
		s.Res.RewardType = append(s.Res.RewardType, "extra")
	}

	return
}