铲车和门卫模糊查询

sckw-common/sckw-common-core/src/main/java/com/sckw/core/common/enums/enums/ErrorCodeEnum.java

@@ -87,7 +87,8 @@ public enum ErrorCodeEnum {
 
     // ====================== 铲车订单（100000~110000）======================
     FORKLIFT_ORDER_NOT_FOUND("100000", "当前铲车订单不存在"),
-    FORKLIFT_ORDER_STATUS_ERROR("100000", "当前铲车订单状态异常"),
+    FORKLIFT_ORDER_STATUS_ERROR("100001", "当前铲车订单状态异常"),
+    FORKLIFT_QUERY_PARAM_ERROR("100002", "当前铲车查询条件异常"),
 
 
 

sckw-modules-api/sckw-order-api/src/main/java/com/sckw/order/api/dubbo/TradeOrderInfoService.java

@@ -139,6 +139,13 @@ public interface TradeOrderInfoService {
      */
     List<OrderUnitInfoDetailVO> queryOrderUnitInfByTOrderId(Set<Long> tradeOrderId);
 
+    /**
+     * 通过企业名称模糊查询
+     *
+     * @return
+     */
+    List<OrderUnitInfoDetailVO> queryOrderUnitInfByEntName(String entName);
+
 
     /**
      * 查询近期的贸易订单，计算商品的近期销量

sckw-modules/sckw-order/src/main/java/com/sckw/order/dubbo/TradeOrderInfoServiceImpl.java

@@ -968,4 +968,28 @@ public class TradeOrderInfoServiceImpl implements TradeOrderInfoService {
 
     }
 
+
+    @Override
+    public List<OrderUnitInfoDetailVO> queryOrderUnitInfByEntName(String entName) {
+        List<KwoTradeOrderUnit> kwoTradeOrderUnits = kwoTradeOrderUnitRepository.queryByEntName(entName);
+        if (CollectionUtils.isEmpty(kwoTradeOrderUnits)) {
+            return Collections.emptyList();
+        }
+        return kwoTradeOrderUnits.stream().map(unit -> {
+            OrderUnitInfoDetailVO vo = new OrderUnitInfoDetailVO();
+            vo.setId(unit.getId());
+            vo.setTOrderId(unit.getTOrderId());
+            vo.setTOrderNo(unit.getTOrderNo());
+            vo.setUnitType(unit.getUnitType());
+            vo.setEntId(unit.getEntId());
+            vo.setFirmName(unit.getFirmName());
+            vo.setContactsId(unit.getContactsId());
+            vo.setContacts(unit.getContacts());
+            vo.setPhone(unit.getPhone());
+            return vo;
+        }).collect(Collectors.toList());
+
+    }
+
+
 }

sckw-modules/sckw-order/src/main/java/com/sckw/order/repository/KwoTradeOrderUnitRepository.java

@@ -46,4 +46,13 @@ public class KwoTradeOrderUnitRepository extends ServiceImpl<KwoTradeOrderUnitMa
                 .eq(KwoTradeOrderUnit::getEntId, entId)
                 .eq(KwoTradeOrderUnit::getUnitType, unitType));
     }
+
+    public List<KwoTradeOrderUnit> queryByEntName(String entName) {
+        return list(
+                Wrappers.<KwoTradeOrderUnit>lambdaQuery()
+                        .eq(BaseModel::getDelFlag, 0)
+                        .eq(KwoTradeOrderUnit::getUnitType, 1)
+                        .like(KwoTradeOrderUnit::getFirmName, entName)
+        );
+    }
 }

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/repository/KwtForkliftWaybillOrderRepository.java

@@ -6,6 +6,8 @@ import com.sckw.transport.dao.KwtForkliftWaybillOrderMapper;
 import com.sckw.transport.model.KwtForkliftWaybillOrder;
 import org.springframework.stereotype.Repository;
 
+import java.util.List;
+
 /**
  * @Author: 马超伟
  * @CreateTime: 2025-10-12
@@ -25,6 +27,22 @@ public class KwtForkliftWaybillOrderRepository extends ServiceImpl<KwtForkliftWa
                 .last("limit 1"));
     }
 
+    public List<KwtForkliftWaybillOrder> queryForkliftWaybillOrderByWOrderIds(List<Long> wOrderIds, Long driverId) {
+        return list(
+                Wrappers.<KwtForkliftWaybillOrder>lambdaQuery()
+                        .in(KwtForkliftWaybillOrder::getWOrderId, wOrderIds)
+                        .eq(driverId != null, KwtForkliftWaybillOrder::getDriverId, driverId)
+                        .orderByDesc(KwtForkliftWaybillOrder::getId));
+    }
+
+    public List<KwtForkliftWaybillOrder> queryForkliftWaybillOrderByLogOrderIds(List<Long> logOrderIds, Long driverId) {
+        return list(
+                Wrappers.<KwtForkliftWaybillOrder>lambdaQuery()
+                        .in(KwtForkliftWaybillOrder::getLOrderId, logOrderIds)
+                        .eq(driverId != null, KwtForkliftWaybillOrder::getDriverId, driverId)
+                        .orderByDesc(KwtForkliftWaybillOrder::getId));
+    }
+
     public KwtForkliftWaybillOrder queryForkliftWaybillOrderByFOrderId(Long forkliftId) {
         return getOne(Wrappers.<KwtForkliftWaybillOrder>lambdaQuery()
                 .eq(KwtForkliftWaybillOrder::getId, forkliftId)

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/repository/KwtGatekeeperWaybillOrderRepository.java

@@ -1,10 +1,13 @@
 package com.sckw.transport.repository;
 
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.sckw.transport.dao.KwtGatekeeperWaybillOrderMapper;
 import com.sckw.transport.model.KwtGatekeeperWaybillOrder;
 import org.springframework.stereotype.Repository;
 
+import java.util.List;
+
 /**
  * @Author: 门卫车辆订单
  * @CreateTime: 2025-10-12
@@ -16,8 +19,18 @@ import org.springframework.stereotype.Repository;
 public class KwtGatekeeperWaybillOrderRepository extends ServiceImpl<KwtGatekeeperWaybillOrderMapper, KwtGatekeeperWaybillOrder> {
 
 
+    public List<KwtGatekeeperWaybillOrder> queryGatekeeperWaybillOrderByWOrderIds(List<Long> wOrderIds) {
+        return list(
+                Wrappers.<KwtGatekeeperWaybillOrder>lambdaQuery()
+                        .in(KwtGatekeeperWaybillOrder::getWOrderId, wOrderIds)
+                        .orderByDesc(KwtGatekeeperWaybillOrder::getId));
+    }
 
-
-  
+    public List<KwtGatekeeperWaybillOrder> queryGatekeeperWaybillOrderByLogOrderIds(List<Long> logOrderIds) {
+        return list(
+                Wrappers.<KwtGatekeeperWaybillOrder>lambdaQuery()
+                        .in(KwtGatekeeperWaybillOrder::getLOrderId, logOrderIds)
+                        .orderByDesc(KwtGatekeeperWaybillOrder::getId));
+    }
 
 }

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/service/app/ForkliftOrderService.java

@@ -8,6 +8,7 @@ import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.sckw.contract.api.RemoteContractService;
 import com.sckw.core.common.enums.enums.ErrorCodeEnum;
 import com.sckw.core.exception.BusinessPlatfromException;
+import com.sckw.core.model.constant.Global;
 import com.sckw.core.model.enums.ForkliftStatusEnum;
 import com.sckw.core.model.enums.LoadingTypeEnum;
 import com.sckw.core.utils.CollectionUtils;
@@ -38,6 +39,7 @@ import org.springframework.data.redis.core.script.DefaultRedisScript;
 import org.springframework.stereotype.Service;
 
 import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
 import java.util.stream.Collectors;
@@ -98,8 +100,44 @@ public class ForkliftOrderService {
      */
     public PageDataResult<ForkliftOrderResp> pageQueryForkliftOrder(ForkliftOrderQueryParam param) {
         log.info("查询铲车司机订单：{}", JSON.toJSONString(param));
+        if ((Objects.equals(param.getStatus(), ForkliftStatusEnum.ORDER_TAKING.getCode())
+                || Objects.equals(param.getStatus(), ForkliftStatusEnum.COMPLETED.getCode())) && StringUtils.isBlank(param.getDriverId())) {
+            throw new BusinessPlatfromException(ErrorCodeEnum.FORKLIFT_QUERY_PARAM_ERROR, "铲车id不能为空！");
+        }
+
+        LambdaQueryWrapper<KwtForkliftWaybillOrder> wrapper = buildAndExecuteQuery(param);
+
+        //查询铲车订单
+        Page<KwtForkliftWaybillOrder> pageByStatus = forkliftWaybillOrderRepository.page(new Page<>(param.getPageNum(), param.getPageSize()), wrapper);
+        List<KwtForkliftWaybillOrder> records = pageByStatus.getRecords();
+        if (CollectionUtils.isEmpty(records)) {
+            log.info("当前铲车司机无铲车订单信息，铲车司机id:{}", param.getDriverId());
+            return PageDataResult.empty(param.getPageNum(), param.getPageSize());
+        }
+        List<ForkliftOrderResp> forkliftOrderPageResult = getForkliftOrderPageResult(records);
+        return PageDataResult.success(param.getPageNum(), param.getPageSize(), pageByStatus.getTotal(), forkliftOrderPageResult);
+    }
+
+    /**
+     * 构建查询条件并执行分页查询
+     */
+    private LambdaQueryWrapper<KwtForkliftWaybillOrder> buildAndExecuteQuery(ForkliftOrderQueryParam param) {
+        //基础查询条件
+        LambdaQueryWrapper<KwtForkliftWaybillOrder> queryWrapper = buildBaseQueryWrapper(param);
+
+        //模糊查询条件
+        handleSearchKeyword(param, queryWrapper);
+        return queryWrapper;
+    }
+
+    /**
+     * 构建基础查询条件
+     * @param param
+     * @return
+     */
+    private LambdaQueryWrapper<KwtForkliftWaybillOrder> buildBaseQueryWrapper(ForkliftOrderQueryParam param) {
         LambdaQueryWrapper<KwtForkliftWaybillOrder> wrapper = Wrappers.<KwtForkliftWaybillOrder>lambdaQuery()
-                .eq(param.getDriverId() != null, KwtForkliftWaybillOrder::getDriverId, param.getDriverId())
+                .eq(StringUtils.isNotBlank(param.getDriverId()), KwtForkliftWaybillOrder::getDriverId, param.getDriverId())
                 .in(CollectionUtils.isNotEmpty(param.getDictIdList()),KwtForkliftWaybillOrder::getDictId, param.getDictIdList())
                 .orderByDesc(KwtForkliftWaybillOrder::getCreateTime)
                 .orderByDesc(KwtForkliftWaybillOrder::getId);
@@ -110,15 +148,124 @@ public class ForkliftOrderService {
         } else if (ForkliftStatusEnum.COMPLETED.getCode().equals(param.getStatus())) {
             wrapper.eq(KwtForkliftWaybillOrder::getStatus, 10);
         }
-        //查询铲车订单
-        Page<KwtForkliftWaybillOrder> pageByStatus = forkliftWaybillOrderRepository.page(new Page<>(param.getPageNum(), param.getPageSize()), wrapper);
-        List<KwtForkliftWaybillOrder> records = pageByStatus.getRecords();
-        if (CollectionUtils.isEmpty(records)) {
-            log.info("当前铲车司机无铲车订单信息，铲车司机id:{}", param.getDriverId());
-            return PageDataResult.empty(param.getPageNum(), param.getPageSize());
+        return wrapper;
+    }
+
+    /**
+     * 关键词模糊查询
+     */
+    private void handleSearchKeyword(ForkliftOrderQueryParam param, LambdaQueryWrapper<KwtForkliftWaybillOrder> wrapper) {
+        if (StringUtils.isBlank(param.getKeyWords())) {
+            return;
         }
-        List<ForkliftOrderResp> forkliftOrderPageResult = getForkliftOrderPageResult(records);
-        return PageDataResult.success(param.getPageNum(), param.getPageSize(), pageByStatus.getTotal(), forkliftOrderPageResult);
+        Set<Long> matchedWaybillOrderIds = findMatchedForkliftOrderIds(param.getKeyWords(), param);
+        if (CollectionUtils.isEmpty(matchedWaybillOrderIds)) {
+            log.info("模糊查询无匹配结果，关键词：{}", param.getKeyWords());
+            // 设置一个不可能的条件，确保返回空结果
+            wrapper.eq(KwtForkliftWaybillOrder::getId, Global.MINUS_ONE);
+        } else {
+            wrapper.in(KwtForkliftWaybillOrder::getId, matchedWaybillOrderIds);
+        }
+    }
+
+    /**
+     * 查询匹配的运单ID（以铲车ID为主键）
+     */
+    private Set<Long> findMatchedForkliftOrderIds(String keyword, ForkliftOrderQueryParam param) {
+        Set<Long> forkliftOrderIds = ConcurrentHashMap.newKeySet();;
+        List<Runnable> searchTasks = Arrays.asList(
+                //1. 运单编号查询（主表字段，直接匹配）
+                () -> addMatchedIdsFromForkliftNo(keyword, forkliftOrderIds, param),
+
+                //2. 车牌号、司机姓名查询
+                () -> addMatchedIdsFromWaybillNo(keyword, forkliftOrderIds, param),
+
+                // 3. 客户名称查询
+                () -> addMatchedIdsFromLogisticsOrderNo(keyword, forkliftOrderIds, param)
+        );
+        // 使用并行流执行查询任务
+        searchTasks.parallelStream().forEach(Runnable::run);
+        return forkliftOrderIds;
+    }
+
+    /**
+     * 从铲车编号查询匹配铲车单号
+     * @param keyword
+     * @param forkliftOrderIds
+     * @param param
+     */
+    private void addMatchedIdsFromForkliftNo(String keyword, Set<Long> forkliftOrderIds, ForkliftOrderQueryParam param) {
+        // 1. 铲车编号查询（主表字段，直接匹配）
+        List<KwtForkliftWaybillOrder> forkliftWaybillOrder = forkliftWaybillOrderRepository.list(
+                Wrappers.<KwtForkliftWaybillOrder>lambdaQuery()
+                        .eq(param.getDriverId() != null, KwtForkliftWaybillOrder::getDriverId, param.getDriverId())
+                        .like(KwtForkliftWaybillOrder::getFOrderNo, keyword)
+        );
+        forkliftOrderIds.addAll(forkliftWaybillOrder.stream()
+                .map(KwtForkliftWaybillOrder::getId)
+                .collect(Collectors.toSet()));
+    }
+
+    /**
+     * 车牌号、司机姓名查询
+     * @param keyword
+     * @param forkliftOrderIds
+     * @param param
+     */
+    private void addMatchedIdsFromWaybillNo(String keyword, Set<Long> forkliftOrderIds, ForkliftOrderQueryParam param) {
+        List<KwtWaybillOrder> waybillOrders = waybillOrderRepository.list(
+                Wrappers.<KwtWaybillOrder>lambdaQuery()
+                        .like(KwtWaybillOrder::getTruckNo, keyword)
+                        .or()
+                        .like(KwtWaybillOrder::getDriverName, keyword)
+                        .eq(KwtWaybillOrder::getDelFlag, 0)
+        );
+        if (CollectionUtils.isNotEmpty(waybillOrders)) {
+            List<Long> matchedWaybillOrderIds = waybillOrders.stream()
+                    .map(KwtWaybillOrder::getId)
+                    .collect(Collectors.toList());
+
+            // 查询这些物流运单对应的铲车订单
+            List<KwtForkliftWaybillOrder> forkliftOrderList = forkliftWaybillOrderRepository
+                    .queryForkliftWaybillOrderByWOrderIds(matchedWaybillOrderIds, param.getDriverId());
+
+            forkliftOrderIds.addAll(forkliftOrderList.stream()
+                    .map(KwtForkliftWaybillOrder::getId)
+                    .collect(Collectors.toSet()));
+        }
+    }
+
+
+    /**
+     * 从企业名称查询贸易订单关联的铲车订单
+     */
+    private void addMatchedIdsFromLogisticsOrderNo(String keyword, Set<Long> forkliftOrderIds, ForkliftOrderQueryParam param) {
+        // 从企业名称查询贸易订单
+        List<OrderUnitInfoDetailVO> orderUnitInfoDetailVOS = tradeOrderInfoService.queryOrderUnitInfByEntName(keyword);
+
+        if (CollectionUtils.isEmpty(orderUnitInfoDetailVOS)) {
+            return;
+        }
+        Set<Long> tOrderIds = orderUnitInfoDetailVOS.stream()
+                .map(OrderUnitInfoDetailVO::getTOrderId)
+                .collect(Collectors.toSet());
+
+        // 通过贸易订单查询关联的物流订单
+        List<KwtLogisticsOrder> logisticsOrders = logisticsOrderRepository.queryByTradeOrderIds(tOrderIds);
+        if (CollectionUtils.isNotEmpty(logisticsOrders)) {
+            List<Long> logOrderIds = logisticsOrders.stream()
+                    .map(KwtLogisticsOrder::getId)
+                    .collect(Collectors.toList());
+
+            // 查询这些物流订单对应的铲车订单
+            List<KwtForkliftWaybillOrder> forkliftOrderList = forkliftWaybillOrderRepository
+                    .queryForkliftWaybillOrderByLogOrderIds(logOrderIds, param.getDriverId());
+
+            forkliftOrderIds.addAll(forkliftOrderList.stream()
+                    .map(KwtForkliftWaybillOrder::getId)
+                    .collect(Collectors.toSet()));
+        }
+
     }
 
     /**

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/service/app/GatekeeperOrderService.java

@@ -6,19 +6,22 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.sckw.contract.api.RemoteContractService;
-import com.sckw.core.common.enums.enums.DictTypeEnum;
 import com.sckw.core.common.enums.enums.ErrorCodeEnum;
 import com.sckw.core.exception.BusinessPlatfromException;
+import com.sckw.core.model.constant.Global;
 import com.sckw.core.model.enums.GatekeeperStatusEnum;
 import com.sckw.core.utils.CollectionUtils;
 import com.sckw.core.utils.DateUtils;
+import com.sckw.core.utils.StringUtils;
 import com.sckw.core.web.response.result.PageDataResult;
 import com.sckw.order.api.dubbo.TradeOrderInfoService;
 import com.sckw.order.api.model.OrderUnitInfoDetailVO;
 import com.sckw.product.api.dubbo.GoodsInfoService;
-import com.sckw.product.api.model.KwpGoods;
 import com.sckw.system.api.RemoteSystemService;
-import com.sckw.transport.model.*;
+import com.sckw.transport.model.KwtGatekeeperWaybillOrder;
+import com.sckw.transport.model.KwtLogisticsOrder;
+import com.sckw.transport.model.KwtWaybillOrder;
+import com.sckw.transport.model.KwtWaybillOrderTicket;
 import com.sckw.transport.model.param.forklift.reponse.GatekeeperOrderResp;
 import com.sckw.transport.model.param.forklift.request.GatekeeperOrderPassParam;
 import com.sckw.transport.model.param.forklift.request.GatekeeperOrderQueryParam;
@@ -31,6 +34,7 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
@@ -78,6 +82,44 @@ public class GatekeeperOrderService {
      */
     public PageDataResult<GatekeeperOrderResp> pageQueryGatekeeperOrder(GatekeeperOrderQueryParam param) {
         log.info("查询门卫订单：{}", JSON.toJSONString(param));
+        //构建查询条件
+        LambdaQueryWrapper<KwtGatekeeperWaybillOrder> wrapper = buildAndExecuteQuery(param);
+
+        //查询门卫订单
+        Page<KwtGatekeeperWaybillOrder> pageByStatus = gatekeeperWaybillOrderRepository.page(new Page<>(param.getPageNum(), param.getPageSize()), wrapper);
+        List<KwtGatekeeperWaybillOrder> records = pageByStatus.getRecords();
+        if (CollectionUtils.isEmpty(records)) {
+            log.info("当前无运单订单信息");
+            return PageDataResult.empty(param.getPageNum(), param.getPageSize());
+        }
+        List<GatekeeperOrderResp> gatekeeperOrderPageResult = getGatekeeperOrderPageResult(records);
+        //处理异常车辆数据
+        gatekeeperOrderPageResult = filterGatekeeperOrderResp(param, gatekeeperOrderPageResult);
+
+        //排序
+        sort(param, gatekeeperOrderPageResult);
+        return PageDataResult.success(param.getPageNum(), param.getPageSize(), pageByStatus.getTotal(), gatekeeperOrderPageResult);
+    }
+
+    /**
+     * 构建查询条件并执行分页查询
+     */
+    private LambdaQueryWrapper<KwtGatekeeperWaybillOrder> buildAndExecuteQuery(GatekeeperOrderQueryParam param) {
+        //基础查询条件
+        LambdaQueryWrapper<KwtGatekeeperWaybillOrder> queryWrapper = buildBaseQueryWrapper(param);
+
+        //模糊查询条件
+        handleSearchKeyword(param, queryWrapper);
+        return queryWrapper;
+
+    }
+
+    /**
+     * 构建基础查询条件
+     * @param param
+     * @return
+     */
+    private  LambdaQueryWrapper<KwtGatekeeperWaybillOrder> buildBaseQueryWrapper(GatekeeperOrderQueryParam param) {
         LambdaQueryWrapper<KwtGatekeeperWaybillOrder> wrapper = Wrappers.<KwtGatekeeperWaybillOrder>lambdaQuery()
                 .orderByDesc(KwtGatekeeperWaybillOrder::getCreateTime)
                 .orderByDesc(KwtGatekeeperWaybillOrder::getId);
@@ -103,23 +145,122 @@ public class GatekeeperOrderService {
                     GatekeeperStatusEnum.EXITED.getCode(),
                     GatekeeperStatusEnum.EMPTY_EXITED.getCode());
         }
-        //查询门卫订单
-        Page<KwtGatekeeperWaybillOrder> pageByStatus = gatekeeperWaybillOrderRepository.page(new Page<>(param.getPageNum(), param.getPageSize()), wrapper);
-        List<KwtGatekeeperWaybillOrder> records = pageByStatus.getRecords();
-        if (CollectionUtils.isEmpty(records)) {
-            log.info("当前无运单订单信息");
-            return PageDataResult.empty(param.getPageNum(), param.getPageSize());
+        return wrapper;
+    }
+
+    /**
+     * 关键词模糊查询
+     */
+    private void handleSearchKeyword(GatekeeperOrderQueryParam param, LambdaQueryWrapper<KwtGatekeeperWaybillOrder> wrapper) {
+        if (StringUtils.isBlank(param.getKeyWords())) {
+            return;
         }
-        List<GatekeeperOrderResp> gatekeeperOrderPageResult = getGatekeeperOrderPageResult(records);
-        //处理异常车辆数据
-        gatekeeperOrderPageResult = filterGatekeeperOrderResp(param, gatekeeperOrderPageResult);
+        Set<Long> matchedWaybillOrderIds = findMatchedGatekeeperOrderIds(param);
+        if (CollectionUtils.isEmpty(matchedWaybillOrderIds)) {
+            log.info("模糊查询无匹配结果，关键词：{}", param.getKeyWords());
+            // 设置一个不可能的条件，确保返回空结果
+            wrapper.eq(KwtGatekeeperWaybillOrder::getId, Global.MINUS_ONE);
+        } else {
+            wrapper.in(KwtGatekeeperWaybillOrder::getId, matchedWaybillOrderIds);
+        }
+    }
 
-        //排序
-        sort(param, gatekeeperOrderPageResult);
-        return PageDataResult.success(param.getPageNum(), param.getPageSize(), pageByStatus.getTotal(), gatekeeperOrderPageResult);
+    /**
+     * 查询匹配的运单ID（以铲车ID为主键）
+     */
+    private Set<Long> findMatchedGatekeeperOrderIds(GatekeeperOrderQueryParam param) {
+        Set<Long> gatekeeperOrderIds = ConcurrentHashMap.newKeySet();;
+        List<Runnable> searchTasks = Arrays.asList(
+                //1. 运单编号查询（主表字段，直接匹配）
+                () -> addMatchedIds(gatekeeperOrderIds, param),
+
+                //2. 车牌号、司机姓名查询
+                () -> addMatchedIdsFromWaybillNo(gatekeeperOrderIds, param),
+
+                // 3. 客户名称查询
+                () -> addMatchedIdsFromLogisticsOrderNo(gatekeeperOrderIds, param)
+        );
+        // 使用并行流执行查询任务
+        searchTasks.parallelStream().forEach(Runnable::run);
+        return gatekeeperOrderIds;
+    }
+
+    /**
+     * 运单编号查询
+     * @param gatekeeperOrderIds
+     * @param param
+     */
+    private void addMatchedIds(Set<Long> gatekeeperOrderIds, GatekeeperOrderQueryParam param) {
+        // 1. 运单编号查询（主表字段，直接匹配）
+        List<KwtGatekeeperWaybillOrder> gatekeeperWaybillOrder = gatekeeperWaybillOrderRepository.list(
+                Wrappers.<KwtGatekeeperWaybillOrder>lambdaQuery()
+                        .like(KwtGatekeeperWaybillOrder::getWOrderNo, param.getKeyWords())
+        );
+        gatekeeperOrderIds.addAll(gatekeeperWaybillOrder.stream()
+                .map(KwtGatekeeperWaybillOrder::getId)
+                .collect(Collectors.toSet()));
+    }
+
+    /**
+     * 车牌号、司机姓名查询
+     * @param gatekeeperOrderIds
+     * @param param
+     */
+    private void addMatchedIdsFromWaybillNo(Set<Long> gatekeeperOrderIds, GatekeeperOrderQueryParam param) {
+        List<KwtWaybillOrder> waybillOrders = waybillOrderRepository.list(
+                Wrappers.<KwtWaybillOrder>lambdaQuery()
+                        .like(KwtWaybillOrder::getTruckNo, param.getKeyWords())
+                        .or()
+                        .like(KwtWaybillOrder::getDriverName, param.getKeyWords())
+                        .eq(KwtWaybillOrder::getDelFlag, 0)
+        );
+        if (CollectionUtils.isNotEmpty(waybillOrders)) {
+            List<Long> matchedWaybillOrderIds = waybillOrders.stream()
+                    .map(KwtWaybillOrder::getId)
+                    .collect(Collectors.toList());
+
+            // 查询这些物流运单对应的铲车订单
+            List<KwtGatekeeperWaybillOrder> gatekeeperOrderList = gatekeeperWaybillOrderRepository
+                    .queryGatekeeperWaybillOrderByWOrderIds(matchedWaybillOrderIds);
+
+            gatekeeperOrderIds.addAll(gatekeeperOrderList.stream()
+                    .map(KwtGatekeeperWaybillOrder::getId)
+                    .collect(Collectors.toSet()));
+        }
     }
 
 
+    /**
+     * 从企业名称查询贸易订单关联的铲车订单
+     */
+    private void addMatchedIdsFromLogisticsOrderNo(Set<Long> gatekeeperOrderIds, GatekeeperOrderQueryParam param) {
+        // 从企业名称查询贸易订单
+        List<OrderUnitInfoDetailVO> orderUnitInfoDetailVOS = tradeOrderInfoService.queryOrderUnitInfByEntName(param.getKeyWords());
+
+        if (CollectionUtils.isEmpty(orderUnitInfoDetailVOS)) {
+            return;
+        }
+        Set<Long> tOrderIds = orderUnitInfoDetailVOS.stream()
+                .map(OrderUnitInfoDetailVO::getTOrderId)
+                .collect(Collectors.toSet());
+
+        // 通过贸易订单查询关联的物流订单
+        List<KwtLogisticsOrder> logisticsOrders = logisticsOrderRepository.queryByTradeOrderIds(tOrderIds);
+        if (CollectionUtils.isNotEmpty(logisticsOrders)) {
+            List<Long> logOrderIds = logisticsOrders.stream()
+                    .map(KwtLogisticsOrder::getId)
+                    .collect(Collectors.toList());
+
+            // 查询这些物流订单对应的铲车订单
+            List<KwtGatekeeperWaybillOrder> gatekeeperOrderList = gatekeeperWaybillOrderRepository
+                    .queryGatekeeperWaybillOrderByLogOrderIds(logOrderIds);
+
+            gatekeeperOrderIds.addAll(gatekeeperOrderList.stream()
+                    .map(KwtGatekeeperWaybillOrder::getId)
+                    .collect(Collectors.toSet()));
+        }
+
+    }
 
     /**
      * 获取门卫订单数据