提交物流合同代码优化

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

@@ -1076,112 +1076,184 @@ public class KwcContractLogisticsService {
         ExcelUtil.downData(response, LogisticsListExport.class, dataList);
     }
 
+    /**
+     * 分页查询物流合同列表
+     * <p>
+     * 该方法根据查询条件分页查询物流合同，并关联查询相关的商品信息、企业信息、运单信息等。
+     * 主要处理流程如下：
+     * <ul>
+     *     <li>1. 获取查询企业ID（优先使用请求参数，否则使用登录用户企业ID）</li>
+     *     <li>2. 构建企业ID列表，包含当前企业及指定的委托方/承运方企业</li>
+     *     <li>3. 根据企业ID查询合同单位，筛选出当前企业参与的合同ID</li>
+     *     <li>4. 应用数据权限过滤合同ID</li>
+     *     <li>5. 分页查询物流合同基本信息</li>
+     *     <li>6. 批量查询关联数据：用户信息、商品信息、企业信息、运单信息</li>
+     *     <li>7. 组装返回结果</li>
+     * </ul>
+     *
+     * @param req 查询请求参数，包含分页信息、合同编号、合同名称、状态、企业ID等
+     * @return 分页查询结果，包含物流合同列表及分页信息
+     */
     public PageDataResult<QueryLogisticListResp> queryLogisticsContractListByPage(QueryLogisticListReq req) {
-        log.info("分页查询物流合同参数：{}", JSON.toJSONString( req));
+        log.info("分页查询物流合同参数：{}", JSON.toJSONString(req));
+        
+        // 步骤1: 获取查询企业ID
+        // 优先使用请求参数中的entId，如果为空则使用登录用户的企业ID
         Long entId;
         if (org.apache.commons.lang3.StringUtils.isNotBlank(req.getEntId())) {
             entId = Long.valueOf(req.getEntId());
-        }else{
+            log.debug("使用请求参数中的企业ID: {}", entId);
+        } else {
             entId = LoginUserHolder.getEntId();
+            log.debug("使用登录用户的企业ID: {}", entId);
         }
 
+        // 步骤2: 构建企业ID列表
+        // 基础列表包含当前登录企业
         List<Long> entIdList = Lists.newArrayList();
         entIdList.add(entId);
         Integer type = null;
+        
+        // 如果指定了委托方企业ID，添加到列表并设置合作类型为委托
         if (org.apache.commons.lang3.StringUtils.isNotBlank(req.getConsignCompanyId())){
             entIdList.add(Long.valueOf(req.getConsignCompanyId()));
             type = CooperateTypeEnum.CONSIGN.getCode();
+            log.debug("添加委托方企业ID: {}, 合作类型: {}", req.getConsignCompanyId(), type);
         }
+        
+        // 如果指定了承运方企业ID，添加到列表并设置合作类型为承运
         if (org.apache.commons.lang3.StringUtils.isNotBlank(req.getCarriageCompanyId())){
             entIdList.add(Long.valueOf(req.getCarriageCompanyId()));
             type = CooperateTypeEnum.CARRIAGE.getCode();
+            log.debug("添加承运方企业ID: {}, 合作类型: {}", req.getCarriageCompanyId(), type);
         }
-        //查询物流企业
+        
+        log.debug("企业ID列表构建完成，entIdList: {}, 合作类型: {}", entIdList, type);
+
+        // 步骤3: 根据企业ID查询合同单位，筛选出当前企业参与的合同ID
         Set<Long> contractIdList = Sets.newHashSet();
         if (org.apache.commons.collections4.CollectionUtils.isNotEmpty(entIdList)){
             List<KwcContractLogisticsUnit> units = kwcContractLogisticsUnitRepository.queryByEntIds(entIdList, type);
+            log.debug("查询到合同单位数量: {}", units != null ? units.size() : 0);
+            
             if (CollectionUtils.isNotEmpty(units)) {
+                // 首先筛选出当前企业直接参与的合同ID
                 Set<Long> contractIds = units.stream().filter(x -> Objects.equals(x.getEntId(), entId))
                         .map(KwcContractLogisticsUnit::getContractId)
                         .collect(Collectors.toSet());
+                log.debug("当前企业直接参与的合同数量: {}", contractIds.size());
+                
+                // 然后筛选出这些合同的所有参与方，确保返回完整的合同信息
                 contractIdList = units.stream()
                         .filter(x->contractIds.contains(x.getContractId()))
                         .map(KwcContractLogisticsUnit::getContractId).collect(Collectors.toSet());
+                log.debug("筛选后的合同ID数量: {}", contractIdList.size());
             }
         }
+        
+        // 如果没有查询到合同ID，直接返回空结果
         if (CollectionUtils.isEmpty(contractIdList) && CollectionUtils.isNotEmpty(entIdList)){
+            log.debug("未查询到符合条件的合同ID，返回空结果");
             return PageDataResult.empty(req.getPageNum(),req.getPageSize());
         }
+
+        // 步骤4: 应用数据权限过滤合同ID
         DataPermissionDTO perm = fetchDataPermissionForCurrentUser();
         contractIdList = applyDataPermissionToLogisticsContractIds(contractIdList, perm);
+        log.debug("数据权限过滤后合同ID数量: {}", contractIdList.size());
+        
         if (CollectionUtils.isEmpty(contractIdList)) {
+            log.debug("数据权限过滤后无合同ID，返回空结果");
             return PageDataResult.empty(req.getPageNum(), req.getPageSize());
         }
 
+        // 步骤5: 分页查询物流合同基本信息
         IPage<KwcContractLogistics> page =kwcContractLogisticsRepository.queryByPage(req.getPageNum(),req.getPageSize(),
                 req.getContractNo(),
                 req.getContractName(),req.getStatus(),contractIdList);
         List<KwcContractLogistics> records = page.getRecords();
+        log.debug("分页查询物流合同完成，总记录数: {}, 当前页记录数: {}", page.getTotal(), records.size());
+        
         if (CollectionUtils.isEmpty(records)) {
+            log.debug("当前页无记录，返回空结果");
             return PageDataResult.empty(req.getPageNum(),req.getPageSize());
         }
-        //发起人id
+
+        // 步骤6: 批量查询关联数据
+        
+        // 6.1 获取合同发起人ID列表
         List<Long> userIds =
                 records.stream()
                         .map(KwcContractLogistics::getCreateBy).distinct()
                         .collect(Collectors.toList());
         Map<Long, UserCacheResDto> longUserCacheResDtoMap = Maps.newHashMap();
-        //获取员工信息
+        
+        // 6.2 批量查询用户信息
         if (org.apache.commons.collections4.CollectionUtils.isNotEmpty(userIds)){
             longUserCacheResDtoMap = remoteSystemService.queryUserCacheMapByIds(userIds);
+            log.debug("查询用户信息完成，用户数量: {}, 查询到: {}", userIds.size(), longUserCacheResDtoMap.size());
         }
 
-        //合同id
+        // 6.3 提取合同ID列表
         Set<Long> contractIds = records.stream()
                 .map(KwcContractLogistics::getId)
                 .collect(Collectors.toSet());
-        //查询物流商品信息
+        
+        // 6.4 查询物流商品信息
         List<KwcContractLogisticsGoods> kwcContractLogisticsGoods =kwcContractLogisticsGoodsRepository.queryByContractIds(contractIds);
         Map<Long, List<KwcContractLogisticsGoods>> contractIdAndGoodsMap = Maps.newHashMap();
         if (org.apache.commons.collections4.CollectionUtils.isNotEmpty(kwcContractLogisticsGoods)){
-            //按照合同id进行分组
+            // 按照合同id进行分组，便于后续组装
             contractIdAndGoodsMap =
                     kwcContractLogisticsGoods.stream().collect(Collectors.groupingBy(KwcContractLogisticsGoods::getContractId));
+            log.debug("查询物流商品信息完成，商品数量: {}, 涉及合同数: {}", kwcContractLogisticsGoods.size(), contractIdAndGoodsMap.size());
         }
 
-        //查询物流企业信息
+        // 6.5 查询物流企业信息
         List<KwcContractLogisticsUnit> kwcContractLogisticsUnits =
                 kwcContractLogisticsUnitRepository.queryByContractIds(contractIds);
         Map<String, KwcContractLogisticsUnit> contractUniTypeAndUnitMap = Maps.newHashMap();
         if (org.apache.commons.collections4.CollectionUtils.isNotEmpty(kwcContractLogisticsUnits)){
-            //合同id和单位类型组合成key映射物流企业信息
-             contractUniTypeAndUnitMap = kwcContractLogisticsUnits.stream()
+            // 合同id和单位类型组合成key映射物流企业信息
+            // key格式: "contractId-unitType"，value: 合同单位信息
+            contractUniTypeAndUnitMap = kwcContractLogisticsUnits.stream()
                     .collect(Collectors.toMap(k->k.getContractId() + "-" + k.getUnitType(),
                             Function.identity(), (x, y) -> x));
+            log.debug("查询物流企业信息完成，企业单位数量: {}", kwcContractLogisticsUnits.size());
         }
 
-        // 根据物流合同查询运单
+        // 6.6 根据物流合同查询运单信息
         List<RWaybillSubOrderVo> rWaybillSubOrderVos = transportRemoteService.queryWaybillOrderByLogContractIds(contractIds);
         Map<Long, RWaybillSubOrderVo> logTradeOrderIdAndWaybillMap = Maps.newHashMap();
         if (CollectionUtils.isNotEmpty(rWaybillSubOrderVos)){
             logTradeOrderIdAndWaybillMap = rWaybillSubOrderVos.stream()
                     .collect(Collectors.toMap(RWaybillSubOrderVo::getLogContractId, Function.identity(), (x, y) -> x));
+            log.debug("查询运单信息完成，运单数量: {}", rWaybillSubOrderVos.size());
         }
+        
+        // 6.7 查询物流合同关联的贸易订单信息
         List<WayContaractbillOrderVo> wayContaractbillOrderVos = transportRemoteService.queryLogisticContractByContTradeIds(contractIds);
         Map<Long, WayContaractbillOrderVo> contractIdAndLogisticsOrderMap = Optional.ofNullable(wayContaractbillOrderVos)
                 .orElse(List.of())
                 .stream()
                 .collect(Collectors.toMap(WayContaractbillOrderVo::getContractId, Function.identity(), (x, y) -> x));
+        log.debug("查询物流合同关联贸易订单完成，订单数量: {}", contractIdAndLogisticsOrderMap.size());
+
+        // 步骤7: 组装返回结果
+        // 将局部变量声明为final以便在lambda表达式中使用
         Map<Long, UserCacheResDto> finalLongUserCacheResDtoMap = longUserCacheResDtoMap;
         Map<String, KwcContractLogisticsUnit> finalContractUniTypeAndUnitMap = contractUniTypeAndUnitMap;
         Map<Long, List<KwcContractLogisticsGoods>> finalContractIdAndGoodsMap = contractIdAndGoodsMap;
         Map<Long, RWaybillSubOrderVo> finalLogTradeOrderIdAndWaybillMap = logTradeOrderIdAndWaybillMap;
+        
+        // 将合同记录转换为响应对象，填充关联信息
         List<QueryLogisticListResp> resp = records.stream()
                 .map(r -> getQueryLogisticListResp(r, finalContractUniTypeAndUnitMap,
                         finalContractIdAndGoodsMap, finalLongUserCacheResDtoMap, finalLogTradeOrderIdAndWaybillMap,
                         contractIdAndLogisticsOrderMap))
                 .collect(Collectors.toList());
 
+        log.debug("物流合同分页查询完成，返回记录数: {}", resp.size());
         return PageDataResult.of(page, resp);
     }