qiangdanxitong/backend/src/main/java/com/designhub/service/ThirdPartyCallbackService.java

package com.designhub.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.designhub.entity.Task;
import com.designhub.entity.ThirdPartyCallback;
import com.designhub.exception.BusinessException;
import com.designhub.mapper.TaskMapper;
import com.designhub.mapper.ThirdPartyCallbackMapper;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;

/**
 * 第三方回调处理Service
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class ThirdPartyCallbackService {

    private final ThirdPartyCallbackMapper callbackMapper;
    private final TaskMapper taskMapper;
    private final ObjectMapper objectMapper;

    /**
     * 处理任务完成回调
     */
    @Transactional(rollbackFor = Exception.class)
    public void handleTaskCompleteCallback(String thirdPartyTaskNo, Map<String, Object> payload) {
        log.info("处理任务完成回调: thirdPartyTaskNo={}", thirdPartyTaskNo);
        
        // 查找对应的任务
        Task task = taskMapper.selectOne(
            new LambdaQueryWrapper<Task>()
                .eq(Task::getThirdPartyTaskNo, thirdPartyTaskNo)
        );
        
        if (task == null) {
            log.error("未找到对应的任务: thirdPartyTaskNo={}", thirdPartyTaskNo);
            throw new BusinessException("任务不存在");
        }
        
        // 创建回调记录
        ThirdPartyCallback callback = new ThirdPartyCallback();
        callback.setTaskId(task.getId());
        callback.setThirdPartyTaskNo(thirdPartyTaskNo);
        callback.setCallbackType("complete");
        callback.setCallbackStatus("pending");
        callback.setCallbackTime(LocalDateTime.now());
        callback.setRetryCount(0);
        
        try {
            callback.setRequestData(objectMapper.writeValueAsString(payload));
        } catch (JsonProcessingException e) {
            log.warn("序列化请求数据失败", e);
        }
        
        callbackMapper.insert(callback);
        
        // 处理回调逻辑
        try {
            // 更新任务状态为已完成
            Task updateTask = new Task();
            updateTask.setId(task.getId());
            updateTask.setStatus("completed");
            updateTask.setProgress(100);
            updateTask.setCompleteTime(LocalDateTime.now());
            updateTask.setUpdateTime(LocalDateTime.now());
            
            taskMapper.updateById(updateTask);
            
            // 更新回调记录状态
            callback.setCallbackStatus("success");
            callback.setProcessedTime(LocalDateTime.now());
            callback.setResponseData("{\"status\":\"success\"}");
            callbackMapper.updateById(callback);
            
            log.info("任务完成回调处理成功: taskId={}, thirdPartyTaskNo={}", task.getId(), thirdPartyTaskNo);
            
        } catch (Exception e) {
            log.error("处理任务完成回调失败", e);
            
            // 更新回调记录状态
            callback.setCallbackStatus("failed");
            callback.setErrorMessage(e.getMessage());
            callback.setProcessedTime(LocalDateTime.now());
            callbackMapper.updateById(callback);
            
            throw new BusinessException("处理回调失败: " + e.getMessage());
        }
    }

    /**
     * 处理任务状态更新回调
     */
    @Transactional(rollbackFor = Exception.class)
    public void handleTaskStatusUpdateCallback(String thirdPartyTaskNo, String status, Map<String, Object> payload) {
        log.info("处理任务状态更新回调: thirdPartyTaskNo={}, status={}", thirdPartyTaskNo, status);
        
        // 查找对应的任务
        Task task = taskMapper.selectOne(
            new LambdaQueryWrapper<Task>()
                .eq(Task::getThirdPartyTaskNo, thirdPartyTaskNo)
        );
        
        if (task == null) {
            log.error("未找到对应的任务: thirdPartyTaskNo={}", thirdPartyTaskNo);
            throw new BusinessException("任务不存在");
        }
        
        // 创建回调记录
        ThirdPartyCallback callback = new ThirdPartyCallback();
        callback.setTaskId(task.getId());
        callback.setThirdPartyTaskNo(thirdPartyTaskNo);
        callback.setCallbackType("status_update");
        callback.setCallbackStatus("pending");
        callback.setCallbackTime(LocalDateTime.now());
        callback.setRetryCount(0);
        
        try {
            callback.setRequestData(objectMapper.writeValueAsString(payload));
        } catch (JsonProcessingException e) {
            log.warn("序列化请求数据失败", e);
        }
        
        callbackMapper.insert(callback);
        
        // 处理回调逻辑（根据第三方状态更新本地状态）
        try {
            // 这里可以根据第三方的status做相应的状态映射
            // 示例：status可能是 "submitted", "processing", "completed", "cancelled" 等
            
            log.info("第三方任务状态: {}", status);
            
            // 更新回调记录状态
            callback.setCallbackStatus("success");
            callback.setProcessedTime(LocalDateTime.now());
            callback.setResponseData("{\"status\":\"success\",\"message\":\"状态已记录\"}");
            callbackMapper.updateById(callback);
            
            log.info("任务状态更新回调处理成功: taskId={}, thirdPartyTaskNo={}, status={}", 
                    task.getId(), thirdPartyTaskNo, status);
            
        } catch (Exception e) {
            log.error("处理任务状态更新回调失败", e);
            
            callback.setCallbackStatus("failed");
            callback.setErrorMessage(e.getMessage());
            callback.setProcessedTime(LocalDateTime.now());
            callbackMapper.updateById(callback);
            
            throw new BusinessException("处理回调失败: " + e.getMessage());
        }
    }

    /**
     * 查询回调记录
     */
    public List<ThirdPartyCallback> getCallbackRecords(String thirdPartyTaskNo) {
        return callbackMapper.selectList(
            new LambdaQueryWrapper<ThirdPartyCallback>()
                .eq(ThirdPartyCallback::getThirdPartyTaskNo, thirdPartyTaskNo)
                .orderByDesc(ThirdPartyCallback::getCallbackTime)
        );
    }
}