crazy_fox_backend_api/service/act_choose_you_want.go

package service

import (
	"fmt"
	"sort"

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

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

type actChooseYouWant struct{}

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

	var stageConf []model.ChooseYouWantStageConf
	if err = jsoniter.Unmarshal(confInfo.Reward, &stageConf); err != nil {
		return nil, errors.Wrap(err, "随心配 奖励Json解析失败")
	}

	var baseConf model.ChooseYouWantBaseConf
	if err = jsoniter.Unmarshal(confInfo.ExtraReward, &baseConf); err != nil {
		return nil, errors.Wrap(err, "随心配 基础配置Json解析失败")
	}

	showConf := This.convertIntoShowConf(stageConf, baseConf)
	if json, err = jsoniter.Marshal(showConf); err != nil {
		return nil, errors.Wrap(err, "随心配 奖励序列化失败")
	}

	return
}

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

	var showConf model.ChooseYouWantShowConf
	if err = jsoniter.Unmarshal(confInfo.ActShowConf, &showConf); err != nil {
		return errors.Wrap(err, "随心配 奖励Json解析失败")
	}

	// 数据转换
	var stageConf []model.ChooseYouWantStageConf
	if stageConf, err = This.convertIntoStageConf(showConf.RewardConf); err != nil {
		return errors.Wrap(err, "随心配 奖励数据转换失败")
	}

	// 奖励配置
	if confInfo.Reward, err = jsoniter.Marshal(stageConf); err != nil {
		return errors.Wrap(err, "随心配 奖励数据序列化失败")
	}

	// 奖励配置
	if confInfo.ExtraReward, err = jsoniter.Marshal(showConf.BaseConf); err != nil {
		return errors.Wrap(err, "随心配 基础配置数据序列化失败")
	}

	return
}

// 分层数据处理
func (This *actChooseYouWant) handleActRewardSection(confInfo *model.ActConfInfo, maps ...map[string]any) error {
	var repoConfArr []model.ChooseYouWantStageConf

	if err := jsoniter.Unmarshal(confInfo.Reward, &repoConfArr); err != nil {
		return errors.Wrap(err, "随心配奖励解析失败")
	}

	conditionMap, rewardMap := maps[0], maps[1]
	for idx1, item1 := range repoConfArr {
		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 *actChooseYouWant) handleActImport(_ *model.ActDetailInfo, excelInfo [][][]string) (json types.JSONText, err error) {
	if len(excelInfo) < 3 {
		return json, errors.New("工作表数量不匹配")
	}

	var showConf model.ChooseYouWantShowConf
	if showConf, err = This.sheetResolver(excelInfo); err != nil {
		return json, errors.Wrap(err, "随心配 工作表解析失败")
	}

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

	return
}

func (This *actChooseYouWant) convertIntoShowConf(stageConf []model.ChooseYouWantStageConf, baseConf model.ChooseYouWantBaseConf) (showConf model.ChooseYouWantShowConf) {
	for lvId, lvStage := range stageConf {
		for ssId, ssGroupStage := range lvStage.Data {

			showConf.RewardConf = append(showConf.RewardConf, model.ChooseYouWantShowStageConf{
				TwoLayerLvSsGroup: model.TwoLayerLvSsGroup{
					Id:      Activity.buildLayerOrderId(int64(lvId), int64(ssId)),
					LvRange: model.LvRange{LvStart: lvStage.Start, LvEnd: lvStage.End},
					SsGroup: ssGroupStage.SsGroup,
				},
				Data: ssGroupStage.Data,
			})
		}
	}

	showConf.BaseConf = baseConf

	return
}

func (This *actChooseYouWant) convertIntoStageConf(confArr []model.ChooseYouWantShowStageConf) (repoConfArr []model.ChooseYouWantStageConf, err error) {

	ssStageArrMap := This.buildSsStageArrMap(confArr)

	repoConfArr = make([]model.ChooseYouWantStageConf, 0, len(confArr))
	for _, stages := range ssStageArrMap {

		for i := 0; i < len(stages.Data); i++ {
			stage := &stages.Data[i]
			stage.Data.Gid = 1845
		}

		repoConfArr = append(repoConfArr, model.ChooseYouWantStageConf{
			StartEnd: model.StartEnd{Start: stages.LvRange.LvStart, End: stages.LvRange.LvEnd},
			Data:     stages.Data,
		})
	}

	return
}

func (This *actChooseYouWant) sheetResolver(sheets [][][]string) (showConf model.ChooseYouWantShowConf, err error) {

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

	// 解析分组ID配置项
	if showConf, err = This.parseBaseSheet(sheet1Array); err != nil {
		return showConf, errors.WithStack(err)
	}

	// 解析分组ID配置项
	var stageConf []model.TwoLayerLvSsGroup
	if stageConf, err = Activity.parseTwoLayerLvSsGroupConf(sheet2Array); err != nil {
		return showConf, errors.WithStack(err)
	}

	// 解析阶段配置项
	var stageMap map[int64]model.ChooseYouWantStageReward
	if stageMap, err = This.parseStageSheet(sheet3Array); err != nil {
		return showConf, errors.WithStack(err)
	}

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

	return
}

func (This *actChooseYouWant) buildSsStageArrMap(confArr []model.ChooseYouWantShowStageConf) []model.ChooseYouWantTmpSsConf {

	ssStageArrMap := make(map[model.LvRange][]model.ChooseYouWantSSGroupStage, 0)
	for i := 0; i < len(confArr); i++ {
		oneRowInfo := confArr[i]

		ssStageArrMap[oneRowInfo.LvRange] = append(ssStageArrMap[oneRowInfo.LvRange], model.ChooseYouWantSSGroupStage{
			SsGroup: oneRowInfo.SsGroup,
			Data:    oneRowInfo.Data,
		})
	}

	tmpSsConf := make([]model.ChooseYouWantTmpSsConf, 0, len(ssStageArrMap))
	for idx, stages := range ssStageArrMap {
		tmpSsConf = append(tmpSsConf, model.ChooseYouWantTmpSsConf{
			LvRange: idx,
			Data:    stages,
		})
	}

	sort.SliceStable(tmpSsConf, func(i, j int) bool {
		if tmpSsConf[i].LvRange.LvStart != tmpSsConf[j].LvRange.LvStart {
			return tmpSsConf[i].LvRange.LvStart < tmpSsConf[j].LvRange.LvStart
		}

		return tmpSsConf[i].LvRange.LvEnd < tmpSsConf[j].LvRange.LvEnd
	})

	return tmpSsConf
}

func (This *actChooseYouWant) parseBaseSheet(sheet [][]string) (showConf model.ChooseYouWantShowConf, err error) {

	for i := 0; i < len(sheet); i++ {
		if len(sheet[i]) == 0 {
			continue
		}

		switch sheet[i][0] {
		case "购买次数":
			if showConf.BaseConf.BuyTimes, err = conv.ToAnyE[int64](sheet[i][1]); err != nil {
				return showConf, errors.WithStack(err)
			}
		}
	}

	return
}

func (This *actChooseYouWant) parseStageSheet(sheet [][]string) (stageMap map[int64]model.ChooseYouWantStageReward, err error) {

	stageMap = make(map[int64]model.ChooseYouWantStageReward, len(sheet))
	for rowIdx := 1; rowIdx < len(sheet); rowIdx++ {

		var (
			id             int64
			one            model.ChooseYouWantStageReward
			leftRewardArr  = make([]model.ExcelPrize, 5)
			rightRewardArr = make([]model.ExcelPrize, 5)
		)

		// 解析行配置
		if err = utils.DestructAssign(sheet[rowIdx], &id, &one.Price, &one.Discount, &leftRewardArr, &rightRewardArr); 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))
		}

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

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

		stageMap[id] = one
	}

	return
}

func (This *actChooseYouWant) packageShowConf(showConf *model.ChooseYouWantShowConf, stageConf []model.TwoLayerLvSsGroup, stageMap map[int64]model.ChooseYouWantStageReward) (err error) {

	var Ok bool
	var reward model.ChooseYouWantStageReward

	showConf.RewardConf = make([]model.ChooseYouWantShowStageConf, 0, len(stageConf))
	for _, layer := range stageConf {

		if reward, Ok = stageMap[layer.Id]; !Ok {
			return errors.New(fmt.Sprintf("阶段唯一ID: %d 未配置", layer.Id))
		}

		showConf.RewardConf = append(showConf.RewardConf, model.ChooseYouWantShowStageConf{
			TwoLayerLvSsGroup: layer,
			Data:              reward,
		})
	}

	return
}