/
validator.go
81 lines (66 loc) · 1.95 KB
/
validator.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
package config
import (
"reflect"
"strings"
"github.com/go-playground/locales/en"
ut "github.com/go-playground/universal-translator"
"github.com/go-playground/validator/v10"
)
// Validator struct
type Validator struct {
validate *validator.Validate
trans ut.Translator
}
// ValidationError represent error from validator
type ValidationError struct {
Namespace string `json:"namespace,omitempty"`
Field string `json:"field,omitempty"`
Error string `json:"error,omitempty"`
}
// NewValidator create an instance of Validator Struct
func NewValidator() *Validator {
en := en.New()
uni := ut.New(en, en)
trans, _ := uni.GetTranslator("en")
_validator := &Validator{
validate: validator.New(),
trans: trans,
}
_validator.validate.RegisterTagNameFunc(func(fld reflect.StructField) string {
name := strings.SplitN(fld.Tag.Get("json"), ",", 2)[0]
if name == "-" {
return ""
}
return name
})
_validator.validate.RegisterTranslation("required", trans, func(ut ut.Translator) error {
return ut.Add("required", "{0} is required", true) // see universal-translator for details
}, func(ut ut.Translator, fe validator.FieldError) string {
t, _ := ut.T("required", fe.Field())
return t
})
return _validator
}
// FormatErrors generate list of error
func (v *Validator) FormatErrors(errs validator.ValidationErrors) []ValidationError {
validationErrorMessages := errs.Translate(v.trans)
messages := make([]ValidationError, 0)
for _, err := range errs {
messages = append(messages, ValidationError{
Namespace: err.Namespace(),
Field: err.Field(),
Error: validationErrorMessages[err.Namespace()],
})
}
return messages
}
// ValidateStruct func
func (v *Validator) ValidateStruct(input interface{}) []ValidationError {
err := v.validate.Struct(input)
if err != nil {
validationErrors := err.(validator.ValidationErrors)
errResp := v.FormatErrors(validationErrors)
return errResp
}
return []ValidationError{}
}