feat: 修复统计

wlzboy

5 天以前 fe33646ee6e2d1e57f2b51812e94983a0e9efb04

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

@@ -1,48 +1,31 @@
package com.ruoyi.system.service.impl;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.system.domain.SysTaskVehicle;
import com.ruoyi.system.domain.VehicleInfo;
import com.ruoyi.system.mapper.SysTaskVehicleMapper;
import com.ruoyi.system.mapper.VehicleInfoMapper;
import com.ruoyi.system.service.ISysTaskVehicleService;
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.VehicleInfoMapper;
import com.ruoyi.system.domain.SysTaskVehicle;
import com.ruoyi.system.domain.VehicleInfo;
import com.ruoyi.system.service.ISysTaskVehicleService;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 任务车辆关联Service业务层处理
 * 任务车辆服务实现类
 * 
 * @author ruoyi
 * @date 2024-01-15
 */
@Service
public class SysTaskVehicleServiceImpl implements ISysTaskVehicleService {
    
    private static final Logger logger = LoggerFactory.getLogger(SysTaskVehicleServiceImpl.class);
    

    @Autowired
    private SysTaskVehicleMapper sysTaskVehicleMapper;
    

    @Autowired
    private VehicleInfoMapper vehicleInfoMapper;

    /**
     * 查询任务车辆关联
     * 
     * @param id 任务车辆关联主键
     * @return 任务车辆关联
     */
    @Override
    public SysTaskVehicle selectSysTaskVehicleById(Long id) {
        return sysTaskVehicleMapper.selectSysTaskVehicleById(id);
    }

    /**
     * 查询任务车辆关联列表
@@ -53,6 +36,17 @@
    @Override
    public List<SysTaskVehicle> selectSysTaskVehicleList(SysTaskVehicle sysTaskVehicle) {
        return sysTaskVehicleMapper.selectSysTaskVehicleList(sysTaskVehicle);
    }

    /**
     * 查询任务车辆关联信息
     * 
     * @param id 任务车辆关联主键
     * @return 任务车辆关联信息
     */
    @Override
    public SysTaskVehicle selectSysTaskVehicleById(Long id) {
        return sysTaskVehicleMapper.selectSysTaskVehicleById(id);
    }

    /**
@@ -73,20 +67,7 @@
     * @return 结果
     */
    @Override
    @Transactional
    public int insertSysTaskVehicle(SysTaskVehicle sysTaskVehicle) {
        // 设置分配时间和分配人
        if (sysTaskVehicle.getAssignTime() == null) {
            sysTaskVehicle.setAssignTime(DateUtils.getNowDate());
        }
        if (sysTaskVehicle.getAssignBy() == null || sysTaskVehicle.getAssignBy().isEmpty()) {
            sysTaskVehicle.setAssignBy(SecurityUtils.getUsername());
        }
        // 设置默认状态
        if (sysTaskVehicle.getStatus() == null || sysTaskVehicle.getStatus().isEmpty()) {
            sysTaskVehicle.setStatus("ASSIGNED");
        }
        sysTaskVehicle.setCreateTime(DateUtils.getNowDate());
        return sysTaskVehicleMapper.insertSysTaskVehicle(sysTaskVehicle);
    }

@@ -97,22 +78,8 @@
     * @return 结果
     */
    @Override
    @Transactional
    public int updateSysTaskVehicle(SysTaskVehicle sysTaskVehicle) {
        sysTaskVehicle.setUpdateTime(DateUtils.getNowDate());
        return sysTaskVehicleMapper.updateSysTaskVehicle(sysTaskVehicle);
    }

    /**
     * 批量删除任务车辆关联
     * 
     * @param ids 需要删除的任务车辆关联主键
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteSysTaskVehicleByIds(Long[] ids) {
        return sysTaskVehicleMapper.deleteSysTaskVehicleByIds(ids);
    }

    /**
@@ -122,71 +89,135 @@
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteSysTaskVehicleById(Long id) {
        return sysTaskVehicleMapper.deleteSysTaskVehicleById(id);
    }

    /**
     * 根据任务ID删除车辆关联
     * 批量删除任务车辆关联信息
     * 
     * @param taskId 任务ID
     * @param ids 需要删除的主键集合
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteSysTaskVehicleByTaskId(Long taskId) {
        return sysTaskVehicleMapper.deleteSysTaskVehicleByTaskId(taskId);
    public int deleteSysTaskVehicleByIds(Long[] ids) {
        return sysTaskVehicleMapper.deleteSysTaskVehicleByIds(ids);
    }

    /**
     * 根据任务ID和车辆ID删除关联
     * 更新任务车辆关联状态
     * 
     * @param taskId 任务ID
     * @param vehicleId 车辆ID
     * @param id 任务车辆关联主键
     * @param status 状态
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteSysTaskVehicleByTaskIdAndVehicleId(Long taskId, Long vehicleId) {
        return sysTaskVehicleMapper.deleteSysTaskVehicleByTaskIdAndVehicleId(taskId, vehicleId);
    public int updateSysTaskVehicleStatus(Long id, String status) {
        SysTaskVehicle taskVehicle = new SysTaskVehicle();
        taskVehicle.setId(id);
        taskVehicle.setStatus(status);
        taskVehicle.setUpdateTime(DateUtils.getNowDate());
        return sysTaskVehicleMapper.updateSysTaskVehicle(taskVehicle);
    }

    /**
     * 检查任务车辆关联是否存在
     * 批量获取车辆当前任务状态
     * 
     * @param taskId 任务ID
     * @param vehicleId 车辆ID
     * @return 结果
     * @param vehicleIds 车辆ID列表
     * @return 车辆任务状态映射
     */
    @Override
    public int checkTaskVehicleExists(Long taskId, Long vehicleId) {
        return sysTaskVehicleMapper.checkTaskVehicleExists(taskId, vehicleId);
    public Map<Long, Map<String, Object>> batchGetVehicleCurrentTaskStatus(List<Long> vehicleIds) {
        Map<Long, Map<String, Object>> statusMap = new HashMap<>();
        
        if (vehicleIds != null && !vehicleIds.isEmpty()) {
            // 这里可以根据实际需求查询车辆的当前任务状态
            // 由于缺乏具体的业务逻辑，这里简单返回空映射
            for (Long vehicleId : vehicleIds) {
                Map<String, Object> statusInfo = new HashMap<>();
                statusInfo.put("vehicleId", vehicleId);
                statusInfo.put("currentTaskId", null);
                statusInfo.put("currentTaskStatus", "AVAILABLE");
                statusInfo.put("lastUpdateTime", DateUtils.getNowDate());
                statusMap.put(vehicleId, statusInfo);
            }
        }
        
        return statusMap;
    }

    /**
     * 批量新增任务车辆关联
     * 
     * @param sysTaskVehicleList 任务车辆关联列表
     * @return 结果
     */
    @Override
    @Transactional
    public int batchInsertSysTaskVehicle(List<SysTaskVehicle> sysTaskVehicleList) {
        return sysTaskVehicleMapper.batchInsertSysTaskVehicle(sysTaskVehicleList);
    public void saveTaskVehicles(Long taskId, List<Long> vehicleIds, String userName) {
        saveTaskVehicles(taskId, vehicleIds, userName, 
            DateUtils.getNowDate(), DateUtils.getNowDate(), DateUtils.getNowDate());
    }

    /**
     * 分配车辆给任务
     * 
     * @param taskId 任务ID
     * @param vehicleId 车辆ID
     * @param remark 备注
     * @return 结果
     */
    @Override
    @Transactional
    public int assignVehicleToTask(Long taskId, Long vehicleId, String remark) {
    public void saveTaskVehicles(Long taskId, List<Long> vehicleIds, String userName,
                                  Date assignTime, Date createTime, Date updateTime) {
        if (vehicleIds == null || vehicleIds.isEmpty()) {
            return;
        }
        
        for (Long vehicleId : vehicleIds) {
            SysTaskVehicle taskVehicle = new SysTaskVehicle();
            taskVehicle.setTaskId(taskId);
            taskVehicle.setVehicleId(vehicleId);
            taskVehicle.setAssignTime(assignTime);
            taskVehicle.setAssignBy(userName);
            taskVehicle.setStatus("ASSIGNED");
            taskVehicle.setCreateBy(userName);
            taskVehicle.setCreateTime(createTime);
            taskVehicle.setUpdateBy(userName);
            taskVehicle.setUpdateTime(updateTime);
            
            sysTaskVehicleMapper.insertSysTaskVehicle(taskVehicle);
        }
    }

    @Override
    @Transactional
    public boolean updateTaskVehicles(Long taskId, List<Long> newVehicleIds, String userName) {
        if (newVehicleIds == null || newVehicleIds.isEmpty()) {
            return false;
        }
        
        // 查询现有的车辆关联
        List<SysTaskVehicle> existingVehicles = sysTaskVehicleMapper.selectSysTaskVehicleByTaskId(taskId);
        List<Long> existingVehicleIds = existingVehicles.stream()
            .map(SysTaskVehicle::getVehicleId)
            .collect(Collectors.toList());
        
        // 比较新旧车辆ID列表，判断是否有变化
        boolean vehiclesChanged = !new HashSet<>(existingVehicleIds).equals(new HashSet<>(newVehicleIds));
        
        // 只有车辆发生变化时才更新
        if (vehiclesChanged) {
            // 删除旧的车辆关联
            sysTaskVehicleMapper.deleteSysTaskVehicleByTaskId(taskId);
            
            // 添加新的车辆关联
            Date now = DateUtils.getNowDate();
            for (Long vehicleId : newVehicleIds) {
                SysTaskVehicle taskVehicle = new SysTaskVehicle();
                taskVehicle.setTaskId(taskId);
                taskVehicle.setVehicleId(vehicleId);
                taskVehicle.setAssignTime(now);
                taskVehicle.setAssignBy(userName);
                taskVehicle.setCreateTime(now);
                sysTaskVehicleMapper.insertSysTaskVehicle(taskVehicle);
            }
            return true;
        }
        
        return false;
    }

    @Override
    @Transactional
    public int assignVehicleToTask(Long taskId, Long vehicleId, String remark, Long userId, String userName) {
        // 检查是否已经分配
        int exists = sysTaskVehicleMapper.checkTaskVehicleExists(taskId, vehicleId);
        if (exists > 0) {
@@ -197,40 +228,25 @@
        taskVehicle.setTaskId(taskId);
        taskVehicle.setVehicleId(vehicleId);
        taskVehicle.setAssignTime(DateUtils.getNowDate());
        taskVehicle.setAssignBy(SecurityUtils.getUsername());
        taskVehicle.setAssignBy(userName);
        taskVehicle.setStatus("ASSIGNED");
        taskVehicle.setRemark(remark);
        
        return sysTaskVehicleMapper.insertSysTaskVehicle(taskVehicle);
    }

    /**
     * 取消任务车辆分配
     * 
     * @param taskId 任务ID
     * @param vehicleId 车辆ID
     * @return 结果
     */
    @Override
    @Transactional
    public int unassignVehicleFromTask(Long taskId, Long vehicleId) {
        return sysTaskVehicleMapper.deleteSysTaskVehicleByTaskIdAndVehicleId(taskId, vehicleId);
    }

    /**
     * 批量分配车辆给任务
     * 
     * @param taskId 任务ID
     * @param vehicleIds 车辆ID列表
     * @param remark 备注
     * @return 结果
     */
    @Override
    @Transactional
    public int assignMultipleVehiclesToTask(Long taskId, List<Long> vehicleIds, String remark) {
    public int assignMultipleVehiclesToTask(Long taskId, List<Long> vehicleIds, String remark, 
                                            Long userId, String userName) {
        List<SysTaskVehicle> taskVehicles = new ArrayList<>();
        Date now = DateUtils.getNowDate();
        String assignBy = SecurityUtils.getUsername();
        
        for (Long vehicleId : vehicleIds) {
            // 检查是否已经分配
@@ -240,41 +256,39 @@
                taskVehicle.setTaskId(taskId);
                taskVehicle.setVehicleId(vehicleId);
                taskVehicle.setAssignTime(now);
                taskVehicle.setAssignBy(assignBy);
                taskVehicle.setAssignBy(userName);
                taskVehicle.setStatus("ASSIGNED");
                taskVehicle.setRemark(remark);
                taskVehicles.add(taskVehicle);
            }
        }
        
        int result = 0;
        if (!taskVehicles.isEmpty()) {
            return sysTaskVehicleMapper.batchInsertSysTaskVehicle(taskVehicles);
            result = sysTaskVehicleMapper.batchInsertSysTaskVehicle(taskVehicles);
        }
        
        return 0;
        return result;
    }

    /**
     * 查询可用车辆
     * 
     * @param deptId 部门ID
     * @param taskType 任务类型
     * @return 可用车辆列表
     */
    @Override
    public List<SysTaskVehicle> getTaskVehicles(Long taskId) {
        return sysTaskVehicleMapper.selectSysTaskVehicleByTaskId(taskId);
    }

    @Override
    public List<SysTaskVehicle> getAvailableVehicles(Long deptId, String taskType) {
        // 查询指定部门下状态为正常的车辆
        List<SysTaskVehicle> availableVehicles = new ArrayList<>();
        
        try {
            // 查询车辆信息
            // 查询所有状态为正常的车辆
            VehicleInfo queryParam = new VehicleInfo();
            queryParam.setDeptId(deptId);
            queryParam.setStatus("0"); // 0表示正常状态
            queryParam.setDeptId(deptId);
            
            List<VehicleInfo> vehicles = vehicleInfoMapper.selectVehicleInfoList(queryParam);
            
            // 转换为 SysTaskVehicle 对象
            // 转换为SysTaskVehicle对象
            for (VehicleInfo vehicle : vehicles) {
                SysTaskVehicle taskVehicle = new SysTaskVehicle();
                taskVehicle.setVehicleId(vehicle.getVehicleId());
@@ -282,30 +296,23 @@
                taskVehicle.setVehicleType(vehicle.getVehicleType());
                taskVehicle.setVehicleBrand(vehicle.getVehicleBrand());
                taskVehicle.setVehicleModel(vehicle.getVehicleModel());
                taskVehicle.setStatus(vehicle.getStatus());
                taskVehicle.setDeptName(vehicle.getDeptName());
                availableVehicles.add(taskVehicle);
            }
        } catch (Exception e) {
            logger.error("查询可用车辆失败", e);
            System.err.println("查询可用车辆失败: " + e.getMessage());
        }
        
        return availableVehicles;
    }

    /**
     * 更新任务车辆关联状态
     * 
     * @param id 关联ID
     * @param status 新状态
     * @return 结果
     */
    @Override
    @Transactional
    public int updateTaskVehicleStatus(Long id, String status) {
        SysTaskVehicle taskVehicle = new SysTaskVehicle();
        taskVehicle.setId(id);
        taskVehicle.setStatus(status);
        taskVehicle.setUpdateTime(DateUtils.getNowDate());
        return sysTaskVehicleMapper.updateSysTaskVehicle(taskVehicle);
    public int deleteTaskVehiclesByTaskId(Long taskId) {
        return sysTaskVehicleMapper.deleteSysTaskVehicleByTaskId(taskId);
    }

    @Override
    public boolean checkVehicleAssigned(Long taskId, Long vehicleId) {
        return sysTaskVehicleMapper.checkTaskVehicleExists(taskId, vehicleId) > 0;
    }
}