a-tuoheng-task/src/main/java/com/ruoyi/task/service/impl/TaskPlanServiceImpl.java

package com.ruoyi.task.service.impl;

import com.ruoyi.task.api.enums.*;
import com.ruoyi.task.domain.api.ITaskDomain;
import com.ruoyi.task.domain.api.ITaskPlanDomain;
import com.ruoyi.task.domain.model.Task;
import com.ruoyi.task.domain.model.TaskPlan;
import com.ruoyi.task.service.api.ITaskPlanService;
import com.ruoyi.task.service.convert.TaskPlanDTOConvert;
import com.ruoyi.task.service.convert.TaskDTOConvert;
import com.ruoyi.task.service.dto.TaskPlanDTO;
import com.ruoyi.task.service.dto.TaskPlanQueryDTO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class TaskPlanServiceImpl implements ITaskPlanService {

    @Autowired
    private ITaskPlanDomain taskPlanDomain;

    @Autowired
    private ITaskDomain taskDomain;

    @Override
    public Long createTimedTaskPlan(TaskPlanDTO taskPlanDTO) {
        TaskPlan taskPlan = TaskPlanDTOConvert.toDomain(taskPlanDTO);
        
        // 校验PlanTypeEnum
        if (taskPlan.getPlanType() != null && taskPlan.getPlanType() == PlanTypeEnum.CYCLE) {
            throw new IllegalArgumentException("定时任务计划不能设置为周期类型");
        }
        
        // 如果PlanTypeEnum为空，设置为定时类型
        if (taskPlan.getPlanType() == null) {
            taskPlan.setPlanType(PlanTypeEnum.TIMED);
        }
        
        TaskPlan result = taskPlanDomain.createTimedTaskPlan(taskPlan);
        
        // 创建对应的任务记录
        createTaskFromPlan(result);
        return result.getId();
    }

    @Override
    public Long createCycleTaskPlan(TaskPlanDTO taskPlanDTO) {
        TaskPlan taskPlan = TaskPlanDTOConvert.toDomain(taskPlanDTO);
        
        // 校验PlanTypeEnum
        if (taskPlan.getPlanType() != null && taskPlan.getPlanType() == PlanTypeEnum.TIMED) {
            throw new IllegalArgumentException("周期任务计划不能设置为定时类型");
        }
        
        // 如果PlanTypeEnum为空，设置为周期类型
        if (taskPlan.getPlanType() == null) {
            taskPlan.setPlanType(PlanTypeEnum.CYCLE);
        }
        
        TaskPlan result = taskPlanDomain.createCycleTaskPlan(taskPlan);
        
        // 创建对应的任务记录
        createTaskFromPlan(result);
        
        return result.getId();
    }

    /**
     * 根据任务计划创建任务记录
     */
    private void createTaskFromPlan(TaskPlan taskPlan) {
        // 检查是否为周期任务计划
        if (taskPlan.getPlanType() == PlanTypeEnum.CYCLE) {
            // 生成周期任务记录
            generateCycleTasks(taskPlan);
        } else {
            // 生成单次任务记录
            generateSingleTask(taskPlan);
        }
    }
    
    /**
     * 生成单次任务记录
     */
    private void generateSingleTask(TaskPlan taskPlan) {
        Task task = new Task();
        task.setTaskName(taskPlan.getPlanName() + "_任务");
        task.setPlanId(taskPlan.getId());
        task.setTaskCategory(TaskCategoryEnum.PLAN_TASK);
        task.setTaskType(TaskTypeEnum.PLAN_TASK);
        task.setExecuteType(taskPlan.getExecuteType());
        task.setRouteId(taskPlan.getRouteId());
        task.setUavId(taskPlan.getUavId());
        task.setStartTime(taskPlan.getStartDate());
        task.setEndTime(taskPlan.getEndDate());
        task.setStatus(StatusEnum.PENDING); // 待执行
        task.setDescription("由任务计划自动创建");
        
        // 创建任务
        taskDomain.createTaskWithoutPlan(task);
    }
    
    /**
     * 生成周期任务记录
     */
    private void generateCycleTasks(TaskPlan taskPlan) {
        // 从开始日期到结束日期，根据周期类型和周期值生成任务
        java.util.Calendar calendar = java.util.Calendar.getInstance();
        calendar.setTime(taskPlan.getStartDate());
        
        java.util.Calendar endCalendar = java.util.Calendar.getInstance();
        endCalendar.setTime(taskPlan.getEndDate());
        
        // 解析周期值
        String cycleValue = taskPlan.getCycleValue();
        java.util.Set<Integer> cycleValues = new java.util.HashSet<>();
        if (cycleValue != null && !cycleValue.isEmpty()) {
            String[] values = cycleValue.split(",");
            for (String value : values) {
                try {
                    cycleValues.add(Integer.parseInt(value.trim()));
                } catch (NumberFormatException e) {
                    // 忽略无效值
                }
            }
        }
        
        // 根据周期类型生成任务
        while (!calendar.after(endCalendar)) {
            boolean shouldCreateTask = false;
            
            if (taskPlan.getCycleType() == CycleTypeEnum.DAILY) {
                // 日周期：每天都创建任务
                shouldCreateTask = true;
            } else if (taskPlan.getCycleType() == CycleTypeEnum.WEEKLY) {
                // 周周期：在指定的星期几创建任务（1-7，1表示周日）
                int dayOfWeek = calendar.get(java.util.Calendar.DAY_OF_WEEK);
                shouldCreateTask = cycleValues.contains(dayOfWeek);
            } else if (taskPlan.getCycleType() == CycleTypeEnum.MONTHLY) {
                // 月周期：在指定的日期创建任务（1-31）
                int dayOfMonth = calendar.get(java.util.Calendar.DAY_OF_MONTH);
                shouldCreateTask = cycleValues.contains(dayOfMonth);
            }
            
            if (shouldCreateTask) {
                Task task = new Task();
                task.setTaskName(taskPlan.getPlanName() + "_任务_" + formatDate(calendar.getTime()));
                task.setPlanId(taskPlan.getId());
                task.setTaskCategory(TaskCategoryEnum.PLAN_TASK);
                task.setTaskType(TaskTypeEnum.PLAN_TASK);
                task.setExecuteType(taskPlan.getExecuteType());
                task.setRouteId(taskPlan.getRouteId());
                task.setUavId(taskPlan.getUavId());
                task.setStartTime(calendar.getTime());
                task.setEndTime(calendar.getTime());
                task.setStatus(StatusEnum.PENDING); // 待执行
                task.setDescription("由任务计划自动创建");
                
                // 创建任务
                taskDomain.createTaskWithoutPlan(task);
            }
            
            // 增加一天
            calendar.add(java.util.Calendar.DAY_OF_YEAR, 1);
        }
    }
    
    /**
     * 格式化日期为字符串
     */
    private String formatDate(java.util.Date date) {
        java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("yyyyMMdd");
        return sdf.format(date);
    }
    


    @Override
    public TaskPlanDTO getTaskPlanById(Long planId) {
        TaskPlan taskPlan = taskPlanDomain.getTaskPlanById(planId);
        return TaskPlanDTOConvert.toDTO(taskPlan);
    }

    @Override
    public List<TaskPlanDTO> getTaskPlanList(TaskPlanQueryDTO queryDTO) {
        // 创建TaskPlan对象作为查询条件
        TaskPlan taskPlan = new TaskPlan();
        taskPlan.setRouteId(queryDTO.getRouteId());
        taskPlan.setStatus(queryDTO.getStatus());
        taskPlan.setPlanType(queryDTO.getPlanType());
        
        List<TaskPlan> taskPlans = taskPlanDomain.getTaskPlanList(taskPlan);
        return TaskPlanDTOConvert.toDTOList(taskPlans);
    }

    @Override
    public boolean updateTaskPlan(TaskPlanDTO taskPlanDTO) {
        TaskPlan taskPlan = TaskPlanDTOConvert.toDomain(taskPlanDTO);
        TaskPlan result = taskPlanDomain.updateTaskPlan(taskPlan);
        return result != null;
    }

    @Override
    public boolean deleteTaskPlan(Long planId) {
        // 先获取该计划下的所有任务
        List<Task> tasks = taskDomain.getTaskByPlanId(planId);
        
        // 删除所有状态为待执行的任务
        for (Task task : tasks) {
            if (task.getStatus() == StatusEnum.PENDING) {
                taskDomain.deleteTask(task.getId());
            }
        }
        
        // 最后删除任务计划
        return taskPlanDomain.deleteTaskPlan(planId);
    }
}