package com.ruoyi.system.service.impl;
|
|
import com.ruoyi.common.config.LegacySystemConfig;
|
import com.ruoyi.common.core.domain.entity.SysUser;
|
import com.ruoyi.common.utils.LongUtil;
|
import com.ruoyi.common.utils.MapValueUtils;
|
import com.ruoyi.common.utils.StringUtils;
|
import com.ruoyi.system.domain.SysTask;
|
import com.ruoyi.system.domain.SysTaskAssignee;
|
import com.ruoyi.system.domain.SysTaskEmergency;
|
import com.ruoyi.system.domain.SysTaskVehicle;
|
import com.ruoyi.system.domain.vo.TaskCreateVO;
|
import com.ruoyi.system.event.TaskDispatchSyncEvent;
|
import com.ruoyi.system.mapper.*;
|
import com.ruoyi.system.service.ISysTaskEmergencyService;
|
import com.ruoyi.system.service.ITaskDispatchSyncService;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.context.ApplicationEventPublisher;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.CollectionUtils;
|
|
import java.util.Date;
|
import java.util.List;
|
import java.util.Map;
|
|
/**
|
* 同步新系统中的调度到旧系统中
|
*/
|
@Slf4j
|
@Service
|
public class TaskDispatchSyncServiceImpl implements ITaskDispatchSyncService {
|
|
@Autowired
|
private ApplicationEventPublisher eventPublisher;
|
|
@Override
|
public Long syncDispatch(Long taskId) {
|
return this.syncDispatchOrderToLegacy(taskId);
|
}
|
|
@Autowired
|
private LegacySystemConfig legacyConfig;
|
|
@Autowired
|
private ISysTaskEmergencyService sysTaskEmergencyService;
|
|
@Autowired
|
private SysTaskMapper sysTaskMapper;
|
|
@Autowired
|
private SysTaskVehicleMapper sysTaskVehicleMapper;
|
|
@Autowired
|
private SysTaskAssigneeMapper sysTaskAssigneeMapper;
|
|
@Autowired
|
private SysUserMapper sysUserMapper;
|
|
@Autowired
|
private LegacyTransferSyncMapper legacyTransferSyncMapper;
|
|
@Autowired
|
private TaskSyncUtilService taskSyncUtilService;
|
@Autowired
|
private TaskDispatchSyncUtilService taskDispatchSyncUtilService;
|
|
|
|
/**
|
* 重新同步车辆和人员变更的任务到旧系统
|
* 当任务的车辆信息或人员信息发生变更时，需要调用旧系统接口重新同步
|
* 使用 admin_save_25.asp 接口，而不是 admin_save_24.gds
|
*/
|
@Override
|
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;
|
}
|
|
// ====== 前置校验：确保任务数据完整 ======
|
|
// 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, Object> params = taskDispatchSyncUtilService.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 =taskSyncUtilService.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;
|
}
|
}
|
|
|
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;
|
}
|
}
|
|
/**
|
* 同步调度单到旧系统（admin_save_24.asp）
|
*/
|
|
private 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 (LongUtil.isEmpty(serviceOrdId)) {
|
log.warn("服务单未同步，无法同步调度单，任务ID: {}", taskId);
|
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);
|
sysTaskEmergencyService.updateSysTaskEmergency(emergency);
|
|
SysUser u=sysUserMapper.selectUserById(task.getCreatorId());
|
Integer oaUserID= u.getOaUserId();
|
|
// 构建请求参数
|
Map<String, Object> params = taskDispatchSyncUtilService.buildDispatchOrderParams(task, emergency);
|
|
|
// 发送HTTP请求
|
String response =taskSyncUtilService.sendHttpPost(legacyConfig.getDispatchCreateUrl(), params);
|
|
// 解析响应
|
Long dispatchOrdId = taskSyncUtilService.parseResponse(response);
|
|
if (dispatchOrdId != null && dispatchOrdId > 0) {
|
// 同步成功，更新记录
|
emergency.setLegacyDispatchOrdId(dispatchOrdId);
|
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);
|
|
eventPublisher.publishEvent(new TaskDispatchSyncEvent(this, taskId, task.getTaskCode(),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;
|
}
|
}
|
|
|
}
|
