crazy_fox_backend_api/service/act_traffic_permit.go

package service

import (
	"fmt"
	"strings"

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

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

type actTrafficPermit struct{}

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

	var repoConf map[int64]model.TrafficPermitRepoConf

	// 基础配置解析
	if err = jsoniter.Unmarshal(confInfo.RewardPro, &repoConf); err != nil {
		return json, errors.Wrap(err, "通行证 Json解析失败")
	}

	// 数据转换
	showConf := utils.MapValues(repoConf, true)
	if json, err = jsoniter.Marshal(showConf); err != nil {
		return json, errors.Wrap(err, "通行证 奖励序列化失败")
	}

	return
}

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

	var showConf []model.TrafficPermitRepoConf
	if err = jsoniter.Unmarshal(confInfo.ActShowConf, &showConf); err != nil {
		return errors.Wrap(err, "通行证 奖励Json解析失败")
	}

	repoConf := This.convertIntoRepoConf(showConf)

	// 配置解析
	if confInfo.RewardPro, err = jsoniter.Marshal(repoConf); err != nil {
		return errors.Wrap(err, "通行证 配置序列化失败")
	}

	return
}

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

	var repoConfMap map[int64]model.TrafficPermitRepoConf
	if err := jsoniter.Unmarshal(confInfo.RewardPro, &repoConfMap); err != nil {
		return errors.Wrap(err, "通行证奖励解析失败")
	}

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

		conditionMap[stageKey] = Activity.buildStageCondition(item1.LvRange)
		rewardMap[stageKey] = item1
	}

	return nil
}

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

	var showConf []model.TrafficPermitShowConf
	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 *actTrafficPermit) convertIntoRepoConf(confArr []model.TrafficPermitRepoConf) map[int64]model.TrafficPermitRepoConf {

	maps := make(map[int64]model.TrafficPermitRepoConf, len(confArr))
	for i := range confArr {
		This.formatTaskConf(confArr[i].Task1)
		This.formatTaskConf(confArr[i].Task2)
		maps[int64(i+1)] = confArr[i]
	}

	return maps
}

func (This *actTrafficPermit) formatTaskConf(taskArr []model.TrafficPermitTaskConf) {
	for i := 0; i < len(taskArr); i++ {
		taskArr[i].Id = int64(i + 1)
	}
}

func (This *actTrafficPermit) sheetResolver(excelInfo [][][]string) (showConf []model.TrafficPermitShowConf, err error) {

	sheet2Array, sheet3Array, sheet4Array, sheet5Array, sheet6Array, sheet7Array :=
		excelInfo[1], excelInfo[2], excelInfo[3], excelInfo[4], excelInfo[5], excelInfo[6]

	// 层级关系映射
	layConfMap, err := This.parseRewardLayerSheet(sheet2Array)
	if err != nil {
		return showConf, errors.WithStack(err)
	}

	// 弹窗配置
	alertConfMap, err := This.parseAlertConfSheet(sheet3Array)
	if err != nil {
		return showConf, errors.WithStack(err)
	}

	// 礼包配置
	giftRewardsMap, err := This.parsePermitRewardSheet(sheet4Array)
	if err != nil {
		return showConf, errors.WithStack(err)
	}

	// 任务配置
	task1ConfMap, task2ConfMap, err := This.parseTaskConfSheet(sheet5Array)
	if err != nil {
		return showConf, errors.WithStack(err)
	}

	// 等级奖励配置
	rewardConfMap, err := This.parseRewardSheet(sheet6Array)
	if err != nil {
		return showConf, errors.WithStack(err)
	}

	// 额外奖励配置
	extraReward, err := This.parseExtraRewardSheet(sheet7Array)
	if err != nil {
		return showConf, errors.WithStack(err)
	}

	showConf, err = This.packageShowConf(layConfMap, alertConfMap, giftRewardsMap, task1ConfMap, task2ConfMap, rewardConfMap, extraReward)
	if err != nil {
		return showConf, errors.WithStack(err)
	}

	return
}

func (This *actTrafficPermit) parseRewardLayerSheet(sheet [][]string) ([]model.TrafficPermitShowConf, error) {

	var err error
	stageConf := make([]model.TrafficPermitShowConf, 0, len(sheet))

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

		var one model.TrafficPermitShowConf
		if err = utils.DestructAssign(sheet[i], &one.Id, &one.LvRange, &one.Basic); err != nil {
			return nil, errors.Wrap(err, fmt.Sprintf("第%d行", i+1))
		}

		stageConf = append(stageConf, one)
	}

	return stageConf, nil
}

func (This *actTrafficPermit) parseAlertConfSheet(sheet [][]string) (map[int64]model.TrafficPermitAlertConfig, error) {
	var err error
	conf := make(map[int64]model.TrafficPermitAlertConfig, len(sheet))

	for i := 1; i < len(sheet); i++ {
		var id int64
		var one model.TrafficPermitAlertConfig

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

		conf[id] = one
	}

	return conf, err
}

func (This *actTrafficPermit) parsePermitRewardSheet(sheet [][]string) (map[int64]model.TrafficPermitOpenConf, error) {

	typStrMap := map[string]string{"普通": "normal", "精英": "special"}

	var err error
	confMap := make(map[int64]map[string]model.TrafficPermitGiftPackConf, len(sheet))

	for i := 1; i < len(sheet); i++ {
		var (
			id     int64
			prizes = make([]model.TrafficPermitExcelPrize, 4)
			typStr string
			one    model.TrafficPermitGiftPackConf
		)

		// 解析行配置
		if err = utils.DestructAssign(sheet[i], &id, &typStr, &one.Price, &prizes); 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", i+1, one.Price))
		}

		if one.Rewards, err = This.multiParseExcelPrize(prizes); err != nil {
			return nil, err
		}

		typ := typStrMap[typStr]

		switch typ {
		case "normal":
			one.Gid = 1770
			if _, Ok := confMap[id]; !Ok {
				confMap[id] = map[string]model.TrafficPermitGiftPackConf{}
			}
			confMap[id]["normal"] = one
		case "special":
			one.Gid = 1814
			if _, Ok := confMap[id]; !Ok {
				confMap[id] = map[string]model.TrafficPermitGiftPackConf{}
			}
			confMap[id]["special"] = one
		default:
			return nil, errors.New("礼包类型错误: " + typStr)
		}
	}

	rewards := make(map[int64]model.TrafficPermitOpenConf, len(confMap))
	for i, conf := range confMap {
		rewards[i] = model.TrafficPermitOpenConf{
			Normal:  conf["normal"],
			Special: conf["special"],
		}
	}

	return rewards, err
}

func (This *actTrafficPermit) parseTaskConfSheet(sheet [][]string) (map[int64][]model.TrafficPermitTaskConf, map[int64][]model.TrafficPermitTaskConf, error) {

	typStrMap := map[string]string{"单日": "single", "双日": "pair"}

	taskTypMap := map[string]int64{
		"邀请好友":      1,
		"完成世界":      2,
		"偷":         3,
		"打":         4,
		"和大盗莫里一起偷袭": 5,
		"和拳手莫里一起进攻": 6,
		"转一次黄金转盘":   7,
		"夺宝一次":      8,
		"玩一次黄金矿工":   9,
		"分享游戏":      10,
		"召回好友":      11,
		"消耗体力200":   12,
		"消耗体力800":   13,
		"消耗体力2000":  14,
		"消耗体力8000":  15,
	}

	var Ok bool
	var err error
	task1 := make(map[int64][]model.TrafficPermitTaskConf, len(sheet)/2)
	task2 := make(map[int64][]model.TrafficPermitTaskConf, len(sheet)/2)

	for i := 1; i < len(sheet); i++ {
		var id int64
		var typStr, taskTyp string
		var one model.TrafficPermitTaskConf

		// 解析行配置
		if err = utils.DestructAssign(sheet[i], &id, &typStr, &taskTyp, &one.Num, &one.GetNum); err != nil {
			return task1, task2, errors.WithStack(err)
		}
		one.Type, Ok = taskTypMap[strings.TrimSpace(taskTyp)]
		if !Ok {
			return nil, nil, errors.New("任务类型错误: " + taskTyp)
		}

		typ := typStrMap[typStr]

		switch typ {
		case "single":
			one.Id = int64(len(task1[id])) + 1
			task1[id] = append(task1[id], one)
		case "pair":
			one.Id = int64(len(task2[id])) + 1
			task2[id] = append(task2[id], one)
		default:
			return nil, nil, errors.New("任务单/双类型错误: " + typStr)
		}
	}

	return task1, task2, err
}

func (This *actTrafficPermit) parseRewardSheet(sheet [][]string) (map[int64][]model.TrafficPermitRewardConf, error) {

	yesOrNoMap := map[string]int64{"是": 1, "否": 0}

	var err error
	rewardArrMap := map[int64][]model.TrafficPermitRewardConf{}

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

		var (
			id           int64
			isGrandPrize string
			freePrizes   = make([]model.ExcelPrize, 4)
			prizes       = make([]model.ExcelPrize, 4)
			one          model.TrafficPermitRewardConf
		)

		// 解析行配置
		if err = utils.DestructAssign(sheet[i], &id, &one.LevelId, &one.Max, &isGrandPrize, &freePrizes, &prizes); err != nil {
			return nil, errors.WithStack(err)
		}

		one.IsGrandPrize = yesOrNoMap[strings.TrimSpace(isGrandPrize)]

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

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

		rewardArrMap[id] = append(rewardArrMap[id], one)
	}

	return rewardArrMap, nil
}

func (This *actTrafficPermit) parseExtraRewardSheet(sheet [][]string) (map[int64]model.TrafficPermitReward, error) {

	var err error
	rewardArrMap := map[int64]model.TrafficPermitReward{}

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

		var (
			id         int64
			freePrizes = make([]model.ExcelPrize, 4)
			prizes     = make([]model.ExcelPrize, 4)
			one        model.TrafficPermitReward
		)

		// 解析行配置
		if err = utils.DestructAssign(sheet[i], &id, &freePrizes, &prizes); err != nil {
			return nil, errors.WithStack(err)
		}

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

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

		rewardArrMap[id] = one
	}

	return rewardArrMap, nil
}

func (This *actTrafficPermit) multiParseExcelPrize(rewards []model.TrafficPermitExcelPrize) ([]model.TrafficPermitPrize, error) {

	rewardStrMap := map[string]int64{"通行证专属头像框": 2, "赠送N个通行证等级": 3}

	prizes := make([]model.TrafficPermitPrize, 0, len(rewards))
	for _, prize := range rewards {
		name := strings.TrimSpace(prize.Name)
		if name == "" {
			continue
		}

		var one model.TrafficPermitPrize
		one.Type = rewardStrMap[name]
		if one.Type == 0 {
			return prizes, errors.New("礼包配置 奖励类型错误:" + name)
		}

		one.Value = prize.Num
		prizes = append(prizes, one)
	}

	return prizes, nil
}

func (This *actTrafficPermit) packageShowConf(layConfMap []model.TrafficPermitShowConf, alertConfMap map[int64]model.TrafficPermitAlertConfig, giftRewardsMap map[int64]model.TrafficPermitOpenConf, task1ConfMap map[int64][]model.TrafficPermitTaskConf, task2ConfMap map[int64][]model.TrafficPermitTaskConf, rewardConfMap map[int64][]model.TrafficPermitRewardConf, extraReward map[int64]model.TrafficPermitReward) (showConf []model.TrafficPermitShowConf, err error) {

	var Ok bool
	for id, layer := range layConfMap {
		one := &layConfMap[id]

		if one.AlertConfig, Ok = alertConfMap[layer.Id]; !Ok {
			return showConf, errors.New(fmt.Sprintf("唯一ID:%d,未配置弹窗配置", layer.Id))
		}

		if one.PermitRewards, Ok = giftRewardsMap[layer.Id]; !Ok {
			return showConf, errors.New(fmt.Sprintf("唯一ID:%d,未配置礼包配置", layer.Id))
		}

		if one.Task1, Ok = task1ConfMap[layer.Id]; !Ok {
			return showConf, errors.New(fmt.Sprintf("唯一ID:%d,未配置单日任务配置", layer.Id))
		}

		if one.Task2, Ok = task2ConfMap[layer.Id]; !Ok {
			return showConf, errors.New(fmt.Sprintf("唯一ID:%d,未配置双日任务配置", layer.Id))
		}

		if one.Levels, Ok = rewardConfMap[layer.Id]; !Ok {
			return showConf, errors.New(fmt.Sprintf("唯一ID:%d,未配置等级奖励配置", layer.Id))
		}

		if one.MaxRewards, Ok = extraReward[layer.Id]; !Ok {
			return showConf, errors.New(fmt.Sprintf("唯一ID:%d,未配置额外奖励配置", layer.Id))
		}
	}

	return layConfMap, nil
}