代码更新：

1. 增加盘点功能
2. 修改呼叫料箱逻辑：少少多
3. 间接物料

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

@@ -165,6 +165,9 @@ public class TaskController {
     private final IWorkService workService;
     private final WorkFlowLastService workFlowLastService;// 服务
     private final StandStackerTaskService standStackerTaskService;// 特殊服务
+    private final InventoryListService inventoryService;
+    private final WorkSummaryService workSummaryService;
+    private final InventoryHistoryService inventoryHistoryService;
 
     /**
      * 接收入库任务请求
@@ -485,6 +488,8 @@ public class TaskController {
                         pickTaskService.remove(new LambdaQueryWrapper<PickTask>().eq(PickTask::getVehicleId, inTask.getVehicleId()));
                         // 移除当前料箱所有的outsideVehicles
                         outsideVehiclesService.remove(new LambdaQueryWrapper<OutsideVehicles>().eq(OutsideVehicles::getVehicleId, inTask.getVehicleId()));
+                        // 清除当前料箱的所有盘点任务
+                        inventoryService.remove(new LambdaQueryWrapper<InventoryList>().eq(InventoryList::getVehicleId, inTask.getVehicleId()));
                     }
                 }
                 // 出库任务
@@ -2079,36 +2084,41 @@ public class TaskController {
                 return convertJsonString(response);
             }
             // 验证请求信息
-            if (Objects.equals(callEmptyVehicleRequest.getVehicleType2(), "间接物料")) {
+//            if (Objects.equals(callEmptyVehicleRequest.getVehicleType2(), "间接物料")) {
-                // TODO 间接物料需要确认
+//                // TODO 间接物料需要确认
-                if (StringUtils.isEmpty(callEmptyVehicleRequest.getGoodsId())) {
+//                if (StringUtils.isEmpty(callEmptyVehicleRequest.getGoodsId())) {
-                    logger.error("间接物料必须输入物料号");
+//                    logger.error("间接物料必须输入物料号");
-                    response.setCode(ResponseCode.ERROR.getCode());
+//                    response.setCode(ResponseCode.ERROR.getCode());
-                    response.setMessage("间接物料必须输入物料号");
+//                    response.setMessage("间接物料必须输入物料号");
-                    return convertJsonString(response);
+//                    return convertJsonString(response);
-                }
+//                }
-                // 查询物料是否是间接物料
+//                // 查询物料是否是间接物料
-                Goods goods = goodsService.getOne(new LambdaQueryWrapper<Goods>().eq(Goods::getGoodsId, callEmptyVehicleRequest.getGoodsId()).eq(Goods::getGoodsInVehicleType, "间接物料").last("limit 1"));
+//                Goods goods = goodsService.getOne(new LambdaQueryWrapper<Goods>().eq(Goods::getGoodsId, callEmptyVehicleRequest.getGoodsId()).eq(Goods::getGoodsInVehicleType, "间接物料").last("limit 1"));
-                if (goods == null) {
+//                if (goods == null) {
-                    logger.error("当前物料不是间接物料");
+//                    logger.error("当前物料不是间接物料");
-                    response.setCode(ResponseCode.ERROR.getCode());
+//                    response.setCode(ResponseCode.ERROR.getCode());
-                    response.setMessage("当前物料不是间接物料");
+//                    response.setMessage("当前物料不是间接物料");
-                    return convertJsonString(response);
+//                    return convertJsonString(response);
-                }
+//                }
-                callEmptyVehicleRequest.setVehicleType1(goods.getVehicleType());
+//                callEmptyVehicleRequest.setVehicleType1(goods.getVehicleType());
-            }
+//            }
 
             // 生成料箱出库任务
             int needNum = callEmptyVehicleRequest.getNeedNum();
             List<Task> vehicleOutTasks = new ArrayList<>();// 任务列表
             List<String> outVehicleIds = new ArrayList<>();// 料箱列表
             // 查询出需求数量的空箱
-            List<Vehicle> emptyVehicles = vehicleService.list(new LambdaQueryWrapper<Vehicle>()
+            LambdaQueryWrapper<Vehicle> emptyVehicleQueryWrapper = new LambdaQueryWrapper<Vehicle>()
-                    .eq(StringUtils.isNotEmpty(callEmptyVehicleRequest.getVehicleType1()), Vehicle::getVehicleType, callEmptyVehicleRequest.getVehicleType1())
                     .eq(Vehicle::getIsEmpty, 1)
                     .eq(Vehicle::getVehicleStatus, VehicleStatus.ON.getCode())
                     .orderByAsc(Vehicle::getLastInTime)
-                    .last("limit " + needNum));
+                    .last("limit " + needNum);
+            if (Objects.equals(callEmptyVehicleRequest.getVehicleType2(), "间接物料")) {
+                emptyVehicleQueryWrapper.eq(Vehicle::getVehicleType, "间接物料");
+            } else {
+                emptyVehicleQueryWrapper.ne(Vehicle::getVehicleType, "间接物料");
+            }
+            List<Vehicle> emptyVehicles = vehicleService.list(emptyVehicleQueryWrapper);
             for (Vehicle emptyVehicle : emptyVehicles) {
                 if (needNum <= 0) {
                     break;
@@ -3128,6 +3138,14 @@ public class TaskController {
                 response.setMessage("请求缺少必须参数，箱号、料号、数量不可缺少。");
                 return convertJsonString(response);
             }
+            List<InventoryList> inventoryListList = inventoryService.list(new LambdaQueryWrapper<InventoryList>()
+                    .eq(InventoryList::getVehicleId, pickNumQuery.getVehicleId()));
+            if (!inventoryListList.isEmpty()) {
+                logger.error("这个箱子还有盘点任务，请先执行盘点。");
+                response.setCode(ResponseCode.ERROR.getCode());
+                response.setMessage("这个箱子还有盘点任务，请先执行盘点。");
+                return convertJsonString(response);
+            }
             // 验证载具号是否重复入库
             if (vehicleService.exists(new LambdaQueryWrapper<Vehicle>().eq(Vehicle::getVehicleId, pickNumQuery.getVehicleId())
                     .and(wrapper -> wrapper.eq(Vehicle::getVehicleStatus, VehicleStatus.ON.getCode())))) {
@@ -3263,4 +3281,299 @@ public class TaskController {
             return convertJsonString(response);
         }
     }
+
+
+
+
+
+
+
+    // TODO 以下是盘点待做
+    /**
+     * 盘点请求
+     *
+     * @param inventoryRequest 请求信息
+     * @return 结果
+     */
+    @PostMapping("/inventoryOut")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    @MyLog(logTitle = "盘点请求", logMethod = "inventoryOut")
+    public String inventoryOut(@RequestBody InventoryRequest inventoryRequest) {
+        logger.info("盘点请求：{}，ip地址：{}", convertJsonString(inventoryRequest), HttpUtils.getIpAddr(servletRequest));
+        ResponseEntity response = new ResponseEntity();
+        try {
+            if (StringUtils.isEmpty(inventoryRequest.getGoodsId())) {
+                logger.error("盘点，请输入料号。");
+                response.setCode(ResponseCode.ERROR.getCode());
+                response.setMessage("盘点，请输入料号。");
+                return convertJsonString(response);
+            }
+            // 查询库存
+            List<Stock> stockList = stockService.list(new LambdaQueryWrapper<Stock>()
+                    .apply("goods_related ->> '$.goodsId' = {0}" + MYSQL_JSON_CI, inventoryRequest.getGoodsId())
+                    .eq(StringUtils.isNotEmpty(inventoryRequest.getVehicleId()), Stock::getVehicleId, inventoryRequest.getVehicleId()));
+            List<Stock> outedStockList = stockList.stream().filter(stock -> !stock.getStockStatus().equals(StockStatus.OK.getCode())).toList();
+            if (!outedStockList.isEmpty()) {
+                logger.error("当前想要盘点的物料未全部在库中，请稍后再试。");
+                response.setCode(ResponseCode.ERROR.getCode());
+                response.setMessage("当前想要盘点的物料未全部在库中，请稍后再试。");
+                return convertJsonString(response);
+            }
+            // 生成出库任务
+            List<Task> outTasks = new ArrayList<>();
+            List<InventoryList> inventoryList = new ArrayList<>();
+            for (Stock stock : stockList) {
+                // 创建出库任务
+                Task tempOutTask = new Task();
+                tempOutTask.setTaskId(generateId("INV_"));
+                tempOutTask.setTaskType(TaskType.OUT.getCode());
+                tempOutTask.setTaskGroup(generateId(""));
+                tempOutTask.setTaskStatus(WmsTaskStatus.NEW.getCode());
+                tempOutTask.setTaskPriority(2);
+                tempOutTask.setVehicleId(stock.getVehicleId());
+                tempOutTask.setUserName(inventoryRequest.getUserName());
+                tempOutTask.setOrigin(stock.getLocationId());
+                tempOutTask.setDestination("");
+                tempOutTask.setCreateTime(LocalDateTime.now());
+                tempOutTask.setIsPicking(1);
+                outTasks.add(tempOutTask);
+                // 创建盘点
+                InventoryList tempInventoryList = new InventoryList();
+                tempInventoryList.setInventoryId(generateId("INV_"));
+                tempInventoryList.setGoodsId(stock.getGoodsRelated().getGoodsId());
+                tempInventoryList.setStockNum(stock.getGoodsRelated().getRemainNum());
+                tempInventoryList.setInventoryStatus(0);
+                tempInventoryList.setInventoryUser(inventoryRequest.getUserName());
+                tempInventoryList.setVehicleId(stock.getVehicleId());
+                tempInventoryList.setInventoryDate(LocalDateTime.now());
+                inventoryList.add(tempInventoryList);
+            }
+            // 添加出库任务
+            if (!outTasks.isEmpty()) {
+                // 保存出库任务
+                taskService.saveBatch(outTasks);
+                // 保存盘点
+                inventoryService.saveBatch(inventoryList);
+                List<String> vehicleIds = outTasks.stream().map(Task::getVehicleId).distinct().toList();
+                // 更新库存状态
+                stockService.update(new LambdaUpdateWrapper<Stock>()
+                        .set(Stock::getStockStatus, StockStatus.OUT.getCode())
+                        .in(Stock::getVehicleId, vehicleIds)
+                        .eq(Stock::getStockStatus, StockStatus.OK.getCode()));
+                // 更新料箱状态
+                vehicleService.update(new LambdaUpdateWrapper<Vehicle>()
+                        .set(Vehicle::getVehicleStatus, VehicleStatus.OUT.getCode())
+                        .in(Vehicle::getVehicleId, vehicleIds)
+                        .eq(Vehicle::getVehicleStatus, VehicleStatus.ON.getCode()));
+            }
+
+            logger.info("下发盘点成功，请等待料箱到达。");
+            response.setCode(ResponseCode.OK.getCode());
+            response.setMessage("下发盘点成功，请等待料箱到达。");
+            return convertJsonString(response);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.error("处理盘点请求异常，{}", convertJsonString(e));
+            response.setCode(ResponseCode.ERROR.getCode());
+            response.setMessage("处理盘点请求异常。");
+            return convertJsonString(response);
+        }
+    }
+
+    /**
+     * 根据物料获取当前的盘点信息
+     *
+     * @param inventoryRequest 请求信息
+     * @return 结果
+     */
+    @PostMapping("/getCurrentGoodsInventory")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    @MyLog(logTitle = "根据物料获取当前的盘点信息", logMethod = "getCurrentGoodsInventory")
+    public String getCurrentGoodsInventory(@RequestBody InventoryRequest inventoryRequest) {
+        logger.info("根据物料获取当前的盘点信息：{}，ip地址：{}", convertJsonString(inventoryRequest), HttpUtils.getIpAddr(servletRequest));
+        ResponseEntity response = new ResponseEntity();
+        try {
+            if (StringUtils.isEmpty(inventoryRequest.getGoodsId())) {
+                logger.error("请输入物料信息。");
+                response.setCode(ResponseCode.ERROR.getCode());
+                response.setMessage("请输入物料信息。");
+                return convertJsonString(response);
+            }
+            List<InventoryVo> inventoryVos = new ArrayList<>();
+            // 查询这个料关于配料的信息
+            List<WorkSummary> workSummaryList = workSummaryService.list(new LambdaQueryWrapper<WorkSummary>()
+                    .eq(WorkSummary::getGoodsId, inventoryRequest.getGoodsId())
+                    .orderByDesc(WorkSummary::getFinishTime));
+            InventoryVo firstInventoryVo = new InventoryVo();
+            if (!workSummaryList.isEmpty()) {
+                // 查询station-config以获取工位信息
+                List<WorkStationConfig> workStationConfigList = workStationConfigService.list(new LambdaQueryWrapper<WorkStationConfig>()
+                        .eq(WorkStationConfig::getSmallBox, workSummaryList.get(0).getWorkCenter()));
+                firstInventoryVo.setFeedingWS(workStationConfigList.isEmpty() ? "" : workStationConfigList.get(0).getWorkCenter());
+                // 查询DBS以获取机器序列号
+                List<KateDBS> kateDBSList = kateDBSService.list(new LambdaQueryWrapper<KateDBS>()
+                        .eq(KateDBS::getWorkOrder, workSummaryList.get(0).getWorkOrder()));
+                firstInventoryVo.setLastFeedingMachineNo(kateDBSList.isEmpty() ? "" : kateDBSList.get(0).getMachineNo());
+                firstInventoryVo.setLastFeedingTime(workSummaryList.get(0).getFinishTime());
+                firstInventoryVo.setIsLack(workSummaryList.get(0).getLackStatus() == 1 ? "是" : "否");
+            }
+            // 查询库存信息
+            List<Stock> stockList = stockService.list(new LambdaQueryWrapper<Stock>()
+                            .apply("goods_related ->> '$.goodsId' = {0}" + MYSQL_JSON_CI, inventoryRequest.getGoodsId()));
+            for (Stock stock : stockList) {
+                InventoryVo inventoryVo = new InventoryVo();
+                inventoryVo.setGoodsId(inventoryRequest.getGoodsId());
+                inventoryVo.setVehiclesQuantity(stockList.size());
+                inventoryVo.setVehicleIds(stock.getVehicleId());
+                String vehicleStatus = "";
+                if (Objects.equals(StockStatus.OK.getCode(), stock.getStockStatus())) {
+                    vehicleStatus = "在库中";
+                } else if (Objects.equals(StockStatus.OUT.getCode(), stock.getStockStatus())) {
+                    vehicleStatus = "等待出库中";
+                } else {
+                    vehicleStatus = "在库外";
+                }
+                inventoryVo.setVehicleStatus(vehicleStatus);
+                inventoryVo.setFeedingWS(firstInventoryVo.getFeedingWS());
+                inventoryVo.setLastFeedingMachineNo(firstInventoryVo.getLastFeedingMachineNo());
+                inventoryVo.setLastFeedingTime(firstInventoryVo.getLastFeedingTime());
+                inventoryVo.setIsLack(firstInventoryVo.getIsLack());
+                inventoryVos.add(inventoryVo);
+            }
+
+            response.setCode(ResponseCode.OK.getCode());
+            response.setMessage("根据物料获取当前的盘点信息成功。");
+            response.setReturnData(inventoryVos);
+            return convertJsonString(response);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.error("根据物料获取当前的盘点信息异常，{}", convertJsonString(e));
+            response.setCode(ResponseCode.ERROR.getCode());
+            response.setMessage("根据物料获取当前的盘点信息异常。");
+            return convertJsonString(response);
+        }
+    }
+
+    /**
+     * 盘点确认
+     *
+     * @param confirmRequest 请求信息
+     * @return 结果
+     */
+    @PostMapping("/inventoryConfirmBack")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    @MyLog(logTitle = "盘点确认", logMethod = "inventoryConfirmBack")
+    public String inventoryConfirmBack(@RequestBody InventoryRequest confirmRequest) {
+        logger.info("盘点确认：{}，ip地址：{}", convertJsonString(confirmRequest), HttpUtils.getIpAddr(servletRequest));
+        ResponseEntity response = new ResponseEntity();
+        try {
+            // 判断信息是否完备
+            if (StringUtils.isEmpty(confirmRequest.getGoodsId())
+            || StringUtils.isEmpty(confirmRequest.getVehicleId())
+            || confirmRequest.getConfirmNum() == null) {
+                logger.error("缺少必须信息。");
+                response.setCode(ResponseCode.ERROR.getCode());
+                response.setMessage("缺少必须信息。");
+                return convertJsonString(response);
+            }
+            // 查询盘点列表
+            List<InventoryList> inventoryListList = inventoryService.list(new LambdaQueryWrapper<InventoryList>()
+                    .eq(InventoryList::getVehicleId, confirmRequest.getVehicleId()));
+            List<InventoryList> currentGoodsInvList = inventoryListList.stream()
+                    .filter(inventoryList -> inventoryList.getGoodsId().equals(confirmRequest.getGoodsId()))
+                    .toList();
+            // 查询下当前库存
+            Stock existStock = stockService.getOne(new LambdaQueryWrapper<Stock>()
+                    .apply("goods_related ->> '$.goodsId' = {0}" + MYSQL_JSON_CI, confirmRequest.getGoodsId())
+                    .eq(Stock::getVehicleId, confirmRequest.getVehicleId())
+                    .last("limit 1"));
+            // 保存盘点记录
+            List<InventoryHistory> historyList = new ArrayList<>();
+            for (InventoryList inventoryList : currentGoodsInvList) {
+                InventoryHistory tempHistory = new InventoryHistory();
+                tempHistory.setInventoryId(inventoryList.getInventoryId());
+                tempHistory.setGoodsId(inventoryList.getGoodsId());
+                tempHistory.setVehicleId(inventoryList.getVehicleId());
+                tempHistory.setStockNum(existStock == null ? BigDecimal.ZERO : existStock.getGoodsRelated().getRemainNum());
+                tempHistory.setRealNum(confirmRequest.getConfirmNum());
+                tempHistory.setInventoryStatus(1);
+                tempHistory.setInventoryResult(tempHistory.getRealNum().compareTo(tempHistory.getStockNum()) == 0 ? 0 : 1);
+                tempHistory.setInventoryUser(confirmRequest.getUserName());
+                tempHistory.setInventoryDate(LocalDateTime.now());
+                historyList.add(tempHistory);
+            }
+            inventoryHistoryService.saveBatch(historyList);
+            inventoryService.removeBatchByIds(currentGoodsInvList);
+            // 判断当前料箱是否还需要盘点
+            List<InventoryList> notCurrentGoodsInvList = inventoryListList.stream()
+                    .filter(inventoryList -> !inventoryList.getGoodsId().equals(confirmRequest.getGoodsId()))
+                    .toList();
+            if (!notCurrentGoodsInvList.isEmpty()) {
+                logger.info("当前料箱其他料仍需要盘点，请继续。");
+                response.setCode(ResponseCode.ERROR.getCode());
+                response.setMessage("当前料箱其他料仍需要盘点，请继续。");
+            } else {
+                // 验证载具号是否重复入库
+                if (vehicleService.exists(new LambdaQueryWrapper<Vehicle>().eq(Vehicle::getVehicleId, confirmRequest.getVehicleId())
+                        .and(wrapper -> wrapper.eq(Vehicle::getVehicleStatus, VehicleStatus.ON.getCode())))) {
+                    logger.error("盘点确认完，但当前箱子{}已在库中，无法回库。", confirmRequest.getVehicleId());
+                    response.setCode(ResponseCode.ERROR.getCode());
+                    response.setMessage("盘点确认完，当前箱子" + confirmRequest.getVehicleId() + "已在库中，无法回库。");
+                    return convertJsonString(response);
+                }
+                // 判断这个箱子是否还有拣选任务
+                boolean hasPickTasks = pickTaskService.exists(new LambdaQueryWrapper<PickTask>()
+                        .eq(PickTask::getVehicleId, confirmRequest.getVehicleId()));
+                if (!hasPickTasks) {
+                    // 判断当前载具是否有回库任务
+                    boolean hasBackTask = taskService.exists(new LambdaQueryWrapper<Task>()
+                            .eq(Task::getVehicleId, confirmRequest.getVehicleId())
+                            .eq(Task::getTaskType, TaskType.IN.getCode())
+                            .likeRight(Task::getTaskId, "HK_"));
+                    if (!hasBackTask) {
+                        // 判断当前载具是否有入库任务
+                        boolean hasInTask = taskService.exists(new LambdaQueryWrapper<Task>()
+                                .eq(Task::getVehicleId, confirmRequest.getVehicleId())
+                                .eq(Task::getTaskType, TaskType.IN.getCode())
+                                .likeRight(Task::getTaskId, "RK_"));
+                        if (!hasInTask) {
+                            // 生成回库任务
+                            Task backTask = new Task();
+                            backTask.setTaskId(generateId("HK_PD_"));
+                            backTask.setTaskGroup(generateId(""));
+                            backTask.setTaskType(TaskType.IN.getCode());
+                            backTask.setTaskStatus(WmsTaskStatus.TEMP.getCode());
+                            backTask.setVehicleId(confirmRequest.getVehicleId());
+                            backTask.setVehicleSize(1);
+                            backTask.setWeight(BigDecimal.ZERO);
+                            backTask.setTaskPriority(1);
+                            backTask.setUserName(confirmRequest.getUserName());
+                            backTask.setCreateTime(LocalDateTime.now());
+                            taskService.save(backTask);
+                        }
+                    }
+                    logger.info("盘点确认结束且确认回库成功。");
+                    response.setCode(ResponseCode.OK.getCode());
+                    response.setMessage("盘点确认结束且确认回库成功。");
+                } else {
+                    logger.error("盘点已经确认完，当前箱子还有拣选任务，不能回库，请将箱子置入拣货环线。");
+                    response.setCode(ResponseCode.ERROR.getCode());
+                    response.setMessage("盘点已经确认完，当前箱子还有拣选任务，不能回库，请将箱子置入拣货环线。");
+                }
+            }
+            return convertJsonString(response);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.error("处理盘点确认请求异常，{}", convertJsonString(e));
+            response.setCode(ResponseCode.ERROR.getCode());
+            response.setMessage("处理盘点确认请求异常。");
+            return convertJsonString(response);
+        }
+    }
 }

src/main/java/com/wms/entity/app/request/InventoryRequest.java

@@ -0,0 +1,37 @@
+package com.wms.entity.app.request;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.math.BigDecimal;
+
+/**
+ * 盘点请求
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class InventoryRequest {
+    /**
+     * 料号
+     */
+    @JsonProperty("goodsId")
+    private String goodsId;
+    /**
+     * 箱号
+     */
+    @JsonProperty("vehicleId")
+    private String vehicleId;
+    /**
+     * 确认数量
+     */
+    @JsonProperty("confirmNum")
+    private BigDecimal confirmNum;
+    /**
+     * 操作人员
+     */
+    @JsonProperty("userName")
+    private String userName;
+}

src/main/java/com/wms/entity/app/vo/InventoryVo.java

@@ -0,0 +1,61 @@
+package com.wms.entity.app.vo;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.time.LocalDateTime;
+
+/**
+ * 盘点信息显示列表
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class InventoryVo {
+    /**
+     * 料号
+     */
+    @JsonProperty("goodsId")
+    private String goodsId;
+    /**
+     * 料箱数量
+     */
+    @JsonProperty("vehiclesQuantity")
+    private Integer vehiclesQuantity;
+    /**
+     * 料箱号
+     */
+    @JsonProperty("vehicleIds")
+    private String vehicleIds;
+    /**
+     * 料箱状态
+     */
+    @JsonProperty("vehicleStatus")
+    private String vehicleStatus;
+    /**
+     * 备料工位
+     */
+    @JsonProperty("feedingWS")
+    private String feedingWS;
+    /**
+     * 最后一台备料机器序列号
+     */
+    @JsonProperty("lastFeedingMachineNo")
+    private String lastFeedingMachineNo;
+    /**
+     * 备料最后一台车日期
+     */
+    @JsonProperty("lastFeedingTime")
+    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime lastFeedingTime;
+    /**
+     * 是否缺料
+     */
+    @JsonProperty("isLack")
+    private String isLack;
+}

src/main/java/com/wms/entity/table/InventoryHistory.java

@@ -54,4 +54,9 @@ public class InventoryHistory {
      */
     @TableField("vehicle_id")
     private String vehicleId;
+    /**
+     * 盘点结果
+     */
+    @TableField("inventory_result")
+    private Integer inventoryResult;
 }

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

@@ -776,7 +776,9 @@ public class WmsJobServiceImplements implements IWmsJobService {
                                 // 找到之前完成的
                                 List<StandStackerTask> currentStandFinishedTasks = standStackerTasks.stream().filter(standStackerTask -> standStackerTask.getStandId().equals(pickStand.getStandId()) && standStackerTask.getTaskType() == 1 && standStackerTask.getTaskStatus() == 1).toList();
                                 if (!currentStandFinishedTasks.isEmpty()) {
-                                    thisQtyType = currentStandFinishedTasks.get(0).getLastQtyType() == 1 ? 2 : 1;
+                                    if (currentStandFinishedTasks.get(0).getLastQtyType() <= 2) {
+                                        thisQtyType = currentStandFinishedTasks.get(0).getLastQtyType() + 1;
+                                    }
                                 }
                                 // 设置分配策略
                                 StandStackerTask newStandStackerTask = new StandStackerTask();
@@ -808,7 +810,7 @@ public class WmsJobServiceImplements implements IWmsJobService {
                                     }
                                 });
                                 String vehicleId;
-                                if (thisQtyType == 1) {
+                                if (thisQtyType == 1 || thisQtyType == 2) {
                                     // 最少使用的箱子
                                     vehicleId = vehicleStandsMap.entrySet().stream()
                                             .min(Comparator.comparingInt(Map.Entry::getValue))
@@ -881,7 +883,7 @@ public class WmsJobServiceImplements implements IWmsJobService {
                     while (availNum > 0) {
                         // 设置分配策略
                         StandStackerTask newStandStackerTask = new StandStackerTask();
-                        newStandStackerTask.setLastQtyType(1);// 超额固定为1
+                        newStandStackerTask.setLastQtyType(2);// 超额固定为2
                         // 查询这个这台堆垛机的料箱号
                         List<String> thisStackerVehicleIds = new ArrayList<>();
                         for (Task task : allTasks) {
@@ -928,7 +930,7 @@ public class WmsJobServiceImplements implements IWmsJobService {
                             }
                         });
                         String vehicleId = vehicleStandsMap.entrySet().stream()
-                                .min(Comparator.comparingInt(Map.Entry::getValue))
+                                .max(Comparator.comparingInt(Map.Entry::getValue))
                                 .map(Map.Entry::getKey)
                                 .orElse("");
                         if (!StringUtils.isEmpty(vehicleId)) {

src/main/java/com/wms/service/serviceImplements/LocationServiceImplements.java

@@ -209,6 +209,7 @@ public class LocationServiceImplements extends ServiceImpl<LocationMapper, Locat
             }
         }
         LambdaQueryWrapper<Location> locationQueryWrapper = new LambdaQueryWrapper<Location>()
+                .ne(Location::getGoodsType, "间接物料")
                 .eq(Location::getAreaId, 1)
                 .eq(Location::getLocationStatus, 0)
                 .eq(Location::getLocationType, 1)

src/main/resources/application.yml

@@ -8,20 +8,20 @@ spring:
                 # 主库
                 master:
                     # 卡特数据库服务器
-                    url: jdbc:mysql://10.90.36.71:3306/wms_kate_suzhou?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowMultiQueries=true&rewriteBatchedStatements=true
+#                    url: jdbc:mysql://10.90.36.71:3306/wms_kate_suzhou?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowMultiQueries=true&rewriteBatchedStatements=true
-                    username: developer
+#                    username: developer
-                    password: developer
+#                    password: developer
-                    driver-class-name: com.mysql.cj.jdbc.Driver
+#                    driver-class-name: com.mysql.cj.jdbc.Driver
                     # 宝开服务器--内网
 #                    url: jdbc:mysql://192.168.3.254:3306/wms_kate_suzhou?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowMultiQueries=true&rewriteBatchedStatements=true
 #                    username: coder
 #                    password: coder
 #                    driver-class-name: com.mysql.cj.jdbc.Driver
 #                    # 本地环境
-#                    url: jdbc:mysql://localhost:3306/wms_kate_suzhou?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowMultiQueries=true&rewriteBatchedStatements=true
+                    url: jdbc:mysql://localhost:3306/wms_kate_suzhou?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowMultiQueries=true&rewriteBatchedStatements=true
-#                    username: developer
+                    username: developer
-#                    password: developer
+                    password: developer
-#                    driver-class-name: com.mysql.cj.jdbc.Driver
+                    driver-class-name: com.mysql.cj.jdbc.Driver
                 # 从库
 #                slave_1:
 #                    url: jdbc:mysql://localhost:3306/wms_aaa?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowMultiQueries=true&rewriteBatchedStatements=true