基础架构

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 ""
+}