Merge remote-tracking branch 'origin/dev_20260131' into dev_20260131

sckw-modules/sckw-contract/src/main/java/com/sckw/contract/service/operateService/KwcContractLogisticsService.java

@@ -63,7 +63,6 @@ import com.sckw.transport.api.model.vo.WayContaractbillOrderVo;
 import jakarta.servlet.http.HttpServletResponse;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.collections4.MapUtils;
 import org.apache.dubbo.config.annotation.DubboReference;
 import org.jetbrains.annotations.NotNull;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -126,12 +125,12 @@ public class KwcContractLogisticsService {
     @DubboReference(version = "1.0.0", group = "design", check = false)
     private GoodsInfoService goodsInfoService;
 
-    @DubboReference(version = "1.0.0", group = "design", check = false, timeout = 8000)
-    private TradeOrderInfoService tradeOrderInfoService;
-
     @DubboReference(version = "1.0.0", group = "design", check = false)
     private TransportRemoteService transportRemoteService;
 
+    @DubboReference(version = "1.0.0", group = "design", check = false, timeout = 8000)
+    private TradeOrderInfoService tradeOrderInfoService;
+
     //销售合同
     @Value(value = "${jumpUrl.saleSendContract}")
     private String saleSendContract;
@@ -1113,21 +1112,10 @@ public class KwcContractLogisticsService {
         if (CollectionUtils.isEmpty(contractIdList) && CollectionUtils.isNotEmpty(entIdList)){
             return PageDataResult.empty(req.getPageNum(),req.getPageSize());
         }
-        // 获取当前用户的数据权限配置
         DataPermissionDTO perm = fetchDataPermissionForCurrentUser();
-        // 如果存在数据权限且需要过滤，则执行权限过滤逻辑
-        if (perm != null && perm.needFilter()) {
-            // 根据合同ID列表及查询条件获取物流合同列表
-            List<KwcContractLogistics> permissionSource = kwcContractLogisticsRepository.queryList(contractIdList,
-                    req.getContractNo(), req.getContractName(), req.getStatus());
-            // 根据数据权限规则过滤合同列表
-            permissionSource = filterLogisticsContractsByPermission(permissionSource, perm);
-            // 如果过滤后无数据，直接返回空分页结果
-            if (CollectionUtils.isEmpty(permissionSource)) {
-                return PageDataResult.empty(req.getPageNum(), req.getPageSize());
-            }
-            // 将过滤后的合同ID重新赋值给contractIdList，用于后续的分页查询
-            contractIdList = permissionSource.stream().map(KwcContractLogistics::getId).collect(Collectors.toSet());
+        contractIdList = applyDataPermissionToLogisticsContractIds(contractIdList, perm);
+        if (CollectionUtils.isEmpty(contractIdList)) {
+            return PageDataResult.empty(req.getPageNum(), req.getPageSize());
         }
 
         IPage<KwcContractLogistics> page =kwcContractLogisticsRepository.queryByPage(req.getPageNum(),req.getPageSize(),
@@ -1746,10 +1734,17 @@ public class KwcContractLogisticsService {
         }
 
 
-        List<KwcContractLogistics> contractLogistics = kwcContractLogisticsRepository.queryList(contractIdList,req.getContractNo(),req.getContractName(),req.getStatus());
-        // 应用数据权限过滤：获取当前用户的数据权限配置，并对物流合同列表进行过滤（个人数据权限与企业层级数据权限为并集关系）
         DataPermissionDTO perm = fetchDataPermissionForCurrentUser();
-        contractLogistics = filterLogisticsContractsByPermission(contractLogistics, perm);
+        contractIdList = applyDataPermissionToLogisticsContractIds(contractIdList, perm);
+        if (CollectionUtils.isEmpty(contractIdList)) {
+            Map<Integer, List<KwcContractLogistics>> emptyMap = new HashMap<>();
+            List<ContractStatusCountResp.ContractStatusCount> statusCounts = statusEnums.stream()
+                    .map(x -> getContractStatusCount(x, emptyMap))
+                    .collect(Collectors.toList());
+            contractStatusCountResp.setContractStatusInfo(statusCounts);
+            return contractStatusCountResp;
+        }
+        List<KwcContractLogistics> contractLogistics = kwcContractLogisticsRepository.queryList(contractIdList,req.getContractNo(),req.getContractName(),req.getStatus());
 
         // 如果过滤后无数据，则返回各状态计数均为0的结果
         if (CollectionUtils.isEmpty(contractLogistics)){
@@ -1814,152 +1809,211 @@ public class KwcContractLogisticsService {
 
 
     /**
-     * 获取当前用户的数据权限配置
+     * 根据数据权限过滤物流合同ID集合。
      * <p>
-     * 通过远程服务获取当前登录用户的数据权限过滤条件，包括可见企业ID、个人数据权限开关等。
-     * 如果获取失败，记录警告日志并返回null，后续逻辑将跳过权限过滤。
+     * 处理逻辑：
+     * 1. 如果无需过滤或输入为空，直接返回。
+     * 2. 如果不是全部可见（即有企业范围限制），则通过物流合同关联的企业ID进行过滤，只保留当前用户可见企业下的合同。
+     * 3. 如果开启了个人数据权限，进一步过滤，只保留销售员为当前用户的合同（通过运单->贸易订单->贸易合同链路关联）。
      * </p>
      *
-     * @return 数据权限DTO，如果获取失败则返回null
+     * @param contractIdList 待过滤的物流合同ID集合
+     * @param perm           数据权限DTO
+     * @return 过滤后的物流合同ID集合
      */
-    private DataPermissionDTO fetchDataPermissionForCurrentUser() {
-        try {
-            DataPermissionFilterReqDto reqDto = new DataPermissionFilterReqDto();
-            reqDto.setUserId(LoginUserHolder.getUserId());
-            reqDto.setRoleId(LoginUserHolder.getCurrentRoleId());
-            reqDto.setManager(LoginUserHolder.isManager());
-            return dataPermissionFeignService.getDataPermissionFilter(reqDto);
-        } catch (Exception e) {
-            log.warn("获取物流合同数据权限失败，跳过权限过滤: {}", e.getMessage());
-            return null;
+    private Set<Long> applyDataPermissionToLogisticsContractIds(Set<Long> contractIdList, DataPermissionDTO perm) {
+        // 1. 基础校验：如果权限对象为空、不需要过滤或合同ID列表为空，直接返回原列表
+        if (perm == null || !perm.needFilter() || CollectionUtils.isEmpty(contractIdList)) {
+            return contractIdList;
         }
+
+        log.debug("开始应用物流合同数据权限过滤, 初始合同数量: {}, 用户ID: {}", contractIdList.size(), perm.getUserId());
+
+        // 2. 企业范围过滤：如果不是全部可见，则根据可见企业ID过滤合同
+        if (!perm.isAllVisible()) {
+            if (CollectionUtils.isEmpty(perm.getVisibleEntIds())) {
+                log.debug("无可见企业权限，清空合同列表");
+                contractIdList.clear();
+                return contractIdList;
+            }
+            
+            // 查询可见企业下的所有物流合同单位
+            List<KwcContractLogisticsUnit> permUnits =
+                    kwcContractLogisticsUnitRepository.queryByEntIds(new ArrayList<>(perm.getVisibleEntIds()), null);
+            
+            // 提取这些单位关联的合同ID
+            Set<Long> entScopeContractIds = permUnits.stream()
+                    .map(KwcContractLogisticsUnit::getContractId)
+                    .filter(Objects::nonNull)
+                    .collect(Collectors.toSet());
+            
+            // 取交集：只保留在可见企业范围内的合同
+            int beforeSize = contractIdList.size();
+            contractIdList.retainAll(entScopeContractIds);
+            log.debug("企业范围过滤完成, 过滤前: {}, 过滤后: {}", beforeSize, contractIdList.size());
+        }
+
+        // 如果经过企业范围过滤后列表为空，直接返回
+        if (CollectionUtils.isEmpty(contractIdList)) {
+            return contractIdList;
+        }
+
+        // 3. 个人数据权限过滤：如果开启，需进一步校验销售员身份
+        if (perm.isPersonalDataEnabled()) {
+            Long uid = perm.getUserId();
+            if (uid == null) {
+                log.warn("个人数据权限开启但用户ID为空，清空合同列表");
+                contractIdList.clear();
+                return contractIdList;
+            }
+            
+            log.debug("开启个人数据权限过滤, 校验销售员ID: {}", uid);
+            // 通过关联的贸易合同销售员进行过滤
+            Set<Long> salesMatched = retainLogisticsContractIdsByLinkedTradeSalesman(contractIdList, uid);
+            
+            // 更新原列表为过滤后的结果
+            contractIdList.clear();
+            contractIdList.addAll(salesMatched);
+            log.debug("个人数据权限过滤完成, 最终合同数量: {}", contractIdList.size());
+        }
+        
+        return contractIdList;
     }
 
     /**
-     * 根据数据权限过滤物流合同列表
+     * 根据关联的贸易合同销售员过滤物流合同ID。
      * <p>
-     * 过滤逻辑：
-     * 1. 通过物流合同ID查询关联的运单子单信息，获取贸易订单ID。
-     * 2. 通过贸易订单ID查询关联的交易合同ID。
-     * 3. 根据交易合同ID查询交易合同详情。
-     * 4. 结合数据权限配置（可见企业ID、个人数据权限），判断当前用户是否有权限查看该物流合同。
-     *    - 若非全部可见，则检查交易合同所属企业是否在可见企业列表中。
-     *    - 若启用个人数据权限，则检查交易合同的销售员是否为当前用户。
-     *    - 只有当至少一个关联的交易合同满足权限要求时，该物流合同才会被保留。
+     * 关联链路：物流合同 -> 运单 (RWaybillSubOrderVo) -> 贸易订单ID -> 贸易订单详情 (TradeOrderContractVo) -> 贸易合同ID -> 贸易合同实体 (KwcContractTrade) -> 销售员ID
      * </p>
      *
-     * @param records 待过滤的物流合同列表
-     * @param perm    数据权限配置
-     * @return 过滤后的物流合同列表
+     * @param logContractIds 物流合同ID集合
+     * @param salesmanUserId 销售员用户ID
+     * @return 符合销售员权限的物流合同ID集合
      */
-    private List<KwcContractLogistics> filterLogisticsContractsByPermission(List<KwcContractLogistics> records, DataPermissionDTO perm) {
-        // 如果记录为空、权限对象为空或不需要过滤，直接返回原列表
-        if (CollectionUtils.isEmpty(records) || perm == null || !perm.needFilter()) {
-            return records;
+    private Set<Long> retainLogisticsContractIdsByLinkedTradeSalesman(Set<Long> logContractIds, Long salesmanUserId) {
+        if (CollectionUtils.isEmpty(logContractIds) || salesmanUserId == null) {
+            return Collections.emptySet();
         }
 
-        // 1. 提取所有物流合同ID
-        Set<Long> logContractIds = records.stream().map(KwcContractLogistics::getId).collect(Collectors.toSet());
+        log.debug("开始解析物流合同关联的贸易销售员, 物流合同数: {}", logContractIds.size());
 
-        // 2. 查询关联的运单子单信息
+        // 1. 查询物流合同关联的运单信息
         List<RWaybillSubOrderVo> orderLinks = transportRemoteService.queryWaybillOrderByLogContractIds(logContractIds);
         if (CollectionUtils.isEmpty(orderLinks)) {
-            return Collections.emptyList();
+            log.debug("未找到关联的运单信息");
+            return Collections.emptySet();
         }
 
-        // 3. 提取贸易订单ID
+        // 2. 从运单中提取贸易订单ID (tradeId)
         Set<Long> tradeOrderIds = orderLinks.stream()
                 .map(RWaybillSubOrderVo::getTradeId)
                 .filter(Objects::nonNull)
                 .collect(Collectors.toSet());
+        
         if (CollectionUtils.isEmpty(tradeOrderIds)) {
-            return Collections.emptyList();
+            log.debug("运单中未包含有效的贸易订单ID");
+            return Collections.emptySet();
         }
 
-        // 4. 查询贸易订单关联的交易合同信息
+        // 3. 批量查询贸易订单详情，获取贸易订单与贸易合同的映射关系
         List<TradeOrderContractVo> tradeOrderContracts = tradeOrderInfoService.queryTradeOrderIds(tradeOrderIds);
         if (CollectionUtils.isEmpty(tradeOrderContracts)) {
-            return Collections.emptyList();
+            log.debug("未找到对应的贸易订单详情");
+            return Collections.emptySet();
         }
 
-        // 5. 构建物流合同ID到交易合同ID集合的映射关系
-        Map<Long, Set<Long>> logContractIdTradeContractIdsMap = buildLogContractTradeContractIdsMap(orderLinks, tradeOrderContracts);
-        if (MapUtils.isEmpty(logContractIdTradeContractIdsMap)) {
-            return Collections.emptyList();
+        // 4. 构建 物流合同ID -> 贸易合同ID集合 的映射
+        Map<Long, Set<Long>> logToTradeContractIds = buildLogContractTradeContractIdsMap(orderLinks, tradeOrderContracts);
+        if (logToTradeContractIds.isEmpty()) {
+            log.debug("未能建立物流合同到贸易合同的映射");
+            return Collections.emptySet();
         }
 
-        // 6. 收集所有相关的交易合同ID
-        Set<Long> tradeContractIds = logContractIdTradeContractIdsMap.values().stream()
+        // 5. 收集所有涉及的贸易合同ID
+        Set<Long> tradeContractIds = logToTradeContractIds.values().stream()
                 .flatMap(Collection::stream)
                 .collect(Collectors.toSet());
 
-        // 7. 批量查询交易合同详情，并构建ID到对象的映射
-        Map<Long, KwcContractTrade> tradeContractMap = kwcContractTradeRepository.findByContractIds(tradeContractIds).stream()
+        // 6. 批量查询贸易合同实体，构建 ID -> 实体 的映射，以便获取销售员ID
+        Map<Long, KwcContractTrade> tradeMap = kwcContractTradeRepository.findByContractIds(tradeContractIds).stream()
                 .collect(Collectors.toMap(KwcContractTrade::getId, Function.identity(), (a, b) -> a));
 
-        // 8. 根据权限规则过滤物流合同
-        return records.stream().filter(record -> {
-            // 获取当前物流合同关联的所有交易合同ID
-            Set<Long> relationTradeContractIds = logContractIdTradeContractIdsMap.get(record.getId());
-            if (CollectionUtils.isEmpty(relationTradeContractIds)) {
-                return false;
+        // 7. 遍历物流合同，检查其关联的贸易合同中是否有指定销售员
+        Set<Long> result = new HashSet<>();
+        for (Long logId : logContractIds) {
+            Set<Long> relTradeContractIds = logToTradeContractIds.get(logId);
+            if (CollectionUtils.isEmpty(relTradeContractIds)) {
+                continue;
             }
-
-            // 只要有一个关联的交易合同满足权限要求，则该物流合同可见
-            return relationTradeContractIds.stream()
-                    .map(tradeContractMap::get)
+            
+            // 只要有一个关联的贸易合同的销售员是指定用户，则该物流合同可见
+            boolean ok = relTradeContractIds.stream()
+                    .map(tradeMap::get)
                     .filter(Objects::nonNull)
-                    .anyMatch(contract -> {
-                        // 校验企业权限
-                        boolean entOk = true;
-                        if (!perm.isAllVisible()) {
-                            if (CollectionUtils.isEmpty(perm.getVisibleEntIds())) {
-                                entOk = false;
-                            } else {
-                                entOk = contract.getEntId() != null && perm.getVisibleEntIds().contains(contract.getEntId());
-                            }
-                        }
-
-                        // 校验个人数据权限（销售员权限）
-                        boolean salesOk = true;
-                        if (perm.isPersonalDataEnabled()) {
-                            salesOk = perm.getUserId() != null && perm.getUserId().equals(contract.getSalesmanId());
-                        }
-
-                        return entOk && salesOk;
-                    });
-        }).collect(Collectors.toList());
+                    .anyMatch(t -> salesmanUserId.equals(t.getSalesmanId()));
+            
+            if (ok) {
+                result.add(logId);
+            }
+        }
+        
+        log.debug("销售员权限过滤结束, 匹配到的物流合同数: {}", result.size());
+        return result;
     }
 
     /**
-     * 构建物流合同ID与关联的交易合同ID集合的映射关系
+     * 构建物流合同ID到贸易合同ID集合的映射关系。
      *
-     * @param orderLinks         运单子单信息列表，包含物流合同ID和贸易订单ID
-     * @param tradeOrderContracts 贸易订单与交易合同的关联信息列表
-     * @return Map<物流合同ID, 交易合同ID集合>
+     * @param orderLinks         运单列表
+     * @param tradeOrderContracts 贸易订单与合同关联列表
+     * @return Map<物流合同ID, Set<贸易合同ID>>
      */
     private Map<Long, Set<Long>> buildLogContractTradeContractIdsMap(List<RWaybillSubOrderVo> orderLinks,
                                                                      List<TradeOrderContractVo> tradeOrderContracts) {
-        // 构建贸易订单ID到交易合同ID的映射关系，过滤掉无效数据
-        Map<Long, Long> tradeOrderIdTradeContractIdMap = tradeOrderContracts.stream()
+        // 构建 贸易订单ID -> 贸易合同ID 的映射
+        Map<Long, Long> tradeOrderIdToContractId = tradeOrderContracts.stream()
                 .filter(item -> item.getTOrderId() != null && item.getContractId() != null)
                 .collect(Collectors.toMap(TradeOrderContractVo::getTOrderId, TradeOrderContractVo::getContractId, (a, b) -> a));
 
-        // 初始化结果Map，key为物流合同ID，value为关联的交易合同ID集合
         Map<Long, Set<Long>> result = new HashMap<>();
-        for (RWaybillSubOrderVo orderLink : orderLinks) {
-            // 跳过物流合同ID或贸易订单ID为空的数据
-            if (orderLink.getLogContractId() == null || orderLink.getTradeId() == null) {
+        for (RWaybillSubOrderVo link : orderLinks) {
+            if (link.getLogContractId() == null || link.getTradeId() == null) {
                 continue;
             }
-            // 获取贸易订单对应的交易合同ID
-            Long tradeContractId = tradeOrderIdTradeContractIdMap.get(orderLink.getTradeId());
+            
+            // 获取运单关联的贸易订单对应的贸易合同ID
+            Long tradeContractId = tradeOrderIdToContractId.get(link.getTradeId());
             if (tradeContractId == null) {
                 continue;
             }
-            // 将交易合同ID添加到对应物流合同ID的集合中
-            result.computeIfAbsent(orderLink.getLogContractId(), key -> new HashSet<>()).add(tradeContractId);
+            
+            // 将贸易合同ID加入该物流合同对应的集合中
+            result.computeIfAbsent(link.getLogContractId(), k -> new HashSet<>()).add(tradeContractId);
         }
+        
+        log.debug("构建物流合同-贸易合同映射完成, 映射数量: {}", result.size());
         return result;
     }
+
+    /**
+     * 获取当前用户的数据权限配置
+     * <p>
+     * 通过远程服务获取当前登录用户的数据权限过滤条件，包括可见企业ID、个人数据权限开关等。
+     * 如果获取失败，记录警告日志并返回null，后续逻辑将跳过权限过滤。
+     * </p>
+     *
+     * @return 数据权限DTO，如果获取失败则返回null
+     */
+    private DataPermissionDTO fetchDataPermissionForCurrentUser() {
+        try {
+            DataPermissionFilterReqDto reqDto = new DataPermissionFilterReqDto();
+            reqDto.setUserId(LoginUserHolder.getUserId());
+            reqDto.setRoleId(LoginUserHolder.getCurrentRoleId());
+            reqDto.setManager(LoginUserHolder.isManager());
+            return dataPermissionFeignService.getDataPermissionFilter(reqDto);
+        } catch (Exception e) {
+            log.warn("获取物流合同数据权限失败，跳过权限过滤: {}", e.getMessage());
+            return null;
+        }
+    }
 }

sckw-modules/sckw-contract/src/main/java/com/sckw/contract/service/operateService/KwcContractTradeService.java

@@ -1679,6 +1679,7 @@ public class KwcContractTradeService {
         if (org.apache.commons.collections4.CollectionUtils.isEmpty(records)) {
             return Collections.emptyList();
         }
+        // 数据权限：企业按 kwc_contract_trade_unit；与销售员条件见 filterTradeContractsByPermission
         DataPermissionDTO perm = fetchDataPermissionForCurrentUser();
         records = filterTradeContractsByPermission(records, perm);
         if (org.apache.commons.collections4.CollectionUtils.isEmpty(records)) {
@@ -2332,6 +2333,16 @@ public class KwcContractTradeService {
 
         // List<KwcContractTrade> kwcContractTrades = kwcContractTradeRepository.queryTradeListByPageList(LoginUserHolder.getEntId());
 
+        if (CollectionUtils.isEmpty(kwcContractTrades)) {
+            Map<Integer, List<KwcContractTrade>> statusAndLogOrdersMap = new HashMap<>();
+            List<ContractStatusCountResp.ContractStatusCount> statusCounts = statusEnums.stream()
+                    .map(x -> getContractStatusCount(x, statusAndLogOrdersMap))
+                    .collect(Collectors.toList());
+            contractStatusCountResp.setContractStatusInfo(statusCounts);
+            return contractStatusCountResp;
+        }
+        DataPermissionDTO dataPerm = fetchDataPermissionForCurrentUser();
+        kwcContractTrades = filterTradeContractsByPermission(kwcContractTrades, dataPerm);
         if (CollectionUtils.isEmpty(kwcContractTrades)) {
             Map<Integer, List<KwcContractTrade>> statusAndLogOrdersMap = new HashMap<>();
             List<ContractStatusCountResp.ContractStatusCount> statusCounts = statusEnums.stream()
@@ -2685,41 +2696,84 @@ public class KwcContractTradeService {
         }
     }
 
+
     /**
-     * 根据数据权限过滤贸易合同列表
+     * 数据权限过滤（{@link #queryTradeListByPage}、{@link #countQueryTradeListByPage}、{@link #queryTradeContractStatusCount} 共用）。
+     * <p>
+     * 与 {@link DataPermissionDTO} 一致：开启个人数据权限时，条件为「角色已勾选企业范围」与「本人为合同销售员」同时满足（AND）。
+     * 企业范围：按 {@code kwc_contract_trade_unit} 中采购/销售等企业的 {@code ent_id} 是否与 {@code visibleEntIds} 有交集；
+     * 个人范围：{@code salesman_id} 等于当前用户。未配置企业限制（全部可见）且未开个人权限时不收缩。
+     * </p>
      *
-     * @param records 待过滤的合同列表
-     * @param perm    数据权限配置
-     * @return 过滤后的合同列表
+     * @param records 待过滤的贸易合同列表
+     * @param perm    当前用户的数据权限配置对象
+     * @return 过滤后的贸易合同列表
      */
     private List<KwcContractTrade> filterTradeContractsByPermission(List<KwcContractTrade> records, DataPermissionDTO perm) {
         // 如果记录为空、权限配置为空或不需要过滤，直接返回原列表
         if (CollectionUtils.isEmpty(records) || perm == null || !perm.needFilter()) {
             return records;
         }
-        return records.stream().filter(record -> {
-            // 校验企业权限
+
+        log.debug("开始执行贸易合同数据权限过滤，原始记录数: {}, 用户ID: {}", records.size(), perm.getUserId());
+
+        // 提取所有合同ID
+        Set<Long> contractIds = records.stream()
+                .map(KwcContractTrade::getId)
+                .filter(Objects::nonNull)
+                .collect(Collectors.toSet());
+
+        // 构建合同ID与关联企业ID集合的映射关系
+        Map<Long, Set<Long>> contractIdEntIdsMap = Collections.emptyMap();
+        if (CollectionUtils.isNotEmpty(contractIds)) {
+            List<KwcContractTradeUnit> tradeUnits = kwcContractTradeUnitRepository.queryByContractIds(contractIds);
+            if (CollectionUtils.isNotEmpty(tradeUnits)) {
+                contractIdEntIdsMap = tradeUnits.stream()
+                        .filter(unit -> unit.getContractId() != null && unit.getEntId() != null)
+                        .collect(Collectors.groupingBy(KwcContractTradeUnit::getContractId,
+                                Collectors.mapping(KwcContractTradeUnit::getEntId, Collectors.toSet())));
+            }
+        }
+
+        Map<Long, Set<Long>> finalContractIdEntIdsMap = contractIdEntIdsMap;
+
+        // 执行过滤逻辑
+        List<KwcContractTrade> filteredRecords = records.stream().filter(record -> {
+            // 1. 校验企业权限
             boolean entOk = true;
             if (!perm.isAllVisible()) {
-                // 如果不是所有可见，检查可见企业ID列表
+                // 如果不是所有企业可见，则检查可见企业ID列表
                 if (CollectionUtils.isEmpty(perm.getVisibleEntIds())) {
                     entOk = false;
+                    log.debug("合同ID: {} 过滤原因: 非全可见且无可见企业权限", record.getId());
                 } else {
-                    // 检查当前合同所属企业是否在可见列表中
-                    entOk = record.getEntId() != null && perm.getVisibleEntIds().contains(record.getEntId());
+                    // 检查当前合同关联的企业中，是否有任意一个在用户的可见企业列表中
+                    Set<Long> relationEntIds = finalContractIdEntIdsMap.get(record.getId());
+                    entOk = CollectionUtils.isNotEmpty(relationEntIds)
+                            && relationEntIds.stream().anyMatch(perm.getVisibleEntIds()::contains);
+                    if (!entOk) {
+                        log.debug("合同ID: {} 过滤原因: 关联企业不在可见列表中", record.getId());
+                    }
                 }
             }
 
-            // 校验销售人员个人数据权限
+            // 2. 校验销售人员个人数据权限
             boolean salesOk = true;
             if (perm.isPersonalDataEnabled()) {
                 // 如果开启了个人数据权限，检查当前用户是否为该合同的销售人员
-                salesOk = perm.getUserId() != null && perm.getUserId().equals(record.getSalesmanId());
+                salesOk = perm.getUserId() != null && Objects.equals(perm.getUserId(), record.getSalesmanId());
+                if (!salesOk) {
+                    log.debug("合同ID: {} 过滤原因: 非本人销售数据 (当前用户: {}, 销售员: {})",
+                            record.getId(), perm.getUserId(), record.getSalesmanId());
+                }
             }
 
-            // 同时满足企业权限和销售人员权限
+            // 同时满足企业权限和销售人员权限才保留
             return entOk && salesOk;
         }).collect(Collectors.toList());
+
+        log.debug("贸易合同数据权限过滤完成，过滤后记录数: {}", filteredRecords.size());
+        return filteredRecords;
     }
 }
 

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/service/KwtLogisticsConsignmentService.java

@@ -2274,6 +2274,7 @@ public class KwtLogisticsConsignmentService {
         // 3. 获取物流订单ID集合
         log.debug("获取物流订单ID集合");
         Set<Long> logOrderIds = getLogOrderIds(req, entList, allEnt);
+        // 应用数据权限过滤
         logOrderIds = applyDataPermissionFilterToLogOrderIds(logOrderIds);
 
         // 4. 检查是否需要返回空结果
@@ -2719,95 +2720,177 @@ public class KwtLogisticsConsignmentService {
      */
 
 
+
     /**
-     * 按数据权限收缩物流订单ID：
-     * 企业权限：贸易合同 ent_id 落在已勾选企业范围内；
-     * 个人权限：贸易合同 salesman_id 为当前用户；
-     * 两者同时开启时为 AND（与系统模块 DataPermissionDTO 规则一致）。
+     * 应用数据权限过滤到物流订单ID集合
+     * <p>
+     * 根据当前登录用户的数据权限配置，对传入的物流订单ID集合进行过滤。
+     * 支持企业维度权限（可见企业范围）和个人维度权限（销售员匹配）。
+     * </p>
+     *
+     * @param logOrderIds 待过滤的物流订单ID集合
+     * @return 过滤后的物流订单ID集合
      */
     private Set<Long> applyDataPermissionFilterToLogOrderIds(Set<Long> logOrderIds) {
         // 1. 获取当前用户的数据权限配置
         DataPermissionDTO perm = fetchDataPermissionForCurrentUser();
-        // 如果无需过滤或权限对象为空，直接返回原始ID集合
+        
+        // 如果未获取到权限配置或不需要进行数据过滤，直接返回原始ID集合da
         if (perm == null || !perm.needFilter()) {
+            log.debug("数据权限过滤：无需过滤或权限配置为空，返回原始订单ID集合，大小: {}", 
+                    CollectionUtils.isEmpty(logOrderIds) ? 0 : logOrderIds.size());
             return logOrderIds;
         }
-        // 如果输入ID集合为空，直接返回
+
+        // 如果输入的订单ID集合为空，直接返回
         if (CollectionUtils.isEmpty(logOrderIds)) {
+            log.debug("数据权限过滤：输入订单ID集合为空");
             return logOrderIds;
         }
 
-        // 2. 查询物流订单详情，获取关联的贸易订单ID
+        log.info("开始应用数据权限过滤，初始订单ID数量: {}, 用户ID: {}", logOrderIds.size(), LoginUserHolder.getUserId());
+        Set<Long> result = new HashSet<>(logOrderIds);
+
+        // 2. 处理企业维度数据权限
+        // 如果不是所有数据可见，则需要根据可见企业ID进行过滤
+        if (!perm.isAllVisible()) {
+            // 如果可见企业ID列表为空，说明该用户无权查看任何企业数据，返回空集合
+            if (CollectionUtils.isEmpty(perm.getVisibleEntIds())) {
+                log.warn("数据权限过滤：用户无可见企业权限，返回空集合");
+                return Sets.newHashSet();
+            }
+
+            log.debug("数据权限过滤：根据可见企业ID过滤，可见企业数量: {}", perm.getVisibleEntIds().size());
+            // 查询这些企业关联的所有物流订单单位信息
+            List<KwtLogisticsOrderUnit> units =
+                    logisticsOrderUnitRepository.queryByEntIds(new HashSet<>(perm.getVisibleEntIds()));
+            
+            // 提取出这些单位对应的物流订单ID
+            Set<Long> entScopeLogOrderIds = units.stream()
+                    .map(KwtLogisticsOrderUnit::getLOrderId)
+                    .filter(Objects::nonNull)
+                    .collect(Collectors.toSet());
+            
+            log.debug("数据权限过滤：企业维度关联的订单ID数量: {}", entScopeLogOrderIds.size());
+            
+            // 取交集：只保留在当前用户可见企业范围内的订单ID
+            result.retainAll(entScopeLogOrderIds);
+            log.debug("数据权限过滤：企业维度过滤后剩余订单ID数量: {}", result.size());
+        }
+
+        // 如果经过企业维度过滤后结果为空，直接返回
+        if (CollectionUtils.isEmpty(result)) {
+            log.info("数据权限过滤：企业维度过滤后无剩余订单，提前返回");
+            return result;
+        }
+
+        // 3. 处理个人维度数据权限
+        // 如果未启用个人数据权限控制，则直接返回当前结果
+        if (!perm.isPersonalDataEnabled()) {
+            log.info("数据权限过滤：未启用个人数据权限，最终订单ID数量: {}", result.size());
+            return result;
+        }
+
+        // 启用个人数据权限时，进一步过滤：仅保留关联贸易合同中销售员为当前用户的物流订单
+        log.debug("数据权限过滤：启用个人数据权限，开始按销售员过滤");
+        Set<Long> finalResult = filterLogOrderIdsByTradeContractSalesman(result, perm);
+        log.info("数据权限过滤完成，最终订单ID数量: {}", finalResult.size());
+        
+        return finalResult;
+    }
+
+    /**
+     * 个人数据权限过滤：仅保留关联贸易合同中销售员为当前用户的物流订单
+     * <p>
+     * 逻辑链路：物流订单 -> 贸易订单ID -> 贸易合同ID -> 合同销售员ID == 当前用户ID
+     * </p>
+     *
+     * @param logOrderIds 待过滤的物流订单ID集合
+     * @param perm        当前用户的数据权限DTO
+     * @return 过滤后的物流订单ID集合
+     */
+    private Set<Long> filterLogOrderIdsByTradeContractSalesman(Set<Long> logOrderIds, DataPermissionDTO perm) {
+        // 校验用户ID，若为空则无法进行个人权限匹配，返回空集合
+        if (perm.getUserId() == null) {
+            log.warn("个人数据权限过滤：用户ID为空，返回空集合");
+            return Sets.newHashSet();
+        }
+
+        Long currentUserId = perm.getUserId();
+        log.debug("个人数据权限过滤：开始处理，待过滤订单数: {}, 当前用户ID: {}", logOrderIds.size(), currentUserId);
+
+        // 1. 查询物流订单详情，获取关联的贸易订单ID
         List<KwtLogisticsOrder> orders = logisticsOrderRepository.queryByLogOrderIds(logOrderIds);
         if (CollectionUtils.isEmpty(orders)) {
+            log.debug("个人数据权限过滤：未查询到物流订单详情，返回空集合");
             return Sets.newHashSet();
         }
+
+        // 提取所有非空的贸易订单ID
         Set<Long> tradeIds = orders.stream()
                 .map(KwtLogisticsOrder::getTOrderId)
                 .filter(Objects::nonNull)
                 .collect(Collectors.toSet());
+        
         if (CollectionUtils.isEmpty(tradeIds)) {
+            log.warn("个人数据权限过滤：物流订单中未找到关联的贸易订单ID，返回空集合");
             return Sets.newHashSet();
         }
+        log.debug("个人数据权限过滤：提取到贸易订单ID数量: {}", tradeIds.size());
 
-        // 3. 通过贸易订单ID查询关联的合同ID
+        // 2. 查询贸易订单与合同的关联关系
         List<TradeOrderContractVo> contractLinks = tradeOrderInfoService.queryTradeOrderIds(tradeIds);
         Map<Long, Long> tradeIdToContractId = new HashMap<>();
         if (CollectionUtils.isNotEmpty(contractLinks)) {
             for (TradeOrderContractVo link : contractLinks) {
+                // 确保贸易订单ID和合同ID均不为空
                 if (link.getTOrderId() == null || link.getContractId() == null) {
                     continue;
                 }
+                // 使用 putIfAbsent 避免覆盖，通常一个贸易订单对应一个主合同
                 tradeIdToContractId.putIfAbsent(link.getTOrderId(), link.getContractId());
             }
         }
+        log.debug("个人数据权限过滤：贸易订单-合同映射关系数量: {}", tradeIdToContractId.size());
 
-        // 4. 批量查询合同基础信息
+        // 3. 批量查询合同基础信息，获取销售员ID
         List<Long> contractIdList = tradeIdToContractId.values().stream().distinct().collect(Collectors.toList());
         Map<Long, ContractCommonInfoResDto> contractMap = Maps.newHashMap();
         if (CollectionUtils.isNotEmpty(contractIdList)) {
             contractMap = contractService.queryContractBaseInfo(contractIdList);
+            log.debug("个人数据权限过滤：查询到合同信息数量: {}", contractMap.size());
+        } else {
+            log.warn("个人数据权限过滤：未找到关联的合同ID列表");
         }
 
-        // 5. 根据数据权限规则过滤允许的贸易订单ID
+        // 4. 筛选出销售员为当前用户的贸易订单ID
         Set<Long> allowedTradeIds = new HashSet<>();
         for (Long tid : tradeIds) {
             Long cid = tradeIdToContractId.get(tid);
             if (cid == null) {
+                // 该贸易订单未关联合同，根据个人权限策略，通常视为不可见或需特殊处理，此处跳过
                 continue;
             }
-            ContractCommonInfoResDto c = contractMap.get(cid);
-            if (c == null) {
+            ContractCommonInfoResDto contractInfo = contractMap.get(cid);
+            if (contractInfo == null) {
+                // 合同信息缺失，跳过
                 continue;
             }
-
-            // 校验企业权限：如果不是全部可见，则检查合同所属企业是否在可见列表中
-            boolean entOk = true;
-            if (!perm.isAllVisible()) {
-                if (CollectionUtils.isEmpty(perm.getVisibleEntIds())) {
-                    entOk = false;
-                } else {
-                    entOk = c.getEntId() != null && perm.getVisibleEntIds().contains(c.getEntId());
-                }
-            }
-
-            // 校验个人权限：如果开启了个人数据隔离，则检查合同销售员是否为当前用户
-            boolean salesOk = true;
-            if (perm.isPersonalDataEnabled()) {
-                salesOk = perm.getUserId() != null && perm.getUserId().equals(c.getSalesmanId());
-            }
-
-            // 同时满足企业权限和个人权限（AND逻辑）
-            if (entOk && salesOk) {
+            // 判断合同销售员是否等于当前用户
+            if (currentUserId.equals(contractInfo.getSalesmanId())) {
                 allowedTradeIds.add(tid);
             }
         }
+        log.debug("个人数据权限过滤：匹配到当前用户作为销售员的贸易订单数量: {}", allowedTradeIds.size());
 
-        // 6. 返回过滤后的物流订单ID集合
-        return orders.stream()
-                .filter(o -> o.getTOrderId() != null && allowedTradeIds.contains(o.getTOrderId()))
+        // 5. 根据允许的贸易订单ID，反向过滤出最终的物流订单ID
+        Set<Long> finalLogOrderIds = orders.stream()
+                .filter(order -> order.getTOrderId() != null && allowedTradeIds.contains(order.getTOrderId()))
                 .map(KwtLogisticsOrder::getId)
                 .collect(Collectors.toSet());
+        
+        log.debug("个人数据权限过滤：最终保留的物流订单数量: {}", finalLogOrderIds.size());
+        return finalLogOrderIds;
     }
 
     private DataPermissionDTO fetchDataPermissionForCurrentUser() {
@@ -2930,7 +3013,6 @@ public class KwtLogisticsConsignmentService {
         return logOrderIds;
     }
 
-    @NotNull
     private Long getAllEnt(String entId) {
         //根据企业类型查询企业
         Long enterId = null;
@@ -2942,8 +3024,6 @@ public class KwtLogisticsConsignmentService {
 
         return enterId;
     }
-
-    @NotNull
     private static LogisticsOrderResp getLogisticsOrderResp(KwtLogisticsOrder kwtLogisticsOrder,
                                                             Map<String, KwtLogisticsOrderUnit> finalLogOrderIdAndUnitTypeKeyAndUnitMap,
                                                             Map<Long, KwtLogisticsOrderGoods> finalLogIdAndGoodsMap,

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/service/KwtWaybillOrderV1Service.java

@@ -3036,7 +3036,7 @@ public class KwtWaybillOrderV1Service {
         Set<Long> billOrderIds = billOrderIdsFuture.join();
         log.debug("物流订单ID查询结果数量: {}, 运单ID查询结果数量: {}", logOrderIds.size(), billOrderIds.size());
 
-        // 应用数据权限过滤：个人数据权限与企业层级数据权限为并集关系
+        // 数据权限：企业按 kwt_logistics_order_unit；个人按贸易合同销售员（见 applyDataPermissionFilterToLogOrderIds）
         logOrderIds = applyDataPermissionFilterToLogOrderIds(logOrderIds);
         log.debug("数据权限过滤后物流订单ID数量: {}", logOrderIds.size());
 
@@ -3654,44 +3654,118 @@ public class KwtWaybillOrderV1Service {
     }
 
     /**
-     * 根据数据权限过滤物流订单ID集合
-     * <p>
-     * 个人数据权限与企业层级数据权限为并集关系：
-     * 勾选后只查已勾选的企业并且贸易合同中销售人员是自己的数据
+     * 根据数据权限过滤物流订单ID集合（{@link #findBillOrderListPage}、{@link #statisticsWaybillOrder} 等共用）。
      * <p>
-     * 过滤链路：物流订单 → 贸易订单 → 贸易合同 → 校验企业ID + 销售人员
+     * 企业数据权限：按 {@code kwt_logistics_order_unit} 中托运/承运企业的 {@code ent_id} 是否落在角色可见企业范围内（与物流订单企业维度一致）。
+     * 个人数据权限：关联贸易合同的 {@code salesman_id} 为当前用户；与企业在 {@link DataPermissionDTO} 下为 AND 组合。
+     * </p>
      *
      * @param logOrderIds 待过滤的物流订单ID集合
      * @return 过滤后的物流订单ID集合
      */
     private Set<Long> applyDataPermissionFilterToLogOrderIds(Set<Long> logOrderIds) {
-        // 获取当前用户的数据权限配置
+        log.debug("开始应用数据权限过滤，原始物流订单ID数量: {}", CollectionUtils.isEmpty(logOrderIds) ? 0 : logOrderIds.size());
+        
+        // 1. 获取当前用户的数据权限配置
         DataPermissionDTO perm = fetchDataPermissionForCurrentUser();
-        // 如果无需过滤或权限配置为空，直接返回原集合
+        
+        // 如果无需过滤或权限配置为空，直接返回原始ID集合
         if (perm == null || !perm.needFilter()) {
+            log.debug("无需进行数据权限过滤，直接返回原始ID集合");
             return logOrderIds;
         }
-        // 如果待过滤集合为空，直接返回
+        
+        // 如果原始ID集合为空，直接返回
         if (CollectionUtils.isEmpty(logOrderIds)) {
+            log.debug("原始物流订单ID集合为空，无需过滤");
             return logOrderIds;
         }
 
-        // 1. 查询物流订单详情
+        Set<Long> result = new HashSet<>(logOrderIds);
+
+        // 2. 处理企业维度的数据权限
+        if (!perm.isAllVisible()) {
+            log.debug("非全量可见模式，开始执行企业维度权限过滤");
+            
+            // 如果可见企业ID列表为空，说明该企业维度下无权限，返回空集合
+            if (CollectionUtils.isEmpty(perm.getVisibleEntIds())) {
+                log.warn("当前用户可见企业ID列表为空，过滤结果为空");
+                return Sets.newHashSet();
+            }
+            
+            // 查询可见企业ID关联的所有物流订单单位信息
+            List<KwtLogisticsOrderUnit> units =
+                    kwtLogisticsOrderUnitRepository.queryByEntIds(new HashSet<>(perm.getVisibleEntIds()));
+            
+            // 提取这些单位关联的物流订单ID
+            Set<Long> entScopeLogOrderIds = units.stream()
+                    .map(KwtLogisticsOrderUnit::getLOrderId)
+                    .filter(Objects::nonNull)
+                    .collect(Collectors.toSet());
+            
+            log.debug("企业维度过滤：可见企业关联的物流订单ID数量: {}", entScopeLogOrderIds.size());
+            
+            // 取交集：只保留既在原始列表中，又在可见企业关联列表中的ID
+            result.retainAll(entScopeLogOrderIds);
+            log.debug("企业维度过滤后剩余ID数量: {}", result.size());
+        }
+
+        // 如果经过企业维度过滤后结果为空，直接返回
+        if (CollectionUtils.isEmpty(result)) {
+            log.debug("企业维度过滤后结果为空，提前返回");
+            return result;
+        }
+
+        // 3. 处理个人维度的数据权限
+        if (!perm.isPersonalDataEnabled()) {
+            log.debug("未启用个人数据权限，返回当前过滤结果");
+            return result;
+        }
+
+        log.debug("启用个人数据权限，开始执行销售员维度过滤");
+        return filterLogOrderIdsByTradeContractSalesman(result, perm);
+    }
+
+    /**
+     * 个人数据权限过滤：仅保留关联贸易合同中销售员为当前用户的物流订单。
+     * <p>
+     * 逻辑链路：物流订单 -> 贸易订单ID -> 贸易合同ID -> 合同基本信息(销售员ID)
+     * </p>
+     *
+     * @param logOrderIds 待过滤的物流订单ID集合
+     * @param perm        数据权限配置对象
+     * @return 过滤后的物流订单ID集合
+     */
+    private Set<Long> filterLogOrderIdsByTradeContractSalesman(Set<Long> logOrderIds, DataPermissionDTO perm) {
+        Long currentUserId = perm.getUserId();
+        log.debug("开始个人数据权限过滤，当前用户ID: {}, 待过滤物流订单ID数量: {}", currentUserId, logOrderIds.size());
+
+        // 校验用户ID
+        if (currentUserId == null) {
+            log.warn("个人数据权限启用但用户ID为空，返回空集合");
+            return Sets.newHashSet();
+        }
+
+        // 1. 查询物流订单详情，获取关联的贸易订单ID
         List<KwtLogisticsOrder> orders = logisticsOrderRepository.queryByLogOrderIds(logOrderIds);
         if (CollectionUtils.isEmpty(orders)) {
+            log.debug("未查询到对应的物流订单详情，返回空集合");
             return Sets.newHashSet();
         }
 
-        // 2. 提取关联的贸易订单ID
+        // 提取所有非空的贸易订单ID
         Set<Long> tradeIds = orders.stream()
                 .map(KwtLogisticsOrder::getTOrderId)
                 .filter(Objects::nonNull)
                 .collect(Collectors.toSet());
+                
         if (CollectionUtils.isEmpty(tradeIds)) {
+            log.debug("物流订单中未关联有效的贸易订单ID，返回空集合");
             return Sets.newHashSet();
         }
+        log.debug("提取到贸易订单ID数量: {}", tradeIds.size());
 
-        // 3. 查询贸易订单与合同的关联关系
+        // 2. 查询贸易订单与贸易合同的关联关系
         List<TradeOrderContractVo> contractLinks = tradeOrderInfoService.queryTradeOrderIds(tradeIds);
         Map<Long, Long> tradeIdToContractId = new HashMap<>();
         if (CollectionUtils.isNotEmpty(contractLinks)) {
@@ -3699,56 +3773,46 @@ public class KwtWaybillOrderV1Service {
                 if (link.getTOrderId() == null || link.getContractId() == null) {
                     continue;
                 }
+                // 使用 putIfAbsent 确保一个贸易订单只映射一个合同ID（通常是一对一）
                 tradeIdToContractId.putIfAbsent(link.getTOrderId(), link.getContractId());
             }
         }
+        log.debug("建立贸易订单到合同ID的映射，映射数量: {}", tradeIdToContractId.size());
 
-        // 4. 批量查询合同基础信息
+        // 3. 批量查询合同基本信息（包含销售员ID）
         List<Long> contractIdList = tradeIdToContractId.values().stream().distinct().collect(Collectors.toList());
         Map<Long, ContractCommonInfoResDto> contractMap = Maps.newHashMap();
         if (CollectionUtils.isNotEmpty(contractIdList)) {
             contractMap = remoteContractService.queryContractBaseInfo(contractIdList);
+            log.debug("批量查询合同基本信息完成，获取合同数量: {}", contractMap.size());
         }
 
-        // 5. 根据权限规则筛选允许的贸易订单ID
+        // 4. 筛选出销售员为当前用户的贸易订单ID
         Set<Long> allowedTradeIds = new HashSet<>();
         for (Long tid : tradeIds) {
             Long cid = tradeIdToContractId.get(tid);
             if (cid == null) {
                 continue;
             }
-            ContractCommonInfoResDto c = contractMap.get(cid);
-            if (c == null) {
+            ContractCommonInfoResDto contractInfo = contractMap.get(cid);
+            if (contractInfo == null) {
                 continue;
             }
-
-            // 校验企业权限：如果不是全部可见，则检查合同所属企业是否在可见列表中
-            boolean entOk = true;
-            if (!perm.isAllVisible()) {
-                if (CollectionUtils.isEmpty(perm.getVisibleEntIds())) {
-                    entOk = false;
-                } else {
-                    entOk = c.getEntId() != null && perm.getVisibleEntIds().contains(c.getEntId());
-                }
-            }
-
-            // 校验个人数据权限：如果启用个人数据权限，则检查合同销售员是否为当前用户
-            boolean salesOk = true;
-            if (perm.isPersonalDataEnabled()) {
-                salesOk = perm.getUserId() != null && perm.getUserId().equals(c.getSalesmanId());
-            }
-
-            // 同时满足企业权限和个人数据权限才允许访问
-            if (entOk && salesOk) {
+            // 判断合同的销售员是否为当前用户
+            if (currentUserId.equals(contractInfo.getSalesmanId())) {
                 allowedTradeIds.add(tid);
             }
         }
+        log.debug("个人权限过滤：当前用户作为销售员的贸易订单ID数量: {}", allowedTradeIds.size());
 
-        // 6. 返回符合权限要求的物流订单ID集合
-        return orders.stream()
-                .filter(o -> o.getTOrderId() != null && allowedTradeIds.contains(o.getTOrderId()))
+        // 5. 根据允许的贸易订单ID，反查并返回对应的物流订单ID
+        Set<Long> finalResult = orders.stream()
+                .filter(order -> order.getTOrderId() != null && allowedTradeIds.contains(order.getTOrderId()))
                 .map(KwtLogisticsOrder::getId)
                 .collect(Collectors.toSet());
+                
+        log.debug("个人数据权限过滤完成，最终保留物流订单ID数量: {}", finalResult.size());
+        return finalResult;
     }
 
     /**