thedevsaddam / govalidator / 267

Committed 18 Jan 2021 04:16PM UTC coverage: 89.32%. First build

Build # 267

Build Type

Pull #80

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/thedevsaddam/govalidator/commit/<a class=hub.com/thedevsaddam/govalidator/commit/<a class="double-link" href="https://git"><a class=hub.com/thedevsaddam/govalidator/commit/<a class="double-link" href="https://git"><a class=hub.com/thedevsaddam/govalidator/commit/<a class="double-link" href="https://git"><a class=hub.com/thedevsaddam/govalidator/commit/3270e51620450d6bd70ce1027399f0f42b335316">3270e5162">&lt;a href=&quot;https://github.com/thedevsaddam/govalidator/commit/</a><a class="double-link" href="https://github.com/thedevsaddam/govalidator/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/thedevsaddam/govalidator/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/thedevsaddam/govalidator/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/thedevsaddam/govalidator/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/thedevsaddam/govalidator/commit/3270e51620450d6bd70ce1027399f0f42b335316">3270e5162</a><a href="https://github.com/thedevsaddam/govalidator/commit/3270e51620450d6bd70ce1027399f0f42b335316">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/thedevsaddam/govalidator/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/thedevsaddam/govalidator/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/thedevsaddam/govalidator/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/thedevsaddam/govalidator/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/thedevsaddam/govalidator/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/thedevsaddam/govalidator/commit/3270e51620450d6bd70ce1027399f0f42b335316&quot;&gt;3270e5162&lt;/a&gt;&lt;a href=&quot;https://github.com/thedevsaddam/govalidator/commit/3270e51620450d6bd70ce1027399f0f42b335316&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/thedevsaddam/govalidator/commit/&amp;lt;/a&amp;gt;&amp;lt;a... (continued)

Pull Request Pull Request #80: send params to govalidator custom messages issue #79

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

1380 of 1545 relevant lines covered (89.32%)

110.77 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.42

/rules.go

package govalidator

import (
        "errors"
        "fmt"
        "math"
        "mime/multipart"
        "net/url"
        "reflect"
        "strconv"
        "strings"
)

var rulesFuncMap = make(map[string]func(string, string, string, interface{}) error)

// AddCustomRule help to add custom rules for validator
// First argument it takes the rule name and second arg a func
// Second arg must have this signature below
// fn func(name string, fn func(field string, rule string, message string, value interface{}) error
// see example in readme: https://github.com/thedevsaddam/govalidator#add-custom-rules
func AddCustomRule(name string, fn func(field string, rule string, message string, value interface{}) error) {
        if isRuleExist(name) {
                panic(fmt.Errorf("govalidator: %s is already defined in rules", name))
        }
        rulesFuncMap[name] = fn
}

// validateCustomRules validate custom rules
func validateCustomRules(field string, rule string, message string, value interface{}, errsBag url.Values) {
        for k, v := range rulesFuncMap {
                if k == rule || strings.HasPrefix(rule, k+":") {
                        err := v(field, rule, message, value)
                        if err != nil {
                                errsBag.Add(field, err.Error())
                        }
                        break
                }
        }
}

func init() {

        // Required check the Required fields
        AddCustomRule("required", func(field, rule, message string, value interface{}) error {
                err := fmt.Errorf("The %s field is required", field)
                if message != "" {
                        err = errors.New(message)
                }
                if value == nil {
                        return err
                }
                if _, ok := value.(multipart.File); ok {
                        return nil
                }
                rv := reflect.ValueOf(value)
                switch rv.Kind() {
                case reflect.String, reflect.Array, reflect.Slice, reflect.Map:
                        if rv.Len() == 0 {
                                return err
                        }
                case reflect.Int:
                        if isEmpty(value.(int)) {
                                return err
                        }
                case reflect.Int8:
                        if isEmpty(value.(int8)) {
                                return err
                        }
                case reflect.Int16:
                        if isEmpty(value.(int16)) {
                                return err
                        }
                case reflect.Int32:
                        if isEmpty(value.(int32)) {
                                return err
                        }
                case reflect.Int64:
                        if isEmpty(value.(int64)) {
                                return err
                        }
                case reflect.Float32:
                        if isEmpty(value.(float32)) {
                                return err
                        }
                case reflect.Float64:
                        if isEmpty(value.(float64)) {
                                return err
                        }
                case reflect.Uint:
                        if isEmpty(value.(uint)) {
                                return err
                        }
                case reflect.Uint8:
                        if isEmpty(value.(uint8)) {
                                return err
                        }
                case reflect.Uint16:
                        if isEmpty(value.(uint16)) {
                                return err
                        }
                case reflect.Uint32:
                        if isEmpty(value.(uint32)) {
                                return err
                        }
                case reflect.Uint64:
                        if isEmpty(value.(uint64)) {
                                return err
                        }
                case reflect.Uintptr:
                        if isEmpty(value.(uintptr)) {
                                return err
                        }
                case reflect.Struct:
                        switch rv.Type().String() {
                        case "govalidator.Int":
                                if v, ok := value.(Int); ok {
                                        if !v.IsSet {
                                                return err
                                        }
                                }
                        case "govalidator.Int64":
                                if v, ok := value.(Int64); ok {
                                        if !v.IsSet {
                                                return err
                                        }
                                }
                        case "govalidator.Float32":
                                if v, ok := value.(Float32); ok {
                                        if !v.IsSet {
                                                return err
                                        }
                                }
                        case "govalidator.Float64":
                                if v, ok := value.(Float64); ok {
                                        if !v.IsSet {
                                                return err
                                        }
                                }
                        case "govalidator.Bool":
                                if v, ok := value.(Bool); ok {
                                        if !v.IsSet {
                                                return err
                                        }
                                }
                        default:
                                panic("govalidator: invalid custom type for required rule")

                        }

                default:
                        panic("govalidator: invalid type for required rule")

                }
                return nil
        })

        // Regex check the custom Regex rules
        // Regex:^[a-zA-Z]+$ means this field can only contain alphabet (a-z and A-Z)
        AddCustomRule("regex", func(field, rule, message string, value interface{}) error {
                str := toString(value)
                err := fmt.Errorf("The %s field format is invalid", field)
                if message != "" {
                        err = errors.New(message)
                }
                rxStr := strings.TrimPrefix(rule, "regex:")
                if !isMatchedRegex(rxStr, str) {
                        return err
                }
                return nil
        })

        // Alpha check if provided field contains valid letters
        AddCustomRule("alpha", func(field string, vlaue string, message string, value interface{}) error {
                str := toString(value)
                err := fmt.Errorf("The %s may only contain letters", field)
                if message != "" {
                        err = errors.New(message)
                }
                if !isAlpha(str) {
                        return err
                }
                return nil
        })

        // AlphaDash check if provided field contains valid letters, numbers, underscore and dash
        AddCustomRule("alpha_dash", func(field string, vlaue string, message string, value interface{}) error {
                str := toString(value)
                err := fmt.Errorf("The %s may only contain letters, numbers, and dashes", field)
                if message != "" {
                        err = errors.New(message)
                }
                if !isAlphaDash(str) {
                        return err
                }
                return nil
        })

        // AlphaDash check if provided field contains valid letters, numbers, underscore and dash
        AddCustomRule("alpha_space", func(field string, vlaue string, message string, value interface{}) error {
                str := toString(value)
                err := fmt.Errorf("The %s may only contain letters, numbers, dashes, space", field)
                if message != "" {
                        err = errors.New(message)
                }
                if !isAlphaSpace(str) {
                        return err
                }
                return nil
        })

        // AlphaNumeric check if provided field contains valid letters and numbers
        AddCustomRule("alpha_num", func(field string, vlaue string, message string, value interface{}) error {
                str := toString(value)
                err := fmt.Errorf("The %s may only contain letters and numbers", field)
                if message != "" {
                        err = errors.New(message)
                }
                if !isAlphaNumeric(str) {
                        return err
                }
                return nil
        })

        // Boolean check if provided field contains Boolean
        // in this case: "0", "1", 0, 1, "true", "false", true, false etc
        AddCustomRule("bool", func(field string, vlaue string, message string, value interface{}) error {
                err := fmt.Errorf("The %s may only contain boolean value, string or int 0, 1", field)
                if message != "" {
                        err = errors.New(message)
                }
                switch t := value.(type) {
                case bool:
                        //if value is boolean then pass
                case string:
                        if !isBoolean(t) {
                                return err
                        }
                case int:
                        if t != 0 && t != 1 {
                                return err
                        }
                case int8:
                        if t != 0 && t != 1 {
                                return err
                        }
                case int16:
                        if t != 0 && t != 1 {
                                return err
                        }
                case int32:
                        if t != 0 && t != 1 {
                                return err
                        }
                case int64:
                        if t != 0 && t != 1 {
                                return err
                        }
                case uint:
                        if t != 0 && t != 1 {
                                return err
                        }
                case uint8:
                        if t != 0 && t != 1 {
                                return err
                        }
                case uint16:
                        if t != 0 && t != 1 {
                                return err
                        }
                case uint32:
                        if t != 0 && t != 1 {
                                return err
                        }
                case uint64:
                        if t != 0 && t != 1 {
                                return err
                        }
                case uintptr:
                        if t != 0 && t != 1 {
                                return err
                        }
                }
                return nil
        })

        // Between check the fields character length range
        // if the field is array, map, slice then the valdiation rule will be the length of the data
        // if the value is int or float then the valdiation rule will be the value comparison
        AddCustomRule("between", func(field string, rule string, message string, value interface{}) error {
                rng := strings.Split(strings.TrimPrefix(rule, "between:"), ",")
                if len(rng) != 2 {
                        panic(errInvalidArgument)
                }
                minFloat, err := strconv.ParseFloat(rng[0], 64)
                if err != nil {
                        panic(errStringToInt)
                }
                maxFloat, err := strconv.ParseFloat(rng[1], 64)
                if err != nil {
                        panic(errStringToInt)
                }
                min := int(minFloat)

                max := int(maxFloat)

                err = fmt.Errorf("The %s field must be between %d and %d", field, min, max)
                if message != "" {
                        err = errors.New(message)
                }
                rv := reflect.ValueOf(value)
                switch rv.Kind() {
                case reflect.String, reflect.Array, reflect.Map, reflect.Slice:
                        inLen := rv.Len()
                        if !(inLen >= min && inLen <= max) {
                                return err
                        }
                case reflect.Int:
                        in := value.(int)
                        if !(in >= min && in <= max) {
                                return err
                        }
                case reflect.Int8:
                        in := int(value.(int8))
                        if !(in >= min && in <= max) {
                                return err
                        }
                case reflect.Int16:
                        in := int(value.(int16))
                        if !(in >= min && in <= max) {
                                return err
                        }
                case reflect.Int32:
                        in := int(value.(int32))
                        if !(in >= min && in <= max) {
                                return err
                        }
                case reflect.Int64:
                        in := int(value.(int64))
                        if !(in >= min && in <= max) {
                                return err
                        }
                case reflect.Uint:
                        in := int(value.(uint))
                        if !(in >= min && in <= max) {
                                return err
                        }
                case reflect.Uint8:
                        in := int(value.(uint8))
                        if !(in >= min && in <= max) {
                                return err
                        }
                case reflect.Uint16:
                        in := int(value.(uint16))
                        if !(in >= min && in <= max) {
                                return err
                        }
                case reflect.Uint32:
                        in := int(value.(uint32))
                        if !(in >= min && in <= max) {
                                return err
                        }
                case reflect.Uint64:
                        in := int(value.(uint64))
                        if !(in >= min && in <= max) {
                                return err
                        }
                case reflect.Uintptr:
                        in := int(value.(uintptr))
                        if !(in >= min && in <= max) {
                                return err
                        }
                case reflect.Float32:
                        in := float64(value.(float32))
                        if !(in >= minFloat && in <= maxFloat) {
                                return fmt.Errorf("The %s field must be between %f and %f", field, minFloat, maxFloat)
                        }
                case reflect.Float64:
                        in := value.(float64)
                        if !(in >= minFloat && in <= maxFloat) {
                                return fmt.Errorf("The %s field must be between %f and %f", field, minFloat, maxFloat)
                        }

                }

                return nil
        })

        // CreditCard check if provided field contains valid credit card number
        // Accepted cards are Visa, MasterCard, American Express, Diners Club, Discover and JCB card
        AddCustomRule("credit_card", func(field string, rule string, message string, value interface{}) error {
                str := toString(value)
                err := fmt.Errorf("The %s field must be a valid credit card number", field)
                if message != "" {
                        err = errors.New(message)
                }
                if !isCreditCard(str) {
                        return err
                }
                return nil
        })

        // Coordinate check if provided field contains valid Coordinate
        AddCustomRule("coordinate", func(field string, rule string, message string, value interface{}) error {
                str := toString(value)
                err := fmt.Errorf("The %s field must be a valid coordinate", field)
                if message != "" {
                        err = errors.New(message)
                }
                if !isCoordinate(str) {
                        return err
                }
                return nil
        })

        // ValidateCSSColor check if provided field contains a valid CSS color code
        AddCustomRule("css_color", func(field string, rule string, message string, value interface{}) error {
                str := toString(value)
                err := fmt.Errorf("The %s field must be a valid CSS color code", field)
                if message != "" {
                        err = errors.New(message)
                }
                if !isCSSColor(str) {
                        return err
                }
                return nil
        })

        // Digits check the exact matching length of digit (0,9)
        // Digits:5 means the field must have 5 digit of length.
        // e.g: 12345 or 98997 etc
        AddCustomRule("digits", func(field string, rule string, message string, value interface{}) error {
                l, err := strconv.Atoi(strings.TrimPrefix(rule, "digits:"))
                if err != nil {
                        panic(errStringToInt)
                }
                err = fmt.Errorf("The %s field must be %d digits", field, l)
                if l == 1 {
                        err = fmt.Errorf("The %s field must be 1 digit", field)
                }
                if message != "" {
                        err = errors.New(message)
                }
                var str string
                switch v := value.(type) {
                case string:
                        str = v
                case float64:
                        str = toString(int64(v))
                case float32:
                        str = toString(int64(v))
                default:
                        str = toString(v)
                }
                if len(str) != l || !regexDigits.MatchString(str) {
                        return err
                }

                return nil
        })

        // DigitsBetween check if the field contains only digit and length between provided range
        // e.g: digits_between:4,5 means the field can have value like: 8887 or 12345 etc
        AddCustomRule("digits_between", func(field string, rule string, message string, value interface{}) error {
                rng := strings.Split(strings.TrimPrefix(rule, "digits_between:"), ",")
                if len(rng) != 2 {
                        panic(errInvalidArgument)
                }
                min, err := strconv.Atoi(rng[0])
                if err != nil {
                        panic(errStringToInt)
                }
                max, err := strconv.Atoi(rng[1])
                if err != nil {
                        panic(errStringToInt)
                }
                err = fmt.Errorf("The %s field must be digits between %d and %d", field, min, max)
                if message != "" {
                        err = errors.New(message)
                }
                str := toString(value)
                if !isNumeric(str) || !(len(str) >= min && len(str) <= max) {
                        return err
                }

                return nil
        })

        // Date check the provided field is valid Date
        AddCustomRule("date", func(field string, rule string, message string, value interface{}) error {
                str := toString(value)

                switch rule {
                case "date:dd-mm-yyyy":
                        if !isDateDDMMYY(str) {
                                if message != "" {
                                        return errors.New(message)
                                }
                                return fmt.Errorf("The %s field must be a valid date format. e.g: dd-mm-yyyy, dd/mm/yyyy etc", field)
                        }
                default:
                        if !isDate(str) {
                                if message != "" {
                                        return errors.New(message)
                                }
                                return fmt.Errorf("The %s field must be a valid date format. e.g: yyyy-mm-dd, yyyy/mm/dd etc", field)
                        }
                }

                return nil
        })

        // Email check the provided field is valid Email
        AddCustomRule("email", func(field string, rule string, message string, value interface{}) error {
                str := toString(value)
                err := fmt.Errorf("The %s field must be a valid email address", field)
                if message != "" {
                        err = errors.New(message)
                }
                if !isEmail(str) {
                        return err
                }
                return nil
        })

        // validFloat check the provided field is valid float number
        AddCustomRule("float", func(field string, rule string, message string, value interface{}) error {
                str := toString(value)
                err := fmt.Errorf("The %s field must be a float number", field)
                if message != "" {
                        err = errors.New(message)
                }
                if !isFloat(str) {
                        return err
                }
                return nil
        })

        // IP check if provided field is valid IP address
        AddCustomRule("ip", func(field string, rule string, message string, value interface{}) error {
                str := toString(value)
                err := fmt.Errorf("The %s field must be a valid IP address", field)
                if message != "" {
                        err = errors.New(message)
                }
                if !isIP(str) {
                        return err
                }
                return nil
        })

        // IP check if provided field is valid IP v4 address
        AddCustomRule("ip_v4", func(field string, rule string, message string, value interface{}) error {
                str := toString(value)
                err := fmt.Errorf("The %s field must be a valid IPv4 address", field)
                if message != "" {
                        err = errors.New(message)
                }
                if !isIPV4(str) {
                        return err
                }
                return nil
        })

        // IP check if provided field is valid IP v6 address
        AddCustomRule("ip_v6", func(field string, rule string, message string, value interface{}) error {
                str := toString(value)
                err := fmt.Errorf("The %s field must be a valid IPv6 address", field)
                if message != "" {
                        err = errors.New(message)
                }
                if !isIPV6(str) {
                        return err
                }
                return nil
        })

        // ValidateJSON check if provided field contains valid json string
        AddCustomRule("json", func(field string, rule string, message string, value interface{}) error {
                str := toString(value)
                err := fmt.Errorf("The %s field must contain valid JSON string", field)
                if message != "" {
                        err = errors.New(message)
                }
                if !isJSON(str) {
                        return err
                }
                return nil
        })

        /// Latitude check if provided field contains valid Latitude
        AddCustomRule("lat", func(field string, rule string, message string, value interface{}) error {
                str := toString(value)
                err := fmt.Errorf("The %s field must contain valid latitude", field)
                if message != "" {
                        err = errors.New(message)
                }
                if !isLatitude(str) {
                        return err
                }
                return nil
        })

        // Longitude check if provided field contains valid Longitude
        AddCustomRule("lon", func(field string, rule string, message string, value interface{}) error {
                str := toString(value)
                err := fmt.Errorf("The %s field must contain valid longitude", field)
                if message != "" {
                        err = errors.New(message)
                }
                if !isLongitude(str) {
                        return err
                }
                return nil
        })

        // Length check the field's character Length
        AddCustomRule("len", func(field string, rule string, message string, value interface{}) error {
                l, err := strconv.Atoi(strings.TrimPrefix(rule, "len:"))
                if err != nil {
                        panic(errStringToInt)
                }
                err = fmt.Errorf("The %s field must be length of %d", field, l)
                if message != "" {
                        err = errors.New(message)
                }
                rv := reflect.ValueOf(value)
                switch rv.Kind() {
                case reflect.String, reflect.Array, reflect.Map, reflect.Slice:
                        vLen := rv.Len()
                        if vLen != l {
                                return err
                        }
                default:
                        str := toString(value) //force the value to be string
                        if len(str) != l {
                                return err
                        }
                }

                return nil
        })

        // Min check the field's minimum character length for string, value for int, float and size for array, map, slice
        AddCustomRule("min", func(field string, rule string, message string, value interface{}) error {
                mustLen := strings.TrimPrefix(rule, "min:")
                lenInt, err := strconv.Atoi(mustLen)
                if err != nil {
                        panic(errStringToInt)
                }
                lenFloat, err := strconv.ParseFloat(mustLen, 64)
                if err != nil {
                        panic(errStringToFloat)
                }
                errMsg := fmt.Errorf("The %s field value can not be less than %d", field, lenInt)
                if message != "" {
                        errMsg = errors.New(message)
                }
                errMsgFloat := fmt.Errorf("The %s field value can not be less than %f", field, lenFloat)
                if message != "" {
                        errMsgFloat = errors.New(message)
                }
                rv := reflect.ValueOf(value)
                switch rv.Kind() {
                case reflect.String:
                        inLen := rv.Len()
                        if inLen < lenInt {
                                if message != "" {
                                        return errors.New(message)
                                }
                                return fmt.Errorf("The %s field must be minimum %d char", field, lenInt)
                        }
                case reflect.Array, reflect.Map, reflect.Slice:
                        inLen := rv.Len()
                        if inLen < lenInt {
                                if message != "" {
                                        return errors.New(message)
                                }
                                return fmt.Errorf("The %s field must be minimum %d in size", field, lenInt)
                        }
                case reflect.Int:
                        in := value.(int)
                        if in < lenInt {
                                return errMsg
                        }
                case reflect.Int8:
                        in := int(value.(int8))
                        if in < lenInt {
                                return errMsg
                        }
                case reflect.Int16:
                        in := int(value.(int16))
                        if in < lenInt {
                                return errMsg
                        }
                case reflect.Int32:
                        in := int(value.(int32))
                        if in < lenInt {
                                return errMsg
                        }
                case reflect.Int64:
                        in := int(value.(int64))
                        if in < lenInt {
                                return errMsg
                        }
                case reflect.Uint:
                        in := int(value.(uint))
                        if in < lenInt {
                                return errMsg
                        }
                case reflect.Uint8:
                        in := int(value.(uint8))
                        if in < lenInt {
                                return errMsg
                        }
                case reflect.Uint16:
                        in := int(value.(uint16))
                        if in < lenInt {
                                return errMsg
                        }
                case reflect.Uint32:
                        in := int(value.(uint32))
                        if in < lenInt {
                                return errMsg
                        }
                case reflect.Uint64:
                        in := int(value.(uint64))
                        if in < lenInt {
                                return errMsg
                        }
                case reflect.Uintptr:
                        in := int(value.(uintptr))
                        if in < lenInt {
                                return errMsg
                        }
                case reflect.Float32:
                        in := value.(float32)
                        if in < float32(lenFloat) {
                                return errMsgFloat
                        }
                case reflect.Float64:
                        in := value.(float64)
                        if in < lenFloat {
                                return errMsgFloat
                        }

                }

                return nil
        })

        // Max check the field's maximum character length for string, value for int, float and size for array, map, slice
        AddCustomRule("max", func(field string, rule string, message string, value interface{}) error {
                mustLen := strings.TrimPrefix(rule, "max:")
                lenInt, err := strconv.Atoi(mustLen)
                if err != nil {
                        panic(errStringToInt)
                }
                lenFloat, err := strconv.ParseFloat(mustLen, 64)
                if err != nil {
                        panic(errStringToFloat)
                }
                errMsg := fmt.Errorf("The %s field value can not be greater than %d", field, lenInt)
                if message != "" {
                        errMsg = errors.New(message)
                }
                errMsgFloat := fmt.Errorf("The %s field value can not be greater than %f", field, lenFloat)
                if message != "" {
                        errMsgFloat = errors.New(message)
                }
                rv := reflect.ValueOf(value)
                switch rv.Kind() {
                case reflect.String:
                        inLen := rv.Len()
                        if inLen > lenInt {
                                if message != "" {
                                        return errors.New(message)
                                }
                                return fmt.Errorf("The %s field must be maximum %d char", field, lenInt)
                        }
                case reflect.Array, reflect.Map, reflect.Slice:
                        inLen := rv.Len()
                        if inLen > lenInt {
                                if message != "" {
                                        return errors.New(message)
                                }
                                return fmt.Errorf("The %s field must be maximum %d in size", field, lenInt)
                        }
                case reflect.Int:
                        in := value.(int)
                        if in > lenInt {
                                return errMsg
                        }
                case reflect.Int8:
                        in := int(value.(int8))
                        if in > lenInt {
                                return errMsg
                        }
                case reflect.Int16:
                        in := int(value.(int16))
                        if in > lenInt {
                                return errMsg
                        }
                case reflect.Int32:
                        in := int(value.(int32))
                        if in > lenInt {
                                return errMsg
                        }
                case reflect.Int64:
                        in := int(value.(int64))
                        if in > lenInt {
                                return errMsg
                        }
                case reflect.Uint:
                        in := int(value.(uint))
                        if in > lenInt {
                                return errMsg
                        }
                case reflect.Uint8:
                        in := int(value.(uint8))
                        if in > lenInt {
                                return errMsg
                        }
                case reflect.Uint16:
                        in := int(value.(uint16))
                        if in > lenInt {
                                return errMsg
                        }
                case reflect.Uint32:
                        in := int(value.(uint32))
                        if in > lenInt {
                                return errMsg
                        }
                case reflect.Uint64:
                        in := int(value.(uint64))
                        if in > lenInt {
                                return errMsg
                        }
                case reflect.Uintptr:
                        in := int(value.(uintptr))
                        if in > lenInt {
                                return errMsg
                        }
                case reflect.Float32:
                        in := value.(float32)
                        if in > float32(lenFloat) {
                                return errMsgFloat
                        }
                case reflect.Float64:
                        in := value.(float64)
                        if in > lenFloat {
                                return errMsgFloat
                        }

                }

                return nil
        })

        // Numeric check if the value of the field is Numeric
        AddCustomRule("mac_address", func(field string, rule string, message string, value interface{}) error {
                str := toString(value)
                err := fmt.Errorf("The %s field must be a valid Mac Address", field)
                if message != "" {
                        err = errors.New(message)
                }
                if !isMacAddress(str) {
                        return err
                }
                return nil
        })

        // Numeric check if the value of the field is Numeric
        AddCustomRule("numeric", func(field string, rule string, message string, value interface{}) error {
                str := toString(value)
                err := fmt.Errorf("The %s field must be numeric", field)
                if message != "" {
                        err = errors.New(message)
                }
                if !isNumeric(str) {
                        return err
                }
                return nil
        })

        // NumericBetween check if the value field numeric value range
        // e.g: numeric_between:18, 65 means number value must be in between a numeric value 18 & 65
        // Both of the bounds can be omited turning it into a min only (`10,`) or a max only (`,10`)
        AddCustomRule("numeric_between", func(field string, rule string, message string, value interface{}) error {
                rng := strings.Split(strings.TrimPrefix(rule, "numeric_between:"), ",")
                if len(rng) != 2 {
                        panic(errInvalidArgument)
                }

                if rng[0] == "" && rng[1] == "" {
                        panic(errInvalidArgument)
                }

                // check for integer value
                min := math.MinInt64
                if rng[0] != "" {
                        _min, err := strconv.ParseFloat(rng[0], 64)
                        if err != nil {
                                panic(errStringToInt)
                        }
                        min = int(_min)
                }

                max := math.MaxInt64
                if rng[1] != "" {
                        _max, err := strconv.ParseFloat(rng[1], 64)
                        if err != nil {
                                panic(errStringToInt)
                        }
                        max = int(_max)
                }

                var errMsg error
                switch {
                case rng[0] == "":
                        errMsg = fmt.Errorf("The %s field value can not be greater than %d", field, max)
                case rng[1] == "":
                        errMsg = fmt.Errorf("The %s field value can not be less than %d", field, min)
                default:
                        errMsg = fmt.Errorf("The %s field must be numeric value between %d and %d", field, min, max)
                }

                if message != "" {
                        errMsg = errors.New(message)
                }

                val := toString(value)

                if !strings.Contains(rng[0], ".") || !strings.Contains(rng[1], ".") {
                        digit, errs := strconv.Atoi(val)
                        if errs != nil {
                                return errMsg
                        }
                        if !(digit >= min && digit <= max) {
                                return errMsg
                        }
                }
                // check for float value
                var err error
                minFloat := -math.MaxFloat64
                if rng[0] != "" {
                        minFloat, err = strconv.ParseFloat(rng[0], 64)
                        if err != nil {
                                panic(errStringToFloat)
                        }
                }

                maxFloat := math.MaxFloat64
                if rng[1] != "" {
                        maxFloat, err = strconv.ParseFloat(rng[1], 64)
                        if err != nil {
                                panic(errStringToFloat)
                        }
                }

                switch {
                case rng[0] == "":
                        errMsg = fmt.Errorf("The %s field value can not be greater than %f", field, maxFloat)
                case rng[1] == "":
                        errMsg = fmt.Errorf("The %s field value can not be less than %f", field, minFloat)
                default:
                        errMsg = fmt.Errorf("The %s field must be numeric value between %f and %f", field, minFloat, maxFloat)
                }

                if message != "" {
                        errMsg = errors.New(message)
                }

                digit, err := strconv.ParseFloat(val, 64)
                if err != nil {
                        return errMsg
                }
                if !(digit >= minFloat && digit <= maxFloat) {
                        return errMsg
                }
                return nil
        })

        // ValidateURL check if provided field is valid URL
        AddCustomRule("url", func(field string, rule string, message string, value interface{}) error {
                str := toString(value)
                err := fmt.Errorf("The %s field format is invalid", field)
                if message != "" {
                        err = errors.New(message)
                }
                if !isURL(str) {
                        return err
                }
                return nil
        })

        // UUID check if provided field contains valid UUID
        AddCustomRule("uuid", func(field string, rule string, message string, value interface{}) error {
                str := toString(value)
                err := fmt.Errorf("The %s field must contain valid UUID", field)
                if message != "" {
                        err = errors.New(message)
                }
                if !isUUID(str) {
                        return err
                }
                return nil
        })

        // UUID3 check if provided field contains valid UUID of version 3
        AddCustomRule("uuid_v3", func(field string, rule string, message string, value interface{}) error {
                str := toString(value)
                err := fmt.Errorf("The %s field must contain valid UUID V3", field)
                if message != "" {
                        err = errors.New(message)
                }
                if !isUUID3(str) {
                        return err
                }
                return nil
        })

        // UUID4 check if provided field contains valid UUID of version 4
        AddCustomRule("uuid_v4", func(field string, rule string, message string, value interface{}) error {
                str := toString(value)
                err := fmt.Errorf("The %s field must contain valid UUID V4", field)
                if message != "" {
                        err = errors.New(message)
                }
                if !isUUID4(str) {
                        return err
                }
                return nil
        })

        // UUID5 check if provided field contains valid UUID of version 5
        AddCustomRule("uuid_v5", func(field string, rule string, message string, value interface{}) error {
                str := toString(value)
                err := fmt.Errorf("The %s field must contain valid UUID V5", field)
                if message != "" {
                        err = errors.New(message)
                }
                if !isUUID5(str) {
                        return err
                }
                return nil
        })

        // In check if provided field equals one of the values specified in the rule
        AddCustomRule("in", func(field string, rule string, message string, value interface{}) error {
                rng := strings.Split(strings.TrimPrefix(rule, "in:"), ",")
                if len(rng) == 0 {
                        panic(errInvalidArgument)
                }
                str := toString(value)
                err := fmt.Errorf("The %s field must be one of %v", field, strings.Join(rng, ", "))
                if message != "" {
                        err = errors.New(message)
                }
                if !isIn(rng, str) {
                        return err
                }
                return nil
        })

        // In check if provided field equals one of the values specified in the rule
        AddCustomRule("not_in", func(field string, rule string, message string, value interface{}) error {
                rng := strings.Split(strings.TrimPrefix(rule, "not_in:"), ",")
                if len(rng) == 0 {
                        panic(errInvalidArgument)
                }
                str := toString(value)
                err := fmt.Errorf("The %s field must not be any of %v", field, strings.Join(rng, ", "))
                if message != "" {
                        err = errors.New(message)
                }
                if isIn(rng, str) {
                        return err
                }
                return nil
        })
}

thedevsaddam / govalidator / 267

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous