package com.ruoyi.system.service.impl;
|
|
import java.util.Date;
|
import java.util.List;
|
import java.util.ArrayList;
|
import java.io.File;
|
import java.io.IOException;
|
|
import com.ruoyi.system.utils.TaskCodeGenerator;
|
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.vo.TaskQueryVO;
|
import com.ruoyi.system.domain.vo.TaskCreateVO;
|
import com.ruoyi.system.domain.vo.TaskUpdateVO;
|
import com.ruoyi.system.domain.vo.TaskStatisticsVO;
|
import com.ruoyi.system.domain.enums.TaskStatus;
|
import com.ruoyi.system.mapper.SysTaskMapper;
|
import com.ruoyi.system.mapper.SysTaskVehicleMapper;
|
import com.ruoyi.system.mapper.SysTaskAttachmentMapper;
|
import com.ruoyi.system.mapper.SysTaskLogMapper;
|
import com.ruoyi.system.mapper.VehicleInfoMapper;
|
import com.ruoyi.system.domain.VehicleInfo;
|
import com.ruoyi.system.service.ISysTaskService;
|
|
/**
|
* 任务管理Service业务层处理
|
*
|
* @author ruoyi
|
* @date 2024-01-15
|
*/
|
@Service
|
public class SysTaskServiceImpl implements ISysTaskService {
|
|
@Autowired
|
private SysTaskMapper sysTaskMapper;
|
|
@Autowired
|
private SysTaskVehicleMapper sysTaskVehicleMapper;
|
|
@Autowired
|
private SysTaskAttachmentMapper sysTaskAttachmentMapper;
|
|
@Autowired
|
private SysTaskLogMapper sysTaskLogMapper;
|
|
@Autowired
|
private VehicleInfoMapper vehicleInfoMapper;
|
|
/**
|
* 查询任务管理
|
*
|
* @param taskId 任务管理主键
|
* @return 任务管理
|
*/
|
@Override
|
public SysTask selectSysTaskByTaskId(Long taskId) {
|
return sysTaskMapper.selectSysTaskByTaskId(taskId);
|
}
|
|
/**
|
* 查询任务管理列表
|
*
|
* @param queryVO 任务查询对象
|
* @return 任务管理
|
*/
|
@Override
|
public List<SysTask> selectSysTaskList(TaskQueryVO queryVO) {
|
return sysTaskMapper.selectSysTaskList(queryVO);
|
}
|
|
/**
|
* 新增任务管理
|
*
|
* @param createVO 任务创建对象
|
* @return 结果
|
*/
|
@Override
|
@Transactional
|
public int insertSysTask(TaskCreateVO createVO) {
|
SysTask task = new SysTask();
|
task.setTaskCode(generateTaskCode());
|
task.setTaskType(createVO.getTaskType());
|
task.setTaskStatus(TaskStatus.PENDING.getCode());
|
task.setTaskDescription(createVO.getTaskDescription());
|
task.setDepartureAddress(createVO.getDepartureAddress());
|
task.setDestinationAddress(createVO.getDestinationAddress());
|
task.setDepartureLongitude(createVO.getDepartureLongitude());
|
task.setDepartureLatitude(createVO.getDepartureLatitude());
|
task.setDestinationLongitude(createVO.getDestinationLongitude());
|
task.setDestinationLatitude(createVO.getDestinationLatitude());
|
task.setPlannedStartTime(createVO.getPlannedStartTime());
|
task.setPlannedEndTime(createVO.getPlannedEndTime());
|
task.setAssigneeId(createVO.getAssigneeId());
|
task.setCreatorId(SecurityUtils.getUserId());
|
task.setDeptId(SecurityUtils.getDeptId());
|
task.setCreateBy(SecurityUtils.getUsername());
|
task.setCreateTime(DateUtils.getNowDate());
|
task.setUpdateBy(SecurityUtils.getUsername());
|
task.setUpdateTime(DateUtils.getNowDate());
|
task.setRemark(createVO.getRemark());
|
task.setDelFlag("0");
|
|
// 计算预计公里数
|
calculateEstimatedDistance(task);
|
|
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(SecurityUtils.getUsername());
|
taskVehicle.setStatus("ASSIGNED");
|
taskVehicle.setCreateBy(SecurityUtils.getUsername());
|
taskVehicle.setCreateTime(DateUtils.getNowDate());
|
taskVehicle.setUpdateBy(SecurityUtils.getUsername());
|
taskVehicle.setUpdateTime(DateUtils.getNowDate());
|
|
sysTaskVehicleMapper.insertSysTaskVehicle(taskVehicle);
|
}
|
}
|
|
// 记录操作日志
|
if (result > 0) {
|
recordTaskLog(task.getTaskId(), "CREATE", "创建任务", null,
|
"任务类型：" + createVO.getTaskType(), SecurityUtils.getUserId(), SecurityUtils.getUsername());
|
}
|
|
return result;
|
}
|
|
/**
|
* 修改任务管理
|
*
|
* @param updateVO 任务更新对象
|
* @return 结果
|
*/
|
@Override
|
@Transactional
|
public int updateSysTask(TaskUpdateVO updateVO) {
|
SysTask oldTask = sysTaskMapper.selectSysTaskByTaskId(updateVO.getTaskId());
|
if (oldTask == null) {
|
throw new RuntimeException("任务不存在");
|
}
|
|
SysTask task = new SysTask();
|
task.setTaskId(updateVO.getTaskId());
|
task.setTaskDescription(updateVO.getTaskDescription());
|
task.setDepartureAddress(updateVO.getDepartureAddress());
|
task.setDestinationAddress(updateVO.getDestinationAddress());
|
task.setDepartureLongitude(updateVO.getDepartureLongitude());
|
task.setDepartureLatitude(updateVO.getDepartureLatitude());
|
task.setDestinationLongitude(updateVO.getDestinationLongitude());
|
task.setDestinationLatitude(updateVO.getDestinationLatitude());
|
task.setPlannedStartTime(updateVO.getPlannedStartTime());
|
task.setPlannedEndTime(updateVO.getPlannedEndTime());
|
task.setAssigneeId(updateVO.getAssigneeId());
|
task.setUpdateBy(SecurityUtils.getUsername());
|
task.setUpdateTime(DateUtils.getNowDate());
|
task.setRemark(updateVO.getRemark());
|
|
// 重新计算预计公里数
|
calculateEstimatedDistance(task);
|
|
int result = sysTaskMapper.updateSysTask(task);
|
|
// 记录操作日志
|
if (result > 0) {
|
recordTaskLog(updateVO.getTaskId(), "UPDATE", "更新任务",
|
buildTaskDescription(oldTask), buildTaskDescription(task),
|
SecurityUtils.getUserId(), SecurityUtils.getUsername());
|
}
|
|
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 = new SysTask();
|
task.setTaskId(taskId);
|
task.setAssigneeId(assigneeId);
|
task.setUpdateBy(SecurityUtils.getUsername());
|
task.setUpdateTime(DateUtils.getNowDate());
|
|
int result = sysTaskMapper.assignTask(task);
|
|
// 记录操作日志
|
if (result > 0) {
|
recordTaskLog(taskId, "ASSIGN", "分配任务", null,
|
"分配给用户ID：" + assigneeId + "，备注：" + remark,
|
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) {
|
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.IN_PROGRESS && oldTask.getActualStartTime() == null) {
|
task.setActualStartTime(DateUtils.getNowDate());
|
} else if (newStatus == TaskStatus.COMPLETED) {
|
task.setActualEndTime(DateUtils.getNowDate());
|
}
|
|
int result = sysTaskMapper.updateTaskStatus(task);
|
|
// 记录操作日志
|
if (result > 0) {
|
recordTaskLog(taskId, "STATUS_CHANGE", "状态变更",
|
"状态：" + oldTaskStatus.getInfo(),
|
"状态：" + newStatus.getInfo() + "，备注：" + remark,
|
SecurityUtils.getUserId(), SecurityUtils.getUsername());
|
}
|
|
return result;
|
}
|
|
/**
|
* 上传任务附件
|
*
|
* @param taskId 任务ID
|
* @param file 文件
|
* @return 结果
|
*/
|
@Override
|
@Transactional
|
public int uploadAttachment(Long taskId, MultipartFile file) {
|
try {
|
// 上传文件
|
String fileName = FileUploadUtils.upload("/task", file);
|
String filePath = FileUploadUtils.getDefaultBaseDir() + fileName;
|
|
SysTaskAttachment attachment = new SysTaskAttachment();
|
attachment.setTaskId(taskId);
|
attachment.setFileName(file.getOriginalFilename());
|
attachment.setFilePath(filePath);
|
attachment.setFileSize(file.getSize());
|
attachment.setFileType(getFileType(file.getOriginalFilename()));
|
attachment.setUploadTime(DateUtils.getNowDate());
|
attachment.setUploadBy(SecurityUtils.getUsername());
|
|
int result = sysTaskAttachmentMapper.insertSysTaskAttachment(attachment);
|
|
// 记录操作日志
|
if (result > 0) {
|
recordTaskLog(taskId, "UPDATE", "上传附件", null,
|
"上传文件：" + file.getOriginalFilename(),
|
SecurityUtils.getUserId(), SecurityUtils.getUsername());
|
}
|
|
return result;
|
} catch (IOException e) {
|
throw new RuntimeException("文件上传失败：" + e.getMessage());
|
}
|
}
|
|
/**
|
* 删除任务附件
|
*
|
* @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;
|
}
|
|
/**
|
* 分配车辆给任务
|
*
|
* @param taskId 任务ID
|
* @param vehicleId 车辆ID
|
* @param remark 备注
|
* @return 结果
|
*/
|
@Override
|
@Transactional
|
public int assignVehicleToTask(Long taskId, Long vehicleId, String remark) {
|
// 检查是否已经分配
|
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(SecurityUtils.getUsername());
|
taskVehicle.setStatus("ASSIGNED");
|
taskVehicle.setRemark(remark);
|
|
int result = sysTaskVehicleMapper.insertSysTaskVehicle(taskVehicle);
|
|
// 记录操作日志
|
if (result > 0) {
|
recordTaskLog(taskId, "ASSIGN", "分配车辆", null,
|
"分配车辆ID：" + vehicleId + "，备注：" + remark,
|
SecurityUtils.getUserId(), SecurityUtils.getUsername());
|
}
|
|
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) {
|
List<SysTaskVehicle> taskVehicles = new ArrayList<>();
|
Date now = DateUtils.getNowDate();
|
String assignBy = SecurityUtils.getUsername();
|
|
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,
|
SecurityUtils.getUserId(), SecurityUtils.getUsername());
|
}
|
|
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，查询所有部门的车辆
|
|
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));
|
// 查询附件
|
task.setAttachments(sysTaskAttachmentMapper.selectSysTaskAttachmentByTaskId(taskId));
|
// 查询操作日志
|
task.setOperationLogs(sysTaskLogMapper.selectSysTaskLogByTaskId(taskId));
|
}
|
return task;
|
}
|
|
@Autowired
|
private TaskCodeGenerator taskCodeGenerator;
|
|
/**
|
* 生成任务编号
|
*
|
* @return 任务编号
|
*/
|
private String generateTaskCode() {
|
return taskCodeGenerator.generateTaskCode();
|
}
|
|
/**
|
* 记录任务操作日志
|
*
|
* @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) {
|
SysTaskLog 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);
|
}
|
}
|
}
|
