Merge pull request '增加验证规则的枚举值' (#2) from feature/validator into master

Reviewed-on: #2
This commit is contained in:
白茶清欢 2025-02-07 20:52:03 +08:00
commit 8ebc73a0df
2 changed files with 629 additions and 0 deletions

View File

@ -194,3 +194,70 @@ func getDataTypeDesc(value DataType, description string) DataTypeDesc {
Description: description,
}
}
var (
// DataTypeBaseNumber 基础的int类型
DataTypeBaseNumber = []DataType{DataTypeInt, DataTypeUint, DataTypeFloat, DataTypeIntPtr, DataTypeUintPtr, DataTypeFloatPtr}
DataTypeBaseInt = []DataType{DataTypeInt, DataTypeIntPtr}
DataTypeBaseUint = []DataType{DataTypeUint, DataTypeUintPtr}
DataTypeBaseFloat = []DataType{DataTypeFloat, DataTypeFloatPtr}
DataTypeBaseString = []DataType{DataTypeString, DataTypeStringPtr}
DataTypeBaseBool = []DataType{DataTypeBool, DataTypeBoolPtr}
DataTypeSliceMarshal = []DataType{
DataTypeSliceAnyWithMarshal,
DataTypeSliceIntWithMarshal,
DataTypeSliceUintWithMarshal,
DataTypeSliceFloatWithMarshal,
DataTypeSliceBoolWithMarshal,
DataTypeSliceMapAnyAnyWithMarshal,
DataTypeSliceMapStringAnyWithMarshal,
DataTypeSliceAnyWithMarshal,
DataTypeSliceSliceWithMarshal,
}
DataTypeSliceSplit = []DataType{
DataTypeSliceIntWithChar,
DataTypeSliceUintWithChar,
DataTypeSliceFloatWithChar,
DataTypeSliceBoolWithChar,
DataTypeSliceStringWithChar,
}
DataTypeSlice = []DataType{
DataTypeSliceString,
DataTypeSliceAny,
DataTypeSliceBool,
DataTypeSliceMapStringAny,
DataTypeSliceInt,
DataTypeSliceUint,
DataTypeSliceFloat,
DataTypeSliceMapAnyAny,
DataTypeSliceSlice,
}
DataTypeMap = []DataType{
DataTypeMapStrAny,
DataTypeMapAnyAny,
DataTypeMapStrBool,
DataTypeMapStrInt,
DataTypeMapStrFloat,
DataTypeMapStrUint,
DataTypeMapStrSlice,
DataTypeMapStrStr,
}
DataTypeMapMarshal = []DataType{
DataTypeMapStrAnyWithMarshal,
DataTypeMapAnyAnyWithMarshal,
DataTypeMapStrBoolWithMarshal,
DataTypeMapStrIntWithMarshal,
DataTypeMapStrFloatWithMarshal,
DataTypeMapStrUintWithMarshal,
DataTypeMapStrSliceWithMarshal,
DataTypeMapStrStrWithMarshal,
}
)
func getMergeDataTypeList(dataTypeList ...[]DataType) []DataType {
res := []DataType{}
for _, dataTypeItemList := range dataTypeList {
res = append(res, dataTypeItemList...)
}
return res
}

562
validator.go Normal file
View File

@ -0,0 +1,562 @@
// Package consts ...
//
// Description : consts ...
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 2025-01-22 16:08
// @see: https://github.com/go-playground/validator/blob/master/README.md#strings
// @demo: https://www.cnblogs.com/zj420255586/p/13542395.html
package consts
type ValidatorRule string // 验证规则
func (vr *ValidatorRule) String() string {
if nil == vr {
return ""
}
return string(*vr)
}
func (vr *ValidatorRule) MarshalJSON() ([]byte, error) {
return []byte(vr.String()), nil
}
// IsValid 验证规则是否有效
func (vr *ValidatorRule) IsValid() bool {
_, exist := ValidatorRuleSupportDataTypeTable[*vr]
if !exist {
return false
}
rule := ValidatorRuleSupportDataTypeTable[*vr].ValidatorRule
if vr.String() != (&rule).String() {
return false
}
return exist
}
// Config 验证规则的配置
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 16:10 2025/1/22
func (vr *ValidatorRule) Config() ValidatorRuleConfig {
return ValidatorRuleSupportDataTypeTable[*vr]
}
// IsSupportDataType 是否支持指定的数据类型
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 16:11 2025/1/22
func (vr *ValidatorRule) IsSupportDataType(dataType DataType) bool {
dataTypeList := vr.Config().SupportDataTypeList
if len(dataTypeList) == 0 {
// 未配置则认为支持
return true
}
for _, dataTypeItem := range dataTypeList {
if dataType.String() == dataTypeItem.String() {
return true
}
}
return false
}
type ValidatorRuleConfig struct {
ValidatorRule ValidatorRule `json:"validator_rule"` // 验证规则
Description string `json:"description"` // 规则描述
SupportDataTypeList []DataType `json:"support_data_type_list"` // 支持的数据类型列表
MinParamCnt int `json:"min_param_cnt"` // 最小参数数量(闭区间)
MaxParamCnt int `json:"max_param_cnt"` // 最大参数数量(闭区间)
ParamCntMustEven bool `json:"param_cnt_must_even"` // 参数数量必须是偶数
WithoutParam bool `json:"without_param"` // 没有参数, 此值为 true, 忽略 MinParamCnt / MaxParamCnt / ParamCntMustEven
}
// ValidatorRuleSupportDataTypeTable 验证规则支持的数据类型表
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 16:13 2025/1/22
var ValidatorRuleSupportDataTypeTable = map[ValidatorRule]ValidatorRuleConfig{
ValidatorRuleEqcsfield: {
ValidatorRule: ValidatorRuleEqcsfield,
Description: "跨结构体字段相等",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseNumber, DataTypeBaseString, DataTypeBaseBool, DataTypeSliceMarshal, DataTypeSliceSplit, DataTypeMapMarshal),
MinParamCnt: 1,
MaxParamCnt: 1,
ParamCntMustEven: false,
},
ValidatorRuleEqfield: {
ValidatorRule: ValidatorRuleEqfield,
Description: "同结构体字段相等",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseNumber, DataTypeBaseString, DataTypeBaseBool, DataTypeSliceMarshal, DataTypeSliceSplit, DataTypeMapMarshal),
MinParamCnt: 1,
MaxParamCnt: 1,
ParamCntMustEven: false,
},
ValidatorRuleFieldcontains: {
ValidatorRule: ValidatorRuleFieldcontains,
Description: "检查指定的字段值是否存在于字段中",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseString, DataTypeSliceMarshal, DataTypeSliceSplit, DataTypeMapMarshal),
MinParamCnt: 1,
MaxParamCnt: 0,
ParamCntMustEven: false,
},
ValidatorRuleFieldexcludes: {
ValidatorRule: ValidatorRuleFieldexcludes,
Description: "检查指定的字段值是否不存在于字段中",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseString, DataTypeSliceMarshal, DataTypeSliceSplit, DataTypeMapMarshal),
MinParamCnt: 1,
MaxParamCnt: 0,
ParamCntMustEven: false,
},
ValidatorRuleGtcsfield: {
ValidatorRule: ValidatorRuleGtcsfield,
Description: "大于(跨结构体)",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseNumber),
MinParamCnt: 1,
MaxParamCnt: 1,
ParamCntMustEven: false,
},
ValidatorRuleGtecsfield: {
ValidatorRule: ValidatorRuleGtecsfield,
Description: "大于(同结构体)",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseNumber),
MinParamCnt: 1,
MaxParamCnt: 1,
ParamCntMustEven: false,
},
ValidatorRuleGtfield: {
ValidatorRule: ValidatorRuleGtfield,
Description: "大于(同结构体)",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseNumber),
MinParamCnt: 1,
MaxParamCnt: 1,
ParamCntMustEven: false,
},
ValidatorRuleGtefield: {
ValidatorRule: ValidatorRuleGtefield,
Description: "大于(同结构体)",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseNumber),
MinParamCnt: 1,
MaxParamCnt: 1,
ParamCntMustEven: false,
},
ValidatorRuleLtcsfield: {
ValidatorRule: ValidatorRuleLtcsfield,
Description: "小于(跨结构体)",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseNumber),
MinParamCnt: 1,
MaxParamCnt: 1,
ParamCntMustEven: false,
},
ValidatorRuleLtecsfield: {
ValidatorRule: ValidatorRuleLtecsfield,
Description: "小于等于(跨结构体)",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseNumber),
MinParamCnt: 1,
MaxParamCnt: 1,
ParamCntMustEven: false,
},
ValidatorRuleLtfield: {
ValidatorRule: ValidatorRuleLtfield,
Description: "小于(同结构体)",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseNumber),
MinParamCnt: 1,
MaxParamCnt: 1,
ParamCntMustEven: false,
},
ValidatorRuleLtefield: {
ValidatorRule: ValidatorRuleLtefield,
Description: "小于等于(同结构体)",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseNumber),
MinParamCnt: 1,
MaxParamCnt: 1,
ParamCntMustEven: false,
},
ValidatorRuleNecsfield: {
ValidatorRule: ValidatorRuleNecsfield,
Description: "不等于(跨结构体)",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseNumber, DataTypeBaseString, DataTypeBaseBool, DataTypeSliceMarshal, DataTypeSliceSplit, DataTypeMapMarshal),
MinParamCnt: 1,
MaxParamCnt: 1,
ParamCntMustEven: false,
},
ValidatorRuleNefield: {
ValidatorRule: ValidatorRuleNefield,
Description: "不等于(同结构体)",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseNumber, DataTypeBaseString, DataTypeBaseBool, DataTypeSliceMarshal, DataTypeSliceSplit, DataTypeMapMarshal),
MinParamCnt: 1,
MaxParamCnt: 1,
ParamCntMustEven: false,
},
ValidateRuleEq: {
ValidatorRule: ValidateRuleEq,
Description: "等于(严格校验)",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseNumber, DataTypeBaseString, DataTypeBaseBool, DataTypeSliceMarshal, DataTypeSliceSplit, DataTypeMapMarshal),
MinParamCnt: 1,
MaxParamCnt: 1,
ParamCntMustEven: false,
},
ValidateRuleEqIgnoreCase: {
ValidatorRule: ValidateRuleEqIgnoreCase,
Description: "等于(忽略大小写)",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseNumber, DataTypeBaseString, DataTypeBaseBool, DataTypeSliceMarshal, DataTypeSliceSplit, DataTypeMapMarshal),
MinParamCnt: 1,
MaxParamCnt: 1,
ParamCntMustEven: false,
},
ValidateRuleGt: {
ValidatorRule: ValidateRuleGt,
Description: "大于",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseNumber),
MinParamCnt: 1,
MaxParamCnt: 0,
ParamCntMustEven: false,
},
ValidateRuleGte: {
ValidatorRule: ValidateRuleGte,
Description: "大于等于",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseNumber),
MinParamCnt: 1,
MaxParamCnt: 0,
ParamCntMustEven: false,
},
ValidateRuleLt: {
ValidatorRule: ValidateRuleLt,
Description: "小于",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseNumber),
MinParamCnt: 1,
MaxParamCnt: 0,
ParamCntMustEven: false,
},
ValidateRuleLte: {
ValidatorRule: ValidateRuleLte,
Description: "小于等于",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseNumber),
MinParamCnt: 1,
MaxParamCnt: 0,
ParamCntMustEven: false,
},
ValidateRuleNe: {
ValidatorRule: ValidateRuleNe,
Description: "不等于(严格判断)",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseNumber, DataTypeBaseString, DataTypeBaseBool, DataTypeSliceMarshal, DataTypeSliceSplit, DataTypeMapMarshal),
MinParamCnt: 1,
MaxParamCnt: 0,
ParamCntMustEven: false,
},
ValidateRuleNeIgnoreCase: {
ValidatorRule: ValidateRuleNeIgnoreCase,
Description: "不等于(忽略大小写)",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseNumber, DataTypeBaseString, DataTypeBaseBool, DataTypeSliceMarshal, DataTypeSliceSplit, DataTypeMapMarshal),
MinParamCnt: 1,
MaxParamCnt: 0,
ParamCntMustEven: false,
},
ValidatorRuleCommonDir: {
ValidatorRule: ValidatorRuleCommonDir,
Description: "文件夹存在",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseString, DataTypeSliceMarshal, DataTypeSliceSplit, DataTypeMapMarshal),
WithoutParam: true,
},
ValidatorRuleCommonDirPath: {
ValidatorRule: ValidatorRuleCommonDirPath,
Description: "文件夹路径存在",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseString, DataTypeSliceMarshal, DataTypeSliceSplit, DataTypeMapMarshal),
WithoutParam: true,
},
ValidatorRuleCommonFile: {
ValidatorRule: ValidatorRuleCommonFile,
Description: "文件存在",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseString, DataTypeSliceMarshal, DataTypeSliceSplit, DataTypeMapMarshal),
WithoutParam: true,
},
ValidatorRuleCommonFilepath: {
ValidatorRule: ValidatorRuleCommonFilepath,
Description: "文件路径存在",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseString, DataTypeSliceMarshal, DataTypeSliceSplit, DataTypeMapMarshal),
WithoutParam: true,
},
ValidatorRuleCommonImage: {
ValidatorRule: ValidatorRuleCommonImage,
Description: "是否图像资源",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseString, DataTypeSliceMarshal, DataTypeSliceSplit, DataTypeMapMarshal),
WithoutParam: true,
},
ValidatorRuleCommonIsDefault: {
ValidatorRule: ValidatorRuleCommonIsDefault,
Description: "是否对应类型默认值",
SupportDataTypeList: nil, // 所有类型均支持
WithoutParam: true,
},
ValidatorRuleCommonLen: {
ValidatorRule: ValidatorRuleCommonLen,
Description: "数据长度",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseString, DataTypeSliceMarshal, DataTypeSliceSplit, DataTypeMapMarshal, DataTypeSlice, DataTypeMap), // 所有类型均支持
MinParamCnt: 1,
MaxParamCnt: 1,
},
ValidatorRuleCommonMax: {
ValidatorRule: ValidatorRuleCommonMax,
Description: "最大值",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseNumber),
MinParamCnt: 1,
MaxParamCnt: 1,
},
ValidatorRuleCommonMin: {
ValidatorRule: ValidatorRuleCommonMin,
Description: "最小值",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseNumber),
MinParamCnt: 1,
MaxParamCnt: 1,
},
ValidatorRuleCommonOneOf: {
ValidatorRule: ValidatorRuleCommonOneOf,
Description: "枚举值",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseNumber, DataTypeBaseString, DataTypeBaseBool),
MinParamCnt: 1,
MaxParamCnt: 0,
},
ValidatorRuleCommonRequired: {
ValidatorRule: ValidatorRuleCommonRequired,
Description: "必传校验",
SupportDataTypeList: nil, // 所有类型均支持
WithoutParam: true,
},
ValidatorRuleCommonRequiredIf: {
ValidatorRule: ValidatorRuleCommonRequiredIf,
Description: "当指定字段等于给定值时, 必传校验",
SupportDataTypeList: nil, // 所有类型均支持
MinParamCnt: 2,
MaxParamCnt: 0,
ParamCntMustEven: true,
},
ValidatorRuleCommonRequiredUnless: {
ValidatorRule: ValidatorRuleCommonRequiredUnless,
Description: "当指定字段不等于给定值时, 必传校验",
SupportDataTypeList: nil, // 所有类型均支持
MinParamCnt: 2,
MaxParamCnt: 0,
ParamCntMustEven: true,
},
ValidatorRuleCommonRequiredWith: {
ValidatorRule: ValidatorRuleCommonRequiredWith,
Description: "当任意一个指定字段不为零值时, 必传校验",
SupportDataTypeList: nil, // 所有类型均支持
MinParamCnt: 1,
MaxParamCnt: 0,
},
ValidatorRuleCommonRequiredWithAll: {
ValidatorRule: ValidatorRuleCommonRequiredWithAll,
Description: "当全部指定字段不为零值时, 必传校验",
SupportDataTypeList: nil, // 所有类型均支持
MinParamCnt: 1,
MaxParamCnt: 0,
},
ValidatorRuleCommonRequiredWithout: {
ValidatorRule: ValidatorRuleCommonRequiredWithout,
Description: "当任意一个字段不存在时, 必传校验",
SupportDataTypeList: nil, // 所有类型均支持
MinParamCnt: 1,
MaxParamCnt: 0,
},
ValidatorRuleCommonRequiredWithoutAll: {
ValidatorRule: ValidatorRuleCommonRequiredWithoutAll,
Description: "当全部字段不存在时, 必传校验",
SupportDataTypeList: nil, // 所有类型均支持
MinParamCnt: 1,
MaxParamCnt: 0,
},
ValidatorRuleCommonExcludedIf: {
ValidatorRule: ValidatorRuleCommonExcludedIf,
Description: "当指定字段等于给定值时,排除校验",
SupportDataTypeList: nil, // 所有类型均支持
},
ValidatorRuleCommonExcludedUnless: {
ValidatorRule: ValidatorRuleCommonExcludedUnless,
Description: "当指定字段等于给定值时,排除校验",
SupportDataTypeList: nil, // 所有类型均支持
MinParamCnt: 2,
MaxParamCnt: 0,
ParamCntMustEven: true,
},
ValidatorRuleCommonExcludedWith: {
ValidatorRule: ValidatorRuleCommonExcludedWith,
Description: "当全部指定字段不为零值时,排除校验",
SupportDataTypeList: nil, // 所有类型均支持
MinParamCnt: 2,
MaxParamCnt: 0,
ParamCntMustEven: true,
},
ValidatorRuleCommonExcludedWithAll: {
ValidatorRule: ValidatorRuleCommonExcludedWithAll,
Description: "当全部指定字段不为零值时,排除校验",
SupportDataTypeList: nil, // 所有类型均支持
MinParamCnt: 1,
MaxParamCnt: 0,
},
ValidatorRuleCommonExcludedWithout: {
ValidatorRule: ValidatorRuleCommonExcludedWithout,
Description: "当任意一个指定字段不存在时,排除校验",
SupportDataTypeList: nil, // 所有类型均支持
MinParamCnt: 1,
MaxParamCnt: 0,
},
ValidatorRuleCommonExcludedWithoutAll: {
ValidatorRule: ValidatorRuleCommonExcludedWithoutAll,
Description: "当全部指定字段不存在时,排除校验",
SupportDataTypeList: nil, // 所有类型均支持
MinParamCnt: 1,
MaxParamCnt: 0,
},
ValidatorRuleCommonUnique: {
ValidatorRule: ValidatorRuleCommonUnique,
Description: "是否唯一, 用于切片验证",
SupportDataTypeList: getMergeDataTypeList(DataTypeSlice), // 所有类型均支持
WithoutParam: true,
},
ValidatorRuleFormatterCron: {
ValidatorRule: ValidatorRuleFormatterCron,
Description: "cron表达式验证",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseString),
WithoutParam: true,
},
ValidatorRuleFormatterEmail: {
ValidatorRule: ValidatorRuleFormatterEmail,
Description: "邮箱地址验证",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseString),
WithoutParam: true,
},
ValidatorRuleFormatterJson: {
ValidatorRule: ValidatorRuleFormatterJson,
Description: "json格式验证",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseString),
WithoutParam: true,
},
ValidatorRuleFormatterJwt: {
ValidatorRule: ValidatorRuleFormatterJson,
Description: "JWT(JSON Web Token)验证",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseString),
WithoutParam: true,
},
ValidatorRuleFormatterLatitude: {
ValidatorRule: ValidatorRuleFormatterLatitude,
Description: "纬度验证",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseNumber),
WithoutParam: true,
},
ValidatorRuleFormatterLongitude: {
ValidatorRule: ValidatorRuleFormatterLongitude,
Description: "经度验证",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseNumber),
WithoutParam: true,
},
ValidatorRuleFormatterTimezone: {
ValidatorRule: ValidatorRuleFormatterLongitude,
Description: "时区验证",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseString),
WithoutParam: true,
},
ValidatorRuleFormatterUrl: {
ValidatorRule: ValidatorRuleFormatterUrl,
Description: "url验证",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseString),
WithoutParam: true,
},
ValidatorRuleFormatterUri: {
ValidatorRule: ValidatorRuleFormatterUrl,
Description: "uri验证",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseString),
WithoutParam: true,
},
ValidatorRuleFormatterLowercase: {
ValidatorRule: ValidatorRuleFormatterLowercase,
Description: "仅包含小写字符",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseString),
WithoutParam: true,
},
ValidatorRuleFormatterUppercase: {
ValidatorRule: ValidatorRuleFormatterUppercase,
Description: "仅包含大写字符",
SupportDataTypeList: getMergeDataTypeList(DataTypeBaseString),
WithoutParam: true,
},
}
var (
// ValidatorRuleEqcsfield .....Fields ..............
ValidatorRuleEqcsfield ValidatorRule = "eqcsfield" // 跨结构体字段相等 eqcsfield={{struct.field}}
ValidatorRuleEqfield ValidatorRule = "eqfield" // 同结构体字段相等 eqfield={{struct.field}}
ValidatorRuleFieldcontains ValidatorRule = "fieldcontains" // 检查指定的字段值是否存在于字段中 fieldcontains={{struct.field}}
ValidatorRuleFieldexcludes ValidatorRule = "fieldexcludes" // 检查指定的字段值是否存在于字段中 fieldexcludes={{struct.field}}
ValidatorRuleGtcsfield ValidatorRule = "gtcsfield" // 大于(跨结构体) gtcsfield={{struct.field}}
ValidatorRuleGtecsfield ValidatorRule = "gtecsfield" // 大于等于(跨结构体) gtecsfield={{struct.field}}
ValidatorRuleGtfield ValidatorRule = "gtfield" // 大于(同结构体) gtfield={{struct.field}}
ValidatorRuleGtefield ValidatorRule = "gtefield" // 大于等于(同结构体) gtefield={{struct.field}}
ValidatorRuleLtcsfield ValidatorRule = "ltcsfield" // 小于(跨结构体) ltcsfield={{struct.field}}
ValidatorRuleLtecsfield ValidatorRule = "ltecsfield" // 小于等于(跨结构体) ltecsfield={{struct.field}}
ValidatorRuleLtfield ValidatorRule = "ltfield" // 小于(同结构体) ltfield={{struct.field}}
ValidatorRuleLtefield ValidatorRule = "ltefield" // 小于等于(同结构体) ltefield={{struct.field}}
ValidatorRuleNecsfield ValidatorRule = "necsfield" // 不等于(跨结构体) necsfield={{struct.field}}
ValidatorRuleNefield ValidatorRule = "nefield" // 不等于(同结构体) nefield={{struct.field}}
// ValidateRuleEq Comparisons ....................
ValidateRuleEq ValidatorRule = "eq" // 相等(严格判断) eq={{any_value}}
ValidateRuleEqIgnoreCase ValidatorRule = "eq_ignore_case" // 相等(忽略大小写) eq_ignore_case={{any_value}}
ValidateRuleGt ValidatorRule = "gt" // 大于 gt={{number_value}}
ValidateRuleGte ValidatorRule = "gte" // 大于等于 gte={{number_value}}
ValidateRuleLt ValidatorRule = "lt" // 小于 lt={{number_value}}
ValidateRuleLte ValidatorRule = "lte" // 小于等于 lte={{number_value}}
ValidateRuleNe ValidatorRule = "ne" // 不相等(严格判断) ne={{any_value}}
ValidateRuleNeIgnoreCase ValidatorRule = "ne_ignore_case" // 不相等(忽略大小写) ne_ignore_case={{any_value}}
// ValidatorRuleCommonDir ............others
ValidatorRuleCommonDir ValidatorRule = "dir" // 文件夹存在
ValidatorRuleCommonDirPath ValidatorRule = "dirpath" // 文件夹路径
ValidatorRuleCommonFile ValidatorRule = "file" // 文件存在
ValidatorRuleCommonFilepath ValidatorRule = "filepath" // 文件路径
ValidatorRuleCommonImage ValidatorRule = "image" // 图像
ValidatorRuleCommonIsDefault ValidatorRule = "isdefault" // 是否默认值
ValidatorRuleCommonLen ValidatorRule = "len" // 长度 len={{uint_value}}
ValidatorRuleCommonMax ValidatorRule = "max" // 最大值 max={{int_value}}
ValidatorRuleCommonMin ValidatorRule = "min" // 最小值 min={{int_value}}
ValidatorRuleCommonOneOf ValidatorRule = "oneof" // 枚举值, 多个空格分隔 oneof={{enum1}} {{enum2}} {{enum....}}
ValidatorRuleCommonRequired ValidatorRule = "required" // 必传
ValidatorRuleCommonRequiredIf ValidatorRule = "required_if" // 当指定字段等于给定值时,校验必传 required_if={{check_field}} {{check_field_value}} {{check_field...}} {{check_field_value...}}
ValidatorRuleCommonRequiredUnless ValidatorRule = "required_unless" // 当指定字段不等于给定值时,校验必传 required_if={{check_field}} {{check_field_value}} {{check_field...}} {{check_field_value...}}
ValidatorRuleCommonRequiredWith ValidatorRule = "required_with" // 当任意一个指定字段不为零值时, 校验必传 required_with={{Field1}} {{Field2}} {{Field...}}
ValidatorRuleCommonRequiredWithAll ValidatorRule = "required_with_all" // 当全部指定字段不为零值时, 校验必传 required_with={{Field1}} {{Field2}} {{Field...}}
ValidatorRuleCommonRequiredWithout ValidatorRule = "required_without" // 任意一个字段为空时,必传校验 required_without={{Field1}} {{Field2}} {{Field...}}
ValidatorRuleCommonRequiredWithoutAll ValidatorRule = "required_without_all" // 全部字段为空时,必传校验 required_without_all={{Field1}} {{Field2}} {{Field...}}
ValidatorRuleCommonExcludedIf ValidatorRule = "excluded_if" // 当指定字段等于给定值时,排除校验 excluded_if={{check_field}} {{check_field_value}} {{check_field...}} {{check_field_value...}}
ValidatorRuleCommonExcludedUnless ValidatorRule = "excluded_unless" // 当指定字段不等于给定值时,排除校验 excluded_if={{check_field}} {{check_field_value}} {{check_field...}} {{check_field_value...}}
ValidatorRuleCommonExcludedWith ValidatorRule = "excluded_with" // 当任意一个指定字段不为零值时,排除校验 excluded_with={{Field1}} {{Field2}} {{Field...}}
ValidatorRuleCommonExcludedWithAll ValidatorRule = "excluded_with_all" // 当全部指定字段不为零值时,排除校验 excluded_with_all={{Field1}} {{Field2}} {{Field...}}
ValidatorRuleCommonExcludedWithout ValidatorRule = "excluded_without" // 当任意一个指定字段不存在时,排除校验 excluded_without={{Field1}} {{Field2}} {{Field...}}
ValidatorRuleCommonExcludedWithoutAll ValidatorRule = "excluded_without_all" // 当q廍指定字段不存在时,排除校验 excluded_without-all={{Field1}} {{Field2}} {{Field...}}
ValidatorRuleCommonUnique ValidatorRule = "unique" // 数据唯一校验
// ValidatorRuleFormatterCron ............. formatter
ValidatorRuleFormatterCron ValidatorRule = "cron" // cron表达式
ValidatorRuleFormatterEmail ValidatorRule = "email" // 邮件地址
ValidatorRuleFormatterJson ValidatorRule = "json" // json格式
ValidatorRuleFormatterJwt ValidatorRule = "jwt" // JSON Web Token (JWT)
ValidatorRuleFormatterLatitude ValidatorRule = "latitude" // 纬度
ValidatorRuleFormatterLongitude ValidatorRule = "longitude" // 经度
ValidatorRuleFormatterTimezone ValidatorRule = "timezone" // 时区
ValidatorRuleFormatterUrl ValidatorRule = "url" // url
ValidatorRuleFormatterUri ValidatorRule = "uri" // uri
ValidatorRuleFormatterLowercase ValidatorRule = "lowercase" // 仅包含小写字符
ValidatorRuleFormatterUppercase ValidatorRule = "uppercase" // 仅包含大写字符
)
// RegisterCustomValidatorRule 注册自定义的验证方法, 允许通过此函数, 覆盖内部默认的配置
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 18:35 2025/1/24
func RegisterCustomValidatorRule(rule ValidatorRule, validatorRuleConfig ValidatorRuleConfig) {
ValidatorRuleSupportDataTypeTable[rule] = validatorRuleConfig
}