feat: 任务修改接口，删除一些不要的字段同步

wlzboy

9 小时以前 5f2ee03958a1a16dc27195c76ea7cffb422c95d1

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

@@ -6,6 +6,7 @@
import com.ruoyi.common.enums.DataSourceType;
import com.ruoyi.system.domain.ImageData;
import com.ruoyi.system.domain.SysTaskAttachment;
import com.ruoyi.system.domain.SysTaskEmergency;
import com.ruoyi.system.file.FileUploadResponse;
import com.ruoyi.system.file.IFileUploadService;
import com.ruoyi.system.imagedata.IImageDataService;
@@ -29,12 +30,13 @@
 * @author ruoyi
 */
@Service
@DataSource(DataSourceType.SQLSERVER)
public class TaskAttachmentSyncServiceImpl implements ITaskAttachmentSyncService {
    
    private static final Logger log = LoggerFactory.getLogger(TaskAttachmentSyncServiceImpl.class);
    

    @Autowired
    private SysTaskAttachmentMapper taskAttachmentMapper;
    
    @Autowired
    private IImageDataService imageDataService;
    
@@ -166,6 +168,107 @@
        return null;
    }
    
    /**
     * 批量同步待同步的任务附件到ImageData
     */
    @Override
    public int batchSyncPendingAttachments() {
        log.info("开始执行批量附件同步任务");
        
        try {
            // 查询待同步的附件列表
            List<SysTaskAttachment> pendingAttachments = taskAttachmentMapper.selectPendingSyncAttachments();
            
            if (pendingAttachments == null || pendingAttachments.isEmpty()) {
                log.info("没有待同步的附件");
                return 0;
            }
            
            log.info("查询到 {} 个待同步的附件", pendingAttachments.size());
            
            // 按任务ID分组同步
            int successCount = 0;
            Long currentTaskId = null;
            Long serviceOrderId = null;
            Long dispatchOrdId = null;
            Integer oaUserId = null;
            
            for (SysTaskAttachment attachment : pendingAttachments) {
                try {
                    // 如果是新任务，需要获取任务信息
                    if (!attachment.getTaskId().equals(currentTaskId)) {
                        currentTaskId = attachment.getTaskId();
                        // 通过联表查询已经包含了任务信息，这里需要单独查询
                        SysTaskEmergency emergencyInfo = getEmergencyInfoByTaskId(currentTaskId);
                        if (emergencyInfo != null) {
                            serviceOrderId = emergencyInfo.getLegacyServiceOrdId();
                            dispatchOrdId = emergencyInfo.getLegacyDispatchOrdId();
                            // 获取任务创建人的OA用户ID
                            oaUserId = getCreatorOaUserId(currentTaskId);
                        } else {
                            log.warn("任务ID={} 的急救转运信息为空，跳过", currentTaskId);
                            continue;
                        }
                    }
                    
                    // 同步单个附件
                    Long imageDataId = syncAttachmentToImageData(attachment, serviceOrderId, dispatchOrdId, oaUserId);
                    
                    if (imageDataId != null && imageDataId > 0) {
                        // 更新附件同步状态
                        attachment.setSyncedToImageData(1);
                        attachment.setSyncTime(new Date());
                        attachment.setImageDataId(imageDataId);
                        taskAttachmentMapper.updateSysTaskAttachment(attachment);
                        
                        successCount++;
                        log.info("附件ID={} 同步成功，ImageDataId={}", 
                            attachment.getAttachmentId(), imageDataId);
                    }
                } catch (Exception e) {
                    log.error("同步附件ID={} 失败", attachment.getAttachmentId(), e);
                    // 继续处理下一个附件
                }
            }
            
            log.info("附件同步完成，成功同步 {}/{} 个附件", successCount, pendingAttachments.size());
            return successCount;
            
        } catch (Exception e) {
            log.error("批量附件同步异常", e);
            return 0;
        }
    }
    
    /**
     * 根据任务ID获取急救转运信息
     */
    @Autowired
    private com.ruoyi.system.mapper.SysTaskEmergencyMapper taskEmergencyMapper;
    
    private SysTaskEmergency getEmergencyInfoByTaskId(Long taskId) {
        return taskEmergencyMapper.selectSysTaskEmergencyByTaskId(taskId);
    }
    
    /**
     * 获取任务创建人的OA用户ID
     */
    @Autowired
    private com.ruoyi.system.mapper.SysTaskMapper taskMapper;
    
    @Autowired
    private com.ruoyi.system.mapper.SysUserMapper userMapper;
    
    private Integer getCreatorOaUserId(Long taskId) {
        com.ruoyi.system.domain.SysTask task = taskMapper.selectSysTaskByTaskId(taskId);
        if (task != null && task.getCreatorId() != null) {
            com.ruoyi.common.core.domain.entity.SysUser user = userMapper.selectUserById(task.getCreatorId());
            if (user != null) {
                return user.getOaUserId();
            }
        }
        return null;
    }

    
    /**