lbsadmin/Beego
1
0
Fork 0
mirror of https://github.com/astaxie/beego.git synced 2024-11-19 05:10:54 +00:00
Code Issues Releases Activity

golint validation

Browse Source
This commit is contained in:
astaxie 2015-09-13 00:13:19 +08:00
parent 1d200da472
commit 2389bc72f9
5 changed files with 202 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
validation/util.go
View File

@ -23,7 +23,8 @@ import (
) )
const ( const (
VALIDTAG = "valid" // ValidTag struct tag
ValidTag = "valid"
) )
var ( var (
@ -55,16 +56,16 @@ func init() {
} }
} }
// Valid function type // ValidFunc Valid function type
type ValidFunc struct { type ValidFunc struct {
Name string Name string
Params []interface{} Params []interface{}
} }
// Validate function map // Funcs Validate function map
type Funcs map[string]reflect.Value type Funcs map[string]reflect.Value
// validate values with named type string // Call validate values with named type string
func (f Funcs) Call(name string, params ...interface{}) (result []reflect.Value, err error) { func (f Funcs) Call(name string, params ...interface{}) (result []reflect.Value, err error) {
defer func() { defer func() {
if r := recover(); r != nil { if r := recover(); r != nil {
@ -96,7 +97,7 @@ func isStructPtr(t reflect.Type) bool {
} }
func getValidFuncs(f reflect.StructField) (vfs []ValidFunc, err error) { func getValidFuncs(f reflect.StructField) (vfs []ValidFunc, err error) {
tag := f.Tag.Get(VALIDTAG) tag := f.Tag.Get(ValidTag)
if len(tag) == 0 { if len(tag) == 0 {
return return
} }

4
validation/util_test.go
View File

@ -20,7 +20,7 @@ import (
) )
type user struct { type user struct {
Id int ID int
Tag string `valid:"Maxx(aa)"` Tag string `valid:"Maxx(aa)"`
Name string `valid:"Required;"` Name string `valid:"Required;"`
Age int `valid:"Required;Range(1, 140)"` Age int `valid:"Required;Range(1, 140)"`
@ -33,7 +33,7 @@ func TestGetValidFuncs(t *testing.T) {
var vfs []ValidFunc var vfs []ValidFunc
var err error var err error
f, _ := tf.FieldByName("Id") f, _ := tf.FieldByName("ID")
if vfs, err = getValidFuncs(f); err != nil { if vfs, err = getValidFuncs(f); err != nil {
t.Fatal(err) t.Fatal(err)
} }

192
validation/validation.go
View File

@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and // See the License for the specific language governing permissions and
// limitations under the License. // limitations under the License.
// package for validations // Package validation for validations
// //
// import ( // import (
// "github.com/astaxie/beego/validation" // "github.com/astaxie/beego/validation"
@ -53,41 +53,43 @@ import (
"strings" "strings"
) )
// ValidFormer valid interface
type ValidFormer interface { type ValidFormer interface {
Valid(*Validation) Valid(*Validation)
} }
type ValidationError struct { // Error show the error
type Error struct {
Message, Key, Name, Field, Tmpl string Message, Key, Name, Field, Tmpl string
Value interface{} Value interface{}
LimitValue interface{} LimitValue interface{}
} }
// Returns the Message. // String Returns the Message.
func (e *ValidationError) String() string { func (e *Error) String() string {
if e == nil { if e == nil {
return "" return ""
} }
return e.Message return e.Message
} }
// A ValidationResult is returned from every validation method. // Result is returned from every validation method.
// It provides an indication of success, and a pointer to the Error (if any). // It provides an indication of success, and a pointer to the Error (if any).
type ValidationResult struct { type Result struct {
Error *ValidationError Error *Error
Ok bool Ok bool
} }
// Get ValidationResult by given key string. // Key Get Result by given key string.
func (r *ValidationResult) Key(key string) *ValidationResult { func (r *Result) Key(key string) *Result {
if r.Error != nil { if r.Error != nil {
r.Error.Key = key r.Error.Key = key
} }
return r return r
} }
// Set ValidationResult message by string or format string with args // Message Set Result message by string or format string with args
func (r *ValidationResult) Message(message string, args ...interface{}) *ValidationResult { func (r *Result) Message(message string, args ...interface{}) *Result {
if r.Error != nil { if r.Error != nil {
if len(args) == 0 { if len(args) == 0 {
r.Error.Message = message r.Error.Message = message
@ -100,142 +102,142 @@ func (r *ValidationResult) Message(message string, args ...interface{}) *Validat
// A Validation context manages data validation and error messages. // A Validation context manages data validation and error messages.
type Validation struct { type Validation struct {
Errors []*ValidationError Errors []*Error
ErrorsMap map[string]*ValidationError ErrorsMap map[string]*Error
} }
// Clean all ValidationError. // Clear Clean all ValidationError.
func (v *Validation) Clear() { func (v *Validation) Clear() {
v.Errors = []*ValidationError{} v.Errors = []*Error{}
v.ErrorsMap = nil v.ErrorsMap = nil
} }
// Has ValidationError nor not. // HasErrors Has ValidationError nor not.
func (v *Validation) HasErrors() bool { func (v *Validation) HasErrors() bool {
return len(v.Errors) > 0 return len(v.Errors) > 0
} }
// Return the errors mapped by key. // ErrorMap Return the errors mapped by key.
// If there are multiple validation errors associated with a single key, the // If there are multiple validation errors associated with a single key, the
// first one "wins". (Typically the first validation will be the more basic). // first one "wins". (Typically the first validation will be the more basic).
func (v *Validation) ErrorMap() map[string]*ValidationError { func (v *Validation) ErrorMap() map[string]*Error {
return v.ErrorsMap return v.ErrorsMap
} }
// Add an error to the validation context. // Error Add an error to the validation context.
func (v *Validation) Error(message string, args ...interface{}) *ValidationResult { func (v *Validation) Error(message string, args ...interface{}) *Result {
result := (&ValidationResult{ result := (&Result{
Ok: false, Ok: false,
Error: &ValidationError{}, Error: &Error{},
}).Message(message, args...) }).Message(message, args...)
v.Errors = append(v.Errors, result.Error) v.Errors = append(v.Errors, result.Error)
return result return result
} }
// Test that the argument is non-nil and non-empty (if string or list) // Required Test that the argument is non-nil and non-empty (if string or list)
func (v *Validation) Required(obj interface{}, key string) *ValidationResult { func (v *Validation) Required(obj interface{}, key string) *Result {
return v.apply(Required{key}, obj) return v.apply(Required{key}, obj)
} }
// Test that the obj is greater than min if obj's type is int // Min Test that the obj is greater than min if obj's type is int
func (v *Validation) Min(obj interface{}, min int, key string) *ValidationResult { func (v *Validation) Min(obj interface{}, min int, key string) *Result {
return v.apply(Min{min, key}, obj) return v.apply(Min{min, key}, obj)
} }
// Test that the obj is less than max if obj's type is int // Max Test that the obj is less than max if obj's type is int
func (v *Validation) Max(obj interface{}, max int, key string) *ValidationResult { func (v *Validation) Max(obj interface{}, max int, key string) *Result {
return v.apply(Max{max, key}, obj) return v.apply(Max{max, key}, obj)
} }
// Test that the obj is between mni and max if obj's type is int // Range Test that the obj is between mni and max if obj's type is int
func (v *Validation) Range(obj interface{}, min, max int, key string) *ValidationResult { func (v *Validation) Range(obj interface{}, min, max int, key string) *Result {
return v.apply(Range{Min{Min: min}, Max{Max: max}, key}, obj) return v.apply(Range{Min{Min: min}, Max{Max: max}, key}, obj)
} }
// Test that the obj is longer than min size if type is string or slice // MinSize Test that the obj is longer than min size if type is string or slice
func (v *Validation) MinSize(obj interface{}, min int, key string) *ValidationResult { func (v *Validation) MinSize(obj interface{}, min int, key string) *Result {
return v.apply(MinSize{min, key}, obj) return v.apply(MinSize{min, key}, obj)
} }
// Test that the obj is shorter than max size if type is string or slice // MaxSize Test that the obj is shorter than max size if type is string or slice
func (v *Validation) MaxSize(obj interface{}, max int, key string) *ValidationResult { func (v *Validation) MaxSize(obj interface{}, max int, key string) *Result {
return v.apply(MaxSize{max, key}, obj) return v.apply(MaxSize{max, key}, obj)
} }
// Test that the obj is same length to n if type is string or slice // Length Test that the obj is same length to n if type is string or slice
func (v *Validation) Length(obj interface{}, n int, key string) *ValidationResult { func (v *Validation) Length(obj interface{}, n int, key string) *Result {
return v.apply(Length{n, key}, obj) return v.apply(Length{n, key}, obj)
} }
// Test that the obj is [a-zA-Z] if type is string // Alpha Test that the obj is [a-zA-Z] if type is string
func (v *Validation) Alpha(obj interface{}, key string) *ValidationResult { func (v *Validation) Alpha(obj interface{}, key string) *Result {
return v.apply(Alpha{key}, obj) return v.apply(Alpha{key}, obj)
} }
// Test that the obj is [0-9] if type is string // Numeric Test that the obj is [0-9] if type is string
func (v *Validation) Numeric(obj interface{}, key string) *ValidationResult { func (v *Validation) Numeric(obj interface{}, key string) *Result {
return v.apply(Numeric{key}, obj) return v.apply(Numeric{key}, obj)
} }
// Test that the obj is [0-9a-zA-Z] if type is string // AlphaNumeric Test that the obj is [0-9a-zA-Z] if type is string
func (v *Validation) AlphaNumeric(obj interface{}, key string) *ValidationResult { func (v *Validation) AlphaNumeric(obj interface{}, key string) *Result {
return v.apply(AlphaNumeric{key}, obj) return v.apply(AlphaNumeric{key}, obj)
} }
// Test that the obj matches regexp if type is string // Match Test that the obj matches regexp if type is string
func (v *Validation) Match(obj interface{}, regex *regexp.Regexp, key string) *ValidationResult { func (v *Validation) Match(obj interface{}, regex *regexp.Regexp, key string) *Result {
return v.apply(Match{regex, key}, obj) return v.apply(Match{regex, key}, obj)
} }
// Test that the obj doesn't match regexp if type is string // NoMatch Test that the obj doesn't match regexp if type is string
func (v *Validation) NoMatch(obj interface{}, regex *regexp.Regexp, key string) *ValidationResult { func (v *Validation) NoMatch(obj interface{}, regex *regexp.Regexp, key string) *Result {
return v.apply(NoMatch{Match{Regexp: regex}, key}, obj) return v.apply(NoMatch{Match{Regexp: regex}, key}, obj)
} }
// Test that the obj is [0-9a-zA-Z_-] if type is string // AlphaDash Test that the obj is [0-9a-zA-Z_-] if type is string
func (v *Validation) AlphaDash(obj interface{}, key string) *ValidationResult { func (v *Validation) AlphaDash(obj interface{}, key string) *Result {
return v.apply(AlphaDash{NoMatch{Match: Match{Regexp: alphaDashPattern}}, key}, obj) return v.apply(AlphaDash{NoMatch{Match: Match{Regexp: alphaDashPattern}}, key}, obj)
} }
// Test that the obj is email address if type is string // Email Test that the obj is email address if type is string
func (v *Validation) Email(obj interface{}, key string) *ValidationResult { func (v *Validation) Email(obj interface{}, key string) *Result {
return v.apply(Email{Match{Regexp: emailPattern}, key}, obj) return v.apply(Email{Match{Regexp: emailPattern}, key}, obj)
} }
// Test that the obj is IP address if type is string // IP Test that the obj is IP address if type is string
func (v *Validation) IP(obj interface{}, key string) *ValidationResult { func (v *Validation) IP(obj interface{}, key string) *Result {
return v.apply(IP{Match{Regexp: ipPattern}, key}, obj) return v.apply(IP{Match{Regexp: ipPattern}, key}, obj)
} }
// Test that the obj is base64 encoded if type is string // Base64 Test that the obj is base64 encoded if type is string
func (v *Validation) Base64(obj interface{}, key string) *ValidationResult { func (v *Validation) Base64(obj interface{}, key string) *Result {
return v.apply(Base64{Match{Regexp: base64Pattern}, key}, obj) return v.apply(Base64{Match{Regexp: base64Pattern}, key}, obj)
} }
// Test that the obj is chinese mobile number if type is string // Mobile Test that the obj is chinese mobile number if type is string
func (v *Validation) Mobile(obj interface{}, key string) *ValidationResult { func (v *Validation) Mobile(obj interface{}, key string) *Result {
return v.apply(Mobile{Match{Regexp: mobilePattern}, key}, obj) return v.apply(Mobile{Match{Regexp: mobilePattern}, key}, obj)
} }
// Test that the obj is chinese telephone number if type is string // Tel Test that the obj is chinese telephone number if type is string
func (v *Validation) Tel(obj interface{}, key string) *ValidationResult { func (v *Validation) Tel(obj interface{}, key string) *Result {
return v.apply(Tel{Match{Regexp: telPattern}, key}, obj) return v.apply(Tel{Match{Regexp: telPattern}, key}, obj)
} }
// Test that the obj is chinese mobile or telephone number if type is string // Phone Test that the obj is chinese mobile or telephone number if type is string
func (v *Validation) Phone(obj interface{}, key string) *ValidationResult { func (v *Validation) Phone(obj interface{}, key string) *Result {
return v.apply(Phone{Mobile{Match: Match{Regexp: mobilePattern}}, return v.apply(Phone{Mobile{Match: Match{Regexp: mobilePattern}},
Tel{Match: Match{Regexp: telPattern}}, key}, obj) Tel{Match: Match{Regexp: telPattern}}, key}, obj)
} }
// Test that the obj is chinese zip code if type is string // ZipCode Test that the obj is chinese zip code if type is string
func (v *Validation) ZipCode(obj interface{}, key string) *ValidationResult { func (v *Validation) ZipCode(obj interface{}, key string) *Result {
return v.apply(ZipCode{Match{Regexp: zipCodePattern}, key}, obj) return v.apply(ZipCode{Match{Regexp: zipCodePattern}, key}, obj)
} }
func (v *Validation) apply(chk Validator, obj interface{}) *ValidationResult { func (v *Validation) apply(chk Validator, obj interface{}) *Result {
if chk.IsSatisfied(obj) { if chk.IsSatisfied(obj) {
return &ValidationResult{Ok: true} return &Result{Ok: true}
} }
// Add the error to the validation context. // Add the error to the validation context.
@ -249,7 +251,7 @@ func (v *Validation) apply(chk Validator, obj interface{}) *ValidationResult {
Name = parts[1] Name = parts[1]
} }
err := &ValidationError{ err := &Error{
Message: chk.DefaultMessage(), Message: chk.DefaultMessage(),
Key: key, Key: key,
Name: Name, Name: Name,
@ -261,34 +263,34 @@ func (v *Validation) apply(chk Validator, obj interface{}) *ValidationResult {
v.setError(err) v.setError(err)
// Also return it in the result. // Also return it in the result.
return &ValidationResult{ return &Result{
Ok: false, Ok: false,
Error: err, Error: err,
} }
} }
func (v *Validation) setError(err *ValidationError) { func (v *Validation) setError(err *Error) {
v.Errors = append(v.Errors, err) v.Errors = append(v.Errors, err)
if v.ErrorsMap == nil { if v.ErrorsMap == nil {
v.ErrorsMap = make(map[string]*ValidationError) v.ErrorsMap = make(map[string]*Error)
} }
if _, ok := v.ErrorsMap[err.Field]; !ok { if _, ok := v.ErrorsMap[err.Field]; !ok {
v.ErrorsMap[err.Field] = err v.ErrorsMap[err.Field] = err
} }
} }
// Set error message for one field in ValidationError // SetError Set error message for one field in ValidationError
func (v *Validation) SetError(fieldName string, errMsg string) *ValidationError { func (v *Validation) SetError(fieldName string, errMsg string) *Error {
err := &ValidationError{Key: fieldName, Field: fieldName, Tmpl: errMsg, Message: errMsg} err := &Error{Key: fieldName, Field: fieldName, Tmpl: errMsg, Message: errMsg}
v.setError(err) v.setError(err)
return err return err
} }
// Apply a group of validators to a field, in order, and return the // Check Apply a group of validators to a field, in order, and return the
// ValidationResult from the first one that fails, or the last one that // ValidationResult from the first one that fails, or the last one that
// succeeds. // succeeds.
func (v *Validation) Check(obj interface{}, checks ...Validator) *ValidationResult { func (v *Validation) Check(obj interface{}, checks ...Validator) *Result {
var result *ValidationResult var result *Result
for _, check := range checks { for _, check := range checks {
result = v.apply(check, obj) result = v.apply(check, obj)
if !result.Ok { if !result.Ok {
@ -298,7 +300,7 @@ func (v *Validation) Check(obj interface{}, checks ...Validator) *ValidationResu
return result return result
} }
// Validate a struct. // Valid Validate a struct.
// the obj parameter must be a struct or a struct pointer // the obj parameter must be a struct or a struct pointer
func (v *Validation) Valid(obj interface{}) (b bool, err error) { func (v *Validation) Valid(obj interface{}) (b bool, err error) {
objT := reflect.TypeOf(obj) objT := reflect.TypeOf(obj)
@ -335,7 +337,7 @@ func (v *Validation) Valid(obj interface{}) (b bool, err error) {
return !v.HasErrors(), nil return !v.HasErrors(), nil
} }
// Recursively validate a struct. // RecursiveValid Recursively validate a struct.
// Step1: Validate by v.Valid // Step1: Validate by v.Valid
// Step2: If pass on step1, then reflect obj's fields // Step2: If pass on step1, then reflect obj's fields
// Step3: Do the Recursively validation to all struct or struct pointer fields // Step3: Do the Recursively validation to all struct or struct pointer fields
@ -345,30 +347,28 @@ func (v *Validation) RecursiveValid(objc interface{}) (bool, error) {
pass, err := v.Valid(objc) pass, err := v.Valid(objc)
if err != nil || false == pass { if err != nil || false == pass {
return pass, err // Stop recursive validation return pass, err // Stop recursive validation
} else { //pass }
// Step 2: Validate struct's struct fields // Step 2: Validate struct's struct fields
objT := reflect.TypeOf(objc) objT := reflect.TypeOf(objc)
objV := reflect.ValueOf(objc) objV := reflect.ValueOf(objc)
if isStructPtr(objT) { if isStructPtr(objT) {
objT = objT.Elem() objT = objT.Elem()
objV = objV.Elem() objV = objV.Elem()
} }
for i := 0; i < objT.NumField(); i++ { for i := 0; i < objT.NumField(); i++ {
t := objT.Field(i).Type t := objT.Field(i).Type
// Recursive applies to struct or pointer to structs fields // Recursive applies to struct or pointer to structs fields
if isStruct(t) || isStructPtr(t) { if isStruct(t) || isStructPtr(t) {
// Step 3: do the recursive validation // Step 3: do the recursive validation
// Only valid the Public field recursively // Only valid the Public field recursively
if objV.Field(i).CanInterface() { if objV.Field(i).CanInterface() {
pass, err = v.RecursiveValid(objV.Field(i).Interface()) pass, err = v.RecursiveValid(objV.Field(i).Interface())
}
} }
} }
return pass, err
} }
return pass, err
} }

6
validation/validation_test.go
View File

@ -302,7 +302,7 @@ func TestZipCode(t *testing.T) {
func TestValid(t *testing.T) { func TestValid(t *testing.T) {
type user struct { type user struct {
Id int ID int
Name string `valid:"Required;Match(/^(test)?\\w*@(/test/);com$/)"` Name string `valid:"Required;Match(/^(test)?\\w*@(/test/);com$/)"`
Age int `valid:"Required;Range(1, 140)"` Age int `valid:"Required;Range(1, 140)"`
} }
@ -352,13 +352,13 @@ func TestValid(t *testing.T) {
func TestRecursiveValid(t *testing.T) { func TestRecursiveValid(t *testing.T) {
type User struct { type User struct {
Id int ID int
Name string `valid:"Required;Match(/^(test)?\\w*@(/test/);com$/)"` Name string `valid:"Required;Match(/^(test)?\\w*@(/test/);com$/)"`
Age int `valid:"Required;Range(1, 140)"` Age int `valid:"Required;Range(1, 140)"`
} }
type AnonymouseUser struct { type AnonymouseUser struct {
Id2 int ID2 int
Name2 string `valid:"Required;Match(/^(test)?\\w*@(/test/);com$/)"` Name2 string `valid:"Required;Match(/^(test)?\\w*@(/test/);com$/)"`
Age2 int `valid:"Required;Range(1, 140)"` Age2 int `valid:"Required;Range(1, 140)"`
} }

102
validation/validators.go
View File

@ -22,6 +22,7 @@ import (
"unicode/utf8" "unicode/utf8"
) )
// MessageTmpls store commond validate template
var MessageTmpls = map[string]string{ var MessageTmpls = map[string]string{
"Required": "Can not be empty", "Required": "Can not be empty",
"Min": "Minimum is %d", "Min": "Minimum is %d",
@ -45,6 +46,7 @@ var MessageTmpls = map[string]string{
"ZipCode": "Must be valid zipcode", "ZipCode": "Must be valid zipcode",
} }
// Validator interface
type Validator interface { type Validator interface {
IsSatisfied(interface{}) bool IsSatisfied(interface{}) bool
DefaultMessage() string DefaultMessage() string
@ -52,10 +54,12 @@ type Validator interface {
GetLimitValue() interface{} GetLimitValue() interface{}
} }
// Required struct
type Required struct { type Required struct {
Key string Key string
} }
// IsSatisfied judge whether obj has value
func (r Required) IsSatisfied(obj interface{}) bool { func (r Required) IsSatisfied(obj interface{}) bool {
if obj == nil { if obj == nil {
return false return false
@ -80,23 +84,28 @@ func (r Required) IsSatisfied(obj interface{}) bool {
return true return true
} }
// DefaultMessage return the default error message
func (r Required) DefaultMessage() string { func (r Required) DefaultMessage() string {
return fmt.Sprint(MessageTmpls["Required"]) return fmt.Sprint(MessageTmpls["Required"])
} }
// GetKey return the r.Key
func (r Required) GetKey() string { func (r Required) GetKey() string {
return r.Key return r.Key
} }
// GetLimitValue return nil now
func (r Required) GetLimitValue() interface{} { func (r Required) GetLimitValue() interface{} {
return nil return nil
} }
// Min check struct
type Min struct { type Min struct {
Min int Min int
Key string Key string
} }
// IsSatisfied judge whether obj is valid
func (m Min) IsSatisfied(obj interface{}) bool { func (m Min) IsSatisfied(obj interface{}) bool {
num, ok := obj.(int) num, ok := obj.(int)
if ok { if ok {
@ -105,23 +114,28 @@ func (m Min) IsSatisfied(obj interface{}) bool {
return false return false
} }
// DefaultMessage return the default min error message
func (m Min) DefaultMessage() string { func (m Min) DefaultMessage() string {
return fmt.Sprintf(MessageTmpls["Min"], m.Min) return fmt.Sprintf(MessageTmpls["Min"], m.Min)
} }
// GetKey return the m.Key
func (m Min) GetKey() string { func (m Min) GetKey() string {
return m.Key return m.Key
} }
// GetLimitValue return the limit value, Min
func (m Min) GetLimitValue() interface{} { func (m Min) GetLimitValue() interface{} {
return m.Min return m.Min
} }
// Max validate struct
type Max struct { type Max struct {
Max int Max int
Key string Key string
} }
// IsSatisfied judge whether obj is valid
func (m Max) IsSatisfied(obj interface{}) bool { func (m Max) IsSatisfied(obj interface{}) bool {
num, ok := obj.(int) num, ok := obj.(int)
if ok { if ok {
@ -130,47 +144,55 @@ func (m Max) IsSatisfied(obj interface{}) bool {
return false return false
} }
// DefaultMessage return the default max error message
func (m Max) DefaultMessage() string { func (m Max) DefaultMessage() string {
return fmt.Sprintf(MessageTmpls["Max"], m.Max) return fmt.Sprintf(MessageTmpls["Max"], m.Max)
} }
// GetKey return the m.Key
func (m Max) GetKey() string { func (m Max) GetKey() string {
return m.Key return m.Key
} }
// GetLimitValue return the limit value, Max
func (m Max) GetLimitValue() interface{} { func (m Max) GetLimitValue() interface{} {
return m.Max return m.Max
} }
// Requires an integer to be within Min, Max inclusive. // Range Requires an integer to be within Min, Max inclusive.
type Range struct { type Range struct {
Min Min
Max Max
Key string Key string
} }
// IsSatisfied judge whether obj is valid
func (r Range) IsSatisfied(obj interface{}) bool { func (r Range) IsSatisfied(obj interface{}) bool {
return r.Min.IsSatisfied(obj) && r.Max.IsSatisfied(obj) return r.Min.IsSatisfied(obj) && r.Max.IsSatisfied(obj)
} }
// DefaultMessage return the default Range error message
func (r Range) DefaultMessage() string { func (r Range) DefaultMessage() string {
return fmt.Sprintf(MessageTmpls["Range"], r.Min.Min, r.Max.Max) return fmt.Sprintf(MessageTmpls["Range"], r.Min.Min, r.Max.Max)
} }
// GetKey return the m.Key
func (r Range) GetKey() string { func (r Range) GetKey() string {
return r.Key return r.Key
} }
// GetLimitValue return the limit value, Max
func (r Range) GetLimitValue() interface{} { func (r Range) GetLimitValue() interface{} {
return []int{r.Min.Min, r.Max.Max} return []int{r.Min.Min, r.Max.Max}
} }
// Requires an array or string to be at least a given length. // MinSize Requires an array or string to be at least a given length.
type MinSize struct { type MinSize struct {
Min int Min int
Key string Key string
} }
// IsSatisfied judge whether obj is valid
func (m MinSize) IsSatisfied(obj interface{}) bool { func (m MinSize) IsSatisfied(obj interface{}) bool {
if str, ok := obj.(string); ok { if str, ok := obj.(string); ok {
return utf8.RuneCountInString(str) >= m.Min return utf8.RuneCountInString(str) >= m.Min
@ -182,24 +204,28 @@ func (m MinSize) IsSatisfied(obj interface{}) bool {
return false return false
} }
// DefaultMessage return the default MinSize error message
func (m MinSize) DefaultMessage() string { func (m MinSize) DefaultMessage() string {
return fmt.Sprintf(MessageTmpls["MinSize"], m.Min) return fmt.Sprintf(MessageTmpls["MinSize"], m.Min)
} }
// GetKey return the m.Key
func (m MinSize) GetKey() string { func (m MinSize) GetKey() string {
return m.Key return m.Key
} }
// GetLimitValue return the limit value
func (m MinSize) GetLimitValue() interface{} { func (m MinSize) GetLimitValue() interface{} {
return m.Min return m.Min
} }
// Requires an array or string to be at most a given length. // MaxSize Requires an array or string to be at most a given length.
type MaxSize struct { type MaxSize struct {
Max int Max int
Key string Key string
} }
// IsSatisfied judge whether obj is valid
func (m MaxSize) IsSatisfied(obj interface{}) bool { func (m MaxSize) IsSatisfied(obj interface{}) bool {
if str, ok := obj.(string); ok { if str, ok := obj.(string); ok {
return utf8.RuneCountInString(str) <= m.Max return utf8.RuneCountInString(str) <= m.Max
@ -211,24 +237,28 @@ func (m MaxSize) IsSatisfied(obj interface{}) bool {
return false return false
} }
// DefaultMessage return the default MaxSize error message
func (m MaxSize) DefaultMessage() string { func (m MaxSize) DefaultMessage() string {
return fmt.Sprintf(MessageTmpls["MaxSize"], m.Max) return fmt.Sprintf(MessageTmpls["MaxSize"], m.Max)
} }
// GetKey return the m.Key
func (m MaxSize) GetKey() string { func (m MaxSize) GetKey() string {
return m.Key return m.Key
} }
// GetLimitValue return the limit value
func (m MaxSize) GetLimitValue() interface{} { func (m MaxSize) GetLimitValue() interface{} {
return m.Max return m.Max
} }
// Requires an array or string to be exactly a given length. // Length Requires an array or string to be exactly a given length.
type Length struct { type Length struct {
N int N int
Key string Key string
} }
// IsSatisfied judge whether obj is valid
func (l Length) IsSatisfied(obj interface{}) bool { func (l Length) IsSatisfied(obj interface{}) bool {
if str, ok := obj.(string); ok { if str, ok := obj.(string); ok {
return utf8.RuneCountInString(str) == l.N return utf8.RuneCountInString(str) == l.N
@ -240,22 +270,27 @@ func (l Length) IsSatisfied(obj interface{}) bool {
return false return false
} }
// DefaultMessage return the default Length error message
func (l Length) DefaultMessage() string { func (l Length) DefaultMessage() string {
return fmt.Sprintf(MessageTmpls["Length"], l.N) return fmt.Sprintf(MessageTmpls["Length"], l.N)
} }
// GetKey return the m.Key
func (l Length) GetKey() string { func (l Length) GetKey() string {
return l.Key return l.Key
} }
// GetLimitValue return the limit value
func (l Length) GetLimitValue() interface{} { func (l Length) GetLimitValue() interface{} {
return l.N return l.N
} }
// Alpha check the alpha
type Alpha struct { type Alpha struct {
Key string Key string
} }
// IsSatisfied judge whether obj is valid
func (a Alpha) IsSatisfied(obj interface{}) bool { func (a Alpha) IsSatisfied(obj interface{}) bool {
if str, ok := obj.(string); ok { if str, ok := obj.(string); ok {
for _, v := range str { for _, v := range str {
@ -268,22 +303,27 @@ func (a Alpha) IsSatisfied(obj interface{}) bool {
return false return false
} }
// DefaultMessage return the default Length error message
func (a Alpha) DefaultMessage() string { func (a Alpha) DefaultMessage() string {
return fmt.Sprint(MessageTmpls["Alpha"]) return fmt.Sprint(MessageTmpls["Alpha"])
} }
// GetKey return the m.Key
func (a Alpha) GetKey() string { func (a Alpha) GetKey() string {
return a.Key return a.Key
} }
// GetLimitValue return the limit value
func (a Alpha) GetLimitValue() interface{} { func (a Alpha) GetLimitValue() interface{} {
return nil return nil
} }
// Numeric check number
type Numeric struct { type Numeric struct {
Key string Key string
} }
// IsSatisfied judge whether obj is valid
func (n Numeric) IsSatisfied(obj interface{}) bool { func (n Numeric) IsSatisfied(obj interface{}) bool {
if str, ok := obj.(string); ok { if str, ok := obj.(string); ok {
for _, v := range str { for _, v := range str {
@ -296,22 +336,27 @@ func (n Numeric) IsSatisfied(obj interface{}) bool {
return false return false
} }
// DefaultMessage return the default Length error message
func (n Numeric) DefaultMessage() string { func (n Numeric) DefaultMessage() string {
return fmt.Sprint(MessageTmpls["Numeric"]) return fmt.Sprint(MessageTmpls["Numeric"])
} }
// GetKey return the n.Key
func (n Numeric) GetKey() string { func (n Numeric) GetKey() string {
return n.Key return n.Key
} }
// GetLimitValue return the limit value
func (n Numeric) GetLimitValue() interface{} { func (n Numeric) GetLimitValue() interface{} {
return nil return nil
} }
// AlphaNumeric check alpha and number
type AlphaNumeric struct { type AlphaNumeric struct {
Key string Key string
} }
// IsSatisfied judge whether obj is valid
func (a AlphaNumeric) IsSatisfied(obj interface{}) bool { func (a AlphaNumeric) IsSatisfied(obj interface{}) bool {
if str, ok := obj.(string); ok { if str, ok := obj.(string); ok {
for _, v := range str { for _, v := range str {
@ -324,134 +369,161 @@ func (a AlphaNumeric) IsSatisfied(obj interface{}) bool {
return false return false
} }
// DefaultMessage return the default Length error message
func (a AlphaNumeric) DefaultMessage() string { func (a AlphaNumeric) DefaultMessage() string {
return fmt.Sprint(MessageTmpls["AlphaNumeric"]) return fmt.Sprint(MessageTmpls["AlphaNumeric"])
} }
// GetKey return the a.Key
func (a AlphaNumeric) GetKey() string { func (a AlphaNumeric) GetKey() string {
return a.Key return a.Key
} }
// GetLimitValue return the limit value
func (a AlphaNumeric) GetLimitValue() interface{} { func (a AlphaNumeric) GetLimitValue() interface{} {
return nil return nil
} }
// Requires a string to match a given regex. // Match Requires a string to match a given regex.
type Match struct { type Match struct {
Regexp *regexp.Regexp Regexp *regexp.Regexp
Key string Key string
} }
// IsSatisfied judge whether obj is valid
func (m Match) IsSatisfied(obj interface{}) bool { func (m Match) IsSatisfied(obj interface{}) bool {
return m.Regexp.MatchString(fmt.Sprintf("%v", obj)) return m.Regexp.MatchString(fmt.Sprintf("%v", obj))
} }
// DefaultMessage return the default Match error message
func (m Match) DefaultMessage() string { func (m Match) DefaultMessage() string {
return fmt.Sprintf(MessageTmpls["Match"], m.Regexp.String()) return fmt.Sprintf(MessageTmpls["Match"], m.Regexp.String())
} }
// GetKey return the m.Key
func (m Match) GetKey() string { func (m Match) GetKey() string {
return m.Key return m.Key
} }
// GetLimitValue return the limit value
func (m Match) GetLimitValue() interface{} { func (m Match) GetLimitValue() interface{} {
return m.Regexp.String() return m.Regexp.String()
} }
// Requires a string to not match a given regex. // NoMatch Requires a string to not match a given regex.
type NoMatch struct { type NoMatch struct {
Match Match
Key string Key string
} }
// IsSatisfied judge whether obj is valid
func (n NoMatch) IsSatisfied(obj interface{}) bool { func (n NoMatch) IsSatisfied(obj interface{}) bool {
return !n.Match.IsSatisfied(obj) return !n.Match.IsSatisfied(obj)
} }
// DefaultMessage return the default NoMatch error message
func (n NoMatch) DefaultMessage() string { func (n NoMatch) DefaultMessage() string {
return fmt.Sprintf(MessageTmpls["NoMatch"], n.Regexp.String()) return fmt.Sprintf(MessageTmpls["NoMatch"], n.Regexp.String())
} }
// GetKey return the n.Key
func (n NoMatch) GetKey() string { func (n NoMatch) GetKey() string {
return n.Key return n.Key
} }
// GetLimitValue return the limit value
func (n NoMatch) GetLimitValue() interface{} { func (n NoMatch) GetLimitValue() interface{} {
return n.Regexp.String() return n.Regexp.String()
} }
var alphaDashPattern = regexp.MustCompile("[^\\d\\w-_]") var alphaDashPattern = regexp.MustCompile("[^\\d\\w-_]")
// AlphaDash check not Alpha
type AlphaDash struct { type AlphaDash struct {
NoMatch NoMatch
Key string Key string
} }
// DefaultMessage return the default AlphaDash error message
func (a AlphaDash) DefaultMessage() string { func (a AlphaDash) DefaultMessage() string {
return fmt.Sprint(MessageTmpls["AlphaDash"]) return fmt.Sprint(MessageTmpls["AlphaDash"])
} }
// GetKey return the n.Key
func (a AlphaDash) GetKey() string { func (a AlphaDash) GetKey() string {
return a.Key return a.Key
} }
// GetLimitValue return the limit value
func (a AlphaDash) GetLimitValue() interface{} { func (a AlphaDash) GetLimitValue() interface{} {
return nil return nil
} }
var emailPattern = regexp.MustCompile("[\\w!#$%&'*+/=?^_`{|}~-]+(?:\\.[\\w!#$%&'*+/=?^_`{|}~-]+)*@(?:[\\w](?:[\\w-]*[\\w])?\\.)+[a-zA-Z0-9](?:[\\w-]*[\\w])?") var emailPattern = regexp.MustCompile("[\\w!#$%&'*+/=?^_`{|}~-]+(?:\\.[\\w!#$%&'*+/=?^_`{|}~-]+)*@(?:[\\w](?:[\\w-]*[\\w])?\\.)+[a-zA-Z0-9](?:[\\w-]*[\\w])?")
// Email check struct
type Email struct { type Email struct {
Match Match
Key string Key string
} }
// DefaultMessage return the default Email error message
func (e Email) DefaultMessage() string { func (e Email) DefaultMessage() string {
return fmt.Sprint(MessageTmpls["Email"]) return fmt.Sprint(MessageTmpls["Email"])
} }
// GetKey return the n.Key
func (e Email) GetKey() string { func (e Email) GetKey() string {
return e.Key return e.Key
} }
// GetLimitValue return the limit value
func (e Email) GetLimitValue() interface{} { func (e Email) GetLimitValue() interface{} {
return nil return nil
} }
var ipPattern = regexp.MustCompile("^((2[0-4]\\d|25[0-5]|[01]?\\d\\d?)\\.){3}(2[0-4]\\d|25[0-5]|[01]?\\d\\d?)$") var ipPattern = regexp.MustCompile("^((2[0-4]\\d|25[0-5]|[01]?\\d\\d?)\\.){3}(2[0-4]\\d|25[0-5]|[01]?\\d\\d?)$")
// IP check struct
type IP struct { type IP struct {
Match Match
Key string Key string
} }
// DefaultMessage return the default IP error message
func (i IP) DefaultMessage() string { func (i IP) DefaultMessage() string {
return fmt.Sprint(MessageTmpls["IP"]) return fmt.Sprint(MessageTmpls["IP"])
} }
// GetKey return the i.Key
func (i IP) GetKey() string { func (i IP) GetKey() string {
return i.Key return i.Key
} }
// GetLimitValue return the limit value
func (i IP) GetLimitValue() interface{} { func (i IP) GetLimitValue() interface{} {
return nil return nil
} }
var base64Pattern = regexp.MustCompile("^(?:[A-Za-z0-99+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$") var base64Pattern = regexp.MustCompile("^(?:[A-Za-z0-99+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$")
// Base64 check struct
type Base64 struct { type Base64 struct {
Match Match
Key string Key string
} }
// DefaultMessage return the default Base64 error message
func (b Base64) DefaultMessage() string { func (b Base64) DefaultMessage() string {
return fmt.Sprint(MessageTmpls["Base64"]) return fmt.Sprint(MessageTmpls["Base64"])
} }
// GetKey return the b.Key
func (b Base64) GetKey() string { func (b Base64) GetKey() string {
return b.Key return b.Key
} }
// GetLimitValue return the limit value
func (b Base64) GetLimitValue() interface{} { func (b Base64) GetLimitValue() interface{} {
return nil return nil
} }
@ -459,19 +531,23 @@ func (b Base64) GetLimitValue() interface{} {
// just for chinese mobile phone number // just for chinese mobile phone number
var mobilePattern = regexp.MustCompile("^((\\+86)|(86))?(1(([35][0-9])|[8][0-9]|[7][067]|[4][579]))\\d{8}$") var mobilePattern = regexp.MustCompile("^((\\+86)|(86))?(1(([35][0-9])|[8][0-9]|[7][067]|[4][579]))\\d{8}$")
// Mobile check struct
type Mobile struct { type Mobile struct {
Match Match
Key string Key string
} }
// DefaultMessage return the default Mobile error message
func (m Mobile) DefaultMessage() string { func (m Mobile) DefaultMessage() string {
return fmt.Sprint(MessageTmpls["Mobile"]) return fmt.Sprint(MessageTmpls["Mobile"])
} }
// GetKey return the m.Key
func (m Mobile) GetKey() string { func (m Mobile) GetKey() string {
return m.Key return m.Key
} }
// GetLimitValue return the limit value
func (m Mobile) GetLimitValue() interface{} { func (m Mobile) GetLimitValue() interface{} {
return nil return nil
} }
@ -479,42 +555,50 @@ func (m Mobile) GetLimitValue() interface{} {
// just for chinese telephone number // just for chinese telephone number
var telPattern = regexp.MustCompile("^(0\\d{2,3}(\\-)?)?\\d{7,8}$") var telPattern = regexp.MustCompile("^(0\\d{2,3}(\\-)?)?\\d{7,8}$")
// Tel check telephone struct
type Tel struct { type Tel struct {
Match Match
Key string Key string
} }
// DefaultMessage return the default Tel error message
func (t Tel) DefaultMessage() string { func (t Tel) DefaultMessage() string {
return fmt.Sprint(MessageTmpls["Tel"]) return fmt.Sprint(MessageTmpls["Tel"])
} }
// GetKey return the t.Key
func (t Tel) GetKey() string { func (t Tel) GetKey() string {
return t.Key return t.Key
} }
// GetLimitValue return the limit value
func (t Tel) GetLimitValue() interface{} { func (t Tel) GetLimitValue() interface{} {
return nil return nil
} }
// just for chinese telephone or mobile phone number // Phone just for chinese telephone or mobile phone number
type Phone struct { type Phone struct {
Mobile Mobile
Tel Tel
Key string Key string
} }
// IsSatisfied judge whether obj is valid
func (p Phone) IsSatisfied(obj interface{}) bool { func (p Phone) IsSatisfied(obj interface{}) bool {
return p.Mobile.IsSatisfied(obj) || p.Tel.IsSatisfied(obj) return p.Mobile.IsSatisfied(obj) || p.Tel.IsSatisfied(obj)
} }
// DefaultMessage return the default Phone error message
func (p Phone) DefaultMessage() string { func (p Phone) DefaultMessage() string {
return fmt.Sprint(MessageTmpls["Phone"]) return fmt.Sprint(MessageTmpls["Phone"])
} }
// GetKey return the p.Key
func (p Phone) GetKey() string { func (p Phone) GetKey() string {
return p.Key return p.Key
} }
// GetLimitValue return the limit value
func (p Phone) GetLimitValue() interface{} { func (p Phone) GetLimitValue() interface{} {
return nil return nil
} }
@ -522,19 +606,23 @@ func (p Phone) GetLimitValue() interface{} {
// just for chinese zipcode // just for chinese zipcode
var zipCodePattern = regexp.MustCompile("^[1-9]\\d{5}$") var zipCodePattern = regexp.MustCompile("^[1-9]\\d{5}$")
// ZipCode check the zip struct
type ZipCode struct { type ZipCode struct {
Match Match
Key string Key string
} }
// DefaultMessage return the default Zip error message
func (z ZipCode) DefaultMessage() string { func (z ZipCode) DefaultMessage() string {
return fmt.Sprint(MessageTmpls["ZipCode"]) return fmt.Sprint(MessageTmpls["ZipCode"])
} }
// GetKey return the z.Key
func (z ZipCode) GetKey() string { func (z ZipCode) GetKey() string {
return z.Key return z.Key
} }
// GetLimitValue return the limit value
func (z ZipCode) GetLimitValue() interface{} { func (z ZipCode) GetLimitValue() interface{} {
return nil return nil
} }