remove pkg directory;

remove build directory;
remove githook directory;

adapter/validation/validators.go

@@ -0,0 +1,512 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package validation
+
+import (
+	"sync"
+
+	"github.com/astaxie/beego/core/validation"
+)
+
+// CanSkipFuncs will skip valid if RequiredFirst is true and the struct field's value is empty
+var CanSkipFuncs = validation.CanSkipFuncs
+
+// MessageTmpls store commond validate template
+var MessageTmpls = map[string]string{
+	"Required":     "Can not be empty",
+	"Min":          "Minimum is %d",
+	"Max":          "Maximum is %d",
+	"Range":        "Range is %d to %d",
+	"MinSize":      "Minimum size is %d",
+	"MaxSize":      "Maximum size is %d",
+	"Length":       "Required length is %d",
+	"Alpha":        "Must be valid alpha characters",
+	"Numeric":      "Must be valid numeric characters",
+	"AlphaNumeric": "Must be valid alpha or numeric characters",
+	"Match":        "Must match %s",
+	"NoMatch":      "Must not match %s",
+	"AlphaDash":    "Must be valid alpha or numeric or dash(-_) characters",
+	"Email":        "Must be a valid email address",
+	"IP":           "Must be a valid ip address",
+	"Base64":       "Must be valid base64 characters",
+	"Mobile":       "Must be valid mobile number",
+	"Tel":          "Must be valid telephone number",
+	"Phone":        "Must be valid telephone or mobile phone number",
+	"ZipCode":      "Must be valid zipcode",
+}
+
+var once sync.Once
+
+// SetDefaultMessage set default messages
+// if not set, the default messages are
+//  "Required":     "Can not be empty",
+//  "Min":          "Minimum is %d",
+//  "Max":          "Maximum is %d",
+//  "Range":        "Range is %d to %d",
+//  "MinSize":      "Minimum size is %d",
+//  "MaxSize":      "Maximum size is %d",
+//  "Length":       "Required length is %d",
+//  "Alpha":        "Must be valid alpha characters",
+//  "Numeric":      "Must be valid numeric characters",
+//  "AlphaNumeric": "Must be valid alpha or numeric characters",
+//  "Match":        "Must match %s",
+//  "NoMatch":      "Must not match %s",
+//  "AlphaDash":    "Must be valid alpha or numeric or dash(-_) characters",
+//  "Email":        "Must be a valid email address",
+//  "IP":           "Must be a valid ip address",
+//  "Base64":       "Must be valid base64 characters",
+//  "Mobile":       "Must be valid mobile number",
+//  "Tel":          "Must be valid telephone number",
+//  "Phone":        "Must be valid telephone or mobile phone number",
+//  "ZipCode":      "Must be valid zipcode",
+func SetDefaultMessage(msg map[string]string) {
+	validation.SetDefaultMessage(msg)
+}
+
+// Validator interface
+type Validator interface {
+	IsSatisfied(interface{}) bool
+	DefaultMessage() string
+	GetKey() string
+	GetLimitValue() interface{}
+}
+
+// Required struct
+type Required validation.Required
+
+// IsSatisfied judge whether obj has value
+func (r Required) IsSatisfied(obj interface{}) bool {
+	return validation.Required(r).IsSatisfied(obj)
+}
+
+// DefaultMessage return the default error message
+func (r Required) DefaultMessage() string {
+	return validation.Required(r).DefaultMessage()
+}
+
+// GetKey return the r.Key
+func (r Required) GetKey() string {
+	return validation.Required(r).GetKey()
+}
+
+// GetLimitValue return nil now
+func (r Required) GetLimitValue() interface{} {
+	return validation.Required(r).GetLimitValue()
+}
+
+// Min check struct
+type Min validation.Min
+
+// IsSatisfied judge whether obj is valid
+// not support int64 on 32-bit platform
+func (m Min) IsSatisfied(obj interface{}) bool {
+	return validation.Min(m).IsSatisfied(obj)
+}
+
+// DefaultMessage return the default min error message
+func (m Min) DefaultMessage() string {
+	return validation.Min(m).DefaultMessage()
+}
+
+// GetKey return the m.Key
+func (m Min) GetKey() string {
+	return validation.Min(m).GetKey()
+}
+
+// GetLimitValue return the limit value, Min
+func (m Min) GetLimitValue() interface{} {
+	return validation.Min(m).GetLimitValue()
+}
+
+// Max validate struct
+type Max validation.Max
+
+// IsSatisfied judge whether obj is valid
+// not support int64 on 32-bit platform
+func (m Max) IsSatisfied(obj interface{}) bool {
+	return validation.Max(m).IsSatisfied(obj)
+}
+
+// DefaultMessage return the default max error message
+func (m Max) DefaultMessage() string {
+	return validation.Max(m).DefaultMessage()
+}
+
+// GetKey return the m.Key
+func (m Max) GetKey() string {
+	return validation.Max(m).GetKey()
+}
+
+// GetLimitValue return the limit value, Max
+func (m Max) GetLimitValue() interface{} {
+	return validation.Max(m).GetLimitValue()
+}
+
+// Range Requires an integer to be within Min, Max inclusive.
+type Range validation.Range
+
+// IsSatisfied judge whether obj is valid
+// not support int64 on 32-bit platform
+func (r Range) IsSatisfied(obj interface{}) bool {
+	return validation.Range(r).IsSatisfied(obj)
+}
+
+// DefaultMessage return the default Range error message
+func (r Range) DefaultMessage() string {
+	return validation.Range(r).DefaultMessage()
+}
+
+// GetKey return the m.Key
+func (r Range) GetKey() string {
+	return validation.Range(r).GetKey()
+}
+
+// GetLimitValue return the limit value, Max
+func (r Range) GetLimitValue() interface{} {
+	return validation.Range(r).GetLimitValue()
+}
+
+// MinSize Requires an array or string to be at least a given length.
+type MinSize validation.MinSize
+
+// IsSatisfied judge whether obj is valid
+func (m MinSize) IsSatisfied(obj interface{}) bool {
+	return validation.MinSize(m).IsSatisfied(obj)
+}
+
+// DefaultMessage return the default MinSize error message
+func (m MinSize) DefaultMessage() string {
+	return validation.MinSize(m).DefaultMessage()
+}
+
+// GetKey return the m.Key
+func (m MinSize) GetKey() string {
+	return validation.MinSize(m).GetKey()
+}
+
+// GetLimitValue return the limit value
+func (m MinSize) GetLimitValue() interface{} {
+	return validation.MinSize(m).GetLimitValue()
+}
+
+// MaxSize Requires an array or string to be at most a given length.
+type MaxSize validation.MaxSize
+
+// IsSatisfied judge whether obj is valid
+func (m MaxSize) IsSatisfied(obj interface{}) bool {
+	return validation.MaxSize(m).IsSatisfied(obj)
+}
+
+// DefaultMessage return the default MaxSize error message
+func (m MaxSize) DefaultMessage() string {
+	return validation.MaxSize(m).DefaultMessage()
+}
+
+// GetKey return the m.Key
+func (m MaxSize) GetKey() string {
+	return validation.MaxSize(m).GetKey()
+}
+
+// GetLimitValue return the limit value
+func (m MaxSize) GetLimitValue() interface{} {
+	return validation.MaxSize(m).GetLimitValue()
+}
+
+// Length Requires an array or string to be exactly a given length.
+type Length validation.Length
+
+// IsSatisfied judge whether obj is valid
+func (l Length) IsSatisfied(obj interface{}) bool {
+	return validation.Length(l).IsSatisfied(obj)
+}
+
+// DefaultMessage return the default Length error message
+func (l Length) DefaultMessage() string {
+	return validation.Length(l).DefaultMessage()
+}
+
+// GetKey return the m.Key
+func (l Length) GetKey() string {
+	return validation.Length(l).GetKey()
+}
+
+// GetLimitValue return the limit value
+func (l Length) GetLimitValue() interface{} {
+	return validation.Length(l).GetLimitValue()
+}
+
+// Alpha check the alpha
+type Alpha validation.Alpha
+
+// IsSatisfied judge whether obj is valid
+func (a Alpha) IsSatisfied(obj interface{}) bool {
+	return validation.Alpha(a).IsSatisfied(obj)
+}
+
+// DefaultMessage return the default Length error message
+func (a Alpha) DefaultMessage() string {
+	return validation.Alpha(a).DefaultMessage()
+}
+
+// GetKey return the m.Key
+func (a Alpha) GetKey() string {
+	return validation.Alpha(a).GetKey()
+}
+
+// GetLimitValue return the limit value
+func (a Alpha) GetLimitValue() interface{} {
+	return validation.Alpha(a).GetLimitValue()
+}
+
+// Numeric check number
+type Numeric validation.Numeric
+
+// IsSatisfied judge whether obj is valid
+func (n Numeric) IsSatisfied(obj interface{}) bool {
+	return validation.Numeric(n).IsSatisfied(obj)
+}
+
+// DefaultMessage return the default Length error message
+func (n Numeric) DefaultMessage() string {
+	return validation.Numeric(n).DefaultMessage()
+}
+
+// GetKey return the n.Key
+func (n Numeric) GetKey() string {
+	return validation.Numeric(n).GetKey()
+}
+
+// GetLimitValue return the limit value
+func (n Numeric) GetLimitValue() interface{} {
+	return validation.Numeric(n).GetLimitValue()
+}
+
+// AlphaNumeric check alpha and number
+type AlphaNumeric validation.AlphaNumeric
+
+// IsSatisfied judge whether obj is valid
+func (a AlphaNumeric) IsSatisfied(obj interface{}) bool {
+	return validation.AlphaNumeric(a).IsSatisfied(obj)
+}
+
+// DefaultMessage return the default Length error message
+func (a AlphaNumeric) DefaultMessage() string {
+	return validation.AlphaNumeric(a).DefaultMessage()
+}
+
+// GetKey return the a.Key
+func (a AlphaNumeric) GetKey() string {
+	return validation.AlphaNumeric(a).GetKey()
+}
+
+// GetLimitValue return the limit value
+func (a AlphaNumeric) GetLimitValue() interface{} {
+	return validation.AlphaNumeric(a).GetLimitValue()
+}
+
+// Match Requires a string to match a given regex.
+type Match validation.Match
+
+// IsSatisfied judge whether obj is valid
+func (m Match) IsSatisfied(obj interface{}) bool {
+	return validation.Match(m).IsSatisfied(obj)
+}
+
+// DefaultMessage return the default Match error message
+func (m Match) DefaultMessage() string {
+	return validation.Match(m).DefaultMessage()
+}
+
+// GetKey return the m.Key
+func (m Match) GetKey() string {
+	return validation.Match(m).GetKey()
+}
+
+// GetLimitValue return the limit value
+func (m Match) GetLimitValue() interface{} {
+	return validation.Match(m).GetLimitValue()
+}
+
+// NoMatch Requires a string to not match a given regex.
+type NoMatch validation.NoMatch
+
+// IsSatisfied judge whether obj is valid
+func (n NoMatch) IsSatisfied(obj interface{}) bool {
+	return validation.NoMatch(n).IsSatisfied(obj)
+}
+
+// DefaultMessage return the default NoMatch error message
+func (n NoMatch) DefaultMessage() string {
+	return validation.NoMatch(n).DefaultMessage()
+}
+
+// GetKey return the n.Key
+func (n NoMatch) GetKey() string {
+	return validation.NoMatch(n).GetKey()
+}
+
+// GetLimitValue return the limit value
+func (n NoMatch) GetLimitValue() interface{} {
+	return validation.NoMatch(n).GetLimitValue()
+}
+
+// AlphaDash check not Alpha
+type AlphaDash validation.AlphaDash
+
+// DefaultMessage return the default AlphaDash error message
+func (a AlphaDash) DefaultMessage() string {
+	return validation.AlphaDash(a).DefaultMessage()
+}
+
+// GetKey return the n.Key
+func (a AlphaDash) GetKey() string {
+	return validation.AlphaDash(a).GetKey()
+}
+
+// GetLimitValue return the limit value
+func (a AlphaDash) GetLimitValue() interface{} {
+	return validation.AlphaDash(a).GetLimitValue()
+}
+
+// Email check struct
+type Email validation.Email
+
+// DefaultMessage return the default Email error message
+func (e Email) DefaultMessage() string {
+	return validation.Email(e).DefaultMessage()
+}
+
+// GetKey return the n.Key
+func (e Email) GetKey() string {
+	return validation.Email(e).GetKey()
+}
+
+// GetLimitValue return the limit value
+func (e Email) GetLimitValue() interface{} {
+	return validation.Email(e).GetLimitValue()
+}
+
+// IP check struct
+type IP validation.IP
+
+// DefaultMessage return the default IP error message
+func (i IP) DefaultMessage() string {
+	return validation.IP(i).DefaultMessage()
+}
+
+// GetKey return the i.Key
+func (i IP) GetKey() string {
+	return validation.IP(i).GetKey()
+}
+
+// GetLimitValue return the limit value
+func (i IP) GetLimitValue() interface{} {
+	return validation.IP(i).GetLimitValue()
+}
+
+// Base64 check struct
+type Base64 validation.Base64
+
+// DefaultMessage return the default Base64 error message
+func (b Base64) DefaultMessage() string {
+	return validation.Base64(b).DefaultMessage()
+}
+
+// GetKey return the b.Key
+func (b Base64) GetKey() string {
+	return validation.Base64(b).GetKey()
+}
+
+// GetLimitValue return the limit value
+func (b Base64) GetLimitValue() interface{} {
+	return validation.Base64(b).GetLimitValue()
+}
+
+// Mobile check struct
+type Mobile validation.Mobile
+
+// DefaultMessage return the default Mobile error message
+func (m Mobile) DefaultMessage() string {
+	return validation.Mobile(m).DefaultMessage()
+}
+
+// GetKey return the m.Key
+func (m Mobile) GetKey() string {
+	return validation.Mobile(m).GetKey()
+}
+
+// GetLimitValue return the limit value
+func (m Mobile) GetLimitValue() interface{} {
+	return validation.Mobile(m).GetLimitValue()
+}
+
+// Tel check telephone struct
+type Tel validation.Tel
+
+// DefaultMessage return the default Tel error message
+func (t Tel) DefaultMessage() string {
+	return validation.Tel(t).DefaultMessage()
+}
+
+// GetKey return the t.Key
+func (t Tel) GetKey() string {
+	return validation.Tel(t).GetKey()
+}
+
+// GetLimitValue return the limit value
+func (t Tel) GetLimitValue() interface{} {
+	return validation.Tel(t).GetLimitValue()
+}
+
+// Phone just for chinese telephone or mobile phone number
+type Phone validation.Phone
+
+// IsSatisfied judge whether obj is valid
+func (p Phone) IsSatisfied(obj interface{}) bool {
+	return validation.Phone(p).IsSatisfied(obj)
+}
+
+// DefaultMessage return the default Phone error message
+func (p Phone) DefaultMessage() string {
+	return validation.Phone(p).DefaultMessage()
+}
+
+// GetKey return the p.Key
+func (p Phone) GetKey() string {
+	return validation.Phone(p).GetKey()
+}
+
+// GetLimitValue return the limit value
+func (p Phone) GetLimitValue() interface{} {
+	return validation.Phone(p).GetLimitValue()
+}
+
+// ZipCode check the zip struct
+type ZipCode validation.ZipCode
+
+// DefaultMessage return the default Zip error message
+func (z ZipCode) DefaultMessage() string {
+	return validation.ZipCode(z).DefaultMessage()
+}
+
+// GetKey return the z.Key
+func (z ZipCode) GetKey() string {
+	return validation.ZipCode(z).GetKey()
+}
+
+// GetLimitValue return the limit value
+func (z ZipCode) GetLimitValue() interface{} {
+	return validation.ZipCode(z).GetLimitValue()
+}