基础架构

internal/infrastructure/http/handlers/admin_handler.go

@@ -0,0 +1,280 @@
+package handlers
+
+import (
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+
+	"tyapi-server/internal/application/admin"
+	"tyapi-server/internal/application/admin/dto/commands"
+	"tyapi-server/internal/application/admin/dto/queries"
+	"tyapi-server/internal/shared/interfaces"
+)
+
+// AdminHandler 管理员HTTP处理器
+type AdminHandler struct {
+	appService      admin.AdminApplicationService
+	responseBuilder interfaces.ResponseBuilder
+	logger          *zap.Logger
+}
+
+// NewAdminHandler 创建管理员HTTP处理器
+func NewAdminHandler(
+	appService admin.AdminApplicationService,
+	responseBuilder interfaces.ResponseBuilder,
+	logger *zap.Logger,
+) *AdminHandler {
+	return &AdminHandler{
+		appService:      appService,
+		responseBuilder: responseBuilder,
+		logger:          logger,
+	}
+}
+
+// Login 管理员登录
+// @Summary 管理员登录
+// @Description 使用用户名和密码进行管理员登录，返回JWT令牌
+// @Tags 管理员认证
+// @Accept json
+// @Produce json
+// @Param request body commands.AdminLoginCommand true "管理员登录请求"
+// @Success 200 {object} responses.AdminLoginResponse "登录成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 401 {object} map[string]interface{} "用户名或密码错误"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/admin/auth/login [post]
+func (h *AdminHandler) Login(c *gin.Context) {
+	var cmd commands.AdminLoginCommand
+	if err := c.ShouldBindJSON(&cmd); err != nil {
+		h.responseBuilder.BadRequest(c, "请求参数错误")
+		return
+	}
+
+	response, err := h.appService.Login(c.Request.Context(), &cmd)
+	if err != nil {
+		h.logger.Error("管理员登录失败", zap.Error(err))
+		h.responseBuilder.Unauthorized(c, err.Error())
+		return
+	}
+
+	h.responseBuilder.Success(c, response, "登录成功")
+}
+
+// CreateAdmin 创建管理员
+// @Summary 创建管理员
+// @Description 创建新的管理员账户，需要超级管理员权限
+// @Tags 管理员管理
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Param request body commands.CreateAdminCommand true "创建管理员请求"
+// @Success 201 {object} map[string]interface{} "管理员创建成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 403 {object} map[string]interface{} "权限不足"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/admin [post]
+func (h *AdminHandler) CreateAdmin(c *gin.Context) {
+	var cmd commands.CreateAdminCommand
+	if err := c.ShouldBindJSON(&cmd); err != nil {
+		h.responseBuilder.BadRequest(c, "请求参数错误")
+		return
+	}
+	cmd.OperatorID = h.getCurrentAdminID(c)
+
+	if err := h.appService.CreateAdmin(c.Request.Context(), &cmd); err != nil {
+		h.logger.Error("创建管理员失败", zap.Error(err))
+		h.responseBuilder.BadRequest(c, err.Error())
+		return
+	}
+
+	h.responseBuilder.Created(c, nil, "管理员创建成功")
+}
+
+// UpdateAdmin 更新管理员
+// @Summary 更新管理员信息
+// @Description 更新指定管理员的基本信息
+// @Tags 管理员管理
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Param id path string true "管理员ID"
+// @Param request body commands.UpdateAdminCommand true "更新管理员请求"
+// @Success 200 {object} map[string]interface{} "管理员更新成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 403 {object} map[string]interface{} "权限不足"
+// @Failure 404 {object} map[string]interface{} "管理员不存在"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/admin/{id} [put]
+func (h *AdminHandler) UpdateAdmin(c *gin.Context) {
+	var cmd commands.UpdateAdminCommand
+	if err := c.ShouldBindJSON(&cmd); err != nil {
+		h.responseBuilder.BadRequest(c, "请求参数错误")
+		return
+	}
+	cmd.AdminID = c.Param("id")
+	cmd.OperatorID = h.getCurrentAdminID(c)
+
+	if err := h.appService.UpdateAdmin(c.Request.Context(), &cmd); err != nil {
+		h.logger.Error("更新管理员失败", zap.Error(err))
+		h.responseBuilder.BadRequest(c, err.Error())
+		return
+	}
+
+	h.responseBuilder.Success(c, nil, "管理员更新成功")
+}
+
+// ChangePassword 修改密码
+// @Summary 修改管理员密码
+// @Description 修改当前登录管理员的密码
+// @Tags 管理员管理
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Param request body commands.ChangeAdminPasswordCommand true "修改密码请求"
+// @Success 200 {object} map[string]interface{} "密码修改成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/admin/change-password [post]
+func (h *AdminHandler) ChangePassword(c *gin.Context) {
+	var cmd commands.ChangeAdminPasswordCommand
+	if err := c.ShouldBindJSON(&cmd); err != nil {
+		h.responseBuilder.BadRequest(c, "请求参数错误")
+		return
+	}
+	cmd.AdminID = h.getCurrentAdminID(c)
+
+	if err := h.appService.ChangePassword(c.Request.Context(), &cmd); err != nil {
+		h.logger.Error("修改密码失败", zap.Error(err))
+		h.responseBuilder.BadRequest(c, err.Error())
+		return
+	}
+
+	h.responseBuilder.Success(c, nil, "密码修改成功")
+}
+
+// ListAdmins 获取管理员列表
+// @Summary 获取管理员列表
+// @Description 分页获取管理员列表，支持搜索和筛选
+// @Tags 管理员管理
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Param page query int false "页码" default(1)
+// @Param size query int false "每页数量" default(10)
+// @Param keyword query string false "搜索关键词"
+// @Param status query string false "状态筛选"
+// @Success 200 {object} responses.AdminListResponse "获取管理员列表成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/admin [get]
+func (h *AdminHandler) ListAdmins(c *gin.Context) {
+	var query queries.ListAdminsQuery
+	if err := c.ShouldBindQuery(&query); err != nil {
+		h.responseBuilder.BadRequest(c, "请求参数错误")
+		return
+	}
+
+	response, err := h.appService.ListAdmins(c.Request.Context(), &query)
+	if err != nil {
+		h.logger.Error("获取管理员列表失败", zap.Error(err))
+		h.responseBuilder.InternalError(c, "获取管理员列表失败")
+		return
+	}
+
+	h.responseBuilder.Success(c, response, "获取管理员列表成功")
+}
+
+// GetAdminByID 根据ID获取管理员
+// @Summary 获取管理员详情
+// @Description 根据管理员ID获取详细信息
+// @Tags 管理员管理
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Param id path string true "管理员ID"
+// @Success 200 {object} responses.AdminInfoResponse "获取管理员详情成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 404 {object} map[string]interface{} "管理员不存在"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/admin/{id} [get]
+func (h *AdminHandler) GetAdminByID(c *gin.Context) {
+	var query queries.GetAdminInfoQuery
+	if err := c.ShouldBindUri(&query); err != nil {
+		h.responseBuilder.BadRequest(c, "请求参数错误")
+		return
+	}
+
+	admin, err := h.appService.GetAdminByID(c.Request.Context(), &query)
+	if err != nil {
+		h.logger.Error("获取管理员详情失败", zap.Error(err))
+		h.responseBuilder.NotFound(c, err.Error())
+		return
+	}
+
+	h.responseBuilder.Success(c, admin, "获取管理员详情成功")
+}
+
+// DeleteAdmin 删除管理员
+// @Summary 删除管理员
+// @Description 删除指定的管理员账户
+// @Tags 管理员管理
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Param id path string true "管理员ID"
+// @Success 200 {object} map[string]interface{} "管理员删除成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 403 {object} map[string]interface{} "权限不足"
+// @Failure 404 {object} map[string]interface{} "管理员不存在"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/admin/{id} [delete]
+func (h *AdminHandler) DeleteAdmin(c *gin.Context) {
+	var cmd commands.DeleteAdminCommand
+	cmd.AdminID = c.Param("id")
+	cmd.OperatorID = h.getCurrentAdminID(c)
+
+	if err := h.appService.DeleteAdmin(c.Request.Context(), &cmd); err != nil {
+		h.logger.Error("删除管理员失败", zap.Error(err))
+		h.responseBuilder.BadRequest(c, err.Error())
+		return
+	}
+
+	h.responseBuilder.Success(c, nil, "管理员删除成功")
+}
+
+// GetAdminStats 获取管理员统计信息
+// @Summary 获取管理员统计信息
+// @Description 获取管理员相关的统计数据
+// @Tags 管理员管理
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Success 200 {object} responses.AdminStatsResponse "获取统计信息成功"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/admin/stats [get]
+func (h *AdminHandler) GetAdminStats(c *gin.Context) {
+	stats, err := h.appService.GetAdminStats(c.Request.Context())
+	if err != nil {
+		h.logger.Error("获取管理员统计失败", zap.Error(err))
+		h.responseBuilder.InternalError(c, "获取统计信息失败")
+		return
+	}
+
+	h.responseBuilder.Success(c, stats, "获取统计信息成功")
+}
+
+// getCurrentAdminID 获取当前管理员ID
+func (h *AdminHandler) getCurrentAdminID(c *gin.Context) string {
+	if userID, exists := c.Get("user_id"); exists {
+		if id, ok := userID.(string); ok {
+			return id
+		}
+	}
+	return ""
+}

internal/infrastructure/http/handlers/certification_handler.go

@@ -0,0 +1,472 @@
+package handlers
+
+import (
+	"io"
+
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+
+	"tyapi-server/internal/application/certification"
+	"tyapi-server/internal/application/certification/dto/commands"
+	"tyapi-server/internal/application/certification/dto/queries"
+	"tyapi-server/internal/shared/interfaces"
+)
+
+// CertificationHandler 认证处理器
+type CertificationHandler struct {
+	appService certification.CertificationApplicationService
+	response   interfaces.ResponseBuilder
+	logger     *zap.Logger
+}
+
+// NewCertificationHandler 创建认证处理器
+func NewCertificationHandler(
+	appService certification.CertificationApplicationService,
+	response interfaces.ResponseBuilder,
+	logger *zap.Logger,
+) *CertificationHandler {
+	return &CertificationHandler{
+		appService: appService,
+		response:   response,
+		logger:     logger,
+	}
+}
+
+// CreateCertification 创建认证申请
+// @Summary 创建认证申请
+// @Description 为用户创建新的企业认证申请
+// @Tags 企业认证
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Success 200 {object} responses.CertificationResponse "认证申请创建成功"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/certification [post]
+func (h *CertificationHandler) CreateCertification(c *gin.Context) {
+	userID := c.GetString("user_id")
+	if userID == "" {
+		h.response.Unauthorized(c, "用户未认证")
+		return
+	}
+
+	cmd := &commands.CreateCertificationCommand{UserID: userID}
+	result, err := h.appService.CreateCertification(c.Request.Context(), cmd)
+	if err != nil {
+		h.logger.Error("创建认证申请失败",
+			zap.String("user_id", userID),
+			zap.Error(err),
+		)
+		h.response.InternalError(c, "创建认证申请失败")
+		return
+	}
+
+	h.response.Success(c, result, "认证申请创建成功")
+}
+
+// UploadBusinessLicense 上传营业执照并同步OCR识别
+// @Summary 上传营业执照并同步OCR识别
+// @Description 上传营业执照文件，立即进行OCR识别并返回结果
+// @Tags 企业认证
+// @Accept multipart/form-data
+// @Produce json
+// @Param file formData file true "营业执照文件"
+// @Security Bearer
+// @Success 200 {object} responses.UploadLicenseResponse "上传成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 401 {object} map[string]interface{} "未授权"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/certification/upload-license [post]
+func (h *CertificationHandler) UploadBusinessLicense(c *gin.Context) {
+	// 获取当前用户ID
+	userID, exists := c.Get("user_id")
+	if !exists {
+		h.response.Unauthorized(c, "用户未认证")
+		return
+	}
+
+	// 获取上传的文件
+	file, err := c.FormFile("file")
+	if err != nil {
+		h.response.BadRequest(c, "文件上传失败")
+		return
+	}
+
+	// 读取文件内容
+	openedFile, err := file.Open()
+	if err != nil {
+		h.response.BadRequest(c, "无法读取文件")
+		return
+	}
+	defer openedFile.Close()
+
+	fileBytes, err := io.ReadAll(openedFile)
+	if err != nil {
+		h.response.BadRequest(c, "文件读取失败")
+		return
+	}
+
+	// 调用应用服务
+	response, err := h.appService.UploadBusinessLicense(c.Request.Context(), userID.(string), fileBytes, file.Filename)
+	if err != nil {
+		h.logger.Error("营业执照上传失败", zap.Error(err))
+		h.response.InternalError(c, "营业执照上传失败")
+		return
+	}
+
+	h.response.Success(c, response, "营业执照上传成功")
+}
+
+// GetCertificationStatus 获取认证状态
+// @Summary 获取认证状态
+// @Description 获取当前用户的认证申请状态
+// @Tags 企业认证
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Success 200 {object} responses.CertificationResponse "获取认证状态成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/certification/status [get]
+func (h *CertificationHandler) GetCertificationStatus(c *gin.Context) {
+	userID := c.GetString("user_id")
+	if userID == "" {
+		h.response.Unauthorized(c, "用户未认证")
+		return
+	}
+
+	query := &queries.GetCertificationStatusQuery{UserID: userID}
+	result, err := h.appService.GetCertificationStatus(c.Request.Context(), query)
+	if err != nil {
+		h.logger.Error("获取认证状态失败",
+			zap.String("user_id", userID),
+			zap.Error(err),
+		)
+		h.response.BadRequest(c, err.Error())
+		return
+	}
+
+	h.response.Success(c, result, "获取认证状态成功")
+}
+
+// GetProgressStats 获取进度统计
+// @Summary 获取进度统计
+// @Description 获取认证申请的进度统计数据
+// @Tags 企业认证
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Success 200 {object} map[string]interface{} "获取进度统计成功"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/certification/stats [get]
+func (h *CertificationHandler) GetProgressStats(c *gin.Context) {
+	// 这里应该实现获取进度统计的逻辑
+	// 暂时返回空数据
+	h.response.Success(c, map[string]interface{}{
+		"total_applications": 0,
+		"pending":            0,
+		"in_progress":        0,
+		"completed":          0,
+		"rejected":           0,
+	}, "获取进度统计成功")
+}
+
+// GetCertificationProgress 获取认证进度
+// @Summary 获取认证进度
+// @Description 获取当前用户的认证申请详细进度信息
+// @Tags 企业认证
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Success 200 {object} map[string]interface{} "获取认证进度成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 404 {object} map[string]interface{} "认证申请不存在"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/certification/progress [get]
+func (h *CertificationHandler) GetCertificationProgress(c *gin.Context) {
+	userID := c.GetString("user_id")
+	if userID == "" {
+		h.response.Unauthorized(c, "用户未认证")
+		return
+	}
+
+	result, err := h.appService.GetCertificationProgress(c.Request.Context(), userID)
+	if err != nil {
+		h.logger.Error("获取认证进度失败",
+			zap.String("user_id", userID),
+			zap.Error(err),
+		)
+		h.response.BadRequest(c, err.Error())
+		return
+	}
+
+	h.response.Success(c, result, "获取认证进度成功")
+}
+
+// SubmitEnterpriseInfo 提交企业信息
+// @Summary 提交企业信息
+// @Description 提交企业基本信息，包括企业名称、统一社会信用代码、法定代表人信息等
+// @Tags 企业认证
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Param request body commands.SubmitEnterpriseInfoCommand true "企业信息"
+// @Success 200 {object} responses.CertificationResponse "企业信息提交成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/certification/enterprise-info [post]
+func (h *CertificationHandler) SubmitEnterpriseInfo(c *gin.Context) {
+	userID := c.GetString("user_id")
+	if userID == "" {
+		h.response.Unauthorized(c, "用户未认证")
+		return
+	}
+
+	var cmd commands.SubmitEnterpriseInfoCommand
+	if err := c.ShouldBindJSON(&cmd); err != nil {
+		h.logger.Error("参数绑定失败", zap.Error(err))
+		h.response.BadRequest(c, "请求参数格式错误")
+		return
+	}
+
+	cmd.UserID = userID
+
+	result, err := h.appService.SubmitEnterpriseInfo(c.Request.Context(), &cmd)
+	if err != nil {
+		h.logger.Error("提交企业信息失败",
+			zap.String("user_id", userID),
+			zap.Error(err),
+		)
+		h.response.BadRequest(c, err.Error())
+		return
+	}
+
+	h.response.Success(c, result, "企业信息提交成功")
+}
+
+// InitiateFaceVerify 发起人脸验证
+// @Summary 发起人脸验证
+// @Description 发起企业法人人脸验证流程
+// @Tags 企业认证
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Param request body commands.InitiateFaceVerifyCommand true "人脸验证请求"
+// @Success 200 {object} responses.FaceVerifyResponse "人脸验证发起成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/certification/face-verify [post]
+func (h *CertificationHandler) InitiateFaceVerify(c *gin.Context) {
+	userID := c.GetString("user_id")
+	if userID == "" {
+		h.response.Unauthorized(c, "用户未认证")
+		return
+	}
+
+	var cmd commands.InitiateFaceVerifyCommand
+	if err := c.ShouldBindJSON(&cmd); err != nil {
+		h.logger.Error("参数绑定失败", zap.Error(err))
+		h.response.BadRequest(c, "请求参数格式错误")
+		return
+	}
+
+	// 根据用户ID获取认证申请
+	query := &queries.GetCertificationStatusQuery{UserID: userID}
+	certification, err := h.appService.GetCertificationStatus(c.Request.Context(), query)
+	if err != nil {
+		h.logger.Error("获取认证申请失败",
+			zap.String("user_id", userID),
+			zap.Error(err),
+		)
+		h.response.BadRequest(c, err.Error())
+		return
+	}
+
+	// 如果用户没有认证申请，返回错误
+	if certification.ID == "" {
+		h.response.BadRequest(c, "用户尚未创建认证申请")
+		return
+	}
+
+	cmd.CertificationID = certification.ID
+
+	result, err := h.appService.InitiateFaceVerify(c.Request.Context(), &cmd)
+	if err != nil {
+		h.logger.Error("发起人脸验证失败",
+			zap.String("certification_id", certification.ID),
+			zap.String("user_id", userID),
+			zap.Error(err),
+		)
+		h.response.BadRequest(c, err.Error())
+		return
+	}
+
+	h.response.Success(c, result, "人脸验证发起成功")
+}
+
+// ApplyContract 申请合同
+// @Summary 申请合同
+// @Description 申请企业认证合同
+// @Tags 企业认证
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Success 200 {object} responses.CertificationResponse "合同申请成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/certification/contract [post]
+func (h *CertificationHandler) ApplyContract(c *gin.Context) {
+	userID := c.GetString("user_id")
+	if userID == "" {
+		h.response.Unauthorized(c, "用户未认证")
+		return
+	}
+
+	result, err := h.appService.ApplyContract(c.Request.Context(), userID)
+	if err != nil {
+		h.logger.Error("申请合同失败",
+			zap.String("user_id", userID),
+			zap.Error(err),
+		)
+		h.response.BadRequest(c, err.Error())
+		return
+	}
+
+	h.response.Success(c, result, "合同申请成功")
+}
+
+// GetCertificationDetails 获取认证详情
+// @Summary 获取认证详情
+// @Description 获取当前用户的认证申请详细信息
+// @Tags 企业认证
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Success 200 {object} responses.CertificationResponse "获取认证详情成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 404 {object} map[string]interface{} "认证申请不存在"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/certification/details [get]
+func (h *CertificationHandler) GetCertificationDetails(c *gin.Context) {
+	userID := c.GetString("user_id")
+	if userID == "" {
+		h.response.Unauthorized(c, "用户未认证")
+		return
+	}
+
+	query := &queries.GetCertificationDetailsQuery{
+		UserID: userID,
+	}
+
+	result, err := h.appService.GetCertificationDetails(c.Request.Context(), query)
+	if err != nil {
+		h.logger.Error("获取认证详情失败",
+			zap.String("user_id", userID),
+			zap.Error(err),
+		)
+		h.response.BadRequest(c, err.Error())
+		return
+	}
+
+	h.response.Success(c, result, "获取认证详情成功")
+}
+
+// RetryStep 重试步骤
+// @Summary 重试认证步骤
+// @Description 重新执行指定的认证步骤
+// @Tags 企业认证
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Param step path string true "步骤名称"
+// @Success 200 {object} map[string]interface{} "步骤重试成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/certification/retry/{step} [post]
+func (h *CertificationHandler) RetryStep(c *gin.Context) {
+	userID := c.GetString("user_id")
+	if userID == "" {
+		h.response.Unauthorized(c, "用户未认证")
+		return
+	}
+
+	step := c.Param("step")
+	if step == "" {
+		h.response.BadRequest(c, "步骤名称不能为空")
+		return
+	}
+
+	var result interface{}
+	var err error
+
+	switch step {
+	case "face_verify":
+		result, err = h.appService.RetryFaceVerify(c.Request.Context(), userID)
+	case "contract_sign":
+		result, err = h.appService.RetryContractSign(c.Request.Context(), userID)
+	default:
+		h.response.BadRequest(c, "不支持的步骤类型")
+		return
+	}
+
+	if err != nil {
+		h.logger.Error("重试认证步骤失败",
+			zap.String("user_id", userID),
+			zap.String("step", step),
+			zap.Error(err),
+		)
+		h.response.BadRequest(c, err.Error())
+		return
+	}
+
+	h.response.Success(c, result, "认证步骤重试成功")
+}
+
+// GetLicenseOCRResult 获取营业执照OCR识别结果
+// @Summary 获取营业执照OCR识别结果
+// @Description 根据上传记录ID获取OCR识别结果
+// @Tags 企业认证
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Param record_id path string true "上传记录ID"
+// @Success 200 {object} responses.UploadLicenseResponse "获取OCR结果成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 404 {object} map[string]interface{} "记录不存在"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/certification/license/{record_id}/ocr-result [get]
+func (h *CertificationHandler) GetLicenseOCRResult(c *gin.Context) {
+	userID := c.GetString("user_id")
+	if userID == "" {
+		h.response.Unauthorized(c, "用户未认证")
+		return
+	}
+
+	recordID := c.Param("record_id")
+	if recordID == "" {
+		h.response.BadRequest(c, "上传记录ID不能为空")
+		return
+	}
+
+	result, err := h.appService.GetLicenseOCRResult(c.Request.Context(), recordID)
+	if err != nil {
+		h.logger.Error("获取OCR结果失败",
+			zap.String("user_id", userID),
+			zap.String("record_id", recordID),
+			zap.Error(err),
+		)
+		h.response.BadRequest(c, err.Error())
+		return
+	}
+
+	h.response.Success(c, result, "获取OCR结果成功")
+}

internal/infrastructure/http/handlers/finance_handler.go

@@ -0,0 +1,429 @@
+package handlers
+
+import (
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+
+	"tyapi-server/internal/application/finance"
+	"tyapi-server/internal/application/finance/dto/commands"
+	"tyapi-server/internal/application/finance/dto/queries"
+	"tyapi-server/internal/shared/interfaces"
+)
+
+// FinanceHandler 财务HTTP处理器
+type FinanceHandler struct {
+	appService      finance.FinanceApplicationService
+	responseBuilder interfaces.ResponseBuilder
+	logger          *zap.Logger
+}
+
+// NewFinanceHandler 创建财务HTTP处理器
+func NewFinanceHandler(
+	appService finance.FinanceApplicationService,
+	responseBuilder interfaces.ResponseBuilder,
+	logger *zap.Logger,
+) *FinanceHandler {
+	return &FinanceHandler{
+		appService:      appService,
+		responseBuilder: responseBuilder,
+		logger:          logger,
+	}
+}
+
+// CreateWallet 创建钱包
+// @Summary 创建钱包
+// @Description 为用户创建新的钱包账户
+// @Tags 钱包管理
+// @Accept json
+// @Produce json
+// @Param request body commands.CreateWalletCommand true "创建钱包请求"
+// @Success 201 {object} responses.WalletResponse "钱包创建成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 409 {object} map[string]interface{} "钱包已存在"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/finance/wallet [post]
+func (h *FinanceHandler) CreateWallet(c *gin.Context) {
+	var cmd commands.CreateWalletCommand
+	if err := c.ShouldBindJSON(&cmd); err != nil {
+		h.responseBuilder.BadRequest(c, "请求参数错误")
+		return
+	}
+
+	response, err := h.appService.CreateWallet(c.Request.Context(), &cmd)
+	if err != nil {
+		h.logger.Error("创建钱包失败", zap.Error(err))
+		h.responseBuilder.BadRequest(c, err.Error())
+		return
+	}
+
+	h.responseBuilder.Created(c, response, "钱包创建成功")
+}
+
+// GetWallet 获取钱包信息
+// @Summary 获取钱包信息
+// @Description 获取当前用户的钱包详细信息
+// @Tags 钱包管理
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Success 200 {object} responses.WalletResponse "获取钱包信息成功"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 404 {object} map[string]interface{} "钱包不存在"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/finance/wallet [get]
+func (h *FinanceHandler) GetWallet(c *gin.Context) {
+	userID := c.GetString("user_id")
+	if userID == "" {
+		h.responseBuilder.Unauthorized(c, "用户未认证")
+		return
+	}
+
+	query := &queries.GetWalletInfoQuery{UserID: userID}
+	result, err := h.appService.GetWallet(c.Request.Context(), query)
+	if err != nil {
+		h.logger.Error("获取钱包信息失败",
+			zap.String("user_id", userID),
+			zap.Error(err),
+		)
+		h.responseBuilder.BadRequest(c, err.Error())
+		return
+	}
+
+	h.responseBuilder.Success(c, result, "获取钱包信息成功")
+}
+
+// UpdateWallet 更新钱包
+// @Summary 更新钱包信息
+// @Description 更新当前用户的钱包基本信息
+// @Tags 钱包管理
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Param request body commands.UpdateWalletCommand true "更新钱包请求"
+// @Success 200 {object} map[string]interface{} "钱包更新成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/finance/wallet [put]
+func (h *FinanceHandler) UpdateWallet(c *gin.Context) {
+	userID := c.GetString("user_id")
+	if userID == "" {
+		h.responseBuilder.Unauthorized(c, "用户未认证")
+		return
+	}
+
+	var cmd commands.UpdateWalletCommand
+	if err := c.ShouldBindJSON(&cmd); err != nil {
+		h.responseBuilder.BadRequest(c, "请求参数错误")
+		return
+	}
+
+	cmd.UserID = userID
+
+	err := h.appService.UpdateWallet(c.Request.Context(), &cmd)
+	if err != nil {
+		h.logger.Error("更新钱包失败",
+			zap.String("user_id", userID),
+			zap.Error(err),
+		)
+		h.responseBuilder.BadRequest(c, err.Error())
+		return
+	}
+
+	h.responseBuilder.Success(c, nil, "钱包更新成功")
+}
+
+// Recharge 充值
+// @Summary 钱包充值
+// @Description 为钱包进行充值操作
+// @Tags 钱包管理
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Param request body commands.RechargeWalletCommand true "充值请求"
+// @Success 200 {object} responses.TransactionResponse "充值成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/finance/wallet/recharge [post]
+func (h *FinanceHandler) Recharge(c *gin.Context) {
+	userID := c.GetString("user_id")
+	if userID == "" {
+		h.responseBuilder.Unauthorized(c, "用户未认证")
+		return
+	}
+
+	var cmd commands.RechargeWalletCommand
+	if err := c.ShouldBindJSON(&cmd); err != nil {
+		h.responseBuilder.BadRequest(c, "请求参数错误")
+		return
+	}
+
+	cmd.UserID = userID
+
+	result, err := h.appService.Recharge(c.Request.Context(), &cmd)
+	if err != nil {
+		h.logger.Error("充值失败",
+			zap.String("user_id", userID),
+			zap.Error(err),
+		)
+		h.responseBuilder.BadRequest(c, err.Error())
+		return
+	}
+
+	h.responseBuilder.Success(c, result, "充值成功")
+}
+
+// Withdraw 提现
+// @Summary 钱包提现
+// @Description 从钱包进行提现操作
+// @Tags 钱包管理
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Param request body commands.WithdrawWalletCommand true "提现请求"
+// @Success 200 {object} responses.TransactionResponse "提现申请已提交"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/finance/wallet/withdraw [post]
+func (h *FinanceHandler) Withdraw(c *gin.Context) {
+	userID := c.GetString("user_id")
+	if userID == "" {
+		h.responseBuilder.Unauthorized(c, "用户未认证")
+		return
+	}
+
+	var cmd commands.WithdrawWalletCommand
+	if err := c.ShouldBindJSON(&cmd); err != nil {
+		h.responseBuilder.BadRequest(c, "请求参数错误")
+		return
+	}
+
+	cmd.UserID = userID
+
+	result, err := h.appService.Withdraw(c.Request.Context(), &cmd)
+	if err != nil {
+		h.logger.Error("提现失败",
+			zap.String("user_id", userID),
+			zap.Error(err),
+		)
+		h.responseBuilder.BadRequest(c, err.Error())
+		return
+	}
+
+	h.responseBuilder.Success(c, result, "提现申请已提交")
+}
+
+// WalletTransaction 钱包交易
+// @Summary 钱包交易
+// @Description 执行钱包内部交易操作
+// @Tags 钱包管理
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Param request body commands.WalletTransactionCommand true "交易请求"
+// @Success 200 {object} responses.TransactionResponse "交易成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/finance/wallet/transaction [post]
+func (h *FinanceHandler) WalletTransaction(c *gin.Context) {
+	userID := c.GetString("user_id")
+	if userID == "" {
+		h.responseBuilder.Unauthorized(c, "用户未认证")
+		return
+	}
+
+	var cmd commands.WalletTransactionCommand
+	if err := c.ShouldBindJSON(&cmd); err != nil {
+		h.responseBuilder.BadRequest(c, "请求参数错误")
+		return
+	}
+
+	cmd.UserID = userID
+
+	result, err := h.appService.WalletTransaction(c.Request.Context(), &cmd)
+	if err != nil {
+		h.logger.Error("钱包交易失败",
+			zap.String("user_id", userID),
+			zap.Error(err),
+		)
+		h.responseBuilder.BadRequest(c, err.Error())
+		return
+	}
+
+	h.responseBuilder.Success(c, result, "交易成功")
+}
+
+// GetWalletStats 获取钱包统计
+// @Summary 获取钱包统计
+// @Description 获取钱包相关的统计数据
+// @Tags 钱包管理
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Success 200 {object} responses.WalletStatsResponse "获取钱包统计成功"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/finance/wallet/stats [get]
+func (h *FinanceHandler) GetWalletStats(c *gin.Context) {
+	userID := c.GetString("user_id")
+	if userID == "" {
+		h.responseBuilder.Unauthorized(c, "用户未认证")
+		return
+	}
+
+	result, err := h.appService.GetWalletStats(c.Request.Context())
+	if err != nil {
+		h.logger.Error("获取钱包统计失败",
+			zap.String("user_id", userID),
+			zap.Error(err),
+		)
+		h.responseBuilder.InternalError(c, "获取钱包统计失败")
+		return
+	}
+
+	h.responseBuilder.Success(c, result, "获取钱包统计成功")
+}
+
+// CreateUserSecrets 创建用户密钥
+// @Summary 创建用户密钥
+// @Description 为用户创建API访问密钥
+// @Tags 用户密钥管理
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Param request body commands.CreateUserSecretsCommand true "创建密钥请求"
+// @Success 201 {object} responses.UserSecretsResponse "用户密钥创建成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 409 {object} map[string]interface{} "密钥已存在"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/finance/secrets [post]
+func (h *FinanceHandler) CreateUserSecrets(c *gin.Context) {
+	userID := c.GetString("user_id")
+	if userID == "" {
+		h.responseBuilder.Unauthorized(c, "用户未认证")
+		return
+	}
+
+	var cmd commands.CreateUserSecretsCommand
+	if err := c.ShouldBindJSON(&cmd); err != nil {
+		h.responseBuilder.BadRequest(c, "请求参数错误")
+		return
+	}
+
+	cmd.UserID = userID
+
+	result, err := h.appService.CreateUserSecrets(c.Request.Context(), &cmd)
+	if err != nil {
+		h.logger.Error("创建用户密钥失败",
+			zap.String("user_id", userID),
+			zap.Error(err),
+		)
+		h.responseBuilder.BadRequest(c, err.Error())
+		return
+	}
+
+	h.responseBuilder.Created(c, result, "用户密钥创建成功")
+}
+
+// GetUserSecrets 获取用户密钥
+// @Summary 获取用户密钥
+// @Description 获取当前用户的API访问密钥信息
+// @Tags 用户密钥管理
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Success 200 {object} responses.UserSecretsResponse "获取用户密钥成功"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 404 {object} map[string]interface{} "密钥不存在"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/finance/secrets [get]
+func (h *FinanceHandler) GetUserSecrets(c *gin.Context) {
+	userID := c.GetString("user_id")
+	if userID == "" {
+		h.responseBuilder.Unauthorized(c, "用户未认证")
+		return
+	}
+
+	query := &queries.GetUserSecretsQuery{UserID: userID}
+	result, err := h.appService.GetUserSecrets(c.Request.Context(), query)
+	if err != nil {
+		h.logger.Error("获取用户密钥失败",
+			zap.String("user_id", userID),
+			zap.Error(err),
+		)
+		h.responseBuilder.BadRequest(c, err.Error())
+		return
+	}
+
+	h.responseBuilder.Success(c, result, "获取用户密钥成功")
+}
+
+// RegenerateAccessKey 重新生成访问密钥
+// @Summary 重新生成访问密钥
+// @Description 重新生成用户的API访问密钥
+// @Tags 用户密钥管理
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Success 200 {object} responses.UserSecretsResponse "访问密钥重新生成成功"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 404 {object} map[string]interface{} "密钥不存在"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/finance/secrets/regenerate [post]
+func (h *FinanceHandler) RegenerateAccessKey(c *gin.Context) {
+	userID := c.GetString("user_id")
+	if userID == "" {
+		h.responseBuilder.Unauthorized(c, "用户未认证")
+		return
+	}
+
+	cmd := &commands.RegenerateAccessKeyCommand{UserID: userID}
+	result, err := h.appService.RegenerateAccessKey(c.Request.Context(), cmd)
+	if err != nil {
+		h.logger.Error("重新生成访问密钥失败",
+			zap.String("user_id", userID),
+			zap.Error(err),
+		)
+		h.responseBuilder.BadRequest(c, err.Error())
+		return
+	}
+
+	h.responseBuilder.Success(c, result, "访问密钥重新生成成功")
+}
+
+// DeactivateUserSecrets 停用用户密钥
+// @Summary 停用用户密钥
+// @Description 停用用户的API访问密钥
+// @Tags 用户密钥管理
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Success 200 {object} map[string]interface{} "用户密钥停用成功"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 404 {object} map[string]interface{} "密钥不存在"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/finance/secrets/deactivate [post]
+func (h *FinanceHandler) DeactivateUserSecrets(c *gin.Context) {
+	userID := c.GetString("user_id")
+	if userID == "" {
+		h.responseBuilder.Unauthorized(c, "用户未认证")
+		return
+	}
+
+	cmd := &commands.DeactivateUserSecretsCommand{UserID: userID}
+	err := h.appService.DeactivateUserSecrets(c.Request.Context(), cmd)
+	if err != nil {
+		h.logger.Error("停用用户密钥失败",
+			zap.String("user_id", userID),
+			zap.Error(err),
+		)
+		h.responseBuilder.BadRequest(c, err.Error())
+		return
+	}
+
+	h.responseBuilder.Success(c, nil, "用户密钥停用成功")
+}

internal/infrastructure/http/handlers/user_handler.go

@@ -0,0 +1,224 @@
+package handlers
+
+import (
+	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
+
+	"tyapi-server/internal/application/user"
+	"tyapi-server/internal/application/user/dto/commands"
+	"tyapi-server/internal/shared/interfaces"
+	"tyapi-server/internal/shared/middleware"
+)
+
+// UserHandler 用户HTTP处理器
+type UserHandler struct {
+	appService user.UserApplicationService
+	response   interfaces.ResponseBuilder
+	validator  interfaces.RequestValidator
+	logger     *zap.Logger
+	jwtAuth    *middleware.JWTAuthMiddleware
+}
+
+// NewUserHandler 创建用户处理器
+func NewUserHandler(
+	appService user.UserApplicationService,
+	response interfaces.ResponseBuilder,
+	validator interfaces.RequestValidator,
+	logger *zap.Logger,
+	jwtAuth *middleware.JWTAuthMiddleware,
+) *UserHandler {
+	return &UserHandler{
+		appService: appService,
+		response:   response,
+		validator:  validator,
+		logger:     logger,
+		jwtAuth:    jwtAuth,
+	}
+}
+
+// SendCode 发送验证码
+// @Summary 发送短信验证码
+// @Description 向指定手机号发送验证码，支持注册、登录、修改密码等场景
+// @Tags 用户认证
+// @Accept json
+// @Produce json
+// @Param request body commands.SendCodeCommand true "发送验证码请求"
+// @Success 200 {object} map[string]interface{} "验证码发送成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 429 {object} map[string]interface{} "请求频率限制"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/users/send-code [post]
+func (h *UserHandler) SendCode(c *gin.Context) {
+	var cmd commands.SendCodeCommand
+	if err := h.validator.BindAndValidate(c, &cmd); err != nil {
+		return
+	}
+
+	clientIP := c.ClientIP()
+	userAgent := c.GetHeader("User-Agent")
+
+	if err := h.appService.SendCode(c.Request.Context(), &cmd, clientIP, userAgent); err != nil {
+		h.response.BadRequest(c, err.Error())
+		return
+	}
+
+	h.response.Success(c, nil, "验证码发送成功")
+}
+
+// Register 用户注册
+// @Summary 用户注册
+// @Description 使用手机号、密码和验证码进行用户注册，需要确认密码
+// @Tags 用户认证
+// @Accept json
+// @Produce json
+// @Param request body commands.RegisterUserCommand true "用户注册请求"
+// @Success 201 {object} responses.RegisterUserResponse "注册成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误或验证码无效"
+// @Failure 409 {object} map[string]interface{} "手机号已存在"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/users/register [post]
+func (h *UserHandler) Register(c *gin.Context) {
+	var cmd commands.RegisterUserCommand
+	if err := h.validator.BindAndValidate(c, &cmd); err != nil {
+		return
+	}
+
+	resp, err := h.appService.Register(c.Request.Context(), &cmd)
+	if err != nil {
+		h.logger.Error("注册用户失败", zap.Error(err))
+		h.response.BadRequest(c, err.Error())
+		return
+	}
+
+	h.response.Created(c, resp, "用户注册成功")
+}
+
+// LoginWithPassword 密码登录
+// @Summary 用户密码登录
+// @Description 使用手机号和密码进行用户登录，返回JWT令牌
+// @Tags 用户认证
+// @Accept json
+// @Produce json
+// @Param request body commands.LoginWithPasswordCommand true "密码登录请求"
+// @Success 200 {object} responses.LoginUserResponse "登录成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 401 {object} map[string]interface{} "用户名或密码错误"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/users/login-password [post]
+func (h *UserHandler) LoginWithPassword(c *gin.Context) {
+	var cmd commands.LoginWithPasswordCommand
+	if err := h.validator.BindAndValidate(c, &cmd); err != nil {
+		return
+	}
+
+	resp, err := h.appService.LoginWithPassword(c.Request.Context(), &cmd)
+	if err != nil {
+		h.logger.Error("密码登录失败", zap.Error(err))
+		h.response.Unauthorized(c, "用户名或密码错误")
+		return
+	}
+
+	h.response.Success(c, resp, "登录成功")
+}
+
+// LoginWithSMS 短信验证码登录
+// @Summary 用户短信验证码登录
+// @Description 使用手机号和短信验证码进行用户登录，返回JWT令牌
+// @Tags 用户认证
+// @Accept json
+// @Produce json
+// @Param request body commands.LoginWithSMSCommand true "短信登录请求"
+// @Success 200 {object} responses.LoginUserResponse "登录成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误或验证码无效"
+// @Failure 401 {object} map[string]interface{} "认证失败"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/users/login-sms [post]
+func (h *UserHandler) LoginWithSMS(c *gin.Context) {
+	var cmd commands.LoginWithSMSCommand
+	if err := h.validator.BindAndValidate(c, &cmd); err != nil {
+		return
+	}
+
+	resp, err := h.appService.LoginWithSMS(c.Request.Context(), &cmd)
+	if err != nil {
+		h.logger.Error("短信登录失败", zap.Error(err))
+		h.response.Unauthorized(c, err.Error())
+		return
+	}
+
+	h.response.Success(c, resp, "登录成功")
+}
+
+// GetProfile 获取当前用户信息
+// @Summary 获取当前用户信息
+// @Description 根据JWT令牌获取当前登录用户的详细信息
+// @Tags 用户管理
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Success 200 {object} responses.UserProfileResponse "用户信息"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 404 {object} map[string]interface{} "用户不存在"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/users/me [get]
+func (h *UserHandler) GetProfile(c *gin.Context) {
+	userID := h.getCurrentUserID(c)
+	if userID == "" {
+		h.response.Unauthorized(c, "用户未认证")
+		return
+	}
+
+	resp, err := h.appService.GetUserProfile(c.Request.Context(), userID)
+	if err != nil {
+		h.logger.Error("获取用户资料失败", zap.Error(err))
+		h.response.NotFound(c, "用户不存在")
+		return
+	}
+
+	h.response.Success(c, resp, "获取用户资料成功")
+}
+
+// ChangePassword 修改密码
+// @Summary 修改密码
+// @Description 使用旧密码、新密码确认和验证码修改当前用户的密码
+// @Tags 用户管理
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Param request body commands.ChangePasswordCommand true "修改密码请求"
+// @Success 200 {object} map[string]interface{} "密码修改成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误或验证码无效"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/users/me/password [put]
+func (h *UserHandler) ChangePassword(c *gin.Context) {
+	userID := h.getCurrentUserID(c)
+	if userID == "" {
+		h.response.Unauthorized(c, "用户未认证")
+		return
+	}
+
+	var cmd commands.ChangePasswordCommand
+	if err := h.validator.BindAndValidate(c, &cmd); err != nil {
+		return
+	}
+	cmd.UserID = userID
+
+	if err := h.appService.ChangePassword(c.Request.Context(), &cmd); err != nil {
+		h.logger.Error("修改密码失败", zap.Error(err))
+		h.response.BadRequest(c, err.Error())
+		return
+	}
+
+	h.response.Success(c, nil, "密码修改成功")
+}
+
+// getCurrentUserID 获取当前用户ID
+func (h *UserHandler) getCurrentUserID(c *gin.Context) string {
+	if userID, exists := c.Get("user_id"); exists {
+		if id, ok := userID.(string); ok {
+			return id
+		}
+	}
+	return ""
+}

internal/infrastructure/http/routes/admin_routes.go

@@ -0,0 +1,58 @@
+package routes
+
+import (
+	"tyapi-server/internal/infrastructure/http/handlers"
+	sharedhttp "tyapi-server/internal/shared/http"
+	"tyapi-server/internal/shared/middleware"
+
+	"go.uber.org/zap"
+)
+
+// AdminRoutes 管理员路由注册器
+type AdminRoutes struct {
+	handler        *handlers.AdminHandler
+	authMiddleware *middleware.JWTAuthMiddleware
+	logger         *zap.Logger
+}
+
+// NewAdminRoutes 创建管理员路由注册器
+func NewAdminRoutes(
+	handler *handlers.AdminHandler,
+	authMiddleware *middleware.JWTAuthMiddleware,
+	logger *zap.Logger,
+) *AdminRoutes {
+	return &AdminRoutes{
+		handler:        handler,
+		authMiddleware: authMiddleware,
+		logger:         logger,
+	}
+}
+
+// Register 注册管理员相关路由
+func (r *AdminRoutes) Register(router *sharedhttp.GinRouter) {
+	// 管理员路由组
+	engine := router.GetEngine()
+	adminGroup := engine.Group("/api/v1/admin")
+	{
+		// 认证相关路由（无需认证）
+		authGroup := adminGroup.Group("/auth")
+		{
+			authGroup.POST("/login", r.handler.Login)
+		}
+
+		// 管理员管理路由（需要认证）
+		authenticated := adminGroup.Group("")
+		authenticated.Use(r.authMiddleware.Handle())
+		{
+			authenticated.POST("", r.handler.CreateAdmin)                    // 创建管理员
+			authenticated.GET("", r.handler.ListAdmins)                      // 获取管理员列表
+			authenticated.GET("/stats", r.handler.GetAdminStats)             // 获取统计信息
+			authenticated.GET("/:id", r.handler.GetAdminByID)                // 获取管理员详情
+			authenticated.PUT("/:id", r.handler.UpdateAdmin)                 // 更新管理员
+			authenticated.DELETE("/:id", r.handler.DeleteAdmin)              // 删除管理员
+			authenticated.POST("/change-password", r.handler.ChangePassword) // 修改密码
+		}
+	}
+
+	r.logger.Info("管理员路由注册完成")
+}

internal/infrastructure/http/routes/certification_routes.go

@@ -0,0 +1,73 @@
+package routes
+
+import (
+	"tyapi-server/internal/infrastructure/http/handlers"
+	sharedhttp "tyapi-server/internal/shared/http"
+	"tyapi-server/internal/shared/middleware"
+
+	"go.uber.org/zap"
+)
+
+// CertificationRoutes 认证路由注册器
+type CertificationRoutes struct {
+	certificationHandler *handlers.CertificationHandler
+	authMiddleware       *middleware.JWTAuthMiddleware
+	logger               *zap.Logger
+}
+
+// NewCertificationRoutes 创建认证路由注册器
+func NewCertificationRoutes(
+	certificationHandler *handlers.CertificationHandler,
+	authMiddleware *middleware.JWTAuthMiddleware,
+	logger *zap.Logger,
+) *CertificationRoutes {
+	return &CertificationRoutes{
+		certificationHandler: certificationHandler,
+		authMiddleware:       authMiddleware,
+		logger:               logger,
+	}
+}
+
+// Register 注册认证相关路由
+func (r *CertificationRoutes) Register(router *sharedhttp.GinRouter) {
+	// 认证相关路由组，需要用户认证
+	engine := router.GetEngine()
+	certificationGroup := engine.Group("/api/v1/certification")
+	certificationGroup.Use(r.authMiddleware.Handle())
+	{
+		// 创建认证申请
+		certificationGroup.POST("", r.certificationHandler.CreateCertification)
+
+		// 营业执照上传
+		certificationGroup.POST("/upload-license", r.certificationHandler.UploadBusinessLicense)
+
+		// 获取OCR识别结果
+		certificationGroup.GET("/license/:record_id/ocr-result", r.certificationHandler.GetLicenseOCRResult)
+
+		// 获取认证状态
+		certificationGroup.GET("/status", r.certificationHandler.GetCertificationStatus)
+
+		// 获取进度统计
+		certificationGroup.GET("/stats", r.certificationHandler.GetProgressStats)
+
+		// 获取认证进度
+		certificationGroup.GET("/progress", r.certificationHandler.GetCertificationProgress)
+
+		// 提交企业信息
+		certificationGroup.POST("/enterprise-info", r.certificationHandler.SubmitEnterpriseInfo)
+
+		// 发起人脸识别验证
+		certificationGroup.POST("/face-verify", r.certificationHandler.InitiateFaceVerify)
+
+		// 申请合同签署
+		certificationGroup.POST("/contract", r.certificationHandler.ApplyContract)
+
+		// 获取认证详情
+		certificationGroup.GET("/details", r.certificationHandler.GetCertificationDetails)
+
+		// 重试认证步骤
+		certificationGroup.POST("/retry/:step", r.certificationHandler.RetryStep)
+	}
+
+	r.logger.Info("认证路由注册完成")
+}

internal/infrastructure/http/routes/finance_routes.go

@@ -0,0 +1,61 @@
+package routes
+
+import (
+	"tyapi-server/internal/infrastructure/http/handlers"
+	sharedhttp "tyapi-server/internal/shared/http"
+	"tyapi-server/internal/shared/middleware"
+
+	"go.uber.org/zap"
+)
+
+// FinanceRoutes 财务路由注册器
+type FinanceRoutes struct {
+	financeHandler *handlers.FinanceHandler
+	authMiddleware *middleware.JWTAuthMiddleware
+	logger         *zap.Logger
+}
+
+// NewFinanceRoutes 创建财务路由注册器
+func NewFinanceRoutes(
+	financeHandler *handlers.FinanceHandler,
+	authMiddleware *middleware.JWTAuthMiddleware,
+	logger *zap.Logger,
+) *FinanceRoutes {
+	return &FinanceRoutes{
+		financeHandler: financeHandler,
+		authMiddleware: authMiddleware,
+		logger:         logger,
+	}
+}
+
+// Register 注册财务相关路由
+func (r *FinanceRoutes) Register(router *sharedhttp.GinRouter) {
+	// 财务路由组，需要用户认证
+	engine := router.GetEngine()
+	financeGroup := engine.Group("/api/v1/finance")
+	financeGroup.Use(r.authMiddleware.Handle())
+	{
+		// 钱包相关路由
+		walletGroup := financeGroup.Group("/wallet")
+		{
+			walletGroup.POST("", r.financeHandler.CreateWallet)                  // 创建钱包
+			walletGroup.GET("", r.financeHandler.GetWallet)                      // 获取钱包信息
+			walletGroup.PUT("", r.financeHandler.UpdateWallet)                   // 更新钱包
+			walletGroup.POST("/recharge", r.financeHandler.Recharge)             // 充值
+			walletGroup.POST("/withdraw", r.financeHandler.Withdraw)             // 提现
+			walletGroup.POST("/transaction", r.financeHandler.WalletTransaction) // 钱包交易
+			walletGroup.GET("/stats", r.financeHandler.GetWalletStats)           // 获取钱包统计
+		}
+
+		// 用户密钥相关路由
+		secretsGroup := financeGroup.Group("/secrets")
+		{
+			secretsGroup.POST("", r.financeHandler.CreateUserSecrets)                // 创建用户密钥
+			secretsGroup.GET("", r.financeHandler.GetUserSecrets)                    // 获取用户密钥
+			secretsGroup.POST("/regenerate", r.financeHandler.RegenerateAccessKey)   // 重新生成访问密钥
+			secretsGroup.POST("/deactivate", r.financeHandler.DeactivateUserSecrets) // 停用用户密钥
+		}
+	}
+
+	r.logger.Info("财务路由注册完成")
+}

internal/infrastructure/http/routes/user_routes.go

@@ -0,0 +1,53 @@
+package routes
+
+import (
+	"tyapi-server/internal/infrastructure/http/handlers"
+	sharedhttp "tyapi-server/internal/shared/http"
+	"tyapi-server/internal/shared/middleware"
+
+	"go.uber.org/zap"
+)
+
+// UserRoutes 用户路由注册器
+type UserRoutes struct {
+	handler        *handlers.UserHandler
+	authMiddleware *middleware.JWTAuthMiddleware
+	logger         *zap.Logger
+}
+
+// NewUserRoutes 创建用户路由注册器
+func NewUserRoutes(
+	handler *handlers.UserHandler,
+	authMiddleware *middleware.JWTAuthMiddleware,
+	logger *zap.Logger,
+) *UserRoutes {
+	return &UserRoutes{
+		handler:        handler,
+		authMiddleware: authMiddleware,
+		logger:         logger,
+	}
+}
+
+// Register 注册用户相关路由
+func (r *UserRoutes) Register(router *sharedhttp.GinRouter) {
+	// 用户域路由组
+	engine := router.GetEngine()
+	usersGroup := engine.Group("/api/v1/users")
+	{
+		// 公开路由（不需要认证）
+		usersGroup.POST("/send-code", r.handler.SendCode)               // 发送验证码
+		usersGroup.POST("/register", r.handler.Register)                // 用户注册
+		usersGroup.POST("/login-password", r.handler.LoginWithPassword) // 密码登录
+		usersGroup.POST("/login-sms", r.handler.LoginWithSMS)           // 短信验证码登录
+
+		// 需要认证的路由
+		authenticated := usersGroup.Group("")
+		authenticated.Use(r.authMiddleware.Handle())
+		{
+			authenticated.GET("/me", r.handler.GetProfile)              // 获取当前用户信息
+			authenticated.PUT("/me/password", r.handler.ChangePassword) // 修改密码
+		}
+	}
+
+	r.logger.Info("用户路由注册完成")
+}