temp

internal/shared/http/validator_zh.go

@@ -1,6 +1,7 @@
 package http
 
 import (
+	"fmt"
 	"strings"
 
 	"tyapi-server/internal/shared/interfaces"
@@ -14,16 +15,12 @@ import (
 
 // RequestValidatorZh 中文验证器实现
 type RequestValidatorZh struct {
-	validator  *validator.Validate
-	translator ut.Translator
 	response   interfaces.ResponseBuilder
+	translator ut.Translator
 }
 
 // NewRequestValidatorZh 创建支持中文翻译的请求验证器
 func NewRequestValidatorZh(response interfaces.ResponseBuilder) interfaces.RequestValidator {
-	// 创建验证器实例
-	validate := validator.New()
-
 	// 创建中文locale
 	zhLocale := zh.New()
 	uni := ut.New(zhLocale, zhLocale)
@@ -31,39 +28,64 @@ func NewRequestValidatorZh(response interfaces.ResponseBuilder) interfaces.Reque
 	// 获取中文翻译器
 	trans, _ := uni.GetTranslator("zh")
 
-	// 注册中文翻译
-	zh_translations.RegisterDefaultTranslations(validate, trans)
+	// 注册官方中文翻译
+	zh_translations.RegisterDefaultTranslations(validator.New(), trans)
 
-	// 注册自定义验证器
-	registerCustomValidatorsZh(validate, trans)
+	// 注册自定义翻译
+	registerCustomTranslations(trans)
 
 	return &RequestValidatorZh{
-		validator:  validate,
-		translator: trans,
 		response:   response,
+		translator: trans,
 	}
 }
 
+// registerCustomTranslations 注册自定义翻译
+func registerCustomTranslations(trans ut.Translator) {
+	// 自定义 eqfield 翻译（更友好的提示）
+	_ = trans.Add("eqfield", "{0}必须与{1}一致", true)
+
+	// 自定义 required 翻译
+	_ = trans.Add("required", "{0}不能为空", true)
+
+	// 自定义 min 翻译
+	_ = trans.Add("min", "{0}长度不能少于{1}位", true)
+
+	// 自定义 max 翻译
+	_ = trans.Add("max", "{0}长度不能超过{1}位", true)
+
+	// 自定义 len 翻译
+	_ = trans.Add("len", "{0}长度必须为{1}位", true)
+
+	// 自定义 email 翻译
+	_ = trans.Add("email", "{0}必须是有效的邮箱地址", true)
+
+	// 自定义手机号翻译
+	_ = trans.Add("phone", "{0}必须是有效的手机号", true)
+
+	// 自定义用户名翻译
+	_ = trans.Add("username", "{0}格式不正确，只能包含字母、数字、下划线，且不能以数字开头", true)
+
+	// 自定义强密码翻译
+	_ = trans.Add("strong_password", "{0}强度不足，必须包含大小写字母和数字，且不少于8位", true)
+}
+
 // Validate 验证请求体
 func (v *RequestValidatorZh) Validate(c *gin.Context, dto interface{}) error {
-	if err := v.validator.Struct(dto); err != nil {
-		validationErrors := v.formatValidationErrorsZh(err)
-		v.response.ValidationError(c, validationErrors)
-		return err
-	}
-	return nil
+	// 直接使用 Gin 的绑定和验证
+	return v.BindAndValidate(c, dto)
 }
 
 // ValidateQuery 验证查询参数
 func (v *RequestValidatorZh) ValidateQuery(c *gin.Context, dto interface{}) error {
 	if err := c.ShouldBindQuery(dto); err != nil {
-		v.response.BadRequest(c, "查询参数格式错误", err.Error())
-		return err
-	}
-
-	if err := v.validator.Struct(dto); err != nil {
-		validationErrors := v.formatValidationErrorsZh(err)
-		v.response.ValidationError(c, validationErrors)
+		// 处理查询参数验证错误
+		if _, ok := err.(validator.ValidationErrors); ok {
+			validationErrors := v.formatValidationErrorsZh(err)
+			v.response.ValidationError(c, validationErrors)
+		} else {
+			v.response.BadRequest(c, "查询参数格式错误", err.Error())
+		}
 		return err
 	}
 	return nil
@@ -72,13 +94,13 @@ func (v *RequestValidatorZh) ValidateQuery(c *gin.Context, dto interface{}) erro
 // ValidateParam 验证路径参数
 func (v *RequestValidatorZh) ValidateParam(c *gin.Context, dto interface{}) error {
 	if err := c.ShouldBindUri(dto); err != nil {
-		v.response.BadRequest(c, "路径参数格式错误", err.Error())
-		return err
-	}
-
-	if err := v.validator.Struct(dto); err != nil {
-		validationErrors := v.formatValidationErrorsZh(err)
-		v.response.ValidationError(c, validationErrors)
+		// 处理路径参数验证错误
+		if _, ok := err.(validator.ValidationErrors); ok {
+			validationErrors := v.formatValidationErrorsZh(err)
+			v.response.ValidationError(c, validationErrors)
+		} else {
+			v.response.BadRequest(c, "路径参数格式错误", err.Error())
+		}
 		return err
 	}
 	return nil
@@ -86,14 +108,20 @@ func (v *RequestValidatorZh) ValidateParam(c *gin.Context, dto interface{}) erro
 
 // BindAndValidate 绑定并验证请求
 func (v *RequestValidatorZh) BindAndValidate(c *gin.Context, dto interface{}) error {
-	// 绑定请求体
+	// 绑定请求体（Gin 会自动进行 binding 标签验证）
 	if err := c.ShouldBindJSON(dto); err != nil {
-		v.response.BadRequest(c, "请求体格式错误", err.Error())
+		// 处理 Gin binding 验证错误
+		if _, ok := err.(validator.ValidationErrors); ok {
+			// 所有验证错误都使用 422 状态码
+			validationErrors := v.formatValidationErrorsZh(err)
+			v.response.ValidationError(c, validationErrors)
+		} else {
+			v.response.BadRequest(c, "请求体格式错误", err.Error())
+		}
 		return err
 	}
 
-	// 验证数据
-	return v.Validate(c, dto)
+	return nil
 }
 
 // formatValidationErrorsZh 格式化验证错误（中文翻译版）
@@ -104,15 +132,8 @@ func (v *RequestValidatorZh) formatValidationErrorsZh(err error) map[string][]st
 		for _, fieldError := range validationErrors {
 			fieldName := v.getFieldNameZh(fieldError)
 
-			// 首先尝试使用翻译器获取翻译后的错误消息
-			errorMessage := fieldError.Translate(v.translator)
-
-			// 如果翻译后的消息包含英文字段名，则替换为中文字段名
-			fieldDisplayName := v.getFieldDisplayName(fieldError.Field())
-			if fieldDisplayName != fieldError.Field() {
-				// 替换字段名为中文
-				errorMessage = strings.ReplaceAll(errorMessage, fieldError.Field(), fieldDisplayName)
-			}
+			// 获取友好的中文错误消息
+			errorMessage := v.getFriendlyErrorMessage(fieldError)
 
 			if _, exists := errors[fieldName]; !exists {
 				errors[fieldName] = []string{}
@@ -124,6 +145,53 @@ func (v *RequestValidatorZh) formatValidationErrorsZh(err error) map[string][]st
 	return errors
 }
 
+// getFriendlyErrorMessage 获取友好的中文错误消息
+func (v *RequestValidatorZh) getFriendlyErrorMessage(fieldError validator.FieldError) string {
+	field := fieldError.Field()
+	tag := fieldError.Tag()
+	param := fieldError.Param()
+
+	fieldDisplayName := v.getFieldDisplayName(field)
+
+	// 优先使用官方翻译器
+	errorMessage := fieldError.Translate(v.translator)
+
+	// 如果官方翻译成功且不是英文，使用官方翻译
+	if errorMessage != fieldError.Error() {
+		// 替换字段名为中文
+		if fieldDisplayName != fieldError.Field() {
+			errorMessage = strings.ReplaceAll(errorMessage, fieldError.Field(), fieldDisplayName)
+		}
+		return errorMessage
+	}
+
+	// 回退到自定义翻译
+	switch tag {
+	case "required":
+		return fmt.Sprintf("%s不能为空", fieldDisplayName)
+	case "email":
+		return fmt.Sprintf("%s必须是有效的邮箱地址", fieldDisplayName)
+	case "min":
+		return fmt.Sprintf("%s长度不能少于%s位", fieldDisplayName, param)
+	case "max":
+		return fmt.Sprintf("%s长度不能超过%s位", fieldDisplayName, param)
+	case "len":
+		return fmt.Sprintf("%s长度必须为%s位", fieldDisplayName, param)
+	case "eqfield":
+		paramDisplayName := v.getFieldDisplayName(param)
+		return fmt.Sprintf("%s必须与%s一致", fieldDisplayName, paramDisplayName)
+	case "phone":
+		return fmt.Sprintf("%s必须是有效的手机号", fieldDisplayName)
+	case "username":
+		return fmt.Sprintf("%s格式不正确，只能包含字母、数字、下划线，且不能以数字开头", fieldDisplayName)
+	case "strong_password":
+		return fmt.Sprintf("%s强度不足，必须包含大小写字母和数字，且不少于8位", fieldDisplayName)
+	default:
+		// 默认错误消息
+		return fmt.Sprintf("%s格式不正确", fieldDisplayName)
+	}
+}
+
 // getFieldNameZh 获取字段名（JSON标签优先）
 func (v *RequestValidatorZh) getFieldNameZh(fieldError validator.FieldError) string {
 	fieldName := fieldError.Field()
@@ -166,129 +234,3 @@ func (v *RequestValidatorZh) toSnakeCase(str string) string {
 	}
 	return strings.ToLower(result.String())
 }
-
-// registerCustomValidatorsZh 注册自定义验证器和中文翻译
-func registerCustomValidatorsZh(v *validator.Validate, trans ut.Translator) {
-	// 注册手机号验证器
-	v.RegisterValidation("phone", validatePhoneZh)
-	v.RegisterTranslation("phone", trans, func(ut ut.Translator) error {
-		return ut.Add("phone", "{0}必须是有效的手机号", true)
-	}, func(ut ut.Translator, fe validator.FieldError) string {
-		t, _ := ut.T("phone", fe.Field())
-		return t
-	})
-
-	// 注册用户名验证器
-	v.RegisterValidation("username", validateUsernameZh)
-	v.RegisterTranslation("username", trans, func(ut ut.Translator) error {
-		return ut.Add("username", "{0}格式不正确，只能包含字母、数字、下划线，且不能以数字开头", true)
-	}, func(ut ut.Translator, fe validator.FieldError) string {
-		t, _ := ut.T("username", fe.Field())
-		return t
-	})
-
-	// 注册密码强度验证器
-	v.RegisterValidation("strong_password", validateStrongPasswordZh)
-	v.RegisterTranslation("strong_password", trans, func(ut ut.Translator) error {
-		return ut.Add("strong_password", "{0}强度不足，必须包含大小写字母和数字，且不少于8位", true)
-	}, func(ut ut.Translator, fe validator.FieldError) string {
-		t, _ := ut.T("strong_password", fe.Field())
-		return t
-	})
-
-	// 自定义eqfield翻译
-	v.RegisterTranslation("eqfield", trans, func(ut ut.Translator) error {
-		return ut.Add("eqfield", "{0}必须等于{1}", true)
-	}, func(ut ut.Translator, fe validator.FieldError) string {
-		t, _ := ut.T("eqfield", fe.Field(), fe.Param())
-		return t
-	})
-}
-
-// validatePhoneZh 验证手机号
-func validatePhoneZh(fl validator.FieldLevel) bool {
-	phone := fl.Field().String()
-	if phone == "" {
-		return true // 空值由required标签处理
-	}
-
-	// 中国手机号验证：11位，以1开头
-	if len(phone) != 11 {
-		return false
-	}
-
-	if !strings.HasPrefix(phone, "1") {
-		return false
-	}
-
-	// 检查是否全是数字
-	for _, r := range phone {
-		if r < '0' || r > '9' {
-			return false
-		}
-	}
-
-	return true
-}
-
-// validateUsernameZh 验证用户名
-func validateUsernameZh(fl validator.FieldLevel) bool {
-	username := fl.Field().String()
-	if username == "" {
-		return true // 空值由required标签处理
-	}
-
-	// 用户名规则：3-30个字符，只能包含字母、数字、下划线，不能以数字开头
-	if len(username) < 3 || len(username) > 30 {
-		return false
-	}
-
-	// 不能以数字开头
-	if username[0] >= '0' && username[0] <= '9' {
-		return false
-	}
-
-	// 只能包含字母、数字、下划线
-	for _, r := range username {
-		if !((r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '_') {
-			return false
-		}
-	}
-
-	return true
-}
-
-// validateStrongPasswordZh 验证密码强度
-func validateStrongPasswordZh(fl validator.FieldLevel) bool {
-	password := fl.Field().String()
-	if password == "" {
-		return true // 空值由required标签处理
-	}
-
-	// 密码强度规则：至少8个字符，包含大小写字母、数字
-	if len(password) < 8 {
-		return false
-	}
-
-	hasUpper := false
-	hasLower := false
-	hasDigit := false
-
-	for _, r := range password {
-		switch {
-		case r >= 'A' && r <= 'Z':
-			hasUpper = true
-		case r >= 'a' && r <= 'z':
-			hasLower = true
-		case r >= '0' && r <= '9':
-			hasDigit = true
-		}
-	}
-
-	return hasUpper && hasLower && hasDigit
-}
-
-// ValidateStruct 直接验证结构体
-func (v *RequestValidatorZh) ValidateStruct(dto interface{}) error {
-	return v.validator.Struct(dto)
-}