iotlcm/server/internal/logic/iot/simcardbatch/warningconfig/schema.go

package warningconfig

import (
	"strings"

	"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/library/batchinput/excel"

	"github.com/gogf/gf/v2/errors/gerror"
)

const (
	cardHeaderIccid      = "ICCID"
	cardHeaderMsisdn     = "MSISDN"
	cardHeaderImsi       = "IMSI"
	cardHeaderFirstWarn  = "第一档阈值(MB)"
	cardHeaderSecondWarn = "第二档阈值(MB)"
	cardHeaderThirdWarn  = "第三档阈值(MB)"
	cardHeaderAutoAction = "第三次是否断网"

	poolHeaderCode       = "流量池编号"
	poolHeaderFirstWarn  = "第一档阈值(%)"
	poolHeaderSecondWarn = "第二档阈值(%)"
	poolHeaderThirdWarn  = "第三档阈值(%)"

	headerWarnMethods = "提醒方式"
	headerWarnPhones  = "短信号码"
	headerWarnEmails  = "邮箱地址"
	headerIsEnabled   = "是否启用"
	headerRemark      = "备注"
)

func templateHeaders(itemType int) []string {
	if itemType == warnItemTypeFlowPool {
		return []string{
			poolHeaderCode,
			poolHeaderFirstWarn,
			poolHeaderSecondWarn,
			poolHeaderThirdWarn,
			headerWarnMethods,
			headerWarnPhones,
			headerWarnEmails,
			headerIsEnabled,
			headerRemark,
		}
	}
	return []string{
		cardHeaderIccid,
		cardHeaderMsisdn,
		cardHeaderImsi,
		cardHeaderFirstWarn,
		cardHeaderSecondWarn,
		cardHeaderThirdWarn,
		cardHeaderAutoAction,
		headerWarnMethods,
		headerWarnPhones,
		headerWarnEmails,
		headerIsEnabled,
		headerRemark,
	}
}

func requiredHeaders(itemType int) []string {
	return templateHeaders(itemType)
}

func NormalizeContextOptions(itemType, warnUnit int) (Options, error) {
	itemType = normalizeItemType(itemType)
	options := Options{
		ItemType:    itemType,
		WarnType:    deriveWarnType(itemType, warnUnit),
		WarnUnit:    warnUnit,
		WarnMethods: warnMethodPlatform,
		IsEnabled:   1,
	}
	if err := validateWarnTypeUnit(itemType, options.WarnType, warnUnit); err != nil {
		return Options{}, err
	}
	return options, nil
}

func parseExcelRowOptions(parsed excel.ParsedRow, itemType, warnUnit int) (Options, error) {
	if itemType == warnItemTypeFlowPool {
		return parseRowOptions(itemType, warnUnit, []string{
			excel.Field(parsed, poolHeaderFirstWarn),
			excel.Field(parsed, poolHeaderSecondWarn),
			excel.Field(parsed, poolHeaderThirdWarn),
			excel.Field(parsed, headerWarnMethods),
			excel.Field(parsed, headerWarnPhones),
			excel.Field(parsed, headerWarnEmails),
			excel.Field(parsed, headerIsEnabled),
			excel.Field(parsed, headerRemark),
		})
	}
	return parseRowOptions(itemType, warnUnit, []string{
		excel.Field(parsed, cardHeaderFirstWarn),
		excel.Field(parsed, cardHeaderSecondWarn),
		excel.Field(parsed, cardHeaderThirdWarn),
		excel.Field(parsed, cardHeaderAutoAction),
		excel.Field(parsed, headerWarnMethods),
		excel.Field(parsed, headerWarnPhones),
		excel.Field(parsed, headerWarnEmails),
		excel.Field(parsed, headerIsEnabled),
		excel.Field(parsed, headerRemark),
	})
}

func parseRowOptions(itemType, warnUnit int, fields []string) (Options, error) {
	expected := 8
	if itemType == warnItemTypeCard {
		expected = 9
	}
	if len(fields) != expected {
		return Options{}, gerror.New("预警配置字段数量不正确")
	}

	first, err := parseRequiredAmount(fields[0], "第一档阈值")
	if err != nil {
		return Options{}, err
	}
	second, err := parseOptionalAmount(fields[1], "第二档阈值")
	if err != nil {
		return Options{}, err
	}
	third, err := parseOptionalAmount(fields[2], "第三档阈值")
	if err != nil {
		return Options{}, err
	}

	offset := 3
	autoAction := 0
	if itemType == warnItemTypeCard {
		if strings.TrimSpace(fields[offset]) != "" {
			enabled, parseErr := excel.ParseBool(fields[offset])
			if parseErr != nil {
				return Options{}, gerror.New("第三次是否断网必须填写是或否")
			}
			if enabled {
				autoAction = warnAutoActionDataCut
			}
		}
		offset++
	}

	methods, err := parseWarnMethods(fields[offset])
	if err != nil {
		return Options{}, err
	}
	phones := strings.TrimSpace(fields[offset+1])
	emails := strings.TrimSpace(fields[offset+2])
	isEnabled := 1
	if strings.TrimSpace(fields[offset+3]) != "" {
		enabled, parseErr := excel.ParseBool(fields[offset+3])
		if parseErr != nil {
			return Options{}, gerror.New("是否启用必须填写是或否")
		}
		if !enabled {
			isEnabled = 0
		}
	}

	options := Options{
		ItemType:    itemType,
		WarnType:    deriveWarnType(itemType, warnUnit),
		WarnUnit:    warnUnit,
		FirstWarn:   first,
		SecondWarn:  second,
		ThirdWarn:   third,
		WarnMethods: methods,
		WarnPhones:  phones,
		WarnEmails:  emails,
		AutoAction:  autoAction,
		IsEnabled:   isEnabled,
		Remark:      strings.TrimSpace(fields[offset+4]),
	}
	if err = validateOptions(&options); err != nil {
		return Options{}, err
	}
	return options, nil
}

func parseRequiredAmount(value, name string) (float64, error) {
	if strings.TrimSpace(value) == "" {
		return 0, gerror.Newf("%s不能为空", name)
	}
	parsed, err := excel.ParseAmount(value)
	if err != nil {
		return 0, gerror.Newf("%s必须是非负数字", name)
	}
	return parsed, nil
}

func parseOptionalAmount(value, name string) (float64, error) {
	if strings.TrimSpace(value) == "" {
		return 0, nil
	}
	parsed, err := excel.ParseAmount(value)
	if err != nil {
		return 0, gerror.Newf("%s必须是非负数字", name)
	}
	return parsed, nil
}

func parseWarnMethods(value string) (string, error) {
	if strings.TrimSpace(value) == "" {
		return "", gerror.New("提醒方式不能为空，至少填写站内提醒")
	}
	for _, method := range splitWarnList(value) {
		switch strings.ToLower(method) {
		case "0", "短信", "1", "邮箱", "2", "电话", "3", "平台消息", "站内提醒", "站内消息":
		default:
			return "", gerror.Newf("提醒方式无效：%s", method)
		}
	}
	return normalizeWarnMethods(value), nil
}

func parseInputConfig(itemType, warnUnit int, fields []string) (Options, error) {
	return parseRowOptions(itemType, warnUnit, fields)
}