feat:优先添加执行人

wlzboy

2025-12-03 656d6f8029f8bf9b2daa9dcc89101a879a70b860

 ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysTaskVehicleServiceImpl.java

@@ -2,14 +2,22 @@

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.system.mapper.SysTaskVehicleMapper;
import com.ruoyi.system.mapper.SysTaskMapper;
import com.ruoyi.system.mapper.VehicleInfoMapper;
import com.ruoyi.system.domain.SysTask;
import com.ruoyi.system.domain.SysTaskVehicle;
import com.ruoyi.system.domain.VehicleInfo;
import com.ruoyi.system.service.ISysTaskVehicleService;

/**
@@ -21,8 +29,16 @@
@Service
public class SysTaskVehicleServiceImpl implements ISysTaskVehicleService {
    
    private static final Logger logger = LoggerFactory.getLogger(SysTaskVehicleServiceImpl.class);
    
    @Autowired
    private SysTaskVehicleMapper sysTaskVehicleMapper;
    
    @Autowired
    private VehicleInfoMapper vehicleInfoMapper;
    
    @Autowired
    private SysTaskMapper sysTaskMapper;

    /**
     * 查询任务车辆关联
@@ -255,29 +271,30 @@
    @Override
    public List<SysTaskVehicle> getAvailableVehicles(Long deptId, String taskType) {
        // 查询指定部门下状态为正常的车辆
        // 这里需要根据实际的车辆信息表结构来实现
        // 暂时返回空列表，实际实现需要：
        // 1. 查询 tb_vehicle_info 表中 dept_id = deptId 且 vehicle_status = '0' 的车辆
        // 2. 排除已经分配给其他未完成任务且状态为 ACTIVE 的车辆
        // 3. 根据任务类型筛选合适的车辆类型
        
        List<SysTaskVehicle> availableVehicles = new ArrayList<>();
        
        // TODO: 实现具体的查询逻辑
        // 示例代码：
        // 1. 查询车辆信息
        // List<TbVehicleInfo> vehicles = vehicleInfoMapper.selectAvailableVehiclesByDept(deptId, taskType);
        // 
        // 2. 转换为 SysTaskVehicle 对象
        // for (TbVehicleInfo vehicle : vehicles) {
        //     SysTaskVehicle taskVehicle = new SysTaskVehicle();
        //     taskVehicle.setVehicleId(vehicle.getVehicleId());
        //     taskVehicle.setVehicleNo(vehicle.getVehicleNo());
        //     taskVehicle.setVehicleType(vehicle.getVehicleType());
        //     taskVehicle.setVehicleBrand(vehicle.getVehicleBrand());
        //     taskVehicle.setVehicleModel(vehicle.getVehicleModel());
        //     availableVehicles.add(taskVehicle);
        // }
        try {
            // 查询车辆信息
            VehicleInfo queryParam = new VehicleInfo();
            queryParam.setDeptId(deptId);
            queryParam.setStatus("0"); // 0表示正常状态
            
            List<VehicleInfo> vehicles = vehicleInfoMapper.selectVehicleInfoList(queryParam);
            
            // 转换为 SysTaskVehicle 对象
            for (VehicleInfo vehicle : vehicles) {
                SysTaskVehicle taskVehicle = new SysTaskVehicle();
                taskVehicle.setVehicleId(vehicle.getVehicleId());
                taskVehicle.setVehicleNo(vehicle.getVehicleNo());
                taskVehicle.setVehicleType(vehicle.getVehicleType());
                taskVehicle.setVehicleBrand(vehicle.getVehicleBrand());
                taskVehicle.setVehicleModel(vehicle.getVehicleModel());
                taskVehicle.setStatus(vehicle.getStatus());
                availableVehicles.add(taskVehicle);
            }
        } catch (Exception e) {
            logger.error("查询可用车辆失败", e);
        }
        
        return availableVehicles;
    }
@@ -298,4 +315,63 @@
        taskVehicle.setUpdateTime(DateUtils.getNowDate());
        return sysTaskVehicleMapper.updateSysTaskVehicle(taskVehicle);
    }

    /**
     * 批量获取车辆当前任务状态
     * 
     * @param vehicleIds 车辆ID列表
     * @return Map<车辆ID, Map<"taskCode": 任务编号, "taskStatus": 任务状态>>
     */
    @Override
    public Map<Long, Map<String, Object>> batchGetVehicleCurrentTaskStatus(List<Long> vehicleIds) {
        Map<Long, Map<String, Object>> resultMap = new HashMap<>();
        
        if (vehicleIds == null || vehicleIds.isEmpty()) {
            return resultMap;
        }
        
        try {
            // 对每个车辆查询其当前正在进行的任务
            for (Long vehicleId : vehicleIds) {
                if (vehicleId == null) {
                    continue;
                }
                
                // 查询车辆的活跃任务（未完成、未取消的任务）
                List<SysTask> activeTasks = sysTaskMapper.selectActiveTasksByVehicleId(vehicleId);
                
                if (activeTasks != null && !activeTasks.isEmpty()) {
                    // 取第一个活跃任务（最新的）
                    SysTask currentTask = activeTasks.get(0);
                    
                    Map<String, Object> taskInfo = new HashMap<>();
                    taskInfo.put("taskCode", currentTask.getTaskCode());
                    taskInfo.put("taskStatus", currentTask.getTaskStatus());
                    taskInfo.put("taskId", currentTask.getTaskId());
                    
                    resultMap.put(vehicleId, taskInfo);
                } else {
                    // 没有活跃任务
                    resultMap.put(vehicleId, null);
                }
            }
        } catch (Exception e) {
            logger.error("批量查询车辆任务状态失败", e);
        }
        
        return resultMap;
    }

    /**
     * 更新任务车辆关联状态（新方法）
     * 
     * @param id 关联ID
     * @param status 新状态
     * @return 结果
     */
    @Override
    @Transactional
    public int updateSysTaskVehicleStatus(Long id, String status) {
        return updateTaskVehicleStatus(id, status);
    }
}