crazy_fox_backend_api/service/act_one_plus.go

package service

import (
	"fmt"
	"sort"

	"crazy-fox-backend-api/config"
	"crazy-fox-backend-api/model"
	"crazy-fox-backend-api/utils"
	"crazy-fox-backend-api/utils/uniqid"

	"github.com/dablelv/go-huge-util/conv"
	"github.com/jmoiron/sqlx/types"
	jsoniter "github.com/json-iterator/go"
	"github.com/pkg/errors"
)

type actOnePlus struct{}

// 展示数据处理
func (This *actOnePlus) handleActShow(confInfo *model.ActConfInfo) (json types.JSONText, err error) {

	var confMap map[int64]model.OnePlusRewardConf
	if err = jsoniter.Unmarshal(confInfo.Reward, &confMap); err != nil {
		return json, errors.Wrap(err, "1+1礼包 奖励Json解析失败")
	}

	var baseConf model.OnePlusBaseConf
	if err = jsoniter.Unmarshal(confInfo.RewardConf, &baseConf); err != nil {
		return json, errors.Wrap(err, "1+1礼包 基础配置Json解析失败")
	}

	// 数据转换
	showConf := This.convertIntoShowConf(confMap, baseConf, confInfo.Type)
	if json, err = jsoniter.Marshal(showConf); err != nil {
		return json, errors.Wrap(err, "1+1礼包 奖励序列化失败")
	}

	return
}

// 保存数据处理
func (This *actOnePlus) handleActSave(confInfo *model.ActConfInfo) (err error) {

	var showConf model.OnePlusShowConf
	if err = jsoniter.Unmarshal(confInfo.ActShowConf, &showConf); err != nil {
		return errors.Wrap(err, "1+1礼包 奖励Json解析失败")
	}

	// 数据转换
	rewardMap := This.convertIntoRepoConf(showConf.RewardConf, confInfo.Type)
	if confInfo.Reward, err = jsoniter.Marshal(rewardMap); err != nil {
		return errors.Wrap(err, "1+1礼包 奖励数据序列化失败")
	}

	baseConf := map[string]int64{"maxNum": showConf.BaseConf.MaxNum}
	if confInfo.RewardConf, err = jsoniter.Marshal(baseConf); err != nil {
		return errors.Wrap(err, "1+1礼包 基础配置序列化失败")
	}

	return
}

// 分层数据处理
func (This *actOnePlus) handleActRewardSection(confInfo *model.ActConfInfo, maps ...map[string]any) error {
	var rewardConfMap map[int64]model.OnePlusRewardConf
	if err := jsoniter.Unmarshal(confInfo.Reward, &rewardConfMap); err != nil {
		return errors.Wrap(err, "1+1礼包 奖励解析失败")
	}

	conditionMap, rewardMap := maps[0], maps[1]
	for idx1, item1 := range rewardConfMap {
		for idx2, item2 := range item1.Data {
			stageKey := fmt.Sprintf("%d_%d", idx1, idx2)

			conditionMap[stageKey] = Activity.buildStageConditionOld(item1.StartEnd, item2.SsGroup)
			rewardMap[stageKey] = item2.Data
		}
	}

	return nil
}

// 导入数据处理
func (This *actOnePlus) handleActImport(detailInfo *model.ActDetailInfo, excelInfo [][][]string) (json types.JSONText, err error) {
	if len(excelInfo) < 3 {
		return json, errors.New("工作表数量不匹配")
	}

	var showConf model.OnePlusShowConf
	if showConf, err = This.sheetResolver(excelInfo, detailInfo.Type); err != nil {
		return json, errors.Wrap(err, "1+1礼包 工作表解析失败")
	}

	if json, err = jsoniter.Marshal(showConf); err != nil {
		return json, errors.Wrap(err, "1+1礼包 配置序列化失败")
	}

	return
}

func (This *actOnePlus) convertIntoShowConf(confMap map[int64]model.OnePlusRewardConf, baseConf model.OnePlusBaseConf, actType string) (showConf model.OnePlusShowConf) {

	for lvId, lvStageReward := range confMap {
		for ssId, ssStageReward := range lvStageReward.Data {

			formatStageReward := func() []model.OnePlusShowStageReward {
				rewardArr := utils.MapValues(ssStageReward.Data, true)

				formatRewards := make([]model.OnePlusShowStageReward, 0, len(rewardArr))
				for i, reward := range rewardArr {
					formatRewards = append(formatRewards, model.OnePlusShowStageReward{
						OnePlusStageReward: reward,
						IsFree:             utils.Ternary(0 == i, false, true),
					})
				}
				return formatRewards
			}()
			showConf.RewardConf = append(showConf.RewardConf, model.OnePlusRewardShowConf{
				TwoLayerLvSsGroup: model.TwoLayerLvSsGroup{
					Id:      Activity.buildLayerOrderId(lvId, ssId),
					LvRange: model.LvRange{LvStart: lvStageReward.Start, LvEnd: lvStageReward.End},
					SsGroup: ssStageReward.SsGroup,
				},
				Reward: formatStageReward,
			})
		}
	}
	sort.SliceStable(showConf.RewardConf, func(i, j int) bool { return showConf.RewardConf[i].Id < showConf.RewardConf[j].Id })

	baseConf.PlusCnt = This.buildPlusCnt(actType)

	showConf.BaseConf = baseConf

	return showConf
}

func (This *actOnePlus) convertIntoRepoConf(rewardConfArr []model.OnePlusRewardShowConf, actType string) map[int64]model.OnePlusRewardConf {
	repoConfMap := map[int64]model.OnePlusRewardConf{}

	var unique = uniqid.GetUniqId()
	defer uniqid.DelMapByUniqId(unique)

	startGid := This.getStartGid(actType)
	for i := 0; i < len(rewardConfArr); i++ {
		oneRowInfo := rewardConfArr[i]

		idxes := uniqid.GetStageIdx(unique, oneRowInfo.LvRange, oneRowInfo.SsGroup)
		lvIdx, ssIdx := idxes[0], idxes[1]

		if _, Ok := repoConfMap[lvIdx]; !Ok {
			repoConfMap[lvIdx] = model.OnePlusRewardConf{
				StartEnd: model.StartEnd{Start: oneRowInfo.LvRange.LvStart, End: oneRowInfo.LvRange.LvEnd},
				Data:     map[int64]model.OnePlusSsGroupStage{},
			}
		}

		rewardMap := make(map[int64]model.OnePlusStageReward, len(oneRowInfo.Reward))
		paidReward := oneRowInfo.Reward[0].OnePlusStageReward
		for idx, reward := range oneRowInfo.Reward {
			one := model.OnePlusStageReward{
				Price:    paidReward.Price,
				Sku:      paidReward.Sku,
				Discount: 1,
				Gid:      int64(idx) + startGid,
				Prizes:   reward.Prizes,
			}
			rewardMap[one.Gid] = one
		}

		if _, Ok := repoConfMap[lvIdx].Data[ssIdx]; !Ok {
			repoConfMap[lvIdx].Data[ssIdx] = model.OnePlusSsGroupStage{
				SsGroup: oneRowInfo.SsGroup,
				Data:    rewardMap,
			}
		}
	}

	return repoConfMap
}

func (This *actOnePlus) sheetResolver(excelInfo [][][]string, actType string) (model.OnePlusShowConf, error) {

	sheet1Array, sheet2Array, sheet3Array := excelInfo[0], excelInfo[1], excelInfo[2]

	// 基础配置
	showConf, err := This.parseBaseConf(sheet1Array, actType)
	if err != nil {
		return showConf, errors.WithStack(err)
	}

	// 解析分组ID配置项
	stageConfArr, err := Activity.parseTwoLayerLvSsGroupConf(sheet2Array)
	if err != nil {
		return showConf, errors.WithStack(err)
	}

	// 解析奖励配置项
	rewardMap, err := This.parseRewardSheet(sheet3Array)
	if err != nil {
		return showConf, errors.WithStack(err)
	}

	if err = This.packageShowConf(&showConf, stageConfArr, rewardMap); err != nil {
		return showConf, errors.WithStack(err)
	}

	return showConf, nil
}

func (This *actOnePlus) parseRewardSheet(sheet [][]string) (rewardMap map[int64][]model.OnePlusShowStageReward, err error) {

	rewardMap = map[int64][]model.OnePlusShowStageReward{}

	for rowIdx := 1; rowIdx < len(sheet); rowIdx++ {

		var (
			id     int64
			ignore string
			one    model.OnePlusShowStageReward
			reward = make([]model.ExcelPrize, 3)
		)

		// 解析行配置
		if err = utils.DestructAssign(sheet[rowIdx], &id, &ignore, &one.Price, &reward); err != nil {
			return nil, errors.WithStack(err)
		}

		if one.Prizes, err = Props.MultiParseActPrize(reward); err != nil {
			return nil, errors.WithStack(err)
		}

		if one.Sku = config.PriceSkuMap[one.Price]; utils.IsEmpty(one.Sku) {
			return nil, errors.New(fmt.Sprintf("第%d行,购买价格：%.2f 无对应sku", rowIdx, one.Price))
		}

		one.IsFree = utils.Ternary(len(rewardMap[id]) == 0, false, true)
		rewardMap[id] = append(rewardMap[id], one)
	}

	return rewardMap, err
}

func (This *actOnePlus) packageShowConf(showConf *model.OnePlusShowConf, layers []model.TwoLayerLvSsGroup, rewardMap map[int64][]model.OnePlusShowStageReward) error {

	showRewardArr := make([]model.OnePlusRewardShowConf, 0, len(layers))
	for _, layer := range layers {
		reward, Ok := rewardMap[layer.Id]
		if !Ok {
			return errors.New("未配置奖励项")
		}
		showRewardArr = append(showRewardArr, model.OnePlusRewardShowConf{
			TwoLayerLvSsGroup: layer,
			Reward:            reward,
		})
	}

	showConf.RewardConf = showRewardArr

	return nil
}

func (This *actOnePlus) parseBaseConf(sheet [][]string, actType string) (showConf model.OnePlusShowConf, err error) {

	var maxNum int64
	for i := 0; i < len(sheet); i++ {
		if len(sheet[i]) == 0 || sheet[i][0] != "最大购买次数" {
			continue
		}

		if maxNum, err = conv.ToAnyE[int64](sheet[i][1]); err != nil {
			return showConf, errors.WithStack(err)
		}
	}

	showConf.BaseConf = model.OnePlusBaseConf{
		MaxNum:  maxNum,
		PlusCnt: This.buildPlusCnt(actType),
	}

	return showConf, err
}

func (This *actOnePlus) buildPlusCnt(actType string) int64 {

	var plusCnt int64
	switch actType {
	case config.ActOnePlusGift:
		plusCnt = 1
	case config.ActOnePlusTwo:
		plusCnt = 2
	case config.ActOnePlusThree:
		plusCnt = 3
	}

	return plusCnt
}

func (This *actOnePlus) getStartGid(actType string) int64 {

	var gid int64
	switch actType {
	case config.ActOnePlusGift:
		gid = 1837
	case config.ActOnePlusTwo:
		gid = 1230001
	case config.ActOnePlusThree:
		gid = 1240001
	}

	return gid
}