mirror of
https://github.com/superseriousbusiness/gotosocial
synced 2025-06-05 21:59:39 +02:00
[chore]: Bump github.com/gin-contrib/gzip from 1.0.1 to 1.1.0 (#3639)
Bumps [github.com/gin-contrib/gzip](https://github.com/gin-contrib/gzip) from 1.0.1 to 1.1.0. - [Release notes](https://github.com/gin-contrib/gzip/releases) - [Changelog](https://github.com/gin-contrib/gzip/blob/master/.goreleaser.yaml) - [Commits](https://github.com/gin-contrib/gzip/compare/v1.0.1...v1.1.0) --- updated-dependencies: - dependency-name: github.com/gin-contrib/gzip dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
This commit is contained in:
dependabot[bot]
GitHub
3
vendor/github.com/go-playground/validator/v10/README.md
generated
vendored
3
vendor/github.com/go-playground/validator/v10/README.md
generated
vendored
@ -1,7 +1,7 @@
|
||||
Package validator
|
||||
=================
|
||||
<img align="right" src="logo.png">[](https://gitter.im/go-playground/validator?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
|
||||
|
||||
|
||||
[](https://travis-ci.org/go-playground/validator)
|
||||
[](https://coveralls.io/github/go-playground/validator?branch=master)
|
||||
[](https://goreportcard.com/report/github.com/go-playground/validator)
|
||||
@ -163,6 +163,7 @@ validate := validator.New(validator.WithRequiredStructEnabled())
|
||||
| btc_addr_bech32 | Bitcoin Bech32 Address (segwit) |
|
||||
| credit_card | Credit Card Number |
|
||||
| mongodb | MongoDB ObjectID |
|
||||
| mongodb_connection_string | MongoDB Connection String |
|
||||
| cron | Cron |
|
||||
| spicedb | SpiceDb ObjectID/Permission/Type |
|
||||
| datetime | Datetime |
|
||||
|
||||
209
vendor/github.com/go-playground/validator/v10/baked_in.go
generated
vendored
209
vendor/github.com/go-playground/validator/v10/baked_in.go
generated
vendored
@ -205,6 +205,7 @@ var (
|
||||
"fqdn": isFQDN,
|
||||
"unique": isUnique,
|
||||
"oneof": isOneOf,
|
||||
"oneofci": isOneOfCI,
|
||||
"html": isHTML,
|
||||
"html_encoded": isHTMLEncoded,
|
||||
"url_encoded": isURLEncoded,
|
||||
@ -213,6 +214,7 @@ var (
|
||||
"json": isJSON,
|
||||
"jwt": isJWT,
|
||||
"hostname_port": isHostnamePort,
|
||||
"port": isPort,
|
||||
"lowercase": isLowercase,
|
||||
"uppercase": isUppercase,
|
||||
"datetime": isDatetime,
|
||||
@ -235,7 +237,8 @@ var (
|
||||
"credit_card": isCreditCard,
|
||||
"cve": isCveFormat,
|
||||
"luhn_checksum": hasLuhnChecksum,
|
||||
"mongodb": isMongoDB,
|
||||
"mongodb": isMongoDBObjectId,
|
||||
"mongodb_connection_string": isMongoDBConnectionString,
|
||||
"cron": isCron,
|
||||
"spicedb": isSpiceDB,
|
||||
}
|
||||
@ -252,7 +255,7 @@ func parseOneOfParam2(s string) []string {
|
||||
oneofValsCacheRWLock.RUnlock()
|
||||
if !ok {
|
||||
oneofValsCacheRWLock.Lock()
|
||||
vals = splitParamsRegex.FindAllString(s, -1)
|
||||
vals = splitParamsRegex().FindAllString(s, -1)
|
||||
for i := 0; i < len(vals); i++ {
|
||||
vals[i] = strings.Replace(vals[i], "'", "", -1)
|
||||
}
|
||||
@ -263,15 +266,15 @@ func parseOneOfParam2(s string) []string {
|
||||
}
|
||||
|
||||
func isURLEncoded(fl FieldLevel) bool {
|
||||
return uRLEncodedRegex.MatchString(fl.Field().String())
|
||||
return uRLEncodedRegex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
func isHTMLEncoded(fl FieldLevel) bool {
|
||||
return hTMLEncodedRegex.MatchString(fl.Field().String())
|
||||
return hTMLEncodedRegex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
func isHTML(fl FieldLevel) bool {
|
||||
return hTMLRegex.MatchString(fl.Field().String())
|
||||
return hTMLRegex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
func isOneOf(fl FieldLevel) bool {
|
||||
@ -298,6 +301,23 @@ func isOneOf(fl FieldLevel) bool {
|
||||
return false
|
||||
}
|
||||
|
||||
// isOneOfCI is the validation function for validating if the current field's value is one of the provided string values (case insensitive).
|
||||
func isOneOfCI(fl FieldLevel) bool {
|
||||
vals := parseOneOfParam2(fl.Param())
|
||||
field := fl.Field()
|
||||
|
||||
if field.Kind() != reflect.String {
|
||||
panic(fmt.Sprintf("Bad field type %T", field.Interface()))
|
||||
}
|
||||
v := field.String()
|
||||
for _, val := range vals {
|
||||
if strings.EqualFold(val, v) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// isUnique is the validation function for validating if each array|slice|map value is unique
|
||||
func isUnique(fl FieldLevel) bool {
|
||||
field := fl.Field()
|
||||
@ -428,7 +448,7 @@ func isSSN(fl FieldLevel) bool {
|
||||
return false
|
||||
}
|
||||
|
||||
return sSNRegex.MatchString(field.String())
|
||||
return sSNRegex().MatchString(field.String())
|
||||
}
|
||||
|
||||
// isLongitude is the validation function for validating if the field's value is a valid longitude coordinate.
|
||||
@ -451,7 +471,7 @@ func isLongitude(fl FieldLevel) bool {
|
||||
panic(fmt.Sprintf("Bad field type %T", field.Interface()))
|
||||
}
|
||||
|
||||
return longitudeRegex.MatchString(v)
|
||||
return longitudeRegex().MatchString(v)
|
||||
}
|
||||
|
||||
// isLatitude is the validation function for validating if the field's value is a valid latitude coordinate.
|
||||
@ -474,7 +494,7 @@ func isLatitude(fl FieldLevel) bool {
|
||||
panic(fmt.Sprintf("Bad field type %T", field.Interface()))
|
||||
}
|
||||
|
||||
return latitudeRegex.MatchString(v)
|
||||
return latitudeRegex().MatchString(v)
|
||||
}
|
||||
|
||||
// isDataURI is the validation function for validating if the field's value is a valid data URI.
|
||||
@ -485,11 +505,11 @@ func isDataURI(fl FieldLevel) bool {
|
||||
return false
|
||||
}
|
||||
|
||||
if !dataURIRegex.MatchString(uri[0]) {
|
||||
if !dataURIRegex().MatchString(uri[0]) {
|
||||
return false
|
||||
}
|
||||
|
||||
return base64Regex.MatchString(uri[1])
|
||||
return base64Regex().MatchString(uri[1])
|
||||
}
|
||||
|
||||
// hasMultiByteCharacter is the validation function for validating if the field's value has a multi byte character.
|
||||
@ -500,17 +520,17 @@ func hasMultiByteCharacter(fl FieldLevel) bool {
|
||||
return true
|
||||
}
|
||||
|
||||
return multibyteRegex.MatchString(field.String())
|
||||
return multibyteRegex().MatchString(field.String())
|
||||
}
|
||||
|
||||
// isPrintableASCII is the validation function for validating if the field's value is a valid printable ASCII character.
|
||||
func isPrintableASCII(fl FieldLevel) bool {
|
||||
return printableASCIIRegex.MatchString(fl.Field().String())
|
||||
return printableASCIIRegex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isASCII is the validation function for validating if the field's value is a valid ASCII character.
|
||||
func isASCII(fl FieldLevel) bool {
|
||||
return aSCIIRegex.MatchString(fl.Field().String())
|
||||
return aSCIIRegex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isUUID5 is the validation function for validating if the field's value is a valid v5 UUID.
|
||||
@ -560,52 +580,52 @@ func isULID(fl FieldLevel) bool {
|
||||
|
||||
// isMD4 is the validation function for validating if the field's value is a valid MD4.
|
||||
func isMD4(fl FieldLevel) bool {
|
||||
return md4Regex.MatchString(fl.Field().String())
|
||||
return md4Regex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isMD5 is the validation function for validating if the field's value is a valid MD5.
|
||||
func isMD5(fl FieldLevel) bool {
|
||||
return md5Regex.MatchString(fl.Field().String())
|
||||
return md5Regex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isSHA256 is the validation function for validating if the field's value is a valid SHA256.
|
||||
func isSHA256(fl FieldLevel) bool {
|
||||
return sha256Regex.MatchString(fl.Field().String())
|
||||
return sha256Regex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isSHA384 is the validation function for validating if the field's value is a valid SHA384.
|
||||
func isSHA384(fl FieldLevel) bool {
|
||||
return sha384Regex.MatchString(fl.Field().String())
|
||||
return sha384Regex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isSHA512 is the validation function for validating if the field's value is a valid SHA512.
|
||||
func isSHA512(fl FieldLevel) bool {
|
||||
return sha512Regex.MatchString(fl.Field().String())
|
||||
return sha512Regex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isRIPEMD128 is the validation function for validating if the field's value is a valid PIPEMD128.
|
||||
func isRIPEMD128(fl FieldLevel) bool {
|
||||
return ripemd128Regex.MatchString(fl.Field().String())
|
||||
return ripemd128Regex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isRIPEMD160 is the validation function for validating if the field's value is a valid PIPEMD160.
|
||||
func isRIPEMD160(fl FieldLevel) bool {
|
||||
return ripemd160Regex.MatchString(fl.Field().String())
|
||||
return ripemd160Regex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isTIGER128 is the validation function for validating if the field's value is a valid TIGER128.
|
||||
func isTIGER128(fl FieldLevel) bool {
|
||||
return tiger128Regex.MatchString(fl.Field().String())
|
||||
return tiger128Regex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isTIGER160 is the validation function for validating if the field's value is a valid TIGER160.
|
||||
func isTIGER160(fl FieldLevel) bool {
|
||||
return tiger160Regex.MatchString(fl.Field().String())
|
||||
return tiger160Regex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isTIGER192 is the validation function for validating if the field's value is a valid isTIGER192.
|
||||
func isTIGER192(fl FieldLevel) bool {
|
||||
return tiger192Regex.MatchString(fl.Field().String())
|
||||
return tiger192Regex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isISBN is the validation function for validating if the field's value is a valid v10 or v13 ISBN.
|
||||
@ -617,7 +637,7 @@ func isISBN(fl FieldLevel) bool {
|
||||
func isISBN13(fl FieldLevel) bool {
|
||||
s := strings.Replace(strings.Replace(fl.Field().String(), "-", "", 4), " ", "", 4)
|
||||
|
||||
if !iSBN13Regex.MatchString(s) {
|
||||
if !iSBN13Regex().MatchString(s) {
|
||||
return false
|
||||
}
|
||||
|
||||
@ -637,7 +657,7 @@ func isISBN13(fl FieldLevel) bool {
|
||||
func isISBN10(fl FieldLevel) bool {
|
||||
s := strings.Replace(strings.Replace(fl.Field().String(), "-", "", 3), " ", "", 3)
|
||||
|
||||
if !iSBN10Regex.MatchString(s) {
|
||||
if !iSBN10Regex().MatchString(s) {
|
||||
return false
|
||||
}
|
||||
|
||||
@ -661,7 +681,7 @@ func isISBN10(fl FieldLevel) bool {
|
||||
func isISSN(fl FieldLevel) bool {
|
||||
s := fl.Field().String()
|
||||
|
||||
if !iSSNRegex.MatchString(s) {
|
||||
if !iSSNRegex().MatchString(s) {
|
||||
return false
|
||||
}
|
||||
s = strings.ReplaceAll(s, "-", "")
|
||||
@ -687,14 +707,14 @@ func isISSN(fl FieldLevel) bool {
|
||||
func isEthereumAddress(fl FieldLevel) bool {
|
||||
address := fl.Field().String()
|
||||
|
||||
return ethAddressRegex.MatchString(address)
|
||||
return ethAddressRegex().MatchString(address)
|
||||
}
|
||||
|
||||
// isEthereumAddressChecksum is the validation function for validating if the field's value is a valid checksumed Ethereum address.
|
||||
// isEthereumAddressChecksum is the validation function for validating if the field's value is a valid checksummed Ethereum address.
|
||||
func isEthereumAddressChecksum(fl FieldLevel) bool {
|
||||
address := fl.Field().String()
|
||||
|
||||
if !ethAddressRegex.MatchString(address) {
|
||||
if !ethAddressRegex().MatchString(address) {
|
||||
return false
|
||||
}
|
||||
// Checksum validation. Reference: https://github.com/ethereum/EIPs/blob/master/EIPS/eip-55.md
|
||||
@ -720,7 +740,7 @@ func isEthereumAddressChecksum(fl FieldLevel) bool {
|
||||
func isBitcoinAddress(fl FieldLevel) bool {
|
||||
address := fl.Field().String()
|
||||
|
||||
if !btcAddressRegex.MatchString(address) {
|
||||
if !btcAddressRegex().MatchString(address) {
|
||||
return false
|
||||
}
|
||||
|
||||
@ -757,7 +777,7 @@ func isBitcoinAddress(fl FieldLevel) bool {
|
||||
func isBitcoinBech32Address(fl FieldLevel) bool {
|
||||
address := fl.Field().String()
|
||||
|
||||
if !btcLowerAddressRegexBech32.MatchString(address) && !btcUpperAddressRegexBech32.MatchString(address) {
|
||||
if !btcLowerAddressRegexBech32().MatchString(address) && !btcUpperAddressRegexBech32().MatchString(address) {
|
||||
return false
|
||||
}
|
||||
|
||||
@ -1369,6 +1389,7 @@ func isPostcodeByIso3166Alpha2(fl FieldLevel) bool {
|
||||
field := fl.Field()
|
||||
param := fl.Param()
|
||||
|
||||
postcodeRegexInit.Do(initPostcodes)
|
||||
reg, found := postCodeRegexDict[param]
|
||||
if !found {
|
||||
return false
|
||||
@ -1406,22 +1427,22 @@ func isPostcodeByIso3166Alpha2Field(fl FieldLevel) bool {
|
||||
|
||||
// isBase32 is the validation function for validating if the current field's value is a valid base 32.
|
||||
func isBase32(fl FieldLevel) bool {
|
||||
return base32Regex.MatchString(fl.Field().String())
|
||||
return base32Regex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isBase64 is the validation function for validating if the current field's value is a valid base 64.
|
||||
func isBase64(fl FieldLevel) bool {
|
||||
return base64Regex.MatchString(fl.Field().String())
|
||||
return base64Regex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isBase64URL is the validation function for validating if the current field's value is a valid base64 URL safe string.
|
||||
func isBase64URL(fl FieldLevel) bool {
|
||||
return base64URLRegex.MatchString(fl.Field().String())
|
||||
return base64URLRegex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isBase64RawURL is the validation function for validating if the current field's value is a valid base64 URL safe string without '=' padding.
|
||||
func isBase64RawURL(fl FieldLevel) bool {
|
||||
return base64RawURLRegex.MatchString(fl.Field().String())
|
||||
return base64RawURLRegex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isURI is the validation function for validating if the current field's value is a valid URI.
|
||||
@ -1667,42 +1688,42 @@ func isFilePath(fl FieldLevel) bool {
|
||||
|
||||
// isE164 is the validation function for validating if the current field's value is a valid e.164 formatted phone number.
|
||||
func isE164(fl FieldLevel) bool {
|
||||
return e164Regex.MatchString(fl.Field().String())
|
||||
return e164Regex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isEmail is the validation function for validating if the current field's value is a valid email address.
|
||||
func isEmail(fl FieldLevel) bool {
|
||||
return emailRegex.MatchString(fl.Field().String())
|
||||
return emailRegex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isHSLA is the validation function for validating if the current field's value is a valid HSLA color.
|
||||
func isHSLA(fl FieldLevel) bool {
|
||||
return hslaRegex.MatchString(fl.Field().String())
|
||||
return hslaRegex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isHSL is the validation function for validating if the current field's value is a valid HSL color.
|
||||
func isHSL(fl FieldLevel) bool {
|
||||
return hslRegex.MatchString(fl.Field().String())
|
||||
return hslRegex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isRGBA is the validation function for validating if the current field's value is a valid RGBA color.
|
||||
func isRGBA(fl FieldLevel) bool {
|
||||
return rgbaRegex.MatchString(fl.Field().String())
|
||||
return rgbaRegex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isRGB is the validation function for validating if the current field's value is a valid RGB color.
|
||||
func isRGB(fl FieldLevel) bool {
|
||||
return rgbRegex.MatchString(fl.Field().String())
|
||||
return rgbRegex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isHEXColor is the validation function for validating if the current field's value is a valid HEX color.
|
||||
func isHEXColor(fl FieldLevel) bool {
|
||||
return hexColorRegex.MatchString(fl.Field().String())
|
||||
return hexColorRegex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isHexadecimal is the validation function for validating if the current field's value is a valid hexadecimal.
|
||||
func isHexadecimal(fl FieldLevel) bool {
|
||||
return hexadecimalRegex.MatchString(fl.Field().String())
|
||||
return hexadecimalRegex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isNumber is the validation function for validating if the current field's value is a valid number.
|
||||
@ -1711,7 +1732,7 @@ func isNumber(fl FieldLevel) bool {
|
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr, reflect.Float32, reflect.Float64:
|
||||
return true
|
||||
default:
|
||||
return numberRegex.MatchString(fl.Field().String())
|
||||
return numberRegex().MatchString(fl.Field().String())
|
||||
}
|
||||
}
|
||||
|
||||
@ -1721,28 +1742,28 @@ func isNumeric(fl FieldLevel) bool {
|
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr, reflect.Float32, reflect.Float64:
|
||||
return true
|
||||
default:
|
||||
return numericRegex.MatchString(fl.Field().String())
|
||||
return numericRegex().MatchString(fl.Field().String())
|
||||
}
|
||||
}
|
||||
|
||||
// isAlphanum is the validation function for validating if the current field's value is a valid alphanumeric value.
|
||||
func isAlphanum(fl FieldLevel) bool {
|
||||
return alphaNumericRegex.MatchString(fl.Field().String())
|
||||
return alphaNumericRegex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isAlpha is the validation function for validating if the current field's value is a valid alpha value.
|
||||
func isAlpha(fl FieldLevel) bool {
|
||||
return alphaRegex.MatchString(fl.Field().String())
|
||||
return alphaRegex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isAlphanumUnicode is the validation function for validating if the current field's value is a valid alphanumeric unicode value.
|
||||
func isAlphanumUnicode(fl FieldLevel) bool {
|
||||
return alphaUnicodeNumericRegex.MatchString(fl.Field().String())
|
||||
return alphaUnicodeNumericRegex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isAlphaUnicode is the validation function for validating if the current field's value is a valid alpha unicode value.
|
||||
func isAlphaUnicode(fl FieldLevel) bool {
|
||||
return alphaUnicodeRegex.MatchString(fl.Field().String())
|
||||
return alphaUnicodeRegex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isBoolean is the validation function for validating if the current field's value is a valid boolean value or can be safely converted to a boolean value.
|
||||
@ -1826,7 +1847,14 @@ func requireCheckFieldValue(
|
||||
return int64(field.Len()) == asInt(value)
|
||||
|
||||
case reflect.Bool:
|
||||
return field.Bool() == asBool(value)
|
||||
return field.Bool() == (value == "true")
|
||||
|
||||
case reflect.Ptr:
|
||||
if field.IsNil() {
|
||||
return value == "nil"
|
||||
}
|
||||
// Handle non-nil pointers
|
||||
return requireCheckFieldValue(fl, param, value, defaultNotFoundValue)
|
||||
}
|
||||
|
||||
// default reflect.String:
|
||||
@ -2565,11 +2593,11 @@ func isIP6Addr(fl FieldLevel) bool {
|
||||
}
|
||||
|
||||
func isHostnameRFC952(fl FieldLevel) bool {
|
||||
return hostnameRegexRFC952.MatchString(fl.Field().String())
|
||||
return hostnameRegexRFC952().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
func isHostnameRFC1123(fl FieldLevel) bool {
|
||||
return hostnameRegexRFC1123.MatchString(fl.Field().String())
|
||||
return hostnameRegexRFC1123().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
func isFQDN(fl FieldLevel) bool {
|
||||
@ -2579,7 +2607,7 @@ func isFQDN(fl FieldLevel) bool {
|
||||
return false
|
||||
}
|
||||
|
||||
return fqdnRegexRFC1123.MatchString(val)
|
||||
return fqdnRegexRFC1123().MatchString(val)
|
||||
}
|
||||
|
||||
// isDir is the validation function for validating if the current field's value is a valid existing directory.
|
||||
@ -2678,7 +2706,7 @@ func isJSON(fl FieldLevel) bool {
|
||||
|
||||
// isJWT is the validation function for validating if the current field's value is a valid JWT string.
|
||||
func isJWT(fl FieldLevel) bool {
|
||||
return jWTRegex.MatchString(fl.Field().String())
|
||||
return jWTRegex().MatchString(fl.Field().String())
|
||||
}
|
||||
|
||||
// isHostnamePort validates a <dns>:<port> combination for fields typically used for socket address.
|
||||
@ -2697,11 +2725,18 @@ func isHostnamePort(fl FieldLevel) bool {
|
||||
|
||||
// If host is specified, it should match a DNS name
|
||||
if host != "" {
|
||||
return hostnameRegexRFC1123.MatchString(host)
|
||||
return hostnameRegexRFC1123().MatchString(host)
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// IsPort validates if the current field's value represents a valid port
|
||||
func isPort(fl FieldLevel) bool {
|
||||
val := fl.Field().Uint()
|
||||
|
||||
return val >= 1 && val <= 65535
|
||||
}
|
||||
|
||||
// isLowercase is the validation function for validating if the current field's value is a lowercase string.
|
||||
func isLowercase(fl FieldLevel) bool {
|
||||
field := fl.Field()
|
||||
@ -2768,26 +2803,26 @@ func isTimeZone(fl FieldLevel) bool {
|
||||
|
||||
// isIso3166Alpha2 is the validation function for validating if the current field's value is a valid iso3166-1 alpha-2 country code.
|
||||
func isIso3166Alpha2(fl FieldLevel) bool {
|
||||
val := fl.Field().String()
|
||||
return iso3166_1_alpha2[val]
|
||||
_, ok := iso3166_1_alpha2[fl.Field().String()]
|
||||
return ok
|
||||
}
|
||||
|
||||
// isIso3166Alpha2EU is the validation function for validating if the current field's value is a valid iso3166-1 alpha-2 European Union country code.
|
||||
func isIso3166Alpha2EU(fl FieldLevel) bool {
|
||||
val := fl.Field().String()
|
||||
return iso3166_1_alpha2_eu[val]
|
||||
_, ok := iso3166_1_alpha2_eu[fl.Field().String()]
|
||||
return ok
|
||||
}
|
||||
|
||||
// isIso3166Alpha3 is the validation function for validating if the current field's value is a valid iso3166-1 alpha-3 country code.
|
||||
func isIso3166Alpha3(fl FieldLevel) bool {
|
||||
val := fl.Field().String()
|
||||
return iso3166_1_alpha3[val]
|
||||
_, ok := iso3166_1_alpha3[fl.Field().String()]
|
||||
return ok
|
||||
}
|
||||
|
||||
// isIso3166Alpha3EU is the validation function for validating if the current field's value is a valid iso3166-1 alpha-3 European Union country code.
|
||||
func isIso3166Alpha3EU(fl FieldLevel) bool {
|
||||
val := fl.Field().String()
|
||||
return iso3166_1_alpha3_eu[val]
|
||||
_, ok := iso3166_1_alpha3_eu[fl.Field().String()]
|
||||
return ok
|
||||
}
|
||||
|
||||
// isIso3166AlphaNumeric is the validation function for validating if the current field's value is a valid iso3166-1 alpha-numeric country code.
|
||||
@ -2809,7 +2844,9 @@ func isIso3166AlphaNumeric(fl FieldLevel) bool {
|
||||
default:
|
||||
panic(fmt.Sprintf("Bad field type %T", field.Interface()))
|
||||
}
|
||||
return iso3166_1_alpha_numeric[code]
|
||||
|
||||
_, ok := iso3166_1_alpha_numeric[code]
|
||||
return ok
|
||||
}
|
||||
|
||||
// isIso3166AlphaNumericEU is the validation function for validating if the current field's value is a valid iso3166-1 alpha-numeric European Union country code.
|
||||
@ -2831,19 +2868,21 @@ func isIso3166AlphaNumericEU(fl FieldLevel) bool {
|
||||
default:
|
||||
panic(fmt.Sprintf("Bad field type %T", field.Interface()))
|
||||
}
|
||||
return iso3166_1_alpha_numeric_eu[code]
|
||||
|
||||
_, ok := iso3166_1_alpha_numeric_eu[code]
|
||||
return ok
|
||||
}
|
||||
|
||||
// isIso31662 is the validation function for validating if the current field's value is a valid iso3166-2 code.
|
||||
func isIso31662(fl FieldLevel) bool {
|
||||
val := fl.Field().String()
|
||||
return iso3166_2[val]
|
||||
_, ok := iso3166_2[fl.Field().String()]
|
||||
return ok
|
||||
}
|
||||
|
||||
// isIso4217 is the validation function for validating if the current field's value is a valid iso4217 currency code.
|
||||
func isIso4217(fl FieldLevel) bool {
|
||||
val := fl.Field().String()
|
||||
return iso4217[val]
|
||||
_, ok := iso4217[fl.Field().String()]
|
||||
return ok
|
||||
}
|
||||
|
||||
// isIso4217Numeric is the validation function for validating if the current field's value is a valid iso4217 numeric currency code.
|
||||
@ -2859,7 +2898,9 @@ func isIso4217Numeric(fl FieldLevel) bool {
|
||||
default:
|
||||
panic(fmt.Sprintf("Bad field type %T", field.Interface()))
|
||||
}
|
||||
return iso4217_numeric[code]
|
||||
|
||||
_, ok := iso4217_numeric[code]
|
||||
return ok
|
||||
}
|
||||
|
||||
// isBCP47LanguageTag is the validation function for validating if the current field's value is a valid BCP 47 language tag, as parsed by language.Parse
|
||||
@ -2878,21 +2919,21 @@ func isBCP47LanguageTag(fl FieldLevel) bool {
|
||||
func isIsoBicFormat(fl FieldLevel) bool {
|
||||
bicString := fl.Field().String()
|
||||
|
||||
return bicRegex.MatchString(bicString)
|
||||
return bicRegex().MatchString(bicString)
|
||||
}
|
||||
|
||||
// isSemverFormat is the validation function for validating if the current field's value is a valid semver version, defined in Semantic Versioning 2.0.0
|
||||
func isSemverFormat(fl FieldLevel) bool {
|
||||
semverString := fl.Field().String()
|
||||
|
||||
return semverRegex.MatchString(semverString)
|
||||
return semverRegex().MatchString(semverString)
|
||||
}
|
||||
|
||||
// isCveFormat is the validation function for validating if the current field's value is a valid cve id, defined in CVE mitre org
|
||||
func isCveFormat(fl FieldLevel) bool {
|
||||
cveString := fl.Field().String()
|
||||
|
||||
return cveRegex.MatchString(cveString)
|
||||
return cveRegex().MatchString(cveString)
|
||||
}
|
||||
|
||||
// isDnsRFC1035LabelFormat is the validation function
|
||||
@ -2900,7 +2941,7 @@ func isCveFormat(fl FieldLevel) bool {
|
||||
// a valid dns RFC 1035 label, defined in RFC 1035.
|
||||
func isDnsRFC1035LabelFormat(fl FieldLevel) bool {
|
||||
val := fl.Field().String()
|
||||
return dnsRegexRFC1035Label.MatchString(val)
|
||||
return dnsRegexRFC1035Label().MatchString(val)
|
||||
}
|
||||
|
||||
// digitsHaveLuhnChecksum returns true if and only if the last element of the given digits slice is the Luhn checksum of the previous elements
|
||||
@ -2926,10 +2967,16 @@ func digitsHaveLuhnChecksum(digits []string) bool {
|
||||
return (sum % 10) == 0
|
||||
}
|
||||
|
||||
// isMongoDB is the validation function for validating if the current field's value is valid mongoDB objectID
|
||||
func isMongoDB(fl FieldLevel) bool {
|
||||
// isMongoDBObjectId is the validation function for validating if the current field's value is valid MongoDB ObjectID
|
||||
func isMongoDBObjectId(fl FieldLevel) bool {
|
||||
val := fl.Field().String()
|
||||
return mongodbRegex.MatchString(val)
|
||||
return mongodbIdRegex().MatchString(val)
|
||||
}
|
||||
|
||||
// isMongoDBConnectionString is the validation function for validating if the current field's value is valid MongoDB Connection String
|
||||
func isMongoDBConnectionString(fl FieldLevel) bool {
|
||||
val := fl.Field().String()
|
||||
return mongodbConnectionRegex().MatchString(val)
|
||||
}
|
||||
|
||||
// isSpiceDB is the validation function for validating if the current field's value is valid for use with Authzed SpiceDB in the indicated way
|
||||
@ -2939,11 +2986,11 @@ func isSpiceDB(fl FieldLevel) bool {
|
||||
|
||||
switch param {
|
||||
case "permission":
|
||||
return spicedbPermissionRegex.MatchString(val)
|
||||
return spicedbPermissionRegex().MatchString(val)
|
||||
case "type":
|
||||
return spicedbTypeRegex.MatchString(val)
|
||||
return spicedbTypeRegex().MatchString(val)
|
||||
case "id", "":
|
||||
return spicedbIDRegex.MatchString(val)
|
||||
return spicedbIDRegex().MatchString(val)
|
||||
}
|
||||
|
||||
panic("Unrecognized parameter: " + param)
|
||||
@ -2995,5 +3042,5 @@ func hasLuhnChecksum(fl FieldLevel) bool {
|
||||
// isCron is the validation function for validating if the current field's value is a valid cron expression
|
||||
func isCron(fl FieldLevel) bool {
|
||||
cronString := fl.Field().String()
|
||||
return cronRegex.MatchString(cronString)
|
||||
return cronRegex().MatchString(cronString)
|
||||
}
|
||||
|
||||
2
vendor/github.com/go-playground/validator/v10/cache.go
generated
vendored
2
vendor/github.com/go-playground/validator/v10/cache.go
generated
vendored
@ -294,7 +294,7 @@ func (v *Validate) parseFieldTagsRecursive(tag string, fieldName string, alias s
|
||||
|
||||
if wrapper, ok := v.validations[current.tag]; ok {
|
||||
current.fn = wrapper.fn
|
||||
current.runValidationWhenNil = wrapper.runValidatinOnNil
|
||||
current.runValidationWhenNil = wrapper.runValidationOnNil
|
||||
} else {
|
||||
panic(strings.TrimSpace(fmt.Sprintf(undefinedValidation, current.tag, fieldName)))
|
||||
}
|
||||
|
||||
2320
vendor/github.com/go-playground/validator/v10/country_codes.go
generated
vendored
2320
vendor/github.com/go-playground/validator/v10/country_codes.go
generated
vendored
File diff suppressed because it is too large
Load Diff
148
vendor/github.com/go-playground/validator/v10/currency_codes.go
generated
vendored
148
vendor/github.com/go-playground/validator/v10/currency_codes.go
generated
vendored
@ -1,79 +1,79 @@
|
||||
package validator
|
||||
|
||||
var iso4217 = map[string]bool{
|
||||
"AFN": true, "EUR": true, "ALL": true, "DZD": true, "USD": true,
|
||||
"AOA": true, "XCD": true, "ARS": true, "AMD": true, "AWG": true,
|
||||
"AUD": true, "AZN": true, "BSD": true, "BHD": true, "BDT": true,
|
||||
"BBD": true, "BYN": true, "BZD": true, "XOF": true, "BMD": true,
|
||||
"INR": true, "BTN": true, "BOB": true, "BOV": true, "BAM": true,
|
||||
"BWP": true, "NOK": true, "BRL": true, "BND": true, "BGN": true,
|
||||
"BIF": true, "CVE": true, "KHR": true, "XAF": true, "CAD": true,
|
||||
"KYD": true, "CLP": true, "CLF": true, "CNY": true, "COP": true,
|
||||
"COU": true, "KMF": true, "CDF": true, "NZD": true, "CRC": true,
|
||||
"HRK": true, "CUP": true, "CUC": true, "ANG": true, "CZK": true,
|
||||
"DKK": true, "DJF": true, "DOP": true, "EGP": true, "SVC": true,
|
||||
"ERN": true, "SZL": true, "ETB": true, "FKP": true, "FJD": true,
|
||||
"XPF": true, "GMD": true, "GEL": true, "GHS": true, "GIP": true,
|
||||
"GTQ": true, "GBP": true, "GNF": true, "GYD": true, "HTG": true,
|
||||
"HNL": true, "HKD": true, "HUF": true, "ISK": true, "IDR": true,
|
||||
"XDR": true, "IRR": true, "IQD": true, "ILS": true, "JMD": true,
|
||||
"JPY": true, "JOD": true, "KZT": true, "KES": true, "KPW": true,
|
||||
"KRW": true, "KWD": true, "KGS": true, "LAK": true, "LBP": true,
|
||||
"LSL": true, "ZAR": true, "LRD": true, "LYD": true, "CHF": true,
|
||||
"MOP": true, "MKD": true, "MGA": true, "MWK": true, "MYR": true,
|
||||
"MVR": true, "MRU": true, "MUR": true, "XUA": true, "MXN": true,
|
||||
"MXV": true, "MDL": true, "MNT": true, "MAD": true, "MZN": true,
|
||||
"MMK": true, "NAD": true, "NPR": true, "NIO": true, "NGN": true,
|
||||
"OMR": true, "PKR": true, "PAB": true, "PGK": true, "PYG": true,
|
||||
"PEN": true, "PHP": true, "PLN": true, "QAR": true, "RON": true,
|
||||
"RUB": true, "RWF": true, "SHP": true, "WST": true, "STN": true,
|
||||
"SAR": true, "RSD": true, "SCR": true, "SLL": true, "SGD": true,
|
||||
"XSU": true, "SBD": true, "SOS": true, "SSP": true, "LKR": true,
|
||||
"SDG": true, "SRD": true, "SEK": true, "CHE": true, "CHW": true,
|
||||
"SYP": true, "TWD": true, "TJS": true, "TZS": true, "THB": true,
|
||||
"TOP": true, "TTD": true, "TND": true, "TRY": true, "TMT": true,
|
||||
"UGX": true, "UAH": true, "AED": true, "USN": true, "UYU": true,
|
||||
"UYI": true, "UYW": true, "UZS": true, "VUV": true, "VES": true,
|
||||
"VND": true, "YER": true, "ZMW": true, "ZWL": true, "XBA": true,
|
||||
"XBB": true, "XBC": true, "XBD": true, "XTS": true, "XXX": true,
|
||||
"XAU": true, "XPD": true, "XPT": true, "XAG": true,
|
||||
var iso4217 = map[string]struct{}{
|
||||
"AFN": {}, "EUR": {}, "ALL": {}, "DZD": {}, "USD": {},
|
||||
"AOA": {}, "XCD": {}, "ARS": {}, "AMD": {}, "AWG": {},
|
||||
"AUD": {}, "AZN": {}, "BSD": {}, "BHD": {}, "BDT": {},
|
||||
"BBD": {}, "BYN": {}, "BZD": {}, "XOF": {}, "BMD": {},
|
||||
"INR": {}, "BTN": {}, "BOB": {}, "BOV": {}, "BAM": {},
|
||||
"BWP": {}, "NOK": {}, "BRL": {}, "BND": {}, "BGN": {},
|
||||
"BIF": {}, "CVE": {}, "KHR": {}, "XAF": {}, "CAD": {},
|
||||
"KYD": {}, "CLP": {}, "CLF": {}, "CNY": {}, "COP": {},
|
||||
"COU": {}, "KMF": {}, "CDF": {}, "NZD": {}, "CRC": {},
|
||||
"HRK": {}, "CUP": {}, "CUC": {}, "ANG": {}, "CZK": {},
|
||||
"DKK": {}, "DJF": {}, "DOP": {}, "EGP": {}, "SVC": {},
|
||||
"ERN": {}, "SZL": {}, "ETB": {}, "FKP": {}, "FJD": {},
|
||||
"XPF": {}, "GMD": {}, "GEL": {}, "GHS": {}, "GIP": {},
|
||||
"GTQ": {}, "GBP": {}, "GNF": {}, "GYD": {}, "HTG": {},
|
||||
"HNL": {}, "HKD": {}, "HUF": {}, "ISK": {}, "IDR": {},
|
||||
"XDR": {}, "IRR": {}, "IQD": {}, "ILS": {}, "JMD": {},
|
||||
"JPY": {}, "JOD": {}, "KZT": {}, "KES": {}, "KPW": {},
|
||||
"KRW": {}, "KWD": {}, "KGS": {}, "LAK": {}, "LBP": {},
|
||||
"LSL": {}, "ZAR": {}, "LRD": {}, "LYD": {}, "CHF": {},
|
||||
"MOP": {}, "MKD": {}, "MGA": {}, "MWK": {}, "MYR": {},
|
||||
"MVR": {}, "MRU": {}, "MUR": {}, "XUA": {}, "MXN": {},
|
||||
"MXV": {}, "MDL": {}, "MNT": {}, "MAD": {}, "MZN": {},
|
||||
"MMK": {}, "NAD": {}, "NPR": {}, "NIO": {}, "NGN": {},
|
||||
"OMR": {}, "PKR": {}, "PAB": {}, "PGK": {}, "PYG": {},
|
||||
"PEN": {}, "PHP": {}, "PLN": {}, "QAR": {}, "RON": {},
|
||||
"RUB": {}, "RWF": {}, "SHP": {}, "WST": {}, "STN": {},
|
||||
"SAR": {}, "RSD": {}, "SCR": {}, "SLL": {}, "SGD": {},
|
||||
"XSU": {}, "SBD": {}, "SOS": {}, "SSP": {}, "LKR": {},
|
||||
"SDG": {}, "SRD": {}, "SEK": {}, "CHE": {}, "CHW": {},
|
||||
"SYP": {}, "TWD": {}, "TJS": {}, "TZS": {}, "THB": {},
|
||||
"TOP": {}, "TTD": {}, "TND": {}, "TRY": {}, "TMT": {},
|
||||
"UGX": {}, "UAH": {}, "AED": {}, "USN": {}, "UYU": {},
|
||||
"UYI": {}, "UYW": {}, "UZS": {}, "VUV": {}, "VES": {},
|
||||
"VND": {}, "YER": {}, "ZMW": {}, "ZWL": {}, "XBA": {},
|
||||
"XBB": {}, "XBC": {}, "XBD": {}, "XTS": {}, "XXX": {},
|
||||
"XAU": {}, "XPD": {}, "XPT": {}, "XAG": {},
|
||||
}
|
||||
|
||||
var iso4217_numeric = map[int]bool{
|
||||
8: true, 12: true, 32: true, 36: true, 44: true,
|
||||
48: true, 50: true, 51: true, 52: true, 60: true,
|
||||
64: true, 68: true, 72: true, 84: true, 90: true,
|
||||
96: true, 104: true, 108: true, 116: true, 124: true,
|
||||
132: true, 136: true, 144: true, 152: true, 156: true,
|
||||
170: true, 174: true, 188: true, 191: true, 192: true,
|
||||
203: true, 208: true, 214: true, 222: true, 230: true,
|
||||
232: true, 238: true, 242: true, 262: true, 270: true,
|
||||
292: true, 320: true, 324: true, 328: true, 332: true,
|
||||
340: true, 344: true, 348: true, 352: true, 356: true,
|
||||
360: true, 364: true, 368: true, 376: true, 388: true,
|
||||
392: true, 398: true, 400: true, 404: true, 408: true,
|
||||
410: true, 414: true, 417: true, 418: true, 422: true,
|
||||
426: true, 430: true, 434: true, 446: true, 454: true,
|
||||
458: true, 462: true, 480: true, 484: true, 496: true,
|
||||
498: true, 504: true, 512: true, 516: true, 524: true,
|
||||
532: true, 533: true, 548: true, 554: true, 558: true,
|
||||
566: true, 578: true, 586: true, 590: true, 598: true,
|
||||
600: true, 604: true, 608: true, 634: true, 643: true,
|
||||
646: true, 654: true, 682: true, 690: true, 694: true,
|
||||
702: true, 704: true, 706: true, 710: true, 728: true,
|
||||
748: true, 752: true, 756: true, 760: true, 764: true,
|
||||
776: true, 780: true, 784: true, 788: true, 800: true,
|
||||
807: true, 818: true, 826: true, 834: true, 840: true,
|
||||
858: true, 860: true, 882: true, 886: true, 901: true,
|
||||
927: true, 928: true, 929: true, 930: true, 931: true,
|
||||
932: true, 933: true, 934: true, 936: true, 938: true,
|
||||
940: true, 941: true, 943: true, 944: true, 946: true,
|
||||
947: true, 948: true, 949: true, 950: true, 951: true,
|
||||
952: true, 953: true, 955: true, 956: true, 957: true,
|
||||
958: true, 959: true, 960: true, 961: true, 962: true,
|
||||
963: true, 964: true, 965: true, 967: true, 968: true,
|
||||
969: true, 970: true, 971: true, 972: true, 973: true,
|
||||
975: true, 976: true, 977: true, 978: true, 979: true,
|
||||
980: true, 981: true, 984: true, 985: true, 986: true,
|
||||
990: true, 994: true, 997: true, 999: true,
|
||||
var iso4217_numeric = map[int]struct{}{
|
||||
8: {}, 12: {}, 32: {}, 36: {}, 44: {},
|
||||
48: {}, 50: {}, 51: {}, 52: {}, 60: {},
|
||||
64: {}, 68: {}, 72: {}, 84: {}, 90: {},
|
||||
96: {}, 104: {}, 108: {}, 116: {}, 124: {},
|
||||
132: {}, 136: {}, 144: {}, 152: {}, 156: {},
|
||||
170: {}, 174: {}, 188: {}, 191: {}, 192: {},
|
||||
203: {}, 208: {}, 214: {}, 222: {}, 230: {},
|
||||
232: {}, 238: {}, 242: {}, 262: {}, 270: {},
|
||||
292: {}, 320: {}, 324: {}, 328: {}, 332: {},
|
||||
340: {}, 344: {}, 348: {}, 352: {}, 356: {},
|
||||
360: {}, 364: {}, 368: {}, 376: {}, 388: {},
|
||||
392: {}, 398: {}, 400: {}, 404: {}, 408: {},
|
||||
410: {}, 414: {}, 417: {}, 418: {}, 422: {},
|
||||
426: {}, 430: {}, 434: {}, 446: {}, 454: {},
|
||||
458: {}, 462: {}, 480: {}, 484: {}, 496: {},
|
||||
498: {}, 504: {}, 512: {}, 516: {}, 524: {},
|
||||
532: {}, 533: {}, 548: {}, 554: {}, 558: {},
|
||||
566: {}, 578: {}, 586: {}, 590: {}, 598: {},
|
||||
600: {}, 604: {}, 608: {}, 634: {}, 643: {},
|
||||
646: {}, 654: {}, 682: {}, 690: {}, 694: {},
|
||||
702: {}, 704: {}, 706: {}, 710: {}, 728: {},
|
||||
748: {}, 752: {}, 756: {}, 760: {}, 764: {},
|
||||
776: {}, 780: {}, 784: {}, 788: {}, 800: {},
|
||||
807: {}, 818: {}, 826: {}, 834: {}, 840: {},
|
||||
858: {}, 860: {}, 882: {}, 886: {}, 901: {},
|
||||
927: {}, 928: {}, 929: {}, 930: {}, 931: {},
|
||||
932: {}, 933: {}, 934: {}, 936: {}, 938: {},
|
||||
940: {}, 941: {}, 943: {}, 944: {}, 946: {},
|
||||
947: {}, 948: {}, 949: {}, 950: {}, 951: {},
|
||||
952: {}, 953: {}, 955: {}, 956: {}, 957: {},
|
||||
958: {}, 959: {}, 960: {}, 961: {}, 962: {},
|
||||
963: {}, 964: {}, 965: {}, 967: {}, 968: {},
|
||||
969: {}, 970: {}, 971: {}, 972: {}, 973: {},
|
||||
975: {}, 976: {}, 977: {}, 978: {}, 979: {},
|
||||
980: {}, 981: {}, 984: {}, 985: {}, 986: {},
|
||||
990: {}, 994: {}, 997: {}, 999: {},
|
||||
}
|
||||
|
||||
29
vendor/github.com/go-playground/validator/v10/doc.go
generated
vendored
29
vendor/github.com/go-playground/validator/v10/doc.go
generated
vendored
@ -253,7 +253,7 @@ Example #2
|
||||
|
||||
This validates that the value is not the data types default zero value.
|
||||
For numbers ensures value is not zero. For strings ensures value is
|
||||
not "". For slices, maps, pointers, interfaces, channels and functions
|
||||
not "". For booleans ensures value is not false. For slices, maps, pointers, interfaces, channels and functions
|
||||
ensures the value is not nil. For structs ensures value is not the zero value when using WithRequiredStructEnabled.
|
||||
|
||||
Usage: required
|
||||
@ -489,12 +489,19 @@ For strings, ints, and uints, oneof will ensure that the value
|
||||
is one of the values in the parameter. The parameter should be
|
||||
a list of values separated by whitespace. Values may be
|
||||
strings or numbers. To match strings with spaces in them, include
|
||||
the target string between single quotes.
|
||||
the target string between single quotes. Kind of like an 'enum'.
|
||||
|
||||
Usage: oneof=red green
|
||||
oneof='red green' 'blue yellow'
|
||||
oneof=5 7 9
|
||||
|
||||
# One Of Case Insensitive
|
||||
|
||||
Works the same as oneof but is case insensitive and therefore only accepts strings.
|
||||
|
||||
Usage: oneofci=red green
|
||||
oneofci='red green' 'blue yellow'
|
||||
|
||||
# Greater Than
|
||||
|
||||
For numbers, this will ensure that the value is greater than the
|
||||
@ -911,7 +918,7 @@ This will accept any uri the golang request uri accepts
|
||||
|
||||
# Urn RFC 2141 String
|
||||
|
||||
This validataes that a string value contains a valid URN
|
||||
This validates that a string value contains a valid URN
|
||||
according to the RFC 2141 spec.
|
||||
|
||||
Usage: urn_rfc2141
|
||||
@ -966,7 +973,7 @@ Bitcoin Bech32 Address (segwit)
|
||||
|
||||
This validates that a string value contains a valid bitcoin Bech32 address as defined
|
||||
by bip-0173 (https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki)
|
||||
Special thanks to Pieter Wuille for providng reference implementations.
|
||||
Special thanks to Pieter Wuille for providing reference implementations.
|
||||
|
||||
Usage: btc_addr_bech32
|
||||
|
||||
@ -1299,7 +1306,7 @@ may not exist at the time of validation.
|
||||
# HostPort
|
||||
|
||||
This validates that a string value contains a valid DNS hostname and port that
|
||||
can be used to valiate fields typically passed to sockets and connections.
|
||||
can be used to validate fields typically passed to sockets and connections.
|
||||
|
||||
Usage: hostname_port
|
||||
|
||||
@ -1386,11 +1393,19 @@ This validates that a string value contains a valid credit card number using Luh
|
||||
|
||||
This validates that a string or (u)int value contains a valid checksum using the Luhn algorithm.
|
||||
|
||||
# MongoDb ObjectID
|
||||
# MongoDB
|
||||
|
||||
This validates that a string is a valid 24 character hexadecimal string.
|
||||
This validates that a string is a valid 24 character hexadecimal string or valid connection string.
|
||||
|
||||
Usage: mongodb
|
||||
mongodb_connection_string
|
||||
|
||||
Example:
|
||||
|
||||
type Test struct {
|
||||
ObjectIdField string `validate:"mongodb"`
|
||||
ConnectionStringField string `validate:"mongodb_connection_string"`
|
||||
}
|
||||
|
||||
# Cron
|
||||
|
||||
|
||||
12
vendor/github.com/go-playground/validator/v10/postcode_regexes.go
generated
vendored
12
vendor/github.com/go-playground/validator/v10/postcode_regexes.go
generated
vendored
@ -1,6 +1,9 @@
|
||||
package validator
|
||||
|
||||
import "regexp"
|
||||
import (
|
||||
"regexp"
|
||||
"sync"
|
||||
)
|
||||
|
||||
var postCodePatternDict = map[string]string{
|
||||
"GB": `^GIR[ ]?0AA|((AB|AL|B|BA|BB|BD|BH|BL|BN|BR|BS|BT|CA|CB|CF|CH|CM|CO|CR|CT|CV|CW|DA|DD|DE|DG|DH|DL|DN|DT|DY|E|EC|EH|EN|EX|FK|FY|G|GL|GY|GU|HA|HD|HG|HP|HR|HS|HU|HX|IG|IM|IP|IV|JE|KA|KT|KW|KY|L|LA|LD|LE|LL|LN|LS|LU|M|ME|MK|ML|N|NE|NG|NN|NP|NR|NW|OL|OX|PA|PE|PH|PL|PO|PR|RG|RH|RM|S|SA|SE|SG|SK|SL|SM|SN|SO|SP|SR|SS|ST|SW|SY|TA|TD|TF|TN|TQ|TR|TS|TW|UB|W|WA|WC|WD|WF|WN|WR|WS|WV|YO|ZE)(\d[\dA-Z]?[ ]?\d[ABD-HJLN-UW-Z]{2}))|BFPO[ ]?\d{1,4}$`,
|
||||
@ -164,9 +167,12 @@ var postCodePatternDict = map[string]string{
|
||||
"YT": `^976\d{2}$`,
|
||||
}
|
||||
|
||||
var postCodeRegexDict = map[string]*regexp.Regexp{}
|
||||
var (
|
||||
postcodeRegexInit sync.Once
|
||||
postCodeRegexDict = map[string]*regexp.Regexp{}
|
||||
)
|
||||
|
||||
func init() {
|
||||
func initPostcodes() {
|
||||
for countryCode, pattern := range postCodePatternDict {
|
||||
postCodeRegexDict[countryCode] = regexp.MustCompile(pattern)
|
||||
}
|
||||
|
||||
158
vendor/github.com/go-playground/validator/v10/regexes.go
generated
vendored
158
vendor/github.com/go-playground/validator/v10/regexes.go
generated
vendored
@ -1,6 +1,9 @@
|
||||
package validator
|
||||
|
||||
import "regexp"
|
||||
import (
|
||||
"regexp"
|
||||
"sync"
|
||||
)
|
||||
|
||||
const (
|
||||
alphaRegexString = "^[a-zA-Z]+$"
|
||||
@ -68,80 +71,93 @@ const (
|
||||
semverRegexString = `^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$` // numbered capture groups https://semver.org/
|
||||
dnsRegexStringRFC1035Label = "^[a-z]([-a-z0-9]*[a-z0-9]){0,62}$"
|
||||
cveRegexString = `^CVE-(1999|2\d{3})-(0[^0]\d{2}|0\d[^0]\d{1}|0\d{2}[^0]|[1-9]{1}\d{3,})$` // CVE Format Id https://cve.mitre.org/cve/identifiers/syntaxchange.html
|
||||
mongodbRegexString = "^[a-f\\d]{24}$"
|
||||
cronRegexString = `(@(annually|yearly|monthly|weekly|daily|hourly|reboot))|(@every (\d+(ns|us|µs|ms|s|m|h))+)|((((\d+,)+\d+|(\d+(\/|-)\d+)|\d+|\*) ?){5,7})`
|
||||
mongodbIdRegexString = "^[a-f\\d]{24}$"
|
||||
mongodbConnStringRegexString = "^mongodb(\\+srv)?:\\/\\/(([a-zA-Z\\d]+):([a-zA-Z\\d$:\\/?#\\[\\]@]+)@)?(([a-z\\d.-]+)(:[\\d]+)?)((,(([a-z\\d.-]+)(:(\\d+))?))*)?(\\/[a-zA-Z-_]{1,64})?(\\?(([a-zA-Z]+)=([a-zA-Z\\d]+))(&(([a-zA-Z\\d]+)=([a-zA-Z\\d]+))?)*)?$"
|
||||
cronRegexString = `(@(annually|yearly|monthly|weekly|daily|hourly|reboot))|(@every (\d+(ns|us|µs|ms|s|m|h))+)|((((\d+,)+\d+|((\*|\d+)(\/|-)\d+)|\d+|\*) ?){5,7})`
|
||||
spicedbIDRegexString = `^(([a-zA-Z0-9/_|\-=+]{1,})|\*)$`
|
||||
spicedbPermissionRegexString = "^([a-z][a-z0-9_]{1,62}[a-z0-9])?$"
|
||||
spicedbTypeRegexString = "^([a-z][a-z0-9_]{1,61}[a-z0-9]/)?[a-z][a-z0-9_]{1,62}[a-z0-9]$"
|
||||
)
|
||||
|
||||
func lazyRegexCompile(str string) func() *regexp.Regexp {
|
||||
var regex *regexp.Regexp
|
||||
var once sync.Once
|
||||
return func() *regexp.Regexp {
|
||||
once.Do(func() {
|
||||
regex = regexp.MustCompile(str)
|
||||
})
|
||||
return regex
|
||||
}
|
||||
}
|
||||
|
||||
var (
|
||||
alphaRegex = regexp.MustCompile(alphaRegexString)
|
||||
alphaNumericRegex = regexp.MustCompile(alphaNumericRegexString)
|
||||
alphaUnicodeRegex = regexp.MustCompile(alphaUnicodeRegexString)
|
||||
alphaUnicodeNumericRegex = regexp.MustCompile(alphaUnicodeNumericRegexString)
|
||||
numericRegex = regexp.MustCompile(numericRegexString)
|
||||
numberRegex = regexp.MustCompile(numberRegexString)
|
||||
hexadecimalRegex = regexp.MustCompile(hexadecimalRegexString)
|
||||
hexColorRegex = regexp.MustCompile(hexColorRegexString)
|
||||
rgbRegex = regexp.MustCompile(rgbRegexString)
|
||||
rgbaRegex = regexp.MustCompile(rgbaRegexString)
|
||||
hslRegex = regexp.MustCompile(hslRegexString)
|
||||
hslaRegex = regexp.MustCompile(hslaRegexString)
|
||||
e164Regex = regexp.MustCompile(e164RegexString)
|
||||
emailRegex = regexp.MustCompile(emailRegexString)
|
||||
base32Regex = regexp.MustCompile(base32RegexString)
|
||||
base64Regex = regexp.MustCompile(base64RegexString)
|
||||
base64URLRegex = regexp.MustCompile(base64URLRegexString)
|
||||
base64RawURLRegex = regexp.MustCompile(base64RawURLRegexString)
|
||||
iSBN10Regex = regexp.MustCompile(iSBN10RegexString)
|
||||
iSBN13Regex = regexp.MustCompile(iSBN13RegexString)
|
||||
iSSNRegex = regexp.MustCompile(iSSNRegexString)
|
||||
uUID3Regex = regexp.MustCompile(uUID3RegexString)
|
||||
uUID4Regex = regexp.MustCompile(uUID4RegexString)
|
||||
uUID5Regex = regexp.MustCompile(uUID5RegexString)
|
||||
uUIDRegex = regexp.MustCompile(uUIDRegexString)
|
||||
uUID3RFC4122Regex = regexp.MustCompile(uUID3RFC4122RegexString)
|
||||
uUID4RFC4122Regex = regexp.MustCompile(uUID4RFC4122RegexString)
|
||||
uUID5RFC4122Regex = regexp.MustCompile(uUID5RFC4122RegexString)
|
||||
uUIDRFC4122Regex = regexp.MustCompile(uUIDRFC4122RegexString)
|
||||
uLIDRegex = regexp.MustCompile(uLIDRegexString)
|
||||
md4Regex = regexp.MustCompile(md4RegexString)
|
||||
md5Regex = regexp.MustCompile(md5RegexString)
|
||||
sha256Regex = regexp.MustCompile(sha256RegexString)
|
||||
sha384Regex = regexp.MustCompile(sha384RegexString)
|
||||
sha512Regex = regexp.MustCompile(sha512RegexString)
|
||||
ripemd128Regex = regexp.MustCompile(ripemd128RegexString)
|
||||
ripemd160Regex = regexp.MustCompile(ripemd160RegexString)
|
||||
tiger128Regex = regexp.MustCompile(tiger128RegexString)
|
||||
tiger160Regex = regexp.MustCompile(tiger160RegexString)
|
||||
tiger192Regex = regexp.MustCompile(tiger192RegexString)
|
||||
aSCIIRegex = regexp.MustCompile(aSCIIRegexString)
|
||||
printableASCIIRegex = regexp.MustCompile(printableASCIIRegexString)
|
||||
multibyteRegex = regexp.MustCompile(multibyteRegexString)
|
||||
dataURIRegex = regexp.MustCompile(dataURIRegexString)
|
||||
latitudeRegex = regexp.MustCompile(latitudeRegexString)
|
||||
longitudeRegex = regexp.MustCompile(longitudeRegexString)
|
||||
sSNRegex = regexp.MustCompile(sSNRegexString)
|
||||
hostnameRegexRFC952 = regexp.MustCompile(hostnameRegexStringRFC952)
|
||||
hostnameRegexRFC1123 = regexp.MustCompile(hostnameRegexStringRFC1123)
|
||||
fqdnRegexRFC1123 = regexp.MustCompile(fqdnRegexStringRFC1123)
|
||||
btcAddressRegex = regexp.MustCompile(btcAddressRegexString)
|
||||
btcUpperAddressRegexBech32 = regexp.MustCompile(btcAddressUpperRegexStringBech32)
|
||||
btcLowerAddressRegexBech32 = regexp.MustCompile(btcAddressLowerRegexStringBech32)
|
||||
ethAddressRegex = regexp.MustCompile(ethAddressRegexString)
|
||||
uRLEncodedRegex = regexp.MustCompile(uRLEncodedRegexString)
|
||||
hTMLEncodedRegex = regexp.MustCompile(hTMLEncodedRegexString)
|
||||
hTMLRegex = regexp.MustCompile(hTMLRegexString)
|
||||
jWTRegex = regexp.MustCompile(jWTRegexString)
|
||||
splitParamsRegex = regexp.MustCompile(splitParamsRegexString)
|
||||
bicRegex = regexp.MustCompile(bicRegexString)
|
||||
semverRegex = regexp.MustCompile(semverRegexString)
|
||||
dnsRegexRFC1035Label = regexp.MustCompile(dnsRegexStringRFC1035Label)
|
||||
cveRegex = regexp.MustCompile(cveRegexString)
|
||||
mongodbRegex = regexp.MustCompile(mongodbRegexString)
|
||||
cronRegex = regexp.MustCompile(cronRegexString)
|
||||
spicedbIDRegex = regexp.MustCompile(spicedbIDRegexString)
|
||||
spicedbPermissionRegex = regexp.MustCompile(spicedbPermissionRegexString)
|
||||
spicedbTypeRegex = regexp.MustCompile(spicedbTypeRegexString)
|
||||
alphaRegex = lazyRegexCompile(alphaRegexString)
|
||||
alphaNumericRegex = lazyRegexCompile(alphaNumericRegexString)
|
||||
alphaUnicodeRegex = lazyRegexCompile(alphaUnicodeRegexString)
|
||||
alphaUnicodeNumericRegex = lazyRegexCompile(alphaUnicodeNumericRegexString)
|
||||
numericRegex = lazyRegexCompile(numericRegexString)
|
||||
numberRegex = lazyRegexCompile(numberRegexString)
|
||||
hexadecimalRegex = lazyRegexCompile(hexadecimalRegexString)
|
||||
hexColorRegex = lazyRegexCompile(hexColorRegexString)
|
||||
rgbRegex = lazyRegexCompile(rgbRegexString)
|
||||
rgbaRegex = lazyRegexCompile(rgbaRegexString)
|
||||
hslRegex = lazyRegexCompile(hslRegexString)
|
||||
hslaRegex = lazyRegexCompile(hslaRegexString)
|
||||
e164Regex = lazyRegexCompile(e164RegexString)
|
||||
emailRegex = lazyRegexCompile(emailRegexString)
|
||||
base32Regex = lazyRegexCompile(base32RegexString)
|
||||
base64Regex = lazyRegexCompile(base64RegexString)
|
||||
base64URLRegex = lazyRegexCompile(base64URLRegexString)
|
||||
base64RawURLRegex = lazyRegexCompile(base64RawURLRegexString)
|
||||
iSBN10Regex = lazyRegexCompile(iSBN10RegexString)
|
||||
iSBN13Regex = lazyRegexCompile(iSBN13RegexString)
|
||||
iSSNRegex = lazyRegexCompile(iSSNRegexString)
|
||||
uUID3Regex = lazyRegexCompile(uUID3RegexString)
|
||||
uUID4Regex = lazyRegexCompile(uUID4RegexString)
|
||||
uUID5Regex = lazyRegexCompile(uUID5RegexString)
|
||||
uUIDRegex = lazyRegexCompile(uUIDRegexString)
|
||||
uUID3RFC4122Regex = lazyRegexCompile(uUID3RFC4122RegexString)
|
||||
uUID4RFC4122Regex = lazyRegexCompile(uUID4RFC4122RegexString)
|
||||
uUID5RFC4122Regex = lazyRegexCompile(uUID5RFC4122RegexString)
|
||||
uUIDRFC4122Regex = lazyRegexCompile(uUIDRFC4122RegexString)
|
||||
uLIDRegex = lazyRegexCompile(uLIDRegexString)
|
||||
md4Regex = lazyRegexCompile(md4RegexString)
|
||||
md5Regex = lazyRegexCompile(md5RegexString)
|
||||
sha256Regex = lazyRegexCompile(sha256RegexString)
|
||||
sha384Regex = lazyRegexCompile(sha384RegexString)
|
||||
sha512Regex = lazyRegexCompile(sha512RegexString)
|
||||
ripemd128Regex = lazyRegexCompile(ripemd128RegexString)
|
||||
ripemd160Regex = lazyRegexCompile(ripemd160RegexString)
|
||||
tiger128Regex = lazyRegexCompile(tiger128RegexString)
|
||||
tiger160Regex = lazyRegexCompile(tiger160RegexString)
|
||||
tiger192Regex = lazyRegexCompile(tiger192RegexString)
|
||||
aSCIIRegex = lazyRegexCompile(aSCIIRegexString)
|
||||
printableASCIIRegex = lazyRegexCompile(printableASCIIRegexString)
|
||||
multibyteRegex = lazyRegexCompile(multibyteRegexString)
|
||||
dataURIRegex = lazyRegexCompile(dataURIRegexString)
|
||||
latitudeRegex = lazyRegexCompile(latitudeRegexString)
|
||||
longitudeRegex = lazyRegexCompile(longitudeRegexString)
|
||||
sSNRegex = lazyRegexCompile(sSNRegexString)
|
||||
hostnameRegexRFC952 = lazyRegexCompile(hostnameRegexStringRFC952)
|
||||
hostnameRegexRFC1123 = lazyRegexCompile(hostnameRegexStringRFC1123)
|
||||
fqdnRegexRFC1123 = lazyRegexCompile(fqdnRegexStringRFC1123)
|
||||
btcAddressRegex = lazyRegexCompile(btcAddressRegexString)
|
||||
btcUpperAddressRegexBech32 = lazyRegexCompile(btcAddressUpperRegexStringBech32)
|
||||
btcLowerAddressRegexBech32 = lazyRegexCompile(btcAddressLowerRegexStringBech32)
|
||||
ethAddressRegex = lazyRegexCompile(ethAddressRegexString)
|
||||
uRLEncodedRegex = lazyRegexCompile(uRLEncodedRegexString)
|
||||
hTMLEncodedRegex = lazyRegexCompile(hTMLEncodedRegexString)
|
||||
hTMLRegex = lazyRegexCompile(hTMLRegexString)
|
||||
jWTRegex = lazyRegexCompile(jWTRegexString)
|
||||
splitParamsRegex = lazyRegexCompile(splitParamsRegexString)
|
||||
bicRegex = lazyRegexCompile(bicRegexString)
|
||||
semverRegex = lazyRegexCompile(semverRegexString)
|
||||
dnsRegexRFC1035Label = lazyRegexCompile(dnsRegexStringRFC1035Label)
|
||||
cveRegex = lazyRegexCompile(cveRegexString)
|
||||
mongodbIdRegex = lazyRegexCompile(mongodbIdRegexString)
|
||||
mongodbConnectionRegex = lazyRegexCompile(mongodbConnStringRegexString)
|
||||
cronRegex = lazyRegexCompile(cronRegexString)
|
||||
spicedbIDRegex = lazyRegexCompile(spicedbIDRegexString)
|
||||
spicedbPermissionRegex = lazyRegexCompile(spicedbPermissionRegexString)
|
||||
spicedbTypeRegex = lazyRegexCompile(spicedbTypeRegexString)
|
||||
)
|
||||
|
||||
5
vendor/github.com/go-playground/validator/v10/util.go
generated
vendored
5
vendor/github.com/go-playground/validator/v10/util.go
generated
vendored
@ -271,7 +271,7 @@ func asFloat64(param string) float64 {
|
||||
return i
|
||||
}
|
||||
|
||||
// asFloat64 returns the parameter as a float64
|
||||
// asFloat32 returns the parameter as a float32
|
||||
// or panics if it can't convert
|
||||
func asFloat32(param string) float64 {
|
||||
i, err := strconv.ParseFloat(param, 32)
|
||||
@ -297,7 +297,8 @@ func panicIf(err error) {
|
||||
|
||||
// Checks if field value matches regex. If fl.Field can be cast to Stringer, it uses the Stringer interfaces
|
||||
// String() return value. Otherwise, it uses fl.Field's String() value.
|
||||
func fieldMatchesRegexByStringerValOrString(regex *regexp.Regexp, fl FieldLevel) bool {
|
||||
func fieldMatchesRegexByStringerValOrString(regexFn func() *regexp.Regexp, fl FieldLevel) bool {
|
||||
regex := regexFn()
|
||||
switch fl.Field().Kind() {
|
||||
case reflect.String:
|
||||
return regex.MatchString(fl.Field().String())
|
||||
|
||||
8
vendor/github.com/go-playground/validator/v10/validator_instance.go
generated
vendored
8
vendor/github.com/go-playground/validator/v10/validator_instance.go
generated
vendored
@ -74,8 +74,8 @@ type CustomTypeFunc func(field reflect.Value) interface{}
|
||||
type TagNameFunc func(field reflect.StructField) string
|
||||
|
||||
type internalValidationFuncWrapper struct {
|
||||
fn FuncCtx
|
||||
runValidatinOnNil bool
|
||||
fn FuncCtx
|
||||
runValidationOnNil bool
|
||||
}
|
||||
|
||||
// Validate contains the validator settings and cache
|
||||
@ -245,7 +245,7 @@ func (v *Validate) registerValidation(tag string, fn FuncCtx, bakedIn bool, nilC
|
||||
if !bakedIn && (ok || strings.ContainsAny(tag, restrictedTagChars)) {
|
||||
panic(fmt.Sprintf(restrictedTagErr, tag))
|
||||
}
|
||||
v.validations[tag] = internalValidationFuncWrapper{fn: fn, runValidatinOnNil: nilCheckable}
|
||||
v.validations[tag] = internalValidationFuncWrapper{fn: fn, runValidationOnNil: nilCheckable}
|
||||
return nil
|
||||
}
|
||||
|
||||
@ -676,7 +676,7 @@ func (v *Validate) VarWithValue(field interface{}, other interface{}, tag string
|
||||
}
|
||||
|
||||
// VarWithValueCtx validates a single variable, against another variable/field's value using tag style validation and
|
||||
// allows passing of contextual validation validation information via context.Context.
|
||||
// allows passing of contextual validation information via context.Context.
|
||||
// eg.
|
||||
// s1 := "abcd"
|
||||
// s2 := "abcd"
|
||||
|
||||
Reference in New Issue
Block a user