package com.ruoyi.device.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.ruoyi.common.utils.bean.BeanUtils;
|
import com.ruoyi.device.mapper.MaintenanceTaskMapper;
|
import com.ruoyi.device.mapper.MaintenanceItemMapper;
|
import com.ruoyi.device.mapper.MaintenanceTaskItemMapper;
|
import com.ruoyi.device.pojo.MaintenanceItem;
|
import com.ruoyi.device.pojo.MaintenanceTask;
|
import com.ruoyi.device.pojo.MaintenanceTaskItem;
|
import com.ruoyi.device.service.MaintenanceTaskService;
|
import com.ruoyi.framework.web.domain.AjaxResult;
|
import com.ruoyi.inspectiontask.pojo.TimingTask;
|
import com.ruoyi.inspectiontask.service.impl.TimingTaskServiceImpl;
|
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.LocalDateTime;
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.HashMap;
|
import java.util.HashSet;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.Set;
|
import java.util.stream.Collectors;
|
|
/**
|
* @author :yys
|
* @date : 2025/12/22 14:57
|
*/
|
@Service
|
@Slf4j
|
@RequiredArgsConstructor
|
public class MaintenanceTaskServiceImpl extends ServiceImpl<MaintenanceTaskMapper, MaintenanceTask> implements MaintenanceTaskService {
|
|
private final MaintenanceTaskMapper maintenanceTaskMapper;
|
private final MaintenanceItemMapper maintenanceItemMapper;
|
private final MaintenanceTaskItemMapper maintenanceTaskItemMapper;
|
private final SysUserMapper sysUserMapper;
|
private final TimingTaskServiceImpl timingTaskService;
|
private final MaintenanceTaskScheduler maintenanceTaskScheduler;
|
|
@Override
|
public AjaxResult listPage(Page page, MaintenanceTask maintenanceTask) {
|
LambdaQueryWrapper<MaintenanceTask> queryWrapper = new LambdaQueryWrapper<>();
|
queryWrapper.orderByDesc(MaintenanceTask::getId);
|
Page<MaintenanceTask> taskPage = maintenanceTaskMapper.selectPage(page, queryWrapper);
|
// 2. 如果没有数据，直接返回空分页
|
if (taskPage.getRecords().isEmpty()) {
|
return AjaxResult.success(taskPage);
|
}
|
|
// 3. 收集所有需要查询的用户ID
|
Set<Long> userIds = new HashSet<>();
|
|
// 收集登记人ID
|
taskPage.getRecords().forEach(task -> {
|
if (task.getRegistrantId() != null) {
|
userIds.add(task.getRegistrantId());
|
}
|
});
|
|
// 4. 批量查询用户信息
|
Map<Long, String> userNickNameMap = new HashMap<>();
|
if (!userIds.isEmpty()) {
|
List<SysUser> users = sysUserMapper.selectUserByIds((new ArrayList<>(userIds)));
|
users.forEach(user -> userNickNameMap.put(user.getUserId(), user.getNickName()));
|
}
|
taskPage.getRecords().forEach(task -> {
|
// 设置登记人昵称
|
if (task.getRegistrantId() != null) {
|
task.setRegistrant(userNickNameMap.getOrDefault(task.getRegistrantId(), "未知用户"));
|
}
|
});
|
taskPage.getRecords().forEach(this::fillTaskItems);
|
return AjaxResult.success(taskPage);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public AjaxResult add(MaintenanceTask maintenanceTask) {
|
List<MaintenanceItem> selectedItems = getSelectedItems(maintenanceTask.getMaintenanceItemIds(), null, maintenanceTask.getTaskId(), maintenanceTask.getFrequencyType());
|
List<MaintenanceTaskItem> customItems = normalizeCustomItems(maintenanceTask.getCustomItems());
|
if (selectedItems == null || selectedItems.size() + customItems.size() == 0)
|
return AjaxResult.error("请选择至少一个有效的保养项目");
|
// 计算首次执行时间
|
TimingTask task = new TimingTask();
|
task.setFrequencyType(maintenanceTask.getFrequencyType());
|
task.setFrequencyDetail(maintenanceTask.getFrequencyDetail());
|
LocalDateTime firstExecutionTime = timingTaskService.calculateFirstExecutionTime(task);
|
maintenanceTask.setNextExecutionTime(firstExecutionTime);
|
int insert = maintenanceTaskMapper.insert(maintenanceTask);
|
if (insert > 0) {
|
saveTaskItems(maintenanceTask, selectedItems, customItems);
|
// 只有当 isActive 为 1 时才添加到定时任务调度器
|
if (maintenanceTask.getIsActive() != null && maintenanceTask.getIsActive() == 1) {
|
maintenanceTaskScheduler.scheduleMaintenanceTask(maintenanceTask);
|
}
|
}
|
return AjaxResult.success("添加成功");
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public AjaxResult updateByMaintenanceTaskId(MaintenanceTask maintenanceTask) {
|
MaintenanceTask maintenanceTask1 = maintenanceTaskMapper.selectById(maintenanceTask.getId());
|
if (maintenanceTask1 == null) {
|
return AjaxResult.warn("没有此数据");
|
}
|
List<MaintenanceItem> selectedItems = getSelectedItems(maintenanceTask.getMaintenanceItemIds(), maintenanceTask1.getId(), maintenanceTask.getTaskId(), maintenanceTask.getFrequencyType());
|
List<MaintenanceTaskItem> customItems = normalizeCustomItems(maintenanceTask.getCustomItems());
|
if (selectedItems == null || selectedItems.size() + customItems.size() == 0)
|
return AjaxResult.error("请选择至少一个有效的保养项目");
|
|
// 保存旧的 isActive 状态
|
Integer oldIsActive = maintenanceTask1.getIsActive();
|
Integer newIsActive = maintenanceTask.getIsActive();
|
|
BeanUtils.copyProperties(maintenanceTask, maintenanceTask1);
|
int update = maintenanceTaskMapper.updateById(maintenanceTask1);
|
if (update > 0) {
|
maintenanceTaskItemMapper.delete(new LambdaQueryWrapper<MaintenanceTaskItem>()
|
.eq(MaintenanceTaskItem::getMaintenanceTaskId, maintenanceTask1.getId()));
|
saveTaskItems(maintenanceTask1, selectedItems, customItems);
|
// 处理 isActive 状态变化
|
if (newIsActive != null && newIsActive == 1) {
|
// 新状态为启用：添加到定时任务调度器
|
if (oldIsActive == null || oldIsActive != 1) {
|
// 从未启用变为启用，添加到调度器
|
maintenanceTaskScheduler.scheduleMaintenanceTask(maintenanceTask1);
|
} else {
|
// 已经启用，更新调度器中的任务
|
maintenanceTaskScheduler.rescheduleMaintenanceTask(maintenanceTask1);
|
}
|
} else {
|
// 新状态为停用：从定时任务调度器中移除
|
if (oldIsActive != null && oldIsActive == 1) {
|
maintenanceTaskScheduler.unscheduleMaintenanceTask(maintenanceTask1.getId());
|
}
|
}
|
}
|
return AjaxResult.success("更新成功");
|
}
|
|
@Override
|
public AjaxResult delete(List<Long> ids) {
|
// 先从定时任务调度器中移除所有待删除的任务
|
ids.forEach(id -> {
|
try {
|
maintenanceTaskScheduler.unscheduleMaintenanceTask(id);
|
} catch (Exception e) {
|
log.error("删除定时任务调度失败, id: {}", id, e);
|
}
|
});
|
|
// 再从数据库中删除记录
|
int delete = maintenanceTaskMapper.deleteBatchIds(ids);
|
if (delete > 0) {
|
maintenanceTaskItemMapper.delete(new LambdaQueryWrapper<MaintenanceTaskItem>()
|
.in(MaintenanceTaskItem::getMaintenanceTaskId, ids));
|
}
|
if (delete > 0) {
|
return AjaxResult.success("删除成功");
|
}
|
return AjaxResult.error("删除失败");
|
}
|
|
private List<MaintenanceTaskItem> normalizeCustomItems(List<MaintenanceTaskItem> customItems) {
|
if (customItems == null) return new ArrayList<>();
|
return customItems.stream().filter(Objects::nonNull)
|
.filter(item -> item.getItemProject() != null && !item.getItemProject().trim().isEmpty()
|
&& item.getItemName() != null && !item.getItemName().trim().isEmpty())
|
.peek(item -> {
|
item.setItemProject(item.getItemProject().trim());
|
item.setItemName(item.getItemName().trim());
|
})
|
.toList();
|
}
|
|
private List<MaintenanceItem> getSelectedItems(List<Long> ids, Long taskId, Long deviceId, String frequencyType) {
|
if (deviceId == null || !List.of("DAILY", "WEEKLY", "MONTHLY", "QUARTERLY").contains(frequencyType)
|
|| (ids != null && new HashSet<>(ids).size() != ids.size())) return null;
|
if (ids == null || ids.isEmpty()) return new ArrayList<>();
|
List<MaintenanceItem> items = maintenanceItemMapper.selectList(new LambdaQueryWrapper<MaintenanceItem>()
|
.in(MaintenanceItem::getId, ids));
|
if (items.size() != ids.size()) return null;
|
if (items.stream().anyMatch(item -> (item.getDeviceLedgerId() != null && !deviceId.equals(item.getDeviceLedgerId()))
|
|| !(frequencyType.equals(item.getFrequencyType()) || "ALL".equals(item.getFrequencyType()))))
|
return null;
|
Map<Long, MaintenanceItem> itemMap = new HashMap<>();
|
items.forEach(item -> itemMap.put(item.getId(), item));
|
Set<Long> existingIds = taskId == null ? Collections.emptySet() : maintenanceTaskItemMapper.selectList(
|
new LambdaQueryWrapper<MaintenanceTaskItem>()
|
.eq(MaintenanceTaskItem::getMaintenanceTaskId, taskId))
|
.stream().map(MaintenanceTaskItem::getMaintenanceItemId).collect(Collectors.toSet());
|
if (items.stream().anyMatch(item -> (item.getDeleted() != null && item.getDeleted() == 1
|
|| item.getIsActive() == null || item.getIsActive() != 1)
|
&& !existingIds.contains(item.getId()))) return null;
|
List<MaintenanceItem> sorted = new ArrayList<>();
|
ids.forEach(id -> sorted.add(itemMap.get(id)));
|
return sorted;
|
}
|
|
private void saveTaskItems(MaintenanceTask task, List<MaintenanceItem> selectedItems, List<MaintenanceTaskItem> customItems) {
|
for (int i = 0; i < selectedItems.size(); i++) {
|
MaintenanceItem source = selectedItems.get(i);
|
MaintenanceTaskItem link = new MaintenanceTaskItem();
|
link.setMaintenanceTaskId(task.getId());
|
link.setMaintenanceItemId(source.getId());
|
link.setItemProject(source.getItemProject());
|
link.setItemName(source.getItemName());
|
link.setSortNum(i);
|
link.setTenantId(task.getTenantId());
|
link.setDeptId(task.getDeptId());
|
maintenanceTaskItemMapper.insert(link);
|
}
|
for (int i = 0; i < customItems.size(); i++) {
|
MaintenanceTaskItem link = new MaintenanceTaskItem();
|
link.setMaintenanceTaskId(task.getId());
|
link.setMaintenanceItemId(null);
|
link.setItemProject(customItems.get(i).getItemProject());
|
link.setItemName(customItems.get(i).getItemName());
|
link.setSortNum(selectedItems.size() + i);
|
link.setTenantId(task.getTenantId());
|
link.setDeptId(task.getDeptId());
|
maintenanceTaskItemMapper.insert(link);
|
}
|
task.setMaintenanceItems(maintenanceTaskItemMapper.selectList(new LambdaQueryWrapper<MaintenanceTaskItem>()
|
.eq(MaintenanceTaskItem::getMaintenanceTaskId, task.getId())
|
.orderByAsc(MaintenanceTaskItem::getSortNum)));
|
task.setMaintenanceItemIds(task.getMaintenanceItems().stream()
|
.map(MaintenanceTaskItem::getMaintenanceItemId).filter(Objects::nonNull).collect(Collectors.toList()));
|
}
|
|
private void fillTaskItems(MaintenanceTask task) {
|
List<MaintenanceTaskItem> items = maintenanceTaskItemMapper.selectList(new LambdaQueryWrapper<MaintenanceTaskItem>()
|
.eq(MaintenanceTaskItem::getMaintenanceTaskId, task.getId())
|
.orderByAsc(MaintenanceTaskItem::getSortNum));
|
task.setMaintenanceItems(items);
|
task.setMaintenanceItemIds(items.stream().map(MaintenanceTaskItem::getMaintenanceItemId).filter(Objects::nonNull)
|
.collect(Collectors.toList()));
|
}
|
}
|
