joybuywork/internal/service/containers/campaign/ads_update.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/utils/logic"
	pb "joybuywork/proto/go_proto/w_campaign"
	"joybuywork/proto/go_proto/workerr"
	dlinkpb "gits.branchcn.com/backend/deeplink/proto/go_proto/dlink"
	"time"
)

type AdsUpdate struct {
	logic.Logic
	Req *pb.AdsUpdateReq
	Res *pb.AdsUpdateRes
}

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

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

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

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

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

	return
}

// 更新活动数据
func (s *AdsUpdate) update() (cpn *model.FissionCampaign, 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 {
		return nil, workerr.NotFound("nof found campaign")
	}

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

	m := s.GetDao().FissionCampaign
	_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(cpn.ID)).UpdateSimple(
		m.Title.Value(s.Req.GetTitle()),
		m.CoverURL.Value(coverUrl),
	)

	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

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

	confM := s.GetDao().FissionCampaignConfig
	_, err = confM.WithContext(s.Ctx).Where(confM.ID.Eq(conf.ID)).UpdateSimple(
		confM.ImageMain.Value(s.Req.GetBgImg()),
		confM.PageTitle.Value(s.Req.GetPageTitle()),
		confM.Countdown.Value(s.Req.GetCountdown()),
	)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	scc := cache.NewCampaignStyle(s.Ctx)
	style, err := scc.FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	styleM := s.GetDao().FissionCampaignStyle
	_, err = styleM.WithContext(s.Ctx).Where(styleM.ID.Eq(style.ID)).UpdateSimple(
		styleM.MainImg.Value(s.Req.GetBgImg()),
		styleM.PageTitle.Value(s.Req.GetPageTitle()),
	)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

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

		_ = cache.NewCampaign(s.Ctx).Clear(cpn)
		_ = cc.Clear(conf)
		_ = scc.Clear(style)

		return
	})

	return
}

// 更新奖品
func (s *AdsUpdate) updateReward(cpn *model.FissionCampaign) (err error) {
	m := s.GetDao().FissionCampaignReward
	list, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.IsDel.Eq(mtype.No)).Find()
	if err != nil {
		return
	}

	var oldMap = make(map[int64]*model.FissionCampaignReward, len(list))
	for _, v := range list {
		oldMap[v.ID] = v
	}

	var add []*model.FissionCampaignReward
	for _, v := range s.Req.GetRewards() {
		old, ok := oldMap[v.GetId()]
		if !ok {
			add = append(add, withdefault.FissionCampaignReward(&model.FissionCampaignReward{
				RewardID: v.GetRewardId(),
				Odds:     v.GetOdds(),
			}))
			continue
		}

		_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(old.ID)).UpdateSimple(
			m.RewardID.Value(v.GetRewardId()),
			m.Odds.Value(v.GetOdds()),
		)
		if err != nil {
			return s.BE().RedisError(err)
		}

		delete(oldMap, v.GetId())
	}

	var delIds = make([]int64, 0, len(oldMap))
	for id := range oldMap {
		delIds = append(delIds, id)
	}

	if len(add) > 0 {
		if err = m.WithContext(s.Ctx).Create(add...); err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	if len(delIds) > 0 {
		if _, err = m.WithContext(s.Ctx).Where(m.ID.In(delIds...)).UpdateSimple(m.IsDel.Value(mtype.Yes)); err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	return s._updateRelate(cpn.ID)
}

func (s *AdsUpdate) _updateRelate(cpnId int64) (err error) {
	m := s.GetDao().RewardRelated
	list, err := m.WithContext(s.Ctx).Where(m.RelateID.Eq(cpnId), m.RelateTable.Eq(s.GetDao().FissionCampaign.TableName())).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var oldMap = make(map[int64]*model.RewardRelated, len(list))
	for _, v := range list {
		oldMap[v.RewardID] = v
	}

	var newIdsMap = make(map[int64]struct{})
	for _, v := range s.Req.GetRewards() {
		if _, ok := newIdsMap[v.GetRewardId()]; !ok {
			newIdsMap[v.GetRewardId()] = struct{}{}
		}
	}

	var add []*model.RewardRelated
	for id := range newIdsMap {
		relate, ok := oldMap[id]

		if !ok {
			add = append(add, withdefault.RewardRelated(&model.RewardRelated{
				RewardID:    id,
				RelateID:    cpnId,
				RelateTable: s.GetDao().FissionCampaign.TableName(),
				CancelTime:  0,
			}))
			continue
		}

		if relate.CancelTime > 0 {
			_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(relate.ID)).UpdateSimple(m.CancelTime.Value(0))
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}
		}

		delete(oldMap, id)
	}

	var delIds = make([]int64, 0, len(oldMap))
	for _, v := range oldMap {
		delIds = append(delIds, v.ID)
	}

	if len(add) > 0 {
		if err = m.WithContext(s.Ctx).Create(add...); err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	if len(delIds) > 0 {
		if _, err = m.WithContext(s.Ctx).Where(m.ID.In(delIds...)).UpdateSimple(m.CancelTime.Value(time.Now().Unix())); err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	return
}

// 设置延迟深度链接数据
func (s *AdsUpdate) 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 *AdsUpdate) _getCoverUrl(cpn *model.FissionCampaign) (coverUrl string, err error) {
	tempM := s.GetDao().FissionTemp

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

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

	m := s.GetDao().FissionTempImage
	img, err := m.WithContext(s.Ctx).Where(m.TempID.Eq(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(temp.GroupID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	return group.CoverURL, nil
}

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

func (s *AdsUpdate) _flip(cpn *model.FissionCampaign) (err error) {
	m := s.GetDao().FissionCampaignFlip
	conf, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.IsDel.Eq(mtype.No)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if conf == nil {
		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
	}

	if conf.CardImg == s.Req.GetFlip().GetCardImg() || s.Req.GetFlip().GetCardImg() == "" {
		return
	}

	_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(conf.ID)).UpdateSimple(m.CardImg.Value(s.Req.GetFlip().GetCardImg()))
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	return
}