Gin parameter validation

Preface

gin The parameter validation of is integrated https://github.com/go-playground

Parameter validation

Use gin.Context in ShouldBind(obj) Method
obj adopt tag Set validation rules

Receive parameter field settings

//json:“json_name”  representative json Format charge json_name Parameter value to Name
//form:"form_name"  Receive on behalf of the form format form_name Parameter value to Name
//xml:"xml_name"  representative xml Format charge xml_name Parameter to Name
type Register struct {
    
	Name string `json:"json_name" form:"form_name" xml:"xml_name"`
}

Parameter condition limits
more tag Please check the official documents (https://pkg.go.dev/github.com/go-playground/validator/v10#hdr-Using_Validator_Tags)

//binding: The latter is conditional 
//required: Required 
//min: Minimum length 
//max: Maximum length 

type Register struct {
    
	Name string `json:"json_name" form:"form_name" xml:"xml_name" binding:"required,min=3,max=10"`
}

Output error message

package main

import (
	"github.com/gin-gonic/gin"
	"net/http"
)

type Register struct {
    
	Name string `json:"json_name" form:"form_name" xml:"xml_name" binding:"required,min=3,max=10"`
}

func main() {
    
	r := gin.Default()

	r.POST("/register", func(c *gin.Context) {
    
		r := &Register{
    }
		err := c.ShouldBind(r)
		if err != nil {
    
			c.JSON(http.StatusBadRequest, gin.H{
    
				"error": err.Error(),
			})
			return
		}

		c.JSON(http.StatusOK, gin.H{
    
			"message": "ok",
		})
	})

	r.Run(":8080")
}

Verify Chinese processing of information

The verification error message without Chinese processing is like this :Key: ‘Register.Name’ Error:Field validation for ‘Name’ failed on the ‘required’ tag

First register the translator , Then create a universal translator , Get the specified translator from the general translator ( Sealed ), Then bind it to gin On the verifier of .
The error returned by the verifier is converted into go-playground Of ValidationErrors type , call Translate Specify a translator to translate

package main

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"
	"github.com/go-playground/locales/en"
	"github.com/go-playground/locales/zh"
	ut "github.com/go-playground/universal-translator"
	"github.com/go-playground/validator/v10"
	en_translation "github.com/go-playground/validator/v10/translations/en"
	zh_translation "github.com/go-playground/validator/v10/translations/zh"
	"net/http"
)

type Register struct {
    
	Name string `json:"json_name" form:"form_name" xml:"xml_name" binding:"required,min=3,max=10"`
}

var trans ut.Translator

func initTranslator(language string) error {
    
	// convert to go-playground Of validator
	validate, ok := binding.Validator.Engine().(*validator.Validate)
	if ok {
    
		// Create translator 
		zhT := zh.New()
		enT := en.New()

		// Create a universal translator 
		// The first parameter is the alternate language , The latter is the language that should be supported 
		uni := ut.New(enT, enT, zhT)

		// Get the specified language translator from 
		trans, ok = uni.GetTranslator(language)
		if !ok {
    
			return fmt.Errorf("not found translator %s", language)
		}

		// Bound to the gin On the verifier of , Yes binding Of tag Translate 
		switch language {
    
		case "zh":
			err := zh_translation.RegisterDefaultTranslations(validate, trans)
			if err != nil {
    
				return err
			}
		default:
			err := en_translation.RegisterDefaultTranslations(validate, trans)
			if err != nil {
    
				return err
			}
		}

	}

	return nil
}

func main() {
    

	err := initTranslator("zh")
	if err != nil {
    
		panic(err)
	}
	r := gin.Default()

	r.POST("/register", func(c *gin.Context) {
    
		r := &Register{
    }
		err := c.ShouldBind(r)
		if err != nil {
    
			if errors, ok := err.(validator.ValidationErrors); ok {
    
				// Call the specified translator to translate 
				c.JSON(http.StatusBadRequest, gin.H{
    
					"error": errors.Translate(trans),
				})
			} else {
    
				c.JSON(http.StatusBadRequest, gin.H{
    
					"error": err.Error(),
				})
			}

			return
		}

		c.JSON(http.StatusOK, gin.H{
    
			"message": "ok",
		})
	})

	r.Run(":8080")
}

The returned error format processing

The error format returned above is like this

{
    
    "error": {
    
        "Register.Name": "Name Is a required field "
    }
}

First of all, I passed JSON Format requested ,error Medium key Should be json_name,value
Should be json_name Is a required field
Ideal data structure

{
    
    "error": {
    
        "json_name": "json_name Is a required field "
    }
}

json_name Can pass RegisterTagNameFunc Set the return field json_name, But even if you set json_name, however key still Register.json_name.
Solution ： Handle the error results , To eliminate Register part

package main

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"
	"github.com/go-playground/locales/en"
	"github.com/go-playground/locales/zh"
	ut "github.com/go-playground/universal-translator"
	"github.com/go-playground/validator/v10"
	en_translation "github.com/go-playground/validator/v10/translations/en"
	zh_translation "github.com/go-playground/validator/v10/translations/zh"
	"net/http"
	"reflect"
	"strings"
)

type Register struct {
    
	Name string `json:"json_name" form:"form_name" xml:"xml_name" binding:"required,min=3,max=10"`
}

var trans ut.Translator

func initTranslator(language string) error {
    
	// convert to go-playground Of validator
	validate, ok := binding.Validator.Engine().(*validator.Validate)

	validate.RegisterTagNameFunc(func(field reflect.StructField) string {
    
		// json:"json_name" form:"form_name" xml:"xml_name" binding:"required,min=3,max=10"
		//  Set back  json tag  The content in   Such as :json_names
		return field.Tag.Get("json")
	})

	if ok {
    
		// Create translator 
		zhT := zh.New()
		enT := en.New()

		// Create a universal translator 
		// The first parameter is the alternate language , The latter is the language that should be supported 
		uni := ut.New(enT, enT, zhT)

		// Get the specified language translator from 
		trans, ok = uni.GetTranslator(language)
		if !ok {
    
			return fmt.Errorf("not found translator %s", language)
		}

		// Yes binding Of tag Translate 
		switch language {
    
		case "zh":
			err := zh_translation.RegisterDefaultTranslations(validate, trans)
			if err != nil {
    
				return err
			}
		default:
			err := en_translation.RegisterDefaultTranslations(validate, trans)
			if err != nil {
    
				return err
			}
		}

	}

	return nil
}

func remove(errors map[string]string) map[string]string {
    
	result := map[string]string{
    }
	for key, value := range errors {
    
		result[key[strings.Index(key, ".")+1:]] = value
	}
	return result
}

func main() {
    

	err := initTranslator("zh")
	if err != nil {
    
		panic(err)
	}
	r := gin.Default()

	r.POST("/register", func(c *gin.Context) {
    
		r := &Register{
    }
		err := c.ShouldBind(r)
		if err != nil {
    
			if errors, ok := err.(validator.ValidationErrors); ok {
    
				// Call the specified translator to translate 
				c.JSON(http.StatusBadRequest, gin.H{
    
					// Call the custom function to remove Register part 
					"error": remove(errors.Translate(trans)),
				})
			} else {
    
				c.JSON(http.StatusBadRequest, gin.H{
    
					"error": err.Error(),
				})
			}

			return
		}

		c.JSON(http.StatusOK, gin.H{
    
			"message": "ok",
		})
	})

	r.Run(":8080")
}