feat: code cleanup

validate_rule.go

@@ -1,165 +0,0 @@
-// Package api_doc ...
-//
-// Description : api_doc ...
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 2025-02-13 15:26
-package api_doc
-
-import (
-	"reflect"
-	"strconv"
-	"strings"
-
-	"git.zhangdeman.cn/zhangdeman/consts"
-)
-
-var (
-	ValidateRule = validateRule{}
-)
-
-type validateRule struct{}
-
-// IsRequired 判断是否必传
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 15:32 2025/2/13
-func (r validateRule) IsRequired(structField reflect.StructField) bool {
-	ruleTable := r.getValidateRuleTable(structField)
-	_, exist := ruleTable[consts.ValidatorRuleCommonRequired.String()]
-	// 存在即为必传
-	return exist
-}
-
-// Enum 获取枚举值
-func (r validateRule) Enum(structField reflect.StructField) []any {
-	ruleTable := r.getValidateRuleTable(structField)
-	oneOfValue, _ := ruleTable[consts.ValidatorRuleCommonOneOf.String()]
-	if len(oneOfValue) == 0 {
-		return []any{}
-	}
-	fieldType := structField.Type.Kind().String()
-	valStrArr := strings.Split(oneOfValue, " ")
-	anySlice := make([]any, 0)
-	for _, val := range valStrArr {
-		if strings.HasPrefix(fieldType, "int") {
-			i, _ := strconv.Atoi(val)
-			anySlice = append(anySlice, i)
-			continue
-		}
-		if strings.HasPrefix(fieldType, "uint") {
-			uintVal, _ := strconv.ParseUint(val, 10, 64)
-			anySlice = append(anySlice, uintVal)
-			continue
-		}
-		if strings.HasPrefix(fieldType, "float") {
-			floatVal, _ := strconv.ParseFloat(val, 64)
-			anySlice = append(anySlice, floatVal)
-			continue
-		}
-		if strings.HasPrefix(fieldType, "string") {
-			anySlice = append(anySlice, val)
-			continue
-		}
-		if strings.HasPrefix(fieldType, "bool") {
-			if val == "true" {
-				anySlice = append(anySlice, true)
-			} else {
-				anySlice = append(anySlice, false)
-			}
-			continue
-		}
-	}
-	return anySlice
-}
-
-// Minimum 最小值
-func (r validateRule) Minimum(structField reflect.StructField) *int64 {
-	ruleTable := r.getValidateRuleTable(structField)
-	var (
-		err                      error
-		minVal, gteVal           int64
-		minStr, gteStr           string
-		minStrExist, gteStrExist bool
-	)
-	if minStr, minStrExist = ruleTable[consts.ValidatorRuleCommonMin.String()]; minStrExist && len(minStr) > 0 {
-		if minVal, err = strconv.ParseInt(minStr, 10, 64); nil != err {
-			panic("validate rule min val = " + minStr + " : " + err.Error())
-		}
-	}
-	if gteStr, gteStrExist = ruleTable[consts.ValidateRuleGte.String()]; gteStrExist && len(gteStr) > 0 {
-		if gteVal, err = strconv.ParseInt(gteStr, 10, 64); nil != err {
-			panic("validate rule gte val = " + gteStr + " : " + err.Error())
-		}
-	}
-	if !minStrExist && !gteStrExist {
-		// 未配置
-		return nil
-	}
-	if len(minStr) > 0 {
-		if len(gteStr) > 0 {
-			if gteVal > minVal {
-				return &minVal
-			}
-			return &gteVal
-		}
-		return &minVal
-	}
-	return &gteVal
-}
-
-// Maximum 最大值
-func (r validateRule) Maximum(structField reflect.StructField) *int64 {
-	ruleTable := r.getValidateRuleTable(structField)
-	var (
-		err                      error
-		maxVal, lteVal           int64
-		maxStr, lteStr           string
-		maxStrExist, gleStrExist bool
-	)
-	if maxStr, maxStrExist = ruleTable[consts.ValidatorRuleCommonMax.String()]; maxStrExist && len(maxStr) > 0 {
-		if maxVal, err = strconv.ParseInt(maxStr, 10, 64); nil != err {
-			panic("validate rule min val = " + maxStr + " : " + err.Error())
-		}
-	}
-	if lteStr, gleStrExist = ruleTable[consts.ValidateRuleLte.String()]; gleStrExist && len(lteStr) > 0 {
-		if lteVal, err = strconv.ParseInt(lteStr, 10, 64); nil != err {
-			panic("validate rule gte val = " + lteStr + " : " + err.Error())
-		}
-	}
-	if !maxStrExist && !gleStrExist {
-		// 未配置
-		return nil
-	}
-	if len(maxStr) > 0 {
-		if len(lteStr) > 0 {
-			if lteVal > maxVal {
-				return &lteVal
-			}
-			return &maxVal
-		}
-		return &maxVal
-	}
-	return &lteVal
-}
-
-// getValidateRuleTable 解析验证规则表
-func (r validateRule) getValidateRuleTable(structField reflect.StructField) map[string]string {
-	res := map[string]string{}
-	ruleStr := ParseStructFieldTag.GetValidateRule(structField)
-	if len(ruleStr) == 0 {
-		return res
-	}
-	expressList := strings.Split(ruleStr, ",")
-	for _, item := range expressList {
-		if strings.Contains(item, "=") {
-			arr := strings.Split(item, "=")
-			res[strings.TrimSpace(arr[0])] = strings.Join(arr[1:], "=")
-		} else {
-			res[strings.TrimSpace(item)] = ""
-		}
-	}
-	return res
-}