效验类

type User struct {
	Name string `v:"required"`
	Type int    `v:"required"`
}
data := g.Map{
	"name": "john",
}
user := User{}

if err := 转换类.Scan(data, &user); err != nil {
	panic(err)
}

if err := g.X效验类().Data(user).Assoc(data).Run(context.Background()); err != nil {
	fmt.Print(err)
}

Output:

The Type field is required

package main

import (
	"context"
	"fmt"

	"github.com/888go/goframe/frame/g"
)

func main() {
	type BizReq struct {
		Account   string `v:"required|length:6,16|same:QQ"`
		QQ        string
		Password  string `v:"required|same:Password2"`
		Password2 string `v:"required"`
	}
	var (
		ctx = context.Background()
		req = BizReq{
			Account:   "gf",
			QQ:        "123456",
			Password:  "goframe.org",
			Password2: "goframe.org",
		}
	)

	if err := g.X效验类().Bail().Data(req).Run(ctx); err != nil {
		fmt.Println("Use Bail Error:", err)
	}

	if err := g.X效验类().Data(req).Run(ctx); err != nil {
		fmt.Println("Not Use Bail Error:", err)
	}

}

Output:

Use Bail Error: The Account value `gf` length must be between 6 and 16
Not Use Bail Error: The Account value `gf` length must be between 6 and 16; The Account value `gf` must be the same as field QQ value `123456`

package main

import (
	"context"
	"fmt"

	"github.com/888go/goframe/frame/g"
)

func main() {
	type BizReq struct {
		Account   string `v:"required"`
		Password  string `v:"required|same:Password2"`
		Password2 string `v:"required"`
	}
	var (
		ctx = context.Background()
		req = BizReq{
			Account:   "gf",
			Password:  "Goframe.org", // 与 Password2 不同，但由于“ci”的存在，规则检查通过
			Password2: "goframe.org",
		}
	)

	if err := g.X效验类().Data(req).Run(ctx); err != nil {
		fmt.Println("Not Use CI Error:", err)
	}

	if err := g.X效验类().Ci().Data(req).Run(ctx); err == nil {
		fmt.Println("Use CI Passed!")
	}

}

Output:

Not Use CI Error: The Password value `Goframe.org` must be the same as field Password2 value `goframe.org`
Use CI Passed!

package main

import (
	"context"
	"fmt"

	"github.com/888go/goframe/frame/g"
)

func main() {
	if err := g.X效验类().Data(16).Rules("min:18").Run(context.Background()); err != nil {
		fmt.Println(err)
	}

	if err := g.X效验类().Clone().Data(20).Run(context.Background()); err != nil {
		fmt.Println(err)
	} else {
		fmt.Println("Check Success!")
	}

}

Output:

The value `16` must be equal or greater than 18
Check Success!

package main

import (
	"context"
	"fmt"

	"github.com/888go/goframe/frame/g"
)

func main() {
	type BizReq struct {
		Password1 string `v:"password"`
		Password2 string `v:"password"`
	}

	var (
		ctx = context.Background()
		req = BizReq{
			Password1: "goframe",
			Password2: "gofra", // 错误信息长度应在6到18个字符之间
		}
	)
	if err := g.X效验类().Data(req).Run(ctx); err != nil {
		fmt.Print(err)
	}

}

Output:

The Password2 value `gofra` is not a valid password format

var (
	i18nManager = gi18n.New(gi18n.Options{Path: 单元测试类.DataPath("i18n")})
	ctxCn       = gi18n.WithLanguage(context.Background(), "cn")
	validator   = 效验类.New()
)

validator = validator.Data(16).Rules("min:18")

if err := validator.Run(context.Background()); err != nil {
	fmt.Println(err)
}

if err := validator.I18n(i18nManager).Run(ctxCn); err != nil {
	fmt.Println(err)
}

Output:

The value `16` must be equal or greater than 18
字段值`16`字段最小值应当为18

package main

import (
	"context"
	"fmt"

	"github.com/888go/goframe/frame/g"
)

func main() {
	if err := g.X效验类().Data(16).Rules("min:18").Messages("Can not regist, Age is less then 18!").Run(context.Background()); err != nil {
		fmt.Println(err)
	}

}

Output:

Can not regist, Age is less then 18!

var (
	ctx             = context.Background()
	lenErrRuleName  = "LenErr"
	passErrRuleName = "PassErr"
	lenErrRuleFunc  = func(ctx context.Context, in 效验类.RuleFuncInput) error {
		pass := in.Value.String()
		if len(pass) != 6 {
			return errors.New(in.Message)
		}
		return nil
	}
	passErrRuleFunc = func(ctx context.Context, in 效验类.RuleFuncInput) error {
		pass := in.Value.String()
		if m := in.Data.X取Map(); m["data"] != pass {
			return errors.New(in.Message)
		}
		return nil
	}
)

type LenErrStruct struct {
	Value string `v:"uid@LenErr#Value Length Error!"`
	Data  string `p:"data"`
}

st := &LenErrStruct{
	Value: "123",
	Data:  "123456",
}
// 单个错误示例
if err := g.X效验类().RuleFunc(lenErrRuleName, lenErrRuleFunc).Data(st).Run(ctx); err != nil {
	fmt.Println(err)
}

type MultiErrorStruct struct {
	Value string `v:"uid@LenErr|PassErr#Value Length Error!|Pass is not Same!"`
	Data  string `p:"data"`
}

multi := &MultiErrorStruct{
	Value: "123",
	Data:  "123456",
}
// 多错误示例
if err := g.X效验类().RuleFunc(lenErrRuleName, lenErrRuleFunc).RuleFunc(passErrRuleName, passErrRuleFunc).Data(multi).Run(ctx); err != nil {
	fmt.Println(err)
}

Output:

Value Length Error!
Value Length Error!; Pass is not Same!

var (
	ctx             = context.Background()
	lenErrRuleName  = "LenErr"
	passErrRuleName = "PassErr"
	lenErrRuleFunc  = func(ctx context.Context, in 效验类.RuleFuncInput) error {
		pass := in.Value.String()
		if len(pass) != 6 {
			return errors.New(in.Message)
		}
		return nil
	}
	passErrRuleFunc = func(ctx context.Context, in 效验类.RuleFuncInput) error {
		pass := in.Value.String()
		if m := in.Data.X取Map(); m["data"] != pass {
			return errors.New(in.Message)
		}
		return nil
	}
	ruleMap = map[string]效验类.RuleFunc{
		lenErrRuleName:  lenErrRuleFunc,
		passErrRuleName: passErrRuleFunc,
	}
)

type MultiErrorStruct struct {
	Value string `v:"uid@LenErr|PassErr#Value Length Error!|Pass is not Same!"`
	Data  string `p:"data"`
}

multi := &MultiErrorStruct{
	Value: "123",
	Data:  "123456",
}

if err := g.X效验类().RuleFuncMap(ruleMap).Data(multi).Run(ctx); err != nil {
	fmt.Println(err)
}

Output:

Value Length Error!; Pass is not Same!

package main

import (
	"context"
	"fmt"

	"github.com/888go/goframe/frame/g"
)

func main() {
	if err := g.X效验类().Data(16).Rules("min:18").Run(context.Background()); err != nil {
		fmt.Println(err)
	}

}

Output:

The value `16` must be equal or greater than 18

package main

import (
	"context"
	"fmt"

	"github.com/888go/goframe/frame/g"
)

func main() {
	// check value mode
	if err := g.X效验类().Data(16).Rules("min:18").Run(context.Background()); err != nil {
		fmt.Println("check value err:", err)
	}
	// check map mode
	data := map[string]interface{}{
		"passport":  "",
		"password":  "123456",
		"password2": "1234567",
	}
	rules := map[string]string{
		"passport":  "required|length:6,16",
		"password":  "required|length:6,16|same:password2",
		"password2": "required|length:6,16",
	}
	if err := g.X效验类().Data(data).Rules(rules).Run(context.Background()); err != nil {
		fmt.Println("check map err:", err)
	}
	// check struct mode
	type Params struct {
		Page      int    `v:"required|min:1"`
		Size      int    `v:"required|between:1,100"`
		ProjectId string `v:"between:1,10000"`
	}
	rules = map[string]string{
		"Page":      "required|min:1",
		"Size":      "required|between:1,100",
		"ProjectId": "between:1,10000",
	}
	obj := &Params{
		Page: 0,
		Size: 101,
	}
	if err := g.X效验类().Data(obj).Run(context.Background()); err != nil {
		fmt.Println("check struct err:", err)
	}

	// May Output:
	// check value err: The value `16` must be equal or greater than 18
	// check map err: The passport field is required; The passport value `` length must be between 6 and 16; The password value `123456` must be the same as field password2
	// check struct err: The Page value `0` must be equal or greater than 1; The Size value `101` must be between 1 and 100
}

Output: