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

package campaignuser

import (
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/dbcheck"
	"joybuywork/internal/repository/finder"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/utils/logic"
	pb "joybuywork/proto/go_proto/w_campaign_user"
	"joybuywork/proto/go_proto/workerr"
)

type RewardForm struct {
	logic.Logic
	Req *pb.RewardFormReq
	Res *pb.RewardFormRes

	langMark string
}

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

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

	if user.IsView == mtype.Yes {
		return s.view()
	}

	return s.form(user)
}

func (s *RewardForm) user() (user *model.FissionUser, err error) {
	user, err = finder.FissionUser(s.Ctx, s.Req.GetCampaignId(), s.Req.GetUserId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

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

	return
}

// 预览用户表单
func (s *RewardForm) view() (err error) {
	m := s.GetDao().FissionCampaignReward
	reward, err := m.WithContext(s.Ctx).Where(m.ID.Eq(s.Req.GetCampaignId()), m.ID.Eq(s.Req.GetRewardId())).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

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

	breward, err := cache.NewReward(s.Ctx).FindById(reward.RewardID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	return s._res(false, breward.FormID, reward.ID, 0, nil)
}

// 正常用户表单
func (s *RewardForm) form(user *model.FissionUser) (err error) {
	m := s.GetDao().FissionRewardRecord.SubTable(user.CampaignID)
	record, err := m.WithContext(s.Ctx).Where(m.HashID.Eq(s.Req.GetRewardHashId()), m.UserID.Eq(user.ID)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

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

	if record.Status == mtype.FissionRewardRecordStatusSubmitForm {
		rfm := s.GetDao().FissionRewardRecordForm
		var recordForm *model.FissionRewardRecordForm
		recordForm, err = rfm.WithContext(s.Ctx).Where(rfm.RecordID.Eq(record.ID)).Take()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		return s._res(true, recordForm.FormID, record.RewardID, record.ID, recordForm.GetItems())
	}

	breward, err := cache.NewReward(s.Ctx).FindById(record.BaseRewardID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if breward.ReceiveType != mtype.RewardReceiveTypeForm || record.Status != mtype.FissionRewardRecordStatusWaitForm {
		return
	}

	return s._res(false, breward.FormID, record.RewardID, record.ID, nil)
}

// 结果
func (s *RewardForm) _res(isSubmit bool, formId, rewardId, recordId int64, items []*mtype.SubmitFormItem) (err error) {
	form, err := cache.NewForm(s.Ctx).FindById(formId)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	s.Res.IsSubmit = isSubmit
	s.Res.Title = form.Title
	s.Res.Id = recordId
	s.Res.RewardId = rewardId

	if isSubmit {
		s.Res.Items = make([]*pb.RewardFormRes_Item, 0, len(items))
		for _, item := range items {
			s.Res.Items = append(s.Res.Items, &pb.RewardFormRes_Item{
				Name:  item.Name,
				Key:   item.Key,
				Value: item.Value,
			})
		}

		return
	}

	for _, v := range form.GetItems() {
		s.Res.Items = append(s.Res.Items, &pb.RewardFormRes_Item{
			Name:  v.GetTranName(s.Req.GetLangMark()),
			Key:   v.Name,
			Value: "",
		})
	}

	return
}