1. 增加需求日期的调整；

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

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

@@ -37,7 +37,8 @@ public enum ConfigMapKeyEnum {
     SAME_MACHINE("SAME_MACHINE"),
     SAME_AREA("SAME_AREA"),
     RATE_TYPE("RATE_TYPE"),
-    USE_REQUIRE_DATE("USE_REQUIRE_DATE");// 是否使用需求时间
+    USE_REQUIRE_DATE("USE_REQUIRE_DATE"),// 是否使用需求时间
+    START_DATE_ADJUST("START_DATE_ADJUST");// 开工日期调整天数
     private final String configKey;
     ConfigMapKeyEnum(String configKey) {
         this.configKey = configKey;

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;
     /**
      * 请求头部信息
      */
@@ -950,4 +956,151 @@ public class KateWorkQueryController {
             return convertJsonString(response);
         }
     }
+
+    /**
+     * 查询工作日历
+     * @param workDateQuery 查询参数
+     * @return 查询结果
+     */
+    @PostMapping("/queryWorkDate")
+    @ResponseBody
+    public String getOrders(@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 = 1;
+                for (LocalDate workDate : localWorkDateList) {
+                    WorkDateVo workDateVo = new WorkDateVo();
+                    workDateVo.setKeyId(index);
+                    workDateVo.setWorkDate(workDate);
+                    workDateVoList.add(workDateVo);
+                    index++;
+                }
+                response.setCode(ResponseCode.OK.getCode());
+                response.setMessage("查询工作日历成功");
+                response.setReturnData(workDateVoList);
+                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/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/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/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/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/serviceImplements/WorkServiceImplements.java

@@ -1033,10 +1033,32 @@ public class WorkServiceImplements implements IWorkService {
         //开始时间：
         LocalDateTime startTime = LocalDateTime.now();
         System.out.println("分析当日工作流，开始时间：" + startTime);
+        // 获取开工日期调整配置
+        int dateAdjust = 0;
+        try {
+            String dateAdjustStr = configMap.get(ConfigMapKeyEnum.START_DATE_ADJUST.getConfigKey());
+            if (StringUtils.isNotEmpty(dateAdjustStr)) {
+                dateAdjust = Integer.parseInt(dateAdjustStr);
+            }
+        } catch (Exception e) {
+            logger.error("获取开工日期调整配置失败：{}，使用默认值0。", 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, currentWorkDate));
+                .eq(KateOrders::getPlanStartDate, localWorkDateList.get(requireDateIndex)));
         if (currentDateKateWorkOrders.isEmpty()) {
             logger.info("没有当日待生成工作流的工单。");
             return;

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/excel/listener/UploadDbsListener.java

@@ -17,6 +17,7 @@ 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;
 
 /**
@@ -52,7 +53,7 @@ public class UploadDbsListener implements ReadListener<KateDbsExcelVo> {
     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());
     }
 
     /**
@@ -66,18 +67,22 @@ public class UploadDbsListener implements ReadListener<KateDbsExcelVo> {
         if (kateDbsExcelVo.getWorkSequence() != null
         && StringUtils.isNotEmpty(kateDbsExcelVo.getWorkOrder())
         && StringUtils.isNotEmpty(kateDbsExcelVo.getMachineNo())) {
-            if (!isAddReqmtDate) {
-                if(kateDbsExcelVo.getPlanStartDate() != null){
-                    cachedDataList.add(kateDbsExcelVo);
-                } else {
             int rowCount = analysisContext.readRowHolder().getRowIndex() + 1;
+            if (kateDbsExcelVo.getPlanStartDate() != null) {
+                // 需要判断日期是否在配置的工作日历里面
+                int indexOfCurrentDate = localWorkDateList.indexOf(kateDbsExcelVo.getPlanStartDate().toLocalDate());
+                if (indexOfCurrentDate == -1) {
+                    // 工作日不包含此开工日期
+                    logger.error("第{}行DBS开工日期为非工作日。", rowCount);
+                    throw new RuntimeException("第" + rowCount + "行DBS开工日期为非工作日。");
+                }
+                cachedDataList.add(kateDbsExcelVo);
+            }
+            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

@@ -16,6 +16,7 @@ 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;
 
 /**
@@ -71,18 +72,22 @@ public class UploadKateOrdersListener implements ReadListener<KateOrdersExcelVo>
                     && StringUtils.isNotEmpty(kateOrdersExcelVo.getSupplyArea())
                     && kateOrdersExcelVo.getRequirementQuantity() != null
                     && kateOrdersExcelVo.getRequirementQuantity().compareTo(BigDecimal.ZERO) > 0) {
-                if (isAddReqmtDate) {
-                    if(kateOrdersExcelVo.getPlanStartDate() != null){
-                        cachedDataList.add(kateOrdersExcelVo);
-                    } else {
                 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 + "行工单需求日期为非工作日。");
+                    }
+                    cachedDataList.add(kateOrdersExcelVo);
+                }
+                if (!isAddReqmtDate) {
+                    // 缺少开工日期
                     logger.error("第{}行工单缺少开工日期。", rowCount);
                     throw new RuntimeException("第" + rowCount + "行工单缺少开工日期。");
                 }
-                } else {
-                    // 符合条件
-                    cachedDataList.add(kateOrdersExcelVo);
-                }
             }
         }
         // 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM

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成功。");
     }
 }