|
|
@@ -66,6 +66,7 @@ import org.apache.commons.collections4.MapUtils;
|
|
|
import org.apache.commons.lang3.StringUtils;
|
|
|
import org.apache.dubbo.config.annotation.DubboReference;
|
|
|
import org.jetbrains.annotations.NotNull;
|
|
|
+import org.springframework.beans.BeanUtils;
|
|
|
import org.springframework.scheduling.annotation.Async;
|
|
|
import org.springframework.stereotype.Service;
|
|
|
|
|
|
@@ -857,59 +858,141 @@ public class kwfTruckTraceService {
|
|
|
* @param req 查询请求
|
|
|
* @return 车辆下拉列表
|
|
|
*/
|
|
|
- public List<TruckSelectVo> getTruckSelectList(TruckSelectReq req) {
|
|
|
- log.info("查询车辆下拉列表参数：{}", JSON.toJSONString( req));
|
|
|
- Long entId = LoginUserHolder.getEntId();
|
|
|
- //根据企业查询物流订单
|
|
|
- List<KwtLogisticsOrderUnit> kwtLogisticsOrderUnits = kwtLogisticsOrderUnitRepository.queryByEntId(entId);
|
|
|
- if (CollUtil.isEmpty(kwtLogisticsOrderUnits)) {
|
|
|
- log.info("该企业未查询到物流订单数据，企业id:{}", entId);
|
|
|
- return List.of();
|
|
|
- }
|
|
|
- //获取物流订单号
|
|
|
- Set<Long> logOrderIds = kwtLogisticsOrderUnits.stream()
|
|
|
- .map(KwtLogisticsOrderUnit::getLOrderId)
|
|
|
- .collect(Collectors.toSet());
|
|
|
- if (CollUtil.isEmpty(logOrderIds)) {
|
|
|
- log.info("该企业下物流订单数据，企业id:{}", entId);
|
|
|
- return List.of();
|
|
|
- }
|
|
|
- //查询子运单
|
|
|
- List<KwtWaybillOrderSubtask> kwtWaybillOrderSubtasks = waybillOrderSubtaskDao.selectList(Wrappers.<KwtWaybillOrderSubtask>lambdaQuery()
|
|
|
- .in(KwtWaybillOrderSubtask::getLOrderId, logOrderIds)
|
|
|
- .eq(BaseModel::getDelFlag, 0));
|
|
|
- if(org.apache.commons.collections4.CollectionUtils.isEmpty(kwtWaybillOrderSubtasks)){
|
|
|
- log.info("该企业下子运单的订单数据不存在，企业id:{}", entId);
|
|
|
- return List.of();
|
|
|
- }
|
|
|
- Set<Long> wayOrderIds = kwtWaybillOrderSubtasks.stream()
|
|
|
- .map(KwtWaybillOrderSubtask::getWOrderId)
|
|
|
- .collect(Collectors.toSet());
|
|
|
- // 使用 Repository 查询车辆运单数据
|
|
|
- List<KwtWaybillOrder> waybillOrders = kwtWaybillOrderRepository.selectTruckListForSelect(req.getTruckNo(),wayOrderIds,req.getWaybillOrderNo());
|
|
|
-
|
|
|
- if (CollectionUtils.isEmpty(waybillOrders)) {
|
|
|
- return new ArrayList<>();
|
|
|
- }
|
|
|
-
|
|
|
- // 获取所有车牌号列表，用于查询实时位置
|
|
|
+public List<TruckSelectVo> getTruckSelectList(TruckSelectReq req) {
|
|
|
+ // 参数校验
|
|
|
+ if (req == null) {
|
|
|
+ log.warn("查询车辆下拉列表参数为空");
|
|
|
+ return Collections.emptyList();
|
|
|
+ }
|
|
|
|
|
|
- Map<Long, String> truckIdTruckNoMap = waybillOrders.stream()
|
|
|
- .filter(x->Objects.nonNull(x.getTruckId()))
|
|
|
- .collect(Collectors.toMap(KwtWaybillOrder::getTruckId, KwtWaybillOrder::getTruckNo, (key1, key2) -> key1));
|
|
|
+ log.info("查询车辆下拉列表参数：{}", JSON.toJSONString(req));
|
|
|
|
|
|
- // 批量查询实时位置状态（30分钟内有数据为在线）
|
|
|
- Map<String, Integer> truckLocationStatusMap = getStringIntegerMap(truckIdTruckNoMap);
|
|
|
+ // 获取当前企业ID
|
|
|
+ Long entId = LoginUserHolder.getEntId();
|
|
|
|
|
|
- // 转换为 VO 对象并根据状态筛选
|
|
|
- return waybillOrders.stream()
|
|
|
- .map(order -> getTruckSelectVo(order, truckLocationStatusMap))
|
|
|
- // 根据请求参数筛选定位状态
|
|
|
- .filter(vo -> req.getLocationStatus() == null || vo.getLocationStatus().equals(req.getLocationStatus()))
|
|
|
- .sorted(Comparator.comparing(TruckSelectVo::getLocationStatus).reversed())
|
|
|
- .collect(Collectors.toList());
|
|
|
+ // 获取物流订单ID集合
|
|
|
+ Set<Long> logOrderIds = getLogisticsOrderIds(entId);
|
|
|
+ if (CollUtil.isEmpty(logOrderIds)) {
|
|
|
+ return Collections.emptyList();
|
|
|
+ }
|
|
|
+
|
|
|
+ // 获取运单ID集合
|
|
|
+ Set<Long> wayOrderIds = getWayOrderIds(logOrderIds);
|
|
|
+ if (CollectionUtils.isEmpty(wayOrderIds)) {
|
|
|
+ return Collections.emptyList();
|
|
|
+ }
|
|
|
+
|
|
|
+ // 查询车辆运单数据
|
|
|
+ List<KwtWaybillOrder> waybillOrders = queryWaybillOrders(req, wayOrderIds);
|
|
|
+ if (CollectionUtils.isEmpty(waybillOrders)) {
|
|
|
+ return Collections.emptyList();
|
|
|
+ }
|
|
|
+
|
|
|
+ // 获取车辆位置状态映射
|
|
|
+ Map<String, Integer> truckLocationStatusMap = getTruckLocationStatusMap(
|
|
|
+ getTruckIdTruckNoMap(waybillOrders));
|
|
|
+
|
|
|
+ // 转换为 VO 对象并根据状态筛选
|
|
|
+ Integer locationStatusFilter = req.getLocationStatus();
|
|
|
+
|
|
|
+ return waybillOrders.stream()
|
|
|
+ .map(order -> buildTruckSelectVo(order, truckLocationStatusMap))
|
|
|
+ // 根据请求参数筛选定位状态
|
|
|
+ .filter(vo -> locationStatusFilter == null || vo.getLocationStatus().equals(locationStatusFilter))
|
|
|
+ // 按定位状态降序排序
|
|
|
+ .sorted(Comparator.comparing(TruckSelectVo::getLocationStatus).reversed())
|
|
|
+ .collect(Collectors.toList());
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * 获取物流订单ID集合
|
|
|
+ */
|
|
|
+private Set<Long> getLogisticsOrderIds(Long entId) {
|
|
|
+ // 根据企业查询物流订单
|
|
|
+ List<KwtLogisticsOrderUnit> logisticsOrderUnits = kwtLogisticsOrderUnitRepository.queryByEntId(entId);
|
|
|
+ if (CollUtil.isEmpty(logisticsOrderUnits)) {
|
|
|
+ log.info("该企业未查询到物流订单数据，企业id:{}", entId);
|
|
|
+ return Collections.emptySet();
|
|
|
+ }
|
|
|
+
|
|
|
+ // 获取物流订单号
|
|
|
+ return logisticsOrderUnits.stream()
|
|
|
+ .map(KwtLogisticsOrderUnit::getLOrderId)
|
|
|
+ .filter(Objects::nonNull)
|
|
|
+ .collect(Collectors.toSet());
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * 获取运单ID集合
|
|
|
+ */
|
|
|
+private Set<Long> getWayOrderIds(Set<Long> logOrderIds) {
|
|
|
+ // 查询子运单
|
|
|
+ List<KwtWaybillOrderSubtask> waybillOrderSubtasks = waybillOrderSubtaskDao.selectList(
|
|
|
+ Wrappers.<KwtWaybillOrderSubtask>lambdaQuery()
|
|
|
+ .in(KwtWaybillOrderSubtask::getLOrderId, logOrderIds)
|
|
|
+ .eq(BaseModel::getDelFlag, 0));
|
|
|
+
|
|
|
+ if (CollectionUtils.isEmpty(waybillOrderSubtasks)) {
|
|
|
+ log.info("该企业下子运单的订单数据不存在，企业id:{}", LoginUserHolder.getEntId());
|
|
|
+ return Collections.emptySet();
|
|
|
}
|
|
|
|
|
|
+ return waybillOrderSubtasks.stream()
|
|
|
+ .map(KwtWaybillOrderSubtask::getWOrderId)
|
|
|
+ .filter(Objects::nonNull)
|
|
|
+ .collect(Collectors.toSet());
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * 查询车辆运单数据
|
|
|
+ */
|
|
|
+private List<KwtWaybillOrder> queryWaybillOrders(TruckSelectReq req, Set<Long> wayOrderIds) {
|
|
|
+ return kwtWaybillOrderRepository.selectTruckListForSelect(
|
|
|
+ req.getTruckNo(), wayOrderIds, req.getWaybillOrderNo());
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * 获取车辆ID和车牌号映射
|
|
|
+ */
|
|
|
+private Map<Long, String> getTruckIdTruckNoMap(List<KwtWaybillOrder> waybillOrders) {
|
|
|
+ return waybillOrders.stream()
|
|
|
+ .filter(order -> Objects.nonNull(order.getTruckId()))
|
|
|
+ .collect(Collectors.toMap(
|
|
|
+ KwtWaybillOrder::getTruckId,
|
|
|
+ KwtWaybillOrder::getTruckNo,
|
|
|
+ (key1, key2) -> key1));
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * 构建车辆选择VO
|
|
|
+ */
|
|
|
+private TruckSelectVo buildTruckSelectVo(KwtWaybillOrder order, Map<String, Integer> truckLocationStatusMap) {
|
|
|
+ TruckSelectVo vo = new TruckSelectVo();
|
|
|
+ BeanUtils.copyProperties(order, vo);
|
|
|
+
|
|
|
+ String truckNo = order.getTruckNo();
|
|
|
+ if (StringUtils.isNotBlank(truckNo) && truckLocationStatusMap != null) {
|
|
|
+ vo.setLocationStatus(truckLocationStatusMap.getOrDefault(truckNo, 0));
|
|
|
+ } else {
|
|
|
+ vo.setLocationStatus(0);
|
|
|
+ }
|
|
|
+
|
|
|
+ return vo;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * 获取车辆位置状态映射
|
|
|
+ */
|
|
|
+private Map<String, Integer> getTruckLocationStatusMap(Map<Long, String> truckIdTruckNoMap) {
|
|
|
+ if (MapUtils.isEmpty(truckIdTruckNoMap)) {
|
|
|
+ return Collections.emptyMap();
|
|
|
+ }
|
|
|
+
|
|
|
+ // 批量查询实时位置状态（30分钟内有数据为在线）
|
|
|
+ return getStringIntegerMap(truckIdTruckNoMap);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
@NotNull
|
|
|
private Map<String, Integer> getStringIntegerMap(Map<Long, String> truckIdTruckNoMap) {
|
|
|
Map<String, Integer> truckLocationStatusMap = new HashMap<>();
|
|
|
@@ -977,222 +1060,425 @@ public class kwfTruckTraceService {
|
|
|
* @param req 查询请求
|
|
|
* @return 分页结果
|
|
|
*/
|
|
|
+ /**
|
|
|
+ * 分页查询地图车辆列表
|
|
|
+ * @param req 查询请求参数，包括日期范围、状态、车牌号、承运单位、托运单位等筛选条件
|
|
|
+ * @return 分页结果，包含车辆在地图上的相关信息
|
|
|
+ */
|
|
|
public PageDataResult<MapVehicleVo> queryMapVehicleList(MapVehicleQueryReq req) {
|
|
|
+ // 打印查询参数日志
|
|
|
log.info("分页查询地图车辆列表参数：{}", req);
|
|
|
- Set<Long> allEnt = getAllEnt();
|
|
|
+
|
|
|
// 处理日期参数，默认为当天
|
|
|
Date startDate = getStartDate(req.getStartDate());
|
|
|
Date endDate = getEndDate(req.getEndDate());
|
|
|
|
|
|
- // 进行中任务状态：已接单(1)、到达装货点(5)、已装货(10)、已离场(15)
|
|
|
- List<Integer> taskingStatus = Lists.newArrayList();
|
|
|
- if (Objects.nonNull(req.getStatus())) {
|
|
|
- taskingStatus.add(req.getStatus());
|
|
|
- } else {
|
|
|
- taskingStatus.addAll(Arrays.asList(CarWaybillV1Enum.PENDING_VEHICLE.getCode(),CarWaybillV1Enum.WEIGHT_TRAFFIC.getCode(), CarWaybillV1Enum.REFUSE_TRAFFIC.getCode(),
|
|
|
- CarWaybillV1Enum.EXIT_COMPLETED.getCode(), CarWaybillV1Enum.WAIT_LOADING.getCode()));
|
|
|
- }
|
|
|
-
|
|
|
+ // 构建查询状态列表，如果未指定状态则查询任务中的订单
|
|
|
+ List<Integer> taskingStatus = buildTaskingStatus(req.getStatus());
|
|
|
+
|
|
|
// 前置条件：根据承运单位和托运单位筛选出符合条件的运单ID
|
|
|
- Set<Long> wayOrderIds = getWayOrderIds(req,allEnt);
|
|
|
- if (CollectionUtils.isEmpty(wayOrderIds) && (StringUtils.isNotBlank(req.getLogisticOrderNo()) || Objects.nonNull(req.getCarrierEntId()) || Objects.nonNull(req.getConsignEntId()) || Objects.nonNull(LoginUserHolder.getEntId()))) {
|
|
|
+ Set<Long> wayOrderIds = getWayOrderIds(req, getAllEnt());
|
|
|
+ // 如果没有符合条件的运单ID，直接返回空结果
|
|
|
+ if (shouldReturnEmptyResult(req, wayOrderIds)) {
|
|
|
return PageDataResult.empty(req.getPageNum(), req.getPageSize());
|
|
|
}
|
|
|
|
|
|
// 使用 MyBatis-Plus 分页查询（如果有前置筛选条件，则添加运单ID的IN条件）
|
|
|
-
|
|
|
+ // 根据日期范围、状态、运单ID、车牌号等条件查询运单信息
|
|
|
IPage<KwtWaybillOrder> page = kwtWaybillOrderRepository.queryMapVehicleListPage(startDate, endDate, taskingStatus, wayOrderIds,req.getTrackNo(), req.getPageNum(),req.getPageSize() );
|
|
|
|
|
|
List<KwtWaybillOrder> waybillOrders = page.getRecords();
|
|
|
if (CollectionUtils.isEmpty(waybillOrders)) {
|
|
|
return PageDataResult.empty(req.getPageNum(), req.getPageSize());
|
|
|
}
|
|
|
-
|
|
|
- // 获取运单ID列表
|
|
|
- List<Long> wOrderIds = waybillOrders.stream()
|
|
|
+
|
|
|
+ // 提取运单ID列表，用于后续批量查询
|
|
|
+ List<Long> wOrderIds = extractWOrderIds(waybillOrders);
|
|
|
+ // 提取车辆ID列表，用于查询车辆详细信息
|
|
|
+ List<Long> truckIds = extractTruckIds(waybillOrders);
|
|
|
+
|
|
|
+ // 批量查询相关数据，提高查询效率
|
|
|
+ Map<Long, RTruckVo> truckIdMap = batchQueryTruckInfo(truckIds);
|
|
|
+ // 批量查询子运单信息
|
|
|
+ Map<Long, KwtWaybillOrderSubtask> wOrderIdSubtaskMap = batchQuerySubtasks(wOrderIds);
|
|
|
+ // 从子运单信息中提取物流订单ID
|
|
|
+ Set<Long> lOrderIds = extractLOrderIds(wOrderIdSubtaskMap);
|
|
|
+
|
|
|
+ // 批量查询物流订单相关数据（单位、货物、地址、订单信息）
|
|
|
+ LogisticsOrderData logisticsOrderData = batchQueryLogisticsOrderData(lOrderIds);
|
|
|
+
|
|
|
+ // 批量查询定位和异常信息
|
|
|
+ Map<String, VehicleLocationInfo> locationInfoMap = batchQueryLocationInfo(waybillOrders);
|
|
|
+ Map<String, Integer> exceptionCountMap = batchQueryExceptionCount(waybillOrders);
|
|
|
+
|
|
|
+ // 获取字典数据，用于车辆能源类型转换
|
|
|
+ Map<String, SysDictResDto> energyTypeMap = getEnergyTypeMap();
|
|
|
+
|
|
|
+ // 根据定位状态筛选（在线/离线），如果未指定定位状态则不过滤
|
|
|
+ List<KwtWaybillOrder> filteredOrders = filterByLocationStatus(waybillOrders, locationInfoMap, req.getLocationStatus());
|
|
|
+
|
|
|
+ // 将查询结果转换为前端需要的VO对象
|
|
|
+ List<MapVehicleVo> result = convertToMapVehicleVos(
|
|
|
+ filteredOrders, wOrderIdSubtaskMap, logisticsOrderData,
|
|
|
+ locationInfoMap, exceptionCountMap, truckIdMap, energyTypeMap);
|
|
|
+ // 根据过滤后的结果创建新的分页对象，确保总数准确
|
|
|
+ Page<MapVehicleVo> filteredPage = new Page<>();
|
|
|
+ filteredPage.setCurrent(page.getCurrent());
|
|
|
+ filteredPage.setSize(page.getSize());
|
|
|
+ filteredPage.setTotal(filteredOrders.size()); // 使用过滤后的实际数量
|
|
|
+ filteredPage.setRecords(result);
|
|
|
+
|
|
|
+ // 返回分页结果（使用数据库分页的总数）
|
|
|
+ return PageDataResult.of(filteredPage, result);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 构建查询状态列表
|
|
|
+ */
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 构建查询状态列表
|
|
|
+ * 如果传入了具体状态，则只查询该状态；否则查询任务中（进行中）的订单状态列表
|
|
|
+ *
|
|
|
+ * @param status 传入的查询状态，如果为null则使用默认的任务中状态列表
|
|
|
+ * @return 状态码列表，用于数据库查询条件
|
|
|
+ */
|
|
|
+ private List<Integer> buildTaskingStatus(Integer status) {
|
|
|
+ if (Objects.nonNull(status)) {
|
|
|
+ // 如果指定了具体状态，只返回该状态的列表
|
|
|
+ return Collections.singletonList(status);
|
|
|
+ }
|
|
|
+ // 默认返回任务进行中的各种状态
|
|
|
+ return Arrays.asList(
|
|
|
+ CarWaybillV1Enum.PENDING_VEHICLE.getCode(), // 待提货
|
|
|
+ CarWaybillV1Enum.WEIGHT_TRAFFIC.getCode(), // 运输中（称重）
|
|
|
+ CarWaybillV1Enum.REFUSE_TRAFFIC.getCode(), // 拒绝运输
|
|
|
+ CarWaybillV1Enum.EXIT_COMPLETED.getCode(), // 出口完成
|
|
|
+ CarWaybillV1Enum.WAIT_LOADING.getCode() // 等待装货
|
|
|
+ );
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 判断是否应返回空结果
|
|
|
+ */
|
|
|
+ private boolean shouldReturnEmptyResult(MapVehicleQueryReq req, Set<Long> wayOrderIds) {
|
|
|
+ return CollectionUtils.isEmpty(wayOrderIds) &&
|
|
|
+ (StringUtils.isNotBlank(req.getLogisticOrderNo()) ||
|
|
|
+ Objects.nonNull(req.getCarrierEntId()) ||
|
|
|
+ Objects.nonNull(req.getConsignEntId()) ||
|
|
|
+ Objects.nonNull(LoginUserHolder.getEntId()));
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 提取运单ID列表
|
|
|
+ */
|
|
|
+ private List<Long> extractWOrderIds(List<KwtWaybillOrder> waybillOrders) {
|
|
|
+ return waybillOrders.stream()
|
|
|
.map(KwtWaybillOrder::getId)
|
|
|
.collect(Collectors.toList());
|
|
|
- //获取车辆id
|
|
|
- List<Long> truckIds = waybillOrders.stream()
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 提取车辆ID列表
|
|
|
+ */
|
|
|
+ private List<Long> extractTruckIds(List<KwtWaybillOrder> waybillOrders) {
|
|
|
+ return waybillOrders.stream()
|
|
|
.map(KwtWaybillOrder::getTruckId)
|
|
|
+ .filter(Objects::nonNull)
|
|
|
.distinct()
|
|
|
.collect(Collectors.toList());
|
|
|
- //根据车辆id获取车辆信息
|
|
|
- List<RTruckVo> truckVos = fleetService.findTruckByTruckIds(truckIds);
|
|
|
- Map<Long, RTruckVo> truckIdMap = new HashMap<>();
|
|
|
- if (CollectionUtils.isNotEmpty(truckVos)){
|
|
|
- // 构建车辆ID到车辆信息的映射
|
|
|
- truckIdMap = truckVos.stream()
|
|
|
- .filter(Objects::nonNull)
|
|
|
- .collect(Collectors.toMap(RTruckVo::getId, Function.identity(), (k1, k2) -> k1));
|
|
|
- }
|
|
|
+ }
|
|
|
|
|
|
- // 查询子运单信息
|
|
|
- List<KwtWaybillOrderSubtask> subtasks = kwtWaybillOrderSubtaskRepository.queryByWOrderIds(wOrderIds);
|
|
|
- Map<Long, KwtWaybillOrderSubtask> wOrderIdSubtaskMap;
|
|
|
- if (CollectionUtils.isNotEmpty(subtasks)) {
|
|
|
- wOrderIdSubtaskMap = subtasks.stream()
|
|
|
- .filter(subtask -> subtask.getWOrderId() != null)
|
|
|
- .collect(Collectors.toMap(KwtWaybillOrderSubtask::getWOrderId, Function.identity(), (k1, k2) -> k1));
|
|
|
- } else {
|
|
|
- wOrderIdSubtaskMap = new HashMap<>();
|
|
|
- }
|
|
|
-
|
|
|
- // 获取物流订单ID
|
|
|
- Set<Long> lOrderIds = new HashSet<>();
|
|
|
- if (CollectionUtils.isNotEmpty(subtasks)) {
|
|
|
- lOrderIds = subtasks.stream()
|
|
|
- .map(KwtWaybillOrderSubtask::getLOrderId)
|
|
|
- .filter(Objects::nonNull)
|
|
|
- .collect(Collectors.toSet());
|
|
|
+ /**
|
|
|
+ * 批量查询车辆信息
|
|
|
+ */
|
|
|
+ private Map<Long, RTruckVo> batchQueryTruckInfo(List<Long> truckIds) {
|
|
|
+ if (CollectionUtils.isEmpty(truckIds)) {
|
|
|
+ return Collections.emptyMap();
|
|
|
}
|
|
|
|
|
|
- List<KwtLogisticsOrderUnit> logisticsOrderUnits = Lists.newArrayList();
|
|
|
- List<KwtLogisticsOrderGoods> goodsList = Lists.newArrayList();
|
|
|
- List<KwtLogisticsOrderAddress> logisticsOrderAddress = Lists.newArrayList();
|
|
|
- Map<Long, KwtLogisticsOrder> logisticsOrderMap = Maps.newHashMap();
|
|
|
- if (CollectionUtils.isNotEmpty(lOrderIds)) {
|
|
|
- // 查询托运企业和承运企业
|
|
|
- logisticsOrderUnits = kwtLogisticsOrderUnitRepository.queryByLOrderIds(new ArrayList<>(lOrderIds));
|
|
|
- // 查询商品信息
|
|
|
- goodsList = kwtLogisticsOrderGoodsRepository.queryByLOrderIds(new ArrayList<>(lOrderIds));
|
|
|
- //查询物流地址
|
|
|
- logisticsOrderAddress = kwtLogisticsOrderAddressRepository.queryByLogOrderIds(new ArrayList<>(lOrderIds));
|
|
|
- List<KwtLogisticsOrder> kwtLogisticsOrders = kwtLogisticsOrderRepository.queryByLogisticsOrderIds(new ArrayList<>(lOrderIds));
|
|
|
- logisticsOrderMap = Optional.ofNullable(kwtLogisticsOrders)
|
|
|
- .orElse(List.of()).stream()
|
|
|
- .collect(Collectors.toMap(KwtLogisticsOrder::getId, Function.identity(), (k1, k2) -> k1));
|
|
|
+ List<RTruckVo> truckVos = fleetService.findTruckByTruckIds(truckIds);
|
|
|
+ if (CollectionUtils.isEmpty(truckVos)) {
|
|
|
+ return Collections.emptyMap();
|
|
|
}
|
|
|
- Map<String, KwtLogisticsOrderAddress> logisticsOrderAddressMap = Maps.newHashMap();
|
|
|
- if (CollectionUtils.isNotEmpty(logisticsOrderAddress)){
|
|
|
- logisticsOrderAddressMap = logisticsOrderAddress.stream()
|
|
|
- .collect(Collectors.toMap(x -> x.getLOrderId() + "_" + x.getAddressType(), Function.identity(), (k1, k2) -> k1));
|
|
|
+
|
|
|
+ return truckVos.stream()
|
|
|
+ .filter(Objects::nonNull)
|
|
|
+ .collect(Collectors.toMap(RTruckVo::getId, Function.identity(), (k1, k2) -> k1));
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 批量查询子运单信息
|
|
|
+ */
|
|
|
+ private Map<Long, KwtWaybillOrderSubtask> batchQuerySubtasks(List<Long> wOrderIds) {
|
|
|
+ if (CollectionUtils.isEmpty(wOrderIds)) {
|
|
|
+ return Collections.emptyMap();
|
|
|
}
|
|
|
-
|
|
|
- // 按物流订单ID和单位类型分组
|
|
|
- Map<String, KwtLogisticsOrderUnit> unitMap =new HashMap<>();
|
|
|
- if (CollectionUtils.isNotEmpty(logisticsOrderUnits)) {
|
|
|
- unitMap = logisticsOrderUnits.stream()
|
|
|
- .filter(unit -> unit.getLOrderId() != null && unit.getUnitType() != null)
|
|
|
- .collect(Collectors.toMap(
|
|
|
- unit -> unit.getLOrderId() + "_" + unit.getUnitType(),
|
|
|
- Function.identity(),
|
|
|
- (k1, k2) -> k1
|
|
|
- ));
|
|
|
+
|
|
|
+ List<KwtWaybillOrderSubtask> subtasks = kwtWaybillOrderSubtaskRepository.queryByWOrderIds(wOrderIds);
|
|
|
+ if (CollectionUtils.isEmpty(subtasks)) {
|
|
|
+ return Collections.emptyMap();
|
|
|
}
|
|
|
-
|
|
|
|
|
|
- Map<Long, KwtLogisticsOrderGoods> goodsMap =new HashMap<>();
|
|
|
- if (CollectionUtils.isNotEmpty(goodsList)) {
|
|
|
- goodsMap = goodsList.stream()
|
|
|
- .filter(goods -> goods.getLOrderId() != null)
|
|
|
- .collect(Collectors.toMap(KwtLogisticsOrderGoods::getLOrderId, Function.identity(), (k1, k2) -> k1));
|
|
|
+ return subtasks.stream()
|
|
|
+ .filter(subtask -> subtask.getWOrderId() != null)
|
|
|
+ .collect(Collectors.toMap(KwtWaybillOrderSubtask::getWOrderId, Function.identity(), (k1, k2) -> k1));
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 提取物流订单ID集合
|
|
|
+ */
|
|
|
+ private Set<Long> extractLOrderIds(Map<Long, KwtWaybillOrderSubtask> wOrderIdSubtaskMap) {
|
|
|
+ return wOrderIdSubtaskMap.values().stream()
|
|
|
+ .map(KwtWaybillOrderSubtask::getLOrderId)
|
|
|
+ .filter(Objects::nonNull)
|
|
|
+ .collect(Collectors.toSet());
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 批量查询物流订单相关数据
|
|
|
+ */
|
|
|
+ private LogisticsOrderData batchQueryLogisticsOrderData(Set<Long> lOrderIds) {
|
|
|
+ LogisticsOrderData data = new LogisticsOrderData();
|
|
|
+
|
|
|
+ if (CollectionUtils.isEmpty(lOrderIds)) {
|
|
|
+ return data;
|
|
|
}
|
|
|
-
|
|
|
- // 获取车牌号列表，查询定位信息
|
|
|
+
|
|
|
+ List<Long> lOrderIdList = new ArrayList<>(lOrderIds);
|
|
|
+
|
|
|
+ // 查询物流订单单位
|
|
|
+ data.setUnits(kwtLogisticsOrderUnitRepository.queryByLOrderIds(lOrderIdList));
|
|
|
+
|
|
|
+ // 查询商品信息
|
|
|
+ data.setGoods(kwtLogisticsOrderGoodsRepository.queryByLOrderIds(lOrderIdList));
|
|
|
+
|
|
|
+ // 查询物流地址
|
|
|
+ data.setAddresses(kwtLogisticsOrderAddressRepository.queryByLogOrderIds(lOrderIdList));
|
|
|
+
|
|
|
+ // 查询物流订单
|
|
|
+ List<KwtLogisticsOrder> logisticsOrders = kwtLogisticsOrderRepository.queryByLogisticsOrderIds(lOrderIdList);
|
|
|
+ data.setOrders(Optional.ofNullable(logisticsOrders)
|
|
|
+ .orElse(Collections.emptyList())
|
|
|
+ .stream()
|
|
|
+ .collect(Collectors.toMap(KwtLogisticsOrder::getId, Function.identity(), (k1, k2) -> k1)));
|
|
|
+
|
|
|
+ return data;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 批量查询定位信息
|
|
|
+ */
|
|
|
+ private Map<String, VehicleLocationInfo> batchQueryLocationInfo(List<KwtWaybillOrder> waybillOrders) {
|
|
|
Map<Long, String> truckIdAndTruckNoMap = waybillOrders.stream()
|
|
|
- .filter(x->Objects.nonNull(x.getTruckId()))
|
|
|
+ .filter(order -> Objects.nonNull(order.getTruckId()))
|
|
|
.collect(Collectors.toMap(KwtWaybillOrder::getTruckId, KwtWaybillOrder::getTruckNo, (k1, k2) -> k1));
|
|
|
|
|
|
- // 批量查询定位状态和位置信息
|
|
|
- Map<String, VehicleLocationInfo> locationInfoMap = queryVehicleLocationBatch(truckIdAndTruckNoMap);
|
|
|
+ return queryVehicleLocationBatch(truckIdAndTruckNoMap);
|
|
|
+ }
|
|
|
|
|
|
- // 批量查询运单轨迹数据，统计异常数量（通过alarmCode判断）
|
|
|
+ /**
|
|
|
+ * 批量查询异常数量
|
|
|
+ */
|
|
|
+ private Map<String, Integer> batchQueryExceptionCount(List<KwtWaybillOrder> waybillOrders) {
|
|
|
List<String> wOrderNos = waybillOrders.stream()
|
|
|
.map(KwtWaybillOrder::getWOrderNo)
|
|
|
.filter(Objects::nonNull)
|
|
|
.distinct()
|
|
|
.collect(Collectors.toList());
|
|
|
- Map<String, Integer> exceptionCountMap = countExceptionsByTraceData(wOrderNos);
|
|
|
-
|
|
|
- // 根据定位状态筛选（这个筛选保留在内存中，因为涉及外部服务调用）
|
|
|
- List<KwtWaybillOrder> filteredOrders = waybillOrders;
|
|
|
- if (req.getLocationStatus() != null) {
|
|
|
- filteredOrders = waybillOrders.stream()
|
|
|
- .filter(order -> {
|
|
|
- VehicleLocationInfo locationInfo = locationInfoMap.get(order.getTruckNo());
|
|
|
- return locationInfo != null && req.getLocationStatus().equals(locationInfo.getLocationStatus());
|
|
|
- })
|
|
|
- .collect(Collectors.toList());
|
|
|
- }
|
|
|
- //查询字段
|
|
|
+
|
|
|
+ return countExceptionsByTraceData(wOrderNos);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 获取能源类型字典
|
|
|
+ */
|
|
|
+ private Map<String, SysDictResDto> getEnergyTypeMap() {
|
|
|
List<SysDictResDto> sysDictResDtos = remoteSystemService.queryDictByType(DictTypeEnum.ENERGY_TYPE.getType());
|
|
|
- Map<String, SysDictResDto> energyTypeMap = new HashMap<>();
|
|
|
- if (CollectionUtils.isNotEmpty(sysDictResDtos)) {
|
|
|
- // 构建字典映射
|
|
|
- energyTypeMap = sysDictResDtos.stream()
|
|
|
- .collect(Collectors.toMap(SysDictResDto::getValue, Function.identity(), (k1, k2) -> k1));
|
|
|
- }
|
|
|
-
|
|
|
- // 转换为 VO
|
|
|
- Map<String, KwtLogisticsOrderUnit> finalUnitMap = unitMap;
|
|
|
- Map<Long, KwtLogisticsOrderGoods> finalGoodsMap = goodsMap;
|
|
|
- Map<Long, RTruckVo> finalTruckIdMap = truckIdMap;
|
|
|
- Map<String, SysDictResDto> finalEnergyTypeMap = energyTypeMap;
|
|
|
- Map<String, KwtLogisticsOrderAddress> finalLogisticsOrderAddressMap = logisticsOrderAddressMap;
|
|
|
- Map<Long, KwtLogisticsOrder> finalLogisticsOrderMap = logisticsOrderMap;
|
|
|
- List<MapVehicleVo> result = filteredOrders.stream()
|
|
|
- .map(order -> buildMapVehicleVo(order, wOrderIdSubtaskMap, finalUnitMap, finalGoodsMap,
|
|
|
- locationInfoMap, exceptionCountMap, finalTruckIdMap, finalEnergyTypeMap, finalLogisticsOrderAddressMap, finalLogisticsOrderMap))
|
|
|
+ if (CollectionUtils.isEmpty(sysDictResDtos)) {
|
|
|
+ return Collections.emptyMap();
|
|
|
+ }
|
|
|
+
|
|
|
+ return sysDictResDtos.stream()
|
|
|
+ .collect(Collectors.toMap(SysDictResDto::getValue, Function.identity(), (k1, k2) -> k1));
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 根据定位状态筛选
|
|
|
+ */
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 根据定位状态筛选运单订单
|
|
|
+ *
|
|
|
+ * @param waybillOrders 运单订单列表
|
|
|
+ * @param locationInfoMap 车辆位置信息映射，key为车牌号，value为位置信息
|
|
|
+ * @param locationStatus 定位状态筛选条件（1-在线，0-离线），如果为null则不过滤
|
|
|
+ * @return 筛选后的运单订单列表
|
|
|
+ */
|
|
|
+ private List<KwtWaybillOrder> filterByLocationStatus(
|
|
|
+ List<KwtWaybillOrder> waybillOrders,
|
|
|
+ Map<String, VehicleLocationInfo> locationInfoMap,
|
|
|
+ Integer locationStatus) {
|
|
|
+
|
|
|
+ // 如果没有定位状态筛选条件，直接返回原列表
|
|
|
+ if (locationStatus == null) {
|
|
|
+ return waybillOrders;
|
|
|
+ }
|
|
|
+
|
|
|
+ // 根据定位状态筛选运单订单
|
|
|
+ return waybillOrders.stream()
|
|
|
+ .filter(order -> {
|
|
|
+ // 获取车辆的位置信息
|
|
|
+ VehicleLocationInfo locationInfo = locationInfoMap.get(order.getTruckNo());
|
|
|
+ // 筛选条件：位置信息存在且定位状态与筛选条件匹配
|
|
|
+ return locationInfo != null && locationStatus.equals(locationInfo.getLocationStatus());
|
|
|
+ })
|
|
|
.collect(Collectors.toList());
|
|
|
-
|
|
|
- // 根据排序类型进行排序
|
|
|
- MapVehicleSortTypeEnum sortType = MapVehicleSortTypeEnum.getByCode(req.getSortType());
|
|
|
- result = switch (sortType) {
|
|
|
- case TIME_DESC ->
|
|
|
- // 按任务开始时间倒序
|
|
|
- result.stream()
|
|
|
- .sorted(Comparator.comparing(MapVehicleVo::getTaskStartTime,
|
|
|
- Comparator.nullsLast(Comparator.reverseOrder())))
|
|
|
- .collect(Collectors.toList());
|
|
|
- case DURATION_DESC ->
|
|
|
- // 按任务耗时倒序
|
|
|
- result.stream()
|
|
|
- .sorted(Comparator.comparing(MapVehicleVo::getTaskDuration,
|
|
|
- Comparator.nullsLast(Comparator.reverseOrder())))
|
|
|
- .collect(Collectors.toList());
|
|
|
- case EXCEPTION_COUNT_DESC ->
|
|
|
- // 按异常数量倒序
|
|
|
- result.stream()
|
|
|
- .sorted(Comparator.comparing(MapVehicleVo::getExceptionCount,
|
|
|
- Comparator.nullsLast(Comparator.reverseOrder())))
|
|
|
- .collect(Collectors.toList());
|
|
|
- };
|
|
|
-
|
|
|
- // 返回分页结果（使用数据库分页的总数）
|
|
|
- return PageDataResult.of(page, result);
|
|
|
}
|
|
|
|
|
|
+ /**
|
|
|
+ * 转换为MapVehicleVo列表
|
|
|
+ * 该方法将过滤后的运单订单列表转换为MapVehicleVo对象列表
|
|
|
+ *
|
|
|
+ * @param filteredOrders 过滤后的运单订单列表
|
|
|
+ * @param wOrderIdSubtaskMap 运单ID与子任务的映射关系
|
|
|
+ * @param logisticsOrderData 物流订单数据对象
|
|
|
+ * @param locationInfoMap 位置信息映射
|
|
|
+ * @param exceptionCountMap 异常计数映射
|
|
|
+ * @param truckIdMap 车辆ID映射
|
|
|
+ * @param energyTypeMap 能源类型映射
|
|
|
+ * @return 返回转换后的MapVehicleVo列表
|
|
|
+ */
|
|
|
+
|
|
|
+ private List<MapVehicleVo> convertToMapVehicleVos(
|
|
|
+ List<KwtWaybillOrder> filteredOrders,
|
|
|
+ Map<Long, KwtWaybillOrderSubtask> wOrderIdSubtaskMap,
|
|
|
+ LogisticsOrderData logisticsOrderData,
|
|
|
+ Map<String, VehicleLocationInfo> locationInfoMap,
|
|
|
+ Map<String, Integer> exceptionCountMap,
|
|
|
+ Map<Long, RTruckVo> truckIdMap,
|
|
|
+ Map<String, SysDictResDto> energyTypeMap) {
|
|
|
+
|
|
|
+ // 构建物流订单相关映射
|
|
|
+ // 构建单位映射，用于快速查找物流订单中的单位信息
|
|
|
+ Map<String, KwtLogisticsOrderUnit> unitMap = buildUnitMap(logisticsOrderData.getUnits());
|
|
|
+ // 构建货物映射，用于快速查找物流订单中的货物信息
|
|
|
+ Map<Long, KwtLogisticsOrderGoods> goodsMap = buildGoodsMap(logisticsOrderData.getGoods());
|
|
|
+ // 构建地址映射，用于快速查找物流订单中的地址信息
|
|
|
+ Map<String, KwtLogisticsOrderAddress> addressMap = buildAddressMap(logisticsOrderData.getAddresses());
|
|
|
+ // 获取订单映射，用于快速查找物流订单信息
|
|
|
+ Map<Long, KwtLogisticsOrder> orderMap = logisticsOrderData.getOrders();
|
|
|
+
|
|
|
+ // 使用Stream流处理订单列表，将每个订单转换为MapVehicleVo对象
|
|
|
+ return filteredOrders.stream()
|
|
|
+ .map(order -> buildMapVehicleVo(
|
|
|
+ order, wOrderIdSubtaskMap, unitMap, goodsMap,
|
|
|
+ locationInfoMap, exceptionCountMap, truckIdMap, energyTypeMap,
|
|
|
+ addressMap, orderMap))
|
|
|
+ .collect(Collectors.toList());
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 构建单位映射
|
|
|
+ */
|
|
|
+ private Map<String, KwtLogisticsOrderUnit> buildUnitMap(List<KwtLogisticsOrderUnit> units) {
|
|
|
+ if (CollectionUtils.isEmpty(units)) {
|
|
|
+ return Collections.emptyMap();
|
|
|
+ }
|
|
|
+
|
|
|
+ return units.stream()
|
|
|
+ .filter(unit -> unit.getLOrderId() != null && unit.getUnitType() != null)
|
|
|
+ .collect(Collectors.toMap(
|
|
|
+ unit -> unit.getLOrderId() + "_" + unit.getUnitType(),
|
|
|
+ Function.identity(),
|
|
|
+ (k1, k2) -> k1));
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 构建商品映射
|
|
|
+ */
|
|
|
+ private Map<Long, KwtLogisticsOrderGoods> buildGoodsMap(List<KwtLogisticsOrderGoods> goodsList) {
|
|
|
+ if (CollectionUtils.isEmpty(goodsList)) {
|
|
|
+ return Collections.emptyMap();
|
|
|
+ }
|
|
|
+
|
|
|
+ return goodsList.stream()
|
|
|
+ .filter(goods -> goods.getLOrderId() != null)
|
|
|
+ .collect(Collectors.toMap(KwtLogisticsOrderGoods::getLOrderId, Function.identity(), (k1, k2) -> k1));
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 构建地址映射
|
|
|
+ */
|
|
|
+ private Map<String, KwtLogisticsOrderAddress> buildAddressMap(List<KwtLogisticsOrderAddress> addresses) {
|
|
|
+ if (CollectionUtils.isEmpty(addresses)) {
|
|
|
+ return Collections.emptyMap();
|
|
|
+ }
|
|
|
+
|
|
|
+ return addresses.stream()
|
|
|
+ .collect(Collectors.toMap(
|
|
|
+ x -> x.getLOrderId() + "_" + x.getAddressType(),
|
|
|
+ Function.identity(),
|
|
|
+ (k1, k2) -> k1));
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 物流订单数据容器
|
|
|
+ */
|
|
|
+ @Data
|
|
|
+ private static class LogisticsOrderData {
|
|
|
+ private List<KwtLogisticsOrderUnit> units;
|
|
|
+ private List<KwtLogisticsOrderGoods> goods;
|
|
|
+ private List<KwtLogisticsOrderAddress> addresses;
|
|
|
+ private Map<Long, KwtLogisticsOrder> orders;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ /**
|
|
|
+ * 根据查询条件获取运单ID集合
|
|
|
+ * 支持按托运单位、承运单位和物流订单号进行筛选
|
|
|
+ *
|
|
|
+ * @param req 查询请求参数
|
|
|
+ * @param allEnt 初始企业ID集合
|
|
|
+ * @return 符合条件的运单ID集合
|
|
|
+ */
|
|
|
@NotNull
|
|
|
- private Set<Long> getWayOrderIds(MapVehicleQueryReq req,Set<Long> allEnt) {
|
|
|
+ private Set<Long> getWayOrderIds(MapVehicleQueryReq req, Set<Long> allEnt) {
|
|
|
Set<Long> wayOrderIds = Sets.newHashSet();
|
|
|
- // List<Long> entIds = new ArrayList<>();
|
|
|
- if (req.getConsignEntId() != null){
|
|
|
+
|
|
|
+ // 添加查询条件中的托运单位和承运单位到企业ID集合中
|
|
|
+ if (req.getConsignEntId() != null) {
|
|
|
allEnt.add(req.getConsignEntId());
|
|
|
}
|
|
|
- if (req.getCarrierEntId() != null){
|
|
|
+ if (req.getCarrierEntId() != null) {
|
|
|
allEnt.add(req.getCarrierEntId());
|
|
|
}
|
|
|
+
|
|
|
+ // 根据企业ID集合查询运单
|
|
|
if (CollectionUtils.isNotEmpty(allEnt)) {
|
|
|
// 第一步：从物流订单单位表查询符合条件的物流订单ID
|
|
|
- // 同时有托运和承运单位条件，将企业ID和类型组合后批量查询
|
|
|
List<KwtLogisticsOrderUnit> allUnits = kwtLogisticsOrderUnitRepository.list(
|
|
|
Wrappers.<KwtLogisticsOrderUnit>lambdaQuery()
|
|
|
.eq(KwtLogisticsOrderUnit::getDelFlag, 0)
|
|
|
.in(KwtLogisticsOrderUnit::getEntId, allEnt)
|
|
|
- .in(KwtLogisticsOrderUnit::getUnitType, Arrays.asList(1, 2,3)));
|
|
|
+ .in(KwtLogisticsOrderUnit::getUnitType, Arrays.asList(1, 2, 3))); // 1-托运单位, 2-承运单位, 3-其他单位
|
|
|
+
|
|
|
if (CollectionUtils.isEmpty(allUnits)) {
|
|
|
return Set.of();
|
|
|
}
|
|
|
- Set<Long> logisticsOrderIds = allUnits.stream()
|
|
|
+
|
|
|
+ // 筛选当前登录用户企业ID相关的物流订单ID
|
|
|
+ Set<Long> userRelatedLogisticsOrderIds = allUnits.stream()
|
|
|
.filter(x -> Objects.equals(x.getEntId(), LoginUserHolder.getEntId()))
|
|
|
.map(KwtLogisticsOrderUnit::getLOrderId)
|
|
|
.collect(Collectors.toSet());
|
|
|
|
|
|
+ // 获取所有符合条件的物流订单ID（必须同时在allUnits和userRelatedLogisticsOrderIds中）
|
|
|
Set<Long> lOrderIds = allUnits.stream()
|
|
|
.map(KwtLogisticsOrderUnit::getLOrderId)
|
|
|
- .filter(logisticsOrderIds::contains)
|
|
|
+ .filter(userRelatedLogisticsOrderIds::contains)
|
|
|
.collect(Collectors.toSet());
|
|
|
+
|
|
|
if (CollectionUtils.isEmpty(lOrderIds)) {
|
|
|
return Set.of();
|
|
|
}
|
|
|
@@ -1210,29 +1496,36 @@ public class kwfTruckTraceService {
|
|
|
// 第三步：获取运单ID
|
|
|
wayOrderIds = subtasks.stream()
|
|
|
.map(KwtWaybillOrderSubtask::getWOrderId)
|
|
|
+ .filter(Objects::nonNull)
|
|
|
.collect(Collectors.toSet());
|
|
|
|
|
|
if (CollectionUtils.isEmpty(wayOrderIds)) {
|
|
|
return Set.of();
|
|
|
}
|
|
|
}
|
|
|
+
|
|
|
+ // 如果请求中包含物流订单号，则单独查询该订单下的运单
|
|
|
if (StringUtils.isNotBlank(req.getLogisticOrderNo())) {
|
|
|
// 获取物流订单ID
|
|
|
KwtLogisticsOrder logOrder = kwtLogisticsOrderRepository.queryByLogisticOrderId(req.getLogisticOrderNo());
|
|
|
if (Objects.isNull(logOrder)) {
|
|
|
return Set.of();
|
|
|
}
|
|
|
- //根据物流订单id查询子运单
|
|
|
+
|
|
|
+ // 根据物流订单ID查询子运单
|
|
|
List<KwtWaybillOrderSubtask> subtasks = kwtWaybillOrderSubtaskRepository.queryByLogId(logOrder.getId());
|
|
|
- // 使用更明确的初始化方式
|
|
|
+
|
|
|
if (CollectionUtils.isNotEmpty(subtasks)) {
|
|
|
- // 直接收集WOrderId，避免无效的addAll操作
|
|
|
- wayOrderIds.addAll(subtasks.stream()
|
|
|
+ // 将新查询到的运单ID添加到结果集合中
|
|
|
+ Set<Long> additionalWayOrderIds = subtasks.stream()
|
|
|
.map(KwtWaybillOrderSubtask::getWOrderId)
|
|
|
.filter(Objects::nonNull)
|
|
|
- .collect(Collectors.toSet()));
|
|
|
+ .collect(Collectors.toSet());
|
|
|
+
|
|
|
+ wayOrderIds.addAll(additionalWayOrderIds);
|
|
|
}
|
|
|
}
|
|
|
+
|
|
|
return wayOrderIds;
|
|
|
}
|
|
|
|
chenxiaofei