package com.ruoyi.business.service.impl;
|
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.ruoyi.business.dto.TimingTaskDto;
|
import com.ruoyi.business.entity.TimingTask;
|
import com.ruoyi.business.mapper.InspectionTaskMapper;
|
import com.ruoyi.business.mapper.TimingTaskMapper;
|
import com.ruoyi.business.service.TimingTaskService;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.ruoyi.common.core.domain.entity.SysUser;
|
import com.ruoyi.common.utils.StringUtils;
|
import com.ruoyi.common.utils.bean.BeanUtils;
|
import com.ruoyi.system.mapper.SysUserMapper;
|
import lombok.extern.slf4j.Slf4j;
|
import org.quartz.SchedulerException;
|
import org.springframework.stereotype.Service;
|
import lombok.RequiredArgsConstructor;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.time.*;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* <p>
|
* 定时巡检任务表 服务实现类
|
* </p>
|
*
|
* @author ld
|
* @since 2025-06-30
|
*/
|
@Service
|
@Slf4j
|
@RequiredArgsConstructor
|
public class TimingTaskServiceImpl extends ServiceImpl<TimingTaskMapper, TimingTask> implements TimingTaskService {
|
|
private final TimingTaskMapper timingTaskMapper;
|
|
private final InspectionTaskMapper inspectionTaskMapper;
|
|
private final TimingTaskScheduler timingTaskScheduler;
|
|
private final SysUserMapper sysUserMapper;
|
|
|
@Override
|
public IPage<TimingTaskDto> selectTimingTaskList(Page<TimingTask> page, TimingTask timingTask) {
|
// 1. 先分页查询定时任务数据
|
IPage<TimingTask> taskPage = timingTaskMapper.selectPage(page, null);
|
|
// 2. 如果没有数据，直接返回空分页
|
if (taskPage.getRecords().isEmpty()) {
|
return new Page<>(taskPage.getCurrent(), taskPage.getSize(), taskPage.getTotal());
|
}
|
|
// 3. 收集所有需要查询的用户ID
|
Set<Long> userIds = new HashSet<>();
|
|
// 收集登记人ID
|
taskPage.getRecords().forEach(task -> {
|
if (task.getRegistrantId() != null) {
|
userIds.add(task.getRegistrantId());
|
}
|
});
|
|
// 收集巡检人ID（多个ID以逗号分隔）
|
taskPage.getRecords().forEach(task -> {
|
if (StringUtils.isNotBlank(task.getInspectorIds())) {
|
Arrays.stream(task.getInspectorIds().split(","))
|
.filter(StringUtils::isNotBlank)
|
.map(Long::valueOf)
|
.forEach(userIds::add);
|
}
|
});
|
|
// 4. 批量查询用户信息
|
Map<Long, String> userNickNameMap = new HashMap<>();
|
if (!userIds.isEmpty()) {
|
List<SysUser> users = sysUserMapper.selectBatchIds(userIds);
|
users.forEach(user -> userNickNameMap.put(user.getUserId(), user.getNickName()));
|
}
|
|
// 5. 转换为DTO
|
List<TimingTaskDto> dtoList = taskPage.getRecords().stream().map(task -> {
|
TimingTaskDto dto = new TimingTaskDto();
|
// 复制基本属性
|
BeanUtils.copyProperties(task, dto);
|
|
// 设置登记人昵称
|
if (task.getRegistrantId() != null) {
|
dto.setRegistrant(userNickNameMap.getOrDefault(task.getRegistrantId(), "未知用户"));
|
}
|
|
// 设置巡检人昵称列表
|
if (StringUtils.isNotBlank(task.getInspectorIds())) {
|
List<String> inspectorNickNames = Arrays.stream(task.getInspectorIds().split(","))
|
.filter(StringUtils::isNotBlank)
|
.map(idStr -> {
|
Long id = Long.valueOf(idStr);
|
return userNickNameMap.getOrDefault(id, "未知用户");
|
})
|
.toList();
|
dto.setInspector(inspectorNickNames.toString());
|
}
|
|
return dto;
|
}).collect(Collectors.toList());
|
|
// 6. 构建返回的分页对象
|
Page<TimingTaskDto> resultPage = new Page<>(taskPage.getCurrent(), taskPage.getSize(), taskPage.getTotal());
|
resultPage.setRecords(dtoList);
|
return resultPage;
|
}
|
|
@Override
|
@Transactional
|
public int addOrEditTimingTask(TimingTaskDto timingTaskDto) throws SchedulerException {
|
TimingTask timingTask = new TimingTask();
|
BeanUtils.copyProperties(timingTaskDto, timingTask);
|
|
// 设置创建人信息和默认值
|
if (Objects.isNull(timingTaskDto.getId())) {
|
timingTask.setRegistrationDate(LocalDate.now());
|
timingTask.setActive(true);
|
|
// 计算首次执行时间
|
LocalDateTime firstExecutionTime = calculateFirstExecutionTime(timingTask);
|
timingTask.setNexExecutionTime(firstExecutionTime);
|
|
int result = timingTaskMapper.insert(timingTask);
|
if (result > 0) {
|
// 新增成功后添加到调度器
|
timingTaskScheduler.scheduleTimingTask(timingTask);
|
}
|
return result;
|
} else {
|
int result = timingTaskMapper.updateById(timingTask);
|
if (result > 0) {
|
// 更新成功后重新调度任务
|
timingTaskScheduler.rescheduleTimingTask(timingTask);
|
}
|
return result;
|
}
|
}
|
|
private LocalDateTime calculateFirstExecutionTime(TimingTask task) {
|
// 根据频率类型和详情计算首次执行时间
|
return switch (task.getFrequencyType()) {
|
case "DAILY" ->
|
// 如果是每天执行，计算今天或明天的具体时间
|
calculateDailyFirstExecution(task.getFrequencyDetail());
|
case "WEEKLY" ->
|
// 如果是每周执行，计算下周的具体星期几
|
calculateWeeklyFirstExecution(task.getFrequencyDetail());
|
case "MONTHLY" ->
|
// 如果是每月执行，计算下个月的具体日期
|
calculateMonthlyFirstExecution(task.getFrequencyDetail());
|
case "QUARTERLY" ->
|
// 自定义频率，如每小时、每30分钟等
|
calculateCustomFirstExecution(task.getFrequencyDetail());
|
default -> throw new IllegalArgumentException("不支持的频率类型: " + task.getFrequencyType());
|
};
|
}
|
|
private LocalDateTime calculateDailyFirstExecution(String frequencyDetail) {
|
// frequencyDetail可能是具体时间，如 "14:30"
|
LocalTime executionTime = LocalTime.parse(frequencyDetail);
|
LocalDateTime now = LocalDateTime.now();
|
LocalDateTime todayExecution = LocalDateTime.of(now.toLocalDate(), executionTime);
|
|
// 如果今天的时间已过，则安排明天执行
|
return now.isBefore(todayExecution) ? todayExecution : todayExecution.plusDays(1);
|
}
|
|
private LocalDateTime calculateWeeklyFirstExecution(String frequencyDetail) {
|
return null;
|
}
|
|
private LocalDateTime calculateMonthlyFirstExecution(String frequencyDetail) {
|
return null;
|
}
|
|
private LocalDateTime calculateCustomFirstExecution(String frequencyDetail) {
|
return null;
|
}
|
|
@Override
|
@Transactional
|
public void updateTaskExecutionTime(Long taskId) {
|
TimingTask task = timingTaskMapper.selectById(taskId);
|
if (task == null) {
|
throw new RuntimeException("定时任务不存在，ID: " + taskId);
|
}
|
|
// 更新最后执行时间为当前时间
|
task.setLastExecuteTime(LocalDateTime.now());
|
|
// 计算下次执行时间
|
LocalDateTime nextExecutionTime = calculateNextExecutionTime(
|
task.getFrequencyType(),
|
task.getFrequencyDetail(),
|
LocalDateTime.now()
|
);
|
task.setNexExecutionTime(nextExecutionTime);
|
|
// 更新数据库
|
timingTaskMapper.updateById(task);
|
}
|
|
/**
|
* 计算下次执行时间
|
*/
|
private LocalDateTime calculateNextExecutionTime(String frequencyType,
|
String frequencyDetail,
|
LocalDateTime currentTime) {
|
try {
|
return switch (frequencyType) {
|
case "DAILY" -> calculateDailyNextTime(frequencyDetail, currentTime);
|
case "WEEKLY" -> calculateWeeklyNextTime(frequencyDetail, currentTime);
|
case "MONTHLY" -> calculateMonthlyNextTime(frequencyDetail, currentTime);
|
case "QUARTERLY" -> calculateQuarterlyNextTime(frequencyDetail, currentTime);
|
default -> throw new IllegalArgumentException("不支持的频率类型: " + frequencyType);
|
};
|
} catch (Exception e) {
|
throw new RuntimeException("计算下次执行时间失败: " + e.getMessage(), e);
|
}
|
}
|
|
/**
|
* 计算每日任务的下次执行时间
|
*/
|
private LocalDateTime calculateDailyNextTime(String timeStr, LocalDateTime current) {
|
LocalTime executionTime = LocalTime.parse(timeStr); // 解析格式 "HH:mm"
|
LocalDateTime nextTime = LocalDateTime.of(current.toLocalDate(), executionTime);
|
|
// 如果今天的时间已过，则安排明天
|
return current.isBefore(nextTime) ? nextTime : nextTime.plusDays(1);
|
}
|
|
/**
|
* 计算每周任务的下次执行时间
|
*/
|
private LocalDateTime calculateWeeklyNextTime(String detail, LocalDateTime current) {
|
String[] parts = detail.split(",");
|
String dayOfWeekStr = parts[0]; // 如 "MON" 或 "MON|WED|FRI"
|
LocalTime time = LocalTime.parse(parts[1]); // 时间部分
|
|
// 解析星期几(支持多个星期)
|
Set<DayOfWeek> targetDays = parseDayOfWeeks(dayOfWeekStr);
|
|
// 从当前时间开始找下一个符合条件的星期几
|
LocalDateTime nextTime = current;
|
while (true) {
|
nextTime = nextTime.plusDays(1);
|
if (targetDays.contains(nextTime.getDayOfWeek())) {
|
return LocalDateTime.of(nextTime.toLocalDate(), time);
|
}
|
|
// 防止无限循环(理论上不会发生)
|
if (nextTime.isAfter(current.plusYears(1))) {
|
throw new RuntimeException("无法找到下次执行时间");
|
}
|
}
|
}
|
|
/**
|
* 计算每月任务的下次执行时间
|
*/
|
private LocalDateTime calculateMonthlyNextTime(String detail, LocalDateTime current) {
|
String[] parts = detail.split(",");
|
int dayOfMonth = Integer.parseInt(parts[0]);
|
LocalTime time = LocalTime.parse(parts[1]);
|
|
// 从下个月开始计算
|
LocalDateTime nextTime = current.plusMonths(1)
|
.withDayOfMonth(Math.min(dayOfMonth, current.plusMonths(1).toLocalDate().lengthOfMonth()))
|
.with(time);
|
|
return nextTime;
|
}
|
|
/**
|
* 计算每季度任务的下次执行时间
|
*/
|
private LocalDateTime calculateQuarterlyNextTime(String detail, LocalDateTime current) {
|
String[] parts = detail.split(",");
|
int quarterMonth = Integer.parseInt(parts[0]); // 1=第1个月，2=第2个月，3=第3个月
|
int dayOfMonth = Integer.parseInt(parts[1]);
|
LocalTime time = LocalTime.parse(parts[2]);
|
|
// 计算当前季度
|
int currentQuarter = (current.getMonthValue() - 1) / 3 + 1;
|
int currentMonthInQuarter = (current.getMonthValue() - 1) % 3 + 1;
|
|
YearMonth targetYearMonth;
|
if (currentMonthInQuarter < quarterMonth) {
|
// 本季度内还有执行机会
|
targetYearMonth = YearMonth.from(current)
|
.plusMonths(quarterMonth - currentMonthInQuarter);
|
} else {
|
// 需要到下个季度
|
targetYearMonth = YearMonth.from(current)
|
.plusMonths(3 - currentMonthInQuarter + quarterMonth);
|
}
|
|
// 处理月末日期
|
int adjustedDay = Math.min(dayOfMonth, targetYearMonth.lengthOfMonth());
|
|
return LocalDateTime.of(
|
targetYearMonth.getYear(),
|
targetYearMonth.getMonthValue(),
|
adjustedDay,
|
time.getHour(),
|
time.getMinute()
|
);
|
}
|
|
/**
|
* 解析星期几字符串
|
*/
|
private Set<DayOfWeek> parseDayOfWeeks(String dayOfWeekStr) {
|
Set<DayOfWeek> days = new HashSet<>();
|
String[] dayStrs = dayOfWeekStr.split("\\|");
|
|
for (String dayStr : dayStrs) {
|
switch (dayStr) {
|
case "MON": days.add(DayOfWeek.MONDAY); break;
|
case "TUE": days.add(DayOfWeek.TUESDAY); break;
|
case "WED": days.add(DayOfWeek.WEDNESDAY); break;
|
case "THU": days.add(DayOfWeek.THURSDAY); break;
|
case "FRI": days.add(DayOfWeek.FRIDAY); break;
|
case "SAT": days.add(DayOfWeek.SATURDAY); break;
|
case "SUN": days.add(DayOfWeek.SUNDAY); break;
|
default: throw new IllegalArgumentException("无效的星期几: " + dayStr);
|
}
|
}
|
|
return days;
|
}
|
|
// /**
|
// * 每天17:40准时触发，执行到期任务
|
// */
|
// @Scheduled(cron = "0 55 17 * * ?", zone = "Asia/Shanghai")
|
// @Transactional
|
// public void executeDueTasks() {
|
// LocalDateTime now = LocalDateTime.now();
|
// log.info("定时任务触发，当前时间: {}", now);
|
//
|
// // 1. 查询所有需要立即执行的任务
|
// List<TimingTask> dueTasks = timingTaskMapper.selectActiveTasks(now);
|
//
|
// // 2. 处理每个任务
|
// dueTasks.forEach(task -> {
|
// // 2.1 转换为巡检任务并保存
|
// InspectionTask inspectionTask = convertToInspectionTask(task);
|
// inspectionTaskMapper.insert(inspectionTask);
|
//
|
// // 2.2 计算并更新下次执行时间
|
// updateNextExecutionTime(task, now);
|
//
|
// log.info("任务[{}]已执行，下次执行时间: {}",
|
// task.getTaskName(),
|
// task.getNexExecutionTime());
|
// });
|
// }
|
//
|
// private InspectionTask convertToInspectionTask(TimingTask timingTask) {
|
// InspectionTask inspectionTask = new InspectionTask();
|
//
|
// // 复制基本属性
|
// inspectionTask.setTaskName(timingTask.getTaskName());
|
// inspectionTask.setInspectorId(timingTask.getInspectorIds());
|
// inspectionTask.setPort(timingTask.getInspectionLocation());
|
// inspectionTask.setRemarks("自动生成自定时任务ID: " + timingTask.getId());
|
// inspectionTask.setRegistrantId(timingTask.getRegistrantId());
|
// inspectionTask.setFrequency(timingTask.getFrequencyType());
|
// return inspectionTask;
|
// }
|
//
|
// private void updateNextExecutionTime(TimingTask task, LocalDateTime currentExecutionTime) {
|
// switch (task.getFrequencyType()) {
|
// case "DAILY":
|
// task.setNexExecutionTime(currentExecutionTime.plusDays(1));
|
// break;
|
// case "WEEKLY":
|
// task.setNexExecutionTime(currentExecutionTime.plusWeeks(1));
|
// break;
|
// case "MONTHLY":
|
// task.setNexExecutionTime(currentExecutionTime.plusMonths(1));
|
// break;
|
// default:
|
// task.setNexExecutionTime(null); // 单次任务
|
// }
|
// timingTaskMapper.updateById(task);
|
// }
|
|
|
|
@Override
|
public int delByIds(Long[] ids) {
|
return timingTaskMapper.deleteByIds(Arrays.asList(ids));
|
}
|
}
|
