vendor/gopkg.in/go-playground/validator.v8/examples/simple/simple.go

   1 package main
   2
   3 import (
   4         "errors"
   5         "fmt"
   6         "reflect"
   7
   8         sql "database/sql/driver"
   9
  10         "gopkg.in/go-playground/validator.v8"
  11 )
  12
  13 // User contains user information
  14 type User struct {
  15         FirstName      string     `validate:"required"`
  16         LastName       string     `validate:"required"`
  17         Age            uint8      `validate:"gte=0,lte=130"`
  18         Email          string     `validate:"required,email"`
  19         FavouriteColor string     `validate:"hexcolor|rgb|rgba"`
  20         Addresses      []*Address `validate:"required,dive,required"` // a person can have a home and cottage...
  21 }
  22
  23 // Address houses a users address information
  24 type Address struct {
  25         Street string `validate:"required"`
  26         City   string `validate:"required"`
  27         Planet string `validate:"required"`
  28         Phone  string `validate:"required"`
  29 }
  30
  31 var validate *validator.Validate
  32
  33 func main() {
  34
  35         config := &validator.Config{TagName: "validate"}
  36
  37         validate = validator.New(config)
  38
  39         validateStruct()
  40         validateField()
  41 }
  42
  43 func validateStruct() {
  44
  45         address := &Address{
  46                 Street: "Eavesdown Docks",
  47                 Planet: "Persphone",
  48                 Phone:  "none",
  49         }
  50
  51         user := &User{
  52                 FirstName:      "Badger",
  53                 LastName:       "Smith",
  54                 Age:            135,
  55                 Email:          "Badger.Smith@gmail.com",
  56                 FavouriteColor: "#000",
  57                 Addresses:      []*Address{address},
  58         }
  59
  60         // returns nil or ValidationErrors ( map[string]*FieldError )
  61         errs := validate.Struct(user)
  62
  63         if errs != nil {
  64
  65                 fmt.Println(errs) // output: Key: "User.Age" Error:Field validation for "Age" failed on the "lte" tag
  66                 //                               Key: "User.Addresses[0].City" Error:Field validation for "City" failed on the "required" tag
  67                 err := errs.(validator.ValidationErrors)["User.Addresses[0].City"]
  68                 fmt.Println(err.Field) // output: City
  69                 fmt.Println(err.Tag)   // output: required
  70                 fmt.Println(err.Kind)  // output: string
  71                 fmt.Println(err.Type)  // output: string
  72                 fmt.Println(err.Param) // output:
  73                 fmt.Println(err.Value) // output:
  74
  75                 // from here you can create your own error messages in whatever language you wish
  76                 return
  77         }
  78
  79         // save user to database
  80 }
  81
  82 func validateField() {
  83         myEmail := "joeybloggs.gmail.com"
  84
  85         errs := validate.Field(myEmail, "required,email")
  86
  87         if errs != nil {
  88                 fmt.Println(errs) // output: Key: "" Error:Field validation for "" failed on the "email" tag
  89                 return
  90         }
  91
  92         // email ok, move on
  93 }
  94
  95 var validate2 *validator.Validate
  96
  97 type valuer struct {
  98         Name string
  99 }
 100
 101 func (v valuer) Value() (sql.Value, error) {
 102
 103         if v.Name == "errorme" {
 104                 return nil, errors.New("some kind of error")
 105         }
 106
 107         if v.Name == "blankme" {
 108                 return "", nil
 109         }
 110
 111         if len(v.Name) == 0 {
 112                 return nil, nil
 113         }
 114
 115         return v.Name, nil
 116 }
 117
 118 // ValidateValuerType implements validator.CustomTypeFunc
 119 func ValidateValuerType(field reflect.Value) interface{} {
 120         if valuer, ok := field.Interface().(sql.Valuer); ok {
 121                 val, err := valuer.Value()
 122                 if err != nil {
 123                         // handle the error how you want
 124                         return nil
 125                 }
 126
 127                 return val
 128         }
 129
 130         return nil
 131 }
 132
 133 func main2() {
 134
 135         config := &validator.Config{TagName: "validate"}
 136
 137         validate2 = validator.New(config)
 138         validate2.RegisterCustomTypeFunc(ValidateValuerType, (*sql.Valuer)(nil), valuer{})
 139
 140         validateCustomFieldType()
 141 }
 142
 143 func validateCustomFieldType() {
 144         val := valuer{
 145                 Name: "blankme",
 146         }
 147
 148         errs := validate2.Field(val, "required")
 149         if errs != nil {
 150                 fmt.Println(errs) // output: Key: "" Error:Field validation for "" failed on the "required" tag
 151                 return
 152         }
 153
 154         // all ok
 155 }