feat: 增加服务单派发通知

wlzboy

2 天以前 8cb5d3440208a3be3e772e65f1bd0ec63031ba62

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

@@ -16,29 +16,29 @@
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.security.cert.X509Certificate;

import com.ruoyi.common.utils.MapValueUtils;
import com.ruoyi.system.domain.*;
import com.ruoyi.system.event.TaskDispatchSyncEvent;
import com.ruoyi.system.event.TaskServiceOrderSyncEvent;
import com.ruoyi.system.mapper.*;
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.context.ApplicationEventPublisher;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.ruoyi.common.config.LegacySystemConfig;
import com.ruoyi.common.utils.MapValueUtils;
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;
import org.springframework.util.CollectionUtils;

/**
 * 旧系统同步Service业务层处理
@@ -89,12 +89,37 @@

    @Autowired
    private ITaskAttachmentService taskAttachmentService;


    @Autowired
    private ApplicationEventPublisher eventPublisher;
    
    @Autowired
    private LegacyTransferSyncMapper legacyTransferSyncMapper;
    
    
    public Map<String,Object> getLegacyDispatchByDispatchId(Long dispatchId) {
        List<Map<String, Object>> result = legacyTransferSyncMapper.selectByDispatchId(dispatchId);
        if(!CollectionUtils.isEmpty(result)){
            return result.get(0);
        }else{
            return null;
        }
    }


    private Map<String,Object> getLegacyByServiceOrdId(Long serviceOrdId) {
        List<Map<String, Object>> result = legacyTransferSyncMapper.selectByServiceOrdId(serviceOrdId);
        if(!CollectionUtils.isEmpty(result)){
            return result.get(0);
        }else{
            return null;
        }
    }
    /**
     * 同步急救转运任务到旧系统
     */
    @Override
    @Transactional
    public Long syncEmergencyTaskToLegacy(Long taskId) {
        if (!legacyConfig.isEnabled()) {
            log.info("旧系统同步已禁用，跳过任务ID: {}", taskId);
@@ -124,7 +149,7 @@
            
            // 如果已经同步过，不再重复同步
            if (emergency.getLegacyServiceOrdId() != null && emergency.getLegacyServiceOrdId() > 0) {
                log.info("任务已同步过，任务ID: {}, ServiceOrdID: {}", taskId, emergency.getLegacyServiceOrdId());
//                log.info("任务已同步过，任务ID: {}, ServiceOrdID: {}", taskId, emergency.getLegacyServiceOrdId());
                return emergency.getLegacyServiceOrdId();
            }
            
@@ -147,13 +172,27 @@
                emergency.setSyncStatus(2); // 同步成功
                emergency.setSyncTime(new Date());
                emergency.setSyncErrorMsg(null);
                Map<String, Object> legacy = getLegacyByServiceOrdId(serviceOrdId);
                String serviceOrdNo = MapValueUtils.getStringValue(legacy, "ServiceOrdNo");
                if(serviceOrdNo!=null) {
                    emergency.setLegacyServiceOrdNo(serviceOrdNo);
                }
                String serviceOrdClass = MapValueUtils.getStringValue(legacy, "ServiceOrdClass");
                if(serviceOrdClass!=null) {
                    emergency.setLegacyServiceOrdClass(serviceOrdClass);
                }
                Date serviceCCTime = MapValueUtils.getDateValue(legacy, "ServiceOrd_CC_Time");
                if(serviceCCTime!=null) {
                    emergency.setLegacyServiceNsTime(serviceCCTime);
                }
                sysTaskEmergencyService.updateSysTaskEmergency(emergency);
                
                // 更新任务主表同步标记
                task.setLegacySynced(1);
                sysTaskMapper.updateSysTask(task);
                
                log.info("任务同步成功，任务ID: {}, ServiceOrdID: {}", taskId, serviceOrdId);

                eventPublisher.publishEvent(new TaskServiceOrderSyncEvent(this, taskId, task.getTaskCode(), serviceOrdId));
//                log.info("任务同步成功，任务ID: {}, ServiceOrdID: {}", taskId, serviceOrdId);
                return serviceOrdId;
            } else {
                // 同步失败
@@ -185,7 +224,13 @@
            return null;
        }
    }
    

    //在这里监听派发的事件
    @EventListener
    public void handleTaskServiceOrderSyncEvent(TaskServiceOrderSyncEvent event) {
//        log.info("收到任务服务单同步事件，任务ID：{}，任务编号：{}，服务单ID：{}", event.getTaskId(), event.getTaskCode(), event.getServiceOrderId());
        syncDispatchOrderToLegacy(event.getTaskId());
    }
    /**
     * 批量同步未同步的急救转运任务
     * 使用分页查询，确保所有符合条件的任务都能被同步
@@ -211,7 +256,7 @@
                    break; // 没有更多数据，退出循环
                }
                
                log.info("开始同步第 {} 页，任务数量: {}", (offset / pageSize) + 1, pendingTasks.size());
//                log.info("开始同步第 {} 页，任务数量: {}", (offset / pageSize) + 1, pendingTasks.size());
                
                int pageSuccessCount = 0;
                for (SysTaskEmergency emergency : pendingTasks) {
@@ -231,19 +276,19 @@
                }
                
                totalSuccessCount += pageSuccessCount;
                log.info("第 {} 页同步完成，总数: {}, 成功: {}", 
                    (offset / pageSize) + 1, pendingTasks.size(), pageSuccessCount);
//                log.info("第 {} 页同步完成，总数: {}, 成功: {}",
//                    (offset / pageSize) + 1, pendingTasks.size(), pageSuccessCount);
                
                // 如果本页数据少于每页大小，说明已经是最后一页
                if (pendingTasks.size() < pageSize) {
                    log.info("已到达最后一页，同步结束");
//                    log.info("已到达最后一页，同步结束");
                    break;
                }
                
                offset += pageSize; // 下一页
            }
            
            log.info("批量同步完成，总成功数: {}", totalSuccessCount);
//            log.info("批量同步完成，总成功数: {}", totalSuccessCount);
            return totalSuccessCount;
            
        } catch (Exception e) {
@@ -301,7 +346,6 @@
     * 同步调度单到旧系统（admin_save_24.asp）
     */
    @Override
    @Transactional
    public Long syncDispatchOrderToLegacy(Long taskId) {
        if (!legacyConfig.isEnabled()) {
            log.info("旧系统同步已禁用，跳过调度单同步，任务ID: {}", taskId);
@@ -331,7 +375,7 @@
            
            // 如果已经同步过，不再重复同步
            if (emergency.getLegacyDispatchOrdId() != null && emergency.getLegacyDispatchOrdId() > 0) {
                log.info("调度单已同步过，任务ID: {}, DispatchOrdID: {}", taskId, emergency.getLegacyDispatchOrdId());
//                log.info("调度单已同步过，任务ID: {}, DispatchOrdID: {}", taskId, emergency.getLegacyDispatchOrdId());
                return emergency.getLegacyDispatchOrdId();
            }

@@ -342,8 +386,70 @@
                return null;
            }



            // ====== 前置校验：确保任务数据完整 ======
            
            // 1. 检查是否已分配车辆
            List<SysTaskVehicle> taskVehicles = sysTaskVehicleMapper.selectSysTaskVehicleByTaskId(taskId);
            if (taskVehicles == null || taskVehicles.isEmpty()) {
                log.warn("任务未分配车辆，跳过调度单同步，任务ID: {}", taskId);
                return null;
            }
            
            // 2. 检查是否已分配执行人员
            List<SysTaskAssignee> taskAssignees = sysTaskAssigneeMapper.selectSysTaskAssigneeByTaskId(taskId);
            if (taskAssignees == null || taskAssignees.isEmpty()) {
                log.warn("任务未分配执行人员，跳过调度单同步，任务ID: {}", taskId);
                return null;
            }
            
            // 3. 检查预约时间是否有效（必须大于1970年）
            if (task.getPlannedStartTime() == null) {
                log.warn("任务未设置预约时间，跳过调度单同步，任务ID: {}", taskId);
                return null;
            }
            
            // 检查预约时间是否大于1970-01-01（时间戳0对应1970-01-01 00:00:00）
            long timestamp1970 = 0L;
            if (task.getPlannedStartTime().getTime() <= timestamp1970) {
                log.warn("任务预约时间无效（小于等于1970年），跳过调度单同步，任务ID: {}, 预约时间: {}", 
                    taskId, task.getPlannedStartTime());
                return null;
            }
            
            // 4. 检查转出医院信息
            if (StringUtils.isEmpty(emergency.getHospitalOutName())) {
                log.warn("任务未设置转出医院，跳过调度单同步，任务ID: {}", taskId);
                return null;
            }
            
            if (StringUtils.isEmpty(emergency.getHospitalOutAddress())) {
                log.warn("任务未设置转出医院地址，跳过调度单同步，任务ID: {}", taskId);
                return null;
            }
            
            // 5. 检查转入医院信息
            if (StringUtils.isEmpty(emergency.getHospitalInName())) {
                log.warn("任务未设置转入医院，跳过调度单同步，任务ID: {}", taskId);
                return null;
            }
            
            if (StringUtils.isEmpty(emergency.getHospitalInAddress())) {
                log.warn("任务未设置转入医院地址，跳过调度单同步，任务ID: {}", taskId);
                return null;
            }
            
            // 6. 检查患者基本信息
            if (StringUtils.isEmpty(emergency.getPatientName())) {
                log.warn("任务未设置患者姓名，跳过调度单同步，任务ID: {}", taskId);
                return null;
            }
            
            if (StringUtils.isEmpty(emergency.getPatientPhone())) {
                log.warn("任务未设置患者电话，跳过调度单同步，任务ID: {}", taskId);
                return null;
            }
            
            log.info("任务数据校验通过，开始同步调度单，任务ID: {}", taskId);

            // 更新同步状态为同步中
            emergency.setDispatchSyncStatus(1);
@@ -368,15 +474,20 @@
                emergency.setDispatchSyncStatus(2); // 同步成功
                emergency.setDispatchSyncTime(new Date());
                emergency.setDispatchSyncErrorMsg(null);
                //更新调度单信息开到新系统
                Map<String,Object> dispatchInfo = this.getLegacyDispatchByDispatchId(dispatchOrdId);
                if (dispatchInfo != null) {
                    emergency.setLegacyDispatchNsTime(MapValueUtils.getDateValue(dispatchInfo, "DispatchOrd_NS_Time")); // 同步成功
                    emergency.setLegacyDispatchOrdClass(MapValueUtils.getStringValue(dispatchInfo, "DispatchOrdClass")); // 同步成功
                    emergency.setLegacyDispatchOrdNo(MapValueUtils.getStringValue(dispatchInfo, "DispatchOrdNo")); // 同步成功
                    emergency.setLegacyServiceNsTime(MapValueUtils.getDateValue(dispatchInfo, "ServiceOrd_CC_Time")); // 同步成功
                    emergency.setLegacyServiceOrdClass(MapValueUtils.getStringValue(dispatchInfo, "ServiceOrdClass")); // 同步成功
                }
                sysTaskEmergencyService.updateSysTaskEmergency(emergency);

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

                log.info("调度单同步成功，任务ID: {}, DispatchOrdID: {}", taskId, dispatchOrdId);
//                log.info("调度单同步成功，任务ID: {}, DispatchOrdID: {}", taskId, dispatchOrdId);
                return dispatchOrdId;
            } else {
                // 同步失败
@@ -408,7 +519,19 @@
            return null;
        }
    }
    

    @EventListener
    public void handleTaskDispatchSyncEvent(TaskDispatchSyncEvent event) {
        Long taskId = event.getTaskId();
        Long dispatchOrdId = event.getDispatchOrderId();
        Long serviceOrdId = event.getServiceOrderId();
        Integer oaUserID = event.getOaUserId();
        List<SysTaskAttachment> taskAttachments= sysTaskService.getAttachmentsByTaskId(taskId);
        if (taskAttachments != null && !taskAttachments.isEmpty()) {
            //同步附件
            this.syncAttachmentToLegacy(taskAttachments,serviceOrdId,dispatchOrdId,oaUserID);
        }
    }
    /**
     * 批量同步未同步的调度单
     * 使用分页查询，确保所有符合条件的任务都能被同步
@@ -428,17 +551,17 @@
            while (true) {
                // 分页查询已同步服务单但未同步调度单的任务
                List<SysTaskEmergency> pendingTasks = sysTaskEmergencyService.selectPendingDispatchSyncTasks(offset, pageSize);
                log.info("查询到未同步调度单的任务数量: {}", pendingTasks.size());
//                log.info("查询到未同步调度单的任务数量: {}", pendingTasks.size());
                if (pendingTasks == null || pendingTasks.isEmpty()) {
                    log.info("没有更多需要同步调度单的任务，offset: {}", offset);
                    break; // 没有更多数据，退出循环
                }
                
                log.info("开始同步调度单第 {} 页，任务数量: {}", (offset / pageSize) + 1, pendingTasks.size());
//                log.info("开始同步调度单第 {} 页，任务数量: {}", (offset / pageSize) + 1, pendingTasks.size());
                
                int pageSuccessCount = 0;
                for (SysTaskEmergency emergency : pendingTasks) {
                    log.info("开始同步调度单，任务ID: {}", emergency.getTaskId());
//                    log.info("开始同步调度单，任务ID: {}", emergency.getTaskId());
                    Long dispatchOrdId = syncDispatchOrderToLegacy(emergency.getTaskId());

                    if (dispatchOrdId != null && dispatchOrdId > 0) {
@@ -456,19 +579,19 @@
                }
                
                totalSuccessCount += pageSuccessCount;
                log.info("调度单第 {} 页同步完成，总数: {}, 成功: {}", 
                    (offset / pageSize) + 1, pendingTasks.size(), pageSuccessCount);
//                log.info("调度单第 {} 页同步完成，总数: {}, 成功: {}",
//                    (offset / pageSize) + 1, pendingTasks.size(), pageSuccessCount);
                
                // 如果本页数据少于每页大小，说明已经是最后一页
                if (pendingTasks.size() < pageSize) {
                    log.info("已到达最后一页，调度单同步结束");
//                    log.info("已到达最后一页，调度单同步结束");
                    break;
                }
                
                offset += pageSize; // 下一页
            }
            
            log.info("批量同步调度单完成，总成功数: {}", totalSuccessCount);
//            log.info("批量同步调度单完成，总成功数: {}", totalSuccessCount);
            return totalSuccessCount;
            
        } catch (Exception e) {
@@ -494,7 +617,7 @@
                SysDept dept = sysDeptMapper.selectDeptById(task.getDeptId());
                if (dept != null && StringUtils.isNotEmpty(dept.getDispatchOrderClass())) {
                    dispatchOrdClass = dept.getDispatchOrderClass();
                    log.info("获取任务所属部门的调度单编码成功，部门ID: {}, 调度单编码: {}", task.getDeptId(), dispatchOrdClass);
//                    log.info("获取任务所属部门的调度单编码成功，部门ID: {}, 调度单编码: {}", task.getDeptId(), dispatchOrdClass);
                }
            } catch (Exception e) {
                log.error("查询任务所属部门信息异常，部门ID: {}", task.getDeptId(), e);
@@ -534,8 +657,20 @@
        // 操作命令
        params.put("DispatchOrd_Check", "0"); // 3=直接强制完成
        
        // 绩效和费用
        params.put("DispatchOrdPerfomance", emergency.getTransferPrice() != null ? emergency.getTransferPrice().toString() : "0");
        // 绩效和费用：确保数值字段不为null
        String transferPrice = "0";
        if (emergency.getTransferPrice() != null) {
            try {
                transferPrice = emergency.getTransferPrice().toString();
                if (transferPrice.contains(".")) {
                    transferPrice = new java.math.BigDecimal(transferPrice).stripTrailingZeros().toPlainString();
                }
            } catch (Exception e) {
                log.warn("转换转运价格失败，任务ID: {}, 使用默认值0", task.getTaskId(), e);
                transferPrice = "0";
            }
        }
        params.put("DispatchOrdPerfomance", transferPrice);
        params.put("StretcherMoney", "0"); // 抬担架费
        params.put("AddMoneyType", ""); // 附加项目
        params.put("AddMoney", "0"); // 附加项目费用
@@ -568,7 +703,8 @@
        params.put("ServiceOrdPtDoctorPhone", ""); // 患者医生电话
        params.put("TransferModeID", ""); // 转运方式
        params.put("ServiceOrdVIP", "0"); // VIP客户
        params.put("ServiceOrdTraTxnPrice", emergency.getTransferPrice() != null ? emergency.getTransferPrice().toString() : "0"); // 成交价
        // 价格字段复用，确保一致性
        params.put("ServiceOrdTraTxnPrice", transferPrice); // 成交价
        params.put("ServiceOrdTraPrePayment", "0"); // 需预付款
        params.put("SettlementPrice", "0"); // 结算价
        params.put("ServiceOrdTraPriceReason", ""); // 差价原因
@@ -585,7 +721,21 @@
        params.put("ServiceOrdEstimatedOrderDate", ""); // 预计派单时间
        params.put("ServiceOrdEstimatedOrderDateOld", ""); // 原预计派单时间
        params.put("ServiceOrdViaDistance", "0"); // 中途距离
        params.put("ServiceOrdTraDistance", emergency.getTransferDistance() != null ? emergency.getTransferDistance().toString() : "0"); // 距离
        // 距离字段：确保不为空，避免旧系统接口报错
        String transferDistance = "0";
        if (emergency.getTransferDistance() != null) {
            try {
                transferDistance = emergency.getTransferDistance().toString();
                // 去除可能的小数点后多余的0
                if (transferDistance.contains(".")) {
                    transferDistance = new java.math.BigDecimal(transferDistance).stripTrailingZeros().toPlainString();
                }
            } catch (Exception e) {
                log.warn("转换转运距离失败，任务ID: {}, 使用默认值0", task.getTaskId(), e);
                transferDistance = "0";
            }
        }
        params.put("ServiceOrdTraDistance", transferDistance);
        params.put("OrderLevel", "0"); // 查看等级
        params.put("ServiceOrdDepartureType", "1"); // 预约类型
        params.put("ConditionLevel", "0"); // 病重级别
@@ -715,8 +865,8 @@
//            params.put("Entourage_3", doctorOaId);  // 医生
//            params.put("Entourage_4", nurseOaId);   // 护士
            
            log.info("任务执行人员同步成功，任务ID: {}, 领队ID: {}, 司机: {}, 医生: {}, 护士: {}", 
                task.getTaskId(), leadEntourageId, driverOaId, doctorOaId, nurseOaId);
//            log.info("任务执行人员同步成功，任务ID: {}, 领队ID: {}, 司机: {}, 医生: {}, 护士: {}",
//                task.getTaskId(), leadEntourageId, driverOaId, doctorOaId, nurseOaId);
            
        } catch (Exception e) {
            log.error("同步任务执行人员异常，任务ID: {}", task.getTaskId(), e);
@@ -756,7 +906,7 @@
            }
            
            // 如果数据库中没有执行人员信息，尝试从任务的主要执行人获取
            log.warn("数据库中未找到执行人员信息，尝试从任务主要执行人获取，任务ID: {}", taskId);
//            log.warn("数据库中未找到执行人员信息，尝试从任务主要执行人获取，任务ID: {}", taskId);
            SysTask task = sysTaskMapper.selectSysTaskByTaskId(taskId);
            if (task != null && task.getAssigneeId() != null) {
                SysUser user = sysUserMapper.selectUserById(task.getAssigneeId());
@@ -883,8 +1033,8 @@
                if (dept != null && StringUtils.isNotEmpty(dept.getServiceOrderClass())) {
                    // 使用部门的服务单编码作为ServiceOrdClass
                    serviceOrdClass = dept.getServiceOrderClass();
                    log.info("获取任务所属部门的服务单编码成功，部门ID: {}, 部门名称: {}, 服务单编码: {}", 
                        task.getDeptId(), dept.getDeptName(), serviceOrdClass);
//                    log.info("获取任务所属部门的服务单编码成功，部门ID: {}, 部门名称: {}, 服务单编码: {}",
//                        task.getDeptId(), dept.getDeptName(), serviceOrdClass);
                } else {
                    log.warn("任务所属部门未配置服务单编码，部门ID: {}、部门名称: {}，使用默认值", 
                        task.getDeptId(), dept != null ? dept.getDeptName() : "null");
@@ -900,7 +1050,7 @@
        String serviceOrdAreaType = "1"; // 默认值
        if (StringUtils.isNotEmpty(emergency.getDocumentTypeId())) {
            serviceOrdAreaType = emergency.getDocumentTypeId();
            log.info("获取单据类型ID成功，任务ID: {}, 单据类型ID: {}", task.getTaskId(), serviceOrdAreaType);
//            log.info("获取单据类型ID成功，任务ID: {}, 单据类型ID: {}", task.getTaskId(), serviceOrdAreaType);
        } else {
            log.warn("任务未配置单据类型ID，任务ID: {}，使用默认值", task.getTaskId());
        }
@@ -913,7 +1063,7 @@
        String serviceOrdType = "1"; // 默认值
        if (StringUtils.isNotEmpty(emergency.getTaskTypeId())) {
            serviceOrdType = emergency.getTaskTypeId();
            log.info("获取任务类型ID成功，任务ID: {}, 任务类型ID: {}", taskId, serviceOrdType);
//            log.info("获取任务类型ID成功，任务ID: {}, 任务类型ID: {}", taskId, serviceOrdType);
        } else {
            log.warn("任务未配置任务类型ID，任务ID: {}，使用默认值", taskId);
        }
@@ -1019,7 +1169,7 @@
            HttpsURLConnection httpsConn = (HttpsURLConnection) conn;
            httpsConn.setSSLSocketFactory(createTrustAllSSLContext().getSocketFactory());
            httpsConn.setHostnameVerifier((hostname, session) -> true); // 信任所有主机名
            log.debug("配置HTTPS连接，信任所有SSL证书，URL: {}", urlString);
//            log.debug("配置HTTPS连接，信任所有SSL证书，URL: {}", urlString);
        }
        
        try {
@@ -1135,6 +1285,93 @@
        }
    }
    
    // 删除下面的重复方法，因为我们将使用MapValueUtils工具类中的方法
    /*
    private String getStringValue(Map<String, Object> map, String key) {
        Object value = map.get(key);
        return value != null ? value.toString() : null;
    }
    
    private BigDecimal getBigDecimalValue(Map<String, Object> map, String key) {
        Object value = map.get(key);
        if (value == null) {
            return null;
        }
        if (value instanceof BigDecimal) {
            return (BigDecimal) value;
        }
        try {
            return new BigDecimal(value.toString());
        } catch (NumberFormatException e) {
            return null;
        }
    }
    
    private Long getLongValue(Map<String, Object> map, String key) {
        Object value = map.get(key);
        if (value == null) {
            return null;
        }
        if (value instanceof Long) {
            return (Long) value;
        }
        try {
            return Long.valueOf(value.toString());
        } catch (NumberFormatException e) {
            return null;
        }
    }
    
    private Integer getIntegerValue(Map<String, Object> map, String key) {
        Object value = map.get(key);
        if (value == null) {
            return null;
        }
        if (value instanceof Integer) {
            return (Integer) value;
        }
        try {
            return Integer.valueOf(value.toString());
        } catch (NumberFormatException e) {
            return null;
        }
    }
    
    private Date getDateValue(Map<String, Object> map, String key) {
        Object value = map.get(key);
        if (value == null) {
            return null;
        }
        if (value instanceof Date) {
            return (Date) value;
        }
        // 如果是字符串，尝试解析
        if (value instanceof String) {
            try {
                return DateUtils.parseDate(value.toString());
            } catch (Exception e) {
                return null;
            }
        }
        return null;
    }
    
    private boolean isValidDateFormat(String dateStr, String format) {
        if (StringUtils.isEmpty(dateStr)) {
            return false;
        }
        
        try {
            SimpleDateFormat sdf = new SimpleDateFormat(format);
            sdf.setLenient(false);
            sdf.parse(dateStr);
            return true;
        } catch (Exception e) {
            return false;
        }
    }
    */
    
    /**
     * 重新同步车辆和人员变更的任务到旧系统
     * 当任务的车辆信息或人员信息发生变更时，需要调用旧系统接口重新同步
@@ -1181,7 +1418,47 @@
                return false;
            }
            
            log.info("开始重新同步调度单，任务ID: {}, DispatchOrdID: {}", taskId, emergency.getLegacyDispatchOrdId());
            // ====== 前置校验：确保任务数据完整 ======
            
            // 1. 检查是否已分配车辆
            List<SysTaskVehicle> taskVehicles = sysTaskVehicleMapper.selectSysTaskVehicleByTaskId(taskId);
            if (taskVehicles == null || taskVehicles.isEmpty()) {
                log.warn("任务未分配车辆，跳过调度单重新同步，任务ID: {}", taskId);
                return false;
            }
            
            // 2. 检查是否已分配执行人员
            List<SysTaskAssignee> taskAssignees = sysTaskAssigneeMapper.selectSysTaskAssigneeByTaskId(taskId);
            if (taskAssignees == null || taskAssignees.isEmpty()) {
                log.warn("任务未分配执行人员，跳过调度单重新同步，任务ID: {}", taskId);
                return false;
            }
            
            // 3. 检查预约时间是否有效
            if (task.getPlannedStartTime() == null || task.getPlannedStartTime().getTime() <= 0L) {
                log.warn("任务预约时间无效，跳过调度单重新同步，任务ID: {}", taskId);
                return false;
            }
            
            // 4. 检查转出医院信息
            if (StringUtils.isEmpty(emergency.getHospitalOutName()) || StringUtils.isEmpty(emergency.getHospitalOutAddress())) {
                log.warn("任务转出医院信息不完整，跳过调度单重新同步，任务ID: {}", taskId);
                return false;
            }
            
            // 5. 检查转入医院信息
            if (StringUtils.isEmpty(emergency.getHospitalInName()) || StringUtils.isEmpty(emergency.getHospitalInAddress())) {
                log.warn("任务转入医院信息不完整，跳过调度单重新同步，任务ID: {}", taskId);
                return false;
            }
            
            // 6. 检查患者基本信息
            if (StringUtils.isEmpty(emergency.getPatientName()) || StringUtils.isEmpty(emergency.getPatientPhone())) {
                log.warn("任务患者信息不完整，跳过调度单重新同步，任务ID: {}", taskId);
                return false;
            }
            
            log.info("任务数据校验通过，开始重新同步调度单，任务ID: {}, DispatchOrdID: {}", taskId, emergency.getLegacyDispatchOrdId());
            
            // 构建请求参数（使用相同的参数构建方法）
            Map<String, String> params = buildDispatchOrderParams(task, emergency);
@@ -1191,7 +1468,7 @@
            log.info("重新同步调度单到旧系统请求参数: {}", params);
            // 发送HTTP请求到旧系统（使用admin_save_25.asp接口）
            String response = sendHttpPost(legacyConfig.getDispatchUpdateUrl(), params);
            log.info("重新同步调度单到旧系统响应: ServiceOrdID:{},DispatchOrdId:{},Result: {}",emergency.getLegacyServiceOrdId(),emergency.getLegacyDispatchOrdId(), response);
//            log.info("重新同步调度单到旧系统响应: ServiceOrdID:{},DispatchOrdId:{},Result: {}",emergency.getLegacyServiceOrdId(),emergency.getLegacyDispatchOrdId(), response);
            // 解析响应
//            Long dispatchOrdId = parseResponse(response);
            
@@ -1202,7 +1479,7 @@
                emergency.setDispatchSyncErrorMsg(null);
                sysTaskEmergencyService.updateSysTaskEmergency(emergency);
                
                log.info("调度单重新同步成功，任务ID: {}, DispatchOrdID: {}", taskId, emergency.getLegacyDispatchOrdId());
//                log.info("调度单重新同步成功，任务ID: {}, DispatchOrdID: {}", taskId, emergency.getLegacyDispatchOrdId());
                return true;
            } else {
                // 重新同步失败
@@ -1250,17 +1527,17 @@
                // 分页查询需要重新同步的任务
                List<SysTaskEmergency> needResyncTasks = sysTaskEmergencyMapper.selectNeedResyncTasks(offset, pageSize);
                
                log.info("查询到需要重新同步的任务数量: {}", needResyncTasks.size());
//                log.info("查询到需要重新同步的任务数量: {}", needResyncTasks.size());
                if (needResyncTasks == null || needResyncTasks.isEmpty()) {
                    log.info("没有更多需要重新同步的任务，offset: {}", offset);
                    break; // 没有更多数据，退出循环
                }
                
                log.info("开始重新同步调度单第 {} 页，任务数量: {}", (offset / pageSize) + 1, needResyncTasks.size());
//                log.info("开始重新同步调度单第 {} 页，任务数量: {}", (offset / pageSize) + 1, needResyncTasks.size());
                
                int pageSuccessCount = 0;
                for (SysTaskEmergency emergency : needResyncTasks) {
                    log.info("开始重新同步调度单，任务ID: {}", emergency.getTaskId());
//                    log.info("开始重新同步调度单，任务ID: {}", emergency.getTaskId());
                    boolean success = resyncDispatchOrderToLegacy(emergency.getTaskId());
                    
                    if (success) {
@@ -1278,19 +1555,19 @@
                }
                
                totalSuccessCount += pageSuccessCount;
                log.info("调度单重新同步第 {} 页完成，总数: {}, 成功: {}", 
                    (offset / pageSize) + 1, needResyncTasks.size(), pageSuccessCount);
//                log.info("调度单重新同步第 {} 页完成，总数: {}, 成功: {}",
//                    (offset / pageSize) + 1, needResyncTasks.size(), pageSuccessCount);
                
                // 如果本页数据少于每页大小，说明已经是最后一页
                if (needResyncTasks.size() < pageSize) {
                    log.info("已到达最后一页，调度单重新同步结束");
//                    log.info("已到达最后一页，调度单重新同步结束");
                    break;
                }
                
                offset += pageSize; // 下一页
            }
            
            log.info("批量重新同步调度单完成，总成功数: {}", totalSuccessCount);
//            log.info("批量重新同步调度单完成，总成功数: {}", totalSuccessCount);
            return totalSuccessCount;
            
        } catch (Exception e) {