pms 同步SAP库存 多线程 功能优化

yudao-module-pms/yudao-module-pms-biz/src/main/java/cn/iocoder/yudao/module/pms/dal/mysql/iotsapstocklog/IotSapStockLogMapper.java

@@ -5,7 +5,9 @@ import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
 import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
 import cn.iocoder.yudao.module.pms.controller.admin.iotsapstocklog.vo.IotSapStockLogPageReqVO;
 import cn.iocoder.yudao.module.pms.dal.dataobject.iotsapstocklog.IotSapStockLogDO;
+import org.apache.ibatis.annotations.Delete;
 import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
 
 /**
  * PMS SAP 库存(sap同步的原始数据日志) Mapper
@@ -46,4 +48,12 @@ public interface IotSapStockLogMapper extends BaseMapperX<IotSapStockLogDO> {
                 .orderByDesc(IotSapStockLogDO::getId));
     }
 
+    /**
+     * 物理删除 上次同步保存的SAP库存数据
+     *
+     * @return 删除条数
+     */
+    @Delete("DELETE FROM rq_iot_sap_stock_log WHERE 1=1 AND factory_code = #{factoryCode}")
+    Integer deleteSapStockLogs(@Param("factoryCode") String factoryCode);
+
 }

yudao-module-pms/yudao-module-pms-biz/src/main/java/cn/iocoder/yudao/module/pms/job/sap/SyncSapStockJob.java

@@ -2,10 +2,8 @@ package cn.iocoder.yudao.module.pms.job.sap;
 
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.collection.CollectionUtil;
-import cn.hutool.core.util.ObjUtil;
 import cn.iocoder.yudao.framework.quartz.core.handler.JobHandler;
 import cn.iocoder.yudao.framework.tenant.core.job.TenantJob;
-import cn.iocoder.yudao.module.pms.dal.mysql.iotsappickinglist.IotSapPickingListMapper;
 import cn.iocoder.yudao.module.pms.sap.SapConnector;
 import cn.iocoder.yudao.module.pms.sap.service.IotSapService;
 import cn.iocoder.yudao.module.pms.sap.vo.IotSapStockVO;
@@ -20,7 +18,9 @@ import org.springframework.stereotype.Component;
 import javax.annotation.Resource;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 
 import static cn.iocoder.yudao.module.pms.framework.config.MultiThreadConfiguration.PMS_THREAD_POOL_TASK_EXECUTOR;
@@ -35,8 +35,7 @@ public class SyncSapStockJob implements JobHandler {
     private SapConnector sapConnector;
     @Autowired
     private SapOrgApi sapOrgApi;
-    @Autowired
-    private IotSapPickingListMapper sapPickingListMapper;
+
     @Resource(name = PMS_THREAD_POOL_TASK_EXECUTOR)
     private ThreadPoolTaskExecutor pmsThreadPoolTaskExecutor;
     @Autowired
@@ -50,59 +49,169 @@ public class SyncSapStockJob implements JobHandler {
         if (CollUtil.isEmpty(factoryCodes)) {
             return "No SAP Factory";
         }
-        factoryCodes.forEach(factory -> {
-            CountDownLatch latch = new CountDownLatch(factoryCodes.size());;
-            pmsThreadPoolTaskExecutor.execute(() -> {
+        log.info("共找到 {} 个工厂需要同步: {}", factoryCodes.size(), factoryCodes);
+
+        // 提前获取SAP连接，避免每个线程重复创建
+        JCoDestination destination;
+        try {
+            destination = sapConnector.getDestination();
+            // 测试连接是否有效
+            destination.ping();
+            log.info("SAP连接建立成功");
+        } catch (JCoException e) {
+            log.error("SAP连接建立失败", e);
+            return "SAP连接失败: " + e.getMessage();
+        }
+
+        // 使用CountDownLatch等待所有线程完成
+        CountDownLatch latch = new CountDownLatch(factoryCodes.size());
+        List<CompletableFuture<Void>> futures = new ArrayList<>();
+        List<String> failedFactories = new ArrayList<>();
+        List<String> successFactories = new ArrayList<>();
+
+
+        // 为每个工厂创建异步任务
+        for (String factory : factoryCodes) {
+            CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
                 try {
-                    JCoDestination destination = sapConnector.getDestination();
-                    JCoFunction function = destination.getRepository().getFunction("ZPMS_002");
-                    if (ObjUtil.isNotEmpty(function)) {
-                        // 设置输入参数
-                        JCoParameterList input = function.getImportParameterList();
-                        input.setValue("IV_MATNR", "");    // 物料编号
-                        input.setValue("IV_WERKS", factory);    // 工厂
-                        input.setValue("IV_LGORT", "");    // 库存地点
-                        // 执行 RFC 调用
-                        function.execute(destination);
-                        // 获取输出参数
-                        JCoParameterList output = function.getTableParameterList();
-                        JCoTable etStockTable = function.getTableParameterList().getTable("ET_STOCK");
-                        System.out.println(factory + "当前工厂对应的SAP库存数量：" + etStockTable.getNumRows());
-                        List<IotSapStockVO> sapStocks = new ArrayList<>();
-                        if (etStockTable != null && etStockTable.getNumRows() > 0) {
-                            for (int i = 0; i < etStockTable.getNumRows(); i++) {
-                                etStockTable.setRow(i);
-                                IotSapStockVO sapStock = new IotSapStockVO();
-                                sapStock.setWERKS(etStockTable.getString("WERKS"));
-                                sapStock.setMATNR(etStockTable.getString("MATNR"));
-                                sapStock.setMAKTX(etStockTable.getString("MAKTX"));
-                                sapStock.setLABST(etStockTable.getBigDecimal("LABST"));
-                                sapStock.setLGORT(etStockTable.getString("LGORT"));
-                                sapStock.setCHARG(etStockTable.getString("CHARG"));
-                                sapStock.setSOBKZ(etStockTable.getString("SOBKZ"));
-                                sapStock.setPSPNR(etStockTable.getString("PSPNR"));
-                                sapStock.setPOSID(etStockTable.getString("POSID"));
-                                sapStock.setMEINS(etStockTable.getString("MEINS"));
-                                sapStock.setINSME(etStockTable.getString("INSME"));
-                                sapStock.setSPEME(etStockTable.getString("SPEME"));
-                                sapStock.setJIAGE(etStockTable.getBigDecimal("JIAGE"));
-                                sapStocks.add(sapStock);
-                            }
-                        }
-                        // 处理头部表信息 和 明细表数据
-                        if (CollUtil.isNotEmpty(sapStocks)) {
-                            iotSapService.processSapStock(factory, sapStocks);
-                        }
-                    }
-                } catch (JCoException e) {
-                    // 记录调用接口异常日志
-                    throw new RuntimeException(e);
+                    syncFactoryStock(destination, factory);
+                    successFactories.add(factory);
+                    log.info("工厂 {} 库存同步完成", factory);
+                } catch (Exception e) {
+                    failedFactories.add(factory);
+                    log.error("工厂 {} 库存同步失败", factory, e);
                 } finally {
                     latch.countDown();
                 }
-            });
-        });
-        return "SAP Stock Info: ET_STOCK";
+            }, pmsThreadPoolTaskExecutor);
+
+            futures.add(future);
+        }
+
+        // 等待所有任务完成，设置超时时间
+        try {
+            boolean completed = latch.await(3, TimeUnit.MINUTES);
+            if (!completed) {
+                log.warn("SAP库存同步任务超时，可能有些工厂数据未完成同步");
+            }
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            log.error("SAP库存同步任务被中断", e);
+            return "任务被中断";
+        }
+
+        // 汇总执行结果
+        String result = buildResultMessage(factoryCodes.size(), successFactories.size(), failedFactories);
+        log.info("SAP库存同步任务完成: {}", result);
+
+        return result;
+    }
+
+    /**
+     * 同步单个工厂的库存数据
+     */
+    private void syncFactoryStock(JCoDestination destination, String factory) {
+        JCoFunction function = null;
+        try {
+            // 每个线程使用独立的JCoFunction实例
+            function = destination.getRepository().getFunction("ZPMS_002");
+            if (function == null) {
+                throw new RuntimeException("未找到SAP函数 ZPMS_002");
+            }
+
+            // 设置输入参数
+            JCoParameterList input = function.getImportParameterList();
+            input.setValue("IV_MATNR", "");    // 物料编号
+            input.setValue("IV_WERKS", factory);    // 工厂
+            input.setValue("IV_LGORT", "");    // 库存地点
+
+            // 执行 RFC 调用
+            long startTime = System.currentTimeMillis();
+            function.execute(destination);
+            long endTime = System.currentTimeMillis();
+
+            log.debug("工厂 {} SAP调用耗时: {}ms", factory, (endTime - startTime));
+
+            // 处理返回数据
+            JCoTable etStockTable = function.getTableParameterList().getTable("ET_STOCK");
+            if (etStockTable == null) {
+                log.warn("工厂 {} 未返回ET_STOCK表数据", factory);
+                return;
+            }
+
+            int rowCount = etStockTable.getNumRows();
+            log.info("工厂 {} 获取到 {} 条库存数据", factory, rowCount);
+
+            if (rowCount > 0) {
+                List<IotSapStockVO> sapStocks = parseSapStockData(etStockTable, factory);
+                if (CollUtil.isNotEmpty(sapStocks)) {
+                    iotSapService.processSapStock(factory, sapStocks);
+                    log.info("工厂 {} 成功处理 {} 条库存记录", factory, sapStocks.size());
+                }
+            }
+
+        } catch (JCoException e) {
+            throw new RuntimeException("工厂 " + factory + " SAP调用失败", e);
+        } finally {
+            // 清理JCo资源
+            if (function != null) {
+                try {
+                    // JCoFunction没有close方法，但可以显式清理
+                    function = null;
+                } catch (Exception e) {
+                    log.warn("清理JCoFunction资源时发生警告", e);
+                }
+            }
+        }
+    }
+
+    /**
+     * 解析SAP库存数据
+     */
+    private List<IotSapStockVO> parseSapStockData(JCoTable etStockTable, String factory) {
+        List<IotSapStockVO> sapStocks = new ArrayList<>();
+
+        for (int i = 0; i < etStockTable.getNumRows(); i++) {
+            etStockTable.setRow(i);
+            try {
+                IotSapStockVO sapStock = new IotSapStockVO();
+                sapStock.setWERKS(etStockTable.getString("WERKS"));
+                sapStock.setMATNR(etStockTable.getString("MATNR"));
+                sapStock.setMAKTX(etStockTable.getString("MAKTX"));
+                sapStock.setLABST(etStockTable.getBigDecimal("LABST"));
+                sapStock.setLGORT(etStockTable.getString("LGORT"));
+                sapStock.setCHARG(etStockTable.getString("CHARG"));
+                sapStock.setSOBKZ(etStockTable.getString("SOBKZ"));
+                sapStock.setPSPNR(etStockTable.getString("PSPNR"));
+                sapStock.setPOSID(etStockTable.getString("POSID"));
+                sapStock.setMEINS(etStockTable.getString("MEINS"));
+                sapStock.setINSME(etStockTable.getString("INSME"));
+                sapStock.setSPEME(etStockTable.getString("SPEME"));
+                sapStock.setJIAGE(etStockTable.getBigDecimal("JIAGE"));
+
+                sapStocks.add(sapStock);
+            } catch (Exception e) {
+                log.error("解析工厂 {} 第 {} 行库存数据时发生错误", factory, i, e);
+            }
+        }
+
+        return sapStocks;
+    }
+
+    /**
+     * 构建结果消息
+     */
+    private String buildResultMessage(int total, int success, List<String> failedFactories) {
+        StringBuilder result = new StringBuilder();
+        result.append("SAP库存同步完成。总计: ").append(total)
+                .append(", 成功: ").append(success)
+                .append(", 失败: ").append(total - success);
+
+        if (CollUtil.isNotEmpty(failedFactories)) {
+            result.append("。失败工厂: ").append(failedFactories);
+        }
+
+        return result.toString();
     }
 
     /**

yudao-module-pms/yudao-module-pms-biz/src/main/java/cn/iocoder/yudao/module/pms/sap/service/IotSapServiceImpl.java

@@ -25,7 +25,6 @@ import cn.iocoder.yudao.module.system.api.dept.DeptApi;
 import cn.iocoder.yudao.module.system.api.dept.dto.DeptRespDTO;
 import cn.iocoder.yudao.module.system.api.saporg.SapOrgApi;
 import cn.iocoder.yudao.module.system.api.saporg.dto.SapOrgRespDTO;
-import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -582,17 +581,6 @@ public class IotSapServiceImpl implements IotSapService {
         }
         System.out.println(factoryCode + "当前库中已有sap库存数量：" + existStockKeys.size());
 
-        // todo 没有维护SAP工厂 库存地点的组织 已经存在的库存数据
-        /* Set<String> noFactoryExistStockKeys = new HashSet<>();
-        if (CollUtil.isNotEmpty(existStocks)) {
-            noFactoryExistStockKeys = existStocks.stream()
-                    // 过滤非空对象和非空code
-                    .filter(stk -> ObjUtil.isNotEmpty(stk) && StrUtil.isNotBlank(stk.getMaterialCode())
-                            && StrUtil.isNotBlank(stk.getFactoryCode()) && StrUtil.isNotBlank(stk.getStorageLocationCode()))
-                    .map(stk -> StrUtil.join("-", stk.getFactoryCode(), stk.getStorageLocationCode(), stk.getMaterialCode()))
-                    .collect(Collectors.toSet());
-        } */
-
         // 将已经存在的库存数据 设置成 Map<String, IotSapStockDO> 的形式 便于后续更新
         // key工厂code-库存地点code-物料编码       value库存对象   从此集合中筛选将要被更新的库存对象
         Map<String, IotSapStockDO> tobeUpdatedStockPair = new HashMap<>();
@@ -605,19 +593,6 @@ public class IotSapServiceImpl implements IotSapService {
                         (existing, replacement) -> existing // 处理键冲突: 保留先出现的元素
                 ));
 
-        // todo 没有配置SAP 工厂 库存地点 的组织库存更新
-        // 将已经存在的库存数据 设置成 Map<String, IotSapStockDO> 的形式 便于后续更新
-        // key工厂code-库存地点code-物料编码       value库存对象   从此集合中筛选将要被更新的库存对象
-        /* Map<String, IotSapStockDO> noFactoryTobeUpdatedStockPair = new HashMap<>();
-        noFactoryTobeUpdatedStockPair = existStocks.stream()
-                .filter(stk -> StrUtil.isNotBlank(stk.getMaterialCode()) && StrUtil.isNotBlank(stk.getFactoryCode())
-                        && StrUtil.isNotBlank(stk.getStorageLocationCode()))
-                .collect(Collectors.toMap(
-                        stk -> StrUtil.join("-", stk.getFactoryCode(), stk.getStorageLocationCode(), stk.getMaterialCode()),
-                        stk -> stk, // 值为对象本身
-                        (existing, replacement) -> existing // 处理键冲突: 保留先出现的元素
-                )); */
-
         // 找出需要新增的库存（SAP物料编码去掉前导零后，不在现有物料集合中的记录）
         Set<String> finalExistStockKeys = existStockKeys;
         List<IotSapStockVO> newStocks = sapStocks.stream()
@@ -635,19 +610,6 @@ public class IotSapServiceImpl implements IotSapService {
 
         System.out.println(factoryCode + "需要新增的sap库存数量：" + newStocks.size());
 
-        // todo 没有维护SAP工厂 库存地点的组织 新增的库存数据
-        // 找出需要新增的库存（SAP物料编码去掉前导零后，不在现有物料集合中的记录）
-        /* Set<String> noFactoryFinalExistStockKeys = noFactoryExistStockKeys;
-        List<IotSapStockVO> noFactoryNewStocks = sapStocks.stream()
-                .filter(stk -> StrUtil.isNotBlank(stk.getMATNR()) && StrUtil.isNotBlank(stk.getLGORT()) && StrUtil.isNotBlank(stk.getWERKS()))
-                .filter(stk -> {
-                    // 处理前导零：移除MATNR前的 00000000
-                    String processedCode = stk.getMATNR().replaceFirst("^0+", "");
-                    // 本地已经配置过库存地点 包含SAP库存接口返回的库存地点
-                    return !noFactoryFinalExistStockKeys.contains(StrUtil.join("-", stk.getWERKS(), stk.getLGORT(), processedCode));
-                })
-                .collect(Collectors.toList()); */
-
         // 新增SAP库存数据
         List<IotSapStockDO> tobeAddedStocks = new ArrayList<>();
         if (CollUtil.isNotEmpty(newStocks)) {
@@ -698,50 +660,6 @@ public class IotSapServiceImpl implements IotSapService {
             });
         }
 
-        // todo 新增 没有配置组织部门的 SAP库存数据
-        /** List<IotSapStockDO> noFactoryTobeAddedStocks = new ArrayList<>();
-        if (CollUtil.isNotEmpty(noFactoryNewStocks)) {
-            noFactoryNewStocks.forEach(stock -> {
-                // 只保存pms维护过库存地点的数据
-                String uniqueKey = StrUtil.join("-", stock.getWERKS(), stock.getLGORT());
-                IotSapStockDO sapStock = new IotSapStockDO();
-                // 部门统一设置为 科瑞石油技术
-                sapStock.setDeptId(156l); **/
-                // 工厂id
-                /* if (factoryIdPair.containsKey(stock.getWERKS())) {
-                    sapStock.setFactoryId(factoryIdPair.get(stock.getWERKS()));
-                } */
-                /** sapStock.setFactoryCode(stock.getWERKS());
-                // 工厂名称
-                if (factoryNamePair.containsKey(stock.getWERKS())) {
-                    sapStock.setFactory(factoryNamePair.get(stock.getWERKS()));
-                }
-                // 库存地点 code
-                sapStock.setStorageLocationCode(stock.getLGORT()); **/
-                // 库存地点id
-                /* if (storageLocationIdPair.containsKey(uniqueKey)) {
-                    sapStock.setStorageLocationId(storageLocationIdPair.get(uniqueKey));
-                } */
-                // 库存地点名称
-                /** if (stockLocationNamePair.containsKey(uniqueKey)) {
-                    sapStock.setProjectDepartment(stockLocationNamePair.get(uniqueKey));
-                }
-                // 物料编码 需要去掉前缀 00000000
-                sapStock.setMaterialCode(stock.getMATNR().replaceFirst("^0+", ""));
-                // 物料描述
-                sapStock.setMaterialName(stock.getMAKTX());
-                // 库存数量
-                sapStock.setQuantity(stock.getLABST());
-                // 单价
-                sapStock.setUnitPrice(stock.getJIAGE());
-                // 基本单位
-                sapStock.setUnit(stock.getMEINS());
-                // 同步时间
-                sapStock.setSyncTime(LocalDateTime.now());
-                noFactoryTobeAddedStocks.add(sapStock);
-            });
-        } **/
-
         // 使用返回的SAP库存数据更新已有的 库存数据
         // pms中已有 SAP返回数据中也存在 则更新 再次判断更新deptId 因为有可能又将SAP库存地点关联到了 组织部门
         List<IotSapStockDO> actualUpdatedStocks = new ArrayList<>();
@@ -787,69 +705,10 @@ public class IotSapServiceImpl implements IotSapService {
             });
         }
 
-        // todo sap 工厂 库存地点 未关联组织部门
-        // 使用返回的SAP库存数据更新已有的 库存数据 pms中已有 SAP返回数据中也存在 则更新
-        /* List<IotSapStockDO> noFactoryActualUpdatedStocks = new ArrayList<>();
-        // key工厂code-库存地点code-物料编码      value库存对象
-        Map<String, IotSapStockVO> noFactoryExistStockPair = createNoFactoryExistStockMap(sapStocks, noFactoryExistStockKeys, storageLocationIdPair);
-        if (CollUtil.isNotEmpty(noFactoryExistStockPair)) {
-            Map<String, IotSapStockDO> finalTobeUpdatedStockPair = noFactoryTobeUpdatedStockPair;
-            noFactoryExistStockPair.forEach((k, v) -> {
-                if (finalTobeUpdatedStockPair.containsKey(k)) {
-                    IotSapStockDO sapStock = finalTobeUpdatedStockPair.get(k);
-                    sapStock.setUnitPrice(v.getJIAGE());    // 更新库存价格
-                    sapStock.setQuantity(v.getLABST());     // 更新库存数量
-                    sapStock.setUnit(v.getMEINS());         // 更新基本单位
-                    noFactoryActualUpdatedStocks.add(sapStock);
-                }
-            });
-        }
-        System.out.println(factoryCode + "SAP工厂库存地点未关联组织部门-需要更新的SAP库存数量：" + noFactoryActualUpdatedStocks.size()); */
-
         // pms中已有 但是 SAP返回数据不存在 如果设置了安全库存，则库存为0，若没有设置安全库存，则可以删除
 
-        // 遍历明细数据 新增 修改 SAP库存数据
-        /* List<IotSapStockDO> tobeSapStocks = new ArrayList<>();
-        sapStocks.forEach(stock -> {
-            // 只保存pms维护过库存地点的数据
-            if (locationCodeDeptIdPair.containsKey(stock.getLGORT())) {
-                IotSapStockDO sapStock = new IotSapStockDO();
-                // 部门id
-                sapStock.setDeptId(locationCodeDeptIdPair.get(stock.getLGORT()));
-                // 工厂id
-                if (factoryIdPair.containsKey(stock.getWERKS())) {
-                    sapStock.setFactoryId(factoryIdPair.get(stock.getWERKS()));
-                }
-                // 工厂名称
-                if (factoryNamePair.containsKey(stock.getWERKS())) {
-                    sapStock.setFactory(factoryNamePair.get(stock.getWERKS()));
-                }
-                // 库存地点id
-                if (storageLocationIdPair.containsKey(stock.getLGORT())) {
-                    sapStock.setStorageLocationId(storageLocationIdPair.get(stock.getLGORT()));
-                }
-                // 库存地点名称
-                if (stockLocationNamePair.containsKey(stock.getLGORT())) {
-                    sapStock.setProjectDepartment(stockLocationNamePair.get(stock.getLGORT()));
-                }
-                // 物料编码 需要去掉前缀 00000000
-                sapStock.setMaterialCode(stock.getMATNR());
-                // 物料描述
-                sapStock.setMaterialName(stock.getMAKTX());
-                // 库存数量
-                sapStock.setQuantity(stock.getLABST());
-                // 单价
-                sapStock.setUnitPrice(stock.getJIAGE());
-                // 基本单位
-                sapStock.setUnit(stock.getMEINS());
-                // 同步时间
-                sapStock.setSyncTime(LocalDateTime.now());
-                tobeSapStocks.add(sapStock);
-            }
-        }); */
-        // 保存SAP库存原始数据 先删除 再新增
-        QueryWrapper<IotSapStockLogDO> queryWrapper = new QueryWrapper<>();
-        TenantUtils.execute(1L, () -> iotSapStockLogMapper.delete(queryWrapper));
+        // 保存SAP库存原始数据 先删除当前工厂下的数据 再新增
+        TenantUtils.execute(1L, () -> iotSapStockLogMapper.deleteSapStockLogs(factoryCode));
         if (CollUtil.isNotEmpty(tobeAddedSapStockLogs)) {
             TenantUtils.execute(1L, () -> iotSapStockLogMapper.insertBatch(tobeAddedSapStockLogs));
         }
@@ -857,18 +716,11 @@ public class IotSapServiceImpl implements IotSapService {
         if (CollUtil.isNotEmpty(tobeAddedStocks)) {
             TenantUtils.execute(1L, () -> iotSapStockMapper.insertBatch(tobeAddedStocks));
         }
-        // 本地库存 初始化 批量插入本地库存 记录 工厂 库存地点 未关联了组织架构部门
-        /* if (CollUtil.isNotEmpty(noFactoryTobeAddedStocks)) {
-            TenantUtils.execute(1L, () -> iotSapStockMapper.insertBatch(noFactoryTobeAddedStocks));
-        } */
+
         // pms中存在而且SAP接口也返回的库存数据：更新
         if (CollUtil.isNotEmpty(actualUpdatedStocks)) {
             TenantUtils.execute(1L, () -> iotSapStockMapper.updateBatch(actualUpdatedStocks));
         }
-        // pms中存在而且SAP接口也返回的库存数据：更新 工厂 库存地点 未关联了组织架构部门
-        /* if (CollUtil.isNotEmpty(noFactoryActualUpdatedStocks)) {
-            TenantUtils.execute(1L, () -> iotSapStockMapper.updateBatch(noFactoryActualUpdatedStocks));
-        } */
     }
 
     /**