1. 修改看板id重新导入的逻辑

2. 修改开始工作获取缺料时尾箱拉取逻辑

src/main/java/com/wms/controller/ExcelController.java

@@ -429,10 +429,8 @@ public class ExcelController {
                 response.setMessage("请先导入物料基本信息。");
                 return convertJsonString(response);
             }
-            // 查询之前的看板
-            Map<String, Kanban> kanbanMap = kanbanService.list().stream().collect(Collectors.toMap(kanban -> kanban.getGoodsId() + kanban.getKanbanId(), kanban -> kanban));
             // 导入excel
-            EasyExcel.read(file.getInputStream(), KanbanGoodsExcelVo.class, new UploadKanbanListener(goodsService, goodsMap, kanbanService, kanbanMap, fileVo.getUserName())).sheet("CLC看板信息").doRead();
+            EasyExcel.read(file.getInputStream(), KanbanGoodsExcelVo.class, new UploadKanbanListener(goodsService, goodsMap, kanbanService, fileVo.getUserName())).sheet("CLC看板信息").doRead();
             // 添加导入记录
             uploadRecordService.save(UploadRecord.ofFileVo(fileVo, "KANBAN"));
             uploadFileHashStringList.remove(fileVo.getHash());

src/main/java/com/wms/service/business/serviceImplements/WorkServiceImplements.java

@@ -49,12 +49,14 @@ public class WorkServiceImplements implements IWorkService {
     private final StockService stockService;// 库存服务
     private final IWmsTaskService wmsTaskService;// 任务服务
     private final PickTaskService pickTaskService;// 拣选任务服务
+    private final OutsideVehiclesService outsideVehiclesService;// 外部流转箱服务
     private final List<String> workCreatingStations = new ArrayList<>();// 当前正在创建任务的站台
     private final List<String> workDoingStations = new ArrayList<>();// 当前正在执行任务的站台
     private final List<String> workFinishingStations = new ArrayList<>();// 当前正在完成任务的站台
 
     /**
      * 新版创建工作
+     *
      * @param workStation 工作站台
      * @throws Exception 异常
      */
@@ -188,120 +190,9 @@ public class WorkServiceImplements implements IWorkService {
         }
     }
 
-//    @Override
-//    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
-//    public void createWork(String workStation) throws Exception {
-//        if (workCreatingStations.contains(workStation)) {
-//            // 当前站台正在创建任务
-//            return;
-//        } else {
-//            // 添加站台
-//            workCreatingStations.add(workStation);
-//        }
-//        if (StringUtils.isEmpty(workStation)) {
-//            // 站台号为空
-//            return;
-//        }
-//        try {
-//            // 先查看当前站台已经生成的工作流是否为空
-//            List<WorkFlow> currentWorkFlowList = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
-//                    .eq(WorkFlow::getWorkStation, workStation)
-//                    .ne(WorkFlow::getWorkStatus, 0));
-//            // 当前站台的工作流中还存在其他任务
-//            if (currentWorkFlowList != null && !currentWorkFlowList.isEmpty()) {
-//                return;
-//            }
-//            // 查询是否有已经分配好的电子标签库位信息
-//            List<ELocationConfig> oldELocationConfigList = eLocationConfigService.list(new LambdaQueryWrapper<ELocationConfig>()
-//                    .eq(ELocationConfig::getWorkStation, workStation));
-//            if (oldELocationConfigList != null && !oldELocationConfigList.isEmpty()) {
-//                return;
-//            }
-//            // 查询所有待下发的
-//            List<WorkFlow> currentStationWorkFlows = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
-//                    .eq(WorkFlow::getWorkStatus, 0)
-//                    .eq(WorkFlow::getWorkStation, workStation));
-//            // 如果当前站台有任务
-//            if (!currentStationWorkFlows.isEmpty()) {
-//                // 获得工单以及小工位列表
-//                List<String> boxNoList = new ArrayList<>();
-//                // 要料Map
-//                Map<String, BigDecimal> needGoodsMap = new HashMap<>();
-//                for (WorkFlow tempWorkflow : currentStationWorkFlows) {
-//                    // 添加盒子配置
-//                    String boxNo = tempWorkflow.getWorkOrder() + "@" + tempWorkflow.getWorkCenter();
-//                    if (!boxNoList.contains(boxNo)) {
-//                        boxNoList.add(boxNo);
-//                    }
-//                    // 添加要料信息
-//                    if (!needGoodsMap.containsKey(tempWorkflow.getGoodsId())) {
-//                        // 添加物料信息
-//                        needGoodsMap.put(tempWorkflow.getGoodsId(), tempWorkflow.getNeedNum());
-//                    } else {
-//                        // 增加需求数量
-//                        needGoodsMap.replace(tempWorkflow.getGoodsId(), needGoodsMap.get(tempWorkflow.getGoodsId()).add(tempWorkflow.getNeedNum()));
-//                    }
-//                }
-//                // 站台要料
-//                List<GoodsToStation> goodsToStationList = new ArrayList<>();
-//                for (String goodsId : needGoodsMap.keySet()) {
-//                    GoodsToStation goodsToStation = new GoodsToStation();
-//                    goodsToStation.setConfigId(goodsId + "_" + workStation);
-//                    goodsToStation.setGoodsId(goodsId);
-//                    goodsToStation.setWorkStation(workStation);
-//                    goodsToStation.setDistributeStatus(0);
-//                    goodsToStation.setDistributedNum(BigDecimal.ZERO);
-//                    goodsToStation.setTotalNum(needGoodsMap.get(goodsId));
-//                    goodsToStationList.add(goodsToStation);
-//                }
-//                // 将站台要料列表存进数据库
-//                goodsToStationService.saveOrUpdateBatch(goodsToStationList);
-//                // 电子标签库位配置
-//                List<ELocationConfig> eLocationConfigList = new ArrayList<>();
-//                // 查找到当前站台所有可用的电子标签
-//                List<ETagLocation> eTagLocationList = eTagLocationService.list(new LambdaQueryWrapper<ETagLocation>()
-//                        .eq(ETagLocation::getWorkStation, workStation)
-//                        .eq(ETagLocation::getELocationStatus, 0)
-//                        .orderByAsc(ETagLocation::getSequenceId));
-//                if (eTagLocationList.isEmpty() || eTagLocationList.size() < boxNoList.size()) {
-//                    throw new Exception("站台：" + workStation + "没有足够可用的电子标签位!");
-//                }
-//                for (ETagLocation eTagLocation : eTagLocationList) {
-//                    if (!boxNoList.isEmpty()) {
-//                        String tempBoxNo = boxNoList.get(0);
-//                        ELocationConfig eLocationConfig = new ELocationConfig();
-//                        eLocationConfig.setWorkOrder(tempBoxNo.split("@")[0]);
-//                        eLocationConfig.setWorkCenter(tempBoxNo.split("@")[1]);
-//                        eLocationConfig.setWorkStation(workStation);
-//                        eLocationConfig.setELocationId(eTagLocation.getELocationId());
-//                        eLocationConfig.setOrderBoxNo(tempBoxNo);
-//                        // 添加配置
-//                        eLocationConfigList.add(eLocationConfig);
-//                        // 移除已经分配的盒子
-//                        boxNoList.remove(tempBoxNo);
-//                    }
-//                }
-//                // 将电子标签库位配置存进数据库
-//                eLocationConfigService.saveBatch(eLocationConfigList);
-//                // 更新工作流状态
-//                List<String> workFlowIds = currentStationWorkFlows.stream().map(WorkFlow::getWorkFlowId).distinct().toList();
-//                workFlowService.update(new LambdaUpdateWrapper<WorkFlow>()
-//                        .set(WorkFlow::getWorkStatus, 1)
-//                        .in(WorkFlow::getWorkFlowId, workFlowIds)
-//                        .eq(WorkFlow::getWorkStatus, 0));
-//            }
-//        } catch (Exception e) {
-//            logger.error("创建站台：{}工作发生异常：{}", workStation, convertJsonString(e));
-//            // 回滚事务
-//            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
-//        } finally {
-//            // 当前站台创建任务完成
-//            workCreatingStations.remove(workStation);
-//        }
-//    }
-
     /**
      * 新版开始工作
+     *
      * @param workStation 工作站台
      * @throws Exception 异常
      */
@@ -329,64 +220,86 @@ public class WorkServiceImplements implements IWorkService {
                     .eq(GoodsToStation::getWorkStation, workStation));
             List<GoodsToStation> notFinishedGoodsList = goodsToStationList.stream().filter(goodsToStation -> goodsToStation.getDistributeStatus() < 2).toList();
             if (notFinishedGoodsList.isEmpty()) {
-                // 查询是否还有这个站台的拣选任务
+                // 查询所有的outsideVehicles
-                if (!pickTaskService.exists(new LambdaQueryWrapper<PickTask>()
+                List<OutsideVehicles> outsideVehiclesList = outsideVehiclesService.list(new LambdaQueryWrapper<OutsideVehicles>()
-                        .eq(PickTask::getStandId, workStation))) {
+                        .ne(OutsideVehicles::getOutStatus, 2));
-                    // 需要重新分配的goodsToStationsList
+                // 查询所有的当前站台的拣选任务
-                    Map<String, GoodsToStation> needDistributeGoodsMap = new HashMap<>();
+                List<PickTask> pickTaskList = pickTaskService.list(new LambdaQueryWrapper<PickTask>()
-                    // 需要完成的工作流
+                        .eq(PickTask::getStandId, workStation));
-                    List<WorkFlow> needFinishWorkFlowList = new ArrayList<>();
+                // 需要重新分配的goodsToStationsList
-                    // 所有缺料的分配
+                Map<String, GoodsToStation> needDistributeGoodsMap = new HashMap<>();
-                    List<String> lackGoodsIdList = goodsToStationList.stream().filter(goodsToStation -> goodsToStation.getDistributeStatus() == 3).map(GoodsToStation::getGoodsId).distinct().toList();
+                // 需要完成的工作流
-                    // 不缺料的分配
+                List<WorkFlow> needFinishWorkFlowList = new ArrayList<>();
-                    Map<String, GoodsToStation> noLackGoodsMap = goodsToStationList.stream().filter(goodsToStation -> goodsToStation.getDistributeStatus() == 2).collect(Collectors.toMap(GoodsToStation::getGoodsId, goodsToStation -> goodsToStation));
+                // 所有缺料的分配
-                    // 查询当前工作流中所有缺料的数据行
+                List<String> lackGoodsIdList = goodsToStationList.stream().filter(goodsToStation -> goodsToStation.getDistributeStatus() == 3).map(GoodsToStation::getGoodsId).distinct().toList();
-                    for (WorkFlow notFinishedWorkFlow : currentWorkFlowList) {
+                // 不缺料的分配
-                        if (notFinishedWorkFlow.getPickedNum().compareTo(notFinishedWorkFlow.getNeedNum()) < 0) {
+                Map<String, GoodsToStation> noLackGoodsMap = goodsToStationList.stream().filter(goodsToStation -> goodsToStation.getDistributeStatus() == 2).collect(Collectors.toMap(GoodsToStation::getGoodsId, goodsToStation -> goodsToStation));
-                            // 缺料时，判断是否当前物料在缺料列表中
+                // 查询当前工作流中所有缺料的数据行
-                            if (lackGoodsIdList.contains(notFinishedWorkFlow.getGoodsId())) {
+                for (WorkFlow notFinishedWorkFlow : currentWorkFlowList) {
-                                // 缺料，添加到需要分配的列表中
+                    if (notFinishedWorkFlow.getPickedNum().compareTo(notFinishedWorkFlow.getNeedNum()) < 0) {
-                                notFinishedWorkFlow.setWorkStatus(2);
+                        // 判断这个料有没有在外面
-                                notFinishedWorkFlow.setFinishTime(LocalDateTime.now());
+                        List<OutsideVehicles> currentGoodsOutsideVehiclesList = outsideVehiclesList.stream().filter(outsideVehicles1 -> outsideVehicles1.getGoodsId().equals(notFinishedWorkFlow.getGoodsId())).toList();
-                                notFinishedWorkFlow.setOpUser("系统自动完成");
+                        if (!currentGoodsOutsideVehiclesList.isEmpty()) {
-                                needFinishWorkFlowList.add(notFinishedWorkFlow);
+                            // 判断这些箱子有没有当前站台的拣选任务
-                            } else {
+                            boolean havePickTask = false;
-                                BigDecimal needNum = notFinishedWorkFlow.getNeedNum().subtract(notFinishedWorkFlow.getPickedNum());
+                            for (OutsideVehicles currentGoodsOutsideVehicles : currentGoodsOutsideVehiclesList) {
-                                if (needDistributeGoodsMap.containsKey(notFinishedWorkFlow.getGoodsId())) {
+                                List<PickTask> currentGoodsPickTaskList = pickTaskList.stream().filter(pickTask -> pickTask.getVehicleId().equals(currentGoodsOutsideVehicles.getVehicleId())).toList();
-                                    // 减少分配数量
+                                if (!currentGoodsPickTaskList.isEmpty()) {
-                                    GoodsToStation oldGoodsToStation = needDistributeGoodsMap.get(notFinishedWorkFlow.getGoodsId());
+                                    havePickTask = true;
-                                    oldGoodsToStation.setDistributedNum(oldGoodsToStation.getDistributedNum().subtract(needNum));
+                                    break;
-                                    oldGoodsToStation.setDistributeStatus(1);
-                                    needDistributeGoodsMap.replace(notFinishedWorkFlow.getGoodsId(), oldGoodsToStation);
-                                } else {
-                                    if (noLackGoodsMap.containsKey(notFinishedWorkFlow.getGoodsId())) {
-                                        GoodsToStation newGoodsToStation = noLackGoodsMap.get(notFinishedWorkFlow.getGoodsId());
-                                        newGoodsToStation.setDistributedNum(newGoodsToStation.getDistributedNum().subtract(needNum));
-                                        newGoodsToStation.setDistributeStatus(1);
-                                        needDistributeGoodsMap.put(notFinishedWorkFlow.getGoodsId(), newGoodsToStation);
-                                    } else {
-                                        GoodsToStation goodsToStation = new GoodsToStation();
-                                        goodsToStation.setConfigId(notFinishedWorkFlow.getGoodsId() + "_" + workStation);
-                                        goodsToStation.setGoodsId(notFinishedWorkFlow.getGoodsId());
-                                        goodsToStation.setWorkStation(workStation);
-                                        goodsToStation.setDistributeStatus(0);
-                                        goodsToStation.setDistributedNum(BigDecimal.ZERO);
-                                        goodsToStation.setTotalNum(needNum);
-                                        needDistributeGoodsMap.put(notFinishedWorkFlow.getGoodsId(), goodsToStation);
-                                    }
                                 }
                             }
-                        } else {
+                            if (havePickTask) {
-                            // 不缺料，直接完成
+                                continue;
+                            }
+                        }
+                        // 缺料时，判断是否当前物料在缺料列表中
+                        if (lackGoodsIdList.contains(notFinishedWorkFlow.getGoodsId())) {
+                            // 缺料，添加到需要分配的列表中
                             notFinishedWorkFlow.setWorkStatus(2);
                             notFinishedWorkFlow.setFinishTime(LocalDateTime.now());
                             notFinishedWorkFlow.setOpUser("系统自动完成");
                             needFinishWorkFlowList.add(notFinishedWorkFlow);
+                        } else {
+                            BigDecimal needNum = notFinishedWorkFlow.getNeedNum().subtract(notFinishedWorkFlow.getPickedNum());
+                            if (needDistributeGoodsMap.containsKey(notFinishedWorkFlow.getGoodsId())) {
+                                // 减少分配数量
+                                GoodsToStation oldGoodsToStation = needDistributeGoodsMap.get(notFinishedWorkFlow.getGoodsId());
+                                oldGoodsToStation.setDistributedNum(oldGoodsToStation.getDistributedNum().subtract(needNum));
+                                oldGoodsToStation.setDistributeStatus(1);
+                                needDistributeGoodsMap.replace(notFinishedWorkFlow.getGoodsId(), oldGoodsToStation);
+                            } else {
+                                if (noLackGoodsMap.containsKey(notFinishedWorkFlow.getGoodsId())) {
+                                    GoodsToStation newGoodsToStation = noLackGoodsMap.get(notFinishedWorkFlow.getGoodsId());
+                                    newGoodsToStation.setDistributedNum(newGoodsToStation.getDistributedNum().subtract(needNum));
+                                    newGoodsToStation.setDistributeStatus(1);
+                                    needDistributeGoodsMap.put(notFinishedWorkFlow.getGoodsId(), newGoodsToStation);
+                                } else {
+                                    GoodsToStation goodsToStation = new GoodsToStation();
+                                    goodsToStation.setConfigId(notFinishedWorkFlow.getGoodsId() + "_" + workStation);
+                                    goodsToStation.setGoodsId(notFinishedWorkFlow.getGoodsId());
+                                    goodsToStation.setWorkStation(workStation);
+                                    goodsToStation.setDistributeStatus(0);
+                                    goodsToStation.setDistributedNum(BigDecimal.ZERO);
+                                    goodsToStation.setTotalNum(needNum);
+                                    needDistributeGoodsMap.put(notFinishedWorkFlow.getGoodsId(), goodsToStation);
+                                }
+                            }
                         }
+                    } else {
+                        // 不缺料，直接完成
+                        notFinishedWorkFlow.setWorkStatus(2);
+                        notFinishedWorkFlow.setFinishTime(LocalDateTime.now());
+                        notFinishedWorkFlow.setOpUser("系统自动完成");
+                        needFinishWorkFlowList.add(notFinishedWorkFlow);
                     }
-                    // 保存重新分配的goodsToStationList
+                }
+                // 保存重新分配的goodsToStationList
+                if (!needDistributeGoodsMap.values().isEmpty()) {
                     goodsToStationService.saveOrUpdateBatch(needDistributeGoodsMap.values());
-                    // 保存需要完成的工作流
+                }
+                // 保存需要完成的工作流
+                if (!needFinishWorkFlowList.isEmpty()) {
                     workFlowService.updateBatchById(needFinishWorkFlowList);
                 }
                 return;
@@ -452,139 +365,9 @@ public class WorkServiceImplements implements IWorkService {
         }
     }
 
-//    @Override
-//    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
-//    public void doWork(String workStation) throws Exception {
-//        if (workDoingStations.contains(workStation)) {
-//            // 当前站台正在创建任务
-//            return;
-//        } else {
-//            // 添加站台
-//            workDoingStations.add(workStation);
-//        }
-//        try {
-//            // 查找当前站台未开始的工作流
-//            List<WorkFlow> currentWorkFlowList = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
-//                    .eq(WorkFlow::getWorkStation, workStation)
-//                    .eq(WorkFlow::getWorkStatus, 1));
-//            // 没有可做的任务
-//            if (currentWorkFlowList == null || currentWorkFlowList.isEmpty()) {
-//                return;
-//            }
-//            // 查站台要料表---未分配以及分配但未完全分配
-//            List<GoodsToStation> goodsToStationList = goodsToStationService.list(new LambdaQueryWrapper<GoodsToStation>()
-//                    .eq(GoodsToStation::getWorkStation, workStation));
-//            List<GoodsToStation> notFinishedGoodsList = goodsToStationList.stream().filter(goodsToStation -> goodsToStation.getDistributeStatus() < 2).toList();
-//            if (notFinishedGoodsList.isEmpty()) {
-//                // 查询是否还有这个站台的拣选任务
-//                if (!pickTaskService.exists(new LambdaQueryWrapper<PickTask>()
-//                        .eq(PickTask::getStandId, workStation))) {
-//                    // 需要重新分配的goodsToStationsList
-//                    Map<String, GoodsToStation> needDistributeGoodsMap = new HashMap<>();
-//                    // 需要完成的工作流
-//                    List<WorkFlow> needFinishWorkFlowList = new ArrayList<>();
-//                    // 所有缺料的分配
-//                    List<String> lackGoodsIdList = goodsToStationList.stream().filter(goodsToStation -> goodsToStation.getDistributeStatus() == 3).map(GoodsToStation::getGoodsId).distinct().toList();
-//                    // 不缺料的分配
-//                    Map<String, GoodsToStation> noLackGoodsMap = goodsToStationList.stream().filter(goodsToStation -> goodsToStation.getDistributeStatus() == 2).collect(Collectors.toMap(GoodsToStation::getGoodsId, goodsToStation -> goodsToStation));
-//                    // 查询当前工作流中所有缺料的数据行
-//                    for (WorkFlow notFinishedWorkFlow : currentWorkFlowList) {
-//                        if (notFinishedWorkFlow.getPickedNum().compareTo(notFinishedWorkFlow.getNeedNum()) < 0) {
-//                            // 缺料时，判断是否当前物料在缺料列表中
-//                            if (lackGoodsIdList.contains(notFinishedWorkFlow.getGoodsId())) {
-//                                // 缺料，添加到需要分配的列表中
-//                                notFinishedWorkFlow.setWorkStatus(2);
-//                                notFinishedWorkFlow.setFinishTime(LocalDateTime.now());
-//                                notFinishedWorkFlow.setOpUser("系统自动完成");
-//                                needFinishWorkFlowList.add(notFinishedWorkFlow);
-//                            } else {
-//                                BigDecimal needNum = notFinishedWorkFlow.getNeedNum().subtract(notFinishedWorkFlow.getPickedNum());
-//                                if (needDistributeGoodsMap.containsKey(notFinishedWorkFlow.getGoodsId())) {
-//                                    // 减少分配数量
-//                                    GoodsToStation oldGoodsToStation = needDistributeGoodsMap.get(notFinishedWorkFlow.getGoodsId());
-//                                    oldGoodsToStation.setDistributedNum(oldGoodsToStation.getDistributedNum().subtract(needNum));
-//                                    oldGoodsToStation.setDistributeStatus(1);
-//                                    needDistributeGoodsMap.replace(notFinishedWorkFlow.getGoodsId(), oldGoodsToStation);
-//                                } else {
-//                                    if (noLackGoodsMap.containsKey(notFinishedWorkFlow.getGoodsId())) {
-//                                        GoodsToStation newGoodsToStation = noLackGoodsMap.get(notFinishedWorkFlow.getGoodsId());
-//                                        newGoodsToStation.setDistributedNum(newGoodsToStation.getDistributedNum().subtract(needNum));
-//                                        newGoodsToStation.setDistributeStatus(1);
-//                                        needDistributeGoodsMap.put(notFinishedWorkFlow.getGoodsId(), newGoodsToStation);
-//                                    } else {
-//                                        GoodsToStation goodsToStation = new GoodsToStation();
-//                                        goodsToStation.setConfigId(notFinishedWorkFlow.getGoodsId() + "_" + workStation);
-//                                        goodsToStation.setGoodsId(notFinishedWorkFlow.getGoodsId());
-//                                        goodsToStation.setWorkStation(workStation);
-//                                        goodsToStation.setDistributeStatus(0);
-//                                        goodsToStation.setDistributedNum(BigDecimal.ZERO);
-//                                        goodsToStation.setTotalNum(needNum);
-//                                        needDistributeGoodsMap.put(notFinishedWorkFlow.getGoodsId(), goodsToStation);
-//                                    }
-//                                }
-//                            }
-//                        } else {
-//                            // 不缺料，直接完成
-//                            notFinishedWorkFlow.setWorkStatus(2);
-//                            notFinishedWorkFlow.setFinishTime(LocalDateTime.now());
-//                            notFinishedWorkFlow.setOpUser("系统自动完成");
-//                            needFinishWorkFlowList.add(notFinishedWorkFlow);
-//                        }
-//                    }
-//                    // 保存重新分配的goodsToStationList
-//                    goodsToStationService.saveOrUpdateBatch(needDistributeGoodsMap.values());
-//                    // 保存需要完成的工作流
-//                    workFlowService.updateBatchById(needFinishWorkFlowList);
-//                }
-//                return;
-//            }
-//            for (GoodsToStation goodsToStation : notFinishedGoodsList) {
-//                // 当前物料当前站台需求数量
-//                BigDecimal needNum = goodsToStation.getTotalNum().subtract(goodsToStation.getDistributedNum());
-//                if (needNum.compareTo(BigDecimal.ZERO) == 0) {
-//                    // 需求数量为0
-//                    continue;
-//                }
-//                // 判断实际库存是否充足
-//                List<Stock> stockList = stockService.list(new LambdaQueryWrapper<Stock>()
-//                        .apply("goods_related ->> '$.goodsId' = {0}" + MYSQL_JSON_CI, goodsToStation.getGoodsId())
-//                        .apply("goods_related ->> '$.remainNum' > 0"));
-//                if (stockList == null || stockList.isEmpty()) {
-//                    goodsToStation.setDistributeStatus(3);
-//                    continue;
-//                }
-//                // 判断当前物料是否在流转中
-//                needNum = wmsTaskService.callGoods(goodsToStation.getGoodsId(), needNum, workStation);
-//                // 判断此时需求数量是否为0
-//                if (needNum.compareTo(BigDecimal.ZERO) <= 0) {
-//                    // 分配完成
-//                    goodsToStation.setDistributeStatus(2);
-//                } else {
-//                    needNum = wmsTaskService.callStocks(goodsToStation.getGoodsId(), needNum, workStation);
-//                    if (needNum.compareTo(BigDecimal.ZERO) > 0) {
-//                        // 已分配但未完全分配
-//                        goodsToStation.setDistributeStatus(1);
-//                    } else {
-//                        // 分配完成
-//                        goodsToStation.setDistributeStatus(2);
-//                    }
-//                }
-//                // 更新已分配数量
-//                goodsToStation.setDistributedNum(goodsToStation.getTotalNum().subtract(needNum));
-//            }
-//            goodsToStationService.updateBatchById(notFinishedGoodsList);
-//        } catch (Exception e) {
-//            logger.error("执行站台：{}工作发生异常：{}", workStation, convertJsonString(e));
-//            // 回滚事务
-//            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
-//        } finally {
-//            // 当前站台创建任务完成
-//            workDoingStations.remove(workStation);
-//        }
-//    }
-
     /**
      * 新版完成工作
+     *
      * @param workStation 工作站台
      * @return 结果
      * @throws Exception 异常
@@ -691,90 +474,6 @@ public class WorkServiceImplements implements IWorkService {
         return "";
     }
 
-//    @Override
-//    public String finishWork(String workStation) throws Exception {
-//        if (workFinishingStations.contains(workStation)) {
-//            // 当前站台正在完成工作
-//            return "当前站台正在完成工作，请勿重复操作";
-//        } else {
-//            // 添加站台
-//            workFinishingStations.add(workStation);
-//        }
-//        try {
-//            if (workFlowService.exists(new LambdaQueryWrapper<WorkFlow>()
-//                    .eq(WorkFlow::getWorkStation, workStation)
-//                    .eq(WorkFlow::getWorkStatus, 1))) {
-//                // 当前站台工作未全部完成
-//                return "工作未全部做完，不允许确认完成。";
-//            }
-//            if (eLocationConfigService.exists(new LambdaQueryWrapper<ELocationConfig>()
-//                    .eq(ELocationConfig::getWorkStation, workStation)
-//                    .eq(ELocationConfig::getPrintStatus, 0))) {
-//                // 有标签未打印
-//                return "有标签未打印";
-//            }
-//            if (!eLocationConfigService.exists(new LambdaQueryWrapper<ELocationConfig>()
-//                    .eq(ELocationConfig::getWorkStation, workStation))) {
-//                // 没有标签，说明点过确认。
-//                return "没有可以确认完成的工作，请勿重复点击。";
-//            }
-//            // 查找当前站台的标签配置
-//            List<ELocationConfig> eLocationConfigList = eLocationConfigService.list(new LambdaQueryWrapper<ELocationConfig>()
-//                    .eq(ELocationConfig::getWorkStation, workStation));
-//            // 保存一下记录
-//            List<ELocationConfigLast> eLocationConfigLastList = ELocationConfig.toLocationsConfigLastList(eLocationConfigList);
-//            // 先清空之前的
-//            eLocationConfigLastService.remove(new LambdaQueryWrapper<ELocationConfigLast>()
-//                    .eq(ELocationConfigLast::getWorkStation, workStation));
-//            eLocationConfigLastService.saveBatch(eLocationConfigLastList);
-//            // 删除所有的标签配置
-//            eLocationConfigService.remove(new LambdaQueryWrapper<ELocationConfig>()
-//                    .eq(ELocationConfig::getWorkStation, workStation));
-//            // 查询当前站台的所有工作流列表
-//            List<WorkFlow> workFlowList = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
-//                    .eq(WorkFlow::getWorkStation, workStation)
-//                    .eq(WorkFlow::getWorkStatus, 2));
-//            // workSummary列表
-//            List<WorkSummary> workSummaryList = new ArrayList<>();
-//            for (WorkFlow workFlow : workFlowList) {
-//                WorkSummary summary = new WorkSummary();
-//                summary.setWorkFlowId(workFlow.getWorkFlowId());
-//                summary.setWorkStation(workFlow.getWorkStation());
-//                summary.setWorkOrder(workFlow.getWorkOrder());
-//                summary.setWorkCenter(workFlow.getWorkCenter());
-//                summary.setGoodsId(workFlow.getGoodsId());
-//                summary.setPickedNum(workFlow.getPickedNum());
-//                summary.setNeedNum(workFlow.getNeedNum());
-//                summary.setLackNum(workFlow.getNeedNum().subtract(workFlow.getPickedNum()));
-//                summary.setWorkDate(workFlow.getCreateTime().toLocalDate().atStartOfDay());
-//                summary.setWorkStatus(workFlow.getWorkStatus());
-//                summary.setLackStatus(summary.getLackNum().compareTo(BigDecimal.ZERO) > 0 ? 1 : 0);
-//                summary.setFinishTime(workFlow.getFinishTime());
-//                summary.setOpUser(workFlow.getOpUser());
-//                // 设置电子标签位置
-//                List<ELocationConfig> currentBoxELocationList = eLocationConfigList.stream().filter(e ->
-//                        e.getWorkOrder().equals(workFlow.getWorkOrder())
-//                                && e.getWorkCenter().equals(workFlow.getWorkCenter())).toList();
-//                summary.setELocationId(currentBoxELocationList.size() > 0 ? currentBoxELocationList.get(0).getELocationId() : "");
-//                workSummaryList.add(summary);
-//            }
-//            workSummaryService.saveBatch(workSummaryList);
-//            // 移除工作流
-//            workFlowService.remove(new LambdaQueryWrapper<WorkFlow>()
-//                    .eq(WorkFlow::getWorkStation, workStation));
-//            // 移库站台要料
-//            goodsToStationService.remove(new LambdaQueryWrapper<GoodsToStation>()
-//                    .eq(GoodsToStation::getWorkStation, workStation));
-//        } catch (Exception e) {
-//            logger.error("完成站台：{}工作发生异常：{}", workStation, convertJsonString(e));
-//            throw new Exception("完成站台：" + workStation + "工作发生异常!");
-//        } finally {
-//            // 当前站台工作完成
-//            workFinishingStations.remove(workStation);
-//        }
-//        return "";
-//    }
-
     /**
      * 先找到MWL的小工位的配置
      *
@@ -862,7 +561,7 @@ public class WorkServiceImplements implements IWorkService {
                     // 通过工单表查询到对应的工单
                     List<KateOrders> kateWorkOrderList = allNewKateWorkOrders.stream().filter(kateWorkOrder ->
                             kateWorkOrder.getWorkOrder().equals(currentWorkCenterAndOrderDto.getWorkOrder())
-                    && kateWorkOrder.getSupplyArea().equals(currentWorkCenterAndOrderDto.getWorkCenter())).toList();
+                                    && kateWorkOrder.getSupplyArea().equals(currentWorkCenterAndOrderDto.getWorkCenter())).toList();
                     for (KateOrders tempOrder : kateWorkOrderList) {
                         // 生成workFlow
                         WorkFlow tempWorkFlow = new WorkFlow();

src/main/java/com/wms/utils/excel/listener/UploadKanbanListener.java

@@ -3,6 +3,7 @@ package com.wms.utils.excel.listener;
 import com.alibaba.excel.context.AnalysisContext;
 import com.alibaba.excel.read.listener.ReadListener;
 import com.alibaba.excel.util.ListUtils;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.wms.entity.app.dto.extend.KanbanEntity;
 import com.wms.entity.table.Goods;
 import com.wms.entity.table.Kanban;
@@ -38,12 +39,10 @@ public class UploadKanbanListener implements ReadListener<KanbanGoodsExcelVo> {
     private final KanbanService kanbanService;// 看板服务
     private final String uploadUser;// 用户
     private final Map<String, Goods> goodsMap;// 物料清单
-    private final Map<String, Kanban> oldKanbanMap;// 看板列表
+    public UploadKanbanListener(GoodsService goodsService, Map<String, Goods> goodsMap, KanbanService kanbanService, String uploadUser) {
-    public UploadKanbanListener(GoodsService goodsService, Map<String, Goods> goodsMap, KanbanService kanbanService, Map<String, Kanban> oldKanbanMap, String uploadUser) {
         this.goodsService = goodsService;
         this.goodsMap = goodsMap;
         this.kanbanService = kanbanService;
-        this.oldKanbanMap = oldKanbanMap;
         this.uploadUser = uploadUser;
     }
 
@@ -93,6 +92,7 @@ public class UploadKanbanListener implements ReadListener<KanbanGoodsExcelVo> {
      */
     private void saveData() {
         // 开始存储数据
+        List<String> goodsIds = new ArrayList<>();
         List<Goods> goodsList = new ArrayList<>();
         List<Kanban> newKanbanList = new ArrayList<>();
         for (KanbanGoodsExcelVo goodsExcelVo : cachedDataList) {
@@ -109,24 +109,25 @@ public class UploadKanbanListener implements ReadListener<KanbanGoodsExcelVo> {
             currentGoods.setLastUpdateTime(LocalDateTime.now());
             currentGoods.setLastUpdateUser(uploadUser);
             goodsList.add(currentGoods);
+            // 物料id列表
+            goodsIds.add(currentGoods.getGoodsId());
             // 查询当前料所有的看板
             for (KanbanEntity kanbanEntity : kanbanList) {
-                if (!oldKanbanMap.containsKey(currentGoods.getGoodsId() + kanbanEntity.getKanbanId())) {
+                // 添加新看板
-                    // 添加新看板
+                Kanban newKanban = new Kanban();
-                    Kanban newKanban = new Kanban();
+                newKanban.setRecordId(generateId("KANBAN_"));
-                    newKanban.setRecordId(generateId("KANBAN_"));
+                newKanban.setGoodsId(currentGoods.getGoodsId());
-                    newKanban.setGoodsId(currentGoods.getGoodsId());
+                newKanban.setKanbanId(kanbanEntity.getKanbanId());
-                    newKanban.setKanbanId(kanbanEntity.getKanbanId());
+                newKanban.setKanbanStatus(1);// 默认置满
-                    newKanban.setKanbanStatus(1);// 默认置满
+                newKanban.setLastPullTime(LocalDateTime.now());
-                    newKanban.setLastPullTime(LocalDateTime.now());
+                newKanban.setLastPullUser(uploadUser);
-                    newKanban.setLastPullUser(uploadUser);
+                newKanbanList.add(newKanban);
-                    newKanbanList.add(newKanban);
-                }
             }
         }
         // 保存物料看板信息
         goodsService.saveOrUpdateBatch(goodsList);
         // 保存看板需求信息
+        kanbanService.remove(new LambdaQueryWrapper<Kanban>().in(Kanban::getGoodsId, goodsIds));
         kanbanService.saveOrUpdateBatch(newKanbanList);
         // 打印保存数量
         SAVE_COUNT += goodsList.size();