package com.ruoyi.system.service.impl;
|
|
import com.ruoyi.common.core.domain.entity.SysDept;
|
import com.ruoyi.common.core.domain.entity.SysUser;
|
import com.ruoyi.common.utils.*;
|
import com.ruoyi.system.domain.SysTask;
|
import com.ruoyi.system.domain.SysTaskEmergency;
|
import com.ruoyi.system.domain.VehicleInfo;
|
import com.ruoyi.system.domain.enums.TaskStatus;
|
import com.ruoyi.system.domain.vo.TaskCreateVO;
|
import com.ruoyi.system.domain.vo.TaskUpdateVO;
|
import com.ruoyi.system.mapper.SysTaskEmergencyMapper;
|
import com.ruoyi.system.mapper.SysTaskMapper;
|
import com.ruoyi.system.service.ILegacyTransferSyncService;
|
import com.ruoyi.system.service.ISysDeptService;
|
import com.ruoyi.system.service.ISysTaskService;
|
import com.ruoyi.system.mapper.LegacyTransferSyncMapper;
|
import com.ruoyi.system.mapper.VehicleInfoMapper;
|
import com.ruoyi.system.service.ISysUserService;
|
import com.ruoyi.system.service.IWechatTaskNotifyService;
|
import com.ruoyi.system.service.INotifyTaskService;
|
import com.ruoyi.system.service.INotifyDispatchService;
|
import com.ruoyi.system.domain.NotifyTask;
|
import com.ruoyi.system.utils.TaskStatusConverter;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import java.text.SimpleDateFormat;
|
import java.math.BigDecimal;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.HashSet;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
|
/**
|
* 旧系统转运单同步Service业务层处理
|
*
|
* @author ruoyi
|
* @date 2025-11-19
|
*/
|
@Service
|
public class LegacyTransferSyncServiceImpl implements ILegacyTransferSyncService {
|
|
private static final Logger log = LoggerFactory.getLogger(LegacyTransferSyncServiceImpl.class);
|
|
@Autowired
|
private SysTaskMapper sysTaskMapper;
|
|
@Autowired
|
private SysTaskEmergencyMapper sysTaskEmergencyMapper;
|
|
@Autowired
|
private ISysTaskService sysTaskService;
|
|
@Autowired
|
private LegacyTransferSyncMapper legacyTransferSyncMapper;
|
|
@Autowired
|
private VehicleInfoMapper vehicleInfoMapper;
|
|
@Autowired
|
private ISysDeptService sysDeptService;
|
|
@Autowired
|
private ISysUserService sysUserService;
|
|
@Autowired
|
private IWechatTaskNotifyService wechatTaskNotifyService;
|
|
@Autowired
|
private INotifyTaskService notifyTaskService;
|
|
@Autowired
|
private INotifyDispatchService notifyDispatchService;
|
|
|
|
/**
|
* 同步指定日期范围的旧系统转运单到新系统
|
* 优化：将多天范围拆分为逐天循环，每次仅查询1天数据，避免大数据量导致SQL Server超时
|
*
|
* @param daysAgo 多少天前的数据（如7表示同步最近7天的数据）
|
* @return 成功同步的转运单数量
|
*/
|
@Override
|
public int syncLegacyTransferOrders(int daysAgo) {
|
try {
|
// 参数验证
|
if (daysAgo <= 0) {
|
log.error("天数参数必须大于0");
|
return 0;
|
}
|
|
log.info("[转运单同步] 开始同步，范围: 最近{}天", daysAgo);
|
int totalSuccessCount = 0;
|
int totalDays = daysAgo + 1;
|
|
// 按天拆分，每次只同步1天的数据，避免大范围查询超时
|
for (int i = daysAgo; i >= 0; i--) {
|
Date dayStart = DateUtils.addDays(new Date(), -i);
|
String dayStartStr = DateUtils.parseDateToStr("yyyy-MM-dd", dayStart) + " 00:00:00";
|
String dayEndStr = DateUtils.parseDateToStr("yyyy-MM-dd", dayStart) + " 23:59:59";
|
|
int dayIndex = totalDays - i;
|
log.info("[转运单同步] 处理天 {}/{}: {}", dayIndex, totalDays, dayStartStr);
|
int daySuccessCount = syncSingleDayOrders(dayStartStr, dayEndStr);
|
totalSuccessCount += daySuccessCount;
|
log.info("[转运单同步] {} 完成，新增同步: {}条，累计: {}条", dayStartStr, daySuccessCount, totalSuccessCount);
|
}
|
|
log.info("[转运单同步] 全部完成，共新增同步 {}条", totalSuccessCount);
|
return totalSuccessCount;
|
|
} catch (Exception e) {
|
log.error("同步{}天前的旧系统转运单数据异常", daysAgo, e);
|
return 0;
|
}
|
}
|
|
/**
|
* 同步单天的转运单数据（Keyset游标分页）
|
*
|
* @param startDateStr 开始日期字符串（yyyy-MM-dd）
|
* @param endDateStr 结束日期字符串（yyyy-MM-dd）
|
* @return 成功同步的转运单数量
|
*/
|
private int syncSingleDayOrders(String startDateStr, String endDateStr) {
|
final int PAGE_SIZE = 5;
|
long lastId = 0L;
|
int successCount = 0;
|
int pageNum = 0;
|
int totalProcessed = 0;
|
|
try {
|
while (true) {
|
List<Map<String, Object>> transferOrders = legacyTransferSyncMapper.selectTransferOrders(startDateStr, endDateStr, lastId, PAGE_SIZE);
|
|
if (transferOrders == null || transferOrders.isEmpty()) {
|
break;
|
}
|
|
pageNum++;
|
int totalCount = transferOrders.size();
|
int processedCount = 0;
|
|
log.info("[转运单同步] {} 第{}页，获取{}.条数据，lastId={}", startDateStr, pageNum, totalCount, lastId);
|
|
for (Map<String, Object> order : transferOrders) {
|
processedCount++;
|
totalProcessed++;
|
try {
|
Long serviceOrdID = MapValueUtils.getLongValue(order, "ServiceOrdID");
|
Long dispatchOrdID = MapValueUtils.getLongValue(order, "DispatchOrdID");
|
|
if (serviceOrdID == null || serviceOrdID <= 0) {
|
log.warn("第{}条数据服务单ID为空，跳过处理", processedCount);
|
continue;
|
}
|
|
// 检查是否已同步
|
if (isTransferOrderSynced(serviceOrdID, dispatchOrdID)) {
|
log.debug("[转运单同步] 已存在，执行更新: ServiceOrdID={}", serviceOrdID);
|
updateTransferOrder(serviceOrdID, dispatchOrdID, order);
|
continue;
|
}
|
|
// 同步单个转运单
|
log.info("[转运单同步] 新增同步: ServiceOrdID={}, DispatchOrdID={}", serviceOrdID, dispatchOrdID);
|
boolean success = syncSingleTransferOrder(serviceOrdID, dispatchOrdID, order);
|
if (success) {
|
successCount++;
|
log.info("[转运单同步] 同步成功: ServiceOrdID={}, 当天新增累计: {}", serviceOrdID, successCount);
|
} else {
|
log.warn("[转运单同步] 同步失败: ServiceOrdID={}, DispatchOrdID={}", serviceOrdID, dispatchOrdID);
|
}
|
|
// 控制同步频率，避免请求过快
|
Thread.sleep(100);
|
} catch (InterruptedException ie) {
|
log.warn("同步任务被中断");
|
Thread.currentThread().interrupt();
|
return successCount;
|
} catch (Exception e) {
|
log.error("同步单个转运单失败: ServiceOrdID={}, DispatchOrdID={}",
|
MapValueUtils.getStringValue(order, "ServiceOrdID"),
|
MapValueUtils.getStringValue(order, "DispatchOrdID"), e);
|
}
|
}
|
|
// 更新游标为本页最后一条的 ServiceOrdID
|
Map<String, Object> lastOrder = transferOrders.get(transferOrders.size() - 1);
|
Long lastServiceOrdID = MapValueUtils.getLongValue(lastOrder, "ServiceOrdID");
|
if (lastServiceOrdID != null && lastServiceOrdID > 0) {
|
lastId = lastServiceOrdID;
|
} else {
|
break;
|
}
|
|
// 本页未满一页，说明已无更多数据
|
if (totalCount < PAGE_SIZE) {
|
break;
|
}
|
}
|
|
log.info("[转运单同步] {} 分页完成，共处理: {}条，新增同步: {}条", startDateStr, totalProcessed, successCount);
|
} catch (Exception e) {
|
log.error("同步单天转运单数据异常: date={}", startDateStr, e);
|
}
|
|
return successCount;
|
}
|
|
/**
|
* 同步单个旧系统转运单到新系统
|
*
|
* @param serviceOrdID 服务单ID
|
* @param dispatchOrdID 调度单ID
|
* @return 是否同步成功
|
*/
|
@Override
|
public boolean syncSingleTransferOrder(Long serviceOrdID, Long dispatchOrdID) {
|
// log.info("开始同步单个转运单: ServiceOrdID={}, DispatchOrdID={}", serviceOrdID, dispatchOrdID);
|
|
try {
|
// 检查参数有效性
|
if (serviceOrdID == null || serviceOrdID <= 0) {
|
log.error("服务单ID不能为空");
|
return false;
|
}
|
|
|
|
List<Map<String, Object>> transferOrders = legacyTransferSyncMapper.selectTransferOrdersByIDs(serviceOrdID, dispatchOrdID);
|
|
Map<String, Object> order = transferOrders.get(0);
|
|
// 检查是否已同步
|
if (isTransferOrderSynced(serviceOrdID, dispatchOrdID)) {
|
// log.info("转运单已同步，跳过: ServiceOrdID={}, DispatchOrdID={}", serviceOrdID, dispatchOrdID);
|
updateTransferOrder(serviceOrdID, dispatchOrdID, order);
|
return true;
|
}
|
|
|
if (transferOrders == null || transferOrders.isEmpty()) {
|
log.error("未查询到对应的转运单信息: ServiceOrdID={}, DispatchOrdID={}", serviceOrdID, dispatchOrdID);
|
return false;
|
}
|
|
|
// 同步单个转运单
|
return syncSingleTransferOrder(serviceOrdID, dispatchOrdID, order);
|
|
} catch (Exception e) {
|
log.error("同步单个转运单异常: ServiceOrdID={}, DispatchOrdID={}", serviceOrdID, dispatchOrdID, e);
|
return false;
|
}
|
}
|
|
/**
|
* 更新单个转运单
|
* @param serviceOrdID
|
* @param dispatchOrdID
|
* @param order
|
* @return
|
*/
|
private boolean updateTransferOrder(Long serviceOrdID, Long dispatchOrdID, Map<String, Object> order){
|
// log.info("开始同步单个转运单: ServiceOrdID={}, DispatchOrdID={}", serviceOrdID, dispatchOrdID);
|
String sysTaskCode="";
|
try {
|
SysTaskEmergency emergency=sysTaskEmergencyMapper.selectByLegacyServiceOrdId(serviceOrdID);
|
if(emergency.getNeedResync().equals(1)){
|
log.info("新系统需要同步到旧系统那里，所以不要同步旧数据到新系统,serviceOrdID={}, DispatchOrdID={}", serviceOrdID, dispatchOrdID);
|
return false;
|
}
|
// 构造TaskCreateVO对象
|
TaskCreateVO createTaskVo = buildCreateTaskVo(serviceOrdID, dispatchOrdID, order);
|
if (createTaskVo == null) {
|
log.error("构造TaskCreateVO失败: ServiceOrdID={}, DispatchOrdID={}", serviceOrdID, dispatchOrdID);
|
return false;
|
}
|
sysTaskCode = createTaskVo.getTaskCode();
|
// 记录创建的任务信息
|
// log.debug("准备创建任务: ServiceOrdID={}, DispatchOrdID={}, 患者姓名={}, 转出医院={}, 转入医院={}",
|
// serviceOrdID, dispatchOrdID,
|
// createTaskVo.getPatient() != null ? createTaskVo.getPatient().getName() : "未知",
|
// createTaskVo.getHospitalOut() != null ? createTaskVo.getHospitalOut().getName() : "未知",
|
// createTaskVo.getHospitalIn() != null ? createTaskVo.getHospitalIn().getName() : "未知");
|
/**
|
* 开单时间
|
*/
|
Date ServiceOrd_CC_Time= MapValueUtils.getDateValue(order, "ServiceOrd_CC_Time");
|
// 调用sysTaskService创建任务
|
String serviceOrdClass = MapValueUtils.getStringValue(order,"ServiceOrdClass");
|
String serviceOrdNo = MapValueUtils.getStringValue(order,"ServiceOrdNo");
|
|
Integer oauserId=MapValueUtils.getIntegerValue(order,"ServiceOrd_CC_ID");
|
if(oauserId==null){
|
oauserId=MapValueUtils.getIntegerValue(order,"ServiceOrd_NS_ID");
|
}
|
if(oauserId==null || oauserId==0) {
|
log.error("创建任务时，获取创建人信息失败，serviceOrdID={}, DispatchOrdID={} ServiceOrd_NS_ID={},ServiceOrd_CC_ID={}", serviceOrdID, dispatchOrdID, MapValueUtils.getIntegerValue(order, "ServiceOrd_NS_ID"), MapValueUtils.getIntegerValue(order, "ServiceOrd_CC_ID"));
|
return false;
|
}
|
SysUser sysUser=sysUserService.selectUserByOaUserId(oauserId);
|
Long taskCreatorId=sysUser==null?null:sysUser.getUserId();
|
String createUserName=sysUser==null?"system":sysUser.getUserName();
|
if(taskCreatorId==null || createUserName==null){
|
log.error("创建任务时，获取创建人信息失败，serviceOrdID={}, DispatchOrdID={}", serviceOrdID, dispatchOrdID);
|
return false;
|
}
|
SysDept dept=sysDeptService.selectDeptByServiceClass(serviceOrdClass);
|
Long deptId=dept==null?null:dept.getDeptId();
|
if(deptId==null){
|
log.error("创建任务时，获取部门信息失败，serviceOrdID={}, DispatchOrdID={}", serviceOrdID, dispatchOrdID);
|
return false;
|
}
|
createTaskVo.setDeptId(deptId);
|
TaskUpdateVO updateTaskVo = new TaskUpdateVO();
|
BeanUtils.copyProperties(createTaskVo, updateTaskVo);
|
|
// log.info("开始保存转运任务,serviceOrdID={}, DispatchOrdID={}", serviceOrdID, dispatchOrdID);
|
|
int result = sysTaskService.updateTask(updateTaskVo,serviceOrdID,dispatchOrdID, serviceOrdNo, taskCreatorId,createUserName, deptId, ServiceOrd_CC_Time, ServiceOrd_CC_Time);
|
|
if (result > 0) {
|
// log.info("转运单同步成功: ServiceOrdID={}, DispatchOrdID={}, 创建的任务ID={}", serviceOrdID, dispatchOrdID, result);
|
|
try {
|
// 直接使用方法头部已查询的 emergency 获取 taskId
|
Long taskId = emergency.getTaskId();
|
if (taskId != null) {
|
notifyTransferOrderByWechat(taskId, serviceOrdID, dispatchOrdID, serviceOrdNo, ServiceOrd_CC_Time, dept, order);
|
} else {
|
log.warn("更新后找不到taskId，跳过通知: ServiceOrdID={}", serviceOrdID);
|
}
|
} catch (Exception e) {
|
log.error("转运单同步成功后发送微信通知失败: ServiceOrdID={}, DispatchOrdID={}", serviceOrdID, dispatchOrdID, e);
|
}
|
|
return true;
|
} else {
|
log.error("转运单同步失败: ServiceOrdID={}, DispatchOrdID={}", serviceOrdID, dispatchOrdID);
|
return false;
|
}
|
|
} catch (Exception e) {
|
log.error("同步单个转运单异常: ServiceOrdID={}, DispatchOrdID={},sysTaskCode:{}", serviceOrdID, dispatchOrdID,sysTaskCode, e);
|
return false;
|
}
|
}
|
/**
|
* 同步单个旧系统转运单到新系统（带详细信息）
|
*
|
* @param serviceOrdID 服务单ID
|
* @param dispatchOrdID 调度单ID
|
* @param order 转运单详细信息
|
* @return 是否同步成功
|
*/
|
private boolean syncSingleTransferOrder(Long serviceOrdID, Long dispatchOrdID, Map<String, Object> order) {
|
// log.info("开始同步单个转运单: ServiceOrdID={}, DispatchOrdID={}", serviceOrdID, dispatchOrdID);
|
String sysTaskCode="";
|
try {
|
// 构造TaskCreateVO对象
|
TaskCreateVO createTaskVo = buildCreateTaskVo(serviceOrdID, dispatchOrdID, order);
|
|
if (createTaskVo == null) {
|
log.error("构造TaskCreateVO失败: ServiceOrdID={}, DispatchOrdID={}", serviceOrdID, dispatchOrdID);
|
return false;
|
}
|
sysTaskCode = createTaskVo.getTaskCode();
|
// 记录创建的任务信息
|
// log.debug("准备创建任务: ServiceOrdID={}, DispatchOrdID={}, 患者姓名={}, 转出医院={}, 转入医院={}",
|
// serviceOrdID, dispatchOrdID,
|
// createTaskVo.getPatient() != null ? createTaskVo.getPatient().getName() : "未知",
|
// createTaskVo.getHospitalOut() != null ? createTaskVo.getHospitalOut().getName() : "未知",
|
// createTaskVo.getHospitalIn() != null ? createTaskVo.getHospitalIn().getName() : "未知");
|
/**
|
* 开单时间
|
*/
|
Date ServiceOrd_CC_Time= MapValueUtils.getDateValue(order, "ServiceOrd_CC_Time");
|
// 调用sysTaskService创建任务
|
String serviceOrdClass = MapValueUtils.getStringValue(order,"ServiceOrdClass");
|
String serviceOrdNo = MapValueUtils.getStringValue(order,"ServiceOrdNo");
|
|
/**
|
* 创建人ID
|
*/
|
Integer oauserId=MapValueUtils.getIntegerValue(order,"ServiceOrd_CC_ID");
|
if(oauserId==null || oauserId==0) {
|
oauserId=MapValueUtils.getIntegerValue(order,"ServiceOrd_NS_ID");
|
}
|
SysUser sysUser=sysUserService.selectUserByOaUserId(oauserId);
|
if(sysUser==null) {
|
log.error("创建任务时，获取创建人信息失败，serviceOrdID={}, DispatchOrdID={} ServiceOrd_CC_ID:{},ServiceOrd_NS_ID:{}", serviceOrdID, dispatchOrdID, MapValueUtils.getIntegerValue(order, "ServiceOrd_CC_ID"), MapValueUtils.getIntegerValue(order, "ServiceOrd_NS_ID"));
|
return false;
|
}
|
|
Long taskCreatorId= sysUser.getUserId();
|
String createUserName= sysUser.getUserName();
|
SysDept dept=sysDeptService.selectDeptByServiceClass(serviceOrdClass);
|
Long deptId=dept==null?null:dept.getDeptId();
|
if(deptId==null){
|
log.error("创建任务时，获取部门信息失败，serviceOrdID={}, DispatchOrdID={} ServiceOrdClass:{}", serviceOrdID, dispatchOrdID, serviceOrdClass);
|
return false;
|
}
|
createTaskVo.setDeptId(deptId);
|
|
|
Long taskId = sysTaskService.insertTask(createTaskVo,serviceOrdID,dispatchOrdID, serviceOrdNo, taskCreatorId,createUserName, deptId, ServiceOrd_CC_Time, ServiceOrd_CC_Time);
|
|
if (taskId != null && taskId > 0) {
|
// log.info("转运单同步成功: ServiceOrdID={}, DispatchOrdID={}, 创建的任务ID={}", serviceOrdID, dispatchOrdID, taskId);
|
|
try {
|
notifyTransferOrderByWechat(taskId, serviceOrdID, dispatchOrdID, serviceOrdNo, ServiceOrd_CC_Time, dept, order);
|
} catch (Exception e) {
|
log.error("转运单同步成功后发送微信通知失败: ServiceOrdID={}, DispatchOrdID={}", serviceOrdID, dispatchOrdID, e);
|
}
|
|
return true;
|
} else {
|
log.error("转运单同步失败: ServiceOrdID={}, DispatchOrdID={}", serviceOrdID, dispatchOrdID);
|
return false;
|
}
|
|
} catch (Exception e) {
|
log.error("同步单个转运单异常: ServiceOrdID={}, DispatchOrdID={},sysTaskCode:{}", serviceOrdID, dispatchOrdID,sysTaskCode, e);
|
return false;
|
}
|
}
|
|
/**
|
* 检查转运单是否已同步
|
*
|
* @param serviceOrdID 服务单ID
|
* @param dispatchOrdID 调度单ID
|
* @return 是否已同步
|
*/
|
@Override
|
public boolean isTransferOrderSynced(Long serviceOrdID, Long dispatchOrdID) {
|
try {
|
// 检查参数有效性
|
if (LongUtil.isEmpty(serviceOrdID)) {
|
log.warn("服务单ID不能为空");
|
return false;
|
}
|
|
// 检查sys_task_emergency表中是否已存在对应的记录
|
// 条件：legacy_service_ord_id = serviceOrdID 或 legacy_dispatch_ord_id = dispatchOrdID
|
|
try {
|
SysTaskEmergency emergency = sysTaskEmergencyMapper.selectByLegacyServiceOrdId(serviceOrdID);
|
if (emergency != null) {
|
return true;
|
}
|
} catch (NumberFormatException e) {
|
log.warn("服务单ID不是有效数字: {}", serviceOrdID);
|
}
|
|
if (LongUtil.isNotEmpty(dispatchOrdID)) {
|
try {
|
SysTaskEmergency emergency = sysTaskEmergencyMapper.selectByLegacyDispatchOrdId(dispatchOrdID);
|
if (emergency != null) {
|
return true;
|
}
|
} catch (NumberFormatException e) {
|
log.warn("调度单ID不是有效数字: {}", dispatchOrdID);
|
}
|
}
|
|
return false;
|
} catch (Exception e) {
|
log.error("检查转运单是否已同步异常: ServiceOrdID={}, DispatchOrdID={}", serviceOrdID, dispatchOrdID, e);
|
return false;
|
}
|
}
|
|
private String getServiceOrdCode(Date ServiceOrd_CC_Time,String serviceOrdClass,String serviceOrdNo){
|
//BF20251101-serviceOrdNo;
|
//将 ServiceOrd_CC_Time 转为 yyyyMMdd 格式
|
String ServiceOrd_CC_Time_Str= DateUtils.parseDateToStr(DateUtils.YYYYMMDD,ServiceOrd_CC_Time);
|
//serviceOrdNo 这个是数字，固定3位数 ，将32，转成032；将1转成001
|
Integer intServiceNo=Integer.valueOf(serviceOrdNo);
|
String ServiceOrdNo_Str=String.format("%03d", intServiceNo);
|
return serviceOrdClass+ServiceOrd_CC_Time_Str+"-"+ServiceOrdNo_Str;
|
}
|
|
|
/**
|
* 构造TaskCreateVO对象用于创建任务
|
*
|
* @param serviceOrdID 服务单ID
|
* @param dispatchOrdID 调度单ID
|
* @param order 转运单详细信息
|
* @return TaskCreateVO对象
|
*/
|
@Override
|
public TaskCreateVO buildCreateTaskVo(Long serviceOrdID, Long dispatchOrdID, Map<String, Object> order) {
|
// log.info("构造TaskCreateVO: ServiceOrdID={}, DispatchOrdID={}", serviceOrdID, dispatchOrdID);
|
|
try {
|
// 检查参数有效性
|
if (order == null || order.isEmpty()) {
|
log.error("转运单详细信息不能为空");
|
return null;
|
}
|
|
if (LongUtil.isEmpty(serviceOrdID)) {
|
log.error("服务单ID不能为空");
|
return null;
|
}
|
String serviceOrdClass = MapValueUtils.getStringValue(order, "ServiceOrdClass");
|
|
TaskCreateVO createTaskVo = new TaskCreateVO();
|
String serviceOrdCode=this.getServiceOrdCode(MapValueUtils.getDateValue(order, "ServiceOrd_CC_Time"),serviceOrdClass,MapValueUtils.getStringValue(order, "ServiceOrdNo"));
|
createTaskVo.setTaskCode(serviceOrdCode);
|
// log.info("构造TaskCreateVO: ServiceOrdID={}, DispatchOrdID={},taskCode:{}", serviceOrdID, dispatchOrdID,serviceOrdCode);
|
// 设置基本信息
|
createTaskVo.setTaskType("EMERGENCY_TRANSFER"); // 急救转运任务
|
|
// 设置单据类型和任务类型ID（从旧系统字段映射）
|
String ServiceOrdAreaType = MapValueUtils.getStringValue(order, "ServiceOrdAreaType");
|
if (StringUtils.isNotEmpty(ServiceOrdAreaType)) {
|
createTaskVo.setDocumentTypeId(ServiceOrdAreaType);
|
}
|
|
String serviceOrdType = MapValueUtils.getStringValue(order, "ServiceOrdType");
|
if (StringUtils.isNotEmpty(serviceOrdType)) {
|
createTaskVo.setTaskTypeId(serviceOrdType);
|
}
|
|
|
|
String serviceOrdVIP = MapValueUtils.getStringValue(order, "ServiceOrdVIP");
|
if(serviceOrdVIP!=null){
|
createTaskVo.setServiceOrdVIP(serviceOrdVIP);
|
}else{
|
createTaskVo.setServiceOrdVIP("0");
|
}
|
|
Integer FromHQ_is = MapValueUtils.getIntegerValue(order, "FromHQ_is");
|
if(IntegerUtil.isNotEmpty(FromHQ_is)){
|
createTaskVo.setFromHQ2_is("1");
|
}else{
|
createTaskVo.setFromHQ2_is("0");
|
}
|
|
// 设置用户ID
|
Long serviceOrdUserID = MapValueUtils.getLongValue(order, "ServiceOrdUserID");
|
|
// 设置患者信息
|
TaskCreateVO.PatientInfo patientInfo = new TaskCreateVO.PatientInfo();
|
patientInfo.setName(MapValueUtils.getStringValue(order, "ServiceOrdPtName"));
|
patientInfo.setPhone(MapValueUtils.getStringValue(order, "ServiceOrdCoPhone"));
|
patientInfo.setIdCard(MapValueUtils.getStringValue(order, "ServiceOrdPtIDCard"));
|
patientInfo.setCondition(MapValueUtils.getStringValue(order, "ServiceOrdPtCondition"));
|
patientInfo.setContact(MapValueUtils.getStringValue(order, "ServiceOrdCoName"));
|
|
String serviceOrdPtSex = MapValueUtils.getStringValue(order, "ServiceOrdPtSex");
|
if(serviceOrdPtSex!=null){
|
if(serviceOrdPtSex.equals("男")){
|
patientInfo.setGender("male");
|
}else if(serviceOrdPtSex.equals("女")){
|
patientInfo.setGender("female");
|
}
|
}
|
createTaskVo.setPatient(patientInfo);
|
//1000公里，提取数字（支持小数）
|
String ServiceOrdTraDistance=MapValueUtils.getStringValue(order, "ServiceOrdTraDistance");
|
if(ServiceOrdTraDistance!=null){
|
// 保留数字和小数点，移除其他字符
|
ServiceOrdTraDistance=ServiceOrdTraDistance.replaceAll("[^0-9.]", "");
|
// 处理多个小数点的情况，只保留第一个
|
int firstDotIndex = ServiceOrdTraDistance.indexOf('.');
|
if (firstDotIndex != -1) {
|
ServiceOrdTraDistance = ServiceOrdTraDistance.substring(0, firstDotIndex + 1)
|
+ ServiceOrdTraDistance.substring(firstDotIndex + 1).replace(".", "");
|
}
|
if (!ServiceOrdTraDistance.isEmpty() && !ServiceOrdTraDistance.equals(".")) {
|
createTaskVo.setTransferDistance(new BigDecimal(ServiceOrdTraDistance));
|
}
|
}
|
|
|
// 设置转出医院信息
|
|
TaskCreateVO.HospitalInfo hospitalOutInfo = new TaskCreateVO.HospitalInfo();
|
Long hospitalOutId = MapValueUtils.getLongValue(order, "ServiceOrdPtOutHospID");
|
hospitalOutInfo.setId(hospitalOutId);
|
if (hospitalOutId != null) {
|
String hospitalOutName = legacyTransferSyncMapper.selectHospitalNameByHospID(hospitalOutId.toString());
|
if (StringUtils.isNotEmpty(hospitalOutName)) {
|
hospitalOutInfo.setName(hospitalOutName);
|
}
|
}
|
String ServiceOrdTraVia=MapValueUtils.getStringValue(order, "ServiceOrdTraVia");
|
if(ServiceOrdTraVia!=null){
|
hospitalOutInfo.setAddress(ServiceOrdTraVia);
|
}
|
|
|
String hospitalOutDeptId = MapValueUtils.getStringValue(order, "ServiceOrdPtServicesID");
|
hospitalOutInfo.setDepartmentId(hospitalOutDeptId);
|
if (StringUtils.isNotEmpty(hospitalOutDeptId)) {
|
String hospitalOutDeptName = legacyTransferSyncMapper.selectDepartmentNameByDeptID(hospitalOutDeptId);
|
if (StringUtils.isNotEmpty(hospitalOutDeptName)) {
|
hospitalOutInfo.setDepartment(hospitalOutDeptName);
|
}
|
}
|
//转出床位
|
String serviceOrdPtServices=MapValueUtils.getStringValue(order, "ServiceOrdPtServices");
|
if(serviceOrdPtServices!= null){
|
hospitalOutInfo.setBedNumber(serviceOrdPtServices);
|
}
|
createTaskVo.setHospitalOut(hospitalOutInfo);
|
|
// 设置转入医院信息
|
TaskCreateVO.HospitalInfo hospitalInInfo = new TaskCreateVO.HospitalInfo();
|
Long hospitalInId = MapValueUtils.getLongValue(order, "ServiceOrdPtInHospID");
|
hospitalInInfo.setId(hospitalInId);
|
if (hospitalInId != null) {
|
String hospitalInName = legacyTransferSyncMapper.selectHospitalNameByHospID(hospitalInId.toString());
|
if (StringUtils.isNotEmpty(hospitalInName)) {
|
hospitalInInfo.setName(hospitalInName);
|
}
|
}
|
String serviceOrdTraEnd = MapValueUtils.getStringValue(order, "ServiceOrdTraEnd");
|
if(serviceOrdTraEnd!= null){
|
hospitalInInfo.setAddress(serviceOrdTraEnd);
|
}
|
//转入床位
|
String serviceOrdPtInServices =MapValueUtils.getStringValue(order, "ServiceOrdPtInServices");
|
if(serviceOrdPtInServices!= null){
|
hospitalInInfo.setBedNumber(serviceOrdPtInServices);
|
}
|
|
|
String hospitalInDeptId = MapValueUtils.getStringValue(order, "ServiceOrdPtInServicesID");
|
hospitalInInfo.setDepartmentId(hospitalInDeptId);
|
if (StringUtils.isNotEmpty(hospitalInDeptId)) {
|
String hospitalInDeptName = legacyTransferSyncMapper.selectDepartmentNameByDeptID(hospitalInDeptId);
|
if (StringUtils.isNotEmpty(hospitalInDeptName)) {
|
hospitalInInfo.setDepartment(hospitalInDeptName);
|
}
|
}
|
createTaskVo.setHospitalIn(hospitalInInfo);
|
|
// 设置地址信息
|
createTaskVo.setDepartureAddress(MapValueUtils.getStringValue(order, "ServiceOrdTraStreet"));
|
createTaskVo.setDestinationAddress(MapValueUtils.getStringValue(order, "ServiceOrdTraEnd"));
|
|
// 设置价格和距离信息
|
createTaskVo.setPrice(MapValueUtils.getBigDecimalValue(order, "ServiceOrdTraTxnPrice"));
|
// 距离信息需要从其他字段计算或获取
|
|
if(LongUtil.isNotEmpty(dispatchOrdID)) {
|
// 设置执行人信息
|
List<TaskCreateVO.AssigneeInfo> assignees = queryAssignees(dispatchOrdID);
|
createTaskVo.setAssignees(assignees);
|
if (!assignees.isEmpty()) {
|
createTaskVo.setAssigneeId(assignees.get(0).getUserId());
|
}
|
}
|
// 设置车辆信息
|
// 车辆ID需要根据DispatchOrdCarID查询获取
|
String carID = MapValueUtils.getStringValue(order, "DispatchOrdCarID");
|
if (StringUtils.isNotEmpty(carID)) {
|
String carLicense = legacyTransferSyncMapper.selectCarLicenseByCarID(carID);
|
if (StringUtils.isNotEmpty(carLicense)) {
|
// 根据车牌号查询新系统中的车辆ID
|
// log.info("转运任务,ServiceOrdID:{},车辆车牌:{}",serviceOrdID,carLicense);
|
// log.debug("车辆车牌号: {}", carLicense);
|
|
// 首先尝试通过VehicleInfoMapper查询车辆信息
|
try {
|
// 先尝试通过car_id查询车辆信息
|
Integer carIdInt = Integer.valueOf(carID);
|
VehicleInfo vehicleInfo = vehicleInfoMapper.selectVehicleInfoByCarId(carIdInt);
|
if (vehicleInfo != null && vehicleInfo.getVehicleId() != null) {
|
// 设置车辆ID列表
|
List<Long> vehicleIds = new ArrayList<>();
|
vehicleIds.add(vehicleInfo.getVehicleId());
|
createTaskVo.setVehicleIds(vehicleIds);
|
// log.debug("通过car_id找到车辆信息: vehicle_id={}, vehicle_no={}", vehicleInfo.getVehicleId(), vehicleInfo.getVehicleNo());
|
} else {
|
// 如果通过car_id找不到，尝试通过车牌号查询
|
vehicleInfo = vehicleInfoMapper.selectVehicleInfoByVehicleNo(carLicense);
|
if (vehicleInfo != null && vehicleInfo.getVehicleId() != null) {
|
List<Long> vehicleIds = new ArrayList<>();
|
vehicleIds.add(vehicleInfo.getVehicleId());
|
createTaskVo.setVehicleIds(vehicleIds);
|
// log.debug("转运任务,ServiceOrdID:{} 通过车牌号找到车辆信息: vehicle_id={}, vehicle_no={}",serviceOrdID, vehicleInfo.getVehicleId(), vehicleInfo.getVehicleNo());
|
} else {
|
log.warn("转运任务,ServiceOrdID:{} 未找到对应的车辆信息: car_id={}, vehicle_no={}",serviceOrdID, carID, carLicense);
|
}
|
}
|
} catch (NumberFormatException e) {
|
log.warn("carID不是有效数字: {}", carID);
|
// 如果carID不是数字，直接通过车牌号查询
|
VehicleInfo vehicleInfo = vehicleInfoMapper.selectVehicleInfoByVehicleNo(carLicense);
|
if (vehicleInfo != null && vehicleInfo.getVehicleId() != null) {
|
List<Long> vehicleIds = new ArrayList<>();
|
vehicleIds.add(vehicleInfo.getVehicleId());
|
createTaskVo.setVehicleIds(vehicleIds);
|
// log.debug("通过车牌号找到车辆信息: vehicle_id={}, vehicle_no={}", vehicleInfo.getVehicleId(), vehicleInfo.getVehicleNo());
|
} else {
|
log.warn("未找到对应的车辆信息: vehicle_no={}", carLicense);
|
}
|
}
|
}
|
}
|
|
|
|
// 设置其他信息
|
createTaskVo.setTaskDescription("从旧系统同步的转运单");
|
|
// 设置备注信息
|
String remark = "服务单ID: " + serviceOrdID + ", 调度单ID: " + dispatchOrdID;
|
String serviceOrdCoTies = MapValueUtils.getStringValue(order, "ServiceOrdCoTies");
|
if (StringUtils.isNotEmpty(serviceOrdCoTies)) {
|
remark += ", 联系人关系: " + serviceOrdCoTies;
|
}
|
createTaskVo.setRemark(remark);
|
|
// 设置计划开始时间
|
Date plannedStartTime = MapValueUtils.getDateValue(order, "ServiceOrdApptDate");
|
if (plannedStartTime != null) {
|
createTaskVo.setPlannedStartTime(plannedStartTime);
|
}
|
|
Date actualStartTime = MapValueUtils.getDateValue(order, "DispatchOrdActualDate");
|
if (actualStartTime != null) {
|
createTaskVo.setActualStartTime(actualStartTime);
|
}
|
|
Date actualEndTime = MapValueUtils.getDateValue(order, "DispatchOrdReturnDate");
|
if (actualEndTime != null) {
|
createTaskVo.setActualEndTime(actualEndTime);
|
}
|
|
|
|
// 设置创建时间 开单日期
|
Date createTime = MapValueUtils.getDateValue(order, "ServiceOrd_CC_Time");
|
if (createTime != null) {
|
createTaskVo.setCreateTime(createTime);
|
}
|
|
// 查询并设置病情信息
|
String diseaseIdsStr = queryDiseaseIds(serviceOrdID);
|
if (StringUtils.isNotEmpty(diseaseIdsStr)) {
|
String[] diseaseIdArray = diseaseIdsStr.split(",");
|
List<Long> diseaseIds = new ArrayList<>();
|
for (String diseaseId : diseaseIdArray) {
|
try {
|
diseaseIds.add(Long.valueOf(diseaseId.trim()));
|
} catch (NumberFormatException e) {
|
log.warn("无效的疾病ID: {}", diseaseId);
|
}
|
}
|
createTaskVo.setDiseaseIds(diseaseIds);
|
}
|
|
Integer dispatchOrdStatus = MapValueUtils.getIntegerValue(order, "DispatchOrdStatus");
|
TaskStatus status= TaskStatusConverter.convertFromLegacyStatus(dispatchOrdStatus);
|
if(status!=null) {
|
createTaskVo.setTaskStatus(status.getCode());
|
}
|
|
// 设置旧系统同步字段
|
String dispatchOrdNo = MapValueUtils.getStringValue(order, "DispatchOrdNo");
|
if(dispatchOrdNo!=null) {
|
createTaskVo.setLegacyDispatchOrdNo(dispatchOrdNo);
|
}
|
Date ccTime=MapValueUtils.getDateValue(order, "ServiceOrd_CC_Time");
|
|
if(ccTime!=null) {
|
createTaskVo.setLegacyServiceNsTime(ccTime);
|
}
|
Date nsTime=MapValueUtils.getDateValue(order, "DispatchOrd_NS_Time");
|
if(nsTime!=null) {
|
createTaskVo.setLegacyDispatchNsTime(MapValueUtils.getDateValue(order, "DispatchOrd_NS_Time"));
|
}
|
String dispatchOrdClass=MapValueUtils.getStringValue(order, "DispatchOrdClass");
|
if(dispatchOrdClass!=null) {
|
createTaskVo.setLegacyDispatchOrdClass(dispatchOrdClass);
|
}
|
|
// String serviceOrdClass=MapValueUtils.getStringValue(order, "ServiceOrdClass");
|
if(serviceOrdClass!=null) {
|
createTaskVo.setLegacyServiceOrdClass(serviceOrdClass);
|
}
|
|
return createTaskVo;
|
|
} catch (Exception e) {
|
log.error("构造TaskCreateVO异常: ServiceOrdID={}, DispatchOrdID={}", serviceOrdID, dispatchOrdID, e);
|
return null;
|
}
|
}
|
|
/**
|
* 查询执行人信息
|
*
|
* @param dispatchOrdID 调度单ID
|
* @return 执行人信息列表
|
*/
|
private List<TaskCreateVO.AssigneeInfo> queryAssignees(Long dispatchOrdID) {
|
long startTime = System.currentTimeMillis();
|
try {
|
// 检查参数有效性
|
if (LongUtil.isEmpty(dispatchOrdID)) {
|
log.warn("调度单ID不能为空");
|
return new ArrayList<>();
|
}
|
|
// 将String转换为Long，避免数据库类型不匹配导致的性能问题
|
|
|
// 从SQL Server查询执行人信息（使用Long类型，匹配BIGINT字段）
|
List<Map<String, Object>> assigneeList = legacyTransferSyncMapper.selectAssigneesByDispatchOrdID(dispatchOrdID);
|
long queryTime = System.currentTimeMillis() - startTime;
|
|
// 记录慢查询（超过500ms）
|
if (queryTime > 500) {
|
log.warn("查询执行人信息耗时过长: {}ms, 调度单ID: {}, 建议在 DispatchOrd_Entourage 表的 DispatchOrdIDDt 字段上创建索引",
|
queryTime, dispatchOrdID);
|
}
|
|
// 转换为TaskCreateVO.AssigneeInfo对象
|
List<TaskCreateVO.AssigneeInfo> assignees = new ArrayList<>();
|
if (assigneeList != null && !assigneeList.isEmpty()) {
|
for (Map<String, Object> assigneeMap : assigneeList) {
|
String entourageOAId = MapValueUtils.getStringValue(assigneeMap, "EntourageOAId");
|
String entourageState = MapValueUtils.getStringValue(assigneeMap, "EntourageID");
|
|
if (StringUtils.isNotEmpty(entourageOAId)) {
|
try {
|
// 将OA用户ID转换为系统用户ID
|
Integer oaUserId = Integer.valueOf(entourageOAId);
|
SysUser sysUser = sysUserService.selectUserByOaUserId(oaUserId);
|
|
if (sysUser != null) {
|
TaskCreateVO.AssigneeInfo assigneeInfo = new TaskCreateVO.AssigneeInfo();
|
assigneeInfo.setUserId(sysUser.getUserId()); // 使用系统用户ID
|
assigneeInfo.setUserName(sysUser.getNickName());
|
// 根据EntourageState确定角色类型
|
// 1,2 司机，3,5 医生，4,6 护士
|
if ("1".equals(entourageState) || "2".equals(entourageState)) {
|
assigneeInfo.setUserType("driver");
|
} else if ("3".equals(entourageState) || "5".equals(entourageState)) {
|
assigneeInfo.setUserType("doctor");
|
} else if ("4".equals(entourageState) || "6".equals(entourageState)) {
|
assigneeInfo.setUserType("nurse");
|
} else {
|
assigneeInfo.setUserType("other");
|
}
|
|
assignees.add(assigneeInfo);
|
} else {
|
log.warn("未找到对应的系统用户: OA用户ID={}", oaUserId);
|
}
|
} catch (NumberFormatException e) {
|
log.warn("执行人OA ID不是有效数字: {}", entourageOAId);
|
}
|
}
|
}
|
}
|
|
// log.debug("查询到{}个执行人，调度单ID: {}, 耗时: {}ms", assignees.size(), dispatchOrdID, System.currentTimeMillis() - startTime);
|
return assignees;
|
} catch (Exception e) {
|
long totalTime = System.currentTimeMillis() - startTime;
|
log.error("查询执行人信息异常，调度单ID: {}, 耗时: {}ms", dispatchOrdID, totalTime, e);
|
return new ArrayList<>(); // 返回空列表而不是null
|
}
|
}
|
|
/**
|
* 查询病情信息
|
*
|
* @param serviceOrdID 服务单ID
|
* @return 病情ID列表
|
*/
|
private String queryDiseaseIds(Long serviceOrdID) {
|
try {
|
// 检查参数有效性
|
if (LongUtil.isEmpty(serviceOrdID) ) {
|
log.warn("服务单ID不能为空");
|
return null;
|
}
|
|
// 从SQL Server查询病情信息
|
List<String> diseaseIds = legacyTransferSyncMapper.selectDiseaseIdsByServiceOrdID(serviceOrdID);
|
|
// 转换为逗号分隔的字符串
|
if (diseaseIds != null && !diseaseIds.isEmpty()) {
|
return String.join(",", diseaseIds);
|
}
|
|
// log.info("查询到病情信息，服务单ID: {}, 病情数量: {}", serviceOrdID, diseaseIds != null ? diseaseIds.size() : 0);
|
return null;
|
} catch (Exception e) {
|
log.error("查询病情信息异常，服务单ID: {}", serviceOrdID, e);
|
return null;
|
}
|
}
|
|
|
|
private void notifyTransferOrderByWechat(Long taskId,
|
Long serviceOrdID,
|
Long dispatchOrdID,
|
String serviceOrdNo,
|
Date serviceOrdCcTime,
|
SysDept dept,
|
Map<String, Object> order) {
|
try {
|
// 1. 获取执行人列表
|
List<TaskCreateVO.AssigneeInfo> assignees = queryAssignees(dispatchOrdID);
|
if (assignees.isEmpty()) {
|
log.info("旧系统同步转运单无执行人，taskId={}", taskId);
|
return;
|
}
|
|
// 2. 查询任务获取showTaskCode
|
SysTask sysTask = sysTaskService.getTaskDetail(taskId);
|
String showTaskCode = sysTask != null ? sysTask.getShowTaskCode() : serviceOrdNo;
|
|
// 3. 构建通知内容
|
String notifyContent = buildLegacyNotifyContent(showTaskCode, serviceOrdCcTime, order);
|
|
// 4. 查询该taskId已有的通知记录，收集已存在的userId集合
|
List<NotifyTask> existingTasks = notifyTaskService.selectByTaskIdAndType(taskId, NotifyTask.NOTIFY_TYPE_TASK_ASSIGN);
|
Set<Long> existingUserIds = new HashSet<>();
|
List<NotifyTask> pendingTasks = new ArrayList<>();
|
if (existingTasks != null && !existingTasks.isEmpty()) {
|
for (NotifyTask t : existingTasks) {
|
existingUserIds.add(t.getUserId());
|
// 将未完成的记录收集给待分发列表
|
if (!NotifyTask.STATUS_COMPLETED.equals(t.getStatus())) {
|
pendingTasks.add(t);
|
}
|
}
|
}
|
|
// 5. 只对新执行人创建通知任务
|
List<NotifyTask> notifyTasks = new ArrayList<>(pendingTasks);
|
for (TaskCreateVO.AssigneeInfo assignee : assignees) {
|
if (assignee == null || assignee.getUserId() == null) {
|
continue;
|
}
|
// 该用户已有通知记录，跳过
|
if (existingUserIds.contains(assignee.getUserId())) {
|
log.info("用户已有通知记录，跳过创建，taskId={}, userId={}", taskId, assignee.getUserId());
|
continue;
|
}
|
|
SysUser user = sysUserService.selectUserById(assignee.getUserId());
|
if (user == null) {
|
log.warn("找不到执行人用户信息，userId={}", assignee.getUserId());
|
continue;
|
}
|
|
NotifyTask notifyTask = new NotifyTask();
|
notifyTask.setTaskId(taskId);
|
notifyTask.setTaskCode(showTaskCode);
|
notifyTask.setNotifyType(NotifyTask.NOTIFY_TYPE_TASK_ASSIGN);
|
notifyTask.setUserId(user.getUserId());
|
notifyTask.setUserName(user.getNickName());
|
notifyTask.setUserPhone(user.getPhonenumber());
|
notifyTask.setTitle("转运单任务派单通知");
|
notifyTask.setContent(notifyContent);
|
notifyTask.setCreateBy("系统同步");
|
|
NotifyTask created = notifyTaskService.createNotifyTask(notifyTask);
|
if (created != null) {
|
notifyTasks.add(created);
|
log.info("创建通知任务成功，id={}, userId={}", created.getId(), user.getUserId());
|
}
|
}
|
|
// 6. 分发通知任务
|
if (!notifyTasks.isEmpty()) {
|
int successCount = notifyDispatchService.dispatchNotifies(notifyTasks);
|
log.info("旧系统同步转运单通知分发完成，taskId={}, 分发数量={}, 成功数量={}",
|
taskId, notifyTasks.size(), successCount);
|
} else {
|
log.info("旧系统同步转运单无需新增通知，taskId={}", taskId);
|
}
|
|
// 5. 同时保留原有的微信通知服务（兼容）
|
// List<Long> userIds = new ArrayList<>();
|
// for (TaskCreateVO.AssigneeInfo assignee : assignees) {
|
// if (assignee != null && assignee.getUserId() != null) {
|
// userIds.add(assignee.getUserId());
|
// }
|
// }
|
// if (!userIds.isEmpty()) {
|
// int wxCount = wechatTaskNotifyService.sendTaskNotifyMessage(taskId, userIds);
|
// log.info("旧系统同步转运单微信通知发送完成，taskId={}, 成功={}", taskId, wxCount);
|
// }
|
|
} catch (Exception e) {
|
log.error("notifyTransferOrderByWechat发生异常, serviceOrdID={}, dispatchOrdID={}", serviceOrdID, dispatchOrdID, e);
|
}
|
}
|
|
/**
|
* 构建旧系统同步转运单的通知内容
|
*/
|
private String buildLegacyNotifyContent(String serviceOrdNo, Date serviceOrdCcTime, Map<String, Object> order) {
|
StringBuilder content = new StringBuilder();
|
content.append("您有新的转运任务，任务单号:").append(serviceOrdNo);
|
|
// 出发时间
|
if (serviceOrdCcTime != null) {
|
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm");
|
content.append("，出发时间:").append(df.format(serviceOrdCcTime));
|
}
|
|
// 出发地
|
String departure = MapValueUtils.getStringValue(order, "ServiceOrdTraVia");
|
if (StringUtils.isNotEmpty(departure)) {
|
content.append("，出发地:").append(departure);
|
}
|
|
// 目的地
|
String destination = MapValueUtils.getStringValue(order, "ServiceOrdTraEnd");
|
if (StringUtils.isNotEmpty(destination)) {
|
content.append("，目的地:").append(destination);
|
}
|
|
content.append("，请及时处理。");
|
return content.toString();
|
}
|
|
private List<SysUser> getWechatNotifyUsers(Long dispatchOrdID, SysDept dept) {
|
try {
|
List<SysUser> result = new ArrayList<>();
|
|
List<TaskCreateVO.AssigneeInfo> assignees = queryAssignees(dispatchOrdID);
|
if (!assignees.isEmpty()) {
|
for (TaskCreateVO.AssigneeInfo assigneeInfo : assignees) {
|
if (assigneeInfo == null || assigneeInfo.getUserId() == null) {
|
continue;
|
}
|
SysUser user = sysUserService.selectUserById(assigneeInfo.getUserId());
|
if (user != null && StringUtils.isNotEmpty(user.getOpenId())) {
|
result.add(user);
|
}
|
}
|
}
|
|
if (!result.isEmpty()) {
|
return result;
|
}
|
|
if (dept == null || StringUtils.isEmpty(dept.getPhone())) {
|
return result;
|
}
|
|
SysUser leader = sysUserService.selectUserByPhonenumber(dept.getPhone());
|
if (leader != null && StringUtils.isNotEmpty(leader.getOpenId())) {
|
result.add(leader);
|
}
|
|
return result;
|
} catch (Exception e) {
|
log.error("获取旧系统同步转运单微信通知接收人失败, dispatchOrdID={}", dispatchOrdID, e);
|
return new ArrayList<>();
|
}
|
}
|
}
|
