package com.ruoyi.inspectiontask.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.ruoyi.basic.dto.StorageBlobDTO;
|
import com.ruoyi.basic.enums.ApplicationTypeEnum;
|
import com.ruoyi.basic.enums.RecordTypeEnum;
|
import com.ruoyi.basic.utils.FileUtil;
|
import com.ruoyi.common.utils.SecurityUtils;
|
import com.ruoyi.common.utils.StringUtils;
|
import com.ruoyi.common.utils.bean.BeanUtils;
|
import com.ruoyi.device.mapper.DeviceLedgerMapper;
|
import com.ruoyi.device.mapper.DeviceRepairMapper;
|
import com.ruoyi.device.pojo.DeviceLedger;
|
import com.ruoyi.device.pojo.DeviceRepair;
|
import com.ruoyi.inspectiontask.dto.InspectionTaskDto;
|
import com.ruoyi.inspectiontask.mapper.InspectionTaskMapper;
|
import com.ruoyi.inspectiontask.pojo.InspectionTask;
|
import com.ruoyi.inspectiontask.service.InspectionTaskService;
|
import com.ruoyi.project.system.domain.SysUser;
|
import com.ruoyi.project.system.mapper.SysUserMapper;
|
import lombok.RequiredArgsConstructor;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.time.format.DateTimeFormatter;
|
import java.util.Date;
|
import java.util.*;
|
import java.util.function.Function;
|
import java.util.stream.Collectors;
|
|
/**
|
* @author :yys
|
* @date : 2025/9/19 10:54
|
*/
|
@Service
|
@Slf4j
|
@RequiredArgsConstructor
|
public class InspectionTaskServiceImpl extends ServiceImpl<InspectionTaskMapper, InspectionTask> implements InspectionTaskService {
|
|
|
private final InspectionTaskMapper inspectionTaskMapper;
|
|
private final SysUserMapper sysUserMapper;
|
|
private final FileUtil fileUtil;
|
|
private final DeviceRepairMapper deviceRepairMapper;
|
|
private final DeviceLedgerMapper deviceLedgerMapper;
|
|
private static final String INSPECTION_RESULT_ABNORMAL = "0";
|
private static final String INSPECTION_RESULT_NORMAL = "1";
|
private static final int REPAIR_STATUS_PENDING = 0;
|
|
@Override
|
public IPage<InspectionTaskDto> selectInspectionTaskList(Page<InspectionTask> page, InspectionTaskDto inspectionTaskDto) {
|
LambdaQueryWrapper<InspectionTask> queryWrapper = new LambdaQueryWrapper<>();
|
queryWrapper.orderByDesc(InspectionTask::getCreateTime);
|
if (StringUtils.isNotBlank(inspectionTaskDto.getTaskName())) {
|
queryWrapper.like(InspectionTask::getTaskName, inspectionTaskDto.getTaskName());
|
}
|
if (StringUtils.isNotBlank(inspectionTaskDto.getInspectionProject())) {
|
queryWrapper.like(InspectionTask::getInspectionProject, inspectionTaskDto.getInspectionProject());
|
}
|
IPage<InspectionTask> entityPage = inspectionTaskMapper.selectPage(page, queryWrapper);
|
|
// 无数据提前返回
|
if (CollectionUtils.isEmpty(entityPage.getRecords())) {
|
return new Page<>(entityPage.getCurrent(), entityPage.getSize(), entityPage.getTotal());
|
}
|
//登记人ids
|
List<Long> registrantIds = entityPage.getRecords().stream().map(InspectionTask::getRegistrantId).collect(Collectors.toList());
|
// 批量查询登记人
|
Map<Long, SysUser> sysUserMap;
|
if (!registrantIds.isEmpty()) {
|
List<SysUser> sysUsers = sysUserMapper.selectUsersByIds(registrantIds);
|
sysUserMap = sysUsers.stream().collect(Collectors.toMap(SysUser::getUserId, Function.identity()));
|
} else {
|
sysUserMap = new HashMap<>();
|
}
|
//获取所有不重复的用户ID
|
Set<Long> allUserIds = entityPage.getRecords().stream()
|
.map(InspectionTask::getInspectorId) // 获取"2,3"这样的字符串
|
.filter(StringUtils::isNotBlank)
|
.flatMap(idsStr -> Arrays.stream(idsStr.split(",")))
|
.map(idStr -> {
|
try {
|
return Long.parseLong(idStr.trim());
|
} catch (NumberFormatException e) {
|
return null;
|
}
|
})
|
.filter(Objects::nonNull)
|
.collect(Collectors.toSet());
|
|
// 使用SQL批量查询用户信息
|
Map<Long, String> userIdToNameMap = allUserIds.isEmpty()
|
? Collections.emptyMap()
|
: sysUserMapper.selectUsersByIds(new ArrayList<>(allUserIds))
|
.stream()
|
.collect(Collectors.toMap(
|
SysUser::getUserId,
|
SysUser::getNickName,
|
(existing, replacement) -> existing));
|
List<InspectionTaskDto> dtoList = entityPage.getRecords().stream().map(inspectionTask -> {
|
InspectionTaskDto dto = new InspectionTaskDto();
|
BeanUtils.copyProperties(inspectionTask, dto); // 复制主对象属性
|
|
// 设置登记人
|
SysUser sysUser = sysUserMap.get(inspectionTask.getRegistrantId());
|
if (sysUser != null) {
|
dto.setRegistrant(sysUser.getNickName());
|
}
|
// 处理巡检人名称
|
if (StringUtils.isNotBlank(inspectionTask.getInspectorId())) {
|
String inspectorNames = Arrays.stream(inspectionTask.getInspectorId().split(","))
|
.map(String::trim)
|
.map(idStr -> {
|
try {
|
Long userId = Long.parseLong(idStr);
|
return userIdToNameMap.getOrDefault(userId, "未知用户(" + idStr + ")");
|
} catch (NumberFormatException e) {
|
return "无效ID(" + idStr + ")";
|
}
|
})
|
.collect(Collectors.joining(","));
|
dto.setInspector(inspectorNames);
|
}
|
|
dto.setDateStr(inspectionTask.getCreateTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
|
// 初始化三个附件列表
|
dto.setCommonFileListVO(fileUtil.getStorageBlobVOsByApplicationAndRecordTypeAndRecordId(ApplicationTypeEnum.FILE, RecordTypeEnum.INSPECTION_TASK, inspectionTask.getId()));
|
dto.setCommonFileListAfterVO(fileUtil.getStorageBlobVOsByApplicationAndRecordTypeAndRecordId(ApplicationTypeEnum.AFTER_FILE, RecordTypeEnum.INSPECTION_TASK, inspectionTask.getId()));
|
dto.setCommonFileListBeforeVO(fileUtil.getStorageBlobVOsByApplicationAndRecordTypeAndRecordId(ApplicationTypeEnum.BEFORE_FILE, RecordTypeEnum.INSPECTION_TASK, inspectionTask.getId()));
|
|
|
return dto;
|
}).collect(Collectors.toList());
|
|
// 7. 构建返回分页对象
|
IPage<InspectionTaskDto> resultPage = new Page<>();
|
BeanUtils.copyProperties(entityPage, resultPage);
|
resultPage.setRecords(dtoList);
|
return resultPage;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public int addOrEditInspectionTask(InspectionTaskDto inspectionTaskDto) {
|
InspectionTask oldInspectionTask = null;
|
if (Objects.nonNull(inspectionTaskDto.getId())) {
|
oldInspectionTask = inspectionTaskMapper.selectById(inspectionTaskDto.getId());
|
if (oldInspectionTask == null) {
|
throw new IllegalArgumentException("巡检任务不存在");
|
}
|
}
|
validateInspectionInput(inspectionTaskDto, oldInspectionTask);
|
|
InspectionTask inspectionTask = new InspectionTask();
|
BeanUtils.copyProperties(inspectionTaskDto, inspectionTask);
|
inspectionTask.setRegistrantId(SecurityUtils.getLoginUser().getUserId());
|
inspectionTask.setRegistrant(SecurityUtils.getLoginUser().getUsername());
|
fillAcceptanceInfo(inspectionTask, oldInspectionTask);
|
int i;
|
if (Objects.isNull(inspectionTaskDto.getId())) {
|
i = inspectionTaskMapper.insert(inspectionTask);
|
} else {
|
i = inspectionTaskMapper.updateById(inspectionTask);
|
}
|
if (i <= 0) {
|
return i;
|
}
|
Long linkedRepairId = syncRepairOrderIfAbnormal(inspectionTask, oldInspectionTask);
|
if (linkedRepairId != null && !Objects.equals(linkedRepairId, inspectionTask.getDeviceRepairId())) {
|
InspectionTask relationUpdate = new InspectionTask();
|
relationUpdate.setId(inspectionTask.getId());
|
relationUpdate.setDeviceRepairId(linkedRepairId);
|
inspectionTaskMapper.updateById(relationUpdate);
|
inspectionTask.setDeviceRepairId(linkedRepairId);
|
}
|
// 保存文件（字段不传则保留历史）
|
saveInspectionAttachments(inspectionTask.getId(), inspectionTaskDto);
|
|
return i;
|
}
|
|
private void validateInspectionInput(InspectionTaskDto inspectionTaskDto, InspectionTask oldInspectionTask) {
|
String inspectionResult = inspectionTaskDto.getInspectionResult();
|
if (StringUtils.isBlank(inspectionResult) && oldInspectionTask != null) {
|
inspectionResult = oldInspectionTask.getInspectionResult();
|
}
|
if (StringUtils.isBlank(inspectionResult)) {
|
throw new IllegalArgumentException("请选择巡检结果");
|
}
|
if (!INSPECTION_RESULT_ABNORMAL.equals(inspectionResult) && !INSPECTION_RESULT_NORMAL.equals(inspectionResult)) {
|
throw new IllegalArgumentException("巡检结果仅支持：0-异常，1-正常");
|
}
|
inspectionTaskDto.setInspectionResult(inspectionResult);
|
|
if (!INSPECTION_RESULT_ABNORMAL.equals(inspectionResult)) {
|
return;
|
}
|
|
String abnormalDescription = inspectionTaskDto.getAbnormalDescription();
|
if (StringUtils.isBlank(abnormalDescription) && oldInspectionTask != null) {
|
abnormalDescription = oldInspectionTask.getAbnormalDescription();
|
}
|
if (StringUtils.isBlank(abnormalDescription)) {
|
throw new IllegalArgumentException("巡检结果为异常时，异常描述不能为空");
|
}
|
inspectionTaskDto.setAbnormalDescription(abnormalDescription);
|
|
if (!hasAnyInspectionPhotoAfterSave(inspectionTaskDto, oldInspectionTask)) {
|
throw new IllegalArgumentException("巡检结果为异常时，必须上传至少一张照片");
|
}
|
}
|
|
private boolean hasAnyInspectionPhotoAfterSave(InspectionTaskDto inspectionTaskDto, InspectionTask oldInspectionTask) {
|
Long recordId = oldInspectionTask == null ? null : oldInspectionTask.getId();
|
return hasApplicationPhotoAfterSave(inspectionTaskDto.getCommonFileListDTO(), ApplicationTypeEnum.FILE, recordId)
|
|| hasApplicationPhotoAfterSave(inspectionTaskDto.getCommonFileListAfterDTO(), ApplicationTypeEnum.AFTER_FILE, recordId)
|
|| hasApplicationPhotoAfterSave(inspectionTaskDto.getCommonFileListBeforeDTO(), ApplicationTypeEnum.BEFORE_FILE, recordId);
|
}
|
|
private boolean hasApplicationPhotoAfterSave(List<StorageBlobDTO> requestPhotos, ApplicationTypeEnum applicationType, Long recordId) {
|
if (requestPhotos != null) {
|
return !requestPhotos.isEmpty();
|
}
|
if (recordId == null) {
|
return false;
|
}
|
return CollectionUtils.isNotEmpty(fileUtil.getStorageAttachmentsByApplicationAndRecordTypeAndRecordId(applicationType, RecordTypeEnum.INSPECTION_TASK, recordId));
|
}
|
|
private void fillAcceptanceInfo(InspectionTask inspectionTask, InspectionTask oldInspectionTask) {
|
Long acceptanceUserId = inspectionTask.getAcceptanceUserId();
|
if (acceptanceUserId == null && oldInspectionTask != null) {
|
acceptanceUserId = oldInspectionTask.getAcceptanceUserId();
|
}
|
if (acceptanceUserId != null) {
|
inspectionTask.setAcceptanceUserId(acceptanceUserId);
|
}
|
|
String acceptanceName = inspectionTask.getAcceptanceName();
|
if (StringUtils.isBlank(acceptanceName) && acceptanceUserId != null) {
|
SysUser acceptanceUser = sysUserMapper.selectUserById(acceptanceUserId);
|
if (acceptanceUser != null) {
|
acceptanceName = acceptanceUser.getNickName();
|
}
|
}
|
if (StringUtils.isBlank(acceptanceName) && oldInspectionTask != null) {
|
acceptanceName = oldInspectionTask.getAcceptanceName();
|
}
|
inspectionTask.setAcceptanceName(acceptanceName);
|
}
|
|
private Long syncRepairOrderIfAbnormal(InspectionTask inspectionTask, InspectionTask oldInspectionTask) {
|
if (!INSPECTION_RESULT_ABNORMAL.equals(inspectionTask.getInspectionResult())) {
|
return inspectionTask.getDeviceRepairId();
|
}
|
Long linkedRepairId = inspectionTask.getDeviceRepairId();
|
if (linkedRepairId == null && oldInspectionTask != null) {
|
linkedRepairId = oldInspectionTask.getDeviceRepairId();
|
}
|
|
if (linkedRepairId != null) {
|
DeviceRepair updateRepair = new DeviceRepair();
|
updateRepair.setId(linkedRepairId);
|
updateRepair.setRemark(inspectionTask.getAbnormalDescription());
|
deviceRepairMapper.updateById(updateRepair);
|
return linkedRepairId;
|
}
|
|
DeviceRepair deviceRepair = buildDeviceRepair(inspectionTask, oldInspectionTask);
|
deviceRepairMapper.insert(deviceRepair);
|
return deviceRepair.getId();
|
}
|
|
private DeviceRepair buildDeviceRepair(InspectionTask inspectionTask, InspectionTask oldInspectionTask) {
|
DeviceRepair deviceRepair = new DeviceRepair();
|
Long deviceLedgerId = resolveDeviceLedgerId(inspectionTask, oldInspectionTask);
|
DeviceLedger deviceLedger = resolveDeviceLedger(deviceLedgerId);
|
deviceRepair.setDeviceLedgerId(deviceLedgerId);
|
deviceRepair.setDeviceName(resolveDeviceName(inspectionTask, oldInspectionTask, deviceLedger));
|
deviceRepair.setDeviceModel(deviceLedger == null ? null : deviceLedger.getDeviceModel());
|
deviceRepair.setRepairName(resolveRepairReporter(inspectionTask, oldInspectionTask));
|
deviceRepair.setRepairTime(new Date());
|
deviceRepair.setRemark(inspectionTask.getAbnormalDescription());
|
deviceRepair.setMachineryCategory(deviceLedger == null ? null : deviceLedger.getType());
|
deviceRepair.setStatus(REPAIR_STATUS_PENDING);
|
return deviceRepair;
|
}
|
|
private Long resolveDeviceLedgerId(InspectionTask inspectionTask, InspectionTask oldInspectionTask) {
|
Integer taskId = inspectionTask.getTaskId();
|
if (taskId == null && oldInspectionTask != null) {
|
taskId = oldInspectionTask.getTaskId();
|
}
|
if (taskId == null || taskId <= 0) {
|
return null;
|
}
|
return taskId.longValue();
|
}
|
|
private DeviceLedger resolveDeviceLedger(Long deviceLedgerId) {
|
if (deviceLedgerId == null) {
|
return null;
|
}
|
return deviceLedgerMapper.selectById(deviceLedgerId);
|
}
|
|
private String resolveDeviceName(InspectionTask inspectionTask, InspectionTask oldInspectionTask, DeviceLedger deviceLedger) {
|
String taskName = inspectionTask.getTaskName();
|
if (StringUtils.isBlank(taskName) && oldInspectionTask != null) {
|
taskName = oldInspectionTask.getTaskName();
|
}
|
if (StringUtils.isNotBlank(taskName)) {
|
return taskName;
|
}
|
return deviceLedger == null ? null : deviceLedger.getDeviceName();
|
}
|
|
private String resolveRepairReporter(InspectionTask inspectionTask, InspectionTask oldInspectionTask) {
|
String reporter = inspectionTask.getInspector();
|
if (StringUtils.isBlank(reporter) && oldInspectionTask != null) {
|
reporter = oldInspectionTask.getInspector();
|
}
|
if (StringUtils.isNotBlank(reporter)) {
|
return reporter;
|
}
|
String inspectorNameByUserId = resolveInspectorNameByUserId(inspectionTask.getInspectorId());
|
if (StringUtils.isBlank(inspectorNameByUserId) && oldInspectionTask != null) {
|
inspectorNameByUserId = resolveInspectorNameByUserId(oldInspectionTask.getInspectorId());
|
}
|
if (StringUtils.isNotBlank(inspectorNameByUserId)) {
|
return inspectorNameByUserId;
|
}
|
try {
|
return SecurityUtils.getUsername();
|
} catch (Exception ignored) {
|
return "system";
|
}
|
}
|
|
private String resolveInspectorNameByUserId(String inspectorIds) {
|
if (StringUtils.isBlank(inspectorIds)) {
|
return null;
|
}
|
String firstInspectorId = Arrays.stream(inspectorIds.split(","))
|
.map(String::trim)
|
.filter(StringUtils::isNotBlank)
|
.findFirst()
|
.orElse(null);
|
if (!StringUtils.isNumeric(firstInspectorId)) {
|
return null;
|
}
|
SysUser sysUser = sysUserMapper.selectUserById(Long.parseLong(firstInspectorId));
|
return sysUser == null ? null : sysUser.getNickName();
|
}
|
|
private void saveInspectionAttachments(Long inspectionTaskId, InspectionTaskDto inspectionTaskDto) {
|
saveAttachmentIfPresent(inspectionTaskId, ApplicationTypeEnum.FILE, inspectionTaskDto.getCommonFileListDTO());
|
saveAttachmentIfPresent(inspectionTaskId, ApplicationTypeEnum.AFTER_FILE, inspectionTaskDto.getCommonFileListAfterDTO());
|
saveAttachmentIfPresent(inspectionTaskId, ApplicationTypeEnum.BEFORE_FILE, inspectionTaskDto.getCommonFileListBeforeDTO());
|
}
|
|
private void saveAttachmentIfPresent(Long inspectionTaskId, ApplicationTypeEnum applicationTypeEnum, List<StorageBlobDTO> storageBlobDTOS) {
|
if (storageBlobDTOS == null) {
|
return;
|
}
|
fileUtil.saveStorageAttachment(applicationTypeEnum, RecordTypeEnum.INSPECTION_TASK, inspectionTaskId, storageBlobDTOS);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public int delByIds(Long[] ids) {
|
// 检查参数
|
if (ids == null || ids.length == 0) {
|
return 0;
|
}
|
// 删除文件
|
fileUtil.deleteStorageAttachmentsByApplicationAndRecordTypeAndRecordIds(ApplicationTypeEnum.FILE, RecordTypeEnum.INSPECTION_TASK, Arrays.asList(ids));
|
fileUtil.deleteStorageAttachmentsByApplicationAndRecordTypeAndRecordIds(ApplicationTypeEnum.AFTER_FILE, RecordTypeEnum.INSPECTION_TASK, Arrays.asList(ids));
|
fileUtil.deleteStorageAttachmentsByApplicationAndRecordTypeAndRecordIds(ApplicationTypeEnum.BEFORE_FILE, RecordTypeEnum.INSPECTION_TASK, Arrays.asList(ids));
|
return inspectionTaskMapper.deleteBatchIds(Arrays.asList(ids));
|
}
|
|
}
|
