1. 增加拣选任务记录报表

2. 增加导入工单和dbs时存在不在工作日的日期时报错；
3. 增加显示工作日历的后台功能；
4. 增加一键切换创建与分配。

src/main/java/com/wms/config/InitLocalConfig.java

@@ -5,9 +5,11 @@ import com.wms.constants.enums.ConfigMapKeyEnum;
 import com.wms.entity.table.Config;
 import com.wms.entity.table.Location;
 import com.wms.entity.table.WorkDate;
+import com.wms.entity.table.WorkStationConfig;
 import com.wms.service.ConfigService;
 import com.wms.service.LocationService;
 import com.wms.service.WorkDateService;
+import com.wms.service.WorkStationConfigService;
 import lombok.RequiredArgsConstructor;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -40,11 +42,17 @@ public class InitLocalConfig implements ApplicationRunner {
      * 工作日历服务
      */
     private final WorkDateService workDateService;
+    /**
+     * 工站配置服务
+     */
+    private final WorkStationConfigService workStationConfigService;
 
     protected final Logger logger = LoggerFactory.getLogger(this.getClass());
     public static Map<String, String> configMap = new HashMap<>();
     public static Map<String, Location> instantLocationMap = new HashMap<>();
     public static List<LocalDate> localWorkDateList = new ArrayList<>();
+    public static Map<String, Integer> smallBoxDateAdjustMap = new HashMap<>();// 小盒子号对应开工日期调整map
+
     @Override
     public void run(ApplicationArguments args) {
         List<Config> configs = configService.selectConfigs("");
@@ -74,5 +82,8 @@ public class InitLocalConfig implements ApplicationRunner {
         // 生成工作日历
         localWorkDateList = workDateService.list(new LambdaQueryWrapper<WorkDate>().orderByAsc(WorkDate::getWorkDate)).stream().map(WorkDate::getWorkDate).distinct().toList();
         logger.info("生成工作日历Map成功。");
+        // 生成小盒子号对应开工日期调整Map
+        smallBoxDateAdjustMap = workStationConfigService.list().stream().collect(Collectors.toMap(WorkStationConfig::getSmallBox, WorkStationConfig::getStartDateAdjust));
+        logger.info("生成小盒子号对应开工日期调整Map成功。");
     }
 }

src/main/java/com/wms/constants/enums/ConfigMapKeyEnum.java

@@ -1,5 +1,11 @@
 package com.wms.constants.enums;
 
+import lombok.Getter;
+
+/**
+ * 配置项枚举
+ */
+@Getter
 public enum ConfigMapKeyEnum {
     MAX_WEIGHT("MAX_WEIGHT"),
     URL_WCS_TASK("URL_WCS_TASK"),
@@ -30,12 +36,12 @@ public enum ConfigMapKeyEnum {
     IF_MERGE_TOMORROW("IF_MERGE_TOMORROW"),
     SAME_MACHINE("SAME_MACHINE"),
     SAME_AREA("SAME_AREA"),
-    RATE_TYPE("RATE_TYPE");
+    RATE_TYPE("RATE_TYPE"),
+    USE_REQUIRE_DATE("USE_REQUIRE_DATE"),// 是否使用需求时间
+    USE_DEFAULT_ADJUST("USE_DEFAULT_ADJUST"),// 使用默认调整天数
+    START_DATE_ADJUST("START_DATE_ADJUST");// 开工日期调整天数
     private final String configKey;
     ConfigMapKeyEnum(String configKey) {
         this.configKey = configKey;
     }
-    public String getConfigKey() {
-        return configKey;
-    }
 }

src/main/java/com/wms/constants/enums/PickTaskStatusEnum.java

@@ -1,5 +1,8 @@
 package com.wms.constants.enums;
 
+import lombok.Getter;
+
+@Getter
 public enum PickTaskStatusEnum {
     TEMP(-1, "暂存"),
     NEW(0, "初始化"),
@@ -15,11 +18,13 @@ public enum PickTaskStatusEnum {
         this.value = value;
     }
 
-    public Integer getCode() {
-        return code;
+    public static String getValueByCode(Integer code) {
+        for (PickTaskStatusEnum value : PickTaskStatusEnum.values()) {
+            if (value.code.equals(code)) {
+                return value.value;
+            }
+        }
+        return "错误枚举值";
     }
 
-    public String getValue() {
-        return value;
-    }
 }

src/main/java/com/wms/constants/enums/StockStatus.java

@@ -1,8 +1,11 @@
 package com.wms.constants.enums;
 
+import lombok.Getter;
+
 /**
  * 库存状态枚举
  */
+@Getter
 public enum StockStatus {
     OK(0, "库存正常"),
     OUT(1, "出库中"),
@@ -10,6 +13,7 @@ public enum StockStatus {
     MOVE(3, "移库中"),
     PICKING(4, "拣选中"),
     BACK(5, "回库中"),
+    OUTED(6, "已出库"),
     LOCK(9, "库存锁定");
 
     private final Integer code;
@@ -21,11 +25,4 @@ public enum StockStatus {
         this.value = value;
     }
 
-    public Integer getCode() {
-        return code;
-    }
-
-    public String getValue() {
-        return value;
-    }
 }

src/main/java/com/wms/constants/enums/StockUpdateReasonEnum.java

@@ -13,7 +13,8 @@ public enum StockUpdateReasonEnum {
     KITTING_UPDATE("备料拣选更新"),
     CONFIRM_UPDATE("站台确认更新"),
     CONFIRM_DELETE("站台处理箱料错误"),
-    CLC_NO_PLAN_UPDATE("直接物料非计划领料回库更新");
+    CLC_NO_PLAN_UPDATE("直接物料非计划领料回库更新"),
+    INV_CONFIRM("盘点确认数量不一致更新");
 
     StockUpdateReasonEnum(String reason) {
         this.reason = reason;

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

@@ -15,6 +15,7 @@ import com.wms.entity.app.vo.FileVo;
 import com.wms.entity.app.vo.UploadRecordVo;
 import com.wms.entity.table.*;
 import com.wms.service.*;
+import com.wms.service.business.IWorkService;
 import com.wms.utils.HttpUtils;
 import com.wms.utils.StringUtils;
 import com.wms.utils.excel.listener.*;
@@ -26,7 +27,6 @@ import lombok.RequiredArgsConstructor;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Controller;
 import org.springframework.transaction.annotation.Isolation;
 import org.springframework.transaction.annotation.Propagation;
@@ -38,9 +38,11 @@ import org.springframework.web.multipart.MultipartFile;
 import java.io.IOException;
 import java.net.URLEncoder;
 import java.nio.charset.StandardCharsets;
+import java.time.LocalDate;
 import java.util.*;
 import java.util.stream.Collectors;
 
+import static com.wms.config.InitLocalConfig.configMap;
 import static com.wms.constants.WmsConstants.MYSQL_JSON_CI;
 import static com.wms.utils.HttpUtils.getIpAddr;
 import static com.wms.utils.StringUtils.convertJsonString;
@@ -69,11 +71,10 @@ public class ExcelController {
     private final WorkFlowService workFlowService;// 工作流服务
     private final WorkDateService workDateService;// 工作日历服务
     private final IStockUpdateRecordService stockUpdateRecordService; // 库存更新记录服务
+    private final IWorkService workService;
 
     private final List<String> uploadFileHashStringList = new ArrayList<>();
-
-    @Value("${reqmtsDate}")
-    private boolean reqmtsDate;
+    private final PickTaskRecordService pickTaskRecordService;
 
     /**
      * 查询上传记录
@@ -103,8 +104,7 @@ public class ExcelController {
         } catch (Exception e) {
             // 回滚事务
             TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
-            e.printStackTrace();
-            logger.error("查询上传记录发生异常：{}", e.getMessage());
+            logger.error("查询上传记录发生异常：{}", convertJsonString(e));
             response.setCode(ResponseCode.ERROR.getCode());
             response.setMessage("查询上传记录发生异常");
             return convertJsonString(response);
@@ -186,7 +186,7 @@ public class ExcelController {
             TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
             uploadFileHashStringList.remove(fileVo.getHash());
             response.setCode(ResponseCode.ERROR.getCode());
-            response.setMessage("导入工作日历异常。");
+            response.setMessage("导入工作日历异常：" + e.getMessage());
             return convertJsonString(response);
         }
     }
@@ -214,7 +214,7 @@ public class ExcelController {
             // 获取之前DBS表的内容
             Map<String, KateDBS> kateDbsMap = kateDbsService.list().stream().collect(Collectors.toMap(KateDBS::getWorkOrder, kateDBS -> kateDBS));
             // 导入excel
-            EasyExcel.read(file.getInputStream(), KateDbsExcelVo.class, new UploadDbsListener(kateDbsService, kateDbsMap, fileVo.getUserName(),reqmtsDate)).sheet().headRowNumber(8).doRead();
+            EasyExcel.read(file.getInputStream(), KateDbsExcelVo.class, new UploadDbsListener(kateDbsService, kateDbsMap, fileVo.getUserName())).sheet().headRowNumber(8).doRead();
             // 添加导入记录
             uploadRecordService.save(UploadRecord.ofFileVo(fileVo, "DBS"));
             uploadFileHashStringList.remove(fileVo.getHash());
@@ -227,7 +227,7 @@ public class ExcelController {
             TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
             uploadFileHashStringList.remove(fileVo.getHash());
             response.setCode(ResponseCode.ERROR.getCode());
-            response.setMessage("导入DBS异常。");
+            response.setMessage("导入DBS异常：" + e.getMessage());
             return convertJsonString(response);
         }
     }
@@ -253,9 +253,9 @@ public class ExcelController {
             }
             uploadFileHashStringList.add(fileVo.getHash());
             // 获取之前工单表的内容
-            Map<String, KateOrders> kateOrdersMap = kateOrdersService.list().stream().collect(Collectors.toMap(kateOrders -> kateOrders.getWorkOrder() + kateOrders.getGoodsId() + kateOrders.getSupplyArea(), kateOrders -> kateOrders));
+            Map<String, KateOrders> kateOrdersMap = kateOrdersService.list().stream().collect(Collectors.toMap(kateOrders -> kateOrders.getWorkOrder() + "_" + kateOrders.getGoodsId() + "_" + kateOrders.getSupplyArea(), kateOrders -> kateOrders));
             // 导入excel
-            EasyExcel.read(file.getInputStream(), KateOrdersExcelVo.class, new UploadKateOrdersListener(kateOrdersService, kateOrdersMap, fileVo.getUserName(),reqmtsDate)).sheet().doRead();
+            EasyExcel.read(file.getInputStream(), KateOrdersExcelVo.class, new UploadKateOrdersListener(kateOrdersService, kateOrdersMap, fileVo.getUserName())).sheet().doRead();
             // 添加导入记录
             uploadRecordService.save(UploadRecord.ofFileVo(fileVo, "ORDERS"));
             uploadFileHashStringList.remove(fileVo.getHash());
@@ -268,7 +268,7 @@ public class ExcelController {
             TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
             uploadFileHashStringList.remove(fileVo.getHash());
             response.setCode(ResponseCode.ERROR.getCode());
-            response.setMessage("导入工单异常。");
+            response.setMessage("导入工单异常:" + e.getMessage());
             return convertJsonString(response);
         }
     }
@@ -809,6 +809,113 @@ public class ExcelController {
                 .sheet("工作分析报表")
                 .doWrite(goodsList.stream().map(WorkSummaryExcelVo::of).toList());
     }
+
+    /**
+     * 导出拣选任务记录
+     *
+     * @param response 请求
+     */
+    @PostMapping("/downloadPickTaskRecordsExcel")
+    @ResponseBody
+    public void downloadPickTaskRecordsExcel(@RequestBody PickTaskRecordQuery pickTaskRecordQuery, HttpServletResponse response) throws IOException {
+        logger.info("导出拣选任务记录，筛选参数：{}，请求ip：{}", convertJsonString(pickTaskRecordQuery), getIpAddr(servletRequest));
+        //设置响应格式
+        response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
+        response.setCharacterEncoding("utf-8");
+        // 这里URLEncoder.encode可以防止中文乱码 当然和easyexcel没有关系
+        String fileName = URLEncoder.encode("拣选任务记录", StandardCharsets.UTF_8).replaceAll("\\+", "%20");
+        response.setHeader("Content-Disposition", "attachment;filename*=utf-8''" + fileName + ".xlsx");
+        // 内容样式
+        HorizontalCellStyleStrategy horizontalCellStyleStrategy = ExcelContentStyle.getContentStyle();
+        List<PickTaskRecord> recordList = Collections.emptyList();
+        if (pickTaskRecordQuery.getWorkDate() != null) {
+            var queryWrapper = new LambdaQueryWrapper<PickTaskRecord>()
+                    .like(StringUtils.isNotEmpty(pickTaskRecordQuery.getVehicleId()), PickTaskRecord::getVehicleId, pickTaskRecordQuery.getVehicleId())
+                    .like(StringUtils.isNotEmpty(pickTaskRecordQuery.getStandId()), PickTaskRecord::getStandId, pickTaskRecordQuery.getStandId())
+                    .between(PickTaskRecord::getArriveTime, pickTaskRecordQuery.getWorkDate().atStartOfDay(), pickTaskRecordQuery.getWorkDate().plusDays(1).atStartOfDay().minusSeconds(1));
+            recordList = pickTaskRecordService.list(queryWrapper);
+        }
+        EasyExcel.write(response.getOutputStream(), PickTaskRecordExcelVo.class)
+                .excelType(ExcelTypeEnum.XLSX)
+                .registerWriteHandler(horizontalCellStyleStrategy)
+                .sheet("拣选任务记录报表")
+                .doWrite(recordList.stream().map(PickTaskRecordExcelVo::fromPo).toList());
+    }
+
+    /**
+     * 导出工单
+     *
+     * @param response 请求
+     */
+    @PostMapping("/downloadKateOrdersExcel")
+    @ResponseBody
+    public void downloadKateOrdersExcel(@RequestBody KateOrdersQuery kateOrdersQuery, HttpServletResponse response) throws IOException {
+        logger.info("导出工单，筛选参数：{}，请求ip：{}", convertJsonString(kateOrdersQuery), getIpAddr(servletRequest));
+        //设置响应格式
+        response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
+        response.setCharacterEncoding("utf-8");
+        // 这里URLEncoder.encode可以防止中文乱码 当然和easyexcel没有关系
+        String fileName = URLEncoder.encode("工单报表", StandardCharsets.UTF_8).replaceAll("\\+", "%20");
+        response.setHeader("Content-Disposition", "attachment;filename*=utf-8''" + fileName + ".xlsx");
+        // 内容样式
+        HorizontalCellStyleStrategy horizontalCellStyleStrategy = ExcelContentStyle.getContentStyle();
+        // 结果列表
+        List<KateOrders> kateOrdersList = Collections.emptyList();
+        if (kateOrdersQuery.getPlanStartDate() != null) {
+            // 添加进总汇总数据
+            List<WorkFlow> allFlows = new ArrayList<>();
+            // 查询配置是否使用默认开工日期
+            String useReqmtDate = configMap.get(ConfigMapKeyEnum.USE_REQUIRE_DATE.getConfigKey());
+            if (!StringUtils.isEmpty(useReqmtDate) && useReqmtDate.equals("1")) {// 使用工单的开工日期
+                // 查询配置是否使用默认开工日期调整
+                String useDefaultAdjust = configMap.get(ConfigMapKeyEnum.USE_DEFAULT_ADJUST.getConfigKey());
+                if (!StringUtils.isEmpty(useDefaultAdjust) && useDefaultAdjust.equals("1")) {
+                    workService.findCurrentDateWorks(allFlows, kateOrdersQuery.getPlanStartDate());
+                } else {
+                    workService.findCurrentDateWorksUseConfig(allFlows, kateOrdersQuery.getPlanStartDate());
+                }
+            } else {
+                // 获取当天所有的装载机工作
+                List<WorkFlow> thisDayMWLWorks = new ArrayList<>();
+                // 获取到当天所有的平地机工作
+                List<WorkFlow> thisDayMGWorks = new ArrayList<>();
+                // 需要合并第二天的平地机工作
+                List<WorkFlow> nextDayMGWorks = new ArrayList<>();
+                // 生成装载机工作流
+                workService.findWorks("", thisDayMWLWorks, "MWL", kateOrdersQuery.getPlanStartDate());
+                if (!thisDayMWLWorks.isEmpty()) {
+                    allFlows.addAll(thisDayMWLWorks);
+                }
+                // 生成当天平地机工作流
+                workService.findWorks("", thisDayMGWorks, "NOT_MWL", kateOrdersQuery.getPlanStartDate());
+                if (!thisDayMGWorks.isEmpty()) {
+                    allFlows.addAll(thisDayMGWorks);
+                    // 查询配置是否需要合并第二天的配置
+                    String ifMergeTomorrow = configMap.get(ConfigMapKeyEnum.IF_MERGE_TOMORROW.getConfigKey());
+                    if (!StringUtils.isEmpty(ifMergeTomorrow) && ifMergeTomorrow.equals("1")) {
+                        // 获取下一个工作日
+                        LocalDate nextWorkDate = workService.nextWorkDate(kateOrdersQuery.getPlanStartDate());
+                        if (nextWorkDate != null && nextWorkDate.isAfter(kateOrdersQuery.getPlanStartDate())) {
+                            workService.findWorks("", nextDayMGWorks, "NOT_MWL", nextWorkDate);
+                        }
+                        if (!nextDayMGWorks.isEmpty()) {
+                            // 添加第二天的平地机工作进汇总
+                            allFlows.addAll(nextDayMGWorks);
+                        }
+                    }
+                }
+            }
+            if (!allFlows.isEmpty()) {
+                kateOrdersList = kateOrdersService.listByIds(allFlows.stream().map(WorkFlow::getOrderId).distinct().toList());
+            }
+        }
+        EasyExcel.write(response.getOutputStream(), KateOrdersExcelVo.class)
+                .excelType(ExcelTypeEnum.XLSX)
+                .registerWriteHandler(horizontalCellStyleStrategy)
+                .sheet("工单报表")
+                .doWrite(kateOrdersList.stream().map(KateOrdersExcelVo::of).toList());
+    }
+
     /**
      * 导出工作流总结
      *

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

@@ -1,14 +1,12 @@
 package com.wms.controller;
 
 import cn.hutool.core.bean.BeanUtil;
-import com.alibaba.fastjson2.JSON;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.wms.annotation.MyLog;
 import com.wms.constants.enums.ResponseCode;
 import com.wms.entity.app.ResponseEntity;
-import com.wms.entity.app.dto.GoodsDto;
 import com.wms.entity.app.dto.PageDto;
 import com.wms.entity.app.dto.extend.VehicleDetailInfo;
 import com.wms.entity.app.request.GoodsQuery;
@@ -82,7 +80,8 @@ public class GoodsController {
             Page<Goods> page = goodsQuery.toMpPage();
             Page<Goods> goodsPage = goodsService.page(page, new LambdaQueryWrapper<Goods>()
                     .like(StringUtils.isNotEmpty(goodsQuery.getGoodsId()), Goods::getGoodsId, goodsQuery.getGoodsId())
-                    .like(StringUtils.isNotEmpty(goodsQuery.getGoodsName()), Goods::getGoodsName, goodsQuery.getGoodsName()));
+                    .like(StringUtils.isNotEmpty(goodsQuery.getGoodsName()), Goods::getGoodsName, goodsQuery.getGoodsName())
+                    .like(StringUtils.isNotEmpty(goodsQuery.getGoodsType()), Goods::getGoodsType, goodsQuery.getGoodsType()));
 
             PageDto<GoodsVo> pageDto = PageDto.of(goodsPage, goods -> BeanUtil.copyProperties(goods, GoodsVo.class));
             response.setCode(ResponseCode.OK.getCode());
@@ -107,7 +106,6 @@ public class GoodsController {
      */
     @PostMapping("/updateGoodsInfo")
     @ResponseBody
-    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
     @MyLog(logTitle = "更新物料信息", logMethod = "updateGoodsInfo")
     public String updateGoodsInfo(@RequestBody GoodsQuery goodsQuery) {
         logger.info("接收到更新物料信息请求：{}，请求ip：{}", convertJsonString(goodsQuery), HttpUtils.getIpAddr(servletRequest));
@@ -133,9 +131,6 @@ public class GoodsController {
             }
             return convertJsonString(rsp);
         } catch (Exception e) {
-            // 回滚事务
-            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
-            e.printStackTrace();
             logger.error("更新物料信息发生异常：{}", e.getMessage());
             // 返回其他异常
             rsp.setCode(ResponseCode.ERROR.getCode());
@@ -168,10 +163,8 @@ public class GoodsController {
             rsp.setReturnData(goodsList);
             return convertJsonString(rsp);
         } catch (Exception e) {
-            // 回滚事务
-            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
             // 返回其他异常
-            logger.error("查询物料信息发生错误：{}", e.getMessage());
+            logger.error("查询物料信息发生异常：{}", e.getMessage());
             rsp.setCode(ResponseCode.ERROR.getCode());
             rsp.setMessage("查询物料发生异常");
             return convertJsonString(rsp);
@@ -218,7 +211,6 @@ public class GoodsController {
      */
     @PostMapping("/deleteGoodsInfo")
     @ResponseBody
-    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
     @MyLog(logTitle = "删除物料信息", logMethod = "deleteGoodsInfo")
     public String deleteVehicle(@RequestBody GoodsQuery goodsQuery) {
         logger.info("接收到删除物料信息请求：{}，请求ip地址：{}", convertJsonString(goodsQuery), HttpUtils.getIpAddr(servletRequest));
@@ -231,7 +223,7 @@ public class GoodsController {
                 rsp.setMessage("请求删除的物料编码为空");
                 return convertJsonString(rsp);
             }
-            if (goodsService.remove(new LambdaQueryWrapper<Goods>().eq(Goods::getGoodsId, goodsQuery.getGoodsId()))) {
+            if (goodsService.removeById(goodsQuery.getGoodsId())) {
                 logger.info("删除物料信息成功");
                 rsp.setCode(ResponseCode.OK.getCode());
                 rsp.setMessage("删除物料信息成功");
@@ -243,8 +235,6 @@ public class GoodsController {
             }
             return convertJsonString(rsp);
         } catch (Exception e) {
-            // 回滚事务
-            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
             logger.error("删除物料信息发生异常：{}", e.getMessage());
             // 返回其他异常
             rsp.setCode(ResponseCode.ERROR.getCode());
@@ -261,7 +251,6 @@ public class GoodsController {
      */
     @PostMapping("/genGoods")
     @ResponseBody
-    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
     @MyLog(logTitle = "生成物料表", logMethod = "genGoods")
     public String genGoods(@RequestBody GoodsQuery goodsQuery) {
         // 9*64*22
@@ -296,8 +285,6 @@ public class GoodsController {
             rsp.setMessage("生成测试物料成功。");
             return convertJsonString(rsp);
         } catch (Exception e) {
-            // 回滚事务
-            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
             logger.info("生成测试物料异常：{}", convertJsonString(e));
             // 返回其他异常
             rsp.setCode(ResponseCode.ERROR.getCode());
@@ -367,11 +354,13 @@ public class GoodsController {
                     vehicle.setVehicleType("间接物料");
                     // 找到这个料箱包含的库存物料列表
                     List<Stock> indirectStocksOfVehicle = allIndirectStock.stream().filter(stock -> stock.getVehicleId().equals(vehicle.getVehicleId())).toList();
-                    List<VehicleDetailInfo> details = new ArrayList<>();
+                    VehicleDetailInfo goodsInfo = new VehicleDetailInfo();
+                    List<String> detailGoodsIds = new ArrayList<>();
                     for (Stock stock : indirectStocksOfVehicle) {
-                        details.add(new VehicleDetailInfo(stock.getGoodsRelated().getGoodsId()));
+                        detailGoodsIds.add(stock.getGoodsRelated().getGoodsId());
                     }
-                    vehicle.setDetails(details);
+                    goodsInfo.setGoodsIds(detailGoodsIds);
+                    vehicle.setGoodsInfo(goodsInfo);
                 }
                 // 更新料箱
                 vehicleService.updateBatchById(allIndirectVehicles);

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

@@ -29,10 +29,12 @@ import org.springframework.web.bind.annotation.*;
 
 import java.math.BigDecimal;
 import java.math.RoundingMode;
+import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.util.*;
 import java.util.stream.Collectors;
 
+import static com.wms.config.InitLocalConfig.localWorkDateList;
 import static com.wms.utils.StringUtils.convertJsonString;
 
 /**
@@ -87,6 +89,10 @@ public class KateWorkQueryController {
      * 库位配置服务
      */
     private final ELocationConfigLastService eLocationConfigLastService;
+    /**
+     * 工作日历服务
+     */
+    private final WorkDateService workDateService;
     /**
      * 请求头部信息
      */
@@ -114,7 +120,6 @@ public class KateWorkQueryController {
         } catch (Exception e) {
             // 回滚事务
             TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
-            e.printStackTrace();
             logger.error("查询DBS发生异常：{}", e.getMessage());
             response.setCode(ResponseCode.ERROR.getCode());
             response.setMessage("查询DBS发生异常");
@@ -232,7 +237,8 @@ public class KateWorkQueryController {
             Page<KateOrders> ordersPage = kateOrderService.page(page, new LambdaQueryWrapper<KateOrders>()
                     .like(StringUtils.isNotEmpty(kateOrdersQuery.getWorkOrder()), KateOrders::getWorkOrder, kateOrdersQuery.getWorkOrder())
                     .like(StringUtils.isNotEmpty(kateOrdersQuery.getGoodsId()), KateOrders::getGoodsId, kateOrdersQuery.getGoodsId())
-                    .like(StringUtils.isNotEmpty(kateOrdersQuery.getSupplyArea()), KateOrders::getSupplyArea, kateOrdersQuery.getSupplyArea()));
+                    .like(StringUtils.isNotEmpty(kateOrdersQuery.getSupplyArea()), KateOrders::getSupplyArea, kateOrdersQuery.getSupplyArea())
+                    .eq(kateOrdersQuery.getPlanStartDate() != null, KateOrders::getPlanStartDate, kateOrdersQuery.getPlanStartDate()));
 
             PageDto<KateOrdersVo> pageDto = PageDto.of(ordersPage, orders -> BeanUtil.copyProperties(orders, KateOrdersVo.class));
             response.setCode(ResponseCode.OK.getCode());
@@ -950,4 +956,157 @@ public class KateWorkQueryController {
             return convertJsonString(response);
         }
     }
+
+    /**
+     * 查询工作日历
+     * @param workDateQuery 查询参数
+     * @return 查询结果
+     */
+    @PostMapping("/queryWorkDate")
+    @ResponseBody
+    public String queryWorkDate(@RequestBody WorkDateQuery workDateQuery) {
+        logger.info("接收到查询工作日历请求：{}，请求ip：{}", convertJsonString(workDateQuery), HttpUtils.getIpAddr(servletRequest));
+        ResponseEntity response = new ResponseEntity();
+        try {
+            if (workDateQuery.getSourceType() == null) {
+                logger.error("查询工作日历的请求参数缺少来源类型。");
+                response.setCode(ResponseCode.ERROR.getCode());
+                response.setMessage("查询工作日历的请求参数缺少来源类型。");
+                return convertJsonString(response);
+            }
+            if (workDateQuery.getSourceType() == 1) {
+                // 查询当前正在使用的
+                List<WorkDateVo> workDateVoList = new ArrayList<>();
+                int index = 0;
+                for (LocalDate workDate : localWorkDateList) {
+                    index++;
+                    if (workDateQuery.getWorkDate() != null && !workDate.equals(workDateQuery.getWorkDate())) {
+                        // 此处用于查询工作日期
+                        continue;
+                    }
+                    WorkDateVo workDateVo = new WorkDateVo();
+                    workDateVo.setKeyId(index);
+                    workDateVo.setWorkDate(workDate);
+                    workDateVoList.add(workDateVo);
+                }
+                // 获取分页信息
+                PageDto<WorkDateVo> pageDto = PageDto.ofList(workDateVoList.size(), (workDateVoList.size() + workDateQuery.getPageSize()) / workDateQuery.getPageSize(), workDateQuery.getPageNo(), workDateQuery.getPageSize(), workDateVoList);
+                response.setCode(ResponseCode.OK.getCode());
+                response.setMessage("查询工作日历成功");
+                response.setReturnData(pageDto);
+                return convertJsonString(response);
+            } else if (workDateQuery.getSourceType() == 2) {
+                // 查询数据库
+                Page<WorkDate> page = workDateQuery.toMpPage();
+                Page<WorkDate> workDatePage = workDateService.page(page, new LambdaQueryWrapper<WorkDate>()
+                        .eq(workDateQuery.getWorkDate() != null, WorkDate::getWorkDate, workDateQuery.getWorkDate()));
+
+                PageDto<WorkDateVo> pageDto = PageDto.of(workDatePage, workDate -> BeanUtil.copyProperties(workDate, WorkDateVo.class));
+                response.setCode(ResponseCode.OK.getCode());
+                response.setMessage("查询工作日历成功。");
+                response.setReturnData(pageDto);
+                return convertJsonString(response);
+            } else {
+                logger.error("查询工作日历的请求参数来源类型错误。");
+                response.setCode(ResponseCode.ERROR.getCode());
+                response.setMessage("查询工作日历的请求参数来源类型错误。");
+                return convertJsonString(response);
+            }
+        } catch (Exception e) {
+            logger.error("查询工作日历发生异常：{}", convertJsonString(e));
+            response.setCode(ResponseCode.ERROR.getCode());
+            response.setMessage("查询工作日历发生异常");
+            return convertJsonString(response);
+        }
+    }
+
+
+    /**
+     * 增加一个工作日
+     *
+     * @param workDateQuery 新增的工作日信息
+     * @return 结果
+     */
+    @PostMapping("/addWorkDate")
+    @ResponseBody
+    @MyLog(logTitle = "新增工作日", logMethod = "addWorkDate")
+    public String addWorkDate(@RequestBody WorkDateQuery workDateQuery) {
+        logger.info("接收到新增工作日请求：{}，请求ip：{}", convertJsonString(workDateQuery), HttpUtils.getIpAddr(servletRequest));
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        try {
+            if (workDateQuery.getWorkDate() == null) {// id为空，不允许执行
+                logger.error("不可新增空的工作日。");
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("不可新增空的工作日。");
+                return convertJsonString(rsp);
+            }
+            // 先查询所有的工作日
+            List<WorkDate> workDateList = workDateService.list(new LambdaQueryWrapper<>());
+            WorkDate newWorkDate = new WorkDate();
+            newWorkDate.setWorkDate(workDateQuery.getWorkDate());
+            newWorkDate.setRemark(workDateQuery.getRemark());
+            workDateList.add(newWorkDate);
+            boolean updateResult = workDateService.updateWorkDate(workDateList);
+            if (updateResult) {
+                logger.info("新增工作日成功。");
+                rsp.setCode(ResponseCode.OK.getCode());
+                rsp.setMessage("新增工作日成功。");
+            } else {
+                logger.error("新增工作日失败。");
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("新增工作日失败。");
+            }
+            return convertJsonString(rsp);
+        } catch (Exception e) {
+            logger.error("新增工作日发生异常：{}", convertJsonString(e));
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage("新增工作日发生异常");
+            return convertJsonString(rsp);
+        }
+    }
+
+    /**
+     * 删除工作日
+     *
+     * @param workDateQuery 删除参数
+     * @return 结果
+     */
+    @PostMapping("/deleteWorkDate")
+    @ResponseBody
+    @MyLog(logTitle = "删除工作日", logMethod = "deleteWorkDate")
+    public String deleteWorkDate(@RequestBody WorkDateQuery workDateQuery) {
+        logger.info("接收到删除工作日请求：{}，请求ip：{}", convertJsonString(workDateQuery), HttpUtils.getIpAddr(servletRequest));
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        try {
+            if (workDateQuery.getWorkDate() == null) {// id为空，不允许执行
+                logger.error("不可删除空的工作日。");
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("不可删除增空的工作日。");
+                return convertJsonString(rsp);
+            }
+            // 先查询所有的工作日
+            List<WorkDate> workDateList = workDateService.list(new LambdaQueryWrapper<>());
+            workDateList.removeIf(workDate -> workDate.getWorkDate().equals(workDateQuery.getWorkDate()));
+            boolean updateResult = workDateService.updateWorkDate(workDateList);
+            if (updateResult) {
+                logger.info("删除工作日成功。");
+                rsp.setCode(ResponseCode.OK.getCode());
+                rsp.setMessage("删除工作日成功。");
+            } else {
+                logger.error("删除工作日失败。");
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("删除工作日失败。");
+            }
+            return convertJsonString(rsp);
+        } catch (Exception e) {
+            logger.error("删除工作日发生异常：{}", convertJsonString(e));
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage("删除工作日发生异常");
+            return convertJsonString(rsp);
+        }
+    }
 }

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

@@ -8,6 +8,8 @@ import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.wms.annotation.MyLog;
 import com.wms.constants.enums.ResponseCode;
 import com.wms.entity.app.dto.PageDto;
+import com.wms.entity.app.dto.extend.VehicleDetailInfo;
+import com.wms.entity.app.dto.extend.VehicleDetailInfo_2;
 import com.wms.entity.app.request.ELocationQuery;
 import com.wms.entity.app.request.LocationQuery;
 import com.wms.entity.app.request.VehicleQuery;
@@ -39,6 +41,7 @@ import org.springframework.web.bind.annotation.*;
 import java.util.ArrayList;
 import java.util.List;
 
+import static com.wms.constants.WmsConstants.MYSQL_JSON_CI;
 import static com.wms.utils.StringUtils.convertJsonString;
 
 /**
@@ -259,7 +262,11 @@ public class LocationController {
         try {
             List<ETagLocation> eLocations = new ArrayList<>();
             for (int i = 1; i <= 9; i++) {
-                for (int j = 1; j <= 120; j++) {
+                for (int j = 1; j <= 160; j++) {
+                    if (j == 128) {
+                        // 128号标签不用
+                        continue;
+                    }
                     ETagLocation eTagLocation = new ETagLocation();
                     if (j < 100) {
                         eTagLocation.setELocationId(i + "-" + StringUtils.padLeft(String.valueOf(j), 2, "0"));
@@ -311,6 +318,7 @@ public class LocationController {
                     .like(StringUtils.isNotEmpty(vehicleQuery.getCurrentLocation()), Vehicle::getCurrentLocation, vehicleQuery.getCurrentLocation())
                     .eq(vehicleQuery.getVehicleStatus() != null, Vehicle::getVehicleStatus, vehicleQuery.getVehicleStatus())
                     .eq(vehicleQuery.getIsEmpty() != null, Vehicle::getIsEmpty, vehicleQuery.getIsEmpty())
+                    .apply(StringUtils.isNotEmpty(vehicleQuery.getGoodsId()), "JSON_CONTAINS(goods_info ->> '$.goodsIds', {0})" + MYSQL_JSON_CI, "\"" + vehicleQuery.getGoodsId() + "\"")
                     .orderByDesc(Vehicle::getLastInTime);
             if (StringUtils.isNotEmpty(vehicleQuery.getVehicleType())) {
                 if (vehicleQuery.getVehicleType().equals("间接物料")) {
@@ -589,4 +597,48 @@ public class LocationController {
 //            return JSON.toJSONString(rsp);
 //        }
 //    }
+
+    /**
+     * 一键更新料箱的物料数据格式
+     *
+     * @param vehicleQuery 料箱
+     * @return 结果
+     */
+    @PostMapping("/updateVehicleGoodsInfoFormat")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    @MyLog(logTitle = "一键更新料箱的物料数据格式", logMethod = "updateVehicleGoodsInfoFormat")
+    public String updateVehicleGoodsInfoFormat(@RequestBody VehicleQuery vehicleQuery) {
+        logger.info("接收到一键更新料箱的物料数据格式请求：{}，请求ip：{}", convertJsonString(vehicleQuery), HttpUtils.getIpAddr(servletRequest));
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        try {
+            // 查询到所有的料箱
+            List<Vehicle> allVehicles = vehicleService.list();
+            List<Vehicle> needUpdateVehicles = new ArrayList<>();
+            for (Vehicle vehicle : allVehicles) {
+                if (vehicle.getDetails() == null || vehicle.getDetails().isEmpty()) {
+                    continue;
+                }
+                List<String> goodsIds = vehicle.getDetails().stream().map(VehicleDetailInfo_2::getGoodsId).distinct().toList();
+                VehicleDetailInfo goodsInfo = new VehicleDetailInfo();
+                goodsInfo.setGoodsIds(goodsIds);
+                vehicle.setGoodsInfo(goodsInfo);
+                needUpdateVehicles.add(vehicle);
+            }
+            // 更新数据
+            vehicleService.updateBatchById(needUpdateVehicles);
+            rsp.setCode(ResponseCode.OK.getCode());
+            rsp.setMessage("更新成功");
+            return convertJsonString(rsp);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.info("一键更新料箱的物料数据格式异常：{}", convertJsonString(e));
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage("一键更新料箱的物料数据格式发生异常");
+            return JSON.toJSONString(rsp);
+        }
+    }
 }

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

@@ -137,6 +137,90 @@ public class StandController {
         }
     }
 
+    /**
+     * 一键切换至创建工作状态
+     *
+     * @param request 站台信息
+     * @return 结果
+     */
+    @PostMapping("/switchToCreate")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    @MyLog(logTitle = "一键切换至创建工作状态", logMethod = "switchToCreate")
+    public String switchToCreate(@RequestBody StandQuery request) {
+        logger.info("接收到一键切换至创建工作状态请求：{}，请求ip：{}", convertJsonString(request), HttpUtils.getIpAddr(servletRequest));
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        try {
+
+            // 更新信息
+            LambdaUpdateWrapper<Stand> lambdaUpdateWrapper = new LambdaUpdateWrapper<Stand>()
+                    .set(Stand::getStandStatus, 1)
+                    .eq(Stand::getIsLock, 0)
+                    .eq(Stand::getStandType, 2);
+            if (standService.update(lambdaUpdateWrapper)) {
+                logger.info("一键切换创建工作成功。");
+                rsp.setCode(ResponseCode.OK.getCode());
+                rsp.setMessage("一键切换创建工作成功。");
+            } else {
+                logger.error("一键切换创建工作失败。");
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("一键切换创建工作失败。");
+            }
+            return convertJsonString(rsp);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.error("一键切换创建工作发生异常：{}", convertJsonString(e));
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage("一键切换创建工作发生异常");
+            return convertJsonString(rsp);
+        }
+    }
+
+    /**
+     * 一键切换至分配工作状态
+     *
+     * @param request 站台信息
+     * @return 结果
+     */
+    @PostMapping("/switchToDistribute")
+    @ResponseBody
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
+    @MyLog(logTitle = "一键切换至分配工作状态", logMethod = "switchToDistribute")
+    public String switchToDistribute(@RequestBody StandQuery request) {
+        logger.info("接收到一键切换至分配工作状态请求：{}，请求ip：{}", convertJsonString(request), HttpUtils.getIpAddr(servletRequest));
+        // 创建响应信息
+        ResponseEntity rsp = new ResponseEntity();
+        try {
+
+            // 更新信息
+            LambdaUpdateWrapper<Stand> lambdaUpdateWrapper = new LambdaUpdateWrapper<Stand>()
+                    .set(Stand::getStandStatus, 0)
+                    .eq(Stand::getIsLock, 0)
+                    .eq(Stand::getStandType, 2);
+            if (standService.update(lambdaUpdateWrapper)) {
+                logger.info("一键切换至分配工作成功。");
+                rsp.setCode(ResponseCode.OK.getCode());
+                rsp.setMessage("一键切换至分配工作成功。");
+            } else {
+                logger.error("一键切换至分配工作失败。");
+                rsp.setCode(ResponseCode.ERROR.getCode());
+                rsp.setMessage("一键切换至分配工作失败。");
+            }
+            return convertJsonString(rsp);
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            logger.error("一键切换至分配工作发生异常：{}", convertJsonString(e));
+            // 返回其他异常
+            rsp.setCode(ResponseCode.ERROR.getCode());
+            rsp.setMessage("一键切换至分配工作发生异常");
+            return convertJsonString(rsp);
+        }
+    }
+
     /**
      * 堆垛机状态变更
      *

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

@@ -112,10 +112,6 @@ public class TaskController {
      * 物料服务
      */
     private final GoodsService goodsService;
-    /**
-     * 流转中物料箱号数据
-     */
-    private final OutsideVehiclesService outsideVehiclesService;
     /**
      * 拣选任务记录服务
      */
@@ -132,10 +128,6 @@ public class TaskController {
      * 工作站配置服务
      */
     private final WorkStationConfigService workStationConfigService;
-    /**
-     * 站台要料服务
-     */
-    private final GoodsToStationService goodsToStationService;
     /**
      * 非计划领料服务
      */
@@ -161,7 +153,6 @@ 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;
@@ -447,9 +438,9 @@ public class TaskController {
                                     newVehicle.setVehicleType(inTask.getGoodsRelated().getGoodsType());
                                     if (Objects.equals(newVehicle.getVehicleType(), "间接物料")) {
                                         // 如果是间接物料，则设置配对物料
-                                        List<VehicleDetailInfo> vehicleDetailInfos = new ArrayList<>();
-                                        vehicleDetailInfos.add(new VehicleDetailInfo(inTask.getGoodsRelated().getGoodsId()));
-                                        newVehicle.setDetails(vehicleDetailInfos);
+                                        VehicleDetailInfo vehicleDetailInfos = new VehicleDetailInfo();
+                                        vehicleDetailInfos.setGoodsIds(new ArrayList<>(List.of(inTask.getGoodsRelated().getGoodsId())));
+                                        newVehicle.setGoodsInfo(vehicleDetailInfos);
                                     }
                                 }
                                 newVehicle.setLastInTime(LocalDateTime.now());
@@ -472,10 +463,22 @@ public class TaskController {
                                     currentVehicle.setVehicleType(inTask.getGoodsRelated().getGoodsType());
                                     if (Objects.equals(currentVehicle.getVehicleType(), "间接物料")) {
                                         // 如果是间接物料，则设置配对物料
-                                        List<VehicleDetailInfo> vehicleDetailInfos = currentVehicle.getDetails() == null ? new ArrayList<>() : currentVehicle.getDetails();
-                                        if (!vehicleDetailInfos.stream().map(VehicleDetailInfo::getGoodsId).toList().contains(inTask.getGoodsRelated().getGoodsId())) {
-                                            vehicleDetailInfos.add(new VehicleDetailInfo(inTask.getGoodsRelated().getGoodsId()));
-                                            currentVehicle.setDetails(vehicleDetailInfos);
+                                        VehicleDetailInfo goodsInfo = currentVehicle.getGoodsInfo();
+                                        if (goodsInfo == null) {
+                                            goodsInfo = new VehicleDetailInfo();
+                                            goodsInfo.setGoodsIds(new ArrayList<>(List.of(inTask.getGoodsRelated().getGoodsId())));
+                                            currentVehicle.setGoodsInfo(goodsInfo);
+                                        } else {
+                                            if (goodsInfo.getGoodsIds() == null) {
+                                                goodsInfo = new VehicleDetailInfo();
+                                                goodsInfo.setGoodsIds(new ArrayList<>(List.of(inTask.getGoodsRelated().getGoodsId())));
+                                                currentVehicle.setGoodsInfo(goodsInfo);
+                                            } else if (!goodsInfo.getGoodsIds().contains(inTask.getGoodsRelated().getGoodsId())) {
+                                                List<String> goodsIds = goodsInfo.getGoodsIds();
+                                                goodsIds.add(inTask.getGoodsRelated().getGoodsId());
+                                                goodsInfo.setGoodsIds(goodsIds);
+                                                currentVehicle.setGoodsInfo(goodsInfo);
+                                            }
                                         }
                                     }
                                 }
@@ -490,8 +493,6 @@ public class TaskController {
                             taskService.remove(new LambdaQueryWrapper<Task>().eq(Task::getTaskId, inTask.getTaskId()));
                             // 移除当前料箱所有的拣选任务
                             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()));
                         }
@@ -514,20 +515,14 @@ public class TaskController {
                                         .ne(Vehicle::getVehicleStatus, VehicleStatus.OUT.getCode()));
                                 // 当前载具上所有库存状态设置为拣选
                                 stockService.update(new LambdaUpdateWrapper<Stock>()
-                                        .set(Stock::getStockStatus, StockStatus.PICKING.getCode())
+                                        .set(Stock::getStockStatus, StockStatus.OUTED.getCode())
                                         .eq(Stock::getVehicleId, outTask.getVehicleId())
-                                        .ne(Stock::getStockStatus, StockStatus.PICKING.getCode()));
+                                        .ne(Stock::getStockStatus, StockStatus.OUTED.getCode()));
                                 // 将该载具对应的拣选任务设置为可发送状态
                                 pickTaskService.update(new LambdaUpdateWrapper<PickTask>()
                                         .set(PickTask::getPickStatus, PickTaskStatusEnum.NEW.getCode())
                                         .eq(PickTask::getVehicleId, outTask.getVehicleId())
                                         .eq(PickTask::getPickStatus, PickTaskStatusEnum.TEMP.getCode()));
-                                // 设置特殊
-                                standStackerTaskService.update(new LambdaUpdateWrapper<StandStackerTask>()
-                                        .set(StandStackerTask::getTaskStatus, 1)
-                                        .set(StandStackerTask::getFinishTime, LocalDateTime.now())
-                                        .eq(StandStackerTask::getVehicleId, outTask.getVehicleId())
-                                        .ne(StandStackerTask::getTaskStatus, 1));
                             } else {// 代表整出
                                 // 删除当前载具上所有库存
                                 List<Stock> removeStocks = stockService.list(new LambdaQueryWrapper<Stock>().eq(Stock::getVehicleId, outTask.getVehicleId()));
@@ -650,7 +645,7 @@ public class TaskController {
                     response.setMessage("暂无可用库位！");
                     return convertJsonString(response);
                 } else {
-                    Location nextLocation = locationService.getOne(new LambdaQueryWrapper<Location>().eq(Location::getLocationId, resultMap.get("nextLocationId")).last("limit 1"));
+                    Location nextLocation = locationService.getById(resultMap.get("nextLocationId"));
                     if (Objects.equals(nextLocation.getLocationStatus(), LocationStatus.OCCUPY.getCode()) && nextLocation.getVehicleId().equals(wcsVehicleInRequest.getVehicleNo())) {
                         nextLocationId = resultMap.get("nextLocationId");
                         break;
@@ -912,7 +907,7 @@ public class TaskController {
                         .set(PickTask::getLastUpdateTime, LocalDateTime.now())
                         .eq(PickTask::getVehicleId, boxArriveRequest.getVehicleNo())
                         .eq(PickTask::getPickStatus, PickTaskStatusEnum.TEMP.getCode()));
-                // 重置当前站台非当前箱子的已完成拣选任务 todo
+                // 重置当前站台非当前箱子的已完成拣选任务
                 pickTaskService.update(new LambdaUpdateWrapper<PickTask>()
                         .set(PickTask::getPickStatus, PickTaskStatusEnum.NEW.getCode())
                         .set(PickTask::getLastUpdateTime, LocalDateTime.now())
@@ -923,6 +918,11 @@ public class TaskController {
                 standService.update(new LambdaUpdateWrapper<Stand>()
                         .set(Stand::getPickVehicle, boxArriveRequest.getVehicleNo())
                         .eq(Stand::getStandId, pickTask.getStandId()));
+                // 更新库存为拣选中
+                stockService.update(new LambdaUpdateWrapper<Stock>()
+                        .set(Stock::getStockStatus, StockStatus.PICKING.getCode())
+                        .eq(Stock::getVehicleId, boxArriveRequest.getVehicleNo())
+                        .ne(Stock::getStockStatus, StockStatus.PICKING.getCode()));
 
                 response.setCode(ResponseCode.OK.getCode());
                 response.setMessage("上报成功");
@@ -1399,39 +1399,6 @@ public class TaskController {
                     }
                     // 更新实际拣选数量
                     workFlow.setPickedNum(workFlow.getPickedNum().add(BigDecimal.valueOf(eTaskFeedbackRequest.getConfirmNum())));
-                    if (eTaskFeedbackRequest.getConfirmNum().compareTo(eTaskFeedbackRequest.getNeedNum()) < 0) {
-                        int diffNum = eTaskFeedbackRequest.getNeedNum() - eTaskFeedbackRequest.getConfirmNum();
-                        // 查站台要料表---未分配以及分配但未完全分配
-                        GoodsToStation goodsToStation = goodsToStationService.getOne(new LambdaQueryWrapper<GoodsToStation>()
-                                .eq(GoodsToStation::getWorkStation, workFlow.getWorkStation())
-                                .eq(GoodsToStation::getGoodsId, workFlow.getGoodsId())
-                                .last("limit 1"));
-                        if (goodsToStation != null) {
-                            // 更新站台要料数量
-                            BigDecimal newDistributeNum = goodsToStation.getDistributedNum().subtract(BigDecimal.valueOf(diffNum));
-                            goodsToStation.setDistributedNum(newDistributeNum.compareTo(BigDecimal.ZERO) <= 0 ? BigDecimal.ZERO : newDistributeNum);
-                            goodsToStation.setDistributeStatus(1);
-                            goodsToStationService.updateById(goodsToStation);
-                        }
-                        // 查询当前站台的拣货任务
-                        PickTask pickTask = pickTaskService.getOne(new LambdaQueryWrapper<PickTask>()
-                                .eq(PickTask::getStandId, workFlow.getWorkStation())
-                                .eq(PickTask::getPickStatus, PickTaskStatusEnum.FINISH.getCode())
-                                .last("limit 1"));
-                        if (pickTask != null) {
-                            // 更新当前的outsideVehicles状态为一个新状态，拉取任务时不拉取它
-                            List<OutsideVehicles> outsideVehiclesList = outsideVehiclesService.list(new LambdaQueryWrapper<OutsideVehicles>()
-                                    .eq(OutsideVehicles::getVehicleId, pickTask.getVehicleId())
-                                    .eq(OutsideVehicles::getGoodsId, workFlow.getGoodsId()));
-                            for (OutsideVehicles outsideVehicles : outsideVehiclesList) {
-                                outsideVehicles.setOutStatus(2);
-                            }
-                            outsideVehiclesService.updateBatchById(outsideVehiclesList);
-                        }
-                        // 更新workFlow状态
-                        workFlow.setLightStatus(0);// 未亮灯
-                        workFlow.setWorkStatus(1);// 正在做
-                    } else {
                     if (workFlow.getPickedNum().compareTo(workFlow.getNeedNum()) < 0) {
                         // 缺料未完成
                         workFlow.setLightStatus(0);// 未亮灯
@@ -1440,7 +1407,6 @@ public class TaskController {
                         workFlow.setLightStatus(2);// 已拍灯
                         workFlow.setWorkStatus(2);// 已完成
                     }
-                    }
                     // 更新workFlow
                     workFlow.setFinishTime(LocalDateTime.now());
                     workFlowService.updateById(workFlow);
@@ -1587,24 +1553,6 @@ public class TaskController {
                             stockService.updateById(existStock);
                             stockUpdateRecordService.addStockUpdateRecord(originStock, existStock, StockUpdateReasonEnum.CONFIRM_UPDATE.getReason(), workConfirmRequest.getUserName(), quantityBefore);
                         }
-                        OutsideVehicles currentGoodsVehicle = outsideVehiclesService.getOne(new LambdaQueryWrapper<OutsideVehicles>()
-                                .eq(OutsideVehicles::getVehicleId, pickTask.getVehicleId())
-                                .eq(OutsideVehicles::getGoodsId, workConfirmRequest.getGoodsId())
-                                .last("limit 1"));
-                        if (workConfirmRequest.getRemainNumReal().compareTo(BigDecimal.ZERO) == 0) {// 实际剩余数量为0
-                            // 更新流转载具表剩余数量
-                            if (currentGoodsVehicle != null) {
-                                currentGoodsVehicle.setRemainNum(BigDecimal.ZERO);
-                                currentGoodsVehicle.setOutStatus(2);
-                                outsideVehiclesService.updateById(currentGoodsVehicle);
-                            }
-                        } else {
-                            // 更新流转载具表剩余数量 todo
-                            if (currentGoodsVehicle != null) {
-                                currentGoodsVehicle.setRemainNum(currentGoodsVehicle.getRemainNum().add(workConfirmRequest.getRemainNumReal().subtract(workConfirmRequest.getRemainNumOrigin())));
-                                outsideVehiclesService.updateById(currentGoodsVehicle);
-                            }
-                        }
                     } else {
                         if (existStock != null && existStock.getGoodsRelated() != null) {
                             if (workConfirmRequest.getRemainNumOrigin().compareTo(BigDecimal.ZERO) == 0) {
@@ -1615,13 +1563,6 @@ public class TaskController {
                                 existStock.setGoodsRelated(goodsDetail);
                                 stockService.updateById(existStock);
                                 stockUpdateRecordService.addStockUpdateRecord(originStock, existStock, StockUpdateReasonEnum.CONFIRM_UPDATE.getReason(), workConfirmRequest.getUserName(), quantityBefore);
-                                OutsideVehicles currentGoodsVehicle = outsideVehiclesService.getOne(new LambdaQueryWrapper<OutsideVehicles>()
-                                        .eq(OutsideVehicles::getVehicleId, pickTask.getVehicleId())
-                                        .eq(OutsideVehicles::getGoodsId, workConfirmRequest.getGoodsId())
-                                        .last("limit 1"));
-                                currentGoodsVehicle.setRemainNum(BigDecimal.ZERO);
-                                currentGoodsVehicle.setOutStatus(2);
-                                outsideVehiclesService.updateById(currentGoodsVehicle);
                             }
                         }
                     }
@@ -1646,7 +1587,7 @@ public class TaskController {
                         if (workFlowService.exists(new LambdaQueryWrapper<WorkFlow>()
                                 .eq(WorkFlow::getWorkStation, standId)
                                 .in(WorkFlow::getGoodsId, goodsIdList)
-                                .notIn(WorkFlow::getWorkStatus, -1, 2))) {
+                                .eq(WorkFlow::getWorkStatus, 1))) {
                             // 需要，不放行，返回前台提示信息
                             StandPickVo pickVoEntity = new StandPickVo();
                             pickVoEntity.setTip("当前料箱还有其他物料需要拣货");
@@ -1670,7 +1611,7 @@ public class TaskController {
                             // 判断是不是已经完成工作
                             if (workFlowService.exists(new LambdaQueryWrapper<WorkFlow>()
                                     .eq(WorkFlow::getWorkStation, standId)
-                                    .notIn(WorkFlow::getWorkStatus, -1, 2))) {
+                                    .eq(WorkFlow::getWorkStatus, 1))) {
                                 // 当前站台工作未全部完成
                                 standService.update(new LambdaUpdateWrapper<Stand>()
                                         .set(Stand::getLastUseTime, LocalDateTime.now())
@@ -1709,7 +1650,7 @@ public class TaskController {
                         // 判断是不是已经完成工作
                         if (workFlowService.exists(new LambdaQueryWrapper<WorkFlow>()
                                 .eq(WorkFlow::getWorkStation, standId)
-                                .notIn(WorkFlow::getWorkStatus, -1, 2))) {
+                                .eq(WorkFlow::getWorkStatus, 1))) {
                             // 当前站台工作未全部完成
                             standService.update(new LambdaUpdateWrapper<Stand>()
                                     .set(Stand::getLastUseTime, LocalDateTime.now())
@@ -1827,7 +1768,7 @@ public class TaskController {
                     if (workFlowService.exists(new LambdaQueryWrapper<WorkFlow>()
                             .eq(WorkFlow::getWorkStation, targetStand.getStandId())
                             .in(WorkFlow::getGoodsId, goodsIdList)
-                            .notIn(WorkFlow::getWorkStatus, -1, 2))) {
+                            .eq(WorkFlow::getWorkStatus, 1))) {
                         // 更新站台信息
                         standService.update(new LambdaUpdateWrapper<Stand>()
                                 .set(Stand::getPickGoods, "")
@@ -1849,7 +1790,7 @@ public class TaskController {
                         // 判断是不是已经完成工作
                         if (workFlowService.exists(new LambdaQueryWrapper<WorkFlow>()
                                 .eq(WorkFlow::getWorkStation, targetStand.getStandId())
-                                .notIn(WorkFlow::getWorkStatus, -1, 2))) {
+                                .eq(WorkFlow::getWorkStatus, 1))) {
                             standService.update(new LambdaUpdateWrapper<Stand>()
                                     .set(Stand::getLastUseTime, LocalDateTime.now())
                                     .set(Stand::getPickVehicle, "")
@@ -1885,7 +1826,7 @@ public class TaskController {
                     // 判断是不是已经完成工作
                     if (workFlowService.exists(new LambdaQueryWrapper<WorkFlow>()
                             .eq(WorkFlow::getWorkStation, targetStand.getStandId())
-                            .notIn(WorkFlow::getWorkStatus, -1, 2))) {
+                            .eq(WorkFlow::getWorkStatus, 1))) {
                         // 当前站台工作未全部完成
                         standService.update(new LambdaUpdateWrapper<Stand>()
                                 .set(Stand::getLastUseTime, LocalDateTime.now())
@@ -2022,7 +1963,6 @@ public class TaskController {
      */
     @PostMapping("/confirmFinishedWork")
     @ResponseBody
-    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
     @MyLog(logTitle = "工作完成确认", logMethod = "confirmFinishedWork")
     public String confirmFinishedWork(@RequestBody WorkQuery workQuery) {
         logger.info("工作完成确认：{}，ip地址：{}", convertJsonString(workQuery), HttpUtils.getIpAddr(servletRequest));
@@ -2074,9 +2014,7 @@ public class TaskController {
             }
             return convertJsonString(response);
         } catch (Exception e) {
-            // 回滚事务
-            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
-            logger.error("工作完成确认异常");
+            logger.error("工作完成确认异常：{}", convertJsonString(e));
             response.setCode(ResponseCode.ERROR.getCode());
             response.setMessage("工作完成确认异常");
             return convertJsonString(response);
@@ -2104,25 +2042,6 @@ public class TaskController {
                 response.setMessage("料箱数量必须为大于0的整数");
                 return convertJsonString(response);
             }
-            // 验证请求信息
-//            if (Objects.equals(callEmptyVehicleRequest.getVehicleType2(), "间接物料")) {
-//                // TODO 间接物料需要确认
-//                if (StringUtils.isEmpty(callEmptyVehicleRequest.getGoodsId())) {
-//                    logger.error("间接物料必须输入物料号");
-//                    response.setCode(ResponseCode.ERROR.getCode());
-//                    response.setMessage("间接物料必须输入物料号");
-//                    return convertJsonString(response);
-//                }
-//                // 查询物料是否是间接物料
-//                Goods goods = goodsService.getOne(new LambdaQueryWrapper<Goods>().eq(Goods::getGoodsId, callEmptyVehicleRequest.getGoodsId()).eq(Goods::getGoodsInVehicleType, "间接物料").last("limit 1"));
-//                if (goods == null) {
-//                    logger.error("当前物料不是间接物料");
-//                    response.setCode(ResponseCode.ERROR.getCode());
-//                    response.setMessage("当前物料不是间接物料");
-//                    return convertJsonString(response);
-//                }
-//                callEmptyVehicleRequest.setVehicleType1(goods.getVehicleType());
-//            }
 
             // 生成料箱出库任务
             int needNum = callEmptyVehicleRequest.getNeedNum();
@@ -2130,14 +2049,31 @@ public class TaskController {
             List<String> outVehicleIds = new ArrayList<>();// 料箱列表
             // 查询出需求数量的空箱
             LambdaQueryWrapper<Vehicle> emptyVehicleQueryWrapper = new LambdaQueryWrapper<Vehicle>()
-                    .eq(Vehicle::getIsEmpty, 1)
                     .eq(Vehicle::getVehicleStatus, VehicleStatus.ON.getCode())
                     .orderByAsc(Vehicle::getLastInTime)
                     .last("limit " + needNum);
             if (Objects.equals(callEmptyVehicleRequest.getVehicleType2(), "间接物料")) {
-                emptyVehicleQueryWrapper.eq(Vehicle::getVehicleType, "间接物料");
+                if (StringUtils.isEmpty(callEmptyVehicleRequest.getGoodsId())) {
+                    logger.error("间接物料必须输入物料号");
+                    response.setCode(ResponseCode.ERROR.getCode());
+                    response.setMessage("间接物料必须输入物料号");
+                    return convertJsonString(response);
+                }
+                // 查询物料是否是间接物料
+                Goods goods = goodsService.getById(callEmptyVehicleRequest.getGoodsId());
+                if (goods == null || !Objects.equals(goods.getGoodsType(), "间接物料")) {
+                    logger.error("当前物料不是间接物料");
+                    response.setCode(ResponseCode.ERROR.getCode());
+                    response.setMessage("当前物料不是间接物料");
+                    return convertJsonString(response);
+                }
+                emptyVehicleQueryWrapper
+                        .eq(Vehicle::getVehicleType, "间接物料")
+                        .apply("JSON_CONTAINS(goods_info ->> '$.goodsIds', {0})" + MYSQL_JSON_CI, "\"" + callEmptyVehicleRequest.getGoodsId() + "\"");
             } else {
-                emptyVehicleQueryWrapper.ne(Vehicle::getVehicleType, "间接物料");
+                emptyVehicleQueryWrapper
+                        .ne(Vehicle::getVehicleType, "间接物料")
+                        .eq(Vehicle::getIsEmpty, 1);
             }
             List<Vehicle> emptyVehicles = vehicleService.list(emptyVehicleQueryWrapper);
             for (Vehicle emptyVehicle : emptyVehicles) {
@@ -2164,6 +2100,7 @@ public class TaskController {
                 outVehicleIds.add(emptyVehicle.getVehicleId());
                 needNum--;
             }
+            if (!outVehicleIds.isEmpty()) {
                 // 保存任务
                 taskService.saveBatch(vehicleOutTasks);
                 // 更新料箱表
@@ -2171,23 +2108,29 @@ public class TaskController {
                         .set(Vehicle::getVehicleStatus, VehicleStatus.OUT.getCode())
                         .in(Vehicle::getVehicleId, outVehicleIds)
                         .ne(Vehicle::getVehicleStatus, VehicleStatus.OUT.getCode()));
+                // 更新库存表
+                stockService.update(new LambdaUpdateWrapper<Stock>()
+                        .set(Stock::getStockStatus, StockStatus.OUT.getCode())
+                        .in(Stock::getVehicleId, outVehicleIds)
+                        .ne(Stock::getStockStatus, StockStatus.OUT.getCode()));
+            }
             if (needNum <= 0) {
                 response.setCode(ResponseCode.OK.getCode());
-                response.setMessage("呼叫空箱成功，请等待箱子出库。");
+                response.setMessage("呼叫料箱成功，请等待箱子出库。");
             } else if (needNum < callEmptyVehicleRequest.getNeedNum()) {
                 response.setCode(ResponseCode.OK.getCode());
-                response.setMessage("已呼叫空箱，但库中空箱数量不足。需求" + callEmptyVehicleRequest.getNeedNum() + "个，实际呼叫" + vehicleOutTasks.size() + "个。");
+                response.setMessage("已呼叫料箱，但库中符合要求料箱数量不足。需求" + callEmptyVehicleRequest.getNeedNum() + "个，实际呼叫" + vehicleOutTasks.size() + "个。");
             } else {
                 response.setCode(ResponseCode.ERROR.getCode());
-                response.setMessage("库中没有空箱了。");
+                response.setMessage("库中没有需求的料箱了。");
             }
             return convertJsonString(response);
         } catch (Exception e) {
             // 回滚事务
             TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
-            logger.error("呼叫空箱发生异常，{}", convertJsonString(e));
+            logger.error("呼叫料箱发生异常，{}", convertJsonString(e));
             response.setCode(ResponseCode.ERROR.getCode());
-            response.setMessage("呼叫空箱发生异常");
+            response.setMessage("呼叫料箱发生异常");
             return convertJsonString(response);
         }
     }
@@ -2271,8 +2214,6 @@ public class TaskController {
                             backTask.setCreateTime(LocalDateTime.now());
                             // 保存任务
                             taskService.save(backTask);
-                            // 删除outsideVehicle表
-                            outsideVehiclesService.remove(new LambdaQueryWrapper<OutsideVehicles>().eq(OutsideVehicles::getVehicleId, requestBackQuery.getVehicleId()));
                             // 设置库存状态为回库中
                             stockService.update(new LambdaUpdateWrapper<Stock>()
                                     .set(Stock::getStockStatus, StockStatus.BACK.getCode())
@@ -2831,7 +2772,7 @@ public class TaskController {
                 return convertJsonString(response);
             }
 
-            // TODO 以下是非计划领料变动
+            // 以下是非计划领料变动
             // 1. 判断当前站台是否允许非计划
             if (targetStand.getAllowNoPlan() != 1) {
                 logger.error("当前站台不允许非计划领料：{}。", targetStand.getStandId());
@@ -2865,11 +2806,10 @@ public class TaskController {
                 // 出库任务列表
                 List<Task> outTasks = new ArrayList<>();
 
-                // TODO 非计划变动
+                // 非计划变动
                 // 拣选任务列表
                 List<PickTask> pickTasks = new ArrayList<>();
 
-
                 // 尝试生成出库任务
                 List<String> pickStandIds = new ArrayList<>();
                 for (Stock tempStock : stockList) {
@@ -2907,7 +2847,7 @@ public class TaskController {
                         tempOutTask.setIsPicking(1);
                         outTasks.add(tempOutTask);
 
-                        // TODO 非计划变动
+                        // 非计划变动
                         // 只有备料站台才下发拣选任务
                         if (targetStand.getStandType() == 2) {
                             // 创建拣选任务
@@ -2922,7 +2862,8 @@ public class TaskController {
                         }
 
                     } else if (Objects.equals(tempStock.getStockStatus(), StockStatus.OUT.getCode())
-                            || Objects.equals(tempStock.getStockStatus(), StockStatus.PICKING.getCode())) {
+                            || Objects.equals(tempStock.getStockStatus(), StockStatus.PICKING.getCode())
+                            || Objects.equals(tempStock.getStockStatus(), StockStatus.OUTED.getCode())) {
                         // 查询这个箱子的拣选任务
                         List<PickTask> thisVehiclePickTasks = pickTaskService.list(new LambdaQueryWrapper<PickTask>()
                                 .eq(PickTask::getVehicleId, tempStock.getVehicleId()));
@@ -2949,7 +2890,7 @@ public class TaskController {
                                     .eq(Task::getVehicleId, tempStock.getVehicleId())
                                     .eq(Task::getTaskStatus, WmsTaskStatus.NEW.getCode()));
 
-                            // TODO 非计划变动
+                            // 非计划变动
                             if (targetStand.getStandType() == 1) {
                                 // 入库站台
                                 thisVehiclePickTasks.forEach(pickTask -> {
@@ -2980,7 +2921,7 @@ public class TaskController {
                     // 保存出库任务
                     taskService.saveBatch(outTasks);
 
-                    // TODO 非计划变动
+                    // 非计划变动
                     // 保存拣选任务
                     if (!pickTasks.isEmpty()) {
                         pickTaskService.saveBatch(pickTasks);
@@ -3260,9 +3201,6 @@ public class TaskController {
         }
     }
 
-
-    // TODO 以下是盘点待做
-
     /**
      * 盘点请求
      *
@@ -3283,6 +3221,36 @@ public class TaskController {
                 response.setMessage("盘点，请输入料号。");
                 return convertJsonString(response);
             }
+
+            // 获取站台号
+            Stand targetStand;
+            if (StringUtils.isNotEmpty(inventoryRequest.getStandId())) {
+                // 站台号从请求参数中获取
+                targetStand = standService.getById(inventoryRequest.getStandId());
+            } else {
+                // 站台号从ip获取
+                targetStand = standService.getOne(new LambdaQueryWrapper<Stand>()
+                        .eq(Stand::getStandIp, HttpUtils.getIpAddr(servletRequest))
+                        .eq(Stand::getStandType, 1)
+                        .last("limit 1"));
+            }
+            if (targetStand == null) {
+                logger.error("查询盘点站台错误。");
+                response.setCode(ResponseCode.ERROR.getCode());
+                response.setMessage("查询盘点站台错误。");
+                return convertJsonString(response);
+            }
+
+            // 判断当前站台是否有工作流
+            boolean haveWorkFlows = workFlowService.exists(new LambdaQueryWrapper<WorkFlow>()
+                    .eq(WorkFlow::getWorkStation, targetStand.getStandId()));
+            if (haveWorkFlows) {
+                logger.error("当前站台还有工作不允许盘点：{}。", targetStand.getStandId());
+                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())
@@ -3297,7 +3265,10 @@ public class TaskController {
             // 生成出库任务
             List<Task> outTasks = new ArrayList<>();
             List<InventoryList> inventoryList = new ArrayList<>();
+            // 本次出库的料箱
+            List<String> thisTimeOutVehicleIds = new ArrayList<>();
             for (Stock stock : stockList) {
+                if (!thisTimeOutVehicleIds.contains(stock.getVehicleId())) {
                     // 创建出库任务
                     Task tempOutTask = new Task();
                     tempOutTask.setTaskId(generateId("INV_"));
@@ -3312,6 +3283,9 @@ public class TaskController {
                     tempOutTask.setCreateTime(LocalDateTime.now());
                     tempOutTask.setIsPicking(1);
                     outTasks.add(tempOutTask);
+                    thisTimeOutVehicleIds.add(stock.getVehicleId());
+                }
+
                 // 创建盘点
                 InventoryList tempInventoryList = new InventoryList();
                 tempInventoryList.setInventoryId(generateId("INV_"));
@@ -3329,16 +3303,43 @@ public class TaskController {
                 taskService.saveBatch(outTasks);
                 // 保存盘点
                 inventoryService.saveBatch(inventoryList);
-                List<String> vehicleIds = outTasks.stream().map(Task::getVehicleId).distinct().toList();
+                // 判断本次是否需要生成拣选任务
+                if (targetStand.getStandType() == 2) {
+                    List<PickTask> newPickTasks = new ArrayList<>();
+                    // 如果是拣选站台的话，需要生成拣选任务
+                    List<PickTask> oldPickTasks = pickTaskService.list(new LambdaQueryWrapper<PickTask>()
+                            .eq(PickTask::getStandId, targetStand.getStandId())
+                            .in(PickTask::getVehicleId, thisTimeOutVehicleIds));
+                    for (String vehicleId : thisTimeOutVehicleIds) {
+                        // 判断这个料箱是否需要生成新的拣选任务
+                        List<PickTask> hasOldPickTask = oldPickTasks.stream().filter(pickTask -> pickTask.getVehicleId().equals(vehicleId)).toList();
+                        if (!hasOldPickTask.isEmpty()) {
+                            continue;
+                        }
+                        // 创建拣选任务
+                        PickTask tempPickTask = new PickTask();
+                        String key = vehicleId + "_" + targetStand.getStandId();
+                        tempPickTask.setPickTaskId(key);
+                        tempPickTask.setVehicleId(vehicleId);
+                        tempPickTask.setStandId(targetStand.getStandId());
+                        tempPickTask.setPickStatus(PickTaskStatusEnum.TEMP.getCode());
+                        tempPickTask.setLastUpdateTime(LocalDateTime.now());
+                        newPickTasks.add(tempPickTask);
+                    }
+                    if (!newPickTasks.isEmpty()) {
+                        // 保存拣选任务
+                        pickTaskService.saveOrUpdateBatch(newPickTasks);
+                    }
+                }
                 // 更新库存状态
                 stockService.update(new LambdaUpdateWrapper<Stock>()
                         .set(Stock::getStockStatus, StockStatus.OUT.getCode())
-                        .in(Stock::getVehicleId, vehicleIds)
+                        .in(Stock::getVehicleId, thisTimeOutVehicleIds)
                         .eq(Stock::getStockStatus, StockStatus.OK.getCode()));
                 // 更新料箱状态
                 vehicleService.update(new LambdaUpdateWrapper<Vehicle>()
                         .set(Vehicle::getVehicleStatus, VehicleStatus.OUT.getCode())
-                        .in(Vehicle::getVehicleId, vehicleIds)
+                        .in(Vehicle::getVehicleId, thisTimeOutVehicleIds)
                         .eq(Vehicle::getVehicleStatus, VehicleStatus.ON.getCode()));
             }
 
@@ -3402,7 +3403,7 @@ public class TaskController {
                 inventoryVo.setGoodsId(inventoryRequest.getGoodsId());
                 inventoryVo.setVehiclesQuantity(stockList.size());
                 inventoryVo.setVehicleIds(stock.getVehicleId());
-                String vehicleStatus = "";
+                String vehicleStatus;
                 if (Objects.equals(StockStatus.OK.getCode(), stock.getStockStatus())) {
                     vehicleStatus = "在库中";
                 } else if (Objects.equals(StockStatus.OUT.getCode(), stock.getStockStatus())) {
@@ -3466,6 +3467,38 @@ public class TaskController {
                     .apply("goods_related ->> '$.goodsId' = {0}" + MYSQL_JSON_CI, confirmRequest.getGoodsId())
                     .eq(Stock::getVehicleId, confirmRequest.getVehicleId())
                     .last("limit 1"));
+            // 更新库存数量
+            if (existStock != null && existStock.getGoodsRelated() != null) {
+                if (confirmRequest.getConfirmNum().compareTo(existStock.getGoodsRelated().getRemainNum()) != 0) {
+                    // 原始库存数量
+                    Stock originStock = BeanUtil.copyProperties(existStock, Stock.class);
+                    BigDecimal quantityBefore = originStock.getGoodsRelated().getRemainNum();
+                    // 判断前后数量差距
+                    BigDecimal diffQuantity = confirmRequest.getConfirmNum().subtract(quantityBefore);
+                    BigDecimal diffPercent = diffQuantity.divide(quantityBefore, 2, RoundingMode.HALF_UP).abs();
+                    if (diffPercent.compareTo(BigDecimal.valueOf(0.05)) > 0) {
+                        // 查询物料信息
+                        Goods goods = goodsService.getById(confirmRequest.getGoodsId());
+                        if (goods != null) {
+                            if (goods.getIndicator() == 3) {
+                                // 判断是否已经盘点三次
+                                if (confirmRequest.getInvIndex() < 3) {
+                                    logger.info("确认数量与原数量差距超过5%，请再次确认。");
+                                    response.setCode(ResponseCode.WARNING.getCode());
+                                    response.setMessage("确认数量与原数量差距超过5%，请再次确认。");
+                                    return convertJsonString(response);
+                                }
+                            }
+                        }
+                    }
+                    StockDetailInfo goodsDetail = existStock.getGoodsRelated();
+                    // 更新库存
+                    goodsDetail.setRemainNum(confirmRequest.getConfirmNum());
+                    existStock.setGoodsRelated(goodsDetail);
+                    stockService.updateById(existStock);
+                    stockUpdateRecordService.addStockUpdateRecord(originStock, existStock, StockUpdateReasonEnum.INV_CONFIRM.getReason(), confirmRequest.getUserName(), quantityBefore);
+                }
+            }
             // 保存盘点记录
             List<InventoryHistory> historyList = new ArrayList<>();
             for (InventoryList inventoryList : currentGoodsInvList) {

src/main/java/com/wms/entity/app/dto/GoodsDto.java

@@ -16,96 +16,119 @@ public class GoodsDto {
     /**
      * 物料编号
      */
+    @JsonProperty("goodsId")
     private String goodsId;
     /**
      * 物料名称/描述
      */
+    @JsonProperty("goodsName")
     private String goodsName;
     /**
      * 单位
      */
+    @JsonProperty("goodsUnit")
     private String goodsUnit;
     /**
      * 物料分类
      */
+    @JsonProperty("goodsType")
     private String goodsType;
     /**
      * 供应商分类
      */
+    @JsonProperty("providerType")
     private String providerType;
     /**
      * 重量
      */
+    @JsonProperty("weight")
     private BigDecimal weight;
     /**
      * 重量单位
      */
+    @JsonProperty("weightUnit")
     private String weightUnit;
     /**
      * 每盒数量
      */
+    @JsonProperty("quantityPerBox")
     private BigDecimal quantityPerBox;
     /**
      * 拆包方式
      */
+    @JsonProperty("unpackingType")
     private String unpackingType;
     /**
      * 载具类型
      */
+    @JsonProperty("vehicleType")
     private String vehicleType;
     /**
      * 载具类型描述
      */
+    @JsonProperty("vehicleTypeDescription")
     private String vehicleTypeDescription;
     /**
      * 物料载具类型
      */
+    @JsonProperty("goodsInVehicleType")
     private String goodsInVehicleType;
     /**
      * 补料方式
      * PULL：有看板
      * PUSH：无看板
      */
+    @JsonProperty("feedingType")
     private String feedingType;
     /**
      * 每个看板包含物料数量
      */
+    @JsonProperty("quantityPerKanban")
     private BigDecimal quantityPerKanban;
     /**
      * 看板的数量
      */
+    @JsonProperty("kanbanNum")
     private BigDecimal kanbanNum;
     /**
      * 看板详细信息
      */
+    @JsonProperty("kanbanList")
     private List<KanbanEntity> kanbanList;
     /**
      * 补货点
      */
+    @JsonProperty("feedingValue")
     private BigDecimal feedingValue;
     /**
      * 备注1
      */
+    @JsonProperty("remark1")
     private String remark1;
     /**
      * 备注2
      */
+    @JsonProperty("remark2")
     private String remark2;
     /**
      * 备注3
      */
+    @JsonProperty("remark3")
     private String remark3;
     /**
      * 数据来源
      */
+    @JsonProperty("dataSource")
     private String dataSource;
     /**
      * 最后更新日期
      */
+    @JsonProperty("lastUpdateTime")
     private LocalDateTime lastUpdateTime;
     /**
      * 最后更新用户
      */
+    @JsonProperty("lastUpdateUser")
     private String lastUpdateUser;
     /**
      * 热度
@@ -117,4 +140,9 @@ public class GoodsDto {
      */
     @JsonProperty("releasePoint")
     private String releasePoint;
+    /**
+     * 盘点指示器
+     */
+    @JsonProperty("indicator")
+    private Integer indicator;
 }

src/main/java/com/wms/entity/app/dto/PageDto.java

@@ -40,4 +40,26 @@ public class PageDto<T> {
         pageDto.setLists(page.getRecords().stream().map(converter).toList());
         return pageDto;
     }
+
+    /**
+     * 将列表集合转换为分页结果
+     * @param total 总数
+     * @param pages 总页数
+     * @param voList 列表集合
+     * @return
+     * @param <VO>
+     */
+    public static <VO> PageDto<VO> ofList(long total, long pages, long pageNo, long pageSize, List<VO> voList) {
+        PageDto<VO> pageDto = new PageDto<>();
+        // 设置总数
+        pageDto.setTotal(total);
+        // 设置总页数
+        pageDto.setPages(pages);
+        if (voList.isEmpty()) {
+            pageDto.setLists(Collections.emptyList());
+            return pageDto;
+        }
+        pageDto.setLists(voList.subList((int) ((pageNo - 1) * pageSize), (int) Math.min(pageNo * pageSize, total)));
+        return pageDto;
+    }
 }

src/main/java/com/wms/entity/app/dto/VehicleDto.java

@@ -33,7 +33,7 @@ public class VehicleDto {
     /**
      * 额外信息
      */
-    private VehicleDetailInfo details;
+    private VehicleDetailInfo goodsInfo;
     /**
      * 上次入库时间
      */

src/main/java/com/wms/entity/app/dto/extend/StockDetailInfo.java

@@ -1,10 +1,14 @@
 package com.wms.entity.app.dto.extend;
 
+import lombok.AllArgsConstructor;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 import java.math.BigDecimal;
 
 @Data
+@AllArgsConstructor
+@NoArgsConstructor
 public class StockDetailInfo {
     /**
      * 物料编号

src/main/java/com/wms/entity/app/dto/extend/VehicleDetailInfo.java

@@ -1,14 +1,22 @@
 package com.wms.entity.app.dto.extend;
 
+import com.fasterxml.jackson.annotation.JsonProperty;
 import lombok.AllArgsConstructor;
 import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
 
 /**
  * 料箱详细信息
  */
 @Data
 @AllArgsConstructor
+@NoArgsConstructor
 public class VehicleDetailInfo {
-    /// 料号
-    private String goodsId;
+    /**
+     * 料号列表
+     */
+    @JsonProperty("goodsIds")
+    private List<String> goodsIds;
 }

src/main/java/com/wms/entity/app/dto/extend/VehicleDetailInfo_2.java

@@ -0,0 +1,22 @@
+package com.wms.entity.app.dto.extend;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+/**
+ * 料箱详细信息
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class VehicleDetailInfo_2 {
+    /**
+     * 料号列表
+     */
+    @JsonProperty("goodsId")
+    private String goodsId;
+}

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

@@ -1,6 +1,7 @@
 package com.wms.entity.app.request;
 
 import cn.hutool.core.bean.BeanUtil;
+import com.baomidou.mybatisplus.annotation.TableField;
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.wms.entity.app.dto.extend.KanbanEntity;
@@ -148,6 +149,30 @@ public class GoodsQuery extends PageQuery {
      */
     @JsonProperty("releasePoint")
     private String releasePoint;
+    /**
+     * 盘点管理
+     * YES
+     * NO
+     */
+    @JsonProperty("needInventory")
+    private String needInventory;
+    /**
+     * SLED管理
+     * YES
+     * NO
+     */
+    @TableField("haveSled")
+    private String haveSled;
+    /**
+     * SLED天数
+     */
+    @TableField("sledDays")
+    private Integer sledDays;
+    /**
+     * 盘点指示器
+     */
+    @JsonProperty("indicator")
+    private Integer indicator;
 
 
     /**

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

@@ -29,9 +29,19 @@ public class InventoryRequest {
      */
     @JsonProperty("confirmNum")
     private BigDecimal confirmNum;
+    /**
+     * 盘点次数
+     */
+    @JsonProperty("invIndex")
+    private Integer invIndex;
     /**
      * 操作人员
      */
     @JsonProperty("userName")
     private String userName;
+    /**
+     * 站台
+     */
+    @JsonProperty("standId")
+    private String standId;
 }

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

@@ -0,0 +1,34 @@
+package com.wms.entity.app.request;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.time.LocalDate;
+
+/**
+ * 拣选任务记录查询
+ */
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class PickTaskRecordQuery extends PageQuery {
+    /**
+     * 载具号
+     */
+    @JsonProperty("vehicleId")
+    private String vehicleId;
+    /**
+     * 站台号
+     */
+    @JsonProperty("standId")
+    private String standId;
+    /**
+     * 工作日期
+     */
+    @JsonProperty("workDate")
+    @DateTimeFormat(pattern = "yyyy-MM-dd")
+    @JsonFormat(pattern = "yyyy-MM-dd")
+    private LocalDate workDate;
+}

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

@@ -7,7 +7,6 @@ import com.wms.entity.table.Vehicle;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 
-import java.util.List;
 import java.util.Objects;
 
 /**
@@ -44,8 +43,13 @@ public class VehicleQuery extends PageQuery {
     /**
      * 额外信息
      */
-    @JsonProperty("details")
-    private String details;
+    @JsonProperty("goodsInfo")
+    private String goodsInfo;
+    /**
+     * 查询料号
+     */
+    @JsonProperty("goodsId")
+    private String goodsId;
 
     /**
      * 将VehicleQuery转化为VehiclePO
@@ -62,7 +66,7 @@ public class VehicleQuery extends PageQuery {
         } else {
             vehiclePO.setVehicleType("");
         }
-        vehiclePO.setDetails(JSON.parseArray(details, VehicleDetailInfo.class));
+        vehiclePO.setGoodsInfo(JSON.parseObject(goodsInfo, VehicleDetailInfo.class));
 
         return vehiclePO;
     }

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

@@ -0,0 +1,34 @@
+package com.wms.entity.app.request;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.time.LocalDate;
+
+/**
+ * 工作日历查询参数
+ */
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class WorkDateQuery extends PageQuery {
+    /**
+     * 工作日
+     */
+    @JsonProperty("workDate")
+    @DateTimeFormat(pattern = "yyyy-MM-dd")
+    @JsonFormat(pattern = "yyyy-MM-dd")
+    private LocalDate workDate;
+    /**
+     * 备注
+     */
+    @JsonProperty("remark")
+    private String remark;
+    /**
+     * 查询来源
+     */
+    @JsonProperty("sourceType")
+    private Integer sourceType;
+}

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

@@ -1,5 +1,6 @@
 package com.wms.entity.app.vo;
 
+import com.baomidou.mybatisplus.annotation.TableField;
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.wms.entity.app.dto.extend.KanbanEntity;
@@ -141,4 +142,28 @@ public class GoodsVo {
      */
     @JsonProperty("releasePoint")
     private String releasePoint;
+    /**
+     * 盘点管理
+     * YES
+     * NO
+     */
+    @JsonProperty("needInventory")
+    private String needInventory;
+    /**
+     * SLED管理
+     * YES
+     * NO
+     */
+    @TableField("haveSled")
+    private String haveSled;
+    /**
+     * SLED天数
+     */
+    @TableField("sledDays")
+    private Integer sledDays;
+    /**
+     * 盘点指示器
+     */
+    @JsonProperty("indicator")
+    private Integer indicator;
 }

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

@@ -113,4 +113,23 @@ public class KateOrdersVo {
     @DateTimeFormat(pattern = "yyyy-MM-dd")
     @JsonFormat(pattern = "yyyy-MM-dd")
     private LocalDateTime planStartDate;
+    /**
+     * 创建时间
+     */
+    @JsonProperty("createTime")
+    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime createTime;
+    /**
+     * 最后更新时间
+     */
+    @JsonProperty("lastUpdateTime")
+    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime lastUpdateTime;
+    /**
+     * 最后更新原因
+     */
+    @JsonProperty("lastUpdateReason")
+    private String lastUpdateReason;
 }

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

@@ -1,12 +1,12 @@
 package com.wms.entity.app.vo;
 
 import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonProperty;
 import com.wms.entity.app.dto.extend.VehicleDetailInfo;
 import lombok.Data;
 import org.springframework.format.annotation.DateTimeFormat;
 
 import java.time.LocalDateTime;
-import java.util.List;
 
 /**
  * 载具VO
@@ -16,30 +16,37 @@ public class VehicleVO {
     /**
      * 载具编号
      */
+    @JsonProperty("vehicleId")
     private String vehicleId;
     /**
      * 当前所在位置
      */
+    @JsonProperty("currentLocation")
     private String currentLocation;
     /**
      * 载具状态
      */
+    @JsonProperty("vehicleStatus")
     private Integer vehicleStatus;
     /**
      * 是否是空箱
      */
+    @JsonProperty("isEmpty")
     private Integer isEmpty;
     /**
      * 载具类型
      */
+    @JsonProperty("vehicleType")
     private String vehicleType;
     /**
-     * 额外信息
+     * 绑定物料信息
      */
-    private List<VehicleDetailInfo> details;
+    @JsonProperty("goodsInfo")
+    private VehicleDetailInfo goodsInfo;
     /**
      * 上次入库时间
      */
+    @JsonProperty("lastInTime")
     @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
     private LocalDateTime lastInTime;

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

@@ -0,0 +1,32 @@
+package com.wms.entity.app.vo;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.time.LocalDate;
+
+/**
+ * 工作日历显示类
+ */
+@Data
+public class WorkDateVo {
+    /**
+     * id
+     */
+    @JsonProperty("id")
+    private Integer keyId;
+    /**
+     * 工作日
+     */
+    @JsonProperty("workDate")
+    @JsonFormat(pattern = "yyyy-MM-dd")
+    @DateTimeFormat(pattern = "yyyy-MM-dd")
+    private LocalDate workDate;
+    /**
+     * 备注
+     */
+    @JsonProperty("remark")
+    private String remark;
+}

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

@@ -54,6 +54,11 @@ public class WorkFlowVo {
      */
     @JsonProperty("needNum")
     private BigDecimal needNum;
+    /**
+     * 需求数量
+     */
+    @JsonProperty("distributedNum")
+    private BigDecimal distributedNum;
     /**
      * 亮灯状态
      * 0：未亮灯

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

@@ -163,4 +163,11 @@ public class Goods {
      */
     @TableField("sled_days")
     private Integer SledDays;
+    /**
+     * 盘点指示器
+     * 1：成本小于2.5$，盘点至多1遍
+     * 3: 成本大于2.5$，盘点至多3遍
+     */
+    @TableField("indicator")
+    private Integer indicator;
 }

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

@@ -110,4 +110,19 @@ public class KateOrders {
      */
     @TableField("plan_start_date")
     private LocalDate planStartDate;
+    /**
+     * 创建时间
+     */
+    @TableField("create_time")
+    private LocalDateTime createTime;
+    /**
+     * 最后更新时间
+     */
+    @TableField("last_update_time")
+    private LocalDateTime lastUpdateTime;
+    /**
+     * 最后更新原因
+     */
+    @TableField("last_update_reason")
+    private String lastUpdateReason;
 }

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

@@ -5,6 +5,7 @@ import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
 import com.baomidou.mybatisplus.extension.handlers.Fastjson2TypeHandler;
 import com.wms.entity.app.dto.extend.VehicleDetailInfo;
+import com.wms.entity.app.dto.extend.VehicleDetailInfo_2;
 import lombok.Data;
 
 import java.time.LocalDateTime;
@@ -45,7 +46,12 @@ public class Vehicle {
      * 额外信息
      */
     @TableField(value = "details", typeHandler = Fastjson2TypeHandler.class)
-    private List<VehicleDetailInfo> details;
+    private List<VehicleDetailInfo_2> details;
+    /**
+     * 间接物料列表
+     */
+    @TableField(value = "goods_info", typeHandler = Fastjson2TypeHandler.class)
+    private VehicleDetailInfo goodsInfo;
     /**
      * 上次入库时间
      */

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

@@ -104,4 +104,9 @@ public class WorkFlow {
      */
     @TableField("big_box")
     private String bigBox;
+    /**
+     * 已分配数量
+     */
+    @TableField("distributed_num")
+    private BigDecimal distributedNum;
 }

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

@@ -101,4 +101,9 @@ public class WorkFlowLast {
      */
     @TableField("big_box")
     private String bigBox;
+    /**
+     * 已分配数量
+     */
+    @TableField("distributed_num")
+    private BigDecimal distributedNum;
 }

src/main/java/com/wms/quartz/job_executor/CommonTaskSender.java

@@ -10,6 +10,7 @@ import org.springframework.transaction.annotation.Transactional;
 import org.springframework.transaction.interceptor.TransactionAspectSupport;
 
 import static com.wms.config.InitLocalConfig.configMap;
+import static com.wms.utils.StringUtils.convertJsonString;
 
 /**
  * 普通任务发送定时器类
@@ -30,7 +31,6 @@ public class CommonTaskSender implements Job {
      * @param jobExecutionContext 执行文本
      */
     @Override
-    @Transactional(rollbackFor = Exception.class)
     public void execute(JobExecutionContext jobExecutionContext) {
         try {
             String sendTask = configMap.get(ConfigMapKeyEnum.SEND_TASK.getConfigKey());
@@ -40,8 +40,7 @@ public class CommonTaskSender implements Job {
             // 发送正常任务
             wmsJobService.sendCommonTasks();
         } catch (Exception e) {
-            // 回滚事务
-            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            log.error("发送任务给wcs发生异常：{}", convertJsonString(e));
         }
     }
 }

src/main/java/com/wms/quartz/job_executor/DataClearExecutor.java

@@ -25,6 +25,6 @@ public class DataClearExecutor implements Job {
         // 删除日志数据
         wmsJobService.deleteLogsRegularly();
         // 删除记录数据
-        wmsJobService.deleteRecordsRegularly();
+//        wmsJobService.deleteRecordsRegularly();
     }
 }

src/main/java/com/wms/quartz/job_executor/KateWorkExecutor.java

@@ -1,8 +1,5 @@
 package com.wms.quartz.job_executor;
-
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.wms.constants.enums.ConfigMapKeyEnum;
-import com.wms.entity.table.Stand;
 import com.wms.service.StandService;
 import com.wms.service.business.IWorkService;
 import com.wms.utils.StringUtils;
@@ -12,7 +9,6 @@ import org.quartz.*;
 
 import java.time.LocalDateTime;
 import java.time.LocalTime;
-import java.util.List;
 
 import static com.wms.config.InitLocalConfig.configMap;
 import static com.wms.utils.StringUtils.convertJsonString;
@@ -43,6 +39,8 @@ public class KateWorkExecutor implements Job {
     public void execute(JobExecutionContext jobExecutionContext) {
         // 创建工作
         createWork();
+        // 修复工作
+        repairWork();
         // 执行工作
         doWork();
     }
@@ -63,13 +61,13 @@ public class KateWorkExecutor implements Job {
         try {
             workService.createTempWorkFlows();
         } catch (Exception e) {
-            log.error("创建当日工作发生错误：{}", e.getMessage());
+            log.error("创建当日工作发生异常：{}", convertJsonString(e));
         }
         try {
             // 分配工作
             workService.distributeWorks();
         } catch (Exception e) {
-            log.error("分配工作时发生错误：{}", e.getMessage());
+            log.error("分配工作时发生异常：{}", convertJsonString(e));
         }
     }
 
@@ -81,17 +79,33 @@ public class KateWorkExecutor implements Job {
         if (StringUtils.isEmpty(startWork) || !startWork.equals("1")) {
             return;
         }
-        // 轮询工作站台，判断是否需要下发任务
-        List<Stand> stands = standService.list(new LambdaQueryWrapper<Stand>()
-                .eq(Stand::getIsLock, 0).eq(Stand::getStandStatus, 0)
-                .eq(Stand::getStandType, 2));
-        List<String> standIds = stands.stream().map(Stand::getStandId).toList();
-        for (String standId : standIds) {
         try {
-                workService.doWork(standId);
+            workService.doWorkMethod2();
         } catch (Exception e) {
-                log.error("执行工作时发生错误：{}", convertJsonString(e.getMessage()));
-            }
+            log.error("执行工作时发生异常：{}", convertJsonString(e));
+        }
+//        // 轮询工作站台，判断是否需要下发任务
+//        List<Stand> stands = standService.list(new LambdaQueryWrapper<Stand>()
+//                .eq(Stand::getIsLock, 0).eq(Stand::getStandStatus, 0)
+//                .eq(Stand::getStandType, 2));
+//        List<String> standIds = stands.stream().map(Stand::getStandId).toList();
+//        for (String standId : standIds) {
+//            try {
+//                workService.doWork(standId);
+//            } catch (Exception e) {
+//                log.error("执行工作时发生错误：{}", convertJsonString(e.getMessage()));
+//            }
+//        }
+    }
+
+    /**
+     * 修复工作
+     */
+    public void repairWork() {
+        try {
+            workService.repairWork();
+        } catch (Exception e) {
+            log.error("修复工作发生异常：{}", convertJsonString(e));
         }
     }
 }

src/main/java/com/wms/quartz/job_executor/PickTaskSender.java

@@ -6,10 +6,9 @@ import com.wms.utils.StringUtils;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.quartz.*;
-import org.springframework.transaction.annotation.Transactional;
-import org.springframework.transaction.interceptor.TransactionAspectSupport;
 
 import static com.wms.config.InitLocalConfig.configMap;
+import static com.wms.utils.StringUtils.convertJsonString;
 
 @Slf4j
 @PersistJobDataAfterExecution
@@ -27,7 +26,6 @@ public class PickTaskSender implements Job {
      * @param jobExecutionContext 执行上下文
      */
     @Override
-    @Transactional(rollbackFor = Exception.class)
     public void execute(JobExecutionContext jobExecutionContext) {
         try {
             String sendTask = configMap.get(ConfigMapKeyEnum.SEND_TASK.getConfigKey());
@@ -37,8 +35,7 @@ public class PickTaskSender implements Job {
             // 发送拣选任务
             wmsJobService.sendPickTasks();
         } catch (Exception e) {
-            // 回滚事务
-            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+            log.error("发送拣选任务任务给wcs发生异常：{}", convertJsonString(e));
         }
     }
 }

src/main/java/com/wms/service/WorkDateService.java

@@ -3,8 +3,15 @@ package com.wms.service;
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.wms.entity.table.WorkDate;
 
+import java.util.List;
+
 /**
  * 卡特DBS服务接口
  */
 public interface WorkDateService extends IService<WorkDate> {
+    /**
+     * 更新工作日历
+     * @param workDateList 工作日列表
+     */
+    boolean updateWorkDate(List<WorkDate> workDateList);
 }

src/main/java/com/wms/service/business/IWmsJobService.java

@@ -6,9 +6,8 @@ package com.wms.service.business;
 public interface IWmsJobService {
     /**
      * 执行普通任务
-     * @throws Exception 异常用于回滚事务
      */
-    void sendCommonTasks() throws Exception;
+    void sendCommonTasks();
 
     /**
      * 下发拣选出库任务
@@ -18,9 +17,8 @@ public interface IWmsJobService {
 
     /**
      * 发送拣选任务
-     * @throws Exception 异常用于回滚事务
      */
-    void sendPickTasks() throws Exception;
+    void sendPickTasks();
 
     /**
      * 发送重复入库修正后的任务

src/main/java/com/wms/service/business/IWorkService.java

@@ -1,5 +1,8 @@
 package com.wms.service.business;
 
+import com.wms.entity.table.WorkFlow;
+
+import java.time.LocalDate;
 import java.util.List;
 
 /**
@@ -13,6 +16,16 @@ public interface IWorkService {
      */
     void doWork(String workStation) throws Exception;
 
+    /**
+     * 新的执行工作
+     */
+    void doWorkMethod2();
+
+    /**
+     * 修复工作
+     */
+    void repairWork();
+
     /**
      * 完成工作
      * @param workStation 工作站台
@@ -30,4 +43,12 @@ public interface IWorkService {
     void distributeWorks();
 
     void distributeWorksMethod2();
+
+    void findCurrentDateWorks(List<WorkFlow> workFlows, LocalDate currentWorkDate);
+
+    void findCurrentDateWorksUseConfig(List<WorkFlow> workFlows, LocalDate currentWorkDate);
+
+    void findWorks(String workStation, List<WorkFlow> workFlows, String model, LocalDate currentWorkDate);
+
+    LocalDate nextWorkDate(LocalDate currentDate);
 }

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

@@ -2,7 +2,6 @@ package com.wms.service.business.serviceImplements;
 
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.wms.constants.enums.*;
-import com.wms.entity.app.dto.extend.VehicleDetailInfo;
 import com.wms.entity.app.request.GoodsInRequest;
 import com.wms.entity.app.request.TaskInRequest;
 import com.wms.entity.app.request.TaskOutRequest;
@@ -82,8 +81,8 @@ public class ValidateServiceImplements implements IValidateService {
                     goodsType = 1;
                 } else {
                     goodsType = 2;
-                    if (existVehicle.getDetails() != null) {
-                        canInGoodsIdList = existVehicle.getDetails().stream().map(VehicleDetailInfo::getGoodsId).toList();
+                    if (existVehicle.getGoodsInfo() != null && !existVehicle.getGoodsInfo().getGoodsIds().isEmpty()) {
+                        canInGoodsIdList = existVehicle.getGoodsInfo().getGoodsIds();
                     }
                 }
             }

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

@@ -14,6 +14,7 @@ import com.wms.entity.app.wcs.WcsTaskRequest;
 import com.wms.entity.table.*;
 import com.wms.service.*;
 import com.wms.service.business.IWmsJobService;
+import com.wms.utils.DbTransUtils;
 import com.wms.utils.HttpUtils;
 import com.wms.utils.StringUtils;
 import com.wms.utils.WmsUtils;
@@ -47,7 +48,6 @@ import static com.wms.utils.StringUtils.convertJsonString;
 @RequiredArgsConstructor(onConstructor = @__(@Autowired))
 public class WmsJobServiceImplements implements IWmsJobService {
     private final Logger logger = LoggerFactory.getLogger(this.getClass());// 日志
-    private final String ROOT_PATH = "./file";
 
     private final LogService logService;// 日志服务
     private final TaskService taskService;// 任务服务
@@ -65,13 +65,13 @@ public class WmsJobServiceImplements implements IWmsJobService {
     private final IStockUpdateRecordService iStockUpdateRecordService;// 库存更新记录服务
     private final UploadRecordService uploadRecordService;// 文件上传记录服务
     private final InventoryHistoryService inventoryHistoryService;
+    private final DbTransUtils dbTransUtils;
 
     /**
      * 发送正常的任务
      */
     @Override
-    public void sendCommonTasks() throws Exception {
-        try {
+    public void sendCommonTasks() {
         // 检索任务表---新建未下发的任务
         LambdaQueryWrapper<Task> waitForDistributeTaskQuery = new LambdaQueryWrapper<Task>()
                 .eq(Task::getTaskStatus, WmsTaskStatus.NEW.getCode());
@@ -89,10 +89,6 @@ public class WmsJobServiceImplements implements IWmsJobService {
             List<String> taskGroupIds = new ArrayList<>();
             // 这里单独处理站台拣选出库以外的任务
             for (Task task : allTasks) {
-                    if (request.size() >= maxWcsAcceptNums) {
-                        // 每次给wcs下发数量
-                        break;
-                    }
                 if (taskGroupIds.contains(task.getTaskGroup())) {
                     // 该任务组已经下发
                     continue;
@@ -103,12 +99,6 @@ public class WmsJobServiceImplements implements IWmsJobService {
                         continue;
                     }
                 }
-                    if (task.getTaskPriority() == 1) {
-                        if (Objects.equals(task.getTaskType(), TaskType.OUT.getCode())
-                                && task.getIsPicking() == 1 && StringUtils.isNotEmpty(task.getPickStand())) {
-                            continue;
-                        }
-                    }
                 // 创建发送的任务
                 WcsTaskRequest tempTask = new WcsTaskRequest();
                 tempTask.setTaskId(task.getTaskGroup());
@@ -127,30 +117,37 @@ public class WmsJobServiceImplements implements IWmsJobService {
                 // 已经发送过的任务组
                 taskGroupIds.add(task.getTaskGroup());
             }
-                if (request.size() == 0) {
+            if (request.isEmpty()) {
                 // 没有新任务发送
                 return;
             }
+            // 下面这行代码模拟wcs下发成功
+//                simulateSendPickOutTasks(taskGroupIds, Collections.emptyList(), Collections.emptyList(), Collections.emptyList());
             // 发送任务
             String url = configMap.get(ConfigMapKeyEnum.URL_WCS_TASK.getConfigKey());
             if (url != null) {
-                    logger.info("向WCS发送任务，地址：{}，请求详情：{}", url, convertJsonString(request));
-                    ResponseEntity result = JSON.parseObject(HttpUtils.sendHttpPostWithoutToken(url, convertJsonString(request)), ResponseEntity.class);
+                // 循环发送任务
+                for (int i = 0; i < request.size(); i += maxWcsAcceptNums) {
+                    List<WcsTaskRequest> tempRequest = request.subList(i, Math.min(i + maxWcsAcceptNums, request.size()));
+                    logger.info("向WCS发送任务{}-{}，地址：{}，请求详情：{}", i + 1, Math.min(i + maxWcsAcceptNums, request.size()), url, convertJsonString(tempRequest));
+                    ResponseEntity result = JSON.parseObject(HttpUtils.sendHttpPostWithoutToken(url, convertJsonString(tempRequest)), ResponseEntity.class);
                     try {
-                        logService.save(new WmsLog(WmsUtils.generateId("LOG_"), "向WCS发送任务", "SetStackerTask", JSON.toJSONString(request), JSON.toJSONString(result), url, LocalDateTime.now(), "WMS"));
+                        logService.save(new WmsLog(WmsUtils.generateId("LOG_"), "向WCS发送任务", "SetStackerTask", JSON.toJSONString(tempRequest), JSON.toJSONString(result), url, LocalDateTime.now(), "WMS"));
                     } catch (Exception e) {
-                        logger.error("插入日志错误。");
+                        logger.error("保存发送任务的日志错误。");
                     }
                     if (result == null) {
-                        logger.error("发送任务异常。");
+                        logger.error("发送堆垛机任务异常。");
                     } else {
                         if (Objects.equals(ResponseCode.OK.getCode(), result.getCode())) {
                             logger.info("发送WCS任务成功。");
+                            List<String> successTaskIds = tempRequest.stream().map(WcsTaskRequest::getTaskId).toList();
                             taskService.update(new LambdaUpdateWrapper<Task>()
                                     .set(Task::getTaskStatus, WmsTaskStatus.WAIT.getCode())
-                                    .in(Task::getTaskGroup, taskGroupIds)
+                                    .in(Task::getTaskGroup, successTaskIds)
                                     .eq(Task::getTaskStatus, WmsTaskStatus.NEW.getCode()));
                         } else {
+                            logger.error("发送任务错误：{}", convertJsonString(result));
                             // 判断returnData的数据
                             if (result.getReturnData() != null) {
                                 List<WcsTaskRequest> errorTasks = JSON.parseArray(result.getReturnData().toString(), WcsTaskRequest.class);
@@ -163,381 +160,20 @@ public class WmsJobServiceImplements implements IWmsJobService {
                                             .eq(Task::getTaskStatus, WmsTaskStatus.NEW.getCode()));
                                 }
                             }
-                            logger.error("发送任务错误：{}", convertJsonString(result));
+                        }
                     }
                 }
             } else {
                 logger.error("WCS发送任务地址为空。");
             }
         }
-        } catch (Exception exception) {
-            logger.error("向WCS发送任务时发生异常：{}", convertJsonString(exception));
-            throw new Exception("向WCS发送任务时发生异常。");
     }
-    }
-
-    /**
-     * 发送PickOut任务
-     * @throws Exception 异常
-     */
-//    @Override
-//    public void sendPickOutTasks() throws Exception {
-//        try {
-//            // 检索任务表---新建未下发的任务
-//            LambdaQueryWrapper<Task> waitForDistributeTaskQuery = new LambdaQueryWrapper<Task>()
-//                    .eq(Task::getTaskStatus, WmsTaskStatus.NEW.getCode())
-//                    .eq(Task::getTaskType, TaskType.OUT.getCode())
-//                    .eq(Task::getTaskPriority, 1);
-//            List<Task> allTasks = taskService.list(waitForDistributeTaskQuery);
-//            if (!allTasks.isEmpty()) {
-//                String max_vehicle_nums = configMap.get(ConfigMapKeyEnum.MAX_VEHICLE_NUMS.getConfigKey());
-//                String max_wcs_accept_nums = configMap.get(ConfigMapKeyEnum.MAX_WCS_ACCEPT_NUMS.getConfigKey());
-//                String max_stand_vehicle_nums = configMap.get(ConfigMapKeyEnum.MAX_STAND_VEHICLE_NUMS.getConfigKey());
-//                if (StringUtils.isEmpty(max_vehicle_nums) || StringUtils.isEmpty(max_wcs_accept_nums) || StringUtils.isEmpty(max_stand_vehicle_nums)) {
-//                    logger.error("配置未生成");
-//                    return;
-//                }
-//                int maxVehicleNums = Integer.parseInt(max_vehicle_nums);// 线体最大箱子数量
-//                int maxWcsAcceptNums = Integer.parseInt(max_wcs_accept_nums);// wcs最大一次性可接受任务数量
-//                int maxStandVehicleNums = Integer.parseInt(max_stand_vehicle_nums);// 每个站台最大箱子数量
-//                List<String> outsideVehicles = outsideVehiclesService.selectDistinctVehicles();
-//                if (outsideVehicles == null || outsideVehicles.isEmpty()) {
-//                    outsideVehicles = Collections.emptyList();
-//                }
-//                int remainVehicleNums = maxVehicleNums - outsideVehicles.size();// 线体剩余箱子数量
-//                if (remainVehicleNums <= 0) {
-//                    return;
-//                }
-//
-//                // 需要发送给wcs的任务列表
-//                List<WcsTaskRequest> request = new ArrayList<>();
-//                // 已经下发的任务组列表
-//                List<String> taskGroupIds = new ArrayList<>();
-//                // 本次生成的箱子
-//                List<String> pickVehicleIds = new ArrayList<>();
-//                // 本次跳过的箱子
-//                List<String> skipVehicleIds = new ArrayList<>();
-//                // 查找所有站台拣选任务
-//                List<PickTask> standPickTasks = pickTaskService.list();
-//                // 生成一个Map，计算每个站台已经出库的拣选任务
-//                Map<String, Integer> outPickTaskMap = new HashMap<>();
-//                Map<String, Integer> updatedOutPickTaskMap = new HashMap<>();
-//                // 轮询工作站台，判断是否需要下发任务
-//                List<Stand> stands = standService.list(new LambdaQueryWrapper<Stand>()
-//                        .eq(Stand::getIsLock, 0).eq(Stand::getStandStatus, 0)
-//                        .eq(Stand::getStandType, 2));
-//                for (Stand workStation : stands) {
-//                    outPickTaskMap.put(workStation.getStandId(), workStation.getPickVehicleCount());
-//                    updatedOutPickTaskMap.put(workStation.getStandId(), workStation.getPickVehicleCount());
-//                }
-//                // 轮询堆垛机状态
-//                List<Stand> stackerList = standService.list(new LambdaQueryWrapper<Stand>()
-//                        .eq(Stand::getIsLock, 0).eq(Stand::getStandStatus, 0)
-//                        .eq(Stand::getStandType, 3));
-//                List<Task> stackRunningTasks = taskService.list(new LambdaQueryWrapper<Task>()
-//                        .eq(Task::getTaskType, TaskType.OUT.getCode())
-//                        .and(wrapper -> wrapper.eq(Task::getTaskStatus, WmsTaskStatus.WAIT.getCode())
-//                                .or().eq(Task::getTaskStatus, WmsTaskStatus.RUN.getCode())));
-//                Map<Integer, Integer> runningTaskNumToEquipmentMap = new HashMap<>();
-//                for (Stand stacker : stackerList) {
-//                    // 找这台堆垛机正在执行的拣选出库任务数量
-//                    runningTaskNumToEquipmentMap.put(stacker.getEquipmentId(), 0);
-//                }
-//                // 生成堆垛机可用列表
-//                for (Task tempStackRunningTask : stackRunningTasks) {
-//                    if (instantLocationMap.containsKey(tempStackRunningTask.getOrigin())) {
-//                        int key = instantLocationMap.get(tempStackRunningTask.getOrigin()).getEquipmentId();
-//                        if (runningTaskNumToEquipmentMap.isEmpty()) {
-//                            // 没有可用堆垛机
-//                            break;
-//                        }
-//                        if (runningTaskNumToEquipmentMap.containsKey(key)) {
-//                            if (runningTaskNumToEquipmentMap.get(key) >= 3) {
-//                                runningTaskNumToEquipmentMap.remove(key);
-//                            } else {
-//                                runningTaskNumToEquipmentMap.replace(key, runningTaskNumToEquipmentMap.get(key) + 1);
-//                            }
-//                        }
-//                    }
-//                }
-//                if (runningTaskNumToEquipmentMap.isEmpty()) {
-//                    // 没有可用堆垛机
-//                    return;
-//                }
-//                // 还有可用堆垛机
-//                while(!runningTaskNumToEquipmentMap.isEmpty()) {
-//                    if (request.size() >= maxWcsAcceptNums || remainVehicleNums <= 0) {
-//                        // 超过wcs一次可接受数量
-//                        break;
-//                    }
-//                    if (outPickTaskMap.isEmpty()) {
-//                        // 没有站台可以使用
-//                        break;
-//                    }
-//                    // 先找出目前数量最少的站台
-//                    String standId = outPickTaskMap.entrySet().stream()
-//                            .min(Comparator.comparingInt(Map.Entry::getValue))
-//                            .map(Map.Entry::getKey)
-//                            .orElse("");
-//                    List<String> vehicleIds;
-//                    if (StringUtils.isNotEmpty(standId)) {
-//                        // 如果这个站台箱子数量超过最大每个站台的箱子数量，则跳过
-//                        if (outPickTaskMap.get(standId) >= maxStandVehicleNums) {
-//                            outPickTaskMap.remove(standId);
-//                            continue;
-//                        }
-//                        // 查找这个站台未下发的料箱
-//                        vehicleIds = standPickTasks.stream()
-//                                .filter(pickTask -> pickTask.getStandId().equals(standId) && pickTask.getPickStatus().equals(PickTaskStatusEnum.TEMP.getCode())
-//                                        && !pickVehicleIds.contains(pickTask.getVehicleId())
-//                                && !skipVehicleIds.contains(pickTask.getVehicleId()))
-//                                .map(PickTask::getVehicleId)
-//                                .distinct()
-//                                .toList();
-//                        if (vehicleIds.isEmpty()) {
-//                            outPickTaskMap.remove(standId);
-//                            continue;
-//                        }
-//                    } else {
-//                        vehicleIds = standPickTasks.stream()
-//                                .filter(pickTask -> pickTask.getPickStatus().equals(PickTaskStatusEnum.TEMP.getCode())
-//                                        && !pickVehicleIds.contains(pickTask.getVehicleId())
-//                                        && !skipVehicleIds.contains(pickTask.getVehicleId()))
-//                                .map(PickTask::getVehicleId)
-//                                .distinct()
-//                                .toList();
-//                        if (vehicleIds.isEmpty()) {
-//                            break;
-//                        }
-//                    }
-//                    // 生成箱子-站台数量的Map
-//                    Map<String, Integer> vehicleStandsMap = new HashMap<>();
-//                    standPickTasks.forEach(pickTask -> {
-//                        if (vehicleIds.contains(pickTask.getVehicleId())) {
-//                            vehicleStandsMap.put(pickTask.getVehicleId(),
-//                                    vehicleStandsMap.getOrDefault(pickTask.getVehicleId(), 0) + 1);
-//                        }
-//                    });
-//                    // 最多使用的箱子
-//                    String maxVehicleId = vehicleStandsMap.entrySet().stream()
-//                            .max(Comparator.comparingInt(Map.Entry::getValue))
-//                            .map(Map.Entry::getKey)
-//                            .orElse("");
-//                    if (!StringUtils.isEmpty(maxVehicleId)) {
-//                        // 找到这个箱子的任务
-//                        List<Task> outPickTasks = allTasks.stream().filter(task -> task.getVehicleId().equals(maxVehicleId) && !pickVehicleIds.contains(task.getVehicleId())
-//                                && task.getIsPicking() == 1 && StringUtils.isNotEmpty(task.getPickStand())).toList();
-//                        if (!outPickTasks.isEmpty()) {
-//                            // 更新每个站台的拣选箱数量
-//                            List<String> maxStandIds = standPickTasks.stream()
-//                                    .filter(pickTask -> pickTask.getVehicleId().equals(maxVehicleId))
-//                                    .map(PickTask::getStandId)
-//                                    .distinct()
-//                                    .toList();
-//                            // 给当前设备号+1
-//                            int equipmentId = instantLocationMap.get(outPickTasks.get(0).getOrigin()).getEquipmentId();
-//                            if (runningTaskNumToEquipmentMap.containsKey(equipmentId)) {
-//                                boolean flag = false;
-//                                for (Task task : outPickTasks) {
-//                                    if (taskGroupIds.contains(task.getTaskGroup())) {
-//                                        // 该任务组已经下发
-//                                        continue;
-//                                    }
-//                                    if (StringUtils.isNotEmpty(task.getPreTask())) {// 当前任务具有前置任务
-//                                        // 查询一下前置的任务有没有存在，存在则不下发
-//                                        if (taskService.exists(new LambdaQueryWrapper<Task>().eq(Task::getTaskId, task.getPreTask()))) {
-//                                            continue;
-//                                        }
-//                                    }
-//                                    // 创建发送的任务
-//                                    WcsTaskRequest tempTask = new WcsTaskRequest();
-//                                    tempTask.setTaskId(task.getTaskGroup());
-//                                    tempTask.setTaskType(task.getTaskType());
-//                                    tempTask.setOrigin(task.getOrigin());
-//                                    tempTask.setDestination(task.getDestination());
-//                                    tempTask.setVehicleNo(task.getVehicleId());
-//                                    tempTask.setVehicleSize(task.getVehicleSize());
-//                                    tempTask.setWeight(task.getWeight());
-//                                    tempTask.setPriority(task.getTaskPriority());
-//                                    request.add(tempTask);
-//                                    // 已经发送过的任务组
-//                                    taskGroupIds.add(task.getTaskGroup());
-//                                    flag = true;
-//                                }
-//                                if (flag) {
-//                                    if (!maxStandIds.isEmpty()) {
-//                                        maxStandIds.forEach(tempStandId -> {
-//                                            outPickTaskMap.put(tempStandId, outPickTaskMap.getOrDefault(tempStandId, 0) + 1);
-//                                            updatedOutPickTaskMap.put(tempStandId, updatedOutPickTaskMap.getOrDefault(tempStandId, 0) + 1);
-//                                        });
-//                                    }
-//                                    runningTaskNumToEquipmentMap.replace(equipmentId, runningTaskNumToEquipmentMap.get(equipmentId) + 1);
-//                                    // 已经发送过的vehicleId
-//                                    pickVehicleIds.add(maxVehicleId);
-//                                    vehicleStandsMap.remove(maxVehicleId);
-//                                    // 剩余线体可继续出库料箱数量
-//                                    remainVehicleNums--;
-//                                }
-//                            } else {
-//                                if (!skipVehicleIds.contains(maxVehicleId)) {
-//                                    skipVehicleIds.add(maxVehicleId);
-//                                }
-//                            }
-//                        } else {
-//                            if (!skipVehicleIds.contains(maxVehicleId)) {
-//                                skipVehicleIds.add(maxVehicleId);
-//                            }
-//                        }
-//                    }
-//                    // 最少使用的箱子
-//                    String minVehicleId = vehicleStandsMap.entrySet().stream()
-//                            .min(Comparator.comparingInt(Map.Entry::getValue))
-//                            .map(Map.Entry::getKey)
-//                            .orElse("");
-//                    if (!StringUtils.isEmpty(minVehicleId)) {
-//                        // 找到这个箱子的任务
-//                        List<Task> outPickTasks = allTasks.stream().filter(task -> task.getVehicleId().equals(minVehicleId) && !pickVehicleIds.contains(task.getVehicleId())
-//                                && task.getIsPicking() == 1 && StringUtils.isNotEmpty(task.getPickStand())).toList();
-//                        if (!outPickTasks.isEmpty()) {
-//                            // 更新每个站台的拣选箱数量
-//                            List<String> minStandIds = standPickTasks.stream()
-//                                    .filter(pickTask -> pickTask.getVehicleId().equals(minVehicleId))
-//                                    .map(PickTask::getStandId)
-//                                    .distinct()
-//                                    .toList();
-//                            // 给当前设备号+1
-//                            int equipmentId = instantLocationMap.get(outPickTasks.get(0).getOrigin()).getEquipmentId();
-//                            if (runningTaskNumToEquipmentMap.containsKey(equipmentId)) {
-//                                boolean flag = false;
-//                                for (Task task : outPickTasks) {
-//                                    if (taskGroupIds.contains(task.getTaskGroup())) {
-//                                        // 该任务组已经下发
-//                                        continue;
-//                                    }
-//                                    if (StringUtils.isNotEmpty(task.getPreTask())) {// 当前任务具有前置任务
-//                                        // 查询一下前置的任务有没有存在，存在则不下发
-//                                        if (taskService.exists(new LambdaQueryWrapper<Task>().eq(Task::getTaskId, task.getPreTask()))) {
-//                                            continue;
-//                                        }
-//                                    }
-//                                    // 创建发送的任务
-//                                    WcsTaskRequest tempTask = new WcsTaskRequest();
-//                                    tempTask.setTaskId(task.getTaskGroup());
-//                                    tempTask.setTaskType(task.getTaskType());
-//                                    tempTask.setOrigin(task.getOrigin());
-//                                    tempTask.setDestination(task.getDestination());
-//                                    tempTask.setVehicleNo(task.getVehicleId());
-//                                    tempTask.setVehicleSize(task.getVehicleSize());
-//                                    tempTask.setWeight(task.getWeight());
-//                                    tempTask.setPriority(task.getTaskPriority());
-//                                    request.add(tempTask);
-//                                    // 已经发送过的任务组
-//                                    taskGroupIds.add(task.getTaskGroup());
-//                                    flag = true;
-//                                }
-//                                if (flag) {
-//                                    if (!minStandIds.isEmpty()) {
-//                                        minStandIds.forEach(tempStandId -> {
-//                                            outPickTaskMap.put(tempStandId, outPickTaskMap.getOrDefault(tempStandId, 0) + 1);
-//                                            updatedOutPickTaskMap.put(tempStandId, updatedOutPickTaskMap.getOrDefault(tempStandId, 0) + 1);
-//                                        });
-//                                    }
-//                                    runningTaskNumToEquipmentMap.replace(equipmentId, runningTaskNumToEquipmentMap.get(equipmentId) + 1);
-//                                    // 已经发送过的vehicleId
-//                                    pickVehicleIds.add(minVehicleId);
-//                                    vehicleStandsMap.remove(minVehicleId);
-//                                    // 剩余线体可继续出库料箱数量
-//                                    remainVehicleNums--;
-//                                }
-//                            } else {
-//                                if (!skipVehicleIds.contains(minVehicleId)) {
-//                                    skipVehicleIds.add(minVehicleId);
-//                                }
-//                            }
-//                        } else {
-//                            if (!skipVehicleIds.contains(minVehicleId)) {
-//                                skipVehicleIds.add(minVehicleId);
-//                            }
-//                        }
-//                    }
-//                    List<Integer> removeKeys = new ArrayList<>(runningTaskNumToEquipmentMap.keySet().stream().toList());
-//                    for (int equipmentId : removeKeys) {
-//                        // 剩余任务有没有这台堆垛机的
-//                        List<Task> remainTasks = allTasks.stream().filter(task -> !skipVehicleIds.contains(task.getVehicleId()) && !pickVehicleIds.contains(task.getVehicleId())
-//                                && task.getIsPicking() == 1 && StringUtils.isNotEmpty(task.getPickStand())).toList();
-//                        if (remainTasks.isEmpty() || runningTaskNumToEquipmentMap.get(equipmentId) >= 3) {
-//                            runningTaskNumToEquipmentMap.remove(equipmentId);
-//                        }
-//                    }
-//                }
-//
-//                if (request.size() == 0) {
-//                    // 没有新任务发送
-//                    return;
-//                }
-//                // 发送任务
-//                String url = configMap.get(ConfigMapKeyEnum.URL_WCS_TASK.getConfigKey());
-//                if (url != null) {
-//                    logger.info("向WCS发送拣选出库任务，地址：{}，请求详情：{}", url, convertJsonString(request));
-//                    ResponseEntity result = JSON.parseObject(HttpUtils.sendHttpPostWithoutToken(url, convertJsonString(request)), ResponseEntity.class);
-//                    try {
-//                        logService.save(new WmsLog(WmsUtils.generateId("LOG_"), "向WCS发送任务", "SetStackerTask", JSON.toJSONString(request), JSON.toJSONString(result), url, LocalDateTime.now(), "WMS"));
-//                    } catch (Exception e) {
-//                        logger.error("插入日志错误。");
-//                    }
-//                    if (result == null) {
-//                        logger.error("发送拣选出库任务异常。");
-//                    } else {
-//                        if (Objects.equals(ResponseCode.OK.getCode(), result.getCode())) {
-//                            logger.info("发送WCS拣选出库任务成功。");
-//                            taskService.update(new LambdaUpdateWrapper<Task>()
-//                                    .set(Task::getTaskStatus, WmsTaskStatus.WAIT.getCode())
-//                                    .in(Task::getTaskGroup, taskGroupIds)
-//                                    .eq(Task::getTaskStatus, WmsTaskStatus.NEW.getCode()));
-//                            // 流转载具状态变更
-//                            if (!pickVehicleIds.isEmpty()) {
-//                                outsideVehiclesService.update(new LambdaUpdateWrapper<OutsideVehicles>()
-//                                        .set(OutsideVehicles::getOutStatus, 1)
-//                                        .in(OutsideVehicles::getVehicleId, pickVehicleIds));
-//                                // 更新站台拣选箱数
-//                                for (String tempStandId : updatedOutPickTaskMap.keySet()) {
-//                                    standService.update(new LambdaUpdateWrapper<Stand>()
-//                                            .set(Stand::getPickVehicleCount, updatedOutPickTaskMap.get(tempStandId))
-//                                            .eq(Stand::getStandId, tempStandId));
-//                                }
-//                            }
-//                        } else {
-//                            // 判断returnData的数据
-//                            if (result.getReturnData() != null) {
-//                                List<WcsTaskRequest> errorTasks = JSON.parseArray(result.getReturnData().toString(), WcsTaskRequest.class);
-//                                if (!errorTasks.isEmpty()) {
-//                                    List<String> failedTaskIds = errorTasks.stream().map(WcsTaskRequest::getTaskId).distinct().toList();
-//                                    // 更新任务状态为异常
-//                                    taskService.update(new LambdaUpdateWrapper<Task>()
-//                                            .set(Task::getTaskStatus, WmsTaskStatus.EXCEPTION.getCode())
-//                                            .in(Task::getTaskGroup, failedTaskIds)
-//                                            .eq(Task::getTaskStatus, WmsTaskStatus.NEW.getCode()));
-//                                }
-//                            }
-//                            logger.error("发送拣选出库任务错误：{}", convertJsonString(result));
-//                        }
-//                    }
-//                } else {
-//                    logger.error("WCS发送任务地址为空。");
-//                }
-//            }
-//        } catch (Exception exception) {
-//            logger.error("向WCS发送拣选出库任务时发生异常：{}", convertJsonString(exception));
-//            throw new Exception("向WCS发送拣选出库任务时发生异常。");
-//        }
-//    }
 
     /**
      * 发送拣选任务
      */
     @Override
-    public void sendPickTasks() throws Exception {
-        try {
+    public void sendPickTasks() {
         // 检索任务表---新建未下发的拣选任务
         LambdaQueryWrapper<PickTask> waitForDistributePickTaskQuery = new LambdaQueryWrapper<PickTask>()
                 .eq(PickTask::getPickStatus, PickTaskStatusEnum.NEW.getCode());
@@ -572,6 +208,8 @@ public class WmsJobServiceImplements implements IWmsJobService {
             requestSingle.setRemark("站台拣选任务");
             request.add(requestSingle);
         }
+        // 下面是模拟发送wcs拣选任务
+//            simulateSendPickTasks(vehicleAndStansMap.keySet().stream().toList());
         if (!request.isEmpty()) {
             // 发送任务
             String url = configMap.get(ConfigMapKeyEnum.URL_WCS_PICK_TASK.getConfigKey());
@@ -581,7 +219,7 @@ public class WmsJobServiceImplements implements IWmsJobService {
                 try {
                     logService.save(new WmsLog(WmsUtils.generateId("LOG_"), "向WCS发送拣选任务", "setConveyTask", convertJsonString(request), convertJsonString(result), url, LocalDateTime.now(), "WMS"));
                 } catch (Exception e) {
-                        logger.error("插入日志错误。");
+                    logger.error("保存发送拣选任务日志错误。");
                 }
                 if (result != null && Objects.equals(ResponseCode.OK.getCode(), result.getCode())) {
                     logger.info("发送拣选任务成功。");
@@ -596,10 +234,6 @@ public class WmsJobServiceImplements implements IWmsJobService {
                 logger.error("WCS发送拣选任务地址为空。");
             }
         }
-        } catch (Exception exception) {
-            logger.error("向WCS发送拣选任务时发生异常：{}", convertJsonString(exception));
-            throw new Exception("向WCS发送拣选任务时发生异常。");
-        }
     }
 
     /**
@@ -710,12 +344,12 @@ public class WmsJobServiceImplements implements IWmsJobService {
             int interval = 180;// 普通接口记录默认保留180天
             int importantInterval = 365;// 重要接口记录默认保留一年
             try {
-                interval = Integer.parseInt(configMap.get(ConfigMapKeyEnum.LOG_DELETE_INTERVAL.getConfigKey()));
+                interval = Integer.parseInt(configMap.get(ConfigMapKeyEnum.RECORD_DELETE_INTERVAL.getConfigKey()));
             } catch (Exception e) {
                 logger.error("获取普通记录清理天数错误，使用默认值180天");
             }
             try {
-                importantInterval = Integer.parseInt(configMap.get(ConfigMapKeyEnum.LOG_DELETE_INTERVAL.getConfigKey()));
+                importantInterval = Integer.parseInt(configMap.get(ConfigMapKeyEnum.IMPORTANT_RECORD_DELETE_INTERVAL.getConfigKey()));
             } catch (Exception e) {
                 logger.error("获取重要记录清理天数错误，使用默认值365天");
             }
@@ -725,6 +359,7 @@ public class WmsJobServiceImplements implements IWmsJobService {
             // 查询过期任务记录
             List<TaskRecord> expireTaskRecords = taskRecordService.list(new LambdaQueryWrapper<TaskRecord>()
                     .lt(TaskRecord::getCreateTime, deleteTime));
+            String ROOT_PATH = "./file";
             if (expireTaskRecords != null && !expireTaskRecords.isEmpty()) {
                 List<String> needRemoveIds = new ArrayList<>();
                 List<DbOfTaskRecord> finishedExcelTemp = new ArrayList<>();
@@ -938,7 +573,7 @@ public class WmsJobServiceImplements implements IWmsJobService {
         // 判断数据行是不是过多
         int rowCount = list.size();
         // 每50万行一个文件
-        int rowCountPerFile = 300000;
+        int rowCountPerFile = 100000;
         int fileCounts = (rowCount + rowCountPerFile - 1) / rowCountPerFile;
         for (int i = 1; i <= fileCounts; i++) {
             List<T> dividedList = list.subList((i - 1) * rowCountPerFile, Math.min(i * rowCountPerFile, rowCount));
@@ -1280,22 +915,29 @@ public class WmsJobServiceImplements implements IWmsJobService {
 //                                .max(Comparator.comparingInt(Map.Entry::getValue))
 //                                .map(Map.Entry::getKey)
 //                                .orElse("");
-                        // new 查找已下发状态以上最少箱子的站台
-                        String standId = standPickCountsMap.entrySet().stream()
-                                .min(Comparator.comparingInt(Map.Entry::getValue))
-                                .map(Map.Entry::getKey)
-                                .orElse("");
-
+                        // 对这些站台进行排序，从少到多
+                        List<String> standIds = standPickCountsMap.entrySet().stream()
+                                .sorted(Comparator.comparingInt(Map.Entry::getValue))
+                                .map(Map.Entry::getKey).toList();
+                        List<String> minStandVehicleIds = new ArrayList<>();
+                        String minStandId = "";
+                        for (String standId : standIds) {
                             // 查找这个站台未下发的料箱
-                        List<String> vehicleIds = standPickTasks.stream()
+                            minStandVehicleIds = standPickTasks.stream()
                                     .filter(pickTask -> pickTask.getPickStatus().equals(PickTaskStatusEnum.TEMP.getCode())
                                             && thisStackerVehicleIds.contains(pickTask.getVehicleId()) && standId.equals(pickTask.getStandId()))
                                     .map(PickTask::getVehicleId)
                                     .distinct()
                                     .toList();
-                        if (vehicleIds.isEmpty()) {
+                            if (!minStandVehicleIds.isEmpty()) {
+                                minStandId = standId;
                                 break;
                             }
+                        }
+                        if (minStandVehicleIds.isEmpty()) {
+                            break;
+                        }
+                        List<String> vehicleIds = minStandVehicleIds;
                         // 生成箱子-站台数量的Map
                         Map<String, Integer> vehicleStandsMap = new HashMap<>();
                         standPickTasks.forEach(pickTask -> {
@@ -1342,7 +984,7 @@ public class WmsJobServiceImplements implements IWmsJobService {
                                     // 添加特殊任务
                                     newStandStackerTask.setVehicleId(task.getVehicleId());
                                     newStandStackerTask.setStackerId(stacker.getEquipmentId());
-                                    newStandStackerTask.setStandId(standId);
+                                    newStandStackerTask.setStandId(minStandId);
                                     newStandStackerTask.setTaskType(2);
                                     newStandStackerTask.setTaskStatus(0);
                                     newStandStackerTask.setCreateTime(LocalDateTime.now());
@@ -1354,7 +996,7 @@ public class WmsJobServiceImplements implements IWmsJobService {
                                     // 已经发送过的vehicleId
                                     pickVehicleIds.add(vehicleId);
                                     availNum--;
-                                    standPickCountsMap.put(standId, standPickCountsMap.get(standId) + 1);
+                                    standPickCountsMap.put(minStandId, standPickCountsMap.getOrDefault(minStandId, 0) + 1);
                                 }
                             }
                         }
@@ -1364,6 +1006,7 @@ public class WmsJobServiceImplements implements IWmsJobService {
                     // 没有新任务发送
                     return;
                 }
+                // 下面这行代码模拟wcs下发成功
 //                simulateSendPickOutTasks(taskGroupIds, pickVehicleIds, needAddStandStackerTasks, needRemoveStandStackerTasks);
                 // 发送任务
                 String url = configMap.get(ConfigMapKeyEnum.URL_WCS_TASK.getConfigKey());
@@ -1444,7 +1087,7 @@ public class WmsJobServiceImplements implements IWmsJobService {
 
                         }
                 } else {
-                    logger.error("WCS发送任务地址为空。");
+                    logger.error("WCS发送站台出库任务地址为空。");
                 }
             }
         } catch (Exception exception) {
@@ -1455,13 +1098,13 @@ public class WmsJobServiceImplements implements IWmsJobService {
 
     /**
      * 模拟出库发送成功
-     * @param taskGroupIds
-     * @param pickVehicleIds
-     * @param needAddStandStackerTasks
-     * @param needRemoveStandStackerTasks
+     * @param taskGroupIds 任务组
+     * @param pickVehicleIds 拣选料箱id
+     * @param needAddStandStackerTasks 需要添加的堆垛机站台任务
+     * @param needRemoveStandStackerTasks 需要移除的堆垛机站台任务
      */
     void simulateSendPickOutTasks(List<String> taskGroupIds, List<String> pickVehicleIds, List<StandStackerTask> needAddStandStackerTasks, List<StandStackerTask> needRemoveStandStackerTasks) {
-        logger.info("发送WCS拣选出库任务成功。");
+        logger.info("模拟发送wcs任务。");
         taskService.update(new LambdaUpdateWrapper<Task>()
                 .set(Task::getTaskStatus, WmsTaskStatus.WAIT.getCode())
                 .in(Task::getTaskGroup, taskGroupIds)
@@ -1473,7 +1116,10 @@ public class WmsJobServiceImplements implements IWmsJobService {
                     .in(OutsideVehicles::getVehicleId, pickVehicleIds));
         }
         // 更新特殊信息
+        if (!needAddStandStackerTasks.isEmpty()) {
             standStackerTaskService.saveBatch(needAddStandStackerTasks);
+        }
+        if (!needRemoveStandStackerTasks.isEmpty()) {
             standStackerTaskService.removeBatchByIds(needRemoveStandStackerTasks);
             List<StandStackerTaskBak> needSaveRecords = new ArrayList<>();
             for (StandStackerTask standStackerTask : needRemoveStandStackerTasks) {
@@ -1484,3 +1130,16 @@ public class WmsJobServiceImplements implements IWmsJobService {
             standStackerTaskBakService.saveBatch(needSaveRecords);
         }
     }
+
+    /**
+     * 模拟发送拣选任务
+     * @param vehicleIds 载具号
+     */
+    void simulateSendPickTasks(List<String> vehicleIds) {
+        logger.info("模拟发送拣选任务。");
+        dbTransUtils.useTran(() -> pickTaskService.update(new LambdaUpdateWrapper<PickTask>()
+                .set(PickTask::getPickStatus, PickTaskStatusEnum.SEND.getCode())
+                .in(PickTask::getVehicleId, vehicleIds)
+                .eq(PickTask::getPickStatus, PickTaskStatusEnum.NEW.getCode())));
+    }
+}

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

@@ -6,10 +6,12 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.wms.constants.enums.*;
 import com.wms.entity.app.dto.WorkCenterAndOrderDto;
+import com.wms.entity.app.dto.extend.StockDetailInfo;
 import com.wms.entity.table.*;
 import com.wms.service.*;
 import com.wms.service.business.IWmsTaskService;
 import com.wms.service.business.IWorkService;
+import com.wms.utils.DbTransUtils;
 import com.wms.utils.StringUtils;
 import lombok.RequiredArgsConstructor;
 import org.slf4j.Logger;
@@ -57,11 +59,13 @@ public class WorkServiceImplements implements IWorkService {
     private final WorkFlowLastService workFlowLastService;// 服务
     private final List<String> workCreatingStations = new ArrayList<>();// 当前正在创建任务的站台
     private final VehicleService vehicleService;// 料箱服务
+    private final DbTransUtils dbTransUtils;// 事务事务工具类
 
 
     //获取配置文件的是否添加了需求时间
     @Value("${reqmtsDate}")
     private boolean isAddReqmtsDate;
+    private List<String> orderIds;
 
     /**
      * 找到下一个工作日
@@ -69,7 +73,8 @@ public class WorkServiceImplements implements IWorkService {
      * @param currentDate 当前日期
      * @return 下一个工作日
      */
-    private LocalDate nextWorkDate(LocalDate currentDate) {
+    @Override
+    public LocalDate nextWorkDate(LocalDate currentDate) {
         // 判断是否是当天开工
         int indexOfCurrentDate = localWorkDateList.indexOf(currentDate);
         if (indexOfCurrentDate == -1) {
@@ -267,6 +272,481 @@ public class WorkServiceImplements implements IWorkService {
         }
     }
 
+    /**
+     * 新的执行工作方法
+     */
+    @Override
+    public void doWorkMethod2() {
+        // 查询一些配置信息
+        String max_vehicle_nums = configMap.get(ConfigMapKeyEnum.MAX_VEHICLE_NUMS.getConfigKey());
+        String max_vehicle_nums_before = configMap.get(ConfigMapKeyEnum.MAX_VEHICLE_BEFORE.getConfigKey());
+        String max_vehicle_nums_after = configMap.get(ConfigMapKeyEnum.MAX_VEHICLE_AFTER.getConfigKey());
+        String max_stand_vehicle_nums = configMap.get(ConfigMapKeyEnum.MAX_STAND_VEHICLE_NUMS.getConfigKey());
+        if (!"1".equals(configMap.get(ConfigMapKeyEnum.SAME_AREA.getConfigKey()))) {
+            if (StringUtils.isEmpty(max_vehicle_nums) || StringUtils.isEmpty(max_stand_vehicle_nums)) {
+                logger.info("允许不同区域时配置未生成。");
+                return;
+            }
+        } else {
+            if (StringUtils.isEmpty(max_vehicle_nums_before) || StringUtils.isEmpty(max_vehicle_nums_after) || StringUtils.isEmpty(max_stand_vehicle_nums)) {
+                logger.info("不允许不同区域时配置未生成。");
+                return;
+            }
+        }
+        // 查找到未完成的工作
+        List<WorkFlow> unfinishedWorkFlowList = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
+                .notIn(WorkFlow::getWorkStatus, -1, 2));
+        if (unfinishedWorkFlowList.isEmpty()) {
+            // 没有未完成的工作
+            logger.info("没有未完成的工作。");
+            return;
+        }
+        // 查询拣选任务
+        List<PickTask> pickTaskList = pickTaskService.list();
+        // 本次可以出库的站台
+        List<String> thisTimeCanOutStandIds = new ArrayList<>();
+        if (!"1".equals(configMap.get(ConfigMapKeyEnum.SAME_AREA.getConfigKey()))) {
+            List<String> standIdsTotal = List.of("ASRS-#1", "ASRS-#2", "ASRS-#3", "ASRS-#4", "ASRS-#5", "ASRS-#6", "ASRS-#7", "ASRS-#8", "ASRS-#9");
+            int maxVehicleNums = Integer.parseInt(max_vehicle_nums);// 线体最大箱子数量
+            // 根据载具号map一下
+            List<String> outVehicleIdList = pickTaskList.stream().map(PickTask::getVehicleId).distinct().toList();
+            if (outVehicleIdList.size() < maxVehicleNums) {
+                thisTimeCanOutStandIds.addAll(standIdsTotal);
+            }
+        } else {
+            List<String> standIdsBefore = List.of("ASRS-#1", "ASRS-#2", "ASRS-#3", "ASRS-#4", "ASRS-#5");
+            List<String> standIdsAfter = List.of("ASRS-#6", "ASRS-#7", "ASRS-#8", "ASRS-#9");
+            int maxVehicleNumsBefore = Integer.parseInt(max_vehicle_nums_before);// 前区线体最大箱子数量
+            int maxVehicleNumsAfter = Integer.parseInt(max_vehicle_nums_after);// 后区线体最大箱子数量
+            Map<String, Integer> vehicleMapBefore = new HashMap<>();
+            Map<String, Integer> vehicleMapAfter = new HashMap<>();
+            for (PickTask tempPickTask : pickTaskList) {
+                // 前区箱子
+                if (standIdsBefore.contains(tempPickTask.getStandId()) && !vehicleMapBefore.containsKey(tempPickTask.getVehicleId())) {
+                    vehicleMapBefore.put(tempPickTask.getVehicleId(), 1);
+                }
+                // 后区箱子
+                if (standIdsAfter.contains(tempPickTask.getStandId()) && !vehicleMapAfter.containsKey(tempPickTask.getVehicleId())) {
+                    vehicleMapAfter.put(tempPickTask.getVehicleId(), 1);
+                }
+            }
+            // 前区可以
+            if (vehicleMapBefore.size() < maxVehicleNumsBefore) {
+                thisTimeCanOutStandIds.addAll(standIdsBefore);
+            }
+            // 后区可以
+            if (vehicleMapAfter.size() < maxVehicleNumsAfter) {
+                thisTimeCanOutStandIds.addAll(standIdsAfter);
+            }
+        }
+        if (thisTimeCanOutStandIds.isEmpty()) {
+            // 没有可出库的站台
+            logger.info("本次无可需要出库的站台。");
+            return;
+        }
+        // 找出所有可用设备
+        List<Stand> stands = standService.list(new LambdaQueryWrapper<Stand>()
+                .eq(Stand::getIsLock, 0).eq(Stand::getStandStatus, 0));
+        // 备料站台---从9号站台开始
+        List<Stand> canUsePickStands = stands.stream().filter(stand -> stand.getStandType() == 2 && thisTimeCanOutStandIds.contains(stand.getStandId())).sorted(Comparator.comparing(Stand::getStandId).reversed()).toList();
+        // 找出所有可用堆垛机---从5号堆垛机开始
+        List<Stand> stackerList = stands.stream().filter(stand -> stand.getStandType() == 3).sorted(Comparator.comparingInt(Stand::getEquipmentId).reversed()).toList();
+        if (canUsePickStands.isEmpty() || stackerList.isEmpty()) {
+            // 没有可用站台或者可用堆垛机
+            logger.info("没有可用站台或者可用堆垛机。");
+            return;
+        }
+        List<String> canUseStandIdList = new ArrayList<>();
+        for (Stand canUseStand : canUsePickStands) {
+            // 查找这个站台已经生成的拣选任务
+            List<PickTask> pickTasksOfThisStand = pickTaskList.stream().filter(pickTask -> Objects.equals(pickTask.getStandId(), canUseStand.getStandId())).distinct().toList();
+            if (pickTasksOfThisStand.size() > Integer.parseInt(max_stand_vehicle_nums)) {
+                // 此站台已生成任务超过阈值
+                logger.info("站台{}已生成任务数量超过阈值。", canUseStand.getStandId());
+                continue;
+            }
+            canUseStandIdList.add(canUseStand.getStandId());
+        }
+        // 需要更新的数据
+        List<String> thisTimeOutVehicleIds = new ArrayList<>();// 本次出库的载具号
+        List<Task> needAddTaskList = new ArrayList<>();// 需要添加的任务数据
+        Map<String, PickTask> needAddPickTaskMap = new HashMap<>();// 需要添加的拣选任务数据
+        List<String> needUpdateWorkFlowIds = new ArrayList<>();// 需要更新的工作流id
+        List<String> needUpdateOrderIds = new ArrayList<>();// 需要更新的工单id
+        List<String> thisTimeCannotOutVehicleIds = new ArrayList<>();// 本次不能出库的载具号
+        // 查询出所有的库存
+        List<Stock> allStockList = stockService.list();
+        // 第一次循环，分出已经出库的物料。
+        Map<String, Integer> outedGoodsIdMap = new HashMap<>();
+        for (Stock stock : allStockList) {
+            if (Objects.equals(stock.getStockStatus(), StockStatus.OK.getCode()) || Objects.equals(stock.getStockStatus(), StockStatus.BACK.getCode()) || Objects.equals(stock.getStockStatus(), StockStatus.LOCK.getCode())) {
+                continue;
+            }
+            String goodsId = stock.getGoodsRelated().getGoodsId();
+            if (!outedGoodsIdMap.containsKey(goodsId)) {
+                outedGoodsIdMap.put(goodsId, 1);
+            }
+        }
+        // 查询出当前所有的出库任务（拣选）
+        List<Task> outTaskList = taskService.list(new LambdaQueryWrapper<Task>()
+                .eq(Task::getTaskType, TaskType.OUT.getCode())
+                .eq(Task::getTaskPriority, 1)
+                .eq(Task::getIsPicking, 1));
+        // 分出在库的物料
+        List<Stock> onStockStockList = allStockList.stream().filter(stock -> Objects.equals(stock.getStockStatus(), StockStatus.OK.getCode())).sorted(Comparator.comparing(Stock::getCreateTime)).toList();
+        for (String standId : canUseStandIdList) {
+            Map<Integer, Integer> equipTaskOfThisStandMap = new HashMap<>();
+            // 生成这个站台在这个设备出库的箱子
+            for (Task task : outTaskList) {
+                if (StringUtils.isEmpty(task.getPickStand())) {
+                    // 没有站台，那么跳过
+                    continue;
+                }
+                int equipmentId = getStackerIdByLocationId(task.getOrigin());
+                if (equipmentId != 0 && Objects.equals(task.getPickStand(), standId)) {
+                    // 当前设备当前站台的任务
+                    equipTaskOfThisStandMap.put(equipmentId, equipTaskOfThisStandMap.getOrDefault(equipmentId, 0) + 1);
+                }
+            }
+            Map<String, String> thisStandOutVehicleMap = new HashMap<>();// 键为载具号，值为库存id
+            for (Stock stock : onStockStockList) {
+                if (!Objects.equals(stock.getStockStatus(), StockStatus.OK.getCode())) {
+                    // 只允许在库库存操作
+                    continue;
+                }
+                // 这个载具本次不允许出库
+                if (thisTimeCannotOutVehicleIds.contains(stock.getVehicleId())) {
+                    continue;
+                }
+                // 同一物料同一时间只能在外面一个箱子
+                if (outedGoodsIdMap.containsKey(stock.getGoodsRelated().getGoodsId())) {
+                    thisTimeCannotOutVehicleIds.add(stock.getVehicleId());
+                    continue;
+                }
+                // 如果载具在本次出库的载具列表中，那么修改库存状态
+                if (thisTimeOutVehicleIds.contains(stock.getVehicleId())) {
+                    stock.setStockStatus(StockStatus.OUT.getCode());
+                    continue;
+                }
+                // 获取这条库存的设备号
+                int equipmentId = getStackerIdByLocationId(stock.getLocationId());
+                if (equipmentId == 0) {
+                    logger.info("载具{}，库位{}，未查到对应的设备号。", stock.getVehicleId(), stock.getLocationId());
+                    continue;
+                }
+                // 判断这个设备能否出库
+                if (equipTaskOfThisStandMap.containsKey(equipmentId) && equipTaskOfThisStandMap.get(equipmentId) >= 2) {
+                    // 这个站台在这台设备已经生成过两条任务，不再生成
+                    continue;
+                }
+                // 判断这个库存是否被当前站台需要
+                BigDecimal originNum = stock.getGoodsRelated().getRemainNum();
+                BigDecimal afterNum = stock.getGoodsRelated().getRemainNum();
+                for (WorkFlow workFlow : unfinishedWorkFlowList) {
+                    if (afterNum.compareTo(BigDecimal.ZERO) <= 0) {
+                        break;
+                    }
+                    if (Objects.equals(workFlow.getWorkStation(), standId) && Objects.equals(workFlow.getGoodsId(), stock.getGoodsRelated().getGoodsId())) {
+                        BigDecimal needNum = workFlow.getNeedNum().subtract(workFlow.getDistributedNum() == null ? BigDecimal.ZERO : workFlow.getDistributedNum());
+                        if (needNum.compareTo(BigDecimal.ZERO) <= 0) {
+                            continue;
+                        }
+                        if (afterNum.compareTo(needNum) >= 0) {
+                            afterNum = afterNum.subtract(needNum);
+                            workFlow.setDistributedNum(workFlow.getNeedNum());
+                        } else {
+                            afterNum = BigDecimal.ZERO;
+                            workFlow.setDistributedNum(workFlow.getDistributedNum() == null ? afterNum : workFlow.getDistributedNum().add(afterNum));
+                        }
+                        workFlow.setWorkStatus(1);
+                        // 添加需要更新的工作流id
+                        if (!needUpdateWorkFlowIds.contains(workFlow.getWorkFlowId())) {
+                            needUpdateWorkFlowIds.add(workFlow.getWorkFlowId());
+                        }
+                        // 添加需要更新的工单id
+                        if (!needUpdateOrderIds.contains(workFlow.getOrderId())) {
+                            needUpdateOrderIds.add(workFlow.getOrderId());
+                        }
+                    }
+                }
+                if (afterNum.compareTo(originNum) != 0) {
+                    // 使用过该库存，更新数量
+                    stock.setStockStatus(StockStatus.OUT.getCode());
+                    StockDetailInfo goodsRelated = stock.getGoodsRelated();
+                    goodsRelated.setRemainNum(afterNum);
+                    stock.setGoodsRelated(goodsRelated);
+                    // 创建出库任务
+                    Task vehicleOutTask = new Task();
+                    vehicleOutTask.setTaskId(generateId("CK_"));
+                    vehicleOutTask.setTaskType(TaskType.OUT.getCode());
+                    vehicleOutTask.setTaskGroup(generateId(""));
+                    vehicleOutTask.setTaskStatus(WmsTaskStatus.NEW.getCode());
+                    vehicleOutTask.setTaskPriority(1);
+                    vehicleOutTask.setVehicleId(stock.getVehicleId());
+                    vehicleOutTask.setUserName("WMS_AUTO");
+                    vehicleOutTask.setOrigin(stock.getLocationId());
+                    vehicleOutTask.setDestination("");
+                    vehicleOutTask.setCreateTime(LocalDateTime.now());
+                    vehicleOutTask.setIsPicking(1);
+                    vehicleOutTask.setPickStand(standId);
+                    needAddTaskList.add(vehicleOutTask);
+                    // 创建拣选任务
+                    String key = stock.getVehicleId() + "_" + standId;
+                    // 此次新建的保存过
+                    if (needAddPickTaskMap.containsKey(key)) {
+                        continue;
+                    }
+                    // 暂存拣选任务
+                    PickTask tempPickTask = new PickTask();
+                    tempPickTask.setPickTaskId(key);
+                    tempPickTask.setVehicleId(stock.getVehicleId());
+                    tempPickTask.setStandId(standId);
+                    tempPickTask.setPickStatus(PickTaskStatusEnum.TEMP.getCode());
+                    tempPickTask.setLastUpdateTime(LocalDateTime.now());
+                    needAddPickTaskMap.put(key, tempPickTask);
+                    // 添加本次出库载具
+                    thisTimeOutVehicleIds.add(stock.getVehicleId());
+                    // 添加设备
+                    equipTaskOfThisStandMap.put(equipmentId, equipTaskOfThisStandMap.getOrDefault(equipmentId, 0) + 1);
+                    // 此处是为了将同一个载具尽量在同一个站台捡完
+                    thisStandOutVehicleMap.put(stock.getVehicleId(), stock.getStockId());
+                }
+            }
+            for (Stock stock : onStockStockList) {
+                if (Objects.equals(stock.getStockStatus(), StockStatus.OK.getCode())) {
+                    continue;
+                }
+                // 这个站台本次出库的载具
+                if (thisStandOutVehicleMap.containsKey(stock.getVehicleId()) && !Objects.equals(thisStandOutVehicleMap.get(stock.getVehicleId()), stock.getStockId())) {
+                    // 判断这个料当前站台需不需要---主要消耗一下数量
+                    BigDecimal originNum = stock.getGoodsRelated().getRemainNum();
+                    BigDecimal afterNum = stock.getGoodsRelated().getRemainNum();
+                    for (WorkFlow workFlow : unfinishedWorkFlowList) {
+                        if (afterNum.compareTo(BigDecimal.ZERO) <= 0) {
+                            break;
+                        }
+                        if (Objects.equals(workFlow.getWorkStation(), standId) && Objects.equals(workFlow.getGoodsId(), stock.getGoodsRelated().getGoodsId())) {
+                            BigDecimal needNum = workFlow.getNeedNum().subtract(workFlow.getDistributedNum() == null ? BigDecimal.ZERO : workFlow.getDistributedNum());
+                            if (needNum.compareTo(BigDecimal.ZERO) <= 0) {
+                                continue;
+                            }
+                            if (afterNum.compareTo(needNum) >= 0) {
+                                afterNum = afterNum.subtract(needNum);
+                                workFlow.setDistributedNum(workFlow.getNeedNum());
+                            } else {
+                                afterNum = BigDecimal.ZERO;
+                                workFlow.setDistributedNum(workFlow.getDistributedNum() == null ? afterNum : workFlow.getDistributedNum().add(afterNum));
+                            }
+                            workFlow.setWorkStatus(1);
+                            // 添加需要更新的工作流id
+                            if (!needUpdateWorkFlowIds.contains(workFlow.getWorkFlowId())) {
+                                needUpdateWorkFlowIds.add(workFlow.getWorkFlowId());
+                            }
+                            // 添加需要更新的工单id
+                            if (!needUpdateOrderIds.contains(workFlow.getOrderId())) {
+                                needUpdateOrderIds.add(workFlow.getOrderId());
+                            }
+                        }
+                    }
+                    if (afterNum.compareTo(originNum) != 0) {
+                        // 使用过该库存，更新数量
+                        stock.setStockStatus(StockStatus.OUT.getCode());
+                        StockDetailInfo goodsRelated = stock.getGoodsRelated();
+                        goodsRelated.setRemainNum(afterNum);
+                        stock.setGoodsRelated(goodsRelated);
+                    }
+                }
+            }
+        }
+        // 再循环一次库存，只判断出库的
+        for (Stock stock : onStockStockList) {
+            if (!Objects.equals(stock.getStockStatus(), StockStatus.OUT.getCode())) {
+                continue;
+            }
+            if (!thisTimeOutVehicleIds.contains(stock.getVehicleId())) {
+                continue;
+            }
+            // 判断这个料当前站台需不需要---主要消耗一下数量
+            BigDecimal originNum = stock.getGoodsRelated().getRemainNum();
+            BigDecimal afterNum = stock.getGoodsRelated().getRemainNum();
+            for (WorkFlow workFlow : unfinishedWorkFlowList) {
+                if (afterNum.compareTo(BigDecimal.ZERO) <= 0) {
+                    break;
+                }
+                if (Objects.equals(workFlow.getGoodsId(), stock.getGoodsRelated().getGoodsId())) {
+                    BigDecimal needNum = workFlow.getNeedNum().subtract(workFlow.getDistributedNum() == null ? BigDecimal.ZERO : workFlow.getDistributedNum());
+                    if (needNum.compareTo(BigDecimal.ZERO) <= 0) {
+                        continue;
+                    }
+                    if (afterNum.compareTo(needNum) >= 0) {
+                        afterNum = afterNum.subtract(needNum);
+                        workFlow.setDistributedNum(workFlow.getNeedNum());
+                    } else {
+                        afterNum = BigDecimal.ZERO;
+                        workFlow.setDistributedNum(workFlow.getDistributedNum() == null ? afterNum : workFlow.getDistributedNum().add(afterNum));
+                    }
+                    workFlow.setWorkStatus(1);
+                    // 添加需要更新的工作流id
+                    if (!needUpdateWorkFlowIds.contains(workFlow.getWorkFlowId())) {
+                        needUpdateWorkFlowIds.add(workFlow.getWorkFlowId());
+                    }
+                    // 添加需要更新的工单id
+                    if (!needUpdateOrderIds.contains(workFlow.getOrderId())) {
+                        needUpdateOrderIds.add(workFlow.getOrderId());
+                    }
+                    // 创建拣选任务
+                    String key = stock.getVehicleId() + "_" + workFlow.getWorkStation();
+                    // 此次新建的保存过
+                    if (needAddPickTaskMap.containsKey(key)) {
+                        continue;
+                    }
+                    // 暂存拣选任务
+                    PickTask tempPickTask = new PickTask();
+                    tempPickTask.setPickTaskId(key);
+                    tempPickTask.setVehicleId(stock.getVehicleId());
+                    tempPickTask.setStandId(workFlow.getWorkStation());
+                    tempPickTask.setPickStatus(PickTaskStatusEnum.TEMP.getCode());
+                    tempPickTask.setLastUpdateTime(LocalDateTime.now());
+                    needAddPickTaskMap.put(key, tempPickTask);
+                }
+            }
+            if (afterNum.compareTo(originNum) != 0) {
+                // 使用过该库存，更新数量
+                stock.setStockStatus(StockStatus.OUT.getCode());
+                StockDetailInfo goodsRelated = stock.getGoodsRelated();
+                goodsRelated.setRemainNum(afterNum);
+                stock.setGoodsRelated(goodsRelated);
+            }
+        }
+        // 处理需要更新的数据
+        List<WorkFlow> finalUpdateWorkFlowList = unfinishedWorkFlowList.stream().filter(workFlow -> needUpdateWorkFlowIds.contains(workFlow.getWorkFlowId())).toList();
+        boolean doTransResult = dbTransUtils.useTran(() -> {
+            if (!thisTimeOutVehicleIds.isEmpty()) {
+                vehicleService.update(new LambdaUpdateWrapper<Vehicle>()
+                        .set(Vehicle::getVehicleStatus, VehicleStatus.OUT.getCode())
+                        .in(Vehicle::getVehicleId, thisTimeOutVehicleIds));
+                stockService.update(new LambdaUpdateWrapper<Stock>()
+                        .set(Stock::getStockStatus, StockStatus.OUT.getCode())
+                        .in(Stock::getVehicleId, thisTimeOutVehicleIds));
+                if (!needAddTaskList.isEmpty()) {
+                    taskService.saveBatch(needAddTaskList);
+                }
+                if (!needAddPickTaskMap.isEmpty()) {
+                    pickTaskService.saveBatch(needAddPickTaskMap.values());
+                }
+                if (!finalUpdateWorkFlowList.isEmpty()) {
+                    workFlowService.updateBatchById(finalUpdateWorkFlowList);
+                }
+                if (!needUpdateOrderIds.isEmpty()) {
+                    kateOrdersService.update(new LambdaUpdateWrapper<KateOrders>()
+                            .set(KateOrders::getOrderStatus, 2)
+                            .set(KateOrders::getLastUpdateTime, LocalDateTime.now())
+                            .set(KateOrders::getLastUpdateReason, "执行工作")
+                            .in(KateOrders::getOrderId, needUpdateOrderIds));
+                }
+            }
+        });
+        if (!doTransResult) {
+            logger.error("解析工作生成任务时，数据库事务执行错误。");
+        }
+    }
+
+    /**
+     * 修复工作
+     */
+    @Override
+    public void repairWork() {
+        // 查找到未完成的工作
+        List<WorkFlow> unfinishedWorkFlowList = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
+                .notIn(WorkFlow::getWorkStatus, -1, 2));
+        if (unfinishedWorkFlowList.isEmpty()) {
+            // 没有未完成的工作
+            logger.info("没有未完成的待修复的工作。");
+            return;
+        }
+        // 查找所有的库存
+        List<Stock> stockList = stockService.list(new LambdaQueryWrapper<Stock>()
+                .ne(Stock::getStockStatus, StockStatus.LOCK.getCode()));
+        // 根据在库物料号map一下
+        Map<String, List<String>> onStockGoodsIdToVehicleIdsMap = new HashMap<>();
+        // 根据不在库的物料号map一下
+        Map<String, List<String>> notOnStockGoodsIdToVehicleIdsMap = new HashMap<>();
+        for (Stock stock : stockList) {
+            String goodsId = stock.getGoodsRelated().getGoodsId();
+            if (Objects.equals(stock.getStockStatus(), StockStatus.OK.getCode())) {
+                if (onStockGoodsIdToVehicleIdsMap.containsKey(goodsId)) {
+                    List<String> oldVehicleList = onStockGoodsIdToVehicleIdsMap.get(goodsId);
+                    oldVehicleList.add(stock.getVehicleId());
+                    onStockGoodsIdToVehicleIdsMap.put(goodsId, oldVehicleList);
+                } else {
+                    onStockGoodsIdToVehicleIdsMap.put(goodsId, new ArrayList<>(List.of(stock.getVehicleId())));
+                }
+            } else {
+                if (notOnStockGoodsIdToVehicleIdsMap.containsKey(goodsId)) {
+                    List<String> oldVehicleList = notOnStockGoodsIdToVehicleIdsMap.get(goodsId);
+                    oldVehicleList.add(stock.getVehicleId());
+                    notOnStockGoodsIdToVehicleIdsMap.put(goodsId, oldVehicleList);
+                } else {
+                    notOnStockGoodsIdToVehicleIdsMap.put(goodsId, new ArrayList<>(List.of(stock.getVehicleId())));
+                }
+            }
+        }
+        List<WorkFlow> needUpdateWorkFlowList = new ArrayList<>();
+        for (WorkFlow workFlow : unfinishedWorkFlowList) {
+            if (workFlow.getPickedNum().compareTo(workFlow.getNeedNum()) >= 0) {
+                // 实际已经完成但未标记为完成的工作流
+                workFlow.setDistributedNum(workFlow.getPickedNum());
+                workFlow.setWorkStatus(2);
+                needUpdateWorkFlowList.add(workFlow);
+                continue;
+            }
+            // 需求的数量未全部分配时，查询是否还有库存
+            if (!onStockGoodsIdToVehicleIdsMap.containsKey(workFlow.getGoodsId()) && !notOnStockGoodsIdToVehicleIdsMap.containsKey(workFlow.getGoodsId())) {
+                // 缺料
+                workFlow.setWorkStatus(2);
+                if (StringUtils.isEmpty(workFlow.getOpUser())) {
+                    workFlow.setOpUser("缺料系统自动完成。");
+                } else {
+                    workFlow.setOpUser(workFlow.getOpUser() + "；缺料系统自动完成。");
+                }
+                needUpdateWorkFlowList.add(workFlow);
+                continue;
+            }
+            // 有在库数量但是没有非在库数量时
+            if (onStockGoodsIdToVehicleIdsMap.containsKey(workFlow.getGoodsId()) && !notOnStockGoodsIdToVehicleIdsMap.containsKey(workFlow.getGoodsId())) {
+                // 更新已分配数量
+                workFlow.setDistributedNum(workFlow.getPickedNum());
+                needUpdateWorkFlowList.add(workFlow);
+            }
+        }
+        // 更新工作流
+        boolean doTransResult = dbTransUtils.useTran(() -> {
+            if (!needUpdateWorkFlowList.isEmpty()) {
+                workFlowService.updateBatchById(needUpdateWorkFlowList);
+            }
+        });
+        if (!doTransResult) {
+            logger.error("修复工作流时，执行数据库事务发生错误。");
+        }
+    }
+
+    /**
+     * 根据库位号获得设备号
+     *
+     * @param locationId 库位号
+     * @return 设备号/堆垛机号
+     */
+    private int getStackerIdByLocationId(String locationId) {
+        if (StringUtils.isEmpty(locationId)) {
+            return 0;
+        }
+        Location targetLocation = instantLocationMap.get(locationId);
+        if (targetLocation == null) {
+            return 0;
+        }
+        return targetLocation.getEquipmentId();
+    }
+
     /**
      * 新版完成工作
      *
@@ -299,22 +779,17 @@ public class WorkServiceImplements implements IWorkService {
                     .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));
-            // 保存，防止标签未打印
-            workFlowLastService.remove(new LambdaQueryWrapper<WorkFlowLast>().eq(WorkFlowLast::getWorkStation, workStation));
-            workFlowLastService.saveBatch(BeanUtil.copyToList(workFlowList, WorkFlowLast.class));
+            if (workFlowList.isEmpty()) {
+                return "没有已完成的工作流可以确认";
+            }
             // workSummary列表
             List<WorkSummary> workSummaryList = new ArrayList<>();
+            List<KateOrders> needUpdateKateOrdersList = new ArrayList<>();
             for (WorkFlow workFlow : workFlowList) {
                 WorkSummary summary = new WorkSummary();
                 summary.setWorkFlowId(workFlow.getWorkFlowId());
@@ -339,34 +814,82 @@ public class WorkServiceImplements implements IWorkService {
                 summary.setELocationId(!currentBoxELocationList.isEmpty() ? currentBoxELocationList.get(0).getELocationId() : "");
                 workSummaryList.add(summary);
                 // 更新工单表
-                kateOrdersService.update(new LambdaUpdateWrapper<KateOrders>()
-                        .set(KateOrders::getOrderStatus, 4)
-                        .set(KateOrders::getFinishTime, LocalDateTime.now())
-                        .set(KateOrders::getPickedQuantity, workFlow.getPickedNum())
-                        .set(KateOrders::getLackQuantity, workFlow.getNeedNum().subtract(workFlow.getPickedNum()))
-                        .eq(KateOrders::getOrderId, workFlow.getOrderId())
-                        .eq(KateOrders::getSupplyArea, workFlow.getWorkCenter())
-                        .eq(KateOrders::getGoodsId, workFlow.getGoodsId()));
-                // 如果当前工单已经没有未完成的工作，更新DBS状态完成
-                if (!kateOrdersService.exists(new LambdaQueryWrapper<KateOrders>()
-                        .eq(KateOrders::getOrderId, workFlow.getOrderId())
-                        .ne(KateOrders::getOrderStatus, 4))) {
-                    kateDBSService.update(new LambdaUpdateWrapper<KateDBS>()
-                            .set(KateDBS::getDbsStatus, 2)
-                            .set(KateDBS::getLastUpdateTime, LocalDateTime.now())
-                            .eq(KateDBS::getWorkOrder, workFlow.getOrderId()));
+                KateOrders tempKateOrder = new KateOrders();
+                tempKateOrder.setOrderId(workFlow.getOrderId());
+                tempKateOrder.setLastUpdateTime(LocalDateTime.now());
+                tempKateOrder.setLastUpdateReason("完成工作");
+                tempKateOrder.setFinishTime(LocalDateTime.now());
+                tempKateOrder.setPickedQuantity(workFlow.getPickedNum());
+                tempKateOrder.setLackQuantity(workFlow.getNeedNum().subtract(workFlow.getPickedNum()));
+                tempKateOrder.setOrderStatus(4);
+                needUpdateKateOrdersList.add(tempKateOrder);
+            }
+            // 工单相关
+            List<String> orderIdList = needUpdateKateOrdersList.stream().map(KateOrders::getOrderId).distinct().toList();
+            List<String> workOrderList = needUpdateKateOrdersList.stream().map(KateOrders::getWorkOrder).distinct().toList();
+            // 查询出这些workOrder的工单
+            List<KateOrders> kateOrdersList = kateOrdersService.list(new LambdaQueryWrapper<KateOrders>()
+                    .in(KateOrders::getWorkOrder, workOrderList));
+            Map<String, Integer> finishWorkOrderMap = new HashMap<>();
+            if (!kateOrdersList.isEmpty()) {
+                for (KateOrders kateOrders : kateOrdersList) {
+                    if (orderIdList.contains(kateOrders.getOrderId())) {
+                        // 本次完成的工单
+                        kateOrders.setOrderStatus(4);
+                    }
+                    // 判断是否完成
+                    if (kateOrders.getOrderStatus() != 4) {
+                        finishWorkOrderMap.put(kateOrders.getWorkOrder(), finishWorkOrderMap.getOrDefault(kateOrders.getWorkOrder(), 0) - 1);
+                    } else {
+                        if (!finishWorkOrderMap.containsKey(kateOrders.getWorkOrder())) {
+                            finishWorkOrderMap.put(kateOrders.getWorkOrder(), 0);
+                        }
+                    }
+                }
+            }
+            // 筛选出已经全部完成的工单
+            List<String> needFinishWorkOrderList = new ArrayList<>();
+            for (String workOrder : finishWorkOrderMap.keySet()) {
+                if (finishWorkOrderMap.get(workOrder) >= 0) {
+                    needFinishWorkOrderList.add(workOrder);
                 }
             }
-            //解决workSummary的主键冲突问题 去掉workSummaryListlist中对象WorkFlowId重复的对象
-            workSummaryList = workSummaryList.stream().collect(Collectors.toMap(WorkSummary::getWorkFlowId, a -> a, (k1, k2) -> k1)).values().stream().collect(Collectors.toList());
 
+            boolean doTransResult = dbTransUtils.useTran(() -> {
+                // 保存，防止标签未打印
+                workFlowLastService.remove(new LambdaQueryWrapper<WorkFlowLast>().eq(WorkFlowLast::getWorkStation, workStation));
+                workFlowLastService.saveOrUpdateBatch(BeanUtil.copyToList(workFlowList, WorkFlowLast.class));
+                // 保存总结
                 workSummaryService.saveOrUpdateBatch(workSummaryList);
+                // 先清空之前的
+                eLocationConfigLastService.remove(new LambdaQueryWrapper<ELocationConfigLast>()
+                        .eq(ELocationConfigLast::getWorkStation, workStation));
+                eLocationConfigLastService.saveOrUpdateBatch(eLocationConfigLastList);
+                // 删除所有的标签配置
+                eLocationConfigService.remove(new LambdaQueryWrapper<ELocationConfig>()
+                        .eq(ELocationConfig::getWorkStation, workStation));
                 // 移除工作流
                 workFlowService.remove(new LambdaQueryWrapper<WorkFlow>()
                         .eq(WorkFlow::getWorkStation, workStation));
                 // 移库站台要料
                 goodsToStationService.remove(new LambdaQueryWrapper<GoodsToStation>()
                         .eq(GoodsToStation::getWorkStation, workStation));
+                // 完成工单
+                if (!needUpdateKateOrdersList.isEmpty()) {
+                    kateOrdersService.updateBatchById(needUpdateKateOrdersList);
+                }
+                // 完成dbs
+                if (!needFinishWorkOrderList.isEmpty()) {
+                    kateDBSService.update(new LambdaUpdateWrapper<KateDBS>()
+                            .set(KateDBS::getDbsStatus, 2)
+                            .set(KateDBS::getLastUpdateTime, LocalDateTime.now())
+                            .in(KateDBS::getWorkOrder, needFinishWorkOrderList));
+                }
+            });
+            if (!doTransResult) {
+                logger.error("完成工作执行数据库事务异常。");
+                return "完成站台：" + workStation + "工作执行数据库事务异常!";
+            }
         } catch (Exception e) {
             logger.error("完成站台：{},工作发生异常：{}", workStation, e.getMessage());
             result = "完成站台：" + workStation + "工作发生异常!";
@@ -381,11 +904,13 @@ public class WorkServiceImplements implements IWorkService {
      * @param workFlows   工作流/工作任务
      * @param model       机型
      */
-    private void findWorks(String workStation, List<WorkFlow> workFlows, String model, LocalDate currentWorkDate) {
+    @Override
+    public void findWorks(String workStation, List<WorkFlow> workFlows, String model, LocalDate currentWorkDate) {
         String modelStr = Objects.equals(model, "MWL") ? "装载机" : "平地机";
         //开始时间：
         LocalDateTime startTime = LocalDateTime.now();
         System.out.println("分析当日" + modelStr + "工作流，开始时间：" + startTime);
+
         // 查到当前站台所有的小工位
         LambdaQueryWrapper<WorkStationConfig> stationConfigQueryWrapper = new LambdaQueryWrapper<WorkStationConfig>()
                 .eq(StringUtils.isNotEmpty(workStation), WorkStationConfig::getWorkStation, workStation);
@@ -398,6 +923,7 @@ public class WorkServiceImplements implements IWorkService {
         List<WorkStationConfig> currentStationConfigsOfNwl = workStationConfigService.list(stationConfigQueryWrapper);
         // 没有工站配置
         if (currentStationConfigsOfNwl == null || currentStationConfigsOfNwl.isEmpty()) {
+            logger.info("缺少{}工站配置，未生成工作流。", model);
             return;
         }
         // 今日开工的工单和小工位
@@ -432,13 +958,8 @@ public class WorkServiceImplements implements IWorkService {
                     if (kateDBS == null || StringUtils.isEmpty(kateDBS.getWorkOrder())) {// 不存在对应的工单计划
                         continue;
                     }
-                    if (!isAddReqmtsDate) {
-                        localDateTime = kateDBS.getPlanStartDate();
-                    } else {
-                        localDateTime = kateWorkOrder.getPlanStartDate().atStartOfDay();
-                    }
                     // 判断是否是当天开工
-                    int indexOfDbs = localWorkDateList.indexOf(localDateTime.toLocalDate());
+                    int indexOfDbs = localWorkDateList.indexOf(kateDBS.getPlanStartDate().toLocalDate());
                     if (indexOfDbs == -1) {
                         // 工作日不包含此开工日期
                         continue;
@@ -496,13 +1017,233 @@ public class WorkServiceImplements implements IWorkService {
                 }
             }
         }
+
         //结束时间
         LocalDateTime endTime = LocalDateTime.now();
         System.out.println("分析当日" + modelStr + "工作流，结束时间：" + endTime);
         // 用时
         long duration = Duration.between(startTime, endTime).toMillis();
         logger.info("分析当日{}工作流耗时：{}ms", modelStr, duration);
+    }
 
+    /**
+     * 获取当日工作流---使用需求日期，使用默认开工日期调整
+     * @param workFlows 工作流
+     * @param currentWorkDate 日期
+     */
+    @Override
+    public void findCurrentDateWorks(List<WorkFlow> workFlows, LocalDate currentWorkDate) {
+        //开始时间：
+        LocalDateTime startTime = LocalDateTime.now();
+        System.out.println("分析当日工作流，开始时间：" + startTime);
+        // 获取开工日期调整配置
+        int dateAdjust = -1;
+        try {
+            String dateAdjustStr = configMap.get(ConfigMapKeyEnum.START_DATE_ADJUST.getConfigKey());
+            if (StringUtils.isNotEmpty(dateAdjustStr)) {
+                dateAdjust = Integer.parseInt(dateAdjustStr);
+            }
+        } catch (Exception e) {
+            logger.error("获取开工日期调整配置失败：{}，使用默认值-1。", e.getMessage());
+        }
+        // 获取到需要查询的需求日期
+        int currentDateIndex = localWorkDateList.indexOf(currentWorkDate);
+        if (currentDateIndex == -1) {
+            logger.error("当前日期不在配置的工作日历中。");
+            return;
+        }
+        // 获取到需要查询的工单
+        int requireDateIndex = currentDateIndex - dateAdjust;
+        if (requireDateIndex < 0 || requireDateIndex >= localWorkDateList.size()) {
+            logger.error("当前日期对应的需求日期不在配置的工作日历中。");
+            return;
+        }
+        List<KateOrders> currentDateKateWorkOrders = kateOrdersService.list(new LambdaQueryWrapper<KateOrders>()
+                .eq(KateOrders::getOrderStatus, 0)
+                .eq(KateOrders::getSortString, configMap.get(ConfigMapKeyEnum.SLOC_FILTER_STRING.getConfigKey()))
+                .eq(KateOrders::getPlanStartDate, localWorkDateList.get(requireDateIndex)));
+        if (currentDateKateWorkOrders.isEmpty()) {
+            logger.info("没有当日待生成工作流的工单。");
+            return;
+        }
+        for (KateOrders tempOrder : currentDateKateWorkOrders) {
+            // 生成workFlow
+            WorkFlow tempWorkFlow = new WorkFlow();
+            tempWorkFlow.setWorkFlowId(generateId("WORKFLOW_"));
+            tempWorkFlow.setOrderId(tempOrder.getOrderId());
+            tempWorkFlow.setWorkStation("");
+            tempWorkFlow.setWorkOrder(tempOrder.getWorkOrder());
+            tempWorkFlow.setWorkCenter(tempOrder.getSupplyArea());
+            tempWorkFlow.setGoodsId(tempOrder.getGoodsId());
+            tempWorkFlow.setNeedNum(tempOrder.getRequirementQuantity());
+            tempWorkFlow.setCreateTime(LocalDateTime.now());
+            tempWorkFlow.setWorkStatus(0);
+            tempWorkFlow.setLightStatus(0);
+            tempWorkFlow.setPickedNum(BigDecimal.ZERO);
+            tempWorkFlow.setPlanDate(currentWorkDate);
+            workFlows.add(tempWorkFlow);
+        }
+        // 获得所有的小盒子号
+        List<String> smallBoxList = workFlows.stream().map(WorkFlow::getWorkCenter).distinct().toList();
+        // 查询工站配置
+        List<WorkStationConfig> currentStationConfigsOfNwl = workStationConfigService.list(new LambdaQueryWrapper<WorkStationConfig>()
+                .in(WorkStationConfig::getSmallBox, smallBoxList)
+                .orderByAsc(WorkStationConfig::getSmallBox));
+        // 没有工站配置
+        if (currentStationConfigsOfNwl == null || currentStationConfigsOfNwl.isEmpty()) {
+            logger.error("缺少工站配置，未生成工作流。");
+            return;
+        }
+        // 生成小盒子对应大盒子map
+        Map<String, String> smallBoxToBigBoxMap = currentStationConfigsOfNwl.stream().collect(Collectors.toMap(WorkStationConfig::getSmallBox, WorkStationConfig::getBigBox));
+        // 生成小盒子对应机型Map
+        Map<String, String> smallBoxToMachineTypeMap = currentStationConfigsOfNwl.stream().collect(Collectors.toMap(WorkStationConfig::getSmallBox, WorkStationConfig::getModel));
+        // 更新机型和大盒子号
+        for (WorkFlow tempWorkFlow : workFlows) {
+            // 机型
+            String model = smallBoxToMachineTypeMap.get(tempWorkFlow.getWorkCenter());
+            // 大盒子号
+            String bigBox = smallBoxToBigBoxMap.get(tempWorkFlow.getWorkCenter());
+            // 改动
+            if (StringUtils.isEmpty(model)) {
+                // 未知机型
+                tempWorkFlow.setMachineType(0);
+            } else {
+                tempWorkFlow.setMachineType(Objects.equals(model, "MWL") ? 1 : 2);
+            }
+            tempWorkFlow.setBigBox(bigBox);
+        }
+
+        //结束时间
+        LocalDateTime endTime = LocalDateTime.now();
+        System.out.println("分析当日工作流，结束时间：" + endTime);
+        // 用时
+        long duration = Duration.between(startTime, endTime).toMillis();
+        logger.info("获取当日工作流耗时：{}ms", duration);
+    }
+
+    /**
+     * 获取当日工作流---使用需求日期，使用工站配置日期调整
+     * @param workFlows 工作流
+     * @param currentWorkDate 日期
+     */
+    @Override
+    public void findCurrentDateWorksUseConfig(List<WorkFlow> workFlows, LocalDate currentWorkDate) {
+        //开始时间：
+        LocalDateTime startTime = LocalDateTime.now();
+        System.out.println("分析当日工作流，开始时间：" + startTime);
+        // 获取开工日期调整配置
+        int defaultDateAdjust = 0;
+        try {
+            String dateAdjustStr = configMap.get(ConfigMapKeyEnum.START_DATE_ADJUST.getConfigKey());
+            if (StringUtils.isNotEmpty(dateAdjustStr)) {
+                defaultDateAdjust = Integer.parseInt(dateAdjustStr);
+            }
+        } catch (Exception e) {
+            logger.error("获取默认开工日期调整配置失败：{}，使用默认值0。", e.getMessage());
+        }
+        // 获取到需要查询的开工日期
+        int currentDateIndex = localWorkDateList.indexOf(currentWorkDate);
+        if (currentDateIndex == -1) {
+            logger.error("当前开工日期不在配置的工作日历中。");
+            return;
+        }
+        // 查询所有未开工的工单
+        List<KateOrders> allBeforeWorkingKateWorkOrders = kateOrdersService.list(new LambdaQueryWrapper<KateOrders>()
+                .eq(KateOrders::getOrderStatus, 0)
+                .eq(KateOrders::getSortString, configMap.get(ConfigMapKeyEnum.SLOC_FILTER_STRING.getConfigKey())));
+        if (allBeforeWorkingKateWorkOrders.isEmpty()) {
+            logger.info("没有未开工的工单。");
+            return;
+        }
+        List<KateOrders> currentDateKateWorkOrders = new ArrayList<>();
+        for (KateOrders tempOrder : allBeforeWorkingKateWorkOrders) {
+            // 开工日期调整
+            Integer dateAdjust = smallBoxDateAdjustMap.get(tempOrder.getSupplyArea());
+            if (dateAdjust == null) {
+                dateAdjust = defaultDateAdjust;
+            }
+            // 获取到需求日期
+            LocalDate requireDate = tempOrder.getPlanStartDate();
+            if (requireDate == null) {
+//                logger.error("工单号：{}，小盒子号：{}，零件号：{}，工单数据缺少需求日期。", tempOrder.getWorkOrder(), tempOrder.getSupplyArea(), tempOrder.getGoodsId());
+                continue;
+            }
+            int requireDateIndex = localWorkDateList.indexOf(requireDate);
+            if (requireDateIndex == -1) {
+                logger.error("工单号：{}，小盒子号：{}，零件号：{}，需求日期：{}不在配置的工作日历中。", tempOrder.getWorkOrder(), tempOrder.getSupplyArea(), tempOrder.getGoodsId(), requireDate);
+                continue;
+            }
+            // 获取到需要查询的工单
+            int workDateIndex = requireDateIndex + dateAdjust;
+            if (workDateIndex < 0 || workDateIndex >= localWorkDateList.size()) {
+                logger.error("需求日期计算出的开工日期不在配置的工作日历中。");
+                continue;
+            }
+            if (workDateIndex != currentDateIndex) {
+                // 开工日期不是当前日期
+                continue;
+            }
+            currentDateKateWorkOrders.add(tempOrder);
+        }
+        if (currentDateKateWorkOrders.isEmpty()) {
+            logger.info("当前工作日没有待生成的工作流。");
+            return;
+        }
+        for (KateOrders tempOrder : currentDateKateWorkOrders) {
+            // 生成workFlow
+            WorkFlow tempWorkFlow = new WorkFlow();
+            tempWorkFlow.setWorkFlowId(generateId("WORKFLOW_"));
+            tempWorkFlow.setOrderId(tempOrder.getOrderId());
+            tempWorkFlow.setWorkStation("");
+            tempWorkFlow.setWorkOrder(tempOrder.getWorkOrder());
+            tempWorkFlow.setWorkCenter(tempOrder.getSupplyArea());
+            tempWorkFlow.setGoodsId(tempOrder.getGoodsId());
+            tempWorkFlow.setNeedNum(tempOrder.getRequirementQuantity());
+            tempWorkFlow.setCreateTime(LocalDateTime.now());
+            tempWorkFlow.setWorkStatus(0);
+            tempWorkFlow.setLightStatus(0);
+            tempWorkFlow.setPickedNum(BigDecimal.ZERO);
+            tempWorkFlow.setPlanDate(currentWorkDate);
+            workFlows.add(tempWorkFlow);
+        }
+        // 获得所有的小盒子号
+        List<String> smallBoxList = workFlows.stream().map(WorkFlow::getWorkCenter).distinct().toList();
+        // 查询工站配置
+        List<WorkStationConfig> currentStationConfigsOfNwl = workStationConfigService.list(new LambdaQueryWrapper<WorkStationConfig>()
+                .in(WorkStationConfig::getSmallBox, smallBoxList)
+                .orderByAsc(WorkStationConfig::getSmallBox));
+        // 没有工站配置
+        if (currentStationConfigsOfNwl == null || currentStationConfigsOfNwl.isEmpty()) {
+            logger.error("缺少必须的工站配置，未生成工作流。");
+            return;
+        }
+        // 生成小盒子对应大盒子map
+        Map<String, String> smallBoxToBigBoxMap = currentStationConfigsOfNwl.stream().collect(Collectors.toMap(WorkStationConfig::getSmallBox, WorkStationConfig::getBigBox));
+        // 生成小盒子对应机型Map
+        Map<String, String> smallBoxToMachineTypeMap = currentStationConfigsOfNwl.stream().collect(Collectors.toMap(WorkStationConfig::getSmallBox, WorkStationConfig::getModel));
+        // 更新机型和大盒子号
+        for (WorkFlow tempWorkFlow : workFlows) {
+            // 机型
+            String model = smallBoxToMachineTypeMap.get(tempWorkFlow.getWorkCenter());
+            // 大盒子号
+            String bigBox = smallBoxToBigBoxMap.get(tempWorkFlow.getWorkCenter());
+            // 改动
+            if (StringUtils.isEmpty(model)) {
+                // 未知机型
+                tempWorkFlow.setMachineType(0);
+            } else {
+                tempWorkFlow.setMachineType(Objects.equals(model, "MWL") ? 1 : 2);
+            }
+            tempWorkFlow.setBigBox(bigBox);
+        }
+
+        //结束时间
+        LocalDateTime endTime = LocalDateTime.now();
+        System.out.println("分析当日工作流，结束时间：" + endTime);
+        // 用时
+        long duration = Duration.between(startTime, endTime).toMillis();
+        logger.info("生成当日工作流耗时：{}ms", duration);
     }
 
     /**
@@ -557,6 +1298,17 @@ public class WorkServiceImplements implements IWorkService {
         }
         // 添加进总汇总数据
         List<WorkFlow> allFlows = new ArrayList<>();
+        // 查询配置是否使用默认开工日期
+        String useReqmtDate = configMap.get(ConfigMapKeyEnum.USE_REQUIRE_DATE.getConfigKey());
+        if (!StringUtils.isEmpty(useReqmtDate) && useReqmtDate.equals("1")) {// 使用工单的开工日期
+            // 查询配置是否使用默认开工日期调整
+            String useDefaultAdjust = configMap.get(ConfigMapKeyEnum.USE_DEFAULT_ADJUST.getConfigKey());
+            if (!StringUtils.isEmpty(useDefaultAdjust) && useDefaultAdjust.equals("1")) {
+                findCurrentDateWorks(allFlows, currentWorkDate);
+            } else {
+                findCurrentDateWorksUseConfig(allFlows, currentWorkDate);
+            }
+        } else {
             // 获取当天所有的装载机工作
             List<WorkFlow> thisDayMWLWorks = new ArrayList<>();
             // 获取到当天所有的平地机工作
@@ -586,6 +1338,8 @@ public class WorkServiceImplements implements IWorkService {
                     }
                 }
             }
+        }
+
         if (!allFlows.isEmpty()) {
             // 处理这些工作流
             List<WorkFlow> oldWorkFlows = workFlowService.list();
@@ -601,16 +1355,19 @@ public class WorkServiceImplements implements IWorkService {
                     continue;
                 }
                 workFlow.setWorkStatus(-1);// 设置暂存状态
+                workFlow.setDistributedNum(BigDecimal.ZERO);
                 finalWorkFlows.add(workFlow);
             }
             if (!finalWorkFlows.isEmpty()) {
                 // 存储数据
                 workFlowService.saveBatch(finalWorkFlows);
                 // 更新工单状态
-                List<String> orderIds = finalWorkFlows.stream().map(WorkFlow::getOrderId).toList();
+                List<String> orderIds = finalWorkFlows.stream().map(WorkFlow::getOrderId).distinct().toList();
                 if (!orderIds.isEmpty()) {
                     kateOrdersService.update(new LambdaUpdateWrapper<KateOrders>()
                             .set(KateOrders::getOrderStatus, 1)
+                            .set(KateOrders::getLastUpdateTime, LocalDateTime.now())
+                            .set(KateOrders::getLastUpdateReason, "创建工作流")
                             .in(KateOrders::getOrderId, orderIds)
                             .eq(KateOrders::getOrderStatus, 0));
                 }

src/main/java/com/wms/service/quartz_job/serviceImpl/JobServiceImpl.java

@@ -93,10 +93,9 @@ public class JobServiceImpl implements IJobService {
         // 这里写死，五个定时器
         jobBeans.add(new JobBean("CommonTaskSender", CommonTaskSender.class, "0/2 * * * * ?", 2000, JobTimerTypeEnums.SIMPLE.getType(), 1));
         jobBeans.add(new JobBean("PickTaskSender", PickTaskSender.class, "0/2 * * * * ?", 2000, JobTimerTypeEnums.SIMPLE.getType(), 1));
-        jobBeans.add(new JobBean("PickOutTaskSender", PickOutTaskSender.class, "0/2 * * * * ?", 2000, JobTimerTypeEnums.SIMPLE.getType(), 1));
-//        jobBeans.add(new JobBean("KateWorkExecutor", KateWorkExecutor.class, "0/20 * * * * ?", 20000, JobTimerTypeEnums.SIMPLE.getType(), 1));
+//        jobBeans.add(new JobBean("PickOutTaskSender", PickOutTaskSender.class, "0/2 * * * * ?", 2000, JobTimerTypeEnums.SIMPLE.getType(), 0));
         jobBeans.add(new JobBean("KateWorkExecutor", KateWorkExecutor.class, "0 0 * * * ?", 20000, JobTimerTypeEnums.SIMPLE.getType(), 1));
-        jobBeans.add(new JobBean("DataClearExecutor", DataClearExecutor.class, "0 0 3 * * ?", 2000, JobTimerTypeEnums.CRON.getType(), 1));
+        jobBeans.add(new JobBean("DataClearExecutor", DataClearExecutor.class, "0 0 23 * * ?", 2000, JobTimerTypeEnums.CRON.getType(), 1));
         for (JobBean jobBean : jobBeans) {
             createJob(jobBean);
         }

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

@@ -1,17 +1,54 @@
 package com.wms.service.serviceImplements;
 
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.wms.entity.table.WorkDate;
 import com.wms.mapper.WorkDateMapper;
 import com.wms.service.WorkDateService;
+import com.wms.utils.DbTransUtils;
 import lombok.RequiredArgsConstructor;
-import org.springframework.beans.factory.annotation.Autowired;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 
+import java.util.Comparator;
+import java.util.List;
+
+import static com.wms.config.InitLocalConfig.localWorkDateList;
+
 /**
  * 工作日历
  */
 @Service
-@RequiredArgsConstructor(onConstructor = @__(@Autowired))
+@RequiredArgsConstructor
+@Slf4j
 public class WorkDateServiceImpl extends ServiceImpl<WorkDateMapper, WorkDate> implements WorkDateService {
+    private final DbTransUtils dbTransUtils;
+    /**
+     * 更新工作日历---实现
+     * @param workDateList 工作日列表
+     */
+    @Override
+    public boolean updateWorkDate(List<WorkDate> workDateList) {
+        // 对工作日列表进行排序
+        List<WorkDate> sortedWorkDateList = workDateList.stream().sorted(Comparator.comparing(WorkDate::getWorkDate)).toList();
+        // 设定id
+        int idIndex = 1;
+        for (WorkDate workDate : sortedWorkDateList) {
+            workDate.setKeyId(idIndex);
+            idIndex++;
+        }
+        boolean doTransResult = dbTransUtils.useTran(() -> {
+            // 删除所有工作日
+            super.remove(new LambdaQueryWrapper<>());
+            // 批量插入工作日
+            super.saveBatch(sortedWorkDateList);
+        });
+        if (!doTransResult) {
+            log.error("更新工作日的事务执行失败。");
+        }
+        // 更新本地缓存的工作日历
+        localWorkDateList = sortedWorkDateList.stream().map(WorkDate::getWorkDate).distinct().toList();
+        log.info("更新本地缓存的工作日历成功。");
+        return doTransResult;
+    }
 }

src/main/java/com/wms/utils/DbTransUtils.java

@@ -0,0 +1,33 @@
+package com.wms.utils;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.TransactionDefinition;
+import org.springframework.transaction.TransactionStatus;
+import org.springframework.transaction.support.DefaultTransactionDefinition;
+
+@Component
+@RequiredArgsConstructor
+public class DbTransUtils {
+    private final PlatformTransactionManager transactionManager;
+
+    /**
+     * 执行一个事务方法
+     * @param baseTran 事务类
+     * @return 执行结果
+     */
+    public boolean useTran(Runnable baseTran) {
+        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
+        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
+        TransactionStatus status = transactionManager.getTransaction(def);
+        try {
+            baseTran.run();
+            transactionManager.commit(status);
+            return true;
+        } catch (Exception e) {
+            transactionManager.rollback(status);
+            return false;
+        }
+    }
+}

src/main/java/com/wms/utils/HttpUtils.java

@@ -101,9 +101,9 @@ public class HttpUtils {
             HttpGet httpGet = new HttpGet(url);
             // 设置超时时间
             RequestConfig requestConfig = RequestConfig.custom()
-                    .setConnectTimeout(5000)
-                    .setConnectionRequestTimeout(1000)
-                    .setSocketTimeout(5000).build();
+                    .setConnectTimeout(15000)
+                    .setConnectionRequestTimeout(15000)
+                    .setSocketTimeout(15000).build();
             httpGet.setConfig(requestConfig);
             for(Map.Entry<String, String> entry : header.entrySet()){
 
@@ -153,9 +153,9 @@ public class HttpUtils {
             httpClient = HttpClients.createDefault();
             HttpPost httppost = new HttpPost(url);
             RequestConfig requestConfig = RequestConfig.custom()
-                    .setConnectTimeout(5000)
-                    .setConnectionRequestTimeout(5000)
-                    .setSocketTimeout(5000).build();
+                    .setConnectTimeout(15000)
+                    .setConnectionRequestTimeout(15000)
+                    .setSocketTimeout(15000).build();
             httppost.setConfig(requestConfig);
             httppost.setHeader("Content-Type", "application/json;charset=UTF-8");
             if (StringUtils.isEmpty(token) && StringUtils.isNotEmpty(userName) && StringUtils.isNotEmpty(password)) {
@@ -197,9 +197,9 @@ public class HttpUtils {
             httpClient = HttpClients.createDefault();
             HttpPost httppost = new HttpPost(url);
             RequestConfig requestConfig = RequestConfig.custom()
-                    .setConnectTimeout(5000)
-                    .setConnectionRequestTimeout(1000)
-                    .setSocketTimeout(5000).build();
+                    .setConnectTimeout(15000)
+                    .setConnectionRequestTimeout(15000)
+                    .setSocketTimeout(15000).build();
             httppost.setConfig(requestConfig);
             httppost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=UTF-8");
             if (StringUtils.isEmpty(token) && StringUtils.isNotEmpty(userName) && StringUtils.isNotEmpty(password)) {

src/main/java/com/wms/utils/StringUtils.java

@@ -1,6 +1,8 @@
 package com.wms.utils;
 
 import com.alibaba.fastjson2.JSON;
+import org.springframework.boot.SpringApplication;
+import org.springframework.context.ApplicationContext;
 
 /**
  * WMS字符串工具类
@@ -27,6 +29,7 @@ public class StringUtils {
      */
     public static String toUnderScoreCase(String str)
     {
+        ApplicationContext applicationContext = SpringApplication.run(StringUtils.class);
         if (str == null)
         {
             return null;
@@ -140,4 +143,34 @@ public class StringUtils {
     public static String padRight(String value, int size, String padStr) {
         return org.apache.commons.lang3.StringUtils.rightPad(value, size, padStr);
     }
+
+    /**
+     * 时长；格式化，最高：xx天xx小时xx分xx秒
+     * @param origin 秒
+     * @return 格式化字符串
+     */
+    public static String durationFormat(Long origin) {
+        long dayDiv = 60 * 60 * 24;
+        long hourDiv = 60 * 60;
+        long minuteDiv = 60;
+        long days = origin / dayDiv;
+        long hours = (origin % dayDiv) / hourDiv;
+        long minutes = (origin % hourDiv) / minuteDiv;
+        long seconds = origin % minuteDiv;
+        String finalStr = "";
+        if (days > 0) {
+            finalStr += days + "天";
+        }
+        if (hours > 0) {
+            finalStr += hours + "小时";
+        }
+        if (minutes > 0) {
+            finalStr += minutes + "分钟";
+        }
+        if (seconds > 0) {
+            finalStr += seconds + "秒";
+        }
+
+        return finalStr;
+    }
 }

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

@@ -102,6 +102,12 @@ public class UploadBaseGoodsListener implements ReadListener<BaseGoodsExcelVo> {
             tempGoods.setNeedInventory(goodsExcelVo.getNeedInventory());
             tempGoods.setHaveSled(goodsExcelVo.getHaveSled());
             tempGoods.setSledDays(goodsExcelVo.getSledDays());
+            if (StringUtils.isEmpty(goodsExcelVo.getIndicator())) {
+                tempGoods.setIndicator(1);
+            } else {
+                tempGoods.setIndicator(3);
+            }
+
             tempGoods.setLastUpdateTime(LocalDateTime.now());
             tempGoods.setLastUpdateUser(uploadUser);
             goodsList.add(tempGoods);

src/main/java/com/wms/utils/excel/listener/UploadDbsListener.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.wms.constants.enums.ConfigMapKeyEnum;
 import com.wms.entity.table.KateDBS;
 import com.wms.service.KateDBSService;
 import com.wms.utils.StringUtils;
@@ -15,6 +16,8 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
+import static com.wms.config.InitLocalConfig.configMap;
+import static com.wms.config.InitLocalConfig.localWorkDateList;
 import static com.wms.utils.WmsUtils.generateId;
 
 /**
@@ -32,21 +35,25 @@ public class UploadDbsListener implements ReadListener<KateDbsExcelVo> {
     private final Map<String, KateDBS> oldKateDBSMap;// 旧的DBS数据
     private final Map<String, KateDBS> newKateDBSMap = new HashMap<>();// 新的DBS数据
     private final int maxSequence;
-    private final boolean isAddReqmtDate;
-    public UploadDbsListener(KateDBSService kateDBSService, Map<String, KateDBS> oldKateDBSMap, String uploadUser, boolean isAddReqmtDate) {
+    private boolean isAddReqmtDate = false;
+    public UploadDbsListener(KateDBSService kateDBSService, Map<String, KateDBS> oldKateDBSMap, String uploadUser) {
         this.kateDBSService = kateDBSService;
         this.oldKateDBSMap = oldKateDBSMap;
         this.uploadUser = uploadUser;
-        this.isAddReqmtDate = isAddReqmtDate;
         // 获取最大序列号
         maxSequence = oldKateDBSMap.values().stream().mapToInt(KateDBS::getWorkSequence).max().orElse(0);
+        // 查询配置是否使用默认开工日期
+        String useReqmtDate = configMap.get(ConfigMapKeyEnum.USE_REQUIRE_DATE.getConfigKey());
+        if (!StringUtils.isEmpty(useReqmtDate) && useReqmtDate.equals("1")) {
+            isAddReqmtDate = true;
+        }
     }
 
     @Override
     public void onException(Exception exception, AnalysisContext context) throws Exception {
         int rowCount = context.readRowHolder().getRowIndex() + 1;
         logger.error("处理Dbs数据发生异常，第{}行发生异常。", rowCount);
-        throw new Exception("第" + rowCount + "行数据异常。");
+        throw new Exception("第" + rowCount + "行数据异常，" + exception.getMessage());
     }
 
     /**
@@ -60,14 +67,25 @@ public class UploadDbsListener implements ReadListener<KateDbsExcelVo> {
         if (kateDbsExcelVo.getWorkSequence() != null
         && StringUtils.isNotEmpty(kateDbsExcelVo.getWorkOrder())
         && StringUtils.isNotEmpty(kateDbsExcelVo.getMachineNo())) {
-            if(!isAddReqmtDate){
+            int rowCount = analysisContext.readRowHolder().getRowIndex() + 1;
             if (kateDbsExcelVo.getPlanStartDate() != null) {
-                    cachedDataList.add(kateDbsExcelVo);
+                // 需要判断日期是否在配置的工作日历里面
+                int indexOfCurrentDate = localWorkDateList.indexOf(kateDbsExcelVo.getPlanStartDate().toLocalDate());
+                if (indexOfCurrentDate == -1) {
+                    // 工作日不包含此开工日期
+                    logger.error("第{}行DBS开工日期为非工作日。", rowCount);
+                    throw new RuntimeException("第" + rowCount + "行DBS开工日期" + kateDbsExcelVo.getPlanStartDate().toLocalDate() + "为非工作日。");
                 }
+                cachedDataList.add(kateDbsExcelVo);
+            } else {
+                if (!isAddReqmtDate) {
+                    // 缺少开工日期
+                    logger.error("第{}行DBS缺少开工日期。", rowCount);
+                    throw new RuntimeException("第" + rowCount + "行DBS缺少开工日期。");
                 } else {
                     cachedDataList.add(kateDbsExcelVo);
                 }
-
+            }
         }
         // 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM
         if (cachedDataList.size() >= BATCH_COUNT) {

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

@@ -12,9 +12,11 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.math.BigDecimal;
+import java.time.LocalDateTime;
 import java.util.*;
 
 import static com.wms.config.InitLocalConfig.configMap;
+import static com.wms.config.InitLocalConfig.localWorkDateList;
 import static com.wms.utils.WmsUtils.generateId;
 
 /**
@@ -35,20 +37,23 @@ public class UploadKateOrdersListener implements ReadListener<KateOrdersExcelVo>
     private final String uploadUser;// 用户
     private final Map<String, KateOrders> oldKateOrdersMap;// 旧的工单数据
     private final Map<String, KateOrders> newKateOrdersMap = new HashMap<>();// 新的工单数据
-    private final boolean isAddReqmtDate;
-
-    public UploadKateOrdersListener(KateOrdersService kateOrdersService, Map<String, KateOrders> oldKateOrdersMap, String uploadUser, boolean isAddReqmtDate) {
+    private boolean isAddReqmtDate = false;
+    public UploadKateOrdersListener(KateOrdersService kateOrdersService, Map<String, KateOrders> oldKateOrdersMap, String uploadUser) {
         this.kateOrdersService = kateOrdersService;
         this.oldKateOrdersMap = oldKateOrdersMap;
         this.uploadUser = uploadUser;
-        this.isAddReqmtDate = isAddReqmtDate;
+        // 查询配置是否使用默认开工日期
+        String useReqmtDate = configMap.get(ConfigMapKeyEnum.USE_REQUIRE_DATE.getConfigKey());
+        if (!StringUtils.isEmpty(useReqmtDate) && useReqmtDate.equals("1")) {
+            isAddReqmtDate = true;
+        }
     }
 
     @Override
     public void onException(Exception exception, AnalysisContext context) throws Exception {
         int rowCount = context.readRowHolder().getRowIndex() + 1;
         logger.error("处理工单数据发生异常，第{}行发生异常。", rowCount);
-        throw new Exception("第" + rowCount + "行数据异常。");
+        throw new Exception("第" + rowCount + "行数据异常，" + exception.getMessage());
     }
 
     /**
@@ -67,13 +72,24 @@ public class UploadKateOrdersListener implements ReadListener<KateOrdersExcelVo>
                     && StringUtils.isNotEmpty(kateOrdersExcelVo.getSupplyArea())
                     && kateOrdersExcelVo.getRequirementQuantity() != null
                     && kateOrdersExcelVo.getRequirementQuantity().compareTo(BigDecimal.ZERO) > 0) {
-                if(isAddReqmtDate){
+                int rowCount = analysisContext.readRowHolder().getRowIndex() + 1;
                 if (kateOrdersExcelVo.getPlanStartDate() != null) {
+                    // 需要判断日期是否在配置的工作日历里面
+                    int indexOfCurrentDate = localWorkDateList.indexOf(kateOrdersExcelVo.getPlanStartDate());
+                    if (indexOfCurrentDate == -1) {
+                        // 工作日不包含此开工日期
+                        logger.error("第{}行工单需求日期为非工作日。", rowCount);
+                        throw new RuntimeException("第" + rowCount + "行工单需求日期" + kateOrdersExcelVo.getPlanStartDate() + "为非工作日。");
+                    }
+                    cachedDataList.add(kateOrdersExcelVo);
+                } else {
+                    if (isAddReqmtDate) {
+                        // 缺少开工日期
+                        logger.error("第{}行工单缺少需求日期。", rowCount);
+                        throw new RuntimeException("第" + rowCount + "行工单缺少需求日期。");
+                    } else {
                         cachedDataList.add(kateOrdersExcelVo);
                     }
-                }else {
-                    // 符合条件
-                    cachedDataList.add(kateOrdersExcelVo);
                 }
             }
         }
@@ -103,7 +119,7 @@ public class UploadKateOrdersListener implements ReadListener<KateOrdersExcelVo>
      */
     private void saveData() {
         for (KateOrdersExcelVo kateOrdersExcelVo : cachedDataList) {
-            String key = kateOrdersExcelVo.getWorkOrder() + kateOrdersExcelVo.getGoodsId() + kateOrdersExcelVo.getSupplyArea();
+            String key = kateOrdersExcelVo.getWorkOrder() + "_" + kateOrdersExcelVo.getGoodsId() + "_" + kateOrdersExcelVo.getSupplyArea();
             if (newKateOrdersMap.containsKey(key)) {
                 KateOrders currentOrder = newKateOrdersMap.get(key);
                 // 设定数量
@@ -112,8 +128,28 @@ public class UploadKateOrdersListener implements ReadListener<KateOrdersExcelVo>
                 newKateOrdersMap.replace(key, currentOrder);
                 continue;
             }
-            // 查询数据库是否存在重复数据
-            if (!oldKateOrdersMap.containsKey(key)) {
+            if (oldKateOrdersMap.containsKey(key)) {
+                KateOrders oldOrder = oldKateOrdersMap.get(key);
+                if (oldOrder.getOrderStatus() == 0) {
+                    oldOrder.setItem(kateOrdersExcelVo.getItem());
+                    oldOrder.setDescription(kateOrdersExcelVo.getDescription());
+                    oldOrder.setSLoc(kateOrdersExcelVo.getSLoc());
+                    oldOrder.setType(kateOrdersExcelVo.getType());
+                    oldOrder.setOriginStatus(kateOrdersExcelVo.getOriginStatus());
+                    oldOrder.setSortString(kateOrdersExcelVo.getSortString());
+                    oldOrder.setRequirementQuantity(kateOrdersExcelVo.getRequirementQuantity());
+                    oldOrder.setGoodsUnit(kateOrdersExcelVo.getGoodsUnit());
+                    oldOrder.setLackQuantity(kateOrdersExcelVo.getRequirementQuantity());
+                    oldOrder.setPickedQuantity(BigDecimal.ZERO);
+                    oldOrder.setUserName(uploadUser);
+                    oldOrder.setLastUpdateTime(LocalDateTime.now());
+                    oldOrder.setLastUpdateReason("导入工单");
+                    //计划开工时间，这个替换后面的dbs的计划开始时间
+                    oldOrder.setPlanStartDate(kateOrdersExcelVo.getPlanStartDate());
+                    newKateOrdersMap.put(key, oldOrder);
+                }
+                continue;
+            }
             // 之前没存在过
             KateOrders newKateOrders = new KateOrders();
             newKateOrders.setOrderId(generateId("ORDER_"));
@@ -132,14 +168,14 @@ public class UploadKateOrdersListener implements ReadListener<KateOrdersExcelVo>
             newKateOrders.setLackQuantity(kateOrdersExcelVo.getRequirementQuantity());
             newKateOrders.setPickedQuantity(BigDecimal.ZERO);
             newKateOrders.setUserName(uploadUser);
+            newKateOrders.setCreateTime(LocalDateTime.now());
+            newKateOrders.setLastUpdateTime(LocalDateTime.now());
+            newKateOrders.setLastUpdateReason("导入工单");
             //计划开工时间，这个替换后面的dbs的计划开始时间
-                if(isAddReqmtDate) {
             newKateOrders.setPlanStartDate(kateOrdersExcelVo.getPlanStartDate());
-                }
             newKateOrdersMap.put(key, newKateOrders);
         }
     }
-    }
 
     /**
      * 保存数据库

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

@@ -5,6 +5,7 @@ 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.config.InitLocalConfig;
 import com.wms.entity.table.WorkStationConfig;
 import com.wms.service.WorkStationConfigService;
 import com.wms.utils.StringUtils;
@@ -17,6 +18,7 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
 
 import static com.wms.utils.WmsUtils.generateId;
 
@@ -119,5 +121,8 @@ public class UploadStationConfigListener implements ReadListener<StationConfigEx
         // 保存数据
         workStationConfigService.saveOrUpdateBatch(newWorkStationConfigMap.values(), BATCH_COUNT);
         logger.info("保存成功{}条数据。", newWorkStationConfigMap.size());
+        // 生成小盒子号对应开工日期调整Map
+        InitLocalConfig.smallBoxDateAdjustMap = workStationConfigService.list().stream().collect(Collectors.toMap(WorkStationConfig::getSmallBox, WorkStationConfig::getStartDateAdjust));
+        logger.info("生成小盒子号对应开工日期调整Map成功。");
     }
 }

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

@@ -11,6 +11,7 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.time.LocalDate;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -28,7 +29,6 @@ public class UploadWorkDateListener implements ReadListener<WorkDateExcelVo> {
     private static final int BATCH_COUNT = 100;
     private List<WorkDateExcelVo> cachedDataList = ListUtils.newArrayListWithExpectedSize(BATCH_COUNT);
     private final WorkDateService workDateService;// 工作日服务
-    private int key = 1;// 主键
     private final Map<LocalDate, WorkDate> newWorkDateMap = new HashMap<>();// 新的工作日
     public UploadWorkDateListener(WorkDateService workDateService) {
         this.workDateService = workDateService;
@@ -86,11 +86,9 @@ public class UploadWorkDateListener implements ReadListener<WorkDateExcelVo> {
             }
             // 创建一个新的工作日历对象
             WorkDate workDate = new WorkDate();
-            workDate.setKeyId(key);
             workDate.setWorkDate(workDateExcelVo.getWorkDate());
             workDate.setRemark(workDateExcelVo.getRemark());
             newWorkDateMap.put(workDateExcelVo.getWorkDate(), workDate);
-            key++;
         }
     }
 
@@ -99,11 +97,10 @@ public class UploadWorkDateListener implements ReadListener<WorkDateExcelVo> {
      */
     private void insertIntoDb() {
         logger.info("此次共导入{}条数据。", newWorkDateMap.size());
-        // 保存数据
-        workDateService.saveOrUpdateBatch(newWorkDateMap.values(), BATCH_COUNT);
+        // 先移除之前的数据
+        if (!workDateService.updateWorkDate(new ArrayList<>(newWorkDateMap.values()))) {
+            throw new RuntimeException("保存数据库失败。");
+        }
         logger.info("保存成功{}条数据。", newWorkDateMap.size());
-        // 生成工作日历
-        localWorkDateList = workDateService.list(new LambdaQueryWrapper<WorkDate>().orderByAsc(WorkDate::getWorkDate)).stream().map(WorkDate::getWorkDate).distinct().toList();
-        logger.info("生成工作日历Map成功。");
     }
 }

src/main/java/com/wms/utils/excel/vo/BaseGoodsExcelVo.java

@@ -91,4 +91,9 @@ public class BaseGoodsExcelVo {
      */
     @ExcelProperty("补料方式")
     private String feedingType;
+    /**
+     * 盘点指示器
+     */
+    @ExcelProperty("indicator")
+    private String indicator;
 }

src/main/java/com/wms/utils/excel/vo/KateOrdersExcelVo.java

@@ -3,10 +3,7 @@ package com.wms.utils.excel.vo;
 import cn.hutool.core.bean.BeanUtil;
 import com.alibaba.excel.annotation.ExcelProperty;
 import com.alibaba.excel.annotation.format.DateTimeFormat;
-import com.baomidou.mybatisplus.annotation.TableField;
-import com.baomidou.mybatisplus.annotation.TableId;
 import com.wms.entity.table.KateOrders;
-import com.wms.entity.table.Location;
 import lombok.Data;
 
 import java.math.BigDecimal;

src/main/java/com/wms/utils/excel/vo/PickTaskRecordExcelVo.java

@@ -0,0 +1,98 @@
+package com.wms.utils.excel.vo;
+
+import cn.hutool.core.date.LocalDateTimeUtil;
+import cn.hutool.core.util.StrUtil;
+import com.alibaba.excel.annotation.ExcelProperty;
+import com.alibaba.excel.annotation.format.DateTimeFormat;
+import com.wms.constants.enums.PickTaskStatusEnum;
+import com.wms.entity.table.PickTaskRecord;
+import com.wms.utils.StringUtils;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+import java.time.temporal.ChronoUnit;
+import java.util.Objects;
+
+/**
+ * 拣选任务记录excelVo
+ */
+@Data
+public class PickTaskRecordExcelVo {
+    /**
+     * 拣选任务号
+     */
+    @ExcelProperty("拣选任务号")
+    private String pickTaskId;
+    /**
+     * 载具号
+     */
+    @ExcelProperty("载具号")
+    private String vehicleId;
+    /**
+     * 站台号
+     */
+    @ExcelProperty("站台号")
+    private String standId;
+    /**
+     * 拣选任务状态
+     * -1：暂时不可发送
+     * 0：初始化
+     * 1：已发送
+     * 2：已完成
+     */
+    @ExcelProperty("拣选任务状态")
+    private String pickStatus;
+    /**
+     * 到达时间
+     */
+    @ExcelProperty("到达时间")
+    @DateTimeFormat("yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime arriveTime;
+    /**
+     * 最近更新时间
+     */
+    @ExcelProperty("离开时间")
+    @DateTimeFormat("yyyy-MM-dd HH:mm:ss")
+    private LocalDateTime lastUpdateTime;
+    /**
+     * 机型
+     * 1: 装载机；2: 平地机
+     */
+    @ExcelProperty("机型")
+    private String machineType;
+    /**
+     * 区域类型
+     * 1: 前；2: 后
+     */
+    @ExcelProperty("区域类型")
+    private String areaType;
+    /**
+     * 滞留时长
+     */
+    @ExcelProperty("滞留时长")
+    private String useTime;
+
+    /**
+     * 创建vo
+     * @param pickTaskRecord po
+     * @return vo
+     */
+    public static PickTaskRecordExcelVo fromPo(PickTaskRecord pickTaskRecord) {
+        PickTaskRecordExcelVo pickTaskRecordExcelVo = new PickTaskRecordExcelVo();
+        pickTaskRecordExcelVo.setPickTaskId(pickTaskRecord.getPickTaskId());
+        pickTaskRecordExcelVo.setVehicleId(pickTaskRecord.getVehicleId());
+        pickTaskRecordExcelVo.setStandId(pickTaskRecord.getStandId());
+        pickTaskRecordExcelVo.setPickStatus(PickTaskStatusEnum.getValueByCode(pickTaskRecord.getPickStatus()));
+        pickTaskRecordExcelVo.setLastUpdateTime(pickTaskRecord.getLastUpdateTime());
+        pickTaskRecordExcelVo.setArriveTime(pickTaskRecord.getArriveTime());
+        pickTaskRecordExcelVo.setMachineType(Objects.equals(pickTaskRecord.getMachineType(), 1) ? "装载机" : "平地机");
+        pickTaskRecordExcelVo.setAreaType(Objects.equals(pickTaskRecord.getAreaType(), 1) ? "前" : "后");
+        if (pickTaskRecord.getArriveTime() != null && pickTaskRecord.getLastUpdateTime() != null) {
+            pickTaskRecordExcelVo.setUseTime(StringUtils.durationFormat(pickTaskRecord.getArriveTime().until(pickTaskRecord.getLastUpdateTime(), ChronoUnit.SECONDS)));
+        } else {
+            pickTaskRecordExcelVo.setUseTime("到达时间与离开时间中有一个错误。");
+        }
+
+        return pickTaskRecordExcelVo;
+    }
+}

src/main/java/com/wms/utils/excel/vo/VehicleExcelVo.java

@@ -1,8 +1,8 @@
 package com.wms.utils.excel.vo;
 
-import cn.hutool.core.bean.BeanUtil;
 import com.alibaba.excel.annotation.ExcelProperty;
 import com.alibaba.excel.annotation.format.DateTimeFormat;
+import com.alibaba.fastjson2.JSON;
 import com.wms.entity.table.Vehicle;
 import lombok.Data;
 
@@ -36,6 +36,16 @@ public class VehicleExcelVo {
     @ExcelProperty("上次入库时间")
     @DateTimeFormat("yyyy-MM-dd HH:mm:ss")
     private LocalDateTime lastInTime;
+    /**
+     * 载具类型
+     */
+    @ExcelProperty("载具类型")
+    private String vehicleType;
+    /**
+     * 间接物料列表
+     */
+    @ExcelProperty("料号列表")
+    private String goodsInfo;
 
     /**
      * 从数据库实体转换为excel对象
@@ -43,6 +53,14 @@ public class VehicleExcelVo {
      * @return excel对象
      */
     public static VehicleExcelVo of(Vehicle vehiclePo) {
-        return BeanUtil.copyProperties(vehiclePo, VehicleExcelVo.class);
+        VehicleExcelVo tempVo = new VehicleExcelVo();
+        tempVo.setVehicleId(vehiclePo.getVehicleId());
+        tempVo.setCurrentLocation(vehiclePo.getCurrentLocation());
+        tempVo.setVehicleStatus(vehiclePo.getVehicleStatus());
+        tempVo.setIsEmpty(vehiclePo.getIsEmpty());
+        tempVo.setLastInTime(vehiclePo.getLastInTime());
+        tempVo.setVehicleType(vehiclePo.getVehicleType());
+        tempVo.setGoodsInfo(JSON.toJSONString(vehiclePo.getGoodsInfo()));
+        return tempVo;
     }
 }

src/main/resources/application.yml

@@ -59,6 +59,8 @@ mybatis-plus:
 
 logging:
     config: classpath:logback.xml
+
+reqmtsDate: false
 #    file:
 #        encoding: UTF-8