feat: 任务修改接口，删除一些不要的字段同步

wlzboy

9 小时以前 5f2ee03958a1a16dc27195c76ea7cffb422c95d1

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

@@ -1,11 +1,23 @@
package com.ruoyi.system.service.impl;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.Date;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.entity.SysDept;
import com.ruoyi.system.mapper.VehicleInfoMapper;
import com.ruoyi.system.mapper.SysUserMapper;
import com.ruoyi.system.mapper.SysDeptMapper;
import com.ruoyi.system.domain.VehicleInfo;
import com.ruoyi.system.domain.VehicleDept;
import com.ruoyi.system.service.IVehicleInfoService;
import com.ruoyi.system.service.ISysDeptService;

/**
 * 车辆信息Service业务层处理
@@ -14,41 +26,144 @@
public class VehicleInfoServiceImpl implements IVehicleInfoService {
    @Autowired
    private VehicleInfoMapper vehicleInfoMapper;
    
    @Autowired
    private SysUserMapper sysUserMapper;
    
    @Autowired
    private SysDeptMapper sysDeptMapper;
    
    @Autowired
    private ISysDeptService sysDeptService;

    /**
     * 查询车辆信息
     * 
     * @param vehicleId 车辆信息主键
     * @return 车辆信息
     */
    @Override
    public VehicleInfo selectVehicleInfoById(Long vehicleId) {
        return vehicleInfoMapper.selectVehicleInfoById(vehicleId);
        return vehicleInfoMapper.selectVehicleInfoWithDeptsById(vehicleId);
    }

    /**
     * 查询车辆信息（包含多分公司关联）
     * 
     * @param vehicleId 车辆信息主键
     * @return 车辆信息（包含deptIds和deptNames）
     */
    @Override
    public VehicleInfo selectVehicleInfoWithDeptsById(Long vehicleId) {
        VehicleInfo vehicle = vehicleInfoMapper.selectVehicleInfoWithDeptsById(vehicleId);
        // 初始化延迟加载的属性，避免序列化问题
        if (vehicle != null) {
            vehicle.initializeLazyProperties();
        }
        return vehicle;
    }

    /**
     * 通过车牌号查询车辆信息
     * 
     * @param plateNumber 车牌号
     * @return 车辆信息
     */
    @Override
    public VehicleInfo selectVehicleInfoByPlateNumber(String plateNumber) {
        return vehicleInfoMapper.selectVehicleInfoByPlateNumber(plateNumber);
    }

    /**
     * 查询车辆信息列表
     * 
     * @param vehicleInfo 车辆信息
     * @return 车辆信息
     */
    @Override
    public List<VehicleInfo> selectVehicleInfoList(VehicleInfo vehicleInfo) {
        return vehicleInfoMapper.selectVehicleInfoList(vehicleInfo);
        List<VehicleInfo> list = vehicleInfoMapper.selectVehicleInfoListWithDepts(vehicleInfo);
        // 初始化延迟加载的属性，避免序列化问题
        for (VehicleInfo vehicle : list) {
            vehicle.initializeLazyProperties();
        }
        return list;
    }

    /**
     * 新增车辆信息
     * 
     * @param vehicleInfo 车辆信息
     * @return 结果
     */
    @Override
    @Transactional
    public int insertVehicleInfo(VehicleInfo vehicleInfo) {
        return vehicleInfoMapper.insertVehicleInfo(vehicleInfo);
        int rows = vehicleInfoMapper.insertVehicleInfo(vehicleInfo);
        
        // 如果选择了多个分公司，保存到关联表
        if (vehicleInfo.getDeptIds() != null && !vehicleInfo.getDeptIds().isEmpty()) {
            insertVehicleDept(vehicleInfo);
        }
        
        return rows;
    }

    /**
     * 修改车辆信息
     * 
     * @param vehicleInfo 车辆信息
     * @return 结果
     */
    /**
     * 修改车辆信息
     * 注意:
     * - 如果需要更新部门关联,请设置 vehicleInfo.deptIds
     * - 如果不需要更新部门关联(仅更新车辆基本信息),请保持 vehicleInfo.deptIds = null
     * - 这样可以避免并发同步时的死锁问题
     * 
     * @param vehicleInfo 车辆信息
     * @return 结果
     */
    @Override
    @Transactional
    public int updateVehicleInfo(VehicleInfo vehicleInfo) {
        // 只有当 deptIds 不为 null 时才更新部门关联(避免不必要的锁竞争)
        if (vehicleInfo.getDeptIds() != null) {
            // 先删除旧的关联关系
            vehicleInfoMapper.deleteVehicleDeptByVehicleId(vehicleInfo.getVehicleId());
            
            // 如果选择了多个分公司,保存到关联表
            if (!vehicleInfo.getDeptIds().isEmpty()) {
                insertVehicleDept(vehicleInfo);
            }
        }
        
        return vehicleInfoMapper.updateVehicleInfo(vehicleInfo);
    }
    
    /**
     * 插入车辆-分公司关联关系
     */
    private void insertVehicleDept(VehicleInfo vehicleInfo) {
        List<VehicleDept> vehicleDepts = new ArrayList<>();
        for (Long deptId : vehicleInfo.getDeptIds()) {
            VehicleDept vd = new VehicleDept();
            vd.setVehicleId(vehicleInfo.getVehicleId());
            vd.setDeptId(deptId);
            vd.setCreateBy(vehicleInfo.getCreateBy());
            vehicleDepts.add(vd);
        }
        if (!vehicleDepts.isEmpty()) {
            vehicleInfoMapper.batchInsertVehicleDept(vehicleDepts);
        }
    }

    /**
     * 批量删除车辆信息
     * 
     * @param vehicleIds 需要删除的车辆信息主键
     * @return 结果
     */
    @Override
    public int deleteVehicleInfoByIds(Long[] vehicleIds) {
@@ -57,9 +172,105 @@

    /**
     * 删除车辆信息信息
     * 
     * @param vehicleId 车辆信息主键
     * @return 结果
     */
    @Override
    public int deleteVehicleInfoById(Long vehicleId) {
        return vehicleInfoMapper.deleteVehicleInfoById(vehicleId);
    }
    
    /**
     * 绑定车辆到用户
     * 
     * @param userId 用户ID
     * @param vehicleId 车辆ID
     * @return 结果
     */
    @Override
    @Transactional
    public int bindVehicleToUser(Long userId, Long vehicleId) {
        // 先解绑用户的所有车辆（业务逻辑：一个用户同时只能绑定一辆车）
        vehicleInfoMapper.unbindAllVehiclesFromUser(userId);
        
        // 绑定新车辆
        String bindBy = "";
        try {
            bindBy = SecurityUtils.getUsername();
        } catch (Exception e) {
            // 如果获取当前用户失败，使用空字符串
        }
        return vehicleInfoMapper.bindVehicleToUser(userId, vehicleId, bindBy);
    }
    
    /**
     * 解绑用户车辆
     * 
     * @param userId 用户ID
     * @param vehicleId 车辆ID
     * @return 结果
     */
    @Override
    public int unbindVehicleFromUser(Long userId, Long vehicleId) {
        return vehicleInfoMapper.unbindVehicleFromUser(userId, vehicleId);
    }
    
    /**
     * 获取用户当前绑定的车辆
     * 
     * @param userId 用户ID
     * @return 车辆信息
     */
    @Override
    public VehicleInfo getUserBoundVehicle(Long userId) {
        return vehicleInfoMapper.getUserBoundVehicle(userId);
    }
    
    /**
     * 根据用户有权限管理的分公司，查询所有可用车辆
     * 逻辑：
     * 1. 查询用户信息
     * 2. 调用sysDeptService.computeBranchCompaniesForUser获取用户管理的所有分公司
     * 3. 通过tb_vehicle_dept关联表查询这些分公司下的所有车辆
     * 
     * @param userId 用户ID
     * @return 车辆列表
     */
    @Override
    public List<VehicleInfo> selectAvailableVehiclesByUser(Long userId) {
        // 1. 查询用户信息
        SysUser user = sysUserMapper.selectUserById(userId);
        if (user == null) {
            return new ArrayList<>();
        }
        
        // 2. 调用sysDeptService获取用户管理的所有分公司
        List<SysDept> branchCompanies = sysDeptService.computeBranchCompaniesForUser(user);
        
        if (branchCompanies.isEmpty()) {
            // 如果没有找到任何分公司，返回空列表
            return new ArrayList<>();
        }
        
        // 3. 根据分公司列表查询车辆，使用Set去重
        Set<Long> vehicleIdSet = new HashSet<>();
        List<VehicleInfo> allVehicles = new ArrayList<>();
        
        for (SysDept branchCompany : branchCompanies) {
            VehicleInfo query = new VehicleInfo();
            query.setDeptId(branchCompany.getDeptId());
            List<VehicleInfo> vehicles = vehicleInfoMapper.selectVehicleInfoList(query);
            
            // 去重添加
            for (VehicleInfo vehicle : vehicles) {
                if (!vehicleIdSet.contains(vehicle.getVehicleId())) {
                    vehicleIdSet.add(vehicle.getVehicleId());
                    allVehicles.add(vehicle);
                }
            }
        }
        
        return allVehicles;
    }
}