package validator
import (
"fmt"
"net/url"
"reflect"
"strconv"
"time"
)
// BakedInValidators is the map of ValidationFunc used internally
// but can be used with any new Validator if desired
var BakedInValidators = map[string]ValidationFunc{
"required": hasValue,
"len": hasLengthOf,
"min": hasMinOf,
"max": hasMaxOf,
"lt": isLt,
"lte": isLte,
"gt": isGt,
"gte": isGte,
"gtefield": isGteField,
"gtfield": isGtField,
"ltefield": isLteField,
"ltfield": isLtField,
"alpha": isAlpha,
"alphanum": isAlphanum,
"numeric": isNumeric,
"number": isNumber,
"hexadecimal": isHexadecimal,
"hexcolor": isHexcolor,
"rgb": isRgb,
"rgba": isRgba,
"hsl": isHsl,
"hsla": isHsla,
"email": isEmail,
"url": isURL,
"uri": isURI,
}
func isURI(val interface{}, field interface{}, param string) bool {
st := reflect.ValueOf(field)
switch st.Kind() {
case reflect.String:
_, err := url.ParseRequestURI(field.(string))
return err == nil
}
panic(fmt.Sprintf("Bad field type %T", field))
}
func isURL(val interface{}, field interface{}, param string) bool {
st := reflect.ValueOf(field)
switch st.Kind() {
case reflect.String:
url, err := url.ParseRequestURI(field.(string))
if err != nil {
return false
}
if len(url.Scheme) == 0 {
return false
}
return err == nil
}
panic(fmt.Sprintf("Bad field type %T", field))
}
func isEmail(val interface{}, field interface{}, param string) bool {
st := reflect.ValueOf(field)
switch st.Kind() {
case reflect.String:
return emailRegex.MatchString(field.(string))
}
panic(fmt.Sprintf("Bad field type %T", field))
}
func isHsla(val interface{}, field interface{}, param string) bool {
st := reflect.ValueOf(field)
switch st.Kind() {
case reflect.String:
return hslaRegex.MatchString(field.(string))
}
panic(fmt.Sprintf("Bad field type %T", field))
}
func isHsl(val interface{}, field interface{}, param string) bool {
st := reflect.ValueOf(field)
switch st.Kind() {
case reflect.String:
return hslRegex.MatchString(field.(string))
}
panic(fmt.Sprintf("Bad field type %T", field))
}
func isRgba(val interface{}, field interface{}, param string) bool {
st := reflect.ValueOf(field)
switch st.Kind() {
case reflect.String:
return rgbaRegex.MatchString(field.(string))
}
panic(fmt.Sprintf("Bad field type %T", field))
}
func isRgb(val interface{}, field interface{}, param string) bool {
st := reflect.ValueOf(field)
switch st.Kind() {
case reflect.String:
return rgbRegex.MatchString(field.(string))
}
panic(fmt.Sprintf("Bad field type %T", field))
}
func isHexcolor(val interface{}, field interface{}, param string) bool {
st := reflect.ValueOf(field)
switch st.Kind() {
case reflect.String:
return hexcolorRegex.MatchString(field.(string))
}
panic(fmt.Sprintf("Bad field type %T", field))
}
func isHexadecimal(val interface{}, field interface{}, param string) bool {
st := reflect.ValueOf(field)
switch st.Kind() {
case reflect.String:
return hexadecimalRegex.MatchString(field.(string))
}
panic(fmt.Sprintf("Bad field type %T", field))
}
func isNumber(val interface{}, field interface{}, param string) bool {
st := reflect.ValueOf(field)
switch st.Kind() {
case reflect.String:
return numberRegex.MatchString(field.(string))
}
panic(fmt.Sprintf("Bad field type %T", field))
}
func isNumeric(val interface{}, field interface{}, param string) bool {
st := reflect.ValueOf(field)
switch st.Kind() {
case reflect.String:
return numericRegex.MatchString(field.(string))
}
panic(fmt.Sprintf("Bad field type %T", field))
}
func isAlphanum(val interface{}, field interface{}, param string) bool {
st := reflect.ValueOf(field)
switch st.Kind() {
case reflect.String:
return alphaNumericRegex.MatchString(field.(string))
}
panic(fmt.Sprintf("Bad field type %T", field))
}
func isAlpha(val interface{}, field interface{}, param string) bool {
st := reflect.ValueOf(field)
switch st.Kind() {
case reflect.String:
return alphaRegex.MatchString(field.(string))
}
panic(fmt.Sprintf("Bad field type %T", field))
}
func hasValue(val interface{}, field interface{}, param string) bool {
st := reflect.ValueOf(field)
switch st.Kind() {
case reflect.Slice, reflect.Map, reflect.Array:
return field != nil && int64(st.Len()) > 0
default:
return field != nil && field != reflect.Zero(reflect.TypeOf(field)).Interface()
}
}
func isGteField(val interface{}, field interface{}, param string) bool {
if val == nil {
panic("struct not passed for cross validation")
}
topVal := reflect.ValueOf(val)
if topVal.Kind() == reflect.Ptr && !topVal.IsNil() {
topVal = reflect.ValueOf(topVal.Elem().Interface())
}
var topFieldVal reflect.Value
switch topVal.Kind() {
case reflect.Struct:
if topVal.Type() == reflect.TypeOf(time.Time{}) {
topFieldVal = topVal
break
}
f := topVal.FieldByName(param)
if f.Kind() == reflect.Invalid {
panic(fmt.Sprintf("Field \"%s\" not found in struct", param))
}
topFieldVal = f
default:
topFieldVal = topVal
}
if topFieldVal.Kind() == reflect.Ptr && !topFieldVal.IsNil() {
topFieldVal = reflect.ValueOf(topFieldVal.Elem().Interface())
}
fv := reflect.ValueOf(field)
switch fv.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return fv.Int() >= topFieldVal.Int()
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
return fv.Uint() >= topFieldVal.Uint()
case reflect.Float32, reflect.Float64:
return fv.Float() >= topFieldVal.Float()
case reflect.Struct:
if fv.Type() == reflect.TypeOf(time.Time{}) {
if topFieldVal.Type() != reflect.TypeOf(time.Time{}) {
panic("Bad Top Level field type")
}
t := topFieldVal.Interface().(time.Time)
fieldTime := field.(time.Time)
return fieldTime.After(t) || fieldTime.Equal(t)
}
}
panic(fmt.Sprintf("Bad field type %T", field))
}
func isGtField(val interface{}, field interface{}, param string) bool {
if val == nil {
panic("struct not passed for cross validation")
}
topVal := reflect.ValueOf(val)
if topVal.Kind() == reflect.Ptr && !topVal.IsNil() {
topVal = reflect.ValueOf(topVal.Elem().Interface())
}
var topFieldVal reflect.Value
switch topVal.Kind() {
case reflect.Struct:
if topVal.Type() == reflect.TypeOf(time.Time{}) {
topFieldVal = topVal
break
}
f := topVal.FieldByName(param)
if f.Kind() == reflect.Invalid {
panic(fmt.Sprintf("Field \"%s\" not found in struct", param))
}
topFieldVal = f
default:
topFieldVal = topVal
}
if topFieldVal.Kind() == reflect.Ptr && !topFieldVal.IsNil() {
topFieldVal = reflect.ValueOf(topFieldVal.Elem().Interface())
}
fv := reflect.ValueOf(field)
switch fv.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return fv.Int() > topFieldVal.Int()
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
return fv.Uint() > topFieldVal.Uint()
case reflect.Float32, reflect.Float64:
return fv.Float() > topFieldVal.Float()
case reflect.Struct:
if fv.Type() == reflect.TypeOf(time.Time{}) {
if topFieldVal.Type() != reflect.TypeOf(time.Time{}) {
panic("Bad Top Level field type")
}
t := topFieldVal.Interface().(time.Time)
fieldTime := field.(time.Time)
return fieldTime.After(t)
}
}
panic(fmt.Sprintf("Bad field type %T", field))
}
func isGte(val interface{}, field interface{}, param string) bool {
st := reflect.ValueOf(field)
switch st.Kind() {
case reflect.String:
p := asInt(param)
return int64(len(st.String())) >= p
case reflect.Slice, reflect.Map, reflect.Array:
p := asInt(param)
return int64(st.Len()) >= p
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
p := asInt(param)
return st.Int() >= p
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
p := asUint(param)
return st.Uint() >= p
case reflect.Float32, reflect.Float64:
p := asFloat(param)
return st.Float() >= p
case reflect.Struct:
if st.Type() == reflect.TypeOf(time.Time{}) {
now := time.Now().UTC()
t := field.(time.Time)
return t.After(now) || t.Equal(now)
}
}
panic(fmt.Sprintf("Bad field type %T", field))
}
func isGt(val interface{}, field interface{}, param string) bool {
st := reflect.ValueOf(field)
switch st.Kind() {
case reflect.String:
p := asInt(param)
return int64(len(st.String())) > p
case reflect.Slice, reflect.Map, reflect.Array:
p := asInt(param)
return int64(st.Len()) > p
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
p := asInt(param)
return st.Int() > p
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
p := asUint(param)
return st.Uint() > p
case reflect.Float32, reflect.Float64:
p := asFloat(param)
return st.Float() > p
case reflect.Struct:
if st.Type() == reflect.TypeOf(time.Time{}) {
return field.(time.Time).After(time.Now().UTC())
}
}
panic(fmt.Sprintf("Bad field type %T", field))
}
// length tests whether a variable's length is equal to a given
// value. For strings it tests the number of characters whereas
// for maps and slices it tests the number of items.
func hasLengthOf(val interface{}, field interface{}, param string) bool {
st := reflect.ValueOf(field)
switch st.Kind() {
case reflect.String:
p := asInt(param)
return int64(len(st.String())) == p
case reflect.Slice, reflect.Map, reflect.Array:
p := asInt(param)
return int64(st.Len()) == p
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
p := asInt(param)
return st.Int() == p
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
p := asUint(param)
return st.Uint() == p
case reflect.Float32, reflect.Float64:
p := asFloat(param)
return st.Float() == p
}
panic(fmt.Sprintf("Bad field type %T", field))
}
// min tests whether a variable value is larger or equal to a given
// number. For number types, it's a simple lesser-than test; for
// strings it tests the number of characters whereas for maps
// and slices it tests the number of items.
func hasMinOf(val interface{}, field interface{}, param string) bool {
return isGte(val, field, param)
}
func isLteField(val interface{}, field interface{}, param string) bool {
if val == nil {
panic("struct not passed for cross validation")
}
topVal := reflect.ValueOf(val)
if topVal.Kind() == reflect.Ptr && !topVal.IsNil() {
topVal = reflect.ValueOf(topVal.Elem().Interface())
}
var topFieldVal reflect.Value
switch topVal.Kind() {
case reflect.Struct:
if topVal.Type() == reflect.TypeOf(time.Time{}) {
topFieldVal = topVal
break
}
f := topVal.FieldByName(param)
if f.Kind() == reflect.Invalid {
panic(fmt.Sprintf("Field \"%s\" not found in struct", param))
}
topFieldVal = f
default:
topFieldVal = topVal
}
if topFieldVal.Kind() == reflect.Ptr && !topFieldVal.IsNil() {
topFieldVal = reflect.ValueOf(topFieldVal.Elem().Interface())
}
fv := reflect.ValueOf(field)
switch fv.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return fv.Int() <= topFieldVal.Int()
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
return fv.Uint() <= topFieldVal.Uint()
case reflect.Float32, reflect.Float64:
return fv.Float() <= topFieldVal.Float()
case reflect.Struct:
if fv.Type() == reflect.TypeOf(time.Time{}) {
if topFieldVal.Type() != reflect.TypeOf(time.Time{}) {
panic("Bad Top Level field type")
}
t := topFieldVal.Interface().(time.Time)
fieldTime := field.(time.Time)
return fieldTime.Before(t) || fieldTime.Equal(t)
}
}
panic(fmt.Sprintf("Bad field type %T", field))
}
func isLtField(val interface{}, field interface{}, param string) bool {
if val == nil {
panic("struct not passed for cross validation")
}
topVal := reflect.ValueOf(val)
if topVal.Kind() == reflect.Ptr && !topVal.IsNil() {
topVal = reflect.ValueOf(topVal.Elem().Interface())
}
var topFieldVal reflect.Value
switch topVal.Kind() {
case reflect.Struct:
if topVal.Type() == reflect.TypeOf(time.Time{}) {
topFieldVal = topVal
break
}
f := topVal.FieldByName(param)
if f.Kind() == reflect.Invalid {
panic(fmt.Sprintf("Field \"%s\" not found in struct", param))
}
topFieldVal = f
default:
topFieldVal = topVal
}
if topFieldVal.Kind() == reflect.Ptr && !topFieldVal.IsNil() {
topFieldVal = reflect.ValueOf(topFieldVal.Elem().Interface())
}
fv := reflect.ValueOf(field)
switch fv.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return fv.Int() < topFieldVal.Int()
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
return fv.Uint() < topFieldVal.Uint()
case reflect.Float32, reflect.Float64:
return fv.Float() < topFieldVal.Float()
case reflect.Struct:
if fv.Type() == reflect.TypeOf(time.Time{}) {
if topFieldVal.Type() != reflect.TypeOf(time.Time{}) {
panic("Bad Top Level field type")
}
t := topFieldVal.Interface().(time.Time)
fieldTime := field.(time.Time)
return fieldTime.Before(t)
}
}
panic(fmt.Sprintf("Bad field type %T", field))
}
func isLte(val interface{}, field interface{}, param string) bool {
st := reflect.ValueOf(field)
switch st.Kind() {
case reflect.String:
p := asInt(param)
return int64(len(st.String())) <= p
case reflect.Slice, reflect.Map, reflect.Array:
p := asInt(param)
return int64(st.Len()) <= p
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
p := asInt(param)
return st.Int() <= p
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
p := asUint(param)
return st.Uint() <= p
case reflect.Float32, reflect.Float64:
p := asFloat(param)
return st.Float() <= p
case reflect.Struct:
if st.Type() == reflect.TypeOf(time.Time{}) {
now := time.Now().UTC()
t := field.(time.Time)
return t.Before(now) || t.Equal(now)
}
}
panic(fmt.Sprintf("Bad field type %T", field))
}
func isLt(val interface{}, field interface{}, param string) bool {
st := reflect.ValueOf(field)
switch st.Kind() {
case reflect.String:
p := asInt(param)
return int64(len(st.String())) < p
case reflect.Slice, reflect.Map, reflect.Array:
p := asInt(param)
return int64(st.Len()) < p
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
p := asInt(param)
return st.Int() < p
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
p := asUint(param)
return st.Uint() < p
case reflect.Float32, reflect.Float64:
p := asFloat(param)
return st.Float() < p
case reflect.Struct:
if st.Type() == reflect.TypeOf(time.Time{}) {
return field.(time.Time).Before(time.Now().UTC())
}
}
panic(fmt.Sprintf("Bad field type %T", field))
}
// max tests whether a variable value is lesser than a given
// value. For numbers, it's a simple lesser-than test; for
// strings it tests the number of characters whereas for maps
// and slices it tests the number of items.
func hasMaxOf(val interface{}, field interface{}, param string) bool {
return isLte(val, field, param)
}
// asInt retuns the parameter as a int64
// or panics if it can't convert
func asInt(param string) int64 {
i, err := strconv.ParseInt(param, 0, 64)
if err != nil {
panic(err.Error())
}
return i
}
// asUint returns the parameter as a uint64
// or panics if it can't convert
func asUint(param string) uint64 {
i, err := strconv.ParseUint(param, 0, 64)
if err != nil {
panic(err.Error())
}
return i
}
// asFloat returns the parameter as a float64
// or panics if it can't convert
func asFloat(param string) float64 {
i, err := strconv.ParseFloat(param, 64)
if err != nil {
panic(err.Error())
}
return i
}