joybuywork/internal/service/provider/malls/mall.go

package malls

import (
	"context"
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/repository/withdefault"
	"joybuywork/internal/service/provider"
	stos "joybuywork/internal/service/provider/s2s"
	"joybuywork/internal/utils/logic"
	"joybuywork/internal/utils/merr"
	"joybuywork/internal/utils/verify"
	"joybuywork/proto/go_proto/workerr"
	"fmt"
)

type Mall struct {
	logic.Context

	mall *model.RedeemMall
}

func NewMall(ctx context.Context, mallId int64, opts ...logic.CtxOption) (item *Mall, err error) {
	item = new(Mall)
	{
		item.BaseInit(ctx, merr.NewBE(ctx), opts...)
	}

	item.mall, err = cache.NewRedeemMall(ctx).FindById(mallId)
	if err != nil {
		return nil, err
	}

	if item.mall == nil {
		return nil, workerr.NotFound("not found mall")
	}

	return
}

func (s *Mall) GetMall() *model.RedeemMall {
	return s.mall
}

func (s *Mall) UpItems() (list []*model.RedeemMallItem, err error) {
	m := s.GetDao().RedeemMallItem

	dbList, err := m.WithContext(s.Ctx).Where(
		m.MallID.Eq(s.mall.ID),
		m.DownAt.Eq(mtype.No),
		m.IsDel.Eq(mtype.No),
	).Order(m.Sort.Desc(), m.ID.Desc()).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	for _, item := range dbList {
		if verify.InArray[int32](item.GetStatus(), mtype.RedeemMallItemStatusUp, mtype.RedeemMallItemStatusWait) {
			list = append(list, item)
		}
	}

	return
}

func (s *Mall) DownItems() (list []*model.RedeemMallItem, err error) {
	m := s.GetDao().RedeemMallItem

	list, err = m.WithContext(s.Ctx).Where(
		m.MallID.Eq(s.mall.ID),
		m.DownAt.Gt(mtype.No),
		m.IsDel.Eq(mtype.No),
	).Order(m.DownAt.Desc(), m.ID.Desc()).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	return
}

func (s *Mall) Exchange(item *model.RedeemMallItem, source string, firstId, secondId, relateId int64, pushParam mtype.RewardPushParam) (record *model.RedeemMallRecord, info provider.RewardAutoLang, err error) {
	reward, record, info, err := s.ExchangeRecord(item, pushParam.Lang)
	if err != nil {
		return
	}

	if record.Status == mtype.RedeemMallRecordStatusOk {
		return
	}

	rp, err := stos.NewReward(s.Ctx, reward)
	if err != nil {
		return
	}

	pushParam.RelateHashId = fmt.Sprintf("%d", record.ID)
	pushParam.RewardId = fmt.Sprintf("%d", record.ID)

	push, err := rp.CreatePush(
		source,
		firstId,
		secondId,
		relateId,
		mtype.Yes,
		pushParam,
	)

	if err != nil || push == nil {
		return
	}

	push, err = rp.Send(push, true)
	if err != nil || push == nil {
		return
	}

	if push.Status == mtype.RewardPushStatusFail {
		record.Status = mtype.RedeemMallRecordStatusFail
		record.FailType = push.FailType
		record.FailMsg = push.FailMsg
	} else {
		record.Status = mtype.RedeemMallRecordStatusOk
		record.CustomRewardVal = push.RespData
	}

	if err = s.GetDao().RedeemMallRecord.WithContext(s.Ctx).Save(record); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	return
}

func (s *Mall) ExchangeRecord(item *model.RedeemMallItem, langMark string) (reward *model.Reward, record *model.RedeemMallRecord, info provider.RewardAutoLang, err error) {
	reward, err = cache.NewReward(s.Ctx).FindById(item.RewardID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	pewards, err := provider.NewRewards(s.Ctx, s.mall.ProjectID, item.RewardID)
	if err != nil {
		return
	}

	info, err = pewards.InfoAutoLang(item.RewardID, langMark)
	if err != nil {
		return
	}

	record = withdefault.RedeemMallRecord(&model.RedeemMallRecord{
		MallID:          item.MallID,
		MallItemID:      item.ID,
		CoinNum:         int64(item.CoinNum),
		Status:          mtype.RedeemMallRecordStatusWait,
		FailType:        "",
		FailMsg:         "",
		RewardID:        item.RewardID,
		CustomRewardVal: "",
	})

	if reward.ReceiveType != mtype.RewardReceiveTypeNotify {
		record.Status = mtype.RedeemMallRecordStatusOk
	}

	if err = s.GetDao().RedeemMallRecord.WithContext(s.Ctx).Create(record); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	return
}