temp

2025-07-21 15:13:26 +08:00
parent 8ad1d7288e
commit b03129667a
41 changed files with 8497 additions and 3968 deletions
--- a/internal/infrastructure/http/handlers/certification_handler.go
+++ b/internal/infrastructure/http/handlers/certification_handler.go
@@ -1,10 +1,6 @@
 package handlers

 import (
-	"bytes"
-	"io"
-	"time"
-
 	"github.com/gin-gonic/gin"
 	"go.uber.org/zap"

@@ -12,157 +8,150 @@ import (
 	"tyapi-server/internal/application/certification/dto/commands"
 	"tyapi-server/internal/application/certification/dto/queries"
 	"tyapi-server/internal/shared/interfaces"
+	"tyapi-server/internal/shared/middleware"
 )

-// CertificationHandler 认证处理器
-// 负责处理HTTP请求，参数验证，调用应用服务，返回HTTP响应
+// CertificationHandler 认证HTTP处理器
 type CertificationHandler struct {
-	certAppService       certification.CertificationApplicationService
-	esignCallbackService certification.EsignCallbackApplicationService
-	response             interfaces.ResponseBuilder
-	validator            interfaces.RequestValidator
-	logger               *zap.Logger
+	appService certification.CertificationApplicationService
+	response   interfaces.ResponseBuilder
+	validator  interfaces.RequestValidator
+	logger     *zap.Logger
+	jwtAuth    *middleware.JWTAuthMiddleware
 }

 // NewCertificationHandler 创建认证处理器
 func NewCertificationHandler(
-	certAppService certification.CertificationApplicationService,
-	esignCallbackService certification.EsignCallbackApplicationService,
+	appService certification.CertificationApplicationService,
 	response interfaces.ResponseBuilder,
 	validator interfaces.RequestValidator,
 	logger *zap.Logger,
+	jwtAuth *middleware.JWTAuthMiddleware,
 ) *CertificationHandler {
 	return &CertificationHandler{
-		certAppService:       certAppService,
-		esignCallbackService: esignCallbackService,
-		response:             response,
-		validator:            validator,
-		logger:               logger,
+		appService: appService,
+		response:   response,
+		validator:  validator,
+		logger:     logger,
+		jwtAuth:    jwtAuth,
 	}
 }

-// GetCertificationStatus 获取认证状态
-// @Summary 获取认证状态
-// @Description 获取当前用户的认证状态信息，包括认证进度、当前状态等
-// @Tags 企业认证
+// ================ 认证申请管理 ================
+
+// CreateCertification 创建认证申请
+// @Summary 创建认证申请
+// @Description 为用户创建企业认证申请
+// @Tags 认证管理
 // @Accept json
 // @Produce json
 // @Security Bearer
-// @Success 200 {object} map[string]interface{} "获取认证状态成功"
-// @Failure 401 {object} map[string]interface{} "用户未登录"
+// @Param request body commands.CreateCertificationCommand true "创建认证申请请求"
+// @Success 201 {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 == "" {
+// @Router /api/v1/certifications [post]
+func (h *CertificationHandler) CreateCertification(c *gin.Context) {
+	var cmd commands.CreateCertificationCommand
+	cmd.UserID = h.getCurrentUserID(c)
+	if cmd.UserID == "" {
 		h.response.Unauthorized(c, "用户未登录")
 		return
 	}

-	query := &queries.GetCertificationStatusQuery{
-		UserID: userID,
-	}
-
-	result, err := h.certAppService.GetCertificationStatus(c.Request.Context(), query)
+	result, err := h.appService.CreateCertification(c.Request.Context(), &cmd)
 	if err != nil {
-		h.logger.Error("获取认证状态失败", zap.Error(err))
+		h.logger.Error("创建认证申请失败", zap.Error(err), zap.String("user_id", cmd.UserID))
 		h.response.BadRequest(c, err.Error())
 		return
 	}

-	h.response.Success(c, result, "获取认证状态成功")
+	h.response.Created(c, result, "认证申请创建成功")
 }

-// GetCertificationDetails 获取认证详情
+// GetCertification 获取认证详情
 // @Summary 获取认证详情
-// @Description 获取当前用户的详细认证信息，包括企业信息、认证记录等
-// @Tags 企业认证
+// @Description 根据认证ID获取认证详情
+// @Tags 认证管理
 // @Accept json
 // @Produce json
 // @Security Bearer
-// @Success 200 {object} map[string]interface{} "获取认证详情成功"
-// @Failure 401 {object} map[string]interface{} "用户未登录"
+// @Param id path string true "认证ID"
+// @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")
+// @Router /api/v1/certifications/{id} [get]
+func (h *CertificationHandler) GetCertification(c *gin.Context) {
+	userID := h.getCurrentUserID(c)
 	if userID == "" {
 		h.response.Unauthorized(c, "用户未登录")
 		return
 	}

-	query := &queries.GetCertificationDetailsQuery{
-		UserID: userID,
+	certificationID := c.Param("id")
+	if certificationID == "" {
+		h.response.BadRequest(c, "认证ID不能为空")
+		return
 	}

-	result, err := h.certAppService.GetCertificationDetails(c.Request.Context(), query)
+	query := &queries.GetCertificationQuery{
+		CertificationID: certificationID,
+		UserID:          userID,
+	}
+
+	result, err := h.appService.GetCertification(c.Request.Context(), query)
 	if err != nil {
-		h.logger.Error("获取认证详情失败", zap.Error(err))
-		h.response.BadRequest(c, err.Error())
+		h.logger.Error("获取认证详情失败", zap.Error(err), zap.String("certification_id", certificationID))
+		h.response.NotFound(c, "认证记录不存在")
 		return
 	}

 	h.response.Success(c, result, "获取认证详情成功")
 }

-// GetCertificationProgress 获取认证进度
-// @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/progress [get]
-func (h *CertificationHandler) GetCertificationProgress(c *gin.Context) {
-	userID := c.GetString("user_id")
-	if userID == "" {
-		h.response.Unauthorized(c, "用户未登录")
-		return
-	}
-
-	result, err := h.certAppService.GetCertificationProgress(c.Request.Context(), userID)
-	if err != nil {
-		h.logger.Error("获取认证进度失败", zap.Error(err))
-		h.response.BadRequest(c, err.Error())
-		return
-	}
-
-	h.response.Success(c, result, "获取认证进度成功")
-}
+// ================ 企业信息管理 ================

 // SubmitEnterpriseInfo 提交企业信息
 // @Summary 提交企业信息
-// @Description 提交企业四要素信息（企业名称、统一社会信用代码、法定代表人姓名、法定代表人身份证），完成企业信息验证。如果用户没有认证申请，系统会自动创建
-// @Tags 企业认证
+// @Description 提交企业认证所需的企业信息
+// @Tags 认证管理
 // @Accept json
 // @Produce json
 // @Security Bearer
-// @Param request body commands.SubmitEnterpriseInfoCommand true "企业信息提交请求"
-// @Success 200 {object} map[string]interface{} "企业信息提交成功"
-// @Failure 400 {object} map[string]interface{} "请求参数错误或验证码无效"
-// @Failure 401 {object} map[string]interface{} "用户未登录"
+// @Param id path string true "认证ID"
+// @Param request body commands.SubmitEnterpriseInfoCommand true "提交企业信息请求"
+// @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/submit-enterprise-info [post]
+// @Router /api/v1/certifications/{id}/enterprise-info [post]
 func (h *CertificationHandler) SubmitEnterpriseInfo(c *gin.Context) {
-	userID := c.GetString("user_id")
+	userID := h.getCurrentUserID(c)
 	if userID == "" {
 		h.response.Unauthorized(c, "用户未登录")
 		return
 	}

+	certificationID := c.Param("id")
+	if certificationID == "" {
+		h.response.BadRequest(c, "认证ID不能为空")
+		return
+	}
+
 	var cmd commands.SubmitEnterpriseInfoCommand
 	if err := h.validator.BindAndValidate(c, &cmd); err != nil {
 		return
 	}
-
+	cmd.CertificationID = certificationID
 	cmd.UserID = userID

-	result, err := h.certAppService.SubmitEnterpriseInfo(c.Request.Context(), &cmd)
+	result, err := h.appService.SubmitEnterpriseInfo(c.Request.Context(), &cmd)
 	if err != nil {
-		h.logger.Error("提交企业信息失败", zap.Error(err))
+		h.logger.Error("提交企业信息失败", zap.Error(err), zap.String("certification_id", certificationID))
 		h.response.BadRequest(c, err.Error())
 		return
 	}
@@ -170,57 +159,38 @@ func (h *CertificationHandler) SubmitEnterpriseInfo(c *gin.Context) {
 	h.response.Success(c, result, "企业信息提交成功")
 }

-// GetEnterpriseAuthURL 获取企业认证链接
-// @Summary 获取企业认证链接
-// @Description 获取e签宝企业认证链接，用户可通过该链接完成企业认证
-// @Tags 企业认证
+// ================ 合同管理 ================
+
+// ApplyContract 申请合同签署
+// @Summary 申请合同签署
+// @Description 申请企业认证合同签署
+// @Tags 认证管理
 // @Accept json
 // @Produce json
 // @Security Bearer
-// @Success 200 {object} map[string]interface{} "获取企业认证链接成功"
-// @Failure 401 {object} map[string]interface{} "用户未登录"
-// @Failure 400 {object} map[string]interface{} "企业信息未提交或认证状态异常"
+// @Param request body commands.ApplyContractCommand true "申请合同请求"
+// @Success 200 {object} responses.ContractSignUrlResponse "合同申请成功"
+// @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/enterprise-auth-url [get]
-func (h *CertificationHandler) GetEnterpriseAuthURL(c *gin.Context) {
-	userID := c.GetString("user_id")
-	if userID == "" {
-		h.response.Unauthorized(c, "用户未登录")
-		return
-	}
-
-	result, err := h.certAppService.GetEnterpriseAuthURL(c.Request.Context(), userID)
-	if err != nil {
-		h.logger.Error("获取企业认证链接失败", 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} map[string]interface{} "合同申请成功"
-// @Failure 401 {object} map[string]interface{} "用户未登录"
-// @Failure 400 {object} map[string]interface{} "企业认证未完成或合同申请失败"
-// @Failure 500 {object} map[string]interface{} "服务器内部错误"
-// @Router /api/v1/certification/apply-contract [post]
+// @Router /api/v1/certifications/apply-contract [post]
 func (h *CertificationHandler) ApplyContract(c *gin.Context) {
-	userID := c.GetString("user_id")
+	userID := h.getCurrentUserID(c)
 	if userID == "" {
 		h.response.Unauthorized(c, "用户未登录")
 		return
 	}

-	result, err := h.certAppService.ApplyContract(c.Request.Context(), userID)
+	var cmd commands.ApplyContractCommand
+	if err := h.validator.BindAndValidate(c, &cmd); err != nil {
+		return
+	}
+	cmd.UserID = userID
+
+	result, err := h.appService.ApplyContract(c.Request.Context(), &cmd)
 	if err != nil {
-		h.logger.Error("申请合同失败", zap.Error(err))
+		h.logger.Error("申请合同失败", zap.Error(err), zap.String("certification_id", cmd.CertificationID))
 		h.response.BadRequest(c, err.Error())
 		return
 	}
@@ -228,161 +198,282 @@ func (h *CertificationHandler) ApplyContract(c *gin.Context) {
 	h.response.Success(c, result, "合同申请成功")
 }

-// GetContractSignURL 获取合同签署链接
-// @Summary 获取合同签署链接
-// @Description 获取e签宝合同签署链接，用户可通过该链接完成合同签署
-// @Tags 企业认证
+// ================ 重试操作 ================
+
+// RetryOperation 重试操作
+// @Summary 重试操作
+// @Description 重试失败的企业认证或合同申请操作
+// @Tags 认证管理
 // @Accept json
 // @Produce json
 // @Security Bearer
-// @Success 200 {object} map[string]interface{} "获取合同签署链接成功"
-// @Failure 401 {object} map[string]interface{} "用户未登录"
-// @Failure 400 {object} map[string]interface{} "合同未申请或签署状态异常"
+// @Param request body commands.RetryOperationCommand true "重试操作请求"
+// @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/contract-sign-url [get]
-func (h *CertificationHandler) GetContractSignURL(c *gin.Context) {
-	userID := c.GetString("user_id")
+// @Router /api/v1/certifications/retry [post]
+func (h *CertificationHandler) RetryOperation(c *gin.Context) {
+	userID := h.getCurrentUserID(c)
 	if userID == "" {
 		h.response.Unauthorized(c, "用户未登录")
 		return
 	}

-	cmd := &commands.GetContractSignURLCommand{
-		UserID: userID,
+	var cmd commands.RetryOperationCommand
+	if err := h.validator.BindAndValidate(c, &cmd); err != nil {
+		return
 	}
+	cmd.UserID = userID

-	result, err := h.certAppService.GetContractSignURL(c.Request.Context(), cmd)
+	result, err := h.appService.RetryOperation(c.Request.Context(), &cmd)
 	if err != nil {
-		h.logger.Error("获取合同签署链接失败", zap.Error(err))
+		h.logger.Error("重试操作失败", zap.Error(err), zap.String("certification_id", cmd.CertificationID))
 		h.response.BadRequest(c, err.Error())
 		return
 	}

-	h.response.Success(c, result, "获取合同签署链接成功")
+	h.response.Success(c, result, "重试操作成功")
 }

-// EsignCallback e签宝回调
-// @Summary e签宝回调接口
-// @Description 接收e签宝认证和签署的回调通知
-// @Tags 企业认证
+// ================ 查询操作 ================
+
+// GetUserCertifications 获取用户认证列表
+// @Summary 获取用户认证列表
+// @Description 获取当前用户的认证申请列表
+// @Tags 认证管理
 // @Accept json
 // @Produce json
-// @Success 200 {object} map[string]interface{} "回调处理成功"
-// @Failure 400 {object} map[string]interface{} "回调参数错误"
+// @Security Bearer
+// @Param status query string false "认证状态"
+// @Param include_completed query bool false "是否包含已完成"
+// @Param include_failed query bool false "是否包含失败"
+// @Param page query int false "页码" default(1)
+// @Param page_size query int false "每页数量" default(10)
+// @Success 200 {object} responses.CertificationListResponse "获取用户认证列表成功"
+// @Failure 401 {object} map[string]interface{} "未认证"
 // @Failure 500 {object} map[string]interface{} "服务器内部错误"
-// @Router /api/v1/certification/esign-callback [post]
-func (h *CertificationHandler) EsignCallback(c *gin.Context) {
-	// 记录请求基本信息
-	h.logger.Info("收到e签宝回调请求",
-		zap.String("method", c.Request.Method),
-		zap.String("url", c.Request.URL.String()),
-		zap.String("remote_addr", c.ClientIP()),
-		zap.String("user_agent", c.GetHeader("User-Agent")),
-	)
-
-	// 记录所有请求头
-	headers := make(map[string]string)
-	for key, values := range c.Request.Header {
-		if len(values) > 0 {
-			headers[key] = values[0]
-		}
-	}
-	h.logger.Info("回调请求头信息", zap.Any("headers", headers))
-
-	// 记录URL查询参数
-	queryParams := make(map[string]string)
-	for key, values := range c.Request.URL.Query() {
-		if len(values) > 0 {
-			queryParams[key] = values[0]
-		}
-	}
-	if len(queryParams) > 0 {
-		h.logger.Info("回调URL查询参数", zap.Any("query_params", queryParams))
+// @Router /api/v1/certifications/user [get]
+func (h *CertificationHandler) GetUserCertifications(c *gin.Context) {
+	userID := h.getCurrentUserID(c)
+	if userID == "" {
+		h.response.Unauthorized(c, "用户未登录")
+		return
 	}

-	// 读取并记录请求体
-	var requestBody interface{}
-	var callbackData map[string]interface{}
-	if c.Request.Body != nil {
-		// 读取请求体
-		bodyBytes, err := c.GetRawData()
-		if err != nil {
-			h.logger.Error("读取回调请求体失败", zap.Error(err))
-			h.response.BadRequest(c, "读取请求体失败")
-			return
-		}
+	var query queries.GetUserCertificationsQuery
+	if err := h.validator.BindAndValidate(c, &query); err != nil {
+		return
+	}
+	query.UserID = userID

-		// 尝试解析为JSON
-		if err := c.ShouldBindJSON(&callbackData); err == nil {
-			requestBody = callbackData
-		} else {
-			// 如果不是JSON，记录原始字符串
-			requestBody = string(bodyBytes)
-			h.logger.Error("回调请求体不是有效的JSON格式", zap.Error(err))
-			h.response.BadRequest(c, "请求体格式错误")
-			return
-		}
-		h.logger.Info("回调请求体内容", zap.Any("body", requestBody))
-
-		// 重新设置请求体，以便后续处理
-		c.Request.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
+	result, err := h.appService.GetUserCertifications(c.Request.Context(), &query)
+	if err != nil {
+		h.logger.Error("获取用户认证列表失败", zap.Error(err), zap.String("user_id", userID))
+		h.response.BadRequest(c, err.Error())
+		return
 	}

-	// 记录Content-Type
-	contentType := c.GetHeader("Content-Type")
-	h.logger.Info("回调请求Content-Type", zap.String("content_type", contentType))
-
-	// 记录Content-Length
-	contentLength := c.GetHeader("Content-Length")
-	if contentLength != "" {
-		h.logger.Info("回调请求Content-Length", zap.String("content_length", contentLength))
-	}
-
-	// 记录时间戳
-	h.logger.Info("回调请求时间",
-		zap.Time("request_time", time.Now()),
-		zap.String("request_id", c.GetHeader("X-Request-ID")),
-	)
-
-	// 记录完整的请求信息摘要
-	h.logger.Info("e签宝回调完整信息摘要",
-		zap.String("method", c.Request.Method),
-		zap.String("url", c.Request.URL.String()),
-		zap.String("client_ip", c.ClientIP()),
-		zap.String("content_type", contentType),
-		zap.Any("headers", headers),
-		zap.Any("query_params", queryParams),
-		zap.Any("body", requestBody),
-	)
-
-	// 处理回调数据
-	if callbackData != nil {
-		// 构建请求头映射
-		headers := make(map[string]string)
-		for key, values := range c.Request.Header {
-			if len(values) > 0 {
-				headers[key] = values[0]
-			}
-		}
-
-		// 构建查询参数映射
-		queryParams := make(map[string]string)
-		for key, values := range c.Request.URL.Query() {
-			if len(values) > 0 {
-				queryParams[key] = values[0]
-			}
-		}
-
-		if err := h.esignCallbackService.HandleCallback(c.Request.Context(), callbackData, headers, queryParams); err != nil {
-			h.logger.Error("处理e签宝回调失败", zap.Error(err))
-			h.response.BadRequest(c, "回调处理失败: "+err.Error())
-			return
-		}
-	}
-
-	// 返回成功响应
-	c.JSON(200, map[string]interface{}{
-		"code": "200",
-		"msg":  "success",
-	})
+	h.response.Success(c, result, "获取用户认证列表成功")
+}
+
+// ListCertifications 获取认证列表（管理员）
+// @Summary 获取认证列表
+// @Description 管理员获取认证申请列表
+// @Tags 认证管理
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Param page query int false "页码" default(1)
+// @Param page_size query int false "每页数量" default(10)
+// @Param sort_by query string false "排序字段"
+// @Param sort_order query string false "排序方向" Enums(asc, desc)
+// @Param status query string false "认证状态"
+// @Param user_id query string false "用户ID"
+// @Param company_name query string false "公司名称"
+// @Param legal_person_name query string false "法人姓名"
+// @Param search_keyword query string false "搜索关键词"
+// @Success 200 {object} responses.CertificationListResponse "获取认证列表成功"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 403 {object} map[string]interface{} "权限不足"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/certifications [get]
+func (h *CertificationHandler) ListCertifications(c *gin.Context) {
+	userID := h.getCurrentUserID(c)
+	if userID == "" {
+		h.response.Unauthorized(c, "用户未登录")
+		return
+	}
+
+	var query queries.ListCertificationsQuery
+	if err := h.validator.BindAndValidate(c, &query); err != nil {
+		return
+	}
+
+	result, err := h.appService.ListCertifications(c.Request.Context(), &query)
+	if err != nil {
+		h.logger.Error("获取认证列表失败", zap.Error(err))
+		h.response.BadRequest(c, err.Error())
+		return
+	}
+
+	h.response.Success(c, result, "获取认证列表成功")
+}
+
+// GetCertificationStatistics 获取认证统计
+// @Summary 获取认证统计
+// @Description 获取认证相关的统计数据
+// @Tags 认证管理
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Param start_date query string true "开始日期" format(date)
+// @Param end_date query string true "结束日期" format(date)
+// @Param period query string false "统计周期" Enums(daily, weekly, monthly, yearly) default(daily)
+// @Param group_by query []string false "分组字段"
+// @Param user_ids query []string false "用户ID列表"
+// @Param statuses query []string false "状态列表"
+// @Success 200 {object} responses.CertificationStatisticsResponse "获取认证统计成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 401 {object} map[string]interface{} "未认证"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/certifications/statistics [get]
+func (h *CertificationHandler) GetCertificationStatistics(c *gin.Context) {
+	userID := h.getCurrentUserID(c)
+	if userID == "" {
+		h.response.Unauthorized(c, "用户未登录")
+		return
+	}
+
+	var query queries.GetCertificationStatisticsQuery
+	if err := h.validator.BindAndValidate(c, &query); err != nil {
+		return
+	}
+
+	result, err := h.appService.GetCertificationStatistics(c.Request.Context(), &query)
+	if err != nil {
+		h.logger.Error("获取认证统计失败", zap.Error(err))
+		h.response.BadRequest(c, err.Error())
+		return
+	}
+
+	h.response.Success(c, result, "获取认证统计成功")
+}
+
+// ================ 回调处理 ================
+
+// HandleEsignCallback 处理e签宝回调
+// @Summary 处理e签宝回调
+// @Description 处理e签宝的企业认证和合同签署回调
+// @Tags 认证管理
+// @Accept json
+// @Produce json
+// @Param request body commands.EsignCallbackCommand true "e签宝回调数据"
+// @Success 200 {object} responses.CallbackResponse "回调处理成功"
+// @Failure 400 {object} map[string]interface{} "请求参数错误"
+// @Failure 500 {object} map[string]interface{} "服务器内部错误"
+// @Router /api/v1/certifications/callbacks [post]
+func (h *CertificationHandler) HandleEsignCallback(c *gin.Context) {
+	var cmd commands.EsignCallbackCommand
+	if err := h.validator.BindAndValidate(c, &cmd); err != nil {
+		return
+	}
+
+	result, err := h.appService.HandleEsignCallback(c.Request.Context(), &cmd)
+	if err != nil {
+		h.logger.Error("处理e签宝回调失败", zap.Error(err), zap.String("certification_id", cmd.CertificationID))
+		h.response.BadRequest(c, err.Error())
+		return
+	}
+
+	h.response.Success(c, result, "回调处理成功")
+}
+
+// ================ 管理员操作 ================
+
+// ForceTransitionStatus 强制状态转换（管理员）
+// @Summary 强制状态转换
+// @Description 管理员强制转换认证状态
+// @Tags 认证管理
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Param request body commands.ForceTransitionStatusCommand true "强制状态转换请求"
+// @Success 200 {object} responses.CertificationResponse "状态转换成功"
+// @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/certifications/force-transition [post]
+func (h *CertificationHandler) ForceTransitionStatus(c *gin.Context) {
+	adminID := h.getCurrentUserID(c)
+	if adminID == "" {
+		h.response.Unauthorized(c, "用户未登录")
+		return
+	}
+
+	var cmd commands.ForceTransitionStatusCommand
+	if err := h.validator.BindAndValidate(c, &cmd); err != nil {
+		return
+	}
+	cmd.AdminID = adminID
+
+	result, err := h.appService.ForceTransitionStatus(c.Request.Context(), &cmd)
+	if err != nil {
+		h.logger.Error("强制状态转换失败", zap.Error(err), zap.String("certification_id", cmd.CertificationID))
+		h.response.BadRequest(c, err.Error())
+		return
+	}
+
+	h.response.Success(c, result, "状态转换成功")
+}
+
+// GetSystemMonitoring 获取系统监控数据
+// @Summary 获取系统监控数据
+// @Description 获取认证系统的监控数据
+// @Tags 认证管理
+// @Accept json
+// @Produce json
+// @Security Bearer
+// @Param time_range query string false "时间范围" Enums(1h, 6h, 24h, 7d, 30d) default(24h)
+// @Param metrics query []string false "监控指标"
+// @Success 200 {object} responses.SystemMonitoringResponse "获取系统监控数据成功"
+// @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/certifications/monitoring [get]
+func (h *CertificationHandler) GetSystemMonitoring(c *gin.Context) {
+	userID := h.getCurrentUserID(c)
+	if userID == "" {
+		h.response.Unauthorized(c, "用户未登录")
+		return
+	}
+
+	var query queries.GetSystemMonitoringQuery
+	if err := h.validator.BindAndValidate(c, &query); err != nil {
+		return
+	}
+
+	result, err := h.appService.GetSystemMonitoring(c.Request.Context(), &query)
+	if err != nil {
+		h.logger.Error("获取系统监控数据失败", zap.Error(err))
+		h.response.BadRequest(c, err.Error())
+		return
+	}
+
+	h.response.Success(c, result, "获取系统监控数据成功")
+}
+
+// ================ 辅助方法 ================
+
+// getCurrentUserID 获取当前用户ID
+func (h *CertificationHandler) getCurrentUserID(c *gin.Context) string {
+	if userID, exists := c.Get("user_id"); exists {
+		if id, ok := userID.(string); ok {
+			return id
+		}
+	}
+	return ""
 }