joybuywork/internal/service/containers/fission_web_web_reward.go

package containers

import (
	"joybuywork/internal/app"
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/dbcheck"
	"joybuywork/internal/repository/finder"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/service/provider"
	"joybuywork/internal/service/provider/award"
	"joybuywork/internal/service/provider/fissionaction"
	"joybuywork/internal/utils"
	"joybuywork/internal/utils/logic"
	pb "joybuywork/proto/go_proto/w_fission_web"
	"joybuywork/proto/go_proto/workerr"
	"time"

	ddevicepb "gits.branchcn.com/backend/deeplink/proto/go_proto/ddevice"
)

type FissionWebWebReward struct {
	logic.Logic
	Req *pb.WebRewardReq
	Res *pb.WebRewardRes
}

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

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

	binder, err := s.wbu(cpn)
	if err != nil || binder == nil {
		return
	}

	wbu, user, err := s.bind(cpn, binder)
	if err != nil || wbu == nil {
		return
	}

	err = s.webReward(cpn, wbu, user)
	if err != nil {
		return
	}

	return
}

func (s *FissionWebWebReward) cpn() (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 {
		err = workerr.NotFound("not found cpn")
		return
	}

	return
}

func (s *FissionWebWebReward) wbu(cpn *model.FissionCampaign) (binder *model.FissionWebUser, err error) {
	res, _ := app.NewDeepLinkDevice().FindBlackbox(s.Ctx, &ddevicepb.FindBlackboxReq{
		Blackbox:  s.Req.GetWebId(),
		ProjectId: cpn.ProjectID,
	})

	if res.GetWid() == "" {
		return
	}

	binder, err = cache.NewFissionWebUser(s.Ctx).FindByWebId(cpn.ID, res.GetWid())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	return
}

func (s *FissionWebWebReward) bind(cpn *model.FissionCampaign, binder *model.FissionWebUser) (*model.FissionWebUser, *model.FissionUser, error) {
	// 已经绑定了用户就不显示了
	if binder.UserID > 0 || binder.RewardID == 0 {
		s.Res.Status = 2
		return binder, nil, nil
	}

	binder, user, err := s._bindUser(cpn, binder)
	if err != nil {
		return nil, nil, err
	}

	if user == nil {
		return binder, nil, nil
	}

	cc := cache.NewFissionWebUser(s.Ctx)

	// 看看这个用户id有没有绑定过站外用户
	wbuM := s.GetDao().FissionWebUser
	hasBind, err := wbuM.WithContext(s.Ctx).Where(wbuM.CampaignID.Eq(cpn.ID), wbuM.UserID.Eq(user.ID)).Take()
	if err = dbcheck.DbError(err); err != nil {
		return nil, nil, s.BE().MysqlError(err)
	}

	// 如果已经绑定上了，就直接不允许领奖
	if hasBind != nil {
		s.Res.Status = 1
		return binder, nil, nil
	}

	_, err = wbuM.WithContext(s.Ctx).Where(wbuM.ID.Eq(binder.ID)).UpdateSimple(wbuM.UserID.Value(user.ID))
	if err != nil {
		return nil, nil, s.BE().MysqlError(err)
	}

	_ = cc.Clear(binder)

	return binder, user, nil
}

func (s *FissionWebWebReward) _bindUser(cpn *model.FissionCampaign, binder *model.FissionWebUser) (*model.FissionWebUser, *model.FissionUser, error) {
	if s.Req.GetUid() == "" {
		return binder, nil, nil
	}

	cc := cache.NewFissionWebUser(s.Ctx)

	user, err := cache.NewFissionUser(s.Ctx, cpn.ID).FindBySubUserId(s.Req.GetUid())
	if err != nil {
		return nil, nil, s.BE().CacheError(err)
	}

	userBind, err := cc.FindByUserId(cpn.ID, user.ID)
	if err != nil {
		return nil, nil, s.BE().CacheError(err)
	}

	// 当前用户并没有领奖
	if userBind == nil {
		return binder, user, nil
	}

	_, err = s._setReward(cpn, binder, user)
	if err != nil {
		return nil, nil, err
	}

	s.Res.Status = 2

	return nil, nil, nil
}

func (s *FissionWebWebReward) _setReward(cpn *model.FissionCampaign, wbu *model.FissionWebUser, user *model.FissionUser) (reward *model.FissionCampaignReward, err error) {
	rewardM := s.GetDao().FissionCampaignReward
	reward, err = rewardM.WithContext(s.Ctx).Where(rewardM.ID.Eq(wbu.RewardID)).Take()
	if err = dbcheck.DbError(err); err != nil {
		return
	}

	if reward == nil {
		return
	}

	preward, err := provider.NewRewards(s.Ctx, cpn.ProjectID, reward.RewardID)
	if err != nil {
		return
	}

	var lang = s.Req.GetLang()
	if user != nil {
		lang = user.LangMark
	}

	lang = utils.NotExistGetFirst(lang, cpn.GetLangMarks())
	info, err := preward.InfoAutoLang(reward.RewardID, lang)
	if err != nil {
		return
	}

	s.AddAfterRun(func() (err error) {
		s.Res.HasReward = true
		s.Res.Title = info.Title
		s.Res.ImgUrl = info.ImgUrl
		s.Res.ReceiveType = info.ReceiveType
		s.Res.Contact = info.Contact
		s.Res.WebUrl = info.WebUrl
		s.Res.AppParam = info.AppParam
		s.Res.PcParam = info.PcParam
		s.Res.KvData = make([]*pb.WebRewardRes_KV, 0, len(info.KvData))
		for _, kv := range info.KvData {
			s.Res.KvData = append(s.Res.KvData, &pb.WebRewardRes_KV{
				Key:   kv.Key,
				Value: kv.Value,
			})
		}

		return
	})

	return
}

func (s *FissionWebWebReward) webReward(cpn *model.FissionCampaign, wbu *model.FissionWebUser, user *model.FissionUser) (err error) {
	reward, err := s._setReward(cpn, wbu, user)
	if err != nil {
		return
	}

	// 找不到用户，只返回当前浏览器用户的奖品数据
	if user == nil {
		return
	}

	var record *model.FissionRewardRecord
	var async []func()
	defer s.AddAfterRun(func() (err error) {

		if record != nil {
			s.Res.RewardId = record.RewardID
			s.Res.RewardHashId = record.HashID
			s.Res.IsPush = record.Status != mtype.FissionRewardRecordStatusWait

			if record.FailType == mtype.FissionRewardRecordFailTypeIneligible {
				s.Res.Status = 1
			}
		}

		for _, do := range async {
			do()
		}

		return
	})

	var rewardType int8 = mtype.FissionCampaignRewardTypeWeb
	if cpn.Target == mtype.FissionCampaignConfigTargetAdsGame {
		rewardType = mtype.FissionCampaignRewardTypeApp
	}

	m := s.GetDao().FissionRewardRecord.SubTable(cpn.ID)
	record, err = m.WithContext(s.Ctx).Where(
		m.CampaignID.Eq(user.CampaignID),
		m.UserID.Eq(user.ID),
		m.RewardType.Eq(rewardType),
	).Take()
	if err = dbcheck.DbError(err); err != nil {
		return s.BE().MysqlError(err)
	}

	if record != nil {
		return
	}

	var opts []award.RecordOption
	if user.IsNew == mtype.No {
		opts = append(opts, award.RewardRecordStatus(
			mtype.FissionRewardRecordStatusFail,
			mtype.FissionRewardRecordFailTypeIneligible,
			mtype.FissionRewardRecordFailTypeNotInstall,
		))
	}

	record, _, async, err = award.NewAwardReward(s.Ctx, s.GetDao(), cpn.ProjectID, user).One(reward, false, opts...)
	if err != nil {
		return
	}

	if user.IsNew == mtype.Yes {
		if cpn.ReportType == mtype.FissionCampaignReportTypeNew {
			fissionaction.NewMarkPoint(s.Ctx).InApp(user).WebToApp(time.Now().Unix(), reward.ID, record.ID, wbu.WebID)
		}
	}

	return
}