package com.ruoyi.system.service.impl; import java.io.BufferedReader; import java.io.InputStreamReader; import java.io.OutputStream; import java.net.HttpURLConnection; import java.net.URL; import java.net.URLEncoder; import java.text.SimpleDateFormat; import java.util.Date; import java.util.HashMap; import java.util.List; import java.util.Map; import javax.net.ssl.HttpsURLConnection; import javax.net.ssl.SSLContext; import javax.net.ssl.TrustManager; import javax.net.ssl.X509TrustManager; import java.security.cert.X509Certificate; 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; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import com.ruoyi.common.config.LegacySystemConfig; 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.vo.TaskCreateVO; import com.ruoyi.system.mapper.SysTaskMapper; import com.ruoyi.system.mapper.SysTaskEmergencyMapper; import com.ruoyi.system.mapper.SysTaskVehicleMapper; import com.ruoyi.system.mapper.SysTaskAssigneeMapper; import com.ruoyi.system.mapper.VehicleInfoMapper; import com.ruoyi.system.mapper.SysUserMapper; import com.ruoyi.system.mapper.SysDeptMapper; import com.ruoyi.system.utils.TaskStatusConverter; /** * 旧系统同步Service业务层处理 * * @author ruoyi * @date 2024-01-20 */ @Service public class LegacySystemSyncServiceImpl implements ILegacySystemSyncService { private static final Logger log = LoggerFactory.getLogger(LegacySystemSyncServiceImpl.class); @Autowired private LegacySystemConfig legacyConfig; @Autowired private SysTaskMapper sysTaskMapper; @Autowired private SysTaskEmergencyMapper sysTaskEmergencyMapper; @Autowired private SysUserMapper sysUserMapper; @Autowired private SysDeptMapper sysDeptMapper; @Autowired private SysTaskVehicleMapper sysTaskVehicleMapper; @Autowired private SysTaskAssigneeMapper sysTaskAssigneeMapper; @Autowired private VehicleInfoMapper vehicleInfoMapper; @Autowired private IDispatchOrdService dispatchOrdService; @Autowired private ISysTaskEmergencyService sysTaskEmergencyService; @Autowired private ITaskAttachmentSyncService taskAttachmentSyncService; @Autowired private ISysTaskService sysTaskService; @Autowired private ITaskAttachmentService taskAttachmentService; /** * 同步急救转运任务到旧系统 */ @Override @Transactional public Long syncEmergencyTaskToLegacy(Long taskId) { if (!legacyConfig.isEnabled()) { log.info("旧系统同步已禁用，跳过任务ID: {}", taskId); return null; } try { // 查询任务信息 SysTask task = sysTaskMapper.selectSysTaskByTaskId(taskId); if (task == null) { log.error("任务不存在，任务ID: {}", taskId); return null; } // 只同步急救转运任务 if (!"EMERGENCY_TRANSFER".equals(task.getTaskType())) { log.info("非急救转运任务，跳过同步，任务ID: {}", taskId); return null; } // 查询急救转运扩展信息 SysTaskEmergency emergency = sysTaskEmergencyService.selectSysTaskEmergencyByTaskId(taskId); if (emergency == null) { log.error("急救转运扩展信息不存在，任务ID: {}", taskId); return null; } // 如果已经同步过，不再重复同步 if (emergency.getLegacyServiceOrdId() != null && emergency.getLegacyServiceOrdId() > 0) { log.info("任务已同步过，任务ID: {}, ServiceOrdID: {}", taskId, emergency.getLegacyServiceOrdId()); return emergency.getLegacyServiceOrdId(); } // 更新同步状态为同步中 emergency.setSyncStatus(1); sysTaskEmergencyService.updateSysTaskEmergency(emergency); // 构建请求参数 Map params = buildSyncParams(task, emergency); // 发送HTTP请求 String response = sendHttpPost(legacyConfig.getEmergencyCreateUrl(), params); // 解析响应 Long serviceOrdId = parseResponse(response); if (serviceOrdId != null && serviceOrdId > 0) { // 同步成功，更新记录 emergency.setLegacyServiceOrdId(serviceOrdId); emergency.setSyncStatus(2); // 同步成功 emergency.setSyncTime(new Date()); emergency.setSyncErrorMsg(null); sysTaskEmergencyService.updateSysTaskEmergency(emergency); // 更新任务主表同步标记 task.setLegacySynced(1); sysTaskMapper.updateSysTask(task); log.info("任务同步成功，任务ID: {}, ServiceOrdID: {}", taskId, serviceOrdId); return serviceOrdId; } else { // 同步失败 emergency.setSyncStatus(3); // 同步失败 emergency.setSyncTime(new Date()); emergency.setSyncErrorMsg("旧系统返回无效的ServiceOrdID: " + response); sysTaskEmergencyService.updateSysTaskEmergency(emergency); log.error("任务同步失败，任务ID: {}, 响应: {}", taskId, response); return null; } } catch (Exception e) { log.error("同步任务到旧系统异常，任务ID: {}", taskId, e); // 更新同步状态为失败 try { SysTaskEmergency emergency = sysTaskEmergencyService.selectSysTaskEmergencyByTaskId(taskId); if (emergency != null) { emergency.setSyncStatus(3); // 同步失败 emergency.setSyncTime(new Date()); emergency.setSyncErrorMsg("同步异常: " + e.getMessage()); sysTaskEmergencyService.updateSysTaskEmergency(emergency); } } catch (Exception ex) { log.error("更新同步状态失败", ex); } return null; } } /** * 批量同步未同步的急救转运任务 * 使用分页查询，确保所有符合条件的任务都能被同步 */ @Override public int batchSyncPendingTasks() { if (!legacyConfig.isEnabled()) { log.info("旧系统同步已禁用"); return 0; } try { int totalSuccessCount = 0; int pageSize = 100; // 每页100条 int offset = 0; while (true) { // 分页查询未同步的急救转运任务（同步状态为0或3的任务） List pendingTasks = sysTaskEmergencyService.selectPendingSyncTasks(offset, pageSize); if (pendingTasks == null || pendingTasks.isEmpty()) { log.info("没有更多需要同步的任务，offset: {}", offset); break; // 没有更多数据，退出循环 } 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("批量同步完成，总成功数: {}", totalSuccessCount); return totalSuccessCount; } catch (Exception e) { log.error("批量同步任务异常", e); return 0; } } /** * 重新同步失败的任务 */ @Override public boolean retrySyncTask(Long taskId) { try { // 重置同步状态 SysTaskEmergency emergency = sysTaskEmergencyService.selectSysTaskEmergencyByTaskId(taskId); if (emergency != null) { emergency.setSyncStatus(0); // 重置为未同步 emergency.setLegacyServiceOrdId(null); emergency.setSyncErrorMsg(null); sysTaskEmergencyService.updateSysTaskEmergency(emergency); } // 重新同步 Long serviceOrdId = syncEmergencyTaskToLegacy(taskId); return serviceOrdId != null && serviceOrdId > 0; } catch (Exception e) { log.error("重新同步任务失败，任务ID: {}", taskId, e); return false; } } /** * 同步任务附件到旧系统 * @param taskAttachments * @param serviceOrdId * @param dispatchOrdId * @param oaUserID */ public void syncAttachmentToLegacy(List 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） */ @Override @Transactional public Long syncDispatchOrderToLegacy(Long taskId) { if (!legacyConfig.isEnabled()) { log.info("旧系统同步已禁用，跳过调度单同步，任务ID: {}", taskId); return null; } try { // 查询任务信息 SysTask task = sysTaskMapper.selectSysTaskByTaskId(taskId); if (task == null) { log.error("任务不存在，任务ID: {}", taskId); return null; } // 只同步急救转运任务 if (!"EMERGENCY_TRANSFER".equals(task.getTaskType())) { log.info("非急救转运任务，跳过调度单同步，任务ID: {}", taskId); return null; } // 查询急救转运扩展信息 SysTaskEmergency emergency = sysTaskEmergencyService.selectSysTaskEmergencyByTaskId(taskId); if (emergency == null) { log.error("急救转运扩展信息不存在，任务ID: {}", taskId); return null; } // 如果已经同步过，不再重复同步 if (emergency.getLegacyDispatchOrdId() != null && emergency.getLegacyDispatchOrdId() > 0) { log.info("调度单已同步过，任务ID: {}, DispatchOrdID: {}", taskId, emergency.getLegacyDispatchOrdId()); return emergency.getLegacyDispatchOrdId(); } Long serviceOrdId=emergency.getLegacyServiceOrdId(); // 必须先同步服务单 if (serviceOrdId == null || serviceOrdId <= 0) { log.warn("服务单未同步，无法同步调度单，任务ID: {}", taskId); return null; } // 更新同步状态为同步中 emergency.setDispatchSyncStatus(1); sysTaskEmergencyService.updateSysTaskEmergency(emergency); SysUser u=sysUserMapper.selectUserById(task.getCreatorId()); Integer oaUserID= u.getOaUserId(); // 构建请求参数 Map params = buildDispatchOrderParams(task, emergency); // 发送HTTP请求 String response = sendHttpPost(legacyConfig.getDispatchCreateUrl(), params); // 解析响应 Long dispatchOrdId = parseResponse(response); if (dispatchOrdId != null && dispatchOrdId > 0) { // 同步成功，更新记录 emergency.setLegacyDispatchOrdId(dispatchOrdId); emergency.setDispatchSyncStatus(2); // 同步成功 emergency.setDispatchSyncTime(new Date()); emergency.setDispatchSyncErrorMsg(null); sysTaskEmergencyService.updateSysTaskEmergency(emergency); List taskAttachments= sysTaskService.getAttachmentsByTaskId(taskId); if (taskAttachments != null && !taskAttachments.isEmpty()) { //同步附件 this.syncAttachmentToLegacy(taskAttachments,serviceOrdId,dispatchOrdId,oaUserID); } log.info("调度单同步成功，任务ID: {}, DispatchOrdID: {}", taskId, dispatchOrdId); return dispatchOrdId; } else { // 同步失败 emergency.setDispatchSyncStatus(3); // 同步失败 emergency.setDispatchSyncTime(new Date()); emergency.setDispatchSyncErrorMsg("旧系统返回无效的DispatchOrdID: " + response); sysTaskEmergencyService.updateSysTaskEmergency(emergency); log.error("调度单同步失败，任务ID: {}, 响应: {}", taskId, response); return null; } } catch (Exception e) { log.error("同步调度单到旧系统异常，任务ID: {}", taskId, e); // 更新同步状态为失败 try { SysTaskEmergency emergency = sysTaskEmergencyService.selectSysTaskEmergencyByTaskId(taskId); if (emergency != null) { emergency.setDispatchSyncStatus(3); // 同步失败 emergency.setDispatchSyncTime(new Date()); emergency.setDispatchSyncErrorMsg("同步异常: " + e.getMessage()); sysTaskEmergencyService.updateSysTaskEmergency(emergency); } } catch (Exception ex) { log.error("更新调度单同步状态失败", ex); } return null; } } /** * 批量同步未同步的调度单 * 使用分页查询，确保所有符合条件的任务都能被同步 */ @Override public int batchSyncPendingDispatchOrders() { if (!legacyConfig.isEnabled()) { log.info("旧系统同步已禁用"); return 0; } try { int totalSuccessCount = 0; int pageSize = 100; // 每页100条 int offset = 0; while (true) { // 分页查询已同步服务单但未同步调度单的任务 List pendingTasks = sysTaskEmergencyService.selectPendingDispatchSyncTasks(offset, pageSize); log.info("查询到未同步调度单的任务数量: {}", pendingTasks.size()); if (pendingTasks == null || pendingTasks.isEmpty()) { log.info("没有更多需要同步调度单的任务，offset: {}", offset); break; // 没有更多数据，退出循环 } 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("批量同步调度单完成，总成功数: {}", totalSuccessCount); return totalSuccessCount; } catch (Exception e) { log.error("批量同步调度单异常", e); return 0; } } /** * 构建调度单同步参数 */ private Map buildDispatchOrderParams(SysTask task, SysTaskEmergency emergency) { Map params = new HashMap<>(); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); // 获取管理员ID（创建人ID对应的OA_UserID） String adminID = this.getAdminID(task); // 获取调度单类型（从任务所属部门的调度单编码获取） String dispatchOrdClass = "SA"; // 默认值 if (task.getDeptId() != null) { try { SysDept dept = sysDeptMapper.selectDeptById(task.getDeptId()); if (dept != null && StringUtils.isNotEmpty(dept.getDispatchOrderClass())) { dispatchOrdClass = dept.getDispatchOrderClass(); log.info("获取任务所属部门的调度单编码成功，部门ID: {}, 调度单编码: {}", task.getDeptId(), dispatchOrdClass); } } catch (Exception e) { log.error("查询任务所属部门信息异常，部门ID: {}", task.getDeptId(), e); } } params.put("AdminID", adminID); // 基本信息 params.put("DispatchOrdClass", dispatchOrdClass); params.put("ServiceOrdID", emergency.getLegacyServiceOrdId().toString()); params.put("DispatchOrdState", "1"); // 调度单状态 // 时间信息 if (task.getPlannedStartTime() != null) { params.put("DispatchOrdTraSDTime", sdf.format(task.getPlannedStartTime())); // 拟出发时间 } else { params.put("DispatchOrdTraSDTime", ""); } params.put("DispatchOrd_NS_Time", task.getCreateTime() != null ? sdf.format(task.getCreateTime()) : sdf.format(new Date())); // 开单时间 // 车辆信息 - 从任务关联的车辆获取CarID Long carId = getTaskVehicleCarId(task.getTaskId()); params.put("DispatchOrdCarID", carId.toString()); // 联系人信息 params.put("DispatchOrdCoName", StringUtils.nvl(emergency.getPatientContact(), "")); params.put("DispatchOrdCoPhone", StringUtils.nvl(emergency.getPatientPhone(), "")); params.put("ServiceOrdCoName", StringUtils.nvl(emergency.getPatientContact(), "")); params.put("ServiceOrdCoPhone", StringUtils.nvl(emergency.getPatientPhone(), "")); params.put("ServiceOrdPtName", StringUtils.nvl(emergency.getPatientName(), "")); params.put("ServiceOrdTraStreet",StringUtils.nvl(task.getDepartureAddress(), StringUtils.nvl(emergency.getHospitalOutAddress(), ""))); // 地址信息 params.put("DispatchOrdTraStreet", StringUtils.nvl(task.getDepartureAddress(), StringUtils.nvl(emergency.getHospitalOutAddress(), ""))); params.put("DispatchOrdTraEnd", StringUtils.nvl(task.getDestinationAddress(), StringUtils.nvl(emergency.getHospitalInAddress(), ""))); params.put("DispatchOrdTraVia", ""); // 实际途经地 // 操作命令 params.put("DispatchOrd_Check", "0"); // 3=直接强制完成 // 绩效和费用 params.put("DispatchOrdPerfomance", emergency.getTransferPrice() != null ? emergency.getTransferPrice().toString() : "0"); params.put("StretcherMoney", "0"); // 抬担架费 params.put("AddMoneyType", ""); // 附加项目 params.put("AddMoney", "0"); // 附加项目费用 params.put("AddMoneyExplain", ""); // 附加项目说明 // 人员信息 params.put("EntourageName_aid1", ""); // 外援人员1 params.put("EntourageName_aid2", ""); // 外援人员2 params.put("DispatchOrd_NS_ID", adminID); // 调度人员ID params.put("RecommendedCar", ""); // 指定车型 params.put("ServiceOrdTaskRemarks", StringUtils.nvl(task.getTaskDescription(), "")); // 医护司备注 // 电话信息 params.put("Phone", StringUtils.nvl(emergency.getPatientPhone(), "")); params.put("TEL_Time", sdf.format(new Date())); params.put("TEL_Remarks", "新系统同步创建调度单"); // 时长信息 params.put("TimeLength_Program", "0"); // 大型活动保障时长 params.put("TimeLength_ICU", "0"); // 居家ICU时长 params.put("TimeLength_Wait", "0"); // 等待时长 // 里程数 params.put("DispatchOrdTraStreetMileage", ""); // 开始里程数 params.put("DispatchOrdTraEndMileage", ""); // 结束里程数 // 服务单相关信息（从admin_save_24.gds 221-255行补充） params.put("ServiceOrdPtCondition", StringUtils.nvl(emergency.getPatientCondition(), "")); // 病情描述 params.put("ServiceOrdPtDoctor", ""); // 患者医生 params.put("ServiceOrdPtDoctorPhone", ""); // 患者医生电话 params.put("TransferModeID", ""); // 转运方式 params.put("ServiceOrdVIP", "0"); // VIP客户 params.put("ServiceOrdTraTxnPrice", emergency.getTransferPrice() != null ? emergency.getTransferPrice().toString() : "0"); // 成交价 params.put("ServiceOrdTraPrePayment", "0"); // 需预付款 params.put("SettlementPrice", "0"); // 结算价 params.put("ServiceOrdTraPriceReason", ""); // 差价原因 params.put("ServiceOrd_CC_ID", ""); // 客服人员ID params.put("ServiceOrd_Sale_ID", ""); // 销售人员ID params.put("ServiceOrdIntroducer", ""); // 介绍人 params.put("ServiceOrd_work_ID", ""); // 主要企微客服ID params.put("ServiceOrd_work_IDs", ""); // 其他企微客服ID params.put("ServiceOrd_work_is", "0"); // 是否企微成交 params.put("CommissionScenarioID", "0"); // 企微绩效方案 params.put("ServiceOrdApptDate", task.getPlannedStartTime() != null ? sdf.format(task.getPlannedStartTime()) : ""); // 预约时间 params.put("ServiceOrdPtDiagnosis", ""); // 诊断 params.put("ServiceOrdOperationRemarks", "新系统同步创建"); // 操作备注 params.put("ServiceOrdEstimatedOrderDate", ""); // 预计派单时间 params.put("ServiceOrdEstimatedOrderDateOld", ""); // 原预计派单时间 params.put("ServiceOrdViaDistance", "0"); // 中途距离 params.put("ServiceOrdTraDistance", emergency.getTransferDistance() != null ? emergency.getTransferDistance().toString() : "0"); // 距离 params.put("OrderLevel", "0"); // 查看等级 params.put("ServiceOrdDepartureType", "1"); // 预约类型 params.put("ConditionLevel", "0"); // 病重级别 params.put("DirectionType", "0"); // 转运去向 params.put("ServiceOrdPtOutHospID", emergency.getHospitalOutId() != null ? emergency.getHospitalOutId().toString() : "0"); // 转出医院ID params.put("ServiceOrdPtInHospID", emergency.getHospitalInId() != null ? emergency.getHospitalInId().toString() : "0"); // 转入医院ID params.put("ServiceOrdPtOutHosp", StringUtils.nvl(emergency.getHospitalOutName(), "")); // 转出医院 params.put("ServiceOrdTraVia", StringUtils.nvl(task.getDepartureAddress(), StringUtils.nvl(emergency.getHospitalOutAddress(), ""))); // 转出地址 params.put("ServiceOrdPtInHosp", StringUtils.nvl(emergency.getHospitalInName(), "")); // 转入医院 params.put("ServiceOrdTraEnd", StringUtils.nvl(task.getDestinationAddress(), StringUtils.nvl(emergency.getHospitalInAddress(), ""))); // 转入地址 params.put("FromHQ2_is", "0"); // 广州总部推送任务标记 // 病情ID列表（ICD-10疾病ID，用于诊断ICD） // 格式：逗号分隔的ID列表，如 ",1,2,3," String ordIcdId = ""; if (StringUtils.isNotEmpty(emergency.getDiseaseIds())) { // 将存储的 "1,2,3" 格式转换为旧系统要求的 ",1,2,3," 格式 ordIcdId = "," + emergency.getDiseaseIds() + ","; log.info("病情ID列表已设置，任务ID: {}, OrdICD_ID: {}", task.getTaskId(), ordIcdId); } params.put("OrdICD_ID", ordIcdId); params.put("OrdICD_ID_old", ""); // 旧病情ID列表（用于对比是否需要更新） // 执行人员信息（随行人员） syncTaskAssignees(task, params); return params; } /** * 同步任务执行人员信息到调度单随行人员参数 * * @param task 任务信息 * @param params 调度单参数Map */ private void syncTaskAssignees(SysTask task, Map params) { try { // 获取任务的执行人员信息列表（包含角色类型） //TODO 如果有两个司机就要 设置　Entourage_1和Entourage_2 //两个护士就要设置 Entourage_4和Entourage_6 //两个医生要设置 Entourage_3和Entourage_5 List assignees = getTaskAssignees(task.getTaskId()); if (assignees == null || assignees.isEmpty()) { log.warn("任务无执行人员，任务ID: {}", task.getTaskId()); // 设置默认空值 params.put("EntourageLeadID", ""); params.put("Entourage_1", ""); // 司机 params.put("Entourage_2", ""); //司机 params.put("Entourage_3", ""); // 医生 params.put("Entourage_5", ""); //医生 params.put("Entourage_4", ""); // 护士 params.put("Entourage_6", ""); // 护士 return; } String leadEntourageId = ""; // 领队的EntourageID String driverOaId = ""; // 司机的OA_UserID String doctorOaId = ""; // 医生的OA_UserID String nurseOaId = ""; // 护士的OA_UserID // 遍历执行人员，根据角色类型分配到对应的Entourage参数 for (int i = 0; i < assignees.size(); i++) { TaskCreateVO.AssigneeInfo assignee = assignees.get(i); Long userId = assignee.getUserId(); String userType = assignee.getUserType(); // 直接使用前端传递的角色类型 if (userId == null) { continue; } // 查询用户的OA_UserID SysUser user = sysUserMapper.selectUserById(userId); if (user == null || user.getOaUserId() == null) { log.warn("执行人员信息不存在或未配置OA_UserID，用户ID: {}", userId); continue; } String oaUserId = user.getOaUserId().toString(); // 根据用户类型分配到对应的Entourage参数 if ("driver".equals(userType)) { if (driverOaId.isEmpty()) { driverOaId = oaUserId; if(params.get("Entourage_1")==null) { params.put("Entourage_1", oaUserId); }else{ params.put("Entourage_2", oaUserId); } // 如果是第一个执行人员，设置为领队 if (i == 0 && leadEntourageId.isEmpty()) { leadEntourageId = "1"; // 司机对应Entourage_1 } } } else if ("doctor".equals(userType)) { if (doctorOaId.isEmpty()) { doctorOaId = oaUserId; if(params.get("Entourage_3")==null) { params.put("Entourage_3", oaUserId); }else{ params.put("Entourage_5", oaUserId); } // 如果是第一个执行人员，设置为领队 if (i == 0 && leadEntourageId.isEmpty()) { leadEntourageId = "3"; // 医生对应Entourage_3 } } } else if ("nurse".equals(userType)) { if (nurseOaId.isEmpty()) { nurseOaId = oaUserId; if(params.get("Entourage_4")==null) { params.put("Entourage_4", oaUserId); }else{ params.put("Entourage_6", oaUserId); } // 如果是第一个执行人员，设置为领队 if (i == 0 && leadEntourageId.isEmpty()) { leadEntourageId = "4"; // 护士对应Entourage_4 } } } } // 设置参数 params.put("EntourageLeadID", leadEntourageId); // params.put("Entourage_1", driverOaId); // 司机 // params.put("Entourage_3", doctorOaId); // 医生 // params.put("Entourage_4", nurseOaId); // 护士 log.info("任务执行人员同步成功，任务ID: {}, 领队ID: {}, 司机: {}, 医生: {}, 护士: {}", task.getTaskId(), leadEntourageId, driverOaId, doctorOaId, nurseOaId); } catch (Exception e) { log.error("同步任务执行人员异常，任务ID: {}", task.getTaskId(), e); // 设置默认空值 params.put("EntourageLeadID", ""); params.put("Entourage_1", ""); params.put("Entourage_3", ""); params.put("Entourage_4", ""); } } /** * 获取任务的执行人员信息列表（包含角色类型） * * @param taskId 任务ID * @return 执行人员信息列表 */ private List getTaskAssignees(Long taskId) { List assignees = new java.util.ArrayList<>(); try { // 从数据库查询执行人员信息（按排序顺序） List taskAssignees = sysTaskAssigneeMapper.selectSysTaskAssigneeByTaskId(taskId); if (taskAssignees != null && !taskAssignees.isEmpty()) { // 将数据库中的执行人员转换为AssigneeInfo对象 for (SysTaskAssignee taskAssignee : taskAssignees) { TaskCreateVO.AssigneeInfo assignee = new TaskCreateVO.AssigneeInfo(); assignee.setUserId(taskAssignee.getUserId()); assignee.setUserName(taskAssignee.getUserName()); assignee.setUserType(taskAssignee.getUserType()); assignees.add(assignee); } log.info("从数据库获取执行人员信息成功，任务ID: {}, 人员数量: {}", taskId, assignees.size()); return assignees; } // 如果数据库中没有执行人员信息，尝试从任务的主要执行人获取 log.warn("数据库中未找到执行人员信息，尝试从任务主要执行人获取，任务ID: {}", taskId); SysTask task = sysTaskMapper.selectSysTaskByTaskId(taskId); if (task != null && task.getAssigneeId() != null) { SysUser user = sysUserMapper.selectUserById(task.getAssigneeId()); if (user != null) { TaskCreateVO.AssigneeInfo assignee = new TaskCreateVO.AssigneeInfo(); assignee.setUserId(user.getUserId()); assignee.setUserName(user.getNickName()); assignee.setUserType(getUserType(user)); // 通过角色判断类型 assignees.add(assignee); } } } catch (Exception e) { log.error("获取任务执行人员信息异常，任务ID: {}", taskId, e); } return assignees; } /** * 判断用户类型（司机/医生/护士/其他） * 根据用户的角色名称来判断 * * @param user 用户信息 * @return 用户类型：driver/doctor/nurse/other */ private String getUserType(SysUser user) { String roleName = ""; // 从用户的角色列表中获取角色名称 if (user.getRoles() != null && !user.getRoles().isEmpty()) { roleName = user.getRoles().get(0).getRoleName(); } // 判断是否为司机 if (roleName != null && roleName.contains("司机")) { return "driver"; } // 判断是否为医生 if (roleName != null && roleName.contains("医生")) { return "doctor"; } // 判断是否为护士 if (roleName != null && roleName.contains("护士")) { return "nurse"; } // 其他类型，默认为司机（保证至少有一个人员） log.warn("用户角色无法判断类型，默认为司机，用户ID: {}, 角色: {}", user.getUserId(), roleName); return "driver"; } /** * 获取任务关联车辆的旧系统CarID * * @param taskId 任务ID * @return CarID，如果未找到则返回0L */ private Long getTaskVehicleCarId(Long taskId) { try { // 从 sys_task_vehicle 表查询车辆ID List taskVehicles = sysTaskVehicleMapper.selectSysTaskVehicleByTaskId(taskId); if (taskVehicles != null && !taskVehicles.isEmpty()) { // 取第一个关联的车辆 Long vehicleId = taskVehicles.get(0).getVehicleId(); if (vehicleId != null) { // 从 tb_vehicle_info 表获取 car_id VehicleInfo vehicleInfo = vehicleInfoMapper.selectVehicleInfoById(vehicleId); if (vehicleInfo != null && vehicleInfo.getCarId() != null) { Long carId = vehicleInfo.getCarId().longValue(); log.info("获取任务关联车辆的CarID成功，任务ID: {}, 车辆ID: {}, CarID: {}", taskId, vehicleId, carId); return carId; } else { log.warn("车辆信息中未配置CarID，任务ID: {}, 车辆ID: {}", taskId, vehicleId); } } else { log.warn("任务车辆关联记录中车辆ID为空，任务ID: {}", taskId); } } else { log.warn("任务未关联车辆，任务ID: {}", taskId); } } catch (Exception e) { log.error("查询任务关联车辆的CarID异常，任务ID: {}", taskId, e); } return 0L; } private String getAdminID(SysTask task) { String adminID=""; if (task.getCreatorId() != null) { try { SysUser creator = sysUserMapper.selectUserById(task.getCreatorId()); if (creator != null && creator.getOaUserId() != null) { adminID = creator.getOaUserId().toString(); log.info("获取创建人OA_UserID成功，用户ID: {}, OA_UserID: {}", task.getCreatorId(), adminID); } else { log.warn("创建人未配置OA_UserID，用户ID: {}", task.getCreatorId()); } } catch (Exception e) { log.error("查询创建人OA_UserID异常，用户ID: {}", task.getCreatorId(), e); } } return adminID; } /** * 构建同步参数 */ private Map buildSyncParams(SysTask task, SysTaskEmergency emergency) { Map params = new HashMap<>(); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); SimpleDateFormat sdfDate = new SimpleDateFormat("yyyy-MM-dd"); Long taskId=task.getTaskId(); // 管理员ID（创建人ID对应的OA_UserID） String adminID = this.getAdminID(task); params.put("adminID", adminID); // 服务单分类（从任务所属部门的服务单编码获取） String serviceOrdClass = "BF"; // ServiceOrdClass默认值 if (task.getDeptId() != null) { try { SysDept dept = sysDeptMapper.selectDeptById(task.getDeptId()); if (dept != null && StringUtils.isNotEmpty(dept.getServiceOrderClass())) { // 使用部门的服务单编码作为ServiceOrdClass serviceOrdClass = dept.getServiceOrderClass(); log.info("获取任务所属部门的服务单编码成功，部门ID: {}, 部门名称: {}, 服务单编码: {}", task.getDeptId(), dept.getDeptName(), serviceOrdClass); } else { log.warn("任务所属部门未配置服务单编码，部门ID: {}、部门名称: {}，使用默认值", task.getDeptId(), dept != null ? dept.getDeptName() : "null"); } } catch (Exception e) { log.error("查询任务所属部门信息异常，部门ID: {}", task.getDeptId(), e); } } else { log.warn("任务未关联部门，使用默认服务单编码"); } // 服务单执行区域（从任务的document_type_id获取） String serviceOrdAreaType = "1"; // 默认值 if (StringUtils.isNotEmpty(emergency.getDocumentTypeId())) { serviceOrdAreaType = emergency.getDocumentTypeId(); log.info("获取单据类型ID成功，任务ID: {}, 单据类型ID: {}", task.getTaskId(), serviceOrdAreaType); } else { log.warn("任务未配置单据类型ID，任务ID: {}，使用默认值", task.getTaskId()); } // 基础信息 params.put("ServiceOrdClass", serviceOrdClass); // 从部门的服务单编码获取 params.put("ServiceOrdAreaType", serviceOrdAreaType); // 从任务的document_type_id获取 // 服务单执行类型（从任务的task_type_id获取） String serviceOrdType = "1"; // 默认值 if (StringUtils.isNotEmpty(emergency.getTaskTypeId())) { serviceOrdType = emergency.getTaskTypeId(); log.info("获取任务类型ID成功，任务ID: {}, 任务类型ID: {}", taskId, serviceOrdType); } else { log.warn("任务未配置任务类型ID，任务ID: {}，使用默认值", taskId); } params.put("ServiceOrdType", serviceOrdType); // 服务单执行类型（从任务的task_type_id获取） params.put("ServiceOrdState", "2"); // 服务单状态（2=正式单） params.put("ServiceOrdStartDate", task.getCreateTime() != null ? sdfDate.format(task.getCreateTime()) : sdfDate.format(new Date())); // 预约时间 if (task.getPlannedStartTime() != null) { params.put("ServiceOrdApptDate", sdf.format(task.getPlannedStartTime())); } // 联系人信息 params.put("ServiceOrdCoName", StringUtils.nvl(emergency.getPatientContact(), "")); params.put("ServiceOrdCoPhone", StringUtils.nvl(emergency.getPatientPhone(), "")); params.put("ServiceOrdCoTies", ""); // 联系人与患者关系 // 患者信息 params.put("ServiceOrdPtName", StringUtils.nvl(emergency.getPatientName(), "")); params.put("ServiceOrdPtAge", ""); // 年龄 params.put("ServiceOrdPtKG", ""); // 体重 params.put("ServiceOrdPtSex", "0".equals(emergency.getPatientGender()) ? "男" : "1".equals(emergency.getPatientGender()) ? "女" : ""); params.put("ServiceOrdPtNat", ""); // 国籍 params.put("ServiceOrdPtIDCard", StringUtils.nvl(emergency.getPatientIdCard(), "")); // 医院信息 params.put("ServiceOrdPtOutHosp", StringUtils.nvl(emergency.getHospitalOutName(), "")); params.put("ServiceOrdPtOutHospID", emergency.getHospitalOutId() != null ? emergency.getHospitalOutId().toString() : "0"); // 转出医院ID params.put("ServiceOrdPtInHosp", StringUtils.nvl(emergency.getHospitalInName(), "")); params.put("ServiceOrdPtInHospID", emergency.getHospitalInId() != null ? emergency.getHospitalInId().toString() : "0"); // 转入医院ID // 科室信息 params.put("ServiceOrdPtServices", StringUtils.nvl(emergency.getHospitalOutDepartment(), "")); params.put("ServiceOrdPtServicesID", StringUtils.nvl(emergency.getHospitalOutDepartmentId(), "0")); // 转出科室ID params.put("ServiceOrdPtInServices", StringUtils.nvl(emergency.getHospitalInDepartment(), "")); params.put("ServiceOrdPtInServicesID", StringUtils.nvl(emergency.getHospitalInDepartmentId(), "0")); // 转入科室ID // 病情信息 params.put("ServiceOrdPtDiagnosis", ""); // 诊断 params.put("ServiceOrdPtCondition", StringUtils.nvl(emergency.getPatientCondition(), "")); params.put("ServiceOrdTaskRemarks", StringUtils.nvl(task.getTaskDescription(), "")); params.put("ServiceOrdPtDoctor", ""); // 患者医生 params.put("ServiceOrdPtDoctorPhone", ""); // 患者医生电话 // 地址信息 params.put("province", ""); // 出发地省份 params.put("city", ""); // 出发地城市 params.put("ServiceOrdTraStreet",task.getDepartureAddress()); //派车地址 params.put("ServiceOrdTraStreetCoo", ""); // 出发地坐标 params.put("ServiceOrdTraEnd", StringUtils.nvl(task.getDestinationAddress(), StringUtils.nvl(emergency.getHospitalInAddress(), ""))); params.put("ServiceOrdTraEndCoo", ""); // 目的地坐标 params.put("ServiceOrdTraVia", ""); // 途经地 // 距离和价格信息 params.put("ServiceOrdViaDistance", "0"); // 中途距离 params.put("ServiceOrdTraDistance", emergency.getTransferDistance() != null ? emergency.getTransferDistance().toString() : "0"); params.put("ServiceOrdTraDuration", ""); // 预计行程时间 params.put("ServiceOrdTraUnitPrice", "0"); // 单价/公里 params.put("ServiceOrdTraOfferPrice", emergency.getTransferPrice() != null ? emergency.getTransferPrice().toString() : "0"); params.put("ServiceOrdTraTxnPrice", emergency.getTransferPrice() != null ? emergency.getTransferPrice().toString() : "0"); params.put("ServiceOrdTraPrePayment", "0"); // 需预付款 params.put("SettlementPrice", "0"); // 结算价 params.put("ServiceOrdTraPriceReason", ""); // 差价原因 // 其他信息 params.put("Phone", StringUtils.nvl(emergency.getPatientPhone(), "")); // 来电电话 params.put("TEL_Time", sdf.format(new Date())); // 来电时间 params.put("TEL_Remarks", "新系统同步"); // 来电备注 params.put("TransferModeID", ""); // 转运方式 params.put("ServiceOrdVIP", "0"); // VIP客户 params.put("ServiceOrd_CC_ID", ""); // 客服人员ID params.put("ServiceOrd_Sale_ID", ""); // 销售人员ID params.put("ServiceOrdIntroducer", ""); // 介绍人 params.put("ServiceOrd_work_ID", ""); // 主要企微客服ID params.put("ServiceOrd_work_IDs", ""); // 其他企微客服ID params.put("ServiceOrd_work_is", "0"); // 是否企微成交 params.put("CommissionScenarioID", "0"); // 企微绩效方案 params.put("ServiceOrdOperationRemarks", "新系统同步创建"); // 操作备注 params.put("ServiceOrdEstimatedOrderDate", ""); // 预计派单时间 params.put("ServiceOrdSource", "10"); // 订单来源（10=新系统） params.put("OrderLevel", "0"); // 查看等级 params.put("ServiceOrdDepartureType", "1"); // 预约类型 params.put("ConditionLevel", "0"); // 病重级别 params.put("DirectionType", "0"); // 转运去向 params.put("ServiceOrd_m", "1"); // 来源入口 params.put("FromHQ2_is", "0"); // 广州总部推送任务标记 params.put("OrderPrice_Auto", "0"); // 订单自动报价参考值 return params; } /** * 发送HTTP/HTTPS POST请求 * 支持HTTPS自签名证书 */ private String sendHttpPost(String urlString, Map params) throws Exception { URL url = new URL(urlString); HttpURLConnection conn = (HttpURLConnection) url.openConnection(); // 如果是HTTPS请求，配置SSL信任所有证书 if (conn instanceof HttpsURLConnection) { HttpsURLConnection httpsConn = (HttpsURLConnection) conn; httpsConn.setSSLSocketFactory(createTrustAllSSLContext().getSocketFactory()); httpsConn.setHostnameVerifier((hostname, session) -> true); // 信任所有主机名 log.debug("配置HTTPS连接，信任所有SSL证书，URL: {}", urlString); } try { // 设置连接属性 conn.setRequestMethod("POST"); conn.setConnectTimeout(legacyConfig.getConnectTimeout()); conn.setReadTimeout(legacyConfig.getReadTimeout()); conn.setDoOutput(true); conn.setDoInput(true); conn.setUseCaches(false); conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded;charset=" + legacyConfig.getCharset()); conn.setRequestProperty("Accept-Charset", legacyConfig.getCharset()); // 构建POST数据 StringBuilder postData = new StringBuilder(); for (Map.Entry entry : params.entrySet()) { if (postData.length() > 0) { postData.append("&"); } postData.append(URLEncoder.encode(entry.getKey(), legacyConfig.getCharset())); postData.append("="); postData.append(URLEncoder.encode(entry.getValue(), legacyConfig.getCharset())); } // 发送POST数据 try (OutputStream os = conn.getOutputStream()) { os.write(postData.toString().getBytes(legacyConfig.getCharset())); os.flush(); } // 读取响应 int responseCode = conn.getResponseCode(); if (responseCode == HttpURLConnection.HTTP_OK) { try (BufferedReader reader = new BufferedReader( new InputStreamReader(conn.getInputStream(), legacyConfig.getCharset()))) { StringBuilder response = new StringBuilder(); String line; while ((line = reader.readLine()) != null) { response.append(line); } return response.toString().trim(); } } else { log.error("请求失败，请求URL {},参数 {}",urlString,postData); throw new Exception("HTTP/HTTPS请求失败，响应码: " + responseCode); } } finally { conn.disconnect(); } } /** * 创建信任所有SSL证书的SSLContext * 用于支持自签名证书的HTTPS请求 * * 注意：此方法会信任所有SSL证书，包括自签名证书 * 仅用于与旧系统的内部通信，生产环境建议使用正规CA证书 */ private SSLContext createTrustAllSSLContext() throws Exception { // 创建信任所有证书的TrustManager TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() { @Override public X509Certificate[] getAcceptedIssuers() { return null; } @Override public void checkClientTrusted(X509Certificate[] certs, String authType) { // 信任所有客户端证书 } @Override public void checkServerTrusted(X509Certificate[] certs, String authType) { // 信任所有服务器证书 } } }; // 安装信任所有证书的TrustManager SSLContext sslContext = SSLContext.getInstance("TLS"); sslContext.init(null, trustAllCerts, new java.security.SecureRandom()); return sslContext; } /** * 解析旧系统响应 * 预期格式: "OK:ServiceOrdID" 或错误信息 */ private Long parseResponse(String response) { if (StringUtils.isEmpty(response)) { return null; } // 去除可能的HTML标签和空白字符 response = response.replaceAll("<[^>]*>", "").trim(); // 检查是否成功响应 if (response.startsWith("OK:")) { try { String serviceOrdIdStr = response.substring(3).trim(); return Long.parseLong(serviceOrdIdStr); } catch (NumberFormatException e) { log.error("解析ServiceOrdID失败: {}", response, e); return null; } } else { log.error("旧系统返回错误: {}", response); return null; } } /** * 重新同步车辆和人员变更的任务到旧系统 * 当任务的车辆信息或人员信息发生变更时，需要调用旧系统接口重新同步 * 使用 admin_save_25.asp 接口，而不是 admin_save_24.gds */ @Override @Transactional public boolean resyncDispatchOrderToLegacy(Long taskId) { if (!legacyConfig.isEnabled()) { log.info("旧系统同步已禁用，跳过调度单重新同步，任务ID: {}", taskId); return false; } try { // 查询任务信息 SysTask task = sysTaskMapper.selectSysTaskByTaskId(taskId); if (task == null) { log.error("任务不存在，任务ID: {}", taskId); return false; } // 只同步急救转运任务 if (!"EMERGENCY_TRANSFER".equals(task.getTaskType())) { log.info("非急救转运任务，跳过调度单重新同步，任务ID: {}", taskId); return false; } // 查询急救转运扩展信息 SysTaskEmergency emergency = sysTaskEmergencyService.selectSysTaskEmergencyByTaskId(taskId); if (emergency == null) { log.error("急救转运扩展信息不存在，任务ID: {}", taskId); return false; } // 必须已经同步过调度单 if (emergency.getLegacyDispatchOrdId() == null || emergency.getLegacyDispatchOrdId() <= 0) { log.warn("调度单未同步，无法重新同步，任务ID: {}", taskId); return false; } Long serviceOrdId = emergency.getLegacyServiceOrdId(); if (serviceOrdId == null || serviceOrdId <= 0) { log.warn("服务单未同步，无法重新同步调度单，任务ID: {}", taskId); return false; } log.info("开始重新同步调度单，任务ID: {}, DispatchOrdID: {}", taskId, emergency.getLegacyDispatchOrdId()); // 构建请求参数（使用相同的参数构建方法） Map params = buildDispatchOrderParams(task, emergency); params.put("DispatchOrdID", emergency.getLegacyDispatchOrdId().toString()); params.put("ServiceOrdID", emergency.getLegacyServiceOrdId().toString()); params.put("DispatchOrdState", "3"); log.info("重新同步调度单到旧系统请求参数: {}", params); // 发送HTTP请求到旧系统（使用admin_save_25.asp接口） String response = sendHttpPost(legacyConfig.getDispatchUpdateUrl(), params); log.info("重新同步调度单到旧系统响应: ServiceOrdID:{},DispatchOrdId:{},Result: {}",emergency.getLegacyServiceOrdId(),emergency.getLegacyDispatchOrdId(), response); // 解析响应 // Long dispatchOrdId = parseResponse(response); if (response != null && response.equals("OK")) { // 重新同步成功，清除重新同步标记 emergency.setNeedResync(0); emergency.setDispatchSyncTime(new Date()); emergency.setDispatchSyncErrorMsg(null); sysTaskEmergencyService.updateSysTaskEmergency(emergency); log.info("调度单重新同步成功，任务ID: {}, DispatchOrdID: {}", taskId, emergency.getLegacyDispatchOrdId()); return true; } else { // 重新同步失败 emergency.setDispatchSyncErrorMsg("重新同步失败：" + response); sysTaskEmergencyService.updateSysTaskEmergency(emergency); log.error("调度单重新同步失败，任务ID: {}, 响应: {}", taskId, response); return false; } } catch (Exception e) { log.error("重新同步调度单到旧系统异常，任务ID: {}", taskId, e); // 更新同步状态为失败 try { SysTaskEmergency emergency = sysTaskEmergencyService.selectSysTaskEmergencyByTaskId(taskId); if (emergency != null) { emergency.setDispatchSyncErrorMsg("重新同步异常: " + e.getMessage()); sysTaskEmergencyService.updateSysTaskEmergency(emergency); } } catch (Exception ex) { log.error("更新调度单同步状态失败", ex); } return false; } } /** * 批量重新同步需要更新的调度单 */ @Override public int batchResyncPendingDispatchOrders() { if (!legacyConfig.isEnabled()) { log.info("旧系统同步已禁用"); return 0; } try { int totalSuccessCount = 0; int pageSize = 100; // 每页100条 int offset = 0; while (true) { // 分页查询需要重新同步的任务 List needResyncTasks = sysTaskEmergencyMapper.selectNeedResyncTasks(offset, pageSize); log.info("查询到需要重新同步的任务数量: {}", needResyncTasks.size()); if (needResyncTasks == null || needResyncTasks.isEmpty()) { log.info("没有更多需要重新同步的任务，offset: {}", offset); break; // 没有更多数据，退出循环 } log.info("开始重新同步调度单第 {} 页，任务数量: {}", (offset / pageSize) + 1, needResyncTasks.size()); int pageSuccessCount = 0; for (SysTaskEmergency emergency : needResyncTasks) { log.info("开始重新同步调度单，任务ID: {}", emergency.getTaskId()); boolean success = resyncDispatchOrderToLegacy(emergency.getTaskId()); if (success) { pageSuccessCount++; } // 避免过于频繁的请求 try { Thread.sleep(1000); // 每个请求间隔1秒 } catch (InterruptedException e) { Thread.currentThread().interrupt(); log.warn("重新同步调度单被中断"); return totalSuccessCount + pageSuccessCount; } } totalSuccessCount += pageSuccessCount; log.info("调度单重新同步第 {} 页完成，总数: {}, 成功: {}", (offset / pageSize) + 1, needResyncTasks.size(), pageSuccessCount); // 如果本页数据少于每页大小，说明已经是最后一页 if (needResyncTasks.size() < pageSize) { log.info("已到达最后一页，调度单重新同步结束"); break; } offset += pageSize; // 下一页 } log.info("批量重新同步调度单完成，总成功数: {}", totalSuccessCount); return totalSuccessCount; } catch (Exception e) { log.error("批量重新同步调度单异常", e); return 0; } } }