feat: 上传附件

wlzboy

2025-11-08 cdcc529ce5fb9aa0dd1dea5bb2a620fc09b7d25c

 ruoyi-system/src/main/java/com/ruoyi/system/service/impl/LegacySystemSyncServiceImpl.java

@@ -12,6 +12,9 @@
import java.util.List;
import java.util.Map;

import com.ruoyi.system.domain.*;
import com.ruoyi.system.service.*;
import com.ruoyi.system.task.ITaskAttachmentService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
@@ -22,11 +25,6 @@
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.entity.SysDept;
import com.ruoyi.system.domain.SysTask;
import com.ruoyi.system.domain.SysTaskEmergency;
import com.ruoyi.system.domain.SysTaskVehicle;
import com.ruoyi.system.domain.SysTaskAssignee;
import com.ruoyi.system.domain.VehicleInfo;
import com.ruoyi.system.domain.vo.TaskCreateVO;
import com.ruoyi.system.mapper.SysTaskMapper;
import com.ruoyi.system.mapper.SysTaskEmergencyMapper;
@@ -35,7 +33,7 @@
import com.ruoyi.system.mapper.VehicleInfoMapper;
import com.ruoyi.system.mapper.SysUserMapper;
import com.ruoyi.system.mapper.SysDeptMapper;
import com.ruoyi.system.service.ILegacySystemSyncService;
import com.ruoyi.system.utils.TaskStatusConverter;

/**
 * 旧系统同步Service业务层处理
@@ -55,9 +53,6 @@
    private SysTaskMapper sysTaskMapper;
    
    @Autowired
    private SysTaskEmergencyMapper sysTaskEmergencyMapper;
    
    @Autowired
    private SysUserMapper sysUserMapper;
    
    @Autowired
@@ -71,6 +66,21 @@
    
    @Autowired
    private VehicleInfoMapper vehicleInfoMapper;
    
    @Autowired
    private IDispatchOrdService dispatchOrdService;
    
    @Autowired
    private ISysTaskEmergencyService sysTaskEmergencyService;

    @Autowired
    private ITaskAttachmentSyncService taskAttachmentSyncService;

    @Autowired
    private ISysTaskService sysTaskService;

    @Autowired
    private ITaskAttachmentService taskAttachmentService;
    
    /**
     * 同步急救转运任务到旧系统
@@ -98,7 +108,7 @@
            }
            
            // 查询急救转运扩展信息
            SysTaskEmergency emergency = sysTaskEmergencyMapper.selectSysTaskEmergencyByTaskId(taskId);
            SysTaskEmergency emergency = sysTaskEmergencyService.selectSysTaskEmergencyByTaskId(taskId);
            if (emergency == null) {
                log.error("急救转运扩展信息不存在，任务ID: {}", taskId);
                return null;
@@ -112,7 +122,7 @@
            
            // 更新同步状态为同步中
            emergency.setSyncStatus(1);
            sysTaskEmergencyMapper.updateSysTaskEmergency(emergency);
            sysTaskEmergencyService.updateSysTaskEmergency(emergency);
            
            // 构建请求参数
            Map<String, String> params = buildSyncParams(task, emergency);
@@ -129,7 +139,7 @@
                emergency.setSyncStatus(2); // 同步成功
                emergency.setSyncTime(new Date());
                emergency.setSyncErrorMsg(null);
                sysTaskEmergencyMapper.updateSysTaskEmergency(emergency);
                sysTaskEmergencyService.updateSysTaskEmergency(emergency);
                
                // 更新任务主表同步标记
                task.setLegacySynced(1);
@@ -142,7 +152,7 @@
                emergency.setSyncStatus(3); // 同步失败
                emergency.setSyncTime(new Date());
                emergency.setSyncErrorMsg("旧系统返回无效的ServiceOrdID: " + response);
                sysTaskEmergencyMapper.updateSysTaskEmergency(emergency);
                sysTaskEmergencyService.updateSysTaskEmergency(emergency);
                
                log.error("任务同步失败，任务ID: {}, 响应: {}", taskId, response);
                return null;
@@ -153,12 +163,12 @@
            
            // 更新同步状态为失败
            try {
                SysTaskEmergency emergency = sysTaskEmergencyMapper.selectSysTaskEmergencyByTaskId(taskId);
                SysTaskEmergency emergency = sysTaskEmergencyService.selectSysTaskEmergencyByTaskId(taskId);
                if (emergency != null) {
                    emergency.setSyncStatus(3); // 同步失败
                    emergency.setSyncTime(new Date());
                    emergency.setSyncErrorMsg("同步异常: " + e.getMessage());
                    sysTaskEmergencyMapper.updateSysTaskEmergency(emergency);
                    sysTaskEmergencyService.updateSysTaskEmergency(emergency);
                }
            } catch (Exception ex) {
                log.error("更新同步状态失败", ex);
@@ -170,6 +180,7 @@
    
    /**
     * 批量同步未同步的急救转运任务
     * 使用分页查询，确保所有符合条件的任务都能被同步
     */
    @Override
    public int batchSyncPendingTasks() {
@@ -179,27 +190,53 @@
        }
        
        try {
            // 查询未同步的急救转运任务（同步状态为0或3的任务）
            List<SysTaskEmergency> pendingTasks = sysTaskEmergencyMapper.selectPendingSyncTasks();
            int totalSuccessCount = 0;
            int pageSize = 100; // 每页100条
            int offset = 0;
            
            int successCount = 0;
            for (SysTaskEmergency emergency : pendingTasks) {
                Long serviceOrdId = syncEmergencyTaskToLegacy(emergency.getTaskId());
                if (serviceOrdId != null && serviceOrdId > 0) {
                    successCount++;
            while (true) {
                // 分页查询未同步的急救转运任务（同步状态为0或3的任务）
                List<SysTaskEmergency> pendingTasks = sysTaskEmergencyService.selectPendingSyncTasks(offset, pageSize);
                
                if (pendingTasks == null || pendingTasks.isEmpty()) {
                    log.info("没有更多需要同步的任务，offset: {}", offset);
                    break; // 没有更多数据，退出循环
                }
                
                // 避免过于频繁的请求
                try {
                    Thread.sleep(1000); // 每个请求间隔1秒
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                log.info("开始同步第 {} 页，任务数量: {}", (offset / pageSize) + 1, pendingTasks.size());
                
                int pageSuccessCount = 0;
                for (SysTaskEmergency emergency : pendingTasks) {
                    Long serviceOrdId = syncEmergencyTaskToLegacy(emergency.getTaskId());
                    if (serviceOrdId != null && serviceOrdId > 0) {
                        pageSuccessCount++;
                    }
                    
                    // 避免过于频繁的请求
                    try {
                        Thread.sleep(1000); // 每个请求间隔1秒
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        log.warn("同步被中断");
                        return totalSuccessCount + pageSuccessCount;
                    }
                }
                
                totalSuccessCount += pageSuccessCount;
                log.info("第 {} 页同步完成，总数: {}, 成功: {}", 
                    (offset / pageSize) + 1, pendingTasks.size(), pageSuccessCount);
                
                // 如果本页数据少于每页大小，说明已经是最后一页
                if (pendingTasks.size() < pageSize) {
                    log.info("已到达最后一页，同步结束");
                    break;
                }
                
                offset += pageSize; // 下一页
            }
            
            log.info("批量同步完成，总数: {}, 成功: {}", pendingTasks.size(), successCount);
            return successCount;
            log.info("批量同步完成，总成功数: {}", totalSuccessCount);
            return totalSuccessCount;
            
        } catch (Exception e) {
            log.error("批量同步任务异常", e);
@@ -215,12 +252,12 @@
    public boolean retrySyncTask(Long taskId) {
        try {
            // 重置同步状态
            SysTaskEmergency emergency = sysTaskEmergencyMapper.selectSysTaskEmergencyByTaskId(taskId);
            SysTaskEmergency emergency = sysTaskEmergencyService.selectSysTaskEmergencyByTaskId(taskId);
            if (emergency != null) {
                emergency.setSyncStatus(0); // 重置为未同步
                emergency.setLegacyServiceOrdId(null);
                emergency.setSyncErrorMsg(null);
                sysTaskEmergencyMapper.updateSysTaskEmergency(emergency);
                sysTaskEmergencyService.updateSysTaskEmergency(emergency);
            }
            
            // 重新同步
@@ -232,7 +269,27 @@
            return false;
        }
    }
    


    /**
     * 同步任务附件到旧系统
     * @param taskAttachments
     * @param serviceOrdId
     * @param dispatchOrdId
     * @param oaUserID
     */
    public void syncAttachmentToLegacy(List<SysTaskAttachment> taskAttachments, Long serviceOrdId,Long dispatchOrdId,Integer oaUserID) {
        taskAttachments.forEach((taskAttachment)->{
            Long imageDataId=  taskAttachmentSyncService.syncAttachmentToImageData(taskAttachment,serviceOrdId,dispatchOrdId,oaUserID);
            if (imageDataId != null && imageDataId > 0) {

                taskAttachment.setSyncedToImageData(1);
                taskAttachment.setSyncTime(new Date());
                taskAttachment.setImageDataId(imageDataId);
                taskAttachmentService.updateAttachment(taskAttachment);
            }
        });
    }
    /**
     * 同步调度单到旧系统（admin_save_24.asp）
     */
@@ -259,7 +316,7 @@
            }
            
            // 查询急救转运扩展信息
            SysTaskEmergency emergency = sysTaskEmergencyMapper.selectSysTaskEmergencyByTaskId(taskId);
            SysTaskEmergency emergency = sysTaskEmergencyService.selectSysTaskEmergencyByTaskId(taskId);
            if (emergency == null) {
                log.error("急救转运扩展信息不存在，任务ID: {}", taskId);
                return null;
@@ -270,16 +327,23 @@
                log.info("调度单已同步过，任务ID: {}, DispatchOrdID: {}", taskId, emergency.getLegacyDispatchOrdId());
                return emergency.getLegacyDispatchOrdId();
            }
            

            Long serviceOrdId=emergency.getLegacyServiceOrdId();
            // 必须先同步服务单
            if (emergency.getLegacyServiceOrdId() == null || emergency.getLegacyServiceOrdId() <= 0) {
            if (serviceOrdId == null || serviceOrdId <= 0) {
                log.warn("服务单未同步，无法同步调度单，任务ID: {}", taskId);
                return null;
            }
            




            // 更新同步状态为同步中
            emergency.setDispatchSyncStatus(1);
            sysTaskEmergencyMapper.updateSysTaskEmergency(emergency);
            sysTaskEmergencyService.updateSysTaskEmergency(emergency);

            SysUser u=sysUserMapper.selectUserById(task.getCreatorId());
            Integer oaUserID= u.getOaUserId();
            
            // 构建请求参数
            Map<String, String> params = buildDispatchOrderParams(task, emergency);
@@ -296,8 +360,14 @@
                emergency.setDispatchSyncStatus(2); // 同步成功
                emergency.setDispatchSyncTime(new Date());
                emergency.setDispatchSyncErrorMsg(null);
                sysTaskEmergencyMapper.updateSysTaskEmergency(emergency);
                
                sysTaskEmergencyService.updateSysTaskEmergency(emergency);

                List<SysTaskAttachment> taskAttachments= sysTaskService.getAttachmentsByTaskId(taskId);
                if (taskAttachments != null && !taskAttachments.isEmpty()) {
                    //同步附件
                   this.syncAttachmentToLegacy(taskAttachments,serviceOrdId,dispatchOrdId,oaUserID);
                }

                log.info("调度单同步成功，任务ID: {}, DispatchOrdID: {}", taskId, dispatchOrdId);
                return dispatchOrdId;
            } else {
@@ -305,7 +375,7 @@
                emergency.setDispatchSyncStatus(3); // 同步失败
                emergency.setDispatchSyncTime(new Date());
                emergency.setDispatchSyncErrorMsg("旧系统返回无效的DispatchOrdID: " + response);
                sysTaskEmergencyMapper.updateSysTaskEmergency(emergency);
                sysTaskEmergencyService.updateSysTaskEmergency(emergency);
                
                log.error("调度单同步失败，任务ID: {}, 响应: {}", taskId, response);
                return null;
@@ -316,12 +386,12 @@
            
            // 更新同步状态为失败
            try {
                SysTaskEmergency emergency = sysTaskEmergencyMapper.selectSysTaskEmergencyByTaskId(taskId);
                SysTaskEmergency emergency = sysTaskEmergencyService.selectSysTaskEmergencyByTaskId(taskId);
                if (emergency != null) {
                    emergency.setDispatchSyncStatus(3); // 同步失败
                    emergency.setDispatchSyncTime(new Date());
                    emergency.setDispatchSyncErrorMsg("同步异常: " + e.getMessage());
                    sysTaskEmergencyMapper.updateSysTaskEmergency(emergency);
                    sysTaskEmergencyService.updateSysTaskEmergency(emergency);
                }
            } catch (Exception ex) {
                log.error("更新调度单同步状态失败", ex);
@@ -333,6 +403,7 @@
    
    /**
     * 批量同步未同步的调度单
     * 使用分页查询，确保所有符合条件的任务都能被同步
     */
    @Override
    public int batchSyncPendingDispatchOrders() {
@@ -342,27 +413,55 @@
        }
        
        try {
            // 查询已同步服务单但未同步调度单的任务
            List<SysTaskEmergency> pendingTasks = sysTaskEmergencyMapper.selectPendingDispatchSyncTasks();
            int totalSuccessCount = 0;
            int pageSize = 100; // 每页100条
            int offset = 0;
            
            int successCount = 0;
            for (SysTaskEmergency emergency : pendingTasks) {
                Long dispatchOrdId = syncDispatchOrderToLegacy(emergency.getTaskId());
                if (dispatchOrdId != null && dispatchOrdId > 0) {
                    successCount++;
            while (true) {
                // 分页查询已同步服务单但未同步调度单的任务
                List<SysTaskEmergency> pendingTasks = sysTaskEmergencyService.selectPendingDispatchSyncTasks(offset, pageSize);
                log.info("查询到未同步调度单的任务数量: {}", pendingTasks.size());
                if (pendingTasks == null || pendingTasks.isEmpty()) {
                    log.info("没有更多需要同步调度单的任务，offset: {}", offset);
                    break; // 没有更多数据，退出循环
                }
                
                // 避免过于频繁的请求
                try {
                    Thread.sleep(1000); // 每个请求间隔1秒
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                log.info("开始同步调度单第 {} 页，任务数量: {}", (offset / pageSize) + 1, pendingTasks.size());
                
                int pageSuccessCount = 0;
                for (SysTaskEmergency emergency : pendingTasks) {
                    log.info("开始同步调度单，任务ID: {}", emergency.getTaskId());
                    Long dispatchOrdId = syncDispatchOrderToLegacy(emergency.getTaskId());

                    if (dispatchOrdId != null && dispatchOrdId > 0) {
                        pageSuccessCount++;
                    }
                    
                    // 避免过于频繁的请求
                    try {
                        Thread.sleep(1000); // 每个请求间隔1秒
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        log.warn("同步调度单被中断");
                        return totalSuccessCount + pageSuccessCount;
                    }
                }
                
                totalSuccessCount += pageSuccessCount;
                log.info("调度单第 {} 页同步完成，总数: {}, 成功: {}", 
                    (offset / pageSize) + 1, pendingTasks.size(), pageSuccessCount);
                
                // 如果本页数据少于每页大小，说明已经是最后一页
                if (pendingTasks.size() < pageSize) {
                    log.info("已到达最后一页，调度单同步结束");
                    break;
                }
                
                offset += pageSize; // 下一页
            }
            
            log.info("批量同步调度单完成，总数: {}, 成功: {}", pendingTasks.size(), successCount);
            return successCount;
            log.info("批量同步调度单完成，总成功数: {}", totalSuccessCount);
            return totalSuccessCount;
            
        } catch (Exception e) {
            log.error("批量同步调度单异常", e);
@@ -398,7 +497,7 @@
        // 基本信息
        params.put("DispatchOrdClass", dispatchOrdClass);
        params.put("ServiceOrdID", emergency.getLegacyServiceOrdId().toString());
        params.put("DispatchOrdState", "8"); // 调度单状态
        params.put("DispatchOrdState", "1"); // 调度单状态
        
        // 时间信息
        if (task.getPlannedStartTime() != null) {
@@ -478,7 +577,7 @@
        params.put("ServiceOrdEstimatedOrderDateOld", ""); // 原预计派单时间
        params.put("ServiceOrdViaDistance", "0"); // 中途距离
        params.put("ServiceOrdTraDistance", emergency.getTransferDistance() != null ? emergency.getTransferDistance().toString() : "0"); // 距离
        params.put("OrderLevel", "2"); // 查看等级
        params.put("OrderLevel", "0"); // 查看等级
        params.put("ServiceOrdDepartureType", "1"); // 预约类型
        params.put("ConditionLevel", "0"); // 病重级别
        params.put("DirectionType", "0"); // 转运去向
@@ -866,7 +965,7 @@
        params.put("ServiceOrdOperationRemarks", "新系统同步创建"); // 操作备注
        params.put("ServiceOrdEstimatedOrderDate", ""); // 预计派单时间
        params.put("ServiceOrdSource", "10"); // 订单来源（10=新系统）
        params.put("OrderLevel", "2"); // 查看等级
        params.put("OrderLevel", "0"); // 查看等级
        params.put("ServiceOrdDepartureType", "1"); // 预约类型
        params.put("ConditionLevel", "0"); // 病重级别
        params.put("DirectionType", "0"); // 转运去向