temp

internal/infrastructure/http/handlers/certification_handler.go

@@ -1,7 +1,9 @@
 package handlers
 
 import (
+	"bytes"
 	"io"
+	"time"
 
 	"github.com/gin-gonic/gin"
 	"go.uber.org/zap"
@@ -13,136 +15,57 @@ import (
 )
 
 // CertificationHandler 认证处理器
+// 负责处理HTTP请求，参数验证，调用应用服务，返回HTTP响应
 type CertificationHandler struct {
-	appService certification.CertificationApplicationService
-	response   interfaces.ResponseBuilder
-	logger     *zap.Logger
+	certAppService       certification.CertificationApplicationService
+	esignCallbackService certification.EsignCallbackApplicationService
+	response             interfaces.ResponseBuilder
+	validator            interfaces.RequestValidator
+	logger               *zap.Logger
 }
 
 // NewCertificationHandler 创建认证处理器
 func NewCertificationHandler(
-	appService certification.CertificationApplicationService,
+	certAppService certification.CertificationApplicationService,
+	esignCallbackService certification.EsignCallbackApplicationService,
 	response interfaces.ResponseBuilder,
+	validator interfaces.RequestValidator,
 	logger *zap.Logger,
 ) *CertificationHandler {
 	return &CertificationHandler{
-		appService: appService,
-		response:   response,
-		logger:     logger,
+		certAppService:       certAppService,
+		esignCallbackService: esignCallbackService,
+		response:             response,
+		validator:            validator,
+		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 获取当前用户的认证申请状态
+// @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{} "未认证"
+// @Success 200 {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, "用户未认证")
+		h.response.Unauthorized(c, "用户未登录")
 		return
 	}
 
-	query := &queries.GetCertificationStatusQuery{UserID: userID}
-	result, err := h.appService.GetCertificationStatus(c.Request.Context(), query)
+	query := &queries.GetCertificationStatusQuery{
+		UserID: userID,
+	}
+
+	result, err := h.certAppService.GetCertificationStatus(c.Request.Context(), query)
 	if err != nil {
-		h.logger.Error("获取认证状态失败",
-			zap.String("user_id", userID),
-			zap.Error(err),
-		)
+		h.logger.Error("获取认证状态失败", zap.Error(err))
 		h.response.BadRequest(c, err.Error())
 		return
 	}
@@ -150,55 +73,59 @@ func (h *CertificationHandler) GetCertificationStatus(c *gin.Context) {
 	h.response.Success(c, result, "获取认证状态成功")
 }
 
-// GetProgressStats 获取进度统计
-// @Summary 获取进度统计
-// @Description 获取认证申请的进度统计数据
+// GetCertificationDetails 获取认证详情
+// @Summary 获取认证详情
+// @Description 获取当前用户的详细认证信息，包括企业信息、认证记录等
 // @Tags 企业认证
 // @Accept json
 // @Produce json
 // @Security Bearer
-// @Success 200 {object} map[string]interface{} "获取进度统计成功"
-// @Failure 401 {object} map[string]interface{} "未认证"
+// @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,
-	}, "获取进度统计成功")
+// @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.certAppService.GetCertificationDetails(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, "获取认证详情成功")
 }
 
 // GetCertificationProgress 获取认证进度
 // @Summary 获取认证进度
-// @Description 获取当前用户的认证申请详细进度信息
+// @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 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, "用户未认证")
+		h.response.Unauthorized(c, "用户未登录")
 		return
 	}
 
-	result, err := h.appService.GetCertificationProgress(c.Request.Context(), userID)
+	result, err := h.certAppService.GetCertificationProgress(c.Request.Context(), userID)
 	if err != nil {
-		h.logger.Error("获取认证进度失败",
-			zap.String("user_id", userID),
-			zap.Error(err),
-		)
+		h.logger.Error("获取认证进度失败", zap.Error(err))
 		h.response.BadRequest(c, err.Error())
 		return
 	}
@@ -208,39 +135,34 @@ func (h *CertificationHandler) GetCertificationProgress(c *gin.Context) {
 
 // SubmitEnterpriseInfo 提交企业信息
 // @Summary 提交企业信息
-// @Description 提交企业基本信息，包括企业名称、统一社会信用代码、法定代表人信息等
+// @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{} "未认证"
+// @Param request body commands.SubmitEnterpriseInfoCommand 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/enterprise-info [post]
+// @Router /api/v1/certification/submit-enterprise-info [post]
 func (h *CertificationHandler) SubmitEnterpriseInfo(c *gin.Context) {
 	userID := c.GetString("user_id")
 	if userID == "" {
-		h.response.Unauthorized(c, "用户未认证")
+		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, "请求参数格式错误")
+	if err := h.validator.BindAndValidate(c, &cmd); err != nil {
 		return
 	}
 
 	cmd.UserID = userID
 
-	result, err := h.appService.SubmitEnterpriseInfo(c.Request.Context(), &cmd)
+	result, err := h.certAppService.SubmitEnterpriseInfo(c.Request.Context(), &cmd)
 	if err != nil {
-		h.logger.Error("提交企业信息失败",
-			zap.String("user_id", userID),
-			zap.Error(err),
-		)
+		h.logger.Error("提交企业信息失败", zap.Error(err))
 		h.response.BadRequest(c, err.Error())
 		return
 	}
@@ -248,92 +170,57 @@ func (h *CertificationHandler) SubmitEnterpriseInfo(c *gin.Context) {
 	h.response.Success(c, result, "企业信息提交成功")
 }
 
-// InitiateFaceVerify 发起人脸验证
-// @Summary 发起人脸验证
-// @Description 发起企业法人人脸验证流程
+// GetEnterpriseAuthURL 获取企业认证链接
+// @Summary 获取企业认证链接
+// @Description 获取e签宝企业认证链接，用户可通过该链接完成企业认证
 // @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{} "未认证"
+// @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/face-verify [post]
-func (h *CertificationHandler) InitiateFaceVerify(c *gin.Context) {
+// @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, "用户未认证")
+		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)
+	result, err := h.certAppService.GetEnterpriseAuthURL(c.Request.Context(), userID)
 	if err != nil {
-		h.logger.Error("获取认证申请失败",
-			zap.String("user_id", userID),
-			zap.Error(err),
-		)
+		h.logger.Error("获取企业认证链接失败", 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, "人脸验证发起成功")
+	h.response.Success(c, result, "获取企业认证链接成功")
 }
 
 // ApplyContract 申请合同
 // @Summary 申请合同
-// @Description 申请企业认证合同
+// @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{} "未认证"
+// @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/contract [post]
+// @Router /api/v1/certification/apply-contract [post]
 func (h *CertificationHandler) ApplyContract(c *gin.Context) {
 	userID := c.GetString("user_id")
 	if userID == "" {
-		h.response.Unauthorized(c, "用户未认证")
+		h.response.Unauthorized(c, "用户未登录")
 		return
 	}
 
-	result, err := h.appService.ApplyContract(c.Request.Context(), userID)
+	result, err := h.certAppService.ApplyContract(c.Request.Context(), userID)
 	if err != nil {
-		h.logger.Error("申请合同失败",
-			zap.String("user_id", userID),
-			zap.Error(err),
-		)
+		h.logger.Error("申请合同失败", zap.Error(err))
 		h.response.BadRequest(c, err.Error())
 		return
 	}
@@ -341,132 +228,161 @@ func (h *CertificationHandler) ApplyContract(c *gin.Context) {
 	h.response.Success(c, result, "合同申请成功")
 }
 
-// GetCertificationDetails 获取认证详情
-// @Summary 获取认证详情
-// @Description 获取当前用户的认证申请详细信息
+// GetContractSignURL 获取合同签署链接
+// @Summary 获取合同签署链接
+// @Description 获取e签宝合同签署链接，用户可通过该链接完成合同签署
 // @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{} "认证申请不存在"
+// @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/details [get]
-func (h *CertificationHandler) GetCertificationDetails(c *gin.Context) {
+// @Router /api/v1/certification/contract-sign-url [get]
+func (h *CertificationHandler) GetContractSignURL(c *gin.Context) {
 	userID := c.GetString("user_id")
 	if userID == "" {
-		h.response.Unauthorized(c, "用户未认证")
+		h.response.Unauthorized(c, "用户未登录")
 		return
 	}
 
-	query := &queries.GetCertificationDetailsQuery{
+	cmd := &commands.GetContractSignURLCommand{
 		UserID: userID,
 	}
 
-	result, err := h.appService.GetCertificationDetails(c.Request.Context(), query)
+	result, err := h.certAppService.GetContractSignURL(c.Request.Context(), cmd)
 	if err != nil {
-		h.logger.Error("获取认证详情失败",
-			zap.String("user_id", userID),
-			zap.Error(err),
-		)
+		h.logger.Error("获取合同签署链接失败", zap.Error(err))
 		h.response.BadRequest(c, err.Error())
 		return
 	}
 
-	h.response.Success(c, result, "获取认证详情成功")
+	h.response.Success(c, result, "获取合同签署链接成功")
 }
 
-// RetryStep 重试步骤
-// @Summary 重试认证步骤
-// @Description 重新执行指定的认证步骤
+// EsignCallback e签宝回调
+// @Summary e签宝回调接口
+// @Description 接收e签宝认证和签署的回调通知
 // @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{} "未认证"
+// @Success 200 {object} map[string]interface{} "回调处理成功"
+// @Failure 400 {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
+// @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))
 	}
 
-	step := c.Param("step")
-	if step == "" {
-		h.response.BadRequest(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
+		}
+
+		// 尝试解析为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))
 	}
 
-	var result interface{}
-	var err error
+	// 记录Content-Type
+	contentType := c.GetHeader("Content-Type")
+	h.logger.Info("回调请求Content-Type", zap.String("content_type", contentType))
 
-	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
+	// 记录Content-Length
+	contentLength := c.GetHeader("Content-Length")
+	if contentLength != "" {
+		h.logger.Info("回调请求Content-Length", zap.String("content_length", contentLength))
 	}
 
-	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.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
+		}
 	}
 
-	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结果成功")
+	// 返回成功响应
+	c.JSON(200, map[string]interface{}{
+		"code": "200",
+		"msg":  "success",
+	})
 }