--- /dev/null
+// Copyright (c) 2012-2016 The Revel Framework Authors, All rights reserved.
+// Revel Framework source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package revel
+
+import (
+ "fmt"
+ "net/http"
+ "net/url"
+ "regexp"
+ "runtime"
+)
+
+// ValidationError simple struct to store the Message & Key of a validation error
+type ValidationError struct {
+ Message, Key string
+}
+
+// String returns the Message field of the ValidationError struct.
+func (e *ValidationError) String() string {
+ if e == nil {
+ return ""
+ }
+ return e.Message
+}
+
+// Validation context manages data validation and error messages.
+type Validation struct {
+ Errors []*ValidationError
+ Request *Request
+ Translator func(locale, message string, args ...interface{}) string
+ keep bool
+}
+
+// Keep tells revel to set a flash cookie on the client to make the validation
+// errors available for the next request.
+// This is helpful when redirecting the client after the validation failed.
+// It is good practice to always redirect upon a HTTP POST request. Thus
+// one should use this method when HTTP POST validation failed and redirect
+// the user back to the form.
+func (v *Validation) Keep() {
+ v.keep = true
+}
+
+// Clear *all* ValidationErrors
+func (v *Validation) Clear() {
+ v.Errors = []*ValidationError{}
+}
+
+// HasErrors returns true if there are any (ie > 0) errors. False otherwise.
+func (v *Validation) HasErrors() bool {
+ return len(v.Errors) > 0
+}
+
+// ErrorMap returns the errors mapped by key.
+// If there are multiple validation errors associated with a single key, the
+// first one "wins". (Typically the first validation will be the more basic).
+func (v *Validation) ErrorMap() map[string]*ValidationError {
+ m := map[string]*ValidationError{}
+ for _, e := range v.Errors {
+ if _, ok := m[e.Key]; !ok {
+ m[e.Key] = e
+ }
+ }
+ return m
+}
+
+// Error adds an error to the validation context.
+func (v *Validation) Error(message string, args ...interface{}) *ValidationResult {
+ result := v.ValidationResult(false).Message(message, args...)
+ v.Errors = append(v.Errors, result.Error)
+ return result
+}
+
+// Error adds an error to the validation context.
+func (v *Validation) ErrorKey(message string, args ...interface{}) *ValidationResult {
+ result := v.ValidationResult(false).MessageKey(message, args...)
+ v.Errors = append(v.Errors, result.Error)
+ return result
+}
+
+// Error adds an error to the validation context.
+func (v *Validation) ValidationResult(ok bool) *ValidationResult {
+ if ok {
+ return &ValidationResult{Ok: ok}
+ } else {
+ return &ValidationResult{Ok: ok, Error: &ValidationError{}, Locale: v.Request.Locale, Translator: v.Translator}
+ }
+}
+
+// ValidationResult is returned from every validation method.
+// It provides an indication of success, and a pointer to the Error (if any).
+type ValidationResult struct {
+ Error *ValidationError
+ Ok bool
+ Locale string
+ Translator func(locale, message string, args ...interface{}) string
+}
+
+// Key sets the ValidationResult's Error "key" and returns itself for chaining
+func (r *ValidationResult) Key(key string) *ValidationResult {
+ if r.Error != nil {
+ r.Error.Key = key
+ }
+ return r
+}
+
+// Message sets the error message for a ValidationResult. Returns itself to
+// allow chaining. Allows Sprintf() type calling with multiple parameters
+func (r *ValidationResult) Message(message string, args ...interface{}) *ValidationResult {
+ if r.Error != nil {
+ if len(args) == 0 {
+ r.Error.Message = message
+ } else {
+ r.Error.Message = fmt.Sprintf(message, args...)
+ }
+ }
+ return r
+}
+
+// Allow a message key to be passed into the validation result. The Validation has already
+// setup the translator to translate the message key
+func (r *ValidationResult) MessageKey(message string, args ...interface{}) *ValidationResult {
+ if r.Error == nil {
+ return r
+ }
+
+ // If translator found, use that to create the message, otherwise call Message method
+ if r.Translator != nil {
+ r.Error.Message = r.Translator(r.Locale, message, args...)
+ } else {
+ r.Message(message, args...)
+ }
+
+ return r
+}
+
+// Required tests that the argument is non-nil and non-empty (if string or list)
+func (v *Validation) Required(obj interface{}) *ValidationResult {
+ return v.apply(Required{}, obj)
+}
+
+func (v *Validation) Min(n int, min int) *ValidationResult {
+ return v.MinFloat(float64(n), float64(min))
+}
+
+func (v *Validation) MinFloat(n float64, min float64) *ValidationResult {
+ return v.apply(Min{min}, n)
+}
+
+func (v *Validation) Max(n int, max int) *ValidationResult {
+ return v.MaxFloat(float64(n), float64(max))
+}
+
+func (v *Validation) MaxFloat(n float64, max float64) *ValidationResult {
+ return v.apply(Max{max}, n)
+}
+
+func (v *Validation) Range(n, min, max int) *ValidationResult {
+ return v.RangeFloat(float64(n), float64(min), float64(max))
+}
+
+func (v *Validation) RangeFloat(n, min, max float64) *ValidationResult {
+ return v.apply(Range{Min{min}, Max{max}}, n)
+}
+
+func (v *Validation) MinSize(obj interface{}, min int) *ValidationResult {
+ return v.apply(MinSize{min}, obj)
+}
+
+func (v *Validation) MaxSize(obj interface{}, max int) *ValidationResult {
+ return v.apply(MaxSize{max}, obj)
+}
+
+func (v *Validation) Length(obj interface{}, n int) *ValidationResult {
+ return v.apply(Length{n}, obj)
+}
+
+func (v *Validation) Match(str string, regex *regexp.Regexp) *ValidationResult {
+ return v.apply(Match{regex}, str)
+}
+
+func (v *Validation) Email(str string) *ValidationResult {
+ return v.apply(Email{Match{emailPattern}}, str)
+}
+
+func (v *Validation) IPAddr(str string, cktype ...int) *ValidationResult {
+ return v.apply(IPAddr{cktype}, str)
+}
+
+func (v *Validation) MacAddr(str string) *ValidationResult {
+ return v.apply(IPAddr{}, str)
+}
+
+func (v *Validation) Domain(str string) *ValidationResult {
+ return v.apply(Domain{}, str)
+}
+
+func (v *Validation) URL(str string) *ValidationResult {
+ return v.apply(URL{}, str)
+}
+
+func (v *Validation) PureText(str string, m int) *ValidationResult {
+ return v.apply(PureText{m}, str)
+}
+
+func (v *Validation) FilePath(str string, m int) *ValidationResult {
+ return v.apply(FilePath{m}, str)
+}
+
+func (v *Validation) apply(chk Validator, obj interface{}) *ValidationResult {
+ if chk.IsSatisfied(obj) {
+ return v.ValidationResult(true)
+ }
+
+ // Get the default key.
+ var key string
+ if pc, _, line, ok := runtime.Caller(2); ok {
+ f := runtime.FuncForPC(pc)
+ if defaultKeys, ok := DefaultValidationKeys[f.Name()]; ok {
+ key = defaultKeys[line]
+ }
+ } else {
+ utilLog.Error("Validation: Failed to get Caller information to look up Validation key")
+ }
+
+ // Add the error to the validation context.
+ err := &ValidationError{
+ Message: chk.DefaultMessage(),
+ Key: key,
+ }
+ v.Errors = append(v.Errors, err)
+
+ // Also return it in the result.
+ vr := v.ValidationResult(false)
+ vr.Error = err
+ return vr
+}
+
+// Check applies a group of validators to a field, in order, and return the
+// ValidationResult from the first one that fails, or the last one that
+// succeeds.
+func (v *Validation) Check(obj interface{}, checks ...Validator) *ValidationResult {
+ var result *ValidationResult
+ for _, check := range checks {
+ result = v.apply(check, obj)
+ if !result.Ok {
+ return result
+ }
+ }
+ return result
+}
+
+// ValidationFilter revel Filter function to be hooked into the filter chain.
+func ValidationFilter(c *Controller, fc []Filter) {
+ // If json request, we shall assume json response is intended,
+ // as such no validation cookies should be tied response
+ if c.Params != nil && c.Params.JSON != nil {
+ c.Validation = &Validation{Request: c.Request, Translator: MessageFunc}
+ fc[0](c, fc[1:])
+ } else {
+ errors, err := restoreValidationErrors(c.Request)
+ c.Validation = &Validation{
+ Errors: errors,
+ keep: false,
+ Request: c.Request,
+ Translator: MessageFunc,
+ }
+ hasCookie := (err != http.ErrNoCookie)
+
+ fc[0](c, fc[1:])
+
+ // Add Validation errors to ViewArgs.
+ c.ViewArgs["errors"] = c.Validation.ErrorMap()
+
+ // Store the Validation errors
+ var errorsValue string
+ if c.Validation.keep {
+ for _, err := range c.Validation.Errors {
+ if err.Message != "" {
+ errorsValue += "\x00" + err.Key + ":" + err.Message + "\x00"
+ }
+ }
+ }
+
+ // When there are errors from Validation and Keep() has been called, store the
+ // values in a cookie. If there previously was a cookie but no errors, remove
+ // the cookie.
+ if errorsValue != "" {
+ c.SetCookie(&http.Cookie{
+ Name: CookiePrefix + "_ERRORS",
+ Value: url.QueryEscape(errorsValue),
+ Domain: CookieDomain,
+ Path: "/",
+ HttpOnly: true,
+ Secure: CookieSecure,
+ })
+ } else if hasCookie {
+ c.SetCookie(&http.Cookie{
+ Name: CookiePrefix + "_ERRORS",
+ MaxAge: -1,
+ Domain: CookieDomain,
+ Path: "/",
+ HttpOnly: true,
+ Secure: CookieSecure,
+ })
+ }
+ }
+}
+
+// Restore Validation.Errors from a request.
+func restoreValidationErrors(req *Request) ([]*ValidationError, error) {
+ var (
+ err error
+ cookie ServerCookie
+ errors = make([]*ValidationError, 0, 5)
+ )
+ if cookie, err = req.Cookie(CookiePrefix + "_ERRORS"); err == nil {
+ ParseKeyValueCookie(cookie.GetValue(), func(key, val string) {
+ errors = append(errors, &ValidationError{
+ Key: key,
+ Message: val,
+ })
+ })
+ }
+ return errors, err
+}
+
+// DefaultValidationKeys register default validation keys for all calls to Controller.Validation.Func().
+// Map from (package).func => (line => name of first arg to Validation func)
+// E.g. "myapp/controllers.helper" or "myapp/controllers.(*Application).Action"
+// This is set on initialization in the generated main.go file.
+var DefaultValidationKeys map[string]map[int]string
Code Review / iec.git / blobdiff