一人可多车，一车只能挂一人

src/main/java/com/hotwj/platform/driverManagement/driver/service/impl/HotDriverServiceImpl.java

@@ -737,53 +737,19 @@ public class HotDriverServiceImpl implements IHotDriverService {
                 removeDriverPortFromUser(oldDriver.getPhone(), oldDriver.getCompanyId());
             }
 
-            // 处理车牌号变更：同步车辆信息的当前驾驶员
+            Set<String> impactedDriverIds = new LinkedHashSet<>();
-            String oldPlate = oldDriver != null ? oldDriver.getPlateNumber() : null;
+            impactedDriverIds.add(driverId);
-            String newPlate = update.getPlateNumber();
+            if (oldDriver != null) {
-            if (!StringUtils.equals(oldPlate, newPlate)) {
+                impactedDriverIds.addAll(findOtherDriversBoundToVehicles(companyId, splitCsv(oldDriver.getVehicleId()), driverId));
-                // 1. 如果旧车牌存在，从旧车辆的当前驾驶员列表中移除当前司机
-                if (StringUtils.isNotBlank(oldPlate)) {
-                    HotVehicle oldVehicle = vehicleMapper.selectOne(new LambdaQueryWrapper<HotVehicle>()
-                        .eq(HotVehicle::getPlateNumber, oldPlate)
-                        .eq(HotVehicle::getCompanyId, update.getCompanyId()));
-                    
-                    if (oldVehicle != null && StringUtils.isNotBlank(oldVehicle.getCurrentDriver())) {
-                        List<String> driverList = new ArrayList<>(Arrays.asList(oldVehicle.getCurrentDriver().split(",")));
-                        if (driverList.remove(driverId)) {
-                            String newDriverStr = String.join(",", driverList);
-                            // 如果结果为空字符串，设为null或空
-                            vehicleMapper.update(null,
-                                new LambdaUpdateWrapper<HotVehicle>()
-                                    .set(HotVehicle::getCurrentDriver, StringUtils.isBlank(newDriverStr) ? null : newDriverStr)
-                                    .eq(HotVehicle::getId, oldVehicle.getId()));
-                        }
-                    }
             }
 
-                // 2. 如果新车牌存在，将当前司机追加到新车辆的当前驾驶员列表
+            boolean bindingSpecified = bo.getVehicleId() != null || bo.getPlateNumber() != null;
-                if (StringUtils.isNotBlank(newPlate)) {
+            if (bindingSpecified) {
-                    HotVehicle newVehicle = vehicleMapper.selectOne(new LambdaQueryWrapper<HotVehicle>()
+                List<HotVehicle> targetVehicles = resolveDriverTargetVehicles(bo, companyId);
-                        .eq(HotVehicle::getPlateNumber, newPlate)
+                impactedDriverIds.addAll(syncVehicleBindingsForDriver(driverId, companyId, targetVehicles));
-                        .eq(HotVehicle::getCompanyId, update.getCompanyId()));
+            }
 
-                    if (newVehicle != null) {
+            syncDriverVehicleRelationsByDriverIds(companyId, impactedDriverIds);
-                        String currentDriverStr = newVehicle.getCurrentDriver();
-                        List<String> driverList = StringUtils.isBlank(currentDriverStr) 
-                            ? new ArrayList<>() 
-                            : new ArrayList<>(Arrays.asList(currentDriverStr.split(",")));
-                            
-                        // 避免重复添加
-                        if (!driverList.contains(driverId)) {
-                            driverList.add(driverId);
-                            String newDriverStr = String.join(",", driverList);
-                            vehicleMapper.update(null,
-                                new LambdaUpdateWrapper<HotVehicle>()
-                                    .set(HotVehicle::getCurrentDriver, newDriverStr)
-                                    .eq(HotVehicle::getId, newVehicle.getId()));
-                        }
-                    }
-                }
-            }
 
             // 同步最新的驾驶员信息到用户表（包含状态变更、基本信息变更）
             HotDriver newDriver = baseMapper.selectById(driverId);
@@ -933,6 +899,168 @@ public class HotDriverServiceImpl implements IHotDriverService {
         }
     }
 
+    private List<HotVehicle> resolveDriverTargetVehicles(HotDriverBo bo, Long companyId) {
+        List<String> vehicleIds = splitCsv(bo.getVehicleId());
+        if (CollUtil.isNotEmpty(vehicleIds)) {
+            List<HotVehicle> vehicles = vehicleMapper.selectList(Wrappers.<HotVehicle>lambdaQuery()
+                    .eq(HotVehicle::getCompanyId, companyId)
+                    .in(HotVehicle::getId, vehicleIds)
+                    .eq(HotVehicle::getIsDeleted, 0L));
+            validateVehicleSelection(vehicleIds, vehicles, true);
+            return vehicles;
+        }
+
+        List<String> plateNumbers = splitCsv(bo.getPlateNumber());
+        if (CollUtil.isEmpty(plateNumbers)) {
+            return new ArrayList<>();
+        }
+        List<HotVehicle> vehicles = vehicleMapper.selectList(Wrappers.<HotVehicle>lambdaQuery()
+                .eq(HotVehicle::getCompanyId, companyId)
+                .in(HotVehicle::getPlateNumber, plateNumbers)
+                .eq(HotVehicle::getIsDeleted, 0L));
+        validateVehicleSelection(plateNumbers, vehicles, false);
+        return vehicles;
+    }
+
+    private void validateVehicleSelection(List<String> expectedValues, List<HotVehicle> vehicles, boolean useVehicleId) {
+        Set<String> actualValues = vehicles.stream()
+                .map(vehicle -> useVehicleId ? vehicle.getId() : vehicle.getPlateNumber())
+                .filter(StringUtils::isNotBlank)
+                .collect(Collectors.toSet());
+        List<String> missingValues = expectedValues.stream()
+                .filter(value -> !actualValues.contains(value))
+                .collect(Collectors.toList());
+        if (CollUtil.isNotEmpty(missingValues)) {
+            throw new ServiceException(useVehicleId
+                    ? "存在未找到的车辆ID：" + String.join(",", missingValues)
+                    : "存在未找到的车牌号：" + String.join(",", missingValues));
+        }
+    }
+
+    private Set<String> syncVehicleBindingsForDriver(String driverId, Long companyId, List<HotVehicle> targetVehicles) {
+        Set<String> impactedDriverIds = new LinkedHashSet<>();
+        impactedDriverIds.add(driverId);
+        if (StringUtils.isBlank(driverId) || companyId == null) {
+            return impactedDriverIds;
+        }
+
+        Set<String> targetVehicleIds = targetVehicles.stream()
+                .map(HotVehicle::getId)
+                .filter(StringUtils::isNotBlank)
+                .collect(Collectors.toCollection(LinkedHashSet::new));
+        List<HotVehicle> companyVehicles = vehicleMapper.selectList(Wrappers.<HotVehicle>lambdaQuery()
+                .eq(HotVehicle::getCompanyId, companyId)
+                .eq(HotVehicle::getIsDeleted, 0L));
+
+        for (HotVehicle vehicle : companyVehicles) {
+            List<String> currentDrivers = splitCsv(vehicle.getCurrentDriver());
+            boolean currentlyBoundToDriver = currentDrivers.contains(driverId);
+            boolean shouldBindToDriver = targetVehicleIds.contains(vehicle.getId());
+
+            if (!currentlyBoundToDriver && !shouldBindToDriver) {
+                continue;
+            }
+
+            if (shouldBindToDriver) {
+                impactedDriverIds.addAll(currentDrivers);
+                if (!currentlyBoundToDriver || currentDrivers.size() != 1) {
+                    vehicleMapper.update(null, new LambdaUpdateWrapper<HotVehicle>()
+                            .set(HotVehicle::getCurrentDriver, driverId)
+                            .eq(HotVehicle::getId, vehicle.getId())
+                            .eq(HotVehicle::getCompanyId, companyId));
+                }
+                continue;
+            }
+
+            List<String> remainingDrivers = new ArrayList<>(currentDrivers);
+            remainingDrivers.removeIf(driverId::equals);
+            impactedDriverIds.addAll(remainingDrivers);
+            vehicleMapper.update(null, new LambdaUpdateWrapper<HotVehicle>()
+                    .set(HotVehicle::getCurrentDriver, normalizeSingleBindingValue(remainingDrivers))
+                    .eq(HotVehicle::getId, vehicle.getId())
+                    .eq(HotVehicle::getCompanyId, companyId));
+        }
+        return impactedDriverIds;
+    }
+
+    private Set<String> findOtherDriversBoundToVehicles(Long companyId, Collection<String> vehicleIds, String excludeDriverId) {
+        Set<String> driverIds = new LinkedHashSet<>();
+        if (companyId == null || CollUtil.isEmpty(vehicleIds)) {
+            return driverIds;
+        }
+        List<HotVehicle> vehicles = vehicleMapper.selectList(Wrappers.<HotVehicle>lambdaQuery()
+                .eq(HotVehicle::getCompanyId, companyId)
+                .in(HotVehicle::getId, vehicleIds)
+                .eq(HotVehicle::getIsDeleted, 0L));
+        for (HotVehicle vehicle : vehicles) {
+            for (String driverId : splitCsv(vehicle.getCurrentDriver())) {
+                if (!StringUtils.equals(driverId, excludeDriverId)) {
+                    driverIds.add(driverId);
+                }
+            }
+        }
+        return driverIds;
+    }
+
+    private void syncDriverVehicleRelationsByDriverIds(Long companyId, Collection<String> driverIds) {
+        if (companyId == null || CollUtil.isEmpty(driverIds)) {
+            return;
+        }
+        List<HotVehicle> vehicles = vehicleMapper.selectList(Wrappers.<HotVehicle>lambdaQuery()
+                .eq(HotVehicle::getCompanyId, companyId)
+                .eq(HotVehicle::getIsDeleted, 0L));
+        for (String driverId : driverIds) {
+            if (StringUtils.isBlank(driverId)) {
+                continue;
+            }
+            List<String> vehicleIds = new ArrayList<>();
+            List<String> plateNumbers = new ArrayList<>();
+            for (HotVehicle vehicle : vehicles) {
+                if (!splitCsv(vehicle.getCurrentDriver()).contains(driverId)) {
+                    continue;
+                }
+                vehicleIds.add(vehicle.getId());
+                plateNumbers.add(vehicle.getPlateNumber());
+            }
+            driverMapper.update(null, new LambdaUpdateWrapper<HotDriver>()
+                    .set(HotDriver::getVehicleId, joinCsv(vehicleIds))
+                    .set(HotDriver::getPlateNumber, joinCsv(plateNumbers))
+                    .eq(HotDriver::getId, driverId)
+                    .eq(HotDriver::getCompanyId, companyId));
+        }
+    }
+
+    private List<String> splitCsv(String value) {
+        if (StringUtils.isBlank(value)) {
+            return new ArrayList<>();
+        }
+        return Arrays.stream(value.split(","))
+                .map(String::trim)
+                .filter(StringUtils::isNotBlank)
+                .distinct()
+                .collect(Collectors.toList());
+    }
+
+    private String joinCsv(Collection<String> values) {
+        if (CollUtil.isEmpty(values)) {
+            return null;
+        }
+        return values.stream()
+                .filter(StringUtils::isNotBlank)
+                .distinct()
+                .collect(Collectors.joining(","));
+    }
+
+    private String normalizeSingleBindingValue(Collection<String> values) {
+        if (CollUtil.isEmpty(values)) {
+            return null;
+        }
+        return values.stream()
+                .filter(StringUtils::isNotBlank)
+                .findFirst()
+                .orElse(null);
+    }
+
     /**
      * 保存驾驶员家庭成员
      */
@@ -997,6 +1125,25 @@ public class HotDriverServiceImpl implements IHotDriverService {
             return;
         }
 
+        Set<String> impactedDriverIds = new LinkedHashSet<>();
+        impactedDriverIds.add(driverId);
+        List<HotVehicle> vehicles = vehicleMapper.selectList(Wrappers.<HotVehicle>lambdaQuery()
+                .eq(HotVehicle::getCompanyId, companyId)
+                .eq(HotVehicle::getIsDeleted, 0L));
+        for (HotVehicle vehicle : vehicles) {
+            List<String> driverIds = splitCsv(vehicle.getCurrentDriver());
+            if (!driverIds.contains(driverId)) {
+                continue;
+            }
+            driverIds.removeIf(driverId::equals);
+            impactedDriverIds.addAll(driverIds);
+            vehicleMapper.update(null, new LambdaUpdateWrapper<HotVehicle>()
+                    .set(HotVehicle::getCurrentDriver, normalizeSingleBindingValue(driverIds))
+                    .eq(HotVehicle::getId, vehicle.getId())
+                    .eq(HotVehicle::getCompanyId, companyId));
+        }
+        syncDriverVehicleRelationsByDriverIds(companyId, impactedDriverIds);
+
         // 2. 将该驾驶员从所有组中移除
         // 查找包含该驾驶员的所有组
         List<HotDriverGroup> groups = groupMapper.selectList(

src/main/java/com/hotwj/platform/resourceManagement/vehicleChange/service/impl/HotVehicleChangeServiceImpl.java

@@ -165,13 +165,48 @@ public class HotVehicleChangeServiceImpl implements IHotVehicleChangeService {
                     .filter(StringUtils::isNotBlank)
                     .collect(Collectors.toList());
             if (!driverIds.isEmpty()) {
+                for (String driverId : driverIds) {
+                    recalculateDriverVehicleRelations(driverId, bo.getCompanyId());
+                }
+            }
+        }
+    }
+
+    private void recalculateDriverVehicleRelations(String driverId, Long companyId) {
+        if (StringUtils.isBlank(driverId) || companyId == null) {
+            return;
+        }
+        List<HotVehicle> vehicles = vehicleMapper.selectList(Wrappers.<HotVehicle>lambdaQuery()
+                .eq(HotVehicle::getCompanyId, companyId)
+                .eq(HotVehicle::getIsDeleted, 0L));
+        List<String> vehicleIds = new ArrayList<>();
+        List<String> plateNumbers = new ArrayList<>();
+        for (HotVehicle item : vehicles) {
+            List<String> currentDrivers = Arrays.stream(StringUtils.defaultString(item.getCurrentDriver()).split(","))
+                    .map(String::trim)
+                    .filter(StringUtils::isNotBlank)
+                    .collect(Collectors.toList());
+            if (!currentDrivers.contains(driverId)) {
+                continue;
+            }
+            vehicleIds.add(item.getId());
+            plateNumbers.add(item.getPlateNumber());
+        }
         driverMapper.update(null, new LambdaUpdateWrapper<HotDriver>()
-                        .set(HotDriver::getVehicleId, null)
+                .set(HotDriver::getVehicleId, joinCsv(vehicleIds))
-                        .set(HotDriver::getPlateNumber, null)
+                .set(HotDriver::getPlateNumber, joinCsv(plateNumbers))
-                        .in(HotDriver::getId, driverIds)
+                .eq(HotDriver::getId, driverId)
-                        .eq(HotDriver::getCompanyId, bo.getCompanyId()));
+                .eq(HotDriver::getCompanyId, companyId));
     }
+
+    private String joinCsv(Collection<String> values) {
+        if (values == null || values.isEmpty()) {
+            return null;
         }
+        return values.stream()
+                .filter(StringUtils::isNotBlank)
+                .distinct()
+                .collect(Collectors.joining(","));
     }
 
     /**

src/main/java/com/hotwj/platform/resourceManagement/vehicleManagement/service/impl/HotVehicleServiceImpl.java

@@ -501,10 +501,14 @@ public class HotVehicleServiceImpl implements IHotVehicleService {
     @Override
     @Transactional(rollbackFor = Exception.class)
     public Boolean updateByBo(HotVehicleBo bo) {
+        validateSingleCurrentDriverBinding(bo.getCurrentDriver());
         // 获取旧数据用于比对
         HotVehicle oldVehicle = baseMapper.selectById(bo.getId());
 
         HotVehicle update = MapstructUtils.convert(bo, HotVehicle.class);
+        String normalizedCurrentDriver = normalizeSingleBindingValue(update.getCurrentDriver());
+        update.setCurrentDriver(normalizedCurrentDriver);
+        bo.setCurrentDriver(normalizedCurrentDriver);
         if (update.getOperationStatus() != null && CLEAR_DRIVER_OPERATION_STATUS.contains(update.getOperationStatus())) {
             update.setCurrentDriver(null);
             bo.setCurrentDriver(null);
@@ -515,60 +519,14 @@ public class HotVehicleServiceImpl implements IHotVehicleService {
         String vehicleId = update.getId();
         Long companyId = update.getCompanyId();
 
-        // 处理驾驶员变更：同步驾驶员信息的车牌号
+        // 处理驾驶员变更：车辆侧只允许单个驾驶员，驾驶员侧回写多车列表
-        String oldDriverId = oldVehicle != null ? oldVehicle.getCurrentDriver() : null;
+        List<String> oldDriverIds = splitCsv(oldVehicle != null ? oldVehicle.getCurrentDriver() : null);
-        String newDriverId = update.getCurrentDriver();
+        List<String> newDriverIds = splitCsv(update.getCurrentDriver());
+        String oldDriverId = oldDriverIds.isEmpty() ? null : oldDriverIds.get(0);
+        String newDriverId = newDriverIds.isEmpty() ? null : newDriverIds.get(0);
         String oldPlate = oldVehicle != null ? oldVehicle.getPlateNumber() : null;
         String newPlate = update.getPlateNumber();
-
+        boolean bindingChanged = !oldDriverIds.equals(newDriverIds) || !StringUtils.equals(oldPlate, newPlate);
-        // 如果驾驶员发生变化 或 车牌号发生变化
-        if (!StringUtils.equals(oldDriverId, newDriverId) || !StringUtils.equals(oldPlate, newPlate)) {
-            List<String> oldDrivers = StringUtils.isBlank(oldDriverId) ? new ArrayList<>() : Arrays.asList(oldDriverId.split(","));
-            List<String> newDrivers = StringUtils.isBlank(newDriverId) ? new ArrayList<>() : Arrays.asList(newDriverId.split(","));
-
-            // 1. 处理移除的驾驶员 (在旧列表中但不在新列表中 -> 清除车牌关联)
-            List<String> removedDrivers = oldDrivers.stream()
-                .filter(d -> !newDrivers.contains(d))
-                .collect(Collectors.toList());
-            
-            if (CollUtil.isNotEmpty(removedDrivers)) {
-                driverMapper.update(null,
-                    new LambdaUpdateWrapper<HotDriver>()
-                        .set(HotDriver::getPlateNumber, null)
-                        .set(HotDriver::getVehicleId, null)
-                        .in(HotDriver::getId, removedDrivers)
-                        .eq(HotDriver::getCompanyId, companyId));
-            }
-
-            // 2. 处理当前的驾驶员 (无论是新增的还是保留的，都统一更新为当前车辆信息)
-            if (CollUtil.isNotEmpty(newDrivers)) {
-                driverMapper.update(null,
-                    new LambdaUpdateWrapper<HotDriver>()
-                        .set(HotDriver::getPlateNumber, newPlate)
-                        .set(HotDriver::getVehicleId, vehicleId)
-                        .in(HotDriver::getId, newDrivers)
-                        .eq(HotDriver::getCompanyId, companyId));
-                // 2.1 对新增绑定的驾驶员发送系统消息
-                List<String> addedDrivers = newDrivers.stream()
-                        .filter(d -> !oldDrivers.contains(d))
-                        .collect(Collectors.toList());
-                if (CollUtil.isNotEmpty(addedDrivers) && StringUtils.isNotBlank(newPlate)) {
-                    HotSystemNotificationGroupBo bos = new HotSystemNotificationGroupBo();
-                    bos.setLevel("普通");
-                    bos.setContent("您已经绑定车辆【" + newPlate + "】。");
-                    bos.setSourceType("驾驶员管理");
-                    bos.setSenderType("SYSTEM");
-                    bos.setReceiverType("驾驶员");
-                    bos.setReceiverIds(addedDrivers);
-                    bos.setIsDeleted(0L);
-                    try {
-                        notificationService.insertByBo(bos);
-                    } catch (Exception e) {
-                        log.warn("发送驾驶员绑定车辆通知失败 companyId={} vehicleId={} plate={}", companyId, vehicleId, newPlate, e);
-                    }
-                }
-            }
-        }
 
         // 更新合同信息
         if (CollUtil.isNotEmpty(bo.getVehicleContracts())) {
@@ -643,6 +601,29 @@ public class HotVehicleServiceImpl implements IHotVehicleService {
         }
 
         if (flag) {
+            if (bindingChanged && companyId != null) {
+                Set<String> impactedDriverIds = new LinkedHashSet<>();
+                impactedDriverIds.addAll(oldDriverIds);
+                impactedDriverIds.addAll(newDriverIds);
+                syncDriverVehicleRelationsByDriverIds(companyId, impactedDriverIds);
+            }
+
+            if (StringUtils.isNotBlank(newDriverId) && !oldDriverIds.contains(newDriverId) && StringUtils.isNotBlank(newPlate)) {
+                HotSystemNotificationGroupBo bos = new HotSystemNotificationGroupBo();
+                bos.setLevel("普通");
+                bos.setContent("您已经绑定车辆【" + newPlate + "】。");
+                bos.setSourceType("驾驶员管理");
+                bos.setSenderType("SYSTEM");
+                bos.setReceiverType("驾驶员");
+                bos.setReceiverIds(Collections.singletonList(newDriverId));
+                bos.setIsDeleted(0L);
+                try {
+                    notificationService.insertByBo(bos);
+                } catch (Exception e) {
+                    log.warn("发送驾驶员绑定车辆通知失败 companyId={} vehicleId={} plate={}", companyId, vehicleId, newPlate, e);
+                }
+            }
+
             Long oldVehicleStatus = oldVehicle != null ? oldVehicle.getVehicleStatus() : null;
             Long newVehicleStatus = update.getVehicleStatus();
             Long oldOperationStatus = oldVehicle != null ? oldVehicle.getOperationStatus() : null;
@@ -723,6 +704,66 @@ public class HotVehicleServiceImpl implements IHotVehicleService {
         }
     }
 
+    private void validateSingleCurrentDriverBinding(String currentDriver) {
+        if (splitCsv(currentDriver).size() > 1) {
+            throw new ServiceException("一辆车只能绑定一个驾驶员");
+        }
+    }
+
+    private String normalizeSingleBindingValue(String value) {
+        List<String> values = splitCsv(value);
+        return values.isEmpty() ? null : values.get(0);
+    }
+
+    private List<String> splitCsv(String value) {
+        if (StringUtils.isBlank(value)) {
+            return new ArrayList<>();
+        }
+        return Arrays.stream(value.split(","))
+                .map(String::trim)
+                .filter(StringUtils::isNotBlank)
+                .distinct()
+                .collect(Collectors.toList());
+    }
+
+    private String joinCsv(Collection<String> values) {
+        if (CollUtil.isEmpty(values)) {
+            return null;
+        }
+        return values.stream()
+                .filter(StringUtils::isNotBlank)
+                .distinct()
+                .collect(Collectors.joining(","));
+    }
+
+    private void syncDriverVehicleRelationsByDriverIds(Long companyId, Collection<String> driverIds) {
+        if (companyId == null || CollUtil.isEmpty(driverIds)) {
+            return;
+        }
+        List<HotVehicle> vehicles = baseMapper.selectList(Wrappers.<HotVehicle>lambdaQuery()
+                .eq(HotVehicle::getCompanyId, companyId)
+                .eq(HotVehicle::getIsDeleted, 0L));
+        for (String driverId : driverIds) {
+            if (StringUtils.isBlank(driverId)) {
+                continue;
+            }
+            List<String> vehicleIds = new ArrayList<>();
+            List<String> plateNumbers = new ArrayList<>();
+            for (HotVehicle vehicle : vehicles) {
+                if (!splitCsv(vehicle.getCurrentDriver()).contains(driverId)) {
+                    continue;
+                }
+                vehicleIds.add(vehicle.getId());
+                plateNumbers.add(vehicle.getPlateNumber());
+            }
+            driverMapper.update(null, new LambdaUpdateWrapper<HotDriver>()
+                    .set(HotDriver::getVehicleId, joinCsv(vehicleIds))
+                    .set(HotDriver::getPlateNumber, joinCsv(plateNumbers))
+                    .eq(HotDriver::getId, driverId)
+                    .eq(HotDriver::getCompanyId, companyId));
+        }
+    }
+
     /**
      * 校验并批量删除公司车辆信息信息
      *

src/main/java/com/hotwj/platform/securityManagement/hiddenDangerInspection/service/impl/HotHiddenDangerInspectionServiceImpl.java

@@ -91,7 +91,7 @@ public class HotHiddenDangerInspectionServiceImpl implements IHotHiddenDangerIns
         if (isDriver) {
             HotDriver driver = DriverLoginContextHelper.getCurrentDriver();
             driverId = driver.getId();
-            vehicleId = driver.getVehicleId();
+            vehicleId = firstCsvValue(driver.getVehicleId());
         }
         String currentMonth = YearMonth.now().toString();
         Page<HotHiddenDangerInspectionVo> page = pageQuery.build();
@@ -109,6 +109,19 @@ public class HotHiddenDangerInspectionServiceImpl implements IHotHiddenDangerIns
         return TableDataInfo.build(page);
     }
 
+    private String firstCsvValue(String value) {
+        if (StringUtils.isBlank(value)) {
+            return null;
+        }
+        for (String item : value.split(",")) {
+            String trimmed = StringUtils.trim(item);
+            if (StringUtils.isNotBlank(trimmed)) {
+                return trimmed;
+            }
+        }
+        return null;
+    }
+
     /**
      * 查询符合条件的隐患排查-排查项目列表
      *

src/main/java/org/dromara/system/controller/system/SysUserController.java

@@ -206,7 +206,7 @@ public class SysUserController extends BaseController {
                 if (StringUtils.isNotBlank(user.getBusinessUserId())) {
                     HotDriverVo driver = hotDriverService.queryById(user.getBusinessUserId());
                     if (driver != null) {
-                        user.setVehicleId(driver.getVehicleId());
+                        user.setVehicleId(firstCsvValue(driver.getVehicleId()));
                         user.setDriverAuditStatus(String.valueOf(driver.getAuditStatus()));
                         user.setHasFaceInitialPhoto(StringUtils.isNotBlank(driver.getPortraitUrl()));
                         user.setUserName(driver.getName());
@@ -237,6 +237,19 @@ public class SysUserController extends BaseController {
         return R.ok(userInfoVo);
     }
 
+    private String firstCsvValue(String value) {
+        if (StringUtils.isBlank(value)) {
+            return null;
+        }
+        for (String item : value.split(",")) {
+            String trimmed = StringUtils.trim(item);
+            if (StringUtils.isNotBlank(trimmed)) {
+                return trimmed;
+            }
+        }
+        return null;
+    }
+
     private byte[] compressImage(MultipartFile file) throws Exception {
         java.awt.image.BufferedImage src = javax.imageio.ImageIO.read(file.getInputStream());
         if (src == null) {