package com.ruoyi.system.service.impl;
|
|
import java.io.*;
|
import java.math.BigDecimal;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
import java.net.HttpURLConnection;
|
import java.net.URL;
|
|
import com.ruoyi.common.core.domain.entity.SysUser;
|
import com.ruoyi.system.domain.vo.*;
|
import com.ruoyi.system.mapper.*;
|
import com.ruoyi.system.utils.TaskCodeGenerator;
|
import com.ruoyi.common.config.ImageUrlConfig;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.multipart.MultipartFile;
|
import com.ruoyi.common.utils.DateUtils;
|
import com.ruoyi.common.utils.SecurityUtils;
|
import com.ruoyi.common.utils.StringUtils;
|
import com.ruoyi.common.utils.GpsDistanceUtils;
|
import com.ruoyi.common.utils.file.FileUploadUtils;
|
import com.ruoyi.common.utils.file.FileUtils;
|
import com.ruoyi.system.domain.SysTask;
|
import com.ruoyi.system.domain.SysTaskVehicle;
|
import com.ruoyi.system.domain.SysTaskAttachment;
|
import com.ruoyi.system.domain.SysTaskLog;
|
import com.ruoyi.system.domain.SysTaskEmergency;
|
import com.ruoyi.system.domain.SysTaskWelfare;
|
import com.ruoyi.system.domain.SysTaskAssignee;
|
import com.ruoyi.system.domain.enums.TaskStatus;
|
import com.ruoyi.system.domain.VehicleInfo;
|
import com.ruoyi.system.service.ISysTaskService;
|
import com.ruoyi.system.service.ILegacySystemSyncService;
|
import com.ruoyi.system.service.ISysTaskEmergencyService;
|
import com.ruoyi.system.service.ITaskAttachmentSyncService;
|
import com.ruoyi.system.service.IMapService;
|
import com.ruoyi.system.event.TaskCreatedEvent;
|
import com.ruoyi.system.event.TaskAssignedEvent;
|
import com.ruoyi.system.event.TaskStatusChangedEvent;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.context.ApplicationEventPublisher;
|
|
/**
|
* 任务管理Service业务层处理
|
*
|
* @author ruoyi
|
* @date 2024-01-15
|
*/
|
@Service
|
public class SysTaskServiceImpl implements ISysTaskService {
|
|
private static final Logger log = LoggerFactory.getLogger(SysTaskServiceImpl.class);
|
|
@Autowired
|
private SysTaskMapper sysTaskMapper;
|
|
@Autowired
|
private SysTaskVehicleMapper sysTaskVehicleMapper;
|
|
@Autowired
|
private SysTaskAttachmentMapper sysTaskAttachmentMapper;
|
|
@Autowired
|
private SysTaskLogMapper sysTaskLogMapper;
|
|
@Autowired
|
private SysTaskEmergencyMapper sysTaskEmergencyMapper;
|
|
@Autowired
|
private SysTaskWelfareMapper sysTaskWelfareMapper;
|
|
@Autowired
|
private SysTaskAssigneeMapper sysTaskAssigneeMapper;
|
|
@Autowired
|
private VehicleInfoMapper vehicleInfoMapper;
|
|
@Autowired(required = false)
|
private ILegacySystemSyncService legacySystemSyncService;
|
|
@Autowired
|
private ISysTaskEmergencyService sysTaskEmergencyService;
|
|
@Autowired
|
private ApplicationEventPublisher eventPublisher;
|
|
@Autowired
|
private ImageUrlConfig imageUrlConfig;
|
|
@Autowired(required = false)
|
private ITaskAttachmentSyncService taskAttachmentSyncService;
|
|
@Autowired
|
private SysUserMapper sysUserMapper;
|
|
@Autowired(required = false)
|
private IMapService mapService;
|
|
/**
|
* 查询任务管理
|
*
|
* @param taskId 任务管理主键
|
* @return 任务管理
|
*/
|
@Override
|
public SysTask selectSysTaskByTaskId(Long taskId) {
|
SysTask task = sysTaskMapper.selectSysTaskByTaskId(taskId);
|
if (task != null) {
|
// 加载急救转运扩展信息
|
if ("EMERGENCY_TRANSFER".equals(task.getTaskType())) {
|
SysTaskEmergency emergencyInfo = sysTaskEmergencyMapper.selectSysTaskEmergencyByTaskId(taskId);
|
task.setEmergencyInfo(emergencyInfo);
|
}
|
// 加载福祉车扩展信息
|
else if ("WELFARE".equals(task.getTaskType())) {
|
SysTaskWelfare welfareInfo = sysTaskWelfareMapper.selectSysTaskWelfareByTaskId(taskId);
|
task.setWelfareInfo(welfareInfo);
|
}
|
}
|
return task;
|
}
|
|
/**
|
* 查询任务管理列表
|
*
|
* @param queryVO 任务查询对象
|
* @return 任务管理
|
*/
|
@Override
|
public List<SysTask> selectSysTaskList(TaskQueryVO queryVO) {
|
return sysTaskMapper.selectSysTaskList(queryVO);
|
}
|
|
/**
|
* 新增任务管理
|
*
|
* @param createVO 任务创建对象
|
* @return 结果
|
*/
|
@Override
|
@Transactional
|
public int insertSysTask(TaskCreateVO createVO) {
|
String username = SecurityUtils.getUsername();
|
SysTask task = new SysTask();
|
task.setTaskCode(generateTaskCode());
|
task.setTaskType(createVO.getTaskType());
|
task.setTaskStatus(TaskStatus.PENDING.getCode());
|
task.setTaskDescription(createVO.getTaskDescription());
|
task.setPlannedStartTime(createVO.getPlannedStartTime());
|
task.setPlannedEndTime(createVO.getPlannedEndTime());
|
task.setAssigneeId(createVO.getAssigneeId());
|
task.setCreatorId(SecurityUtils.getUserId());
|
// 优先使用前端传入的部门ID，如果没有则使用当前用户的部门ID
|
task.setDeptId(createVO.getDeptId() != null ? createVO.getDeptId() : SecurityUtils.getDeptId());
|
task.setCreateBy(username);
|
task.setCreateTime(DateUtils.getNowDate());
|
task.setUpdateBy(username);
|
task.setUpdateTime(DateUtils.getNowDate());
|
task.setRemark(createVO.getRemark());
|
task.setDelFlag("0");
|
|
// 设置通用地址和坐标信息
|
if (createVO.getDepartureAddress() != null) {
|
task.setDepartureAddress(createVO.getDepartureAddress());
|
}
|
if (createVO.getDestinationAddress() != null) {
|
task.setDestinationAddress(createVO.getDestinationAddress());
|
}
|
if (createVO.getDepartureLongitude() != null) {
|
task.setDepartureLongitude(createVO.getDepartureLongitude());
|
}
|
if (createVO.getDepartureLatitude() != null) {
|
task.setDepartureLatitude(createVO.getDepartureLatitude());
|
}
|
if (createVO.getDestinationLongitude() != null) {
|
task.setDestinationLongitude(createVO.getDestinationLongitude());
|
}
|
if (createVO.getDestinationLatitude() != null) {
|
task.setDestinationLatitude(createVO.getDestinationLatitude());
|
}
|
if (createVO.getEstimatedDistance() != null) {
|
task.setEstimatedDistance(createVO.getEstimatedDistance());
|
}
|
|
// 设置急救转运特定信息
|
if (createVO.getTransferTime() != null) {
|
task.setPlannedStartTime(createVO.getTransferTime());
|
}
|
if (createVO.getTransferDistance() != null) {
|
task.setEstimatedDistance(createVO.getTransferDistance());
|
}
|
|
// 设置福祉车特定信息
|
if (createVO.getServiceTime() != null) {
|
task.setPlannedStartTime(createVO.getServiceTime());
|
}
|
if (createVO.getStartAddress() != null) {
|
task.setDepartureAddress(createVO.getStartAddress());
|
}
|
if (createVO.getEndAddress() != null) {
|
task.setDestinationAddress(createVO.getEndAddress());
|
}
|
// 设置福祉车公里数
|
if (createVO.getDistance() != null) {
|
task.setEstimatedDistance(createVO.getDistance());
|
}
|
|
// 自动获取出发地GPS坐标（如果缺失）
|
if (task.getDepartureAddress() != null &&
|
(task.getDepartureLongitude() == null || task.getDepartureLatitude() == null) &&
|
mapService != null) {
|
try {
|
Map<String, Double> coords = mapService.geocoding(
|
task.getDepartureAddress(),
|
extractCityFromAddress(task.getDepartureAddress())
|
);
|
if (coords != null) {
|
task.setDepartureLongitude(BigDecimal.valueOf(coords.get("lng")));
|
task.setDepartureLatitude(BigDecimal.valueOf(coords.get("lat")));
|
log.info("出发地GPS坐标自动获取成功: {}, {}", coords.get("lng"), coords.get("lat"));
|
}
|
} catch (Exception e) {
|
log.error("自动获取出发地GPS坐标失败", e);
|
}
|
}
|
|
// 自动获取目的地GPS坐标（如果缺失）
|
if (task.getDestinationAddress() != null &&
|
(task.getDestinationLongitude() == null || task.getDestinationLatitude() == null) &&
|
mapService != null) {
|
try {
|
Map<String, Double> coords = mapService.geocoding(
|
task.getDestinationAddress(),
|
extractCityFromAddress(task.getDestinationAddress())
|
);
|
if (coords != null) {
|
task.setDestinationLongitude(BigDecimal.valueOf(coords.get("lng")));
|
task.setDestinationLatitude(BigDecimal.valueOf(coords.get("lat")));
|
log.info("目的地GPS坐标自动获取成功: {}, {}", coords.get("lng"), coords.get("lat"));
|
}
|
} catch (Exception e) {
|
log.error("自动获取目的地GPS坐标失败", e);
|
}
|
}
|
|
int result = sysTaskMapper.insertSysTask(task);
|
|
// 保存车辆关联信息
|
if (result > 0 && createVO.getVehicleIds() != null && !createVO.getVehicleIds().isEmpty()) {
|
for (Long vehicleId : createVO.getVehicleIds()) {
|
SysTaskVehicle taskVehicle = new SysTaskVehicle();
|
taskVehicle.setTaskId(task.getTaskId());
|
taskVehicle.setVehicleId(vehicleId);
|
taskVehicle.setAssignTime(DateUtils.getNowDate());
|
taskVehicle.setAssignBy(username);
|
taskVehicle.setStatus("ASSIGNED");
|
taskVehicle.setCreateBy(username);
|
taskVehicle.setCreateTime(DateUtils.getNowDate());
|
taskVehicle.setUpdateBy(username);
|
taskVehicle.setUpdateTime(DateUtils.getNowDate());
|
|
sysTaskVehicleMapper.insertSysTaskVehicle(taskVehicle);
|
}
|
}
|
|
// 保存执行人员信息（包含角色类型）
|
if (result > 0 && createVO.getAssignees() != null && !createVO.getAssignees().isEmpty()) {
|
saveTaskAssignees(task.getTaskId(), createVO.getAssignees(),username);
|
}
|
|
// 保存急救转运扩展信息
|
if (result > 0 && "EMERGENCY_TRANSFER".equals(createVO.getTaskType())) {
|
saveEmergencyInfo(task.getTaskId(),username, createVO,null,null,null);
|
}
|
|
// 保存福祉车扩展信息
|
if (result > 0 && "WELFARE".equals(createVO.getTaskType())) {
|
saveWelfareInfo(task.getTaskId(),SecurityUtils.getUsername(), createVO);
|
}
|
|
// 记录操作日志
|
if (result > 0) {
|
recordTaskLog(task.getTaskId(), "CREATE", "创建任务", null,
|
"任务类型：" + createVO.getTaskType(), SecurityUtils.getUserId(), SecurityUtils.getUsername());
|
}
|
|
// 发布任务创建事件
|
if (result > 0) {
|
eventPublisher.publishEvent(new TaskCreatedEvent(
|
this,
|
task.getTaskId(),
|
task.getTaskCode(),
|
task.getTaskType(),
|
task.getCreatorId(),
|
SecurityUtils.getUsername()
|
));
|
}
|
|
// 发布任务分配事件
|
if (result > 0 && createVO.getAssignees() != null && !createVO.getAssignees().isEmpty()) {
|
List<Long> assigneeIds = createVO.getAssignees().stream()
|
.map(assignee -> assignee.getUserId())
|
.collect(Collectors.toList());
|
List<String> assigneeNames = createVO.getAssignees().stream()
|
.map(assignee -> assignee.getUserName())
|
.collect(Collectors.toList());
|
|
eventPublisher.publishEvent(new TaskAssignedEvent(
|
this,
|
task.getTaskId(),
|
task.getTaskCode(),
|
assigneeIds,
|
assigneeNames,
|
SecurityUtils.getUserId(),
|
SecurityUtils.getUsername()
|
));
|
}
|
|
// 异步同步急救转运任务到旧系统
|
if (result > 0 && "EMERGENCY_TRANSFER".equals(createVO.getTaskType()) && legacySystemSyncService != null) {
|
final Long finalTaskId = task.getTaskId();
|
new Thread(() -> {
|
try {
|
Thread.sleep(2000); // 等待2秒，确保事务已提交
|
legacySystemSyncService.syncEmergencyTaskToLegacy(finalTaskId);
|
} catch (Exception e) {
|
// 同步失败不影响主流程，仅记录日志
|
}
|
}).start();
|
}
|
|
return result;
|
}
|
|
/**
|
* 新增任务管理（允许从外部传入用户信息、部门信息和时间信息）
|
*
|
* @param createVO 任务创建对象
|
* @param userId 用户ID
|
* @param deptId 部门ID
|
* @param createTime 创建时间
|
* @param updateTime 更新时间
|
* @return 结果
|
*/
|
@Override
|
@Transactional
|
public int insertTask(TaskCreateVO createVO,String serviceOrderId,String dispatchOrderId, String serviceOrdNo, Long userId,String userName, Long deptId, Date createTime, Date updateTime) {
|
SysTask task = new SysTask();
|
if(createVO.getTaskCode()!=null){
|
task.setTaskCode(createVO.getTaskCode());
|
}else{
|
task.setTaskCode(generateTaskCode());
|
}
|
task.setTaskType(createVO.getTaskType());
|
task.setTaskStatus(TaskStatus.PENDING.getCode());
|
task.setTaskDescription(createVO.getTaskDescription());
|
task.setPlannedStartTime(createVO.getPlannedStartTime());
|
task.setPlannedEndTime(createVO.getPlannedEndTime());
|
task.setActualStartTime(createVO.getActualStartTime());
|
task.setActualEndTime(createVO.getActualEndTime());
|
task.setAssigneeId(createVO.getAssigneeId());
|
// 使用外部传入的用户ID和部门ID
|
task.setCreatorId(userId);
|
task.setDeptId(deptId);
|
task.setCreateBy(userName);
|
// 使用外部传入的创建时间和更新时间
|
task.setCreateTime(createTime);
|
task.setUpdateTime(updateTime);
|
task.setUpdateBy(userName);
|
task.setRemark(createVO.getRemark());
|
task.setDelFlag("0");
|
|
|
|
// 设置通用地址和坐标信息
|
if (createVO.getDepartureAddress() != null) {
|
task.setDepartureAddress(createVO.getDepartureAddress());
|
}
|
if (createVO.getDestinationAddress() != null) {
|
task.setDestinationAddress(createVO.getDestinationAddress());
|
}
|
if (createVO.getDepartureLongitude() != null) {
|
task.setDepartureLongitude(createVO.getDepartureLongitude());
|
}
|
if (createVO.getDepartureLatitude() != null) {
|
task.setDepartureLatitude(createVO.getDepartureLatitude());
|
}
|
if (createVO.getDestinationLongitude() != null) {
|
task.setDestinationLongitude(createVO.getDestinationLongitude());
|
}
|
if (createVO.getDestinationLatitude() != null) {
|
task.setDestinationLatitude(createVO.getDestinationLatitude());
|
}
|
if (createVO.getEstimatedDistance() != null) {
|
task.setEstimatedDistance(createVO.getEstimatedDistance());
|
}
|
|
// 设置急救转运特定信息
|
if (createVO.getTransferTime() != null) {
|
task.setPlannedStartTime(createVO.getTransferTime());
|
}
|
if (createVO.getTransferDistance() != null) {
|
task.setEstimatedDistance(createVO.getTransferDistance());
|
}
|
|
// 设置福祉车特定信息
|
if (createVO.getPlannedStartTime() != null) {
|
task.setPlannedStartTime(createVO.getPlannedStartTime());
|
}
|
if (createVO.getStartAddress() != null) {
|
task.setDepartureAddress(createVO.getStartAddress());
|
}
|
if (createVO.getEndAddress() != null) {
|
task.setDestinationAddress(createVO.getEndAddress());
|
}
|
// 设置福祉车公里数
|
if (createVO.getDistance() != null) {
|
task.setEstimatedDistance(createVO.getDistance());
|
}
|
|
// 自动获取出发地GPS坐标（如果缺失）
|
if (task.getDepartureAddress() != null &&
|
(task.getDepartureLongitude() == null || task.getDepartureLatitude() == null) &&
|
mapService != null) {
|
try {
|
Map<String, Double> coords = mapService.geocoding(
|
task.getDepartureAddress(),
|
extractCityFromAddress(task.getDepartureAddress())
|
);
|
if (coords != null) {
|
task.setDepartureLongitude(BigDecimal.valueOf(coords.get("lng")));
|
task.setDepartureLatitude(BigDecimal.valueOf(coords.get("lat")));
|
log.info("出发地GPS坐标自动获取成功: {}, {}", coords.get("lng"), coords.get("lat"));
|
}
|
} catch (Exception e) {
|
log.error("自动获取出发地GPS坐标失败", e);
|
}
|
}
|
|
// 自动获取目的地GPS坐标（如果缺失）
|
if (task.getDestinationAddress() != null &&
|
(task.getDestinationLongitude() == null || task.getDestinationLatitude() == null) &&
|
mapService != null) {
|
try {
|
Map<String, Double> coords = mapService.geocoding(
|
task.getDestinationAddress(),
|
extractCityFromAddress(task.getDestinationAddress())
|
);
|
if (coords != null) {
|
task.setDestinationLongitude(BigDecimal.valueOf(coords.get("lng")));
|
task.setDestinationLatitude(BigDecimal.valueOf(coords.get("lat")));
|
log.info("目的地GPS坐标自动获取成功: {}, {}", coords.get("lng"), coords.get("lat"));
|
}
|
} catch (Exception e) {
|
log.error("自动获取目的地GPS坐标失败", e);
|
}
|
}
|
|
int result = sysTaskMapper.insertSysTask(task);
|
|
// 保存车辆关联信息
|
if (result > 0 && createVO.getVehicleIds() != null && !createVO.getVehicleIds().isEmpty()) {
|
for (Long vehicleId : createVO.getVehicleIds()) {
|
SysTaskVehicle taskVehicle = new SysTaskVehicle();
|
taskVehicle.setTaskId(task.getTaskId());
|
taskVehicle.setVehicleId(vehicleId);
|
taskVehicle.setAssignTime(updateTime);
|
taskVehicle.setAssignBy(userName);
|
taskVehicle.setStatus("ASSIGNED");
|
taskVehicle.setCreateBy(userName);
|
taskVehicle.setCreateTime(createTime);
|
taskVehicle.setUpdateBy(userName);
|
taskVehicle.setUpdateTime(updateTime);
|
|
sysTaskVehicleMapper.insertSysTaskVehicle(taskVehicle);
|
}
|
}
|
|
// 保存执行人员信息（包含角色类型）
|
if (result > 0 && createVO.getAssignees() != null && !createVO.getAssignees().isEmpty()) {
|
saveTaskAssignees(task.getTaskId(), createVO.getAssignees(),userName);
|
}
|
|
// 保存急救转运扩展信息
|
if (result > 0 && "EMERGENCY_TRANSFER".equals(createVO.getTaskType())) {
|
saveEmergencyInfo(task.getTaskId(),userName, createVO, serviceOrderId, dispatchOrderId, serviceOrdNo);
|
}
|
|
// 保存福祉车扩展信息
|
if (result > 0 && "WELFARE".equals(createVO.getTaskType())) {
|
saveWelfareInfo(task.getTaskId(),userName, createVO);
|
}
|
|
// 记录操作日志
|
if (result > 0) {
|
recordTaskLog(task.getTaskId(), "CREATE", "创建任务", null,
|
"任务类型：" + createVO.getTaskType(), userId, userName);
|
}
|
|
// 发布任务创建事件
|
if (result > 0) {
|
eventPublisher.publishEvent(new TaskCreatedEvent(
|
this,
|
task.getTaskId(),
|
task.getTaskCode(),
|
task.getTaskType(),
|
userId,
|
userName
|
));
|
}
|
|
// 发布任务分配事件
|
if (result > 0 && createVO.getAssignees() != null && !createVO.getAssignees().isEmpty()) {
|
List<Long> assigneeIds = createVO.getAssignees().stream()
|
.map(assignee -> assignee.getUserId())
|
.collect(Collectors.toList());
|
List<String> assigneeNames = createVO.getAssignees().stream()
|
.map(assignee -> assignee.getUserName())
|
.collect(Collectors.toList());
|
|
eventPublisher.publishEvent(new TaskAssignedEvent(
|
this,
|
task.getTaskId(),
|
task.getTaskCode(),
|
assigneeIds,
|
assigneeNames,
|
userId,
|
userName
|
));
|
}
|
|
|
|
return result;
|
}
|
|
/**
|
* 修改任务管理
|
*
|
* @param updateVO 任务更新对象
|
* @return 结果
|
*/
|
@Override
|
@Transactional
|
public int updateSysTask(TaskUpdateVO updateVO, Boolean updateFromLegacy) {
|
SysTask oldTask = sysTaskMapper.selectSysTaskByTaskId(updateVO.getTaskId());
|
if (oldTask == null) {
|
throw new RuntimeException("任务不存在");
|
}
|
String userName = SecurityUtils.getUsername();
|
|
SysTask task = new SysTask();
|
task.setTaskId(updateVO.getTaskId());
|
task.setTaskDescription(updateVO.getTaskDescription());
|
task.setPlannedStartTime(updateVO.getPlannedStartTime());
|
task.setPlannedEndTime(updateVO.getPlannedEndTime());
|
task.setAssigneeId(updateVO.getAssigneeId());
|
task.setUpdateBy(userName);
|
task.setUpdateTime(updateVO.getUpdateTime() != null ? updateVO.getUpdateTime() : DateUtils.getNowDate());
|
task.setRemark(updateVO.getRemark());
|
|
// 设置通用地址和坐标信息
|
task.setDepartureAddress(updateVO.getDepartureAddress());
|
task.setDestinationAddress(updateVO.getDestinationAddress());
|
task.setDepartureLongitude(updateVO.getDepartureLongitude());
|
task.setDepartureLatitude(updateVO.getDepartureLatitude());
|
task.setDestinationLongitude(updateVO.getDestinationLongitude());
|
task.setDestinationLatitude(updateVO.getDestinationLatitude());
|
|
// 设置预计距离
|
if (updateVO.getEstimatedDistance() != null) {
|
task.setEstimatedDistance(updateVO.getEstimatedDistance());
|
} else if (updateVO.getTransferDistance() != null) {
|
// 兼容急救转运字段
|
task.setEstimatedDistance(updateVO.getTransferDistance());
|
} else if (updateVO.getDistance() != null) {
|
// 兼容福祉车字段
|
task.setEstimatedDistance(updateVO.getDistance());
|
}
|
|
// 如果更新了部门ID
|
if (updateVO.getDeptId() != null) {
|
task.setDeptId(updateVO.getDeptId());
|
}
|
|
// 如果更新了任务编号
|
if (updateVO.getTaskCode() != null) {
|
task.setTaskCode(updateVO.getTaskCode());
|
}
|
|
// 自动获取出发地GPS坐标（如果更新了地址但缺失坐标）
|
if (updateVO.getDepartureAddress() != null &&
|
(updateVO.getDepartureLongitude() == null || updateVO.getDepartureLatitude() == null) &&
|
mapService != null) {
|
if (!updateVO.getDepartureAddress().equals(oldTask.getDepartureAddress())) {
|
try {
|
Map<String, Double> coords = mapService.geocoding(
|
updateVO.getDepartureAddress(),
|
extractCityFromAddress(updateVO.getDepartureAddress())
|
);
|
if (coords != null) {
|
task.setDepartureLongitude(BigDecimal.valueOf(coords.get("lng")));
|
task.setDepartureLatitude(BigDecimal.valueOf(coords.get("lat")));
|
log.info("出发地GPS坐标自动获取成功: {}, {}", coords.get("lng"), coords.get("lat"));
|
}
|
} catch (Exception e) {
|
log.error("自动获取出发地GPS坐标失败", e);
|
}
|
}
|
}
|
|
// 自动获取目的地GPS坐标（如果更新了地址但缺失坐标）
|
if (updateVO.getDestinationAddress() != null &&
|
(updateVO.getDestinationLongitude() == null || updateVO.getDestinationLatitude() == null) &&
|
mapService != null) {
|
if (!updateVO.getDestinationAddress().equals(oldTask.getDestinationAddress())) {
|
try {
|
Map<String, Double> coords = mapService.geocoding(
|
updateVO.getDestinationAddress(),
|
extractCityFromAddress(updateVO.getDestinationAddress())
|
);
|
if (coords != null) {
|
task.setDestinationLongitude(BigDecimal.valueOf(coords.get("lng")));
|
task.setDestinationLatitude(BigDecimal.valueOf(coords.get("lat")));
|
log.info("目的地GPS坐标自动获取成功: {}, {}", coords.get("lng"), coords.get("lat"));
|
}
|
} catch (Exception e) {
|
log.error("自动获取目的地GPS坐标失败", e);
|
}
|
}
|
}
|
// 用于跟踪是否需要重新同步（车辆、人员、地址、成交价变更）
|
boolean needResync = true;
|
int result = sysTaskMapper.updateSysTask(task);
|
|
|
|
// 更新车辆关联
|
if (result > 0 && updateVO.getVehicleIds() != null && !updateVO.getVehicleIds().isEmpty()) {
|
// 查询现有的车辆关联
|
List<SysTaskVehicle> existingVehicles = sysTaskVehicleMapper.selectSysTaskVehicleByTaskId(updateVO.getTaskId());
|
List<Long> existingVehicleIds = existingVehicles.stream()
|
.map(SysTaskVehicle::getVehicleId)
|
.collect(Collectors.toList());
|
|
// 比较新旧车辆ID列表，判断是否有变化
|
boolean vehiclesChanged = !new HashSet<>(existingVehicleIds).equals(new HashSet<>(updateVO.getVehicleIds()));
|
|
// 只有车辆发生变化时才更新
|
if (vehiclesChanged) {
|
// 删除旧的车辆关联
|
sysTaskVehicleMapper.deleteSysTaskVehicleByTaskId(updateVO.getTaskId());
|
|
// 添加新的车辆关联
|
Date now = DateUtils.getNowDate();
|
String currentUser = userName;
|
for (Long vehicleId : updateVO.getVehicleIds()) {
|
SysTaskVehicle taskVehicle = new SysTaskVehicle();
|
taskVehicle.setTaskId(updateVO.getTaskId());
|
taskVehicle.setVehicleId(vehicleId);
|
taskVehicle.setAssignTime(now);
|
taskVehicle.setAssignBy(currentUser);
|
taskVehicle.setCreateTime(now);
|
sysTaskVehicleMapper.insertSysTaskVehicle(taskVehicle);
|
}
|
|
// 标记需要重新同步（车辆变更）
|
needResync = true;
|
}
|
}
|
|
// 更新执行人员（检测人员变更）
|
if (result > 0 && updateVO.getAssignees() != null) {
|
// 查询现有的执行人员
|
List<SysTaskAssignee> existingAssignees = sysTaskAssigneeMapper.selectSysTaskAssigneeByTaskId(updateVO.getTaskId());
|
List<Long> existingAssigneeIds = existingAssignees.stream()
|
.map(SysTaskAssignee::getUserId)
|
.collect(Collectors.toList());
|
|
List<Long> newAssigneeIds = updateVO.getAssignees().stream()
|
.map(TaskCreateVO.AssigneeInfo::getUserId)
|
.collect(Collectors.toList());
|
|
// 比较新旧执行人员ID列表，判断是否有变化
|
boolean assigneesChanged = !new HashSet<>(existingAssigneeIds).equals(new HashSet<>(newAssigneeIds));
|
|
// 只有执行人员发生变化时才更新
|
if (assigneesChanged) {
|
// 删除旧的执行人员关联
|
sysTaskAssigneeMapper.deleteSysTaskAssigneeByTaskId(updateVO.getTaskId());
|
|
// 添加新的执行人员关联
|
if (!updateVO.getAssignees().isEmpty()) {
|
saveTaskAssignees(updateVO.getTaskId(), updateVO.getAssignees(), userName);
|
}
|
|
// 标记需要重新同步（人员变更）
|
needResync = true;
|
}
|
}
|
|
// 更新急救转运扩展信息（检测地址和成交价变更）
|
if (result > 0 && "EMERGENCY_TRANSFER".equals(oldTask.getTaskType())) {
|
// 获取旧的急救转运信息
|
SysTaskEmergency oldEmergency = sysTaskEmergencyMapper.selectSysTaskEmergencyByTaskId(updateVO.getTaskId());
|
|
// 检测转出医院地址变更
|
boolean hospitalOutAddressChanged = false;
|
if (updateVO.getHospitalOut() != null && updateVO.getHospitalOut().getAddress() != null
|
&& oldEmergency != null
|
&& !updateVO.getHospitalOut().getAddress().equals(oldEmergency.getHospitalOutAddress())) {
|
hospitalOutAddressChanged = true;
|
}
|
|
// 检测转入医院地址变更
|
boolean hospitalInAddressChanged = false;
|
if (updateVO.getHospitalIn() != null && updateVO.getHospitalIn().getAddress() != null
|
&& oldEmergency != null
|
&& !updateVO.getHospitalIn().getAddress().equals(oldEmergency.getHospitalInAddress())) {
|
hospitalInAddressChanged = true;
|
}
|
|
// 检测成交价变更
|
boolean transferPriceChanged = false;
|
if (updateVO.getPrice() != null
|
&& oldEmergency != null
|
&& oldEmergency.getTransferPrice() != null
|
&& updateVO.getPrice().compareTo(oldEmergency.getTransferPrice()) != 0) {
|
transferPriceChanged = true;
|
}
|
|
;
|
|
// 更新急救转运信息
|
if (updateVO.getHospitalOut() != null || updateVO.getHospitalIn() != null || updateVO.getPatient() != null) {
|
updateEmergencyInfoFromCreateVO(updateVO.getTaskId(), updateVO, userName);
|
}
|
|
// 如果地址或成交价发生变更，标记需要重新同步
|
if (hospitalOutAddressChanged || hospitalInAddressChanged || transferPriceChanged) {
|
needResync = true;
|
}
|
}
|
|
// 更新福祉车扩展信息
|
if (result > 0 && "WELFARE".equals(oldTask.getTaskType())) {
|
if (updateVO.getPassenger() != null || updateVO.getStartAddress() != null || updateVO.getEndAddress() != null) {
|
updateWelfareInfoFromCreateVO(updateVO.getTaskId(), updateVO, userName);
|
}
|
}
|
|
// 如果是急救转运任务且有变更，标记需要重新同步
|
if (result > 0 && "EMERGENCY_TRANSFER".equals(oldTask.getTaskType()) && needResync && !updateFromLegacy) {
|
try {
|
sysTaskEmergencyService.markNeedResync(updateVO.getTaskId());
|
} catch (Exception e) {
|
// 标记失败不影响主流程
|
}
|
}
|
|
// 记录操作日志
|
if (result > 0) {
|
recordTaskLog(updateVO.getTaskId(), "UPDATE", "更新任务",
|
buildTaskDescription(oldTask), buildTaskDescription(task),
|
SecurityUtils.getUserId(), userName);
|
}
|
|
return result;
|
}
|
|
/**
|
* 更新任务（用于旧系统同步）
|
*
|
* @param updateVO 任务更新对象
|
* @param serviceOrderId 旧系统服务单ID
|
* @param dispatchOrderId 旧系统调度单ID
|
* @param serviceOrdNo 旧系统服务单编号
|
* @param userId 用户ID
|
* @param userName 用户名
|
* @param deptId 部门ID
|
* @param createTime 创建时间
|
* @param updateTime 更新时间
|
* @return 结果
|
*/
|
@Override
|
public int updateTask(TaskUpdateVO updateVO, String serviceOrderId, String dispatchOrderId, String serviceOrdNo,
|
Long userId, String userName, Long deptId, Date createTime, Date updateTime) {
|
// 通过旧系统服务单ID查找任务
|
SysTaskEmergency taskEmergency = sysTaskEmergencyMapper.selectByLegacyServiceOrdId(Long.parseLong(serviceOrderId));
|
Long taskId = taskEmergency.getTaskId();
|
updateVO.setTaskId(taskId);
|
SysTask task = new SysTask();
|
task.setTaskId(taskId);
|
task.setTaskDescription(updateVO.getTaskDescription());
|
task.setPlannedStartTime(updateVO.getPlannedStartTime());
|
task.setPlannedEndTime(updateVO.getPlannedEndTime());
|
task.setAssigneeId(updateVO.getAssigneeId());
|
task.setUpdateBy(userName);
|
task.setUpdateTime(DateUtils.getNowDate());
|
task.setRemark(updateVO.getRemark());
|
|
|
// 设置地址和坐标信息
|
task.setDepartureAddress(updateVO.getDepartureAddress());
|
task.setDestinationAddress(updateVO.getDestinationAddress());
|
task.setDepartureLongitude(updateVO.getDepartureLongitude());
|
task.setDepartureLatitude(updateVO.getDepartureLatitude());
|
task.setDestinationLongitude(updateVO.getDestinationLongitude());
|
task.setDestinationLatitude(updateVO.getDestinationLatitude());
|
|
// 如果更新了部门ID
|
if (updateVO.getDeptId() != null) {
|
task.setDeptId(updateVO.getDeptId());
|
}
|
|
// 如果更新了任务编号
|
if (updateVO.getTaskCode() != null) {
|
task.setTaskCode(updateVO.getTaskCode());
|
}
|
|
// 获取旧任务信息，用于判断地址是否变更
|
SysTask oldTask = sysTaskMapper.selectSysTaskByTaskId(taskId);
|
|
// 自动获取出发地GPS坐标（如果地址变更且缺失坐标）
|
if (oldTask != null && updateVO.getDepartureAddress() != null
|
&& !updateVO.getDepartureAddress().equals(oldTask.getDepartureAddress())
|
&& (updateVO.getDepartureLongitude() == null || updateVO.getDepartureLatitude() == null)
|
&& mapService != null) {
|
try {
|
Map<String, Double> coords = mapService.geocoding(
|
updateVO.getDepartureAddress(),
|
extractCityFromAddress(updateVO.getDepartureAddress())
|
);
|
if (coords != null) {
|
task.setDepartureLongitude(BigDecimal.valueOf(coords.get("lng")));
|
task.setDepartureLatitude(BigDecimal.valueOf(coords.get("lat")));
|
log.info("出发地GPS坐标自动获取成功: {}, {}", coords.get("lng"), coords.get("lat"));
|
}
|
} catch (Exception e) {
|
log.error("自动获取出发地GPS坐标失败", e);
|
}
|
}
|
|
// 自动获取目的地GPS坐标（如果地址变更且缺失坐标）
|
if (oldTask != null && updateVO.getDestinationAddress() != null
|
&& !updateVO.getDestinationAddress().equals(oldTask.getDestinationAddress())
|
&& (updateVO.getDestinationLongitude() == null || updateVO.getDestinationLatitude() == null)
|
&& mapService != null) {
|
try {
|
Map<String, Double> coords = mapService.geocoding(
|
updateVO.getDestinationAddress(),
|
extractCityFromAddress(updateVO.getDestinationAddress())
|
);
|
if (coords != null) {
|
task.setDestinationLongitude(BigDecimal.valueOf(coords.get("lng")));
|
task.setDestinationLatitude(BigDecimal.valueOf(coords.get("lat")));
|
log.info("目的地GPS坐标自动获取成功: {}, {}", coords.get("lng"), coords.get("lat"));
|
}
|
} catch (Exception e) {
|
log.error("自动获取目的地GPS坐标失败", e);
|
}
|
}
|
|
int result = sysTaskMapper.updateSysTask(task);
|
|
// 更新车辆关联
|
if (result > 0 && updateVO.getVehicleIds() != null && !updateVO.getVehicleIds().isEmpty()) {
|
// 查询现有的车辆关联
|
List<SysTaskVehicle> existingVehicles = sysTaskVehicleMapper.selectSysTaskVehicleByTaskId(taskId);
|
List<Long> existingVehicleIds = existingVehicles.stream()
|
.map(SysTaskVehicle::getVehicleId)
|
.collect(Collectors.toList());
|
|
// 比较新旧车辆ID列表，判断是否有变化
|
boolean vehiclesChanged = !new HashSet<>(existingVehicleIds).equals(new HashSet<>(updateVO.getVehicleIds()));
|
|
// 只有车辆发生变化时才更新
|
if (vehiclesChanged) {
|
// 删除旧的车辆关联
|
sysTaskVehicleMapper.deleteSysTaskVehicleByTaskId(taskId);
|
|
// 添加新的车辆关联
|
Date now = DateUtils.getNowDate();
|
for (Long vehicleId : updateVO.getVehicleIds()) {
|
SysTaskVehicle taskVehicle = new SysTaskVehicle();
|
taskVehicle.setTaskId(taskId);
|
taskVehicle.setVehicleId(vehicleId);
|
taskVehicle.setAssignTime(now);
|
taskVehicle.setAssignBy(userName);
|
taskVehicle.setCreateTime(now);
|
sysTaskVehicleMapper.insertSysTaskVehicle(taskVehicle);
|
}
|
}
|
}
|
|
// 更新执行人员（检测人员变更）
|
if (result > 0 && updateVO.getAssignees() != null) {
|
// 查询现有的执行人员
|
List<SysTaskAssignee> existingAssignees = sysTaskAssigneeMapper.selectSysTaskAssigneeByTaskId(taskId);
|
List<Long> existingAssigneeIds = existingAssignees.stream()
|
.map(SysTaskAssignee::getUserId)
|
.collect(Collectors.toList());
|
|
List<Long> newAssigneeIds = updateVO.getAssignees().stream()
|
.map(TaskCreateVO.AssigneeInfo::getUserId)
|
.collect(Collectors.toList());
|
|
// 比较新旧执行人员ID列表，判断是否有变化
|
boolean assigneesChanged = !new HashSet<>(existingAssigneeIds).equals(new HashSet<>(newAssigneeIds));
|
|
// 只有执行人员发生变化时才更新
|
if (assigneesChanged) {
|
// 删除旧的执行人员关联
|
sysTaskAssigneeMapper.deleteSysTaskAssigneeByTaskId(taskId);
|
|
// 添加新的执行人员关联
|
if (!updateVO.getAssignees().isEmpty()) {
|
saveTaskAssignees(taskId, updateVO.getAssignees(), userName);
|
}
|
}
|
}
|
|
// 更新急救转运扩展信息
|
if (result > 0) {
|
// 更新旧系统ID
|
if (serviceOrderId != null) {
|
taskEmergency.setLegacyServiceOrdId(Long.parseLong(serviceOrderId));
|
}
|
if (dispatchOrderId != null) {
|
taskEmergency.setLegacyDispatchOrdId(Long.parseLong(dispatchOrderId));
|
}
|
if (serviceOrdNo != null) {
|
taskEmergency.setLegacyServiceOrdNo(serviceOrdNo);
|
}
|
|
// 使用TaskCreateVO的字段来更新急救转运信息
|
if (updateVO.getHospitalOut() != null || updateVO.getHospitalIn() != null || updateVO.getPatient() != null) {
|
updateEmergencyInfoFromCreateVO(taskId, updateVO, userName);
|
}
|
}
|
|
return result;
|
}
|
|
/**
|
* 批量删除任务管理
|
*
|
* @param taskIds 需要删除的任务管理主键
|
* @return 结果
|
*/
|
@Override
|
@Transactional
|
public int deleteSysTaskByTaskIds(Long[] taskIds) {
|
int result = 0;
|
for (Long taskId : taskIds) {
|
// 记录删除日志
|
recordTaskLog(taskId, "DELETE", "删除任务", null, null,
|
SecurityUtils.getUserId(), SecurityUtils.getUsername());
|
result += sysTaskMapper.deleteSysTaskByTaskId(taskId);
|
}
|
return result;
|
}
|
|
/**
|
* 分配任务
|
*
|
* @param taskId 任务ID
|
* @param assigneeId 执行人ID
|
* @param remark 备注
|
* @return 结果
|
*/
|
@Override
|
@Transactional
|
public int assignTask(Long taskId, Long assigneeId, String remark) {
|
SysTask task = sysTaskMapper.selectSysTaskByTaskId(taskId);
|
if (task == null) {
|
throw new RuntimeException("任务不存在");
|
}
|
|
SysTask updateTask = new SysTask();
|
updateTask.setTaskId(taskId);
|
updateTask.setAssigneeId(assigneeId);
|
updateTask.setUpdateBy(SecurityUtils.getUsername());
|
updateTask.setUpdateTime(DateUtils.getNowDate());
|
|
int result = sysTaskMapper.assignTask(updateTask);
|
|
// 记录操作日志
|
if (result > 0) {
|
recordTaskLog(taskId, "ASSIGN", "分配任务", null,
|
"分配给用户ID：" + assigneeId + "，备注：" + remark,
|
SecurityUtils.getUserId(), SecurityUtils.getUsername());
|
}
|
|
// 发布任务分配事件
|
if (result > 0) {
|
List<Long> assigneeIds = new ArrayList<>();
|
assigneeIds.add(assigneeId);
|
|
eventPublisher.publishEvent(new TaskAssignedEvent(
|
this,
|
task.getTaskId(),
|
task.getTaskCode(),
|
assigneeIds,
|
null, // 姓名列表在监听器中查询
|
SecurityUtils.getUserId(),
|
SecurityUtils.getUsername()
|
));
|
}
|
|
return result;
|
}
|
|
/**
|
* 变更任务状态
|
*
|
* @param taskId 任务ID
|
* @param newStatus 新状态
|
* @param remark 备注
|
* @return 结果
|
*/
|
@Override
|
@Transactional
|
public int changeTaskStatus(Long taskId, TaskStatus newStatus, String remark) {
|
return changeTaskStatusWithLocation(taskId, newStatus, remark, null);
|
}
|
|
/**
|
* 变更任务状态（含GPS位置信息）
|
*
|
* @param taskId 任务ID
|
* @param newStatus 新状态
|
* @param remark 备注
|
* @param locationLog GPS位置信息日志对象
|
* @return 结果
|
*/
|
@Override
|
@Transactional
|
public int changeTaskStatusWithLocation(Long taskId, TaskStatus newStatus, String remark, SysTaskLog locationLog) {
|
SysTask oldTask = sysTaskMapper.selectSysTaskByTaskId(taskId);
|
if (oldTask == null) {
|
throw new RuntimeException("任务不存在");
|
}
|
|
// 验证状态流转是否合法
|
TaskStatus oldTaskStatus = TaskStatus.getByCode(oldTask.getTaskStatus());
|
if (!oldTask.canChangeStatus(newStatus)) {
|
throw new RuntimeException("状态流转不合法：从 " + oldTaskStatus.getInfo() + " 到 " + newStatus.getInfo());
|
}
|
|
SysTask task = new SysTask();
|
task.setTaskId(taskId);
|
task.setTaskStatus(newStatus.getCode());
|
task.setUpdateBy(SecurityUtils.getUsername());
|
task.setUpdateTime(DateUtils.getNowDate());
|
|
// 根据状态设置相应的时间
|
if (newStatus == TaskStatus.DEPARTING && oldTask.getActualStartTime() == null) {
|
// 出发中：设置实际开始时间
|
task.setActualStartTime(DateUtils.getNowDate());
|
} else if (newStatus == TaskStatus.IN_PROGRESS && oldTask.getActualStartTime() == null) {
|
// 兼容旧数据：任务中状态也设置实际开始时间
|
task.setActualStartTime(DateUtils.getNowDate());
|
} else if (newStatus == TaskStatus.COMPLETED) {
|
// 已完成：设置实际结束时间
|
task.setActualEndTime(DateUtils.getNowDate());
|
}
|
|
int result = sysTaskMapper.updateTaskStatus(task);
|
|
// 记录操作日志（含GPS位置信息）
|
if (result > 0) {
|
recordTaskLog(taskId, "STATUS_CHANGE", "状态变更",
|
"状态：" + oldTaskStatus.getInfo(),
|
"状态：" + newStatus.getInfo() + "，备注：" + remark,
|
SecurityUtils.getUserId(), SecurityUtils.getUsername(),
|
locationLog);
|
}
|
|
// 发布任务状态变更事件
|
if (result > 0) {
|
// 查询任务的所有执行人
|
List<SysTaskAssignee> assignees = sysTaskAssigneeMapper.selectSysTaskAssigneeByTaskId(taskId);
|
List<Long> assigneeIds = null;
|
if (assignees != null && !assignees.isEmpty()) {
|
assigneeIds = assignees.stream()
|
.map(SysTaskAssignee::getUserId)
|
.collect(Collectors.toList());
|
}
|
|
eventPublisher.publishEvent(new TaskStatusChangedEvent(
|
this,
|
oldTask.getTaskId(),
|
oldTask.getTaskCode(),
|
oldTaskStatus.getCode(),
|
newStatus.getCode(),
|
oldTaskStatus.getInfo(),
|
newStatus.getInfo(),
|
assigneeIds,
|
oldTask.getCreatorId()
|
));
|
}
|
|
return result;
|
}
|
|
/**
|
* 上传任务附件
|
*
|
* @param taskId 任务ID
|
* @param file 文件
|
* @param category 附件分类
|
* @return 结果
|
*/
|
@Override
|
@Transactional
|
public Long uploadAttachment(Long taskId, MultipartFile file, String category) {
|
try {
|
// 上传文件，返回相对路径（如：/task/2025/01/15/xxx.jpg）
|
String fileName = category+"_"+System.currentTimeMillis()+"_"+file.getOriginalFilename();
|
|
fileName=saveLocalPath(fileName,file.getInputStream());
|
|
SysTaskAttachment attachment = new SysTaskAttachment();
|
attachment.setTaskId(taskId);
|
attachment.setFileName(file.getOriginalFilename());
|
// 保存相对路径，不包含 baseDir
|
attachment.setFilePath(fileName);
|
attachment.setFileSize(file.getSize());
|
attachment.setFileType(getFileType(file.getOriginalFilename()));
|
attachment.setAttachmentCategory(category);
|
attachment.setUploadTime(DateUtils.getNowDate());
|
attachment.setUploadBy(SecurityUtils.getUsername());
|
|
Long result = sysTaskAttachmentMapper.insertSysTaskAttachment(attachment);
|
|
// 记录操作日志
|
if (result > 0) {
|
String categoryDesc = getCategoryDesc(category);
|
recordTaskLog(taskId, "UPDATE", "上传附件", null,
|
"上传文件：" + file.getOriginalFilename() + "(分类：" + categoryDesc + ")",
|
SecurityUtils.getUserId(), SecurityUtils.getUsername());
|
|
|
}
|
|
return attachment.getAttachmentId();
|
} catch (IOException e) {
|
throw new RuntimeException("文件上传失败：" + e.getMessage());
|
}
|
}
|
|
/**
|
* 从微信mediaId上传任务附件
|
*
|
* @param taskId 任务ID
|
* @param accessToken 微信AccessToken
|
* @param mediaId 微信mediaId
|
* @param category 附件分类
|
* @return 返回附件ID
|
*/
|
@Override
|
@Transactional
|
public Long uploadAttachmentFromWechat(Long taskId, String accessToken, String mediaId, String category) {
|
try {
|
// 从微信服务器下载文件
|
String wechatUrl = String.format(
|
"https://api.weixin.qq.com/cgi-bin/media/get?access_token=%s&media_id=%s",
|
accessToken, mediaId
|
);
|
|
byte[] fileBytes = downloadFromUrl(wechatUrl);
|
if (fileBytes == null || fileBytes.length == 0) {
|
throw new RuntimeException("从微信下载文件失败");
|
}
|
|
// 生成文件名（使用mediaId作为文件名的一部分）
|
String fileName = "wx_" + mediaId.substring(0, Math.min(20, mediaId.length())) + "_" + System.currentTimeMillis() + ".jpg";
|
|
// 保存到本地
|
String relativeFilePath = saveLocalPath(fileName, fileBytes);
|
|
// 保存附件记录
|
SysTaskAttachment attachment = new SysTaskAttachment();
|
attachment.setTaskId(taskId);
|
attachment.setFileName(fileName);
|
// 保存相对路径
|
attachment.setFilePath(relativeFilePath);
|
attachment.setFileSize((long) fileBytes.length);
|
attachment.setFileType("jpg");
|
attachment.setAttachmentCategory(category);
|
attachment.setUploadTime(DateUtils.getNowDate());
|
attachment.setUploadBy(SecurityUtils.getUsername());
|
|
Long result = sysTaskAttachmentMapper.insertSysTaskAttachment(attachment);
|
|
// 记录操作日志
|
if (result > 0) {
|
String categoryDesc = getCategoryDesc(category);
|
recordTaskLog(taskId, "UPDATE", "上传附件", null,
|
"通过微信上传文件：" + fileName + "(分类：" + categoryDesc + ")",
|
SecurityUtils.getUserId(), SecurityUtils.getUsername());
|
|
|
}
|
|
return attachment.getAttachmentId();
|
} catch (Exception e) {
|
throw new RuntimeException("从微信上传文件失败：" + e.getMessage());
|
}
|
}
|
|
private static String saveLocalPath(String fileName, byte[] fileBytes) throws IOException {
|
String baseDir = FileUploadUtils.getDefaultBaseDir();
|
String datePath = DateUtils.datePath();
|
String uploadDir = baseDir + "/task/" + datePath;
|
|
// 创建目录
|
File uploadPath = new File(uploadDir);
|
if (!uploadPath.exists()) {
|
uploadPath.mkdirs();
|
}
|
|
// 保存文件
|
String filePath = uploadDir + "/" + fileName;
|
File file = new File(filePath);
|
try (FileOutputStream fos = new FileOutputStream(file)) {
|
fos.write(fileBytes);
|
}
|
|
// 生成相对路径（不包含baseDir）
|
String relativeFilePath = "/task/" + datePath + "/" + fileName;
|
return relativeFilePath;
|
}
|
|
private String saveLocalPath(String fileName,InputStream stream){
|
String baseDir = FileUploadUtils.getDefaultBaseDir();
|
String datePath = DateUtils.datePath();
|
String uploadDir = baseDir + "/task/" + datePath;
|
|
// 创建目录
|
File uploadPath = new File(uploadDir);
|
if (!uploadPath.exists()) {
|
uploadPath.mkdirs();
|
}
|
|
// 保存文件
|
String filePath = uploadDir + "/" + fileName;
|
//将inputstream写入文件
|
try (OutputStream os = new FileOutputStream(filePath)) {
|
byte[] buffer = new byte[1024]; // 缓冲区，减少 IO 次数
|
int bytesRead;
|
// 循环读取输入流中的数据，写入输出流
|
while ((bytesRead = stream.read(buffer)) != -1) {
|
os.write(buffer, 0, bytesRead);
|
}
|
os.flush(); // 强制刷新缓冲区，确保数据写入文件
|
} catch (IOException e) {
|
e.printStackTrace();
|
}
|
|
// 生成相对路径（不包含baseDir）
|
String relativeFilePath = "/task/" + datePath + "/" + fileName;
|
return relativeFilePath;
|
}
|
|
/**
|
* 从 URL 下载文件
|
*/
|
private byte[] downloadFromUrl(String fileUrl) throws IOException {
|
URL url = new URL(fileUrl);
|
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
|
connection.setRequestMethod("GET");
|
connection.setConnectTimeout(10000);
|
connection.setReadTimeout(30000);
|
|
try (InputStream inputStream = connection.getInputStream()) {
|
byte[] buffer = new byte[4096];
|
int bytesRead;
|
java.io.ByteArrayOutputStream outputStream = new java.io.ByteArrayOutputStream();
|
|
while ((bytesRead = inputStream.read(buffer)) != -1) {
|
outputStream.write(buffer, 0, bytesRead);
|
}
|
|
return outputStream.toByteArray();
|
} finally {
|
connection.disconnect();
|
}
|
}
|
|
/**
|
* 删除任务附件
|
*
|
* @param attachmentId 附件ID
|
* @return 结果
|
*/
|
@Override
|
@Transactional
|
public int deleteAttachment(Long attachmentId) {
|
SysTaskAttachment attachment = sysTaskAttachmentMapper.selectSysTaskAttachmentByAttachmentId(attachmentId);
|
if (attachment == null) {
|
throw new RuntimeException("附件不存在");
|
}
|
|
// 删除物理文件
|
try {
|
FileUtils.deleteFile(attachment.getFilePath());
|
} catch (Exception e) {
|
// 忽略文件删除失败
|
}
|
|
int result = sysTaskAttachmentMapper.deleteSysTaskAttachmentByAttachmentId(attachmentId);
|
|
// 记录操作日志
|
if (result > 0) {
|
recordTaskLog(attachment.getTaskId(), "UPDATE", "删除附件",
|
"删除文件：" + attachment.getFileName(), null,
|
SecurityUtils.getUserId(), SecurityUtils.getUsername());
|
}
|
|
return result;
|
}
|
|
/**
|
* 根据ID获取附件详情
|
*
|
* @param attachmentId 附件ID
|
* @return 附件详情
|
*/
|
@Override
|
public SysTaskAttachment getAttachmentById(Long attachmentId) {
|
SysTaskAttachment attachment = sysTaskAttachmentMapper.selectSysTaskAttachmentByAttachmentId(attachmentId);
|
if (attachment != null) {
|
// 拼接完整URL
|
buildAttachmentUrl(attachment);
|
}
|
return attachment;
|
}
|
|
@Override
|
public List<SysTaskAttachment> getAttachmentsByTaskId(Long taskId) {
|
return sysTaskAttachmentMapper.selectSysTaskAttachmentByTaskId(taskId);
|
}
|
|
/**
|
* 分配车辆给任务
|
*
|
* @param taskId 任务ID
|
* @param vehicleId 车辆ID
|
* @param remark 备注
|
* @return 结果
|
*/
|
@Override
|
@Transactional
|
public int assignVehicleToTask(Long taskId, Long vehicleId, String remark,Long userId,String userName) {
|
// 检查是否已经分配
|
int exists = sysTaskVehicleMapper.checkTaskVehicleExists(taskId, vehicleId);
|
if (exists > 0) {
|
throw new RuntimeException("车辆已经分配给该任务");
|
}
|
|
SysTaskVehicle taskVehicle = new SysTaskVehicle();
|
taskVehicle.setTaskId(taskId);
|
taskVehicle.setVehicleId(vehicleId);
|
taskVehicle.setAssignTime(DateUtils.getNowDate());
|
taskVehicle.setAssignBy(userName);
|
taskVehicle.setStatus("ASSIGNED");
|
taskVehicle.setRemark(remark);
|
|
int result = sysTaskVehicleMapper.insertSysTaskVehicle(taskVehicle);
|
|
// 记录操作日志
|
if (result > 0) {
|
recordTaskLog(taskId, "ASSIGN", "分配车辆", null,
|
"分配车辆ID：" + vehicleId + "，备注：" + remark,
|
userId, userName);
|
}
|
|
return result;
|
}
|
|
/**
|
* 取消任务车辆分配
|
*
|
* @param taskId 任务ID
|
* @param vehicleId 车辆ID
|
* @return 结果
|
*/
|
@Override
|
@Transactional
|
public int unassignVehicleFromTask(Long taskId, Long vehicleId) {
|
int result = sysTaskVehicleMapper.deleteSysTaskVehicleByTaskIdAndVehicleId(taskId, vehicleId);
|
|
// 记录操作日志
|
if (result > 0) {
|
recordTaskLog(taskId, "ASSIGN", "取消车辆分配",
|
"取消车辆ID：" + vehicleId, null,
|
SecurityUtils.getUserId(), SecurityUtils.getUsername());
|
}
|
|
return result;
|
}
|
|
/**
|
* 批量分配车辆给任务
|
*
|
* @param taskId 任务ID
|
* @param vehicleIds 车辆ID列表
|
* @param remark 备注
|
* @return 结果
|
*/
|
@Override
|
@Transactional
|
public int assignMultipleVehiclesToTask(Long taskId, List<Long> vehicleIds, String remark,Long userId,String userName) {
|
List<SysTaskVehicle> taskVehicles = new ArrayList<>();
|
Date now = DateUtils.getNowDate();
|
String assignBy = userName;
|
|
for (Long vehicleId : vehicleIds) {
|
// 检查是否已经分配
|
int exists = sysTaskVehicleMapper.checkTaskVehicleExists(taskId, vehicleId);
|
if (exists == 0) {
|
SysTaskVehicle taskVehicle = new SysTaskVehicle();
|
taskVehicle.setTaskId(taskId);
|
taskVehicle.setVehicleId(vehicleId);
|
taskVehicle.setAssignTime(now);
|
taskVehicle.setAssignBy(assignBy);
|
taskVehicle.setStatus("ASSIGNED");
|
taskVehicle.setRemark(remark);
|
taskVehicles.add(taskVehicle);
|
}
|
}
|
|
int result = 0;
|
if (!taskVehicles.isEmpty()) {
|
result = sysTaskVehicleMapper.batchInsertSysTaskVehicle(taskVehicles);
|
}
|
|
// 记录操作日志
|
if (result > 0) {
|
recordTaskLog(taskId, "ASSIGN", "批量分配车辆", null,
|
"分配车辆数量：" + result + "，备注：" + remark,
|
userId,userName);
|
}
|
|
return result;
|
}
|
|
/**
|
* 查询任务关联的车辆
|
*
|
* @param taskId 任务ID
|
* @return 任务车辆关联列表
|
*/
|
@Override
|
public List<SysTaskVehicle> getTaskVehicles(Long taskId) {
|
return sysTaskVehicleMapper.selectSysTaskVehicleByTaskId(taskId);
|
}
|
|
/**
|
* 查询可用车辆
|
*
|
* @param deptId 部门ID
|
* @param taskType 任务类型
|
* @return 可用车辆列表
|
*/
|
@Override
|
public List<SysTaskVehicle> getAvailableVehicles(Long deptId, String taskType) {
|
List<SysTaskVehicle> availableVehicles = new ArrayList<>();
|
|
try {
|
// 查询所有状态为正常的车辆（不限制部门）
|
VehicleInfo queryParam = new VehicleInfo();
|
queryParam.setStatus("0"); // 0表示正常状态
|
// 不设置deptId，查询所有部门的车辆
|
queryParam.setDeptId(deptId);
|
|
List<VehicleInfo> vehicles = vehicleInfoMapper.selectVehicleInfoList(queryParam);
|
|
// 转换为SysTaskVehicle对象
|
for (VehicleInfo vehicle : vehicles) {
|
SysTaskVehicle taskVehicle = new SysTaskVehicle();
|
taskVehicle.setVehicleId(vehicle.getVehicleId());
|
taskVehicle.setVehicleNo(vehicle.getVehicleNo());
|
taskVehicle.setVehicleType(vehicle.getVehicleType());
|
taskVehicle.setVehicleBrand(vehicle.getVehicleBrand());
|
taskVehicle.setVehicleModel(vehicle.getVehicleModel());
|
taskVehicle.setDeptName(vehicle.getDeptName()); // 添加部门名称
|
availableVehicles.add(taskVehicle);
|
}
|
} catch (Exception e) {
|
// 如果查询失败，记录日志并返回空列表
|
System.err.println("查询可用车辆失败: " + e.getMessage());
|
}
|
|
return availableVehicles;
|
}
|
|
/**
|
* 查询任务统计信息
|
*
|
* @return 任务统计信息
|
*/
|
@Override
|
public TaskStatisticsVO getTaskStatistics() {
|
return sysTaskMapper.selectTaskStatistics();
|
}
|
|
/**
|
* 查询超时任务列表
|
*
|
* @return 超时任务列表
|
*/
|
@Override
|
public List<SysTask> selectOverdueTasks() {
|
return sysTaskMapper.selectOverdueTasks();
|
}
|
|
/**
|
* 查询我的任务列表
|
*
|
* @param userId 用户ID
|
* @return 我的任务列表
|
*/
|
@Override
|
public List<SysTask> selectMyTasks(Long userId) {
|
return sysTaskMapper.selectMyTasks(userId);
|
}
|
|
/**
|
* 获取任务详情（包含关联数据）
|
*
|
* @param taskId 任务ID
|
* @return 任务详情
|
*/
|
@Override
|
public SysTask getTaskDetail(Long taskId) {
|
SysTask task = sysTaskMapper.selectSysTaskByTaskId(taskId);
|
if (task != null) {
|
// 查询关联车辆
|
task.setAssignedVehicles(sysTaskVehicleMapper.selectSysTaskVehicleByTaskId(taskId));
|
// 查询附件
|
List<SysTaskAttachment> attachments = sysTaskAttachmentMapper.selectSysTaskAttachmentByTaskId(taskId);
|
// 为每个附件拼接完整URL
|
if (attachments != null && !attachments.isEmpty()) {
|
attachments.forEach(this::buildAttachmentUrl);
|
}
|
task.setAttachments(attachments);
|
// 查询操作日志
|
task.setOperationLogs(sysTaskLogMapper.selectSysTaskLogByTaskId(taskId));
|
// 查询执行人员列表
|
task.setAssignees(sysTaskAssigneeMapper.selectSysTaskAssigneeByTaskId(taskId));
|
// 加载急救转运扩展信息
|
if ("EMERGENCY_TRANSFER".equals(task.getTaskType())) {
|
SysTaskEmergency emergencyInfo = sysTaskEmergencyMapper.selectSysTaskEmergencyByTaskId(taskId);
|
task.setEmergencyInfo(emergencyInfo);
|
}
|
// 加载福祉车扩展信息
|
else if ("WELFARE".equals(task.getTaskType())) {
|
SysTaskWelfare welfareInfo = sysTaskWelfareMapper.selectSysTaskWelfareByTaskId(taskId);
|
task.setWelfareInfo(welfareInfo);
|
}
|
}
|
return task;
|
}
|
|
/**
|
* 检查车辆是否有正在进行中的任务
|
* 正在进行中的任务是指状态不为：PENDING（待处理）、COMPLETED（已完成）、CANCELLED（已取消）的任务
|
*
|
* @param vehicleId 车辆ID
|
* @return 正在进行中的任务列表
|
*/
|
@Override
|
public List<SysTask> checkVehicleActiveTasks(Long vehicleId) {
|
return sysTaskMapper.selectActiveTasksByVehicleId(vehicleId);
|
}
|
|
/**
|
* 检查任务是否已关联旧系统服务单ID
|
*
|
* @param taskId 任务ID
|
* @return true-已关联，false-未关联
|
*/
|
@Override
|
public boolean hasLegacyServiceOrdId(Long taskId) {
|
// 只有急救转运任务才有旧系统ID
|
SysTask task = sysTaskMapper.selectSysTaskByTaskId(taskId);
|
if (task != null && "EMERGENCY_TRANSFER".equals(task.getTaskType())) {
|
SysTaskEmergency emergencyInfo = sysTaskEmergencyMapper.selectSysTaskEmergencyByTaskId(taskId);
|
return emergencyInfo != null && emergencyInfo.getLegacyServiceOrdId() != null;
|
}
|
return false;
|
}
|
|
/**
|
* 检查任务是否已关联旧系统调度单ID
|
*
|
* @param taskId 任务ID
|
* @return true-已关联，false-未关联
|
*/
|
@Override
|
public boolean hasLegacyDispatchOrdId(Long taskId) {
|
// 只有急救转运任务才有旧系统ID
|
SysTask task = sysTaskMapper.selectSysTaskByTaskId(taskId);
|
if (task != null && "EMERGENCY_TRANSFER".equals(task.getTaskType())) {
|
SysTaskEmergency emergencyInfo = sysTaskEmergencyMapper.selectSysTaskEmergencyByTaskId(taskId);
|
return emergencyInfo != null && emergencyInfo.getLegacyDispatchOrdId() != null;
|
}
|
return false;
|
}
|
|
/**
|
* 根据旧系统服务单ID检查是否存在任务
|
*
|
* @param legacyServiceOrdId 旧系统服务单ID
|
* @return true-存在，false-不存在
|
*/
|
@Override
|
public boolean existsByLegacyServiceOrdId(Long legacyServiceOrdId) {
|
if (legacyServiceOrdId == null) {
|
return false;
|
}
|
SysTaskEmergency emergencyInfo = sysTaskEmergencyMapper.selectByLegacyServiceOrdId(legacyServiceOrdId);
|
return emergencyInfo != null;
|
}
|
|
/**
|
* 根据旧系统调度单ID检查是否存在任务
|
*
|
* @param legacyDispatchOrdId 旧系统调度单ID
|
* @return true-存在，false-不存在
|
*/
|
@Override
|
public boolean existsByLegacyDispatchOrdId(Long legacyDispatchOrdId) {
|
if (legacyDispatchOrdId == null) {
|
return false;
|
}
|
SysTaskEmergency emergencyInfo = sysTaskEmergencyMapper.selectByLegacyDispatchOrdId(legacyDispatchOrdId);
|
return emergencyInfo != null;
|
}
|
|
@Autowired
|
private TaskCodeGenerator taskCodeGenerator;
|
|
/**
|
* 生成任务编号
|
*
|
* @return 任务编号
|
*/
|
private String generateTaskCode() {
|
return taskCodeGenerator.generateTaskCode();
|
}
|
|
/**
|
* 从地址中提取城市名称（用于地图地理编码）
|
*
|
* @param address 地址
|
* @return 城市名称
|
*/
|
private String extractCityFromAddress(String address) {
|
if (address == null || address.trim().isEmpty()) {
|
return null;
|
}
|
|
// 常见城市名列表
|
String[] cities = {"广州", "深圳", "东莞", "佛山", "珠海", "惠州", "中山", "江门", "湛江", "肇庆", "清远", "韶关", "梅州", "河源", "潮州", "揭阳", "汕头", "汕尾", "云浮", "阳江","北京","上海","天津"};
|
|
|
for (String city : cities) {
|
if (address.contains(city)) {
|
return city;
|
}
|
}
|
|
return null;
|
}
|
|
/**
|
* 记录任务操作日志
|
*
|
* @param taskId 任务ID
|
* @param operationType 操作类型
|
* @param operationDesc 操作描述
|
* @param oldValue 操作前值
|
* @param newValue 操作后值
|
* @param operatorId 操作人ID
|
* @param operatorName 操作人姓名
|
*/
|
private void recordTaskLog(Long taskId, String operationType, String operationDesc,
|
String oldValue, String newValue, Long operatorId, String operatorName) {
|
recordTaskLog(taskId, operationType, operationDesc, oldValue, newValue,
|
operatorId, operatorName, null);
|
}
|
|
/**
|
* 记录任务操作日志（含GPS位置信息）
|
*
|
* @param taskId 任务ID
|
* @param operationType 操作类型
|
* @param operationDesc 操作描述
|
* @param oldValue 操作前值
|
* @param newValue 操作后值
|
* @param operatorId 操作人ID
|
* @param operatorName 操作人姓名
|
* @param log GPS位置信息日志对象（可为null）
|
*/
|
private void recordTaskLog(Long taskId, String operationType, String operationDesc,
|
String oldValue, String newValue, Long operatorId, String operatorName,
|
SysTaskLog log) {
|
if (log == null) {
|
log = new SysTaskLog();
|
}
|
|
log.setTaskId(taskId);
|
log.setOperationType(operationType);
|
log.setOperationDesc(operationDesc);
|
log.setOldValue(oldValue);
|
log.setNewValue(newValue);
|
log.setOperatorId(operatorId);
|
log.setOperatorName(operatorName);
|
log.setOperationTime(DateUtils.getNowDate());
|
// 这里可以获取IP地址
|
log.setIpAddress("127.0.0.1");
|
|
sysTaskLogMapper.insertSysTaskLog(log);
|
}
|
|
/**
|
* 构建任务描述
|
*
|
* @param task 任务对象
|
* @return 任务描述
|
*/
|
private String buildTaskDescription(SysTask task) {
|
StringBuilder sb = new StringBuilder();
|
sb.append("任务编号：").append(task.getTaskCode()).append("，");
|
sb.append("任务类型：").append(task.getTaskType()).append("，");
|
sb.append("任务状态：").append(task.getTaskStatus()).append("，");
|
if (StringUtils.isNotEmpty(task.getTaskDescription())) {
|
sb.append("任务描述：").append(task.getTaskDescription()).append("，");
|
}
|
return sb.toString();
|
}
|
|
/**
|
* 获取文件类型
|
*
|
* @param fileName 文件名
|
* @return 文件类型
|
*/
|
private String getFileType(String fileName) {
|
if (StringUtils.isEmpty(fileName)) {
|
return "";
|
}
|
int lastDotIndex = fileName.lastIndexOf(".");
|
if (lastDotIndex > 0 && lastDotIndex < fileName.length() - 1) {
|
return fileName.substring(lastDotIndex + 1).toLowerCase();
|
}
|
return "";
|
}
|
|
/**
|
* 计算预计公里数
|
*
|
* @param task 任务对象
|
*/
|
private void calculateEstimatedDistance(SysTask task) {
|
if (task.getDepartureLongitude() != null && task.getDepartureLatitude() != null &&
|
task.getDestinationLongitude() != null && task.getDestinationLatitude() != null) {
|
|
// 验证GPS坐标是否有效
|
if (GpsDistanceUtils.isValidCoordinate(task.getDepartureLatitude(), task.getDepartureLongitude()) &&
|
GpsDistanceUtils.isValidCoordinate(task.getDestinationLatitude(), task.getDestinationLongitude())) {
|
|
// 计算距离
|
java.math.BigDecimal distance = GpsDistanceUtils.calculateDistance(
|
task.getDepartureLatitude(), task.getDepartureLongitude(),
|
task.getDestinationLatitude(), task.getDestinationLongitude()
|
);
|
|
task.setEstimatedDistance(distance);
|
} else {
|
// 坐标无效，设置为0
|
task.setEstimatedDistance(java.math.BigDecimal.ZERO);
|
}
|
} else {
|
// 坐标不完整，设置为0
|
task.setEstimatedDistance(java.math.BigDecimal.ZERO);
|
}
|
}
|
|
/**
|
* 保存任务执行人员信息（包含角色类型）
|
*
|
* @param taskId 任务ID
|
* @param assignees 执行人员信息列表
|
*/
|
private void saveTaskAssignees(Long taskId, java.util.List<TaskCreateVO.AssigneeInfo> assignees,String userName) {
|
if (assignees == null || assignees.isEmpty()) {
|
return;
|
}
|
|
java.util.List<SysTaskAssignee> taskAssignees = new java.util.ArrayList<>();
|
Date now = DateUtils.getNowDate();
|
String currentUser = userName;
|
|
for (int i = 0; i < assignees.size(); i++) {
|
TaskCreateVO.AssigneeInfo assigneeInfo = assignees.get(i);
|
|
SysTaskAssignee taskAssignee = new SysTaskAssignee();
|
taskAssignee.setTaskId(taskId);
|
taskAssignee.setUserId(assigneeInfo.getUserId());
|
taskAssignee.setUserName(assigneeInfo.getUserName());
|
taskAssignee.setUserType(assigneeInfo.getUserType());
|
// 第一个执行人员为主要执行人
|
taskAssignee.setIsPrimary(i == 0 ? "1" : "0");
|
taskAssignee.setSortOrder(i);
|
taskAssignee.setCreateTime(now);
|
taskAssignee.setCreateBy(currentUser);
|
taskAssignee.setUpdateTime(now);
|
taskAssignee.setUpdateBy(currentUser);
|
|
taskAssignees.add(taskAssignee);
|
}
|
|
// 批量保存
|
if (!taskAssignees.isEmpty()) {
|
sysTaskAssigneeMapper.batchInsertSysTaskAssignee(taskAssignees);
|
}
|
}
|
|
/**
|
* 保存急救转运任务扩展信息
|
*
|
* @param taskId 任务ID
|
* @param createVO 任务创建对象
|
*/
|
private void saveEmergencyInfo(Long taskId,String createUserName, TaskCreateVO createVO,String serviceOrderId,String dispatchOrderId, String serviceOrdNo) {
|
SysTaskEmergency emergencyInfo = new SysTaskEmergency();
|
emergencyInfo.setTaskId(taskId);
|
|
// 设置患者信息
|
if (createVO.getPatient() != null) {
|
emergencyInfo.setPatientContact(createVO.getPatient().getContact());
|
emergencyInfo.setPatientPhone(createVO.getPatient().getPhone());
|
emergencyInfo.setPatientName(createVO.getPatient().getName());
|
emergencyInfo.setPatientGender(createVO.getPatient().getGender());
|
emergencyInfo.setPatientIdCard(createVO.getPatient().getIdCard());
|
emergencyInfo.setPatientCondition(createVO.getPatient().getCondition());
|
}
|
|
// 设置转出医院信息
|
if (createVO.getHospitalOut() != null) {
|
emergencyInfo.setHospitalOutId(createVO.getHospitalOut().getId());
|
emergencyInfo.setHospitalOutName(createVO.getHospitalOut().getName());
|
emergencyInfo.setHospitalOutDepartment(createVO.getHospitalOut().getDepartment());
|
emergencyInfo.setHospitalOutDepartmentId(createVO.getHospitalOut().getDepartmentId());
|
emergencyInfo.setHospitalOutBedNumber(createVO.getHospitalOut().getBedNumber());
|
emergencyInfo.setHospitalOutAddress(createVO.getHospitalOut().getAddress());
|
|
// GPS坐标：优先使用前端传入的，否则后端自动获取
|
if (createVO.getHospitalOut().getLongitude() != null && createVO.getHospitalOut().getLatitude() != null) {
|
emergencyInfo.setHospitalOutLongitude(createVO.getHospitalOut().getLongitude());
|
emergencyInfo.setHospitalOutLatitude(createVO.getHospitalOut().getLatitude());
|
} else if (mapService != null && createVO.getHospitalOut().getAddress() != null) {
|
// 后端自动获取GPS坐标
|
try {
|
Map<String, Double> coords = mapService.geocoding(
|
createVO.getHospitalOut().getAddress(),
|
extractCityFromAddress(createVO.getHospitalOut().getAddress())
|
);
|
if (coords != null) {
|
emergencyInfo.setHospitalOutLongitude(BigDecimal.valueOf(coords.get("lng")));
|
emergencyInfo.setHospitalOutLatitude(BigDecimal.valueOf(coords.get("lat")));
|
log.info("转出医院GPS坐标自动获取成功: {}, {}", coords.get("lng"), coords.get("lat"));
|
}
|
} catch (Exception e) {
|
log.error("自动获取转出医院GPS坐标失败", e);
|
}
|
}
|
}
|
|
// 设置转入医院信息
|
if (createVO.getHospitalIn() != null) {
|
emergencyInfo.setHospitalInId(createVO.getHospitalIn().getId());
|
emergencyInfo.setHospitalInName(createVO.getHospitalIn().getName());
|
emergencyInfo.setHospitalInDepartment(createVO.getHospitalIn().getDepartment());
|
emergencyInfo.setHospitalInDepartmentId(createVO.getHospitalIn().getDepartmentId());
|
emergencyInfo.setHospitalInBedNumber(createVO.getHospitalIn().getBedNumber());
|
emergencyInfo.setHospitalInAddress(createVO.getHospitalIn().getAddress());
|
|
// GPS坐标：优先使用前端传入的，否则后端自动获取
|
if (createVO.getHospitalIn().getLongitude() != null && createVO.getHospitalIn().getLatitude() != null) {
|
emergencyInfo.setHospitalInLongitude(createVO.getHospitalIn().getLongitude());
|
emergencyInfo.setHospitalInLatitude(createVO.getHospitalIn().getLatitude());
|
} else if (mapService != null && createVO.getHospitalIn().getAddress() != null) {
|
// 后端自动获取GPS坐标
|
try {
|
Map<String, Double> coords = mapService.geocoding(
|
createVO.getHospitalIn().getAddress(),
|
extractCityFromAddress(createVO.getHospitalIn().getAddress())
|
);
|
if (coords != null) {
|
emergencyInfo.setHospitalInLongitude(BigDecimal.valueOf(coords.get("lng")));
|
emergencyInfo.setHospitalInLatitude(BigDecimal.valueOf(coords.get("lat")));
|
log.info("转入医院GPS坐标自动获取成功: {}, {}", coords.get("lng"), coords.get("lat"));
|
}
|
} catch (Exception e) {
|
log.error("自动获取转入医院GPS坐标失败", e);
|
}
|
}
|
}
|
|
// 设置费用信息
|
emergencyInfo.setTransferDistance(createVO.getTransferDistance());
|
emergencyInfo.setTransferPrice(createVO.getPrice());
|
|
// 设置单据类型ID
|
emergencyInfo.setDocumentTypeId(createVO.getDocumentTypeId());
|
|
// 设置任务类型ID
|
emergencyInfo.setTaskTypeId(createVO.getTaskTypeId());
|
|
// 设置病情ID列表（将List<Long>转换为逗号分隔的字符串）
|
if (createVO.getDiseaseIds() != null && !createVO.getDiseaseIds().isEmpty()) {
|
String diseaseIdsStr = createVO.getDiseaseIds().stream()
|
.map(String::valueOf)
|
.collect(Collectors.joining(","));
|
emergencyInfo.setDiseaseIds(diseaseIdsStr);
|
}
|
|
if(serviceOrderId!=null){
|
emergencyInfo.setLegacyServiceOrdId(Long.parseLong(serviceOrderId));
|
emergencyInfo.setSyncStatus(2);
|
emergencyInfo.setSyncTime(new Date());
|
emergencyInfo.setSyncErrorMsg("旧系统同步过来");
|
}
|
if(dispatchOrderId!=null){
|
emergencyInfo.setLegacyDispatchOrdId(Long.parseLong(dispatchOrderId));
|
emergencyInfo.setDispatchSyncStatus(2);
|
emergencyInfo.setDispatchSyncTime(new Date());
|
emergencyInfo.setDispatchSyncErrorMsg("旧系统同步过来");
|
}
|
if(serviceOrdNo!=null){
|
emergencyInfo.setLegacyServiceOrdNo(serviceOrdNo);
|
}
|
// 系统字段
|
emergencyInfo.setCreateTime(DateUtils.getNowDate());
|
emergencyInfo.setUpdateTime(DateUtils.getNowDate());
|
emergencyInfo.setCreateBy(createUserName);
|
emergencyInfo.setUpdateBy(createUserName);
|
|
sysTaskEmergencyMapper.insertSysTaskEmergency(emergencyInfo);
|
}
|
|
/**
|
* 从 TaskCreateVO 更新急救转运任务扩展信息
|
*
|
* @param taskId 任务ID
|
* @param createVO 任务创建/更新对象
|
* @param userName 操作人名
|
*/
|
private void updateEmergencyInfoFromCreateVO(Long taskId, TaskCreateVO createVO, String userName) {
|
// 查询现有的扩展信息
|
SysTaskEmergency existingInfo = sysTaskEmergencyMapper.selectSysTaskEmergencyByTaskId(taskId);
|
if (existingInfo == null) {
|
// 如果不存在，则创建新的
|
existingInfo = new SysTaskEmergency();
|
existingInfo.setTaskId(taskId);
|
existingInfo.setCreateTime(DateUtils.getNowDate());
|
existingInfo.setCreateBy(userName);
|
}
|
|
// 更新患者信息
|
if (createVO.getPatient() != null) {
|
if (createVO.getPatient().getContact() != null) {
|
existingInfo.setPatientContact(createVO.getPatient().getContact());
|
}
|
if (createVO.getPatient().getPhone() != null) {
|
existingInfo.setPatientPhone(createVO.getPatient().getPhone());
|
}
|
if (createVO.getPatient().getName() != null) {
|
existingInfo.setPatientName(createVO.getPatient().getName());
|
}
|
if (createVO.getPatient().getGender() != null) {
|
existingInfo.setPatientGender(createVO.getPatient().getGender());
|
}
|
if (createVO.getPatient().getIdCard() != null) {
|
existingInfo.setPatientIdCard(createVO.getPatient().getIdCard());
|
}
|
if (createVO.getPatient().getCondition() != null) {
|
existingInfo.setPatientCondition(createVO.getPatient().getCondition());
|
}
|
}
|
|
// 更新转出医院信息
|
if (createVO.getHospitalOut() != null) {
|
if (createVO.getHospitalOut().getId() != null) {
|
existingInfo.setHospitalOutId(createVO.getHospitalOut().getId());
|
}
|
if (createVO.getHospitalOut().getName() != null) {
|
existingInfo.setHospitalOutName(createVO.getHospitalOut().getName());
|
}
|
if (createVO.getHospitalOut().getDepartment() != null) {
|
existingInfo.setHospitalOutDepartment(createVO.getHospitalOut().getDepartment());
|
}
|
if (createVO.getHospitalOut().getDepartmentId() != null) {
|
existingInfo.setHospitalOutDepartmentId(createVO.getHospitalOut().getDepartmentId());
|
}
|
if (createVO.getHospitalOut().getBedNumber() != null) {
|
existingInfo.setHospitalOutBedNumber(createVO.getHospitalOut().getBedNumber());
|
}
|
if (createVO.getHospitalOut().getAddress() != null && !createVO.getHospitalOut().getAddress().equals(existingInfo.getHospitalOutAddress())) {
|
existingInfo.setHospitalOutAddress(createVO.getHospitalOut().getAddress());
|
|
// 如枟更新了地址但没有GPS坐标，后端自动获取
|
if (createVO.getHospitalOut().getLongitude() == null && createVO.getHospitalOut().getLatitude() == null && mapService != null) {
|
try {
|
|
Map<String, Double> coords = mapService.geocoding(
|
createVO.getHospitalOut().getAddress(),
|
extractCityFromAddress(createVO.getHospitalOut().getAddress())
|
);
|
if (coords != null) {
|
existingInfo.setHospitalOutLongitude(BigDecimal.valueOf(coords.get("lng")));
|
existingInfo.setHospitalOutLatitude(BigDecimal.valueOf(coords.get("lat")));
|
log.info("转出医院GPS坐标自动获取成功: {}, {}", coords.get("lng"), coords.get("lat"));
|
}
|
} catch (Exception e) {
|
log.error("自动获取转出医院GPS坐标失败", e);
|
}
|
}
|
}
|
if (createVO.getHospitalOut().getLongitude() != null) {
|
existingInfo.setHospitalOutLongitude(createVO.getHospitalOut().getLongitude());
|
}
|
if (createVO.getHospitalOut().getLatitude() != null) {
|
existingInfo.setHospitalOutLatitude(createVO.getHospitalOut().getLatitude());
|
}
|
}
|
|
// 更新转入医院信息
|
if (createVO.getHospitalIn() != null) {
|
if (createVO.getHospitalIn().getId() != null) {
|
existingInfo.setHospitalInId(createVO.getHospitalIn().getId());
|
}
|
if (createVO.getHospitalIn().getName() != null) {
|
existingInfo.setHospitalInName(createVO.getHospitalIn().getName());
|
}
|
if (createVO.getHospitalIn().getDepartment() != null) {
|
existingInfo.setHospitalInDepartment(createVO.getHospitalIn().getDepartment());
|
}
|
if (createVO.getHospitalIn().getDepartmentId() != null) {
|
existingInfo.setHospitalInDepartmentId(createVO.getHospitalIn().getDepartmentId());
|
}
|
if (createVO.getHospitalIn().getBedNumber() != null) {
|
existingInfo.setHospitalInBedNumber(createVO.getHospitalIn().getBedNumber());
|
}
|
if (createVO.getHospitalIn().getAddress() != null && !createVO.getHospitalIn().getAddress().equals(existingInfo.getHospitalInAddress())) {
|
existingInfo.setHospitalInAddress(createVO.getHospitalIn().getAddress());
|
|
// 如果更新了地址但没有GPS坐标，后端自动获取
|
if (createVO.getHospitalIn().getLongitude() == null && createVO.getHospitalIn().getLatitude() == null && mapService != null) {
|
try {
|
Map<String, Double> coords = mapService.geocoding(
|
createVO.getHospitalIn().getAddress(),
|
extractCityFromAddress(createVO.getHospitalIn().getAddress())
|
);
|
if (coords != null) {
|
existingInfo.setHospitalInLongitude(BigDecimal.valueOf(coords.get("lng")));
|
existingInfo.setHospitalInLatitude(BigDecimal.valueOf(coords.get("lat")));
|
log.info("转入医院GPS坐标自动获取成功: {}, {}", coords.get("lng"), coords.get("lat"));
|
}
|
} catch (Exception e) {
|
log.error("自动获取转入医院GPS坐标失败", e);
|
}
|
}
|
}
|
if (createVO.getHospitalIn().getLongitude() != null) {
|
existingInfo.setHospitalInLongitude(createVO.getHospitalIn().getLongitude());
|
}
|
if (createVO.getHospitalIn().getLatitude() != null) {
|
existingInfo.setHospitalInLatitude(createVO.getHospitalIn().getLatitude());
|
}
|
}
|
|
// 更新费用信息
|
if (createVO.getTransferDistance() != null) {
|
existingInfo.setTransferDistance(createVO.getTransferDistance());
|
}
|
if (createVO.getPrice() != null) {
|
existingInfo.setTransferPrice(createVO.getPrice());
|
}
|
|
// 更新单据类型ID
|
if (createVO.getDocumentTypeId() != null) {
|
existingInfo.setDocumentTypeId(createVO.getDocumentTypeId());
|
}
|
|
// 更新任务类型ID
|
if (createVO.getTaskTypeId() != null) {
|
existingInfo.setTaskTypeId(createVO.getTaskTypeId());
|
}
|
|
// 更新病情ID列表
|
if (createVO.getDiseaseIds() != null && !createVO.getDiseaseIds().isEmpty()) {
|
String diseaseIdsStr = createVO.getDiseaseIds().stream()
|
.map(String::valueOf)
|
.collect(Collectors.joining(","));
|
existingInfo.setDiseaseIds(diseaseIdsStr);
|
}
|
|
// 系统字段
|
existingInfo.setUpdateTime(DateUtils.getNowDate());
|
existingInfo.setUpdateBy(userName);
|
|
// 执行更新
|
sysTaskEmergencyMapper.updateSysTaskEmergency(existingInfo);
|
}
|
|
/**
|
* 从 TaskCreateVO 更新福祉车任务扩展信息
|
*
|
* @param taskId 任务ID
|
* @param createVO 任务创建/更新对象
|
* @param userName 操作人名
|
*/
|
private void updateWelfareInfoFromCreateVO(Long taskId, TaskCreateVO createVO, String userName) {
|
// 查询现有的扩展信息
|
SysTaskWelfare existingInfo = sysTaskWelfareMapper.selectSysTaskWelfareByTaskId(taskId);
|
if (existingInfo == null) {
|
// 如果不存在，则创建新的
|
existingInfo = new SysTaskWelfare();
|
existingInfo.setTaskId(taskId);
|
existingInfo.setCreateTime(DateUtils.getNowDate());
|
existingInfo.setCreateBy(userName);
|
}
|
|
// 更新乘客信息
|
if (createVO.getPassenger() != null) {
|
if (createVO.getPassenger().getContact() != null) {
|
existingInfo.setPassengerContact(createVO.getPassenger().getContact());
|
}
|
if (createVO.getPassenger().getPhone() != null) {
|
existingInfo.setPassengerPhone(createVO.getPassenger().getPhone());
|
}
|
}
|
|
// 更新地址信息
|
if (createVO.getStartAddress() != null) {
|
existingInfo.setPickupAddress(createVO.getStartAddress());
|
}
|
if (createVO.getEndAddress() != null) {
|
existingInfo.setDestinationAddress(createVO.getEndAddress());
|
}
|
|
// 更新GPS坐标
|
if (createVO.getDepartureLongitude() != null) {
|
existingInfo.setPickupLongitude(createVO.getDepartureLongitude());
|
}
|
if (createVO.getDepartureLatitude() != null) {
|
existingInfo.setPickupLatitude(createVO.getDepartureLatitude());
|
}
|
if (createVO.getDestinationLongitude() != null) {
|
existingInfo.setDestinationLongitude(createVO.getDestinationLongitude());
|
}
|
if (createVO.getDestinationLatitude() != null) {
|
existingInfo.setDestinationLatitude(createVO.getDestinationLatitude());
|
}
|
|
// 更新距离和费用
|
if (createVO.getDistance() != null) {
|
existingInfo.setServiceDistance(createVO.getDistance());
|
} else if (createVO.getEstimatedDistance() != null) {
|
existingInfo.setServiceDistance(createVO.getEstimatedDistance());
|
}
|
if (createVO.getPrice() != null) {
|
existingInfo.setServicePrice(createVO.getPrice());
|
}
|
|
// 系统字段
|
existingInfo.setUpdateTime(DateUtils.getNowDate());
|
existingInfo.setUpdateBy(userName);
|
|
// 执行更新
|
sysTaskWelfareMapper.updateSysTaskWelfare(existingInfo);
|
}
|
|
/**
|
* 保存福祉车任务扩展信息
|
*
|
* @param taskId 任务ID
|
* @param createVO 任务创建对象
|
*/
|
private void saveWelfareInfo(Long taskId,String userName, TaskCreateVO createVO) {
|
SysTaskWelfare welfareInfo = new SysTaskWelfare();
|
welfareInfo.setTaskId(taskId);
|
|
// 设置乘客信息
|
if (createVO.getPassenger() != null) {
|
welfareInfo.setPassengerContact(createVO.getPassenger().getContact());
|
welfareInfo.setPassengerPhone(createVO.getPassenger().getPhone());
|
}
|
|
// 设置地址信息
|
welfareInfo.setPickupAddress(createVO.getStartAddress());
|
welfareInfo.setDestinationAddress(createVO.getEndAddress());
|
|
// 设置GPS坐标
|
welfareInfo.setPickupLongitude(createVO.getDepartureLongitude());
|
welfareInfo.setPickupLatitude(createVO.getDepartureLatitude());
|
welfareInfo.setDestinationLongitude(createVO.getDestinationLongitude());
|
welfareInfo.setDestinationLatitude(createVO.getDestinationLatitude());
|
|
// 设置距离和费用
|
// 优先使用福祉车专用的distance字段，如果没有则使用通用的estimatedDistance
|
BigDecimal serviceDistance = createVO.getDistance() != null ? createVO.getDistance() : createVO.getEstimatedDistance();
|
welfareInfo.setServiceDistance(serviceDistance);
|
welfareInfo.setServicePrice(createVO.getPrice());
|
|
// 系统字段
|
welfareInfo.setCreateTime(DateUtils.getNowDate());
|
welfareInfo.setUpdateTime(DateUtils.getNowDate());
|
welfareInfo.setCreateBy(userName);
|
welfareInfo.setUpdateBy(userName);
|
|
sysTaskWelfareMapper.insertSysTaskWelfare(welfareInfo);
|
}
|
|
/**
|
* 获取附件分类描述
|
*
|
* @param category 附件分类代码
|
* @return 分类描述
|
*/
|
private String getCategoryDesc(String category) {
|
if (category == null || category.isEmpty()) {
|
return "未分类";
|
}
|
switch (category) {
|
case "1": return "知情同意书";
|
case "2": return "病人资料";
|
case "3": return "操作记录";
|
case "4": return "出车前";
|
case "5": return "出车后";
|
case "6": return "系安全带";
|
default: return "其他";
|
}
|
}
|
|
/**
|
* 构建附件的完整URL
|
*
|
* @param attachment 附件对象
|
*/
|
private void buildAttachmentUrl(SysTaskAttachment attachment) {
|
if (attachment != null && StringUtils.isNotEmpty(attachment.getFilePath())) {
|
String imageUrl = imageUrlConfig.getImageUrl();
|
if (StringUtils.isNotEmpty(imageUrl)) {
|
// 拼接完整URL：域名 + 相对路径
|
attachment.setFileUrl(imageUrl + attachment.getFilePath());
|
} else {
|
// 如果未配置域名，直接使用相对路径
|
attachment.setFileUrl(attachment.getFilePath());
|
}
|
}
|
}
|
|
|
}
|
