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.ExecuteTypeEnum;
import com.ruoyi.task.api.enums.PlanTypeEnum;
import com.ruoyi.task.api.enums.StatusEnum;
import com.ruoyi.task.api.enums.TaskCategoryEnum;
import com.ruoyi.task.api.enums.TaskTypeEnum;
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 != null ? result.getId() : null;
    }

    /**
     * 根据任务计划创建任务记录
     */
    private void createTaskFromPlan(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);
    }

    @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(StatusEnum.getByCode(queryDTO.getStatus()));
        taskPlan.setPlanType(PlanTypeEnum.getByCode(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) {
        return taskPlanDomain.deleteTaskPlan(planId);
    }
}