// RegisterRule registers custom validation rule and function for package.
// It returns error if there's already the same rule registered previously.
func RegisterRule(rule string, f RuleFunc) error

// RuleFunc is the custom function for data validation.
// The parameter `rule` specifies the validation rule string, like "required", "between:1,100", etc.
// The parameter `value` specifies the value for this rule to validate.
// The parameter `message` specifies the custom error message or configured i18n message for this rule.
// The parameter `data` specifies the `data` which is passed to the Validator. It might be type of map/struct or a nil value.
// You can ignore the parameter `data` if you do not really need it in your custom validation rule.
type RuleFunc func(ctx context.Context, rule string, value interface{}, message string, data interface{}) error

自定义错误默认情况下已支持i18n特性，因此您只需要按照 gf.gvalid.rule.自定义规则名称 配置i18n转译信息即可，该信息在校验失败时自动从i18n管理器获取后，通过message参数传入给您注册的自定义校验方法中。

注意事项：自定义规则的注册方法不支持并发调用，您需要在程序启动时进行注册（例如在boot包中处理），无法在运行时动态注册，否则会产生并发安全问题。

package main

import (
	"context"
	"fmt"
	"github.com/gogf/gf/util/gvalid"

	"github.com/gogf/gf/errors/gerror"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/util/gconv"
)

type User struct {
	Id   int
	Name string `v:"required|unique-name # 请输入用户名称|用户名称已被占用"`
	Pass string `v:"required|length:6,18"`
}

func init() {
	rule := "unique-name"
	if err := gvalid.RegisterRule(rule, UniqueNameChecker); err != nil {
		panic(err)
	}
}

func UniqueNameChecker(ctx context.Context, rule string, value interface{}, message string, data interface{}) error {
	user := &User{}
	if v, ok := data.(*User); ok {
		user = v
	}
	// SELECT COUNT(*) FROM `user` WHERE `id` != xxx AND `name` != xxx
	count, err := g.Model("user").
		Ctx(ctx).
		WhereNot("id", user.Id).
		WhereNot("name", gconv.String(value)).
		Count()
	if err != nil {
		return err
	}
	if count > 0 {
		return gerror.New(message)
	}
	return nil
}

func main() {
	user := &User{
		Id:   1,
		Name: "john",
		Pass: "123456",
	}
	err := g.Validator().CheckStruct(user)
	fmt.Println(err)
}

package main

import (
	"context"
	"errors"
	"fmt"
	"github.com/gogf/gf/util/gvalid"
	"math"
	"reflect"

	"github.com/gogf/gf/frame/g"
)

func init() {
	rule := "required"
	if err := gvalid.RegisterRule(rule, RequiredChecker); err != nil {
		panic(err)
	}
}

func RequiredChecker(ctx context.Context, rule string, value interface{}, message string, data interface{}) error {
	reflectValue := reflect.ValueOf(value)
	if reflectValue.Kind() == reflect.Ptr {
		reflectValue = reflectValue.Elem()
	}
	isEmpty := false
	switch reflectValue.Kind() {
	case
		reflect.Bool:
		isEmpty = !reflectValue.Bool()

	case
		reflect.Int,
		reflect.Int8,
		reflect.Int16,
		reflect.Int32,
		reflect.Int64:
		isEmpty = reflectValue.Int() == 0

	case
		reflect.Uint,
		reflect.Uint8,
		reflect.Uint16,
		reflect.Uint32,
		reflect.Uint64,
		reflect.Uintptr:
		isEmpty = reflectValue.Uint() == 0

	case
		reflect.Float32,
		reflect.Float64:
		isEmpty = math.Float64bits(reflectValue.Float()) == 0

	case
		reflect.Complex64,
		reflect.Complex128:
		c := reflectValue.Complex()
		isEmpty = math.Float64bits(real(c)) == 0 && math.Float64bits(imag(c)) == 0

	case
		reflect.String,
		reflect.Map,
		reflect.Array,
		reflect.Slice:
		isEmpty = reflectValue.Len() == 0
	}
	if isEmpty {
		return errors.New(message)
	}
	return nil
}

func main() {
	fmt.Println(g.Validator().Rules("required").Messages("It's required").CheckValue(""))
	fmt.Println(g.Validator().Rules("required").Messages("It's required").CheckValue([]string{}))
	fmt.Println(g.Validator().Rules("required").Messages("It's required").CheckValue(map[string]int{}))
}

It's required
It's required
It's required