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

package campaign

import (
	"joybuywork/internal/app"
	"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/repository/withdefault"
	"joybuywork/internal/service/cmm"
	"joybuywork/internal/utils"
	"joybuywork/internal/utils/logic"
	"joybuywork/internal/utils/timez"
	pb "joybuywork/proto/go_proto/w_campaign"
	"joybuywork/proto/go_proto/workerr"
	dlinkpb "gits.branchcn.com/backend/deeplink/proto/go_proto/dlink"
	"time"
)

type AdsStore struct {
	logic.Logic
	Req *pb.AdsStoreReq
	Res *pb.AdsStoreRes

	project *model.Project
	temp    *model.FissionTemp
}

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

func (s *AdsStore) Exec() (err error) {
	err = s.depend()
	if err != nil {
		return
	}

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

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

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

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

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

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

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

	return
}

func (s *AdsStore) depend() (err error) {
	project, err := finder.Project(s.Ctx, s.Req.GetProjectId())
	if err != nil {
		return s.BE().CacheError(err)
	}

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

	tempM := s.GetDao().FissionTemp

	temp, err := tempM.WithContext(s.Ctx).Where(tempM.HashID.Eq(s.Req.GetTemplateId())).Take()
	if err = dbcheck.DbError(err); err != nil {
		return s.BE().MysqlError(err)
	}

	if temp == nil {
		return workerr.NotFound("temp not found")
	}

	s.project = project
	s.temp = temp

	return
}

// 创建活动
func (s *AdsStore) create() (cpn *model.FissionCampaign, err error) {
	startTime := time.Now().Unix()
	cpn = withdefault.FissionCampaign(&model.FissionCampaign{
		FissionID:  s.temp.FissionID,
		ProjectID:  s.project.ID,
		CreatorID:  s.Req.GetUserId(),
		TemplateID: s.temp.ID,
		StartTime:  timez.GMT(startTime, 8),
		TOffset:    8,
		TStart:     startTime,
		Title:      s.Req.GetTitle(),
		Status:     mtype.FissionCampaignStatusPub,
		Target:     mtype.FissionCampaignConfigTargetAdsGame,
	})

	cpn.CoverURL, err = s._getCoverUrl()
	if err != nil {
		return
	}

	cpn.SetLangTypes([]int8{s.temp.LangType})

	m := s.GetDao().FissionCampaign
	if err = m.WithContext(s.Ctx).Create(cpn); err != nil {
		return nil, s.BE().MysqlError(err)
	}

	s.AddAfterRun(func() (err error) {
		s.Res.Id = cpn.ID
		s.Res.HashId = cpn.HashID
		return
	})

	return
}

// 创建配置
func (s *AdsStore) createConfig(cpn *model.FissionCampaign) (err error) {
	conf := withdefault.FissionCampaignConfig(&model.FissionCampaignConfig{
		CampaignID: cpn.ID,
		ImageMain:  s.Req.GetBgImg(),
		PageTitle:  s.Req.GetPageTitle(),
		Countdown:  s.Req.GetCountdown(),
	})

	m := s.GetDao().FissionCampaignConfig
	if err = m.WithContext(s.Ctx).Create(conf); err != nil {
		return s.BE().MysqlError(err)
	}

	style := withdefault.FissionCampaignStyle(&model.FissionCampaignStyle{
		CampaignID: cpn.ID,
		MainImg:    s.Req.GetBgImg(),
		PageTitle:  s.Req.GetPageTitle(),
	})

	styleM := s.GetDao().FissionCampaignStyle
	if err = styleM.WithContext(s.Ctx).Create(style); err != nil {
		return s.BE().MysqlError(err)
	}

	return
}

// 创建奖品
func (s *AdsStore) createReward(cpn *model.FissionCampaign) (err error) {
	var relateIds []int64
	var relateMap = make(map[int64]string)
	var add = make([]*model.FissionCampaignReward, 0, len(s.Req.GetRewards()))
	for _, v := range s.Req.GetRewards() {
		add = append(add, withdefault.FissionCampaignReward(&model.FissionCampaignReward{
			CampaignID: cpn.ID,
			RewardID:   v.GetRewardId(),
			Odds:       v.GetOdds(),
		}))

		if _, ok := relateMap[v.GetRewardId()]; !ok && v.GetRewardId() > 0 {
			relateMap[v.GetRewardId()] = ""
			relateIds = append(relateIds, v.GetRewardId())
		}
	}

	if len(add) == 0 {
		return
	}

	m := s.GetDao().FissionCampaignReward
	if err = m.WithContext(s.Ctx).Create(add...); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var relates []*model.RewardRelated
	for _, v := range relateIds {
		relates = append(relates, withdefault.RewardRelated(&model.RewardRelated{
			RewardID:    v,
			RelateID:    cpn.ID,
			RelateTable: s.GetDao().FissionCampaign.TableName(),
		}))
	}

	relateM := s.GetDao().RewardRelated
	if err = relateM.WithContext(s.Ctx).Create(relates...); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	return
}

// 创建默认数据
func (s *AdsStore) createDefault(cpn *model.FissionCampaign) (err error) {
	m := s.GetDao().FissionCampaignChannel

	// 默认站内渠道
	var mark = utils.GetRandEnStr(consts.ChannelMarkLen)
	var chs = []*model.FissionCampaignChannel{
		withdefault.FissionCampaignChannel(&model.FissionCampaignChannel{
			CampaignID: cpn.ID,
			IsDefault:  mtype.Yes,
			Mark:       mark,
			Title:      consts.ChannelDefaultName,
			CType:      mtype.FissionCampaignChannelTypeApp,
		}),
	}

	err = m.WithContext(s.Ctx).Create(chs...)
	if err != nil {
		return s.BE().MysqlError(err)
	}

	// 统计任务
	var atMarks = []string{mtype.FissionArchiveTaskMarkAdsHour, mtype.FissionArchiveTaskMarkAdsDay}
	var archiveTasks = make([]*model.FissionArchiveTask, 0, len(atMarks))
	for _, v := range atMarks {
		archiveTasks = append(archiveTasks, withdefault.FissionArchiveTask(&model.FissionArchiveTask{
			CampaignID: cpn.ID,
			EndTime:    0,
			Mark:       v,
			IsStop:     mtype.Yes,
		}))
	}

	atm := s.GetDao().FissionArchiveTask
	err = atm.WithContext(s.Ctx).Create(archiveTasks...)
	if err != nil {
		return s.BE().MysqlError(err)
	}

	err = cmm.NewCMM(s.Ctx, s.GetDao()).AnalyzeCampaign(cpn.ProjectID, cpn.ID, cpn.StartTime, cpn.EndTime, 0)
	if err != nil {
		return
	}

	return
}

// 创建访问链接
func (s *AdsStore) createLink(cpn *model.FissionCampaign) (err error) {
	_, err = app.NewDeepLinkLink().CreateCampaignLinkOne(s.Ctx, &dlinkpb.CreateCampaignLinkOneReq{
		ProjectId:   s.project.ID,
		CampaignId:  cpn.ID,
		CreatedTime: cpn.CreatedAt,
	})

	if err != nil {
		return
	}

	return
}

// 设置延迟深度链接数据
func (s *AdsStore) saveDelayLinkData(cpn *model.FissionCampaign) (err error) {
	var data = &dlinkpb.SaveCampaignDataListReq{
		ProjectId:  cpn.ProjectID,
		CampaignId: cpn.ID,
		Data:       make([]*dlinkpb.SaveCampaignDataListReq_Data, 0, len(s.Req.GetDelayLinkData())),
	}

	for _, v := range s.Req.GetDelayLinkData() {
		data.Data = append(data.Data, &dlinkpb.SaveCampaignDataListReq_Data{
			Key: v.GetKey(),
			Val: v.GetValue(),
		})
	}

	_, err = app.NewDeepLinkLink().SaveCampaignDataList(s.Ctx, data)
	if err != nil {
		return
	}

	return
}

func (s *AdsStore) _getCoverUrl() (coverUrl string, err error) {
	m := s.GetDao().FissionTempImage
	img, err := m.WithContext(s.Ctx).Where(m.TempID.Eq(s.temp.ID), m.Mark.Eq("main")).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if img.Val != s.Req.GetBgImg() {
		return s.Req.GetBgImg(), nil
	}

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

	return group.CoverURL, nil
}

func (s *AdsStore) fission(cpn *model.FissionCampaign) (err error) {
	switch cpn.FissionID {
	case consts.IdAdsFlip:
		return s._flip(cpn)
	default:
		return
	}
}

func (s *AdsStore) _flip(cpn *model.FissionCampaign) (err error) {
	m := s.GetDao().FissionCampaignFlip

	err = m.WithContext(s.Ctx).Create(withdefault.FissionCampaignFlip(&model.FissionCampaignFlip{
		CampaignID: cpn.ID,
		InitChance: 0,
		CardImg:    s.Req.GetFlip().GetCardImg(),
		DayChance:  0,
	}))
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	return
}