What's the simplest way to customize the error message?

[geoff-maddock]

Looking to implement go-playground for validation, and looking for a clear way to customize the error message.

Right now I implemented a tag on a struct as such:

type QuoteRequestDTO struct {
	Title                     *string              `binding:"required" json:"title,omitempty" validate:"lte=128"`
	...
	}

And if I call validate with a title column larger than 128 characters, I get back an error:

Key: 'QuoteRequestDTO.Title' Error:Field validation for 'Title' failed on the 'lte' tag\n

However, that's not sufficient information - I'd like to be able to make it read something like:

Key: 'QuoteRequestDTO.Title' Error:Field validation for 'Title', must be lte=128, but actual was 130\n

Can anyone point to an example of how to create such a custom error message?

[geoff-maddock]

After a bit of searching, the most straightforward method I've found is processing the errors:

	err := validate.Struct(quoteValidator.quote)
	if err != nil {
		// convert errors into a more ledgable error
		for _, err := range err.(validator.ValidationErrors) {
			errs = append(errs, fmt.Errorf("field %s: wanted %s %s, got `%s`", err.Field(), err.Tag(), err.Param(), err.Value()))
		}
	}

Although to get what I really want I'll need to set up some cases to change the message based on the type of validation.

It would be nice if I could just use a static message expressed as an annotation on the model struct

[thanhphuchuynh]

//This is my processing:

type TStruct struct {
	IDNumberType string `json:"idNumberType" validate:"required,oneof=CCCD CMND" errormgs:"idNumberType just accept CCCD or CMND"`
}

func (m *TStruct) Validate(validate *validator.Validate) error {
	return pkgvalidator.ValidateFunc[TStruct](*m, validate)
}

my pkg validator:

// Help valid struct with tag custom
const tagCustom = "errormgs"

func errorTagFunc[T interface{}](obj interface{}, snp string, fieldname, actualTag string) error {
	o := obj.(T)

	if !strings.Contains(snp, fieldname) {
		return nil
	}

	fieldArr := strings.Split(snp, ".")
	rsf := reflect.TypeOf(&o).Elem()

	for i := 1; i < len(fieldArr); i++ {
		field, found := rsf.FieldByName(fieldArr[i])
		if found {
			if fieldArr[i] == fieldname {
				customMessage := field.Tag.Get(tagCustom)
				if customMessage != "" {
					return fmt.Errorf("%s: %s (%s)", fieldname, customMessage, actualTag)
				}
				return nil
			} else {
				nestedFieldType := field.Type
				rsf = nestedFieldType
			}
		}
	}
	return nil
}

func ValidateFunc[T interface{}](obj interface{}, validate *validatorv10.Validate) (errs error) {
	o := obj.(T)

	defer func() {
		if r := recover(); r != nil {
			fmt.Println("Recovered in Validate:", r)
			errs = fmt.Errorf("can't validate %+v", r)
		}
	}()

	if err := validate.Struct(o); err != nil {
		errorValid := err.(validatorv10.ValidationErrors)
		for _, e := range errorValid {
			// snp  X.Y.Z
			snp := e.StructNamespace()
			errmgs := errorTagFunc[T](obj, snp, e.Field(), e.ActualTag())
			if errmgs != nil {
				errs = errors.Join(errs, fmt.Errorf("%w", errmgs))
			} else {
				errs = errors.Join(errs, fmt.Errorf("%w", e))
			}
		}
	}

	if errs != nil {
		return errs
	}

	return nil
}

when some field error show errormgs
https://dev.to/thanhphuchuynh/customizing-error-messages-in-struct-validation-using-tags-in-go-4k0j

[jaredweinfurtner]

I use a common function:

func ValidationError(structField string, err validator.ValidationErrors) string {
	if len(err) == 0 {
		return ""
	}
	for _, e := range err {
		if e.StructField() == structField {
			switch e.Tag() {
			case "required":
				return fmt.Sprintf("The %s field is required.", e.Field())
			case "min":
				return fmt.Sprintf("The %s field must be at least %s characters long.", e.Field(), e.Param())
			case "max":
				return fmt.Sprintf("The %s field must be at most %s characters long.", e.Field(), e.Param())
			case "email":
				return fmt.Sprintf("The %s field must be a valid email address.", e.Field())
			}
		}
	}
	return ""
}