1.优化

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

@@ -24,7 +24,8 @@ public enum ConfigMapKeyEnum {
     USE_SETTING_DATE("USE_SETTING_DATE"),
     SETTING_DATE("SETTING_DATE"),
     RATE_MIN_TO_MAX("RATE_MIN_TO_MAX"),
-    WORK_PRIORITY("WORK_PRIORITY");
+    WORK_PRIORITY("WORK_PRIORITY"),
+    IF_MERGE_TOMORROW("IF_MERGE_TOMORROW");
     private final String configKey;
     ConfigMapKeyEnum(String configKey) {
         this.configKey = configKey;

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

@@ -1,25 +0,0 @@
-package com.wms.constants.enums;
-
-public enum KateTaskStatus {
-    NEW(0, "待下发"),
-    WAIT(1, "已下发"),
-    RUN(2, "执行中"),
-    PICKING(3, "正在拣货"),
-    FINISH(5, "任务完成");
-
-    private final Integer code;
-    private final String name;
-
-    KateTaskStatus(Integer code, String name) {
-        this.code = code;
-        this.name = name;
-    }
-
-    public Integer getCode() {
-        return code;
-    }
-
-    public String getName() {
-        return name;
-    }
-}

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

@@ -1,27 +0,0 @@
-package com.wms.constants.enums;
-
-/**
- * 向mes反馈的任务状态码
- */
-public enum MesStatus {
-    WAIT(0, "等待执行"),
-    RUN(1, "执行中"),
-    FINISH(2, "执行完成"),
-    EXCEPTION(3, "任务异常");
-
-    private final Integer statusCode;
-    private final String statusInfo;
-
-    MesStatus(Integer statusCode, String statusInfo) {
-        this.statusCode = statusCode;
-        this.statusInfo = statusInfo;
-    }
-
-    public Integer getStatusCode() {
-        return statusCode;
-    }
-
-    public String getStatusInfo() {
-        return statusInfo;
-    }
-}

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

@@ -1,26 +0,0 @@
-package com.wms.constants.enums;
-
-/**
- * 站台状态的枚举
- */
-public enum StandStatus {
-    OK(0, "可用"),
-    OCCUPY(1, "占用");
-
-    private final Integer code;
-
-    private final String value;
-
-    StandStatus(Integer code, String value) {
-        this.code = code;
-        this.value = value;
-    }
-
-    public Integer getCode() {
-        return code;
-    }
-
-    public String getValue() {
-        return value;
-    }
-}

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

@@ -1,22 +0,0 @@
-package com.wms.constants.enums;
-
-public enum UrlEnums {
-    URL_WMS_TO_WCS_SEND_TASK("WMS向WCS发送任务", "/api/Wms/WmsTask/SetStackerTask"),
-    URL_WMS_TO_WCS_CHANGE_TASK("WMS请求变更任务状态", "/api/Wms/WmsTask/ChangeTaskStatus");
-
-    private final String description;
-    private final String value;
-
-    UrlEnums(String description, String value) {
-        this.description = description;
-        this.value = value;
-    }
-
-    public String getDescription() {
-        return description;
-    }
-
-    public String getValue() {
-        return value;
-    }
-}

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

@@ -1,26 +0,0 @@
-package com.wms.constants.enums;
-
-/**
- * 向Wcs发送任务变更时的任务状态枚举
- */
-public enum WcsChangeTaskStatus {
-    FINISH(0, "重新执行任务"),
-    CANCEL(1, "取消/删除任务"),
-    EXCEPTION(2, "完成任务");
-
-    private final Integer code;
-    private final String message;
-
-    WcsChangeTaskStatus(Integer code, String message) {
-        this.code = code;
-        this.message = message;
-    }
-
-    public Integer getCode() {
-        return code;
-    }
-
-    public String getMessage() {
-        return message;
-    }
-}

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

@@ -171,16 +171,24 @@ public class JobComponent {
         if (now.isBefore(LocalDateTime.of(now.toLocalDate(), LocalTime.of(7, 40))) || now.isAfter(LocalDateTime.of(now.toLocalDate(), LocalTime.of(23, 40)))) {
             return;
         }
+        try {
+            workService.createTempWorkFlows();
+        } catch (Exception e) {
+            logger.error("创建当日工作发生错误：{}", e.getMessage());
+        }
         // 轮询工作站台，判断是否需要下发任务
         List<Stand> stands = standService.list(new LambdaQueryWrapper<Stand>()
                 .eq(Stand::getIsLock, 0).eq(Stand::getStandStatus, 0)
                 .eq(Stand::getStandType, 2));
         for (Stand workStation : stands) {
             try {
-                // 创建工作
+//                // 创建工作
-                workService.createWork(workStation.getStandId());
+//                workService.createWork(workStation.getStandId());
+                // 分配工作
+                workService.distributeWorks(workStation.getStandId());
             } catch (Exception e) {
-                logger.error("创建工作时发生错误：{}", convertJsonString(e.getMessage()));
+//                logger.error("创建工作时发生错误：{}", e.getMessage());
+                logger.error("分配工作时发生错误：{}", e.getMessage());
             }
         }
     }

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

@@ -6,6 +6,7 @@ import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.Data;
 
 import java.math.BigDecimal;
+import java.time.LocalDate;
 import java.time.LocalDateTime;
 
 /**
@@ -85,4 +86,14 @@ public class WorkFlow {
      */
     @TableField("op_user")
     private String opUser;
+    /**
+     * 机器类型
+     */
+    @TableField("machine_type")
+    private Integer machineType;
+    /**
+     * 计划日期
+     */
+    @TableField("plan_date")
+    private LocalDate planDate;
 }

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

@@ -6,6 +6,7 @@ import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.Data;
 
 import java.math.BigDecimal;
+import java.time.LocalDate;
 import java.time.LocalDateTime;
 
 /**
@@ -85,4 +86,14 @@ public class WorkFlowLast {
      */
     @TableField("op_user")
     private String opUser;
+    /**
+     * 机器类型
+     */
+    @TableField("machine_type")
+    private Integer machineType;
+    /**
+     * 计划日期
+     */
+    @TableField("plan_date")
+    private LocalDate planDate;
 }

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

@@ -6,6 +6,7 @@ import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.Data;
 
 import java.math.BigDecimal;
+import java.time.LocalDate;
 import java.time.LocalDateTime;
 
 /**
@@ -89,4 +90,14 @@ public class WorkSummary {
      */
     @TableField("e_location_id")
     private String eLocationId;
+    /**
+     * 机器类型
+     */
+    @TableField("machine_type")
+    private Integer machineType;
+    /**
+     * 计划日期
+     */
+    @TableField("plan_date")
+    private LocalDate planDate;
 }

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

@@ -27,5 +27,18 @@ public interface IWorkService {
      * 完成工作
      * @param workStation 工作站台
      */
-    String finishWork(String workStation) throws Exception;
+    String finishWork(String workStation);
+
+    /**
+     * 创建暂存工作
+     * @throws Exception 异常
+     */
+    void createTempWorkFlows() throws Exception;
+
+    /**
+     * 分配工作
+     * @param workStation 站台号
+     * @throws Exception 异常
+     */
+    void distributeWorks(String workStation) throws Exception;
 }

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

@@ -115,6 +115,11 @@ public class WorkServiceImplements implements IWorkService {
             List<WorkFlow> currentStationWorkFlows = new ArrayList<>();
             // 先找MWL机型
             String workPriority = configMap.get(ConfigMapKeyEnum.WORK_PRIORITY.getConfigKey());
+            // 查找到当前站台所有可用的电子标签
+            List<ETagLocation> eTagLocationList = eTagLocationService.list(new LambdaQueryWrapper<ETagLocation>()
+                    .eq(ETagLocation::getWorkStation, workStation)
+                    .eq(ETagLocation::getELocationStatus, 0)
+                    .orderByAsc(ETagLocation::getSequenceId));
             if (!StringUtils.isEmpty(workPriority) && workPriority.equals("1")) {
                 // 找非MWL机型--先平地机
                 findWorks(workStation, currentStationWorkFlows, "NOT_MWL", currentWorkDate);
@@ -129,6 +134,7 @@ public class WorkServiceImplements implements IWorkService {
                     findWorks(workStation, currentStationWorkFlows, "NOT_MWL", currentWorkDate);
                 }
             }
+
             // 如果当前站台有任务
             if (!currentStationWorkFlows.isEmpty()) {
                 // 将工作流列表添加进数据库
@@ -158,6 +164,9 @@ public class WorkServiceImplements implements IWorkService {
                         needGoodsMap.replace(tempWorkflow.getGoodsId(), needGoodsMap.get(tempWorkflow.getGoodsId()).add(tempWorkflow.getNeedNum()));
                     }
                 }
+                if (eTagLocationList.isEmpty() || eTagLocationList.size() < boxNoList.size()) {
+                    throw new Exception("站台：" + workStation + "没有足够可用的电子标签位!");
+                }
                 // 站台要料
                 List<GoodsToStation> goodsToStationList = new ArrayList<>();
                 for (String goodsId : needGoodsMap.keySet()) {
@@ -188,14 +197,6 @@ public class WorkServiceImplements implements IWorkService {
                 }
                 // 电子标签库位配置
                 List<ELocationConfig> eLocationConfigList = new ArrayList<>();
-                // 查找到当前站台所有可用的电子标签
-                List<ETagLocation> eTagLocationList = eTagLocationService.list(new LambdaQueryWrapper<ETagLocation>()
-                        .eq(ETagLocation::getWorkStation, workStation)
-                        .eq(ETagLocation::getELocationStatus, 0)
-                        .orderByAsc(ETagLocation::getSequenceId));
-                if (eTagLocationList.isEmpty() || eTagLocationList.size() < boxNoList.size()) {
-                    throw new Exception("站台：" + workStation + "没有足够可用的电子标签位!");
-                }
                 for (ETagLocation eTagLocation : eTagLocationList) {
                     if (boxNoList.isEmpty()) {
                         break;
@@ -225,6 +226,27 @@ public class WorkServiceImplements implements IWorkService {
         }
     }
 
+    /**
+     * 找到下一个工作日
+     *
+     * @param currentDate 当前日期
+     * @return 下一个工作日
+     */
+    private LocalDate nextWorkDate(LocalDate currentDate) {
+        // 判断是否是当天开工
+        int indexOfCurrentDate = localWorkDateList.indexOf(currentDate);
+        if (indexOfCurrentDate == -1) {
+            // 工作日不包含此开工日期
+            return null;
+        }
+        int indexAfterAdjust = indexOfCurrentDate + 1;
+        if (indexAfterAdjust >= localWorkDateList.size()) {
+            // 调整后的日期不再工作日范围
+            return null;
+        }
+        return localWorkDateList.get(indexAfterAdjust);
+    }
+
     /**
      * 新版开始工作
      *
@@ -244,7 +266,8 @@ public class WorkServiceImplements implements IWorkService {
             // 查找当前站台未开始的工作流
             List<WorkFlow> currentWorkFlowList = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
                     .eq(WorkFlow::getWorkStation, workStation)
-                    .ne(WorkFlow::getWorkStatus, 2));
+                    .notIn(WorkFlow::getWorkStatus, -1, 2));
+//                    .ne(WorkFlow::getWorkStatus, 2));
             // 没有可做的任务
             if (currentWorkFlowList == null || currentWorkFlowList.isEmpty()) {
                 return;
@@ -422,10 +445,9 @@ public class WorkServiceImplements implements IWorkService {
      *
      * @param workStation 工作站台
      * @return 结果
-     * @throws Exception 异常
      */
     @Override
-    public String finishWork(String workStation) throws Exception {
+    public String finishWork(String workStation) {
         if (workFinishingStations.contains(workStation)) {
             // 当前站台正在完成工作
             return "当前站台正在完成工作，请勿重复操作";
@@ -433,9 +455,11 @@ public class WorkServiceImplements implements IWorkService {
             // 添加站台
             workFinishingStations.add(workStation);
         }
+        String result = "";
         try {
             if (workFlowService.exists(new LambdaQueryWrapper<WorkFlow>()
                     .eq(WorkFlow::getWorkStation, workStation)
+                    .notIn(WorkFlow::getWorkStatus, -1, 2)
                     .ne(WorkFlow::getWorkStatus, 2))) {
                 // 当前站台工作未全部完成
                 return "工作未全部做完，不允许确认完成。";
@@ -521,12 +545,12 @@ public class WorkServiceImplements implements IWorkService {
                     .eq(GoodsToStation::getWorkStation, workStation));
         } catch (Exception e) {
             logger.error("完成站台：{}工作发生异常：{}", workStation, convertJsonString(e));
-            throw new Exception("完成站台：" + workStation + "工作发生异常!");
+            result = "完成站台：" + workStation + "工作发生异常!";
         } finally {
             // 当前站台工作完成
             workFinishingStations.remove(workStation);
         }
-        return "";
+        return result;
     }
 
     /**
@@ -538,7 +562,8 @@ public class WorkServiceImplements implements IWorkService {
      */
     private void findWorks(String workStation, List<WorkFlow> workFlows, String model, LocalDate currentWorkDate) {
         // 查到当前站台所有的小工位
-        LambdaQueryWrapper<WorkStationConfig> stationConfigQueryWrapper = new LambdaQueryWrapper<WorkStationConfig>().eq(WorkStationConfig::getWorkStation, workStation);
+        LambdaQueryWrapper<WorkStationConfig> stationConfigQueryWrapper = new LambdaQueryWrapper<WorkStationConfig>()
+                .eq(StringUtils.isNotEmpty(workStation), WorkStationConfig::getWorkStation, workStation);
         if (Objects.equals(model, "MWL")) {
             stationConfigQueryWrapper.eq(WorkStationConfig::getModel, "MWL");
         } else {
@@ -631,6 +656,9 @@ public class WorkServiceImplements implements IWorkService {
                         tempWorkFlow.setWorkStatus(0);
                         tempWorkFlow.setLightStatus(0);
                         tempWorkFlow.setPickedNum(BigDecimal.ZERO);
+                        // 改动
+                        tempWorkFlow.setMachineType(Objects.equals(model, "MWL") ? 1 : 2);
+                        tempWorkFlow.setPlanDate(currentWorkDate);
                         workFlows.add(tempWorkFlow);
                     }
                 }
@@ -638,6 +666,383 @@ public class WorkServiceImplements implements IWorkService {
         }
     }
 
+    /**
+     * 获取当前的工作日期
+     *
+     * @return 当前的工作日期
+     */
+    private LocalDate getCurrentWorkDate() {
+        // 先判断当日是否是工作日
+        LocalDate currentWorkDate = LocalDate.now();
+        // 获取当前配置日期
+        try {
+            String useSettingDate = configMap.get(ConfigMapKeyEnum.USE_SETTING_DATE.getConfigKey());
+            if (!StringUtils.isEmpty(useSettingDate) && useSettingDate.equals("1")) {
+                String settingDate = configMap.get(ConfigMapKeyEnum.SETTING_DATE.getConfigKey());
+                if (!StringUtils.isEmpty(settingDate)) {
+                    String[] settingDateArray = settingDate.split("-");
+                    int settingDateYear = Integer.parseInt(settingDateArray[0]);
+                    int settingDateMonth = Integer.parseInt(settingDateArray[1]);
+                    int settingDateDay = Integer.parseInt(settingDateArray[2]);
+                    // 系统配置的当前日期
+                    currentWorkDate = LocalDate.of(settingDateYear, settingDateMonth, settingDateDay);
+                }
+            }
+        } catch (Exception e) {
+            logger.error("获取配置工作日期错误，使用当前系统日期。");
+        }
+        return currentWorkDate;
+    }
+
+    /**
+     * 尝试，先生成工作流
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void createTempWorkFlows() {
+        LocalDate currentWorkDate = getCurrentWorkDate();
+        if (!localWorkDateList.contains(currentWorkDate)) {
+            return;
+        }
+        // 添加进总汇总数据
+        List<WorkFlow> allFlows = new ArrayList<>();
+        // 获取当天所有的装载机工作
+        List<WorkFlow> thisDayMWLWorks = new ArrayList<>();
+        findWorks("", thisDayMWLWorks, "MWL", currentWorkDate);
+        if (!thisDayMWLWorks.isEmpty()) {
+            allFlows.addAll(thisDayMWLWorks);
+        }
+        // 获取到当天所有的平地机工作
+        List<WorkFlow> thisDayMGWorks = new ArrayList<>();
+        findWorks("", thisDayMGWorks, "NOT_MWL", currentWorkDate);
+        if (!thisDayMGWorks.isEmpty()) {
+            allFlows.addAll(thisDayMGWorks);
+            // 查询配置是否需要合并第二天的配置
+            String ifMergeTomorrow = configMap.get(ConfigMapKeyEnum.IF_MERGE_TOMORROW.getConfigKey());
+            if (!StringUtils.isEmpty(ifMergeTomorrow) && ifMergeTomorrow.equals("1")) {
+                // 需要合并第二天的平地机工作
+                List<WorkFlow> nextDayMGWorks = new ArrayList<>();
+                // 获取下一个工作日
+                LocalDate nextWorkDate = nextWorkDate(currentWorkDate);
+                if (nextWorkDate != null && nextWorkDate.isAfter(currentWorkDate)) {
+                    findWorks("", nextDayMGWorks, "NOT_MWL", nextWorkDate);
+                }
+                if (!nextDayMGWorks.isEmpty()) {
+                    // 添加第二天的平地机工作进汇总
+                    allFlows.addAll(nextDayMGWorks);
+                }
+            }
+        }
+        // 处理这些工作流
+        List<WorkFlow> oldWorkFlows = workFlowService.list();
+        // 按照工单号+小盒子号+料号来map一下
+        Map<String, WorkFlow> oldWorkFlowsMap = oldWorkFlows.stream().collect(
+                Collectors.toMap(workFlow ->
+                        workFlow.getWorkOrder() + "_" + workFlow.getWorkCenter() + "_" + workFlow.getGoodsId(), workFlow -> workFlow));
+        // 最后需要存储的工作
+        List<WorkFlow> finalWorkFlows = new ArrayList<>();
+        for (WorkFlow workFlow : allFlows) {
+            String key = workFlow.getWorkOrder() + "_" + workFlow.getWorkCenter() + "_" + workFlow.getGoodsId();
+            if (oldWorkFlowsMap.containsKey(key)) {
+                continue;
+            }
+            workFlow.setWorkStatus(-1);// 设置暂存状态
+            finalWorkFlows.add(workFlow);
+        }
+        if (!finalWorkFlows.isEmpty()) {
+            // 存储数据
+            workFlowService.saveBatch(finalWorkFlows);
+            // 更新工单状态
+            List<String> orderIds = finalWorkFlows.stream().map(WorkFlow::getOrderId).toList();
+            if (!orderIds.isEmpty()) {
+                kateOrdersService.update(new LambdaUpdateWrapper<KateOrders>()
+                        .set(KateOrders::getOrderStatus, 1)
+                        .in(KateOrders::getOrderId, orderIds)
+                        .eq(KateOrders::getOrderStatus, 0));
+            }
+            // 更新dbs表
+            List<String> workOrderList = finalWorkFlows.stream().map(WorkFlow::getWorkOrder).distinct().toList();
+            if (!workOrderList.isEmpty()) {
+                kateDBSService.update(new LambdaUpdateWrapper<KateDBS>()
+                        .set(KateDBS::getDbsStatus, 1)
+                        .in(KateDBS::getWorkOrder, workOrderList)
+                        .eq(KateDBS::getDbsStatus, 0));
+            }
+        }
+    }
+
+    /**
+     * 分配任务
+     *
+     * @param workStation 站台号
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void distributeWorks(String workStation) {
+        if (workCreatingStations.contains(workStation)) {
+            // 当前站台正在创建任务
+            return;
+        } else {
+            // 添加站台
+            workCreatingStations.add(workStation);
+        }
+        if (StringUtils.isEmpty(workStation)) {
+            // 站台号为空
+            return;
+        }
+        try {
+            // 获取工作优先级
+            String workPriority = configMap.get(ConfigMapKeyEnum.WORK_PRIORITY.getConfigKey());
+            List<WorkFlow> needDistributeWorks = new ArrayList<>();
+            if (!StringUtils.isEmpty(workPriority) && workPriority.equals("1")) {
+                // 当前工作优先级为先平地机后装载机
+                // 查询当前站台是否还有装载机的任务没做完
+                List<WorkFlow> oldMwlWorks = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
+                        .eq(WorkFlow::getWorkStation, workStation)
+                        .eq(WorkFlow::getMachineType, 1)
+                        .ne(WorkFlow::getWorkStatus, -1));
+                if (!oldMwlWorks.isEmpty()) {
+                    // 装载机没做完，不允许做平地机
+                    return;
+                }
+                // 查询已经生成的工作
+                List<WorkFlow> oldWorkFlows = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
+                        .eq(WorkFlow::getMachineType, 2)
+                        .eq(WorkFlow::getWorkStatus, -1));
+                if (oldWorkFlows.isEmpty()) {
+                    // 判断下是否有平地机任务还未生成
+                    List<WorkFlow> notCreatedMGWorks = new ArrayList<>();
+                    findWorks("", notCreatedMGWorks, "NOT_MWL", getCurrentWorkDate());
+                    if (!notCreatedMGWorks.isEmpty()) {
+                        // 仍有未生成的平地机任务，跳过
+                        return;
+                    }
+                    // 查询装载机
+                    List<WorkFlow> mwlWorks = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
+                            .eq(WorkFlow::getMachineType, 1)
+                            .eq(WorkFlow::getWorkStatus, -1));
+                    if (mwlWorks.isEmpty()) {
+                        // 没有装载机任务，跳过
+                        return;
+                    }
+                    needDistributeWorks.addAll(mwlWorks);
+                } else {
+                    needDistributeWorks.addAll(oldWorkFlows);
+                }
+            } else {
+                // 默认优先级为先装载机后平地机
+                // 查询当前站台是否还有平地机的任务没做完
+                List<WorkFlow> oldMgWorks = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
+                        .eq(WorkFlow::getWorkStation, workStation)
+                        .eq(WorkFlow::getMachineType, 2)
+                        .ne(WorkFlow::getWorkStatus, -1));
+                if (!oldMgWorks.isEmpty()) {
+                    // 平地机没做完，不允许做装载机
+                    return;
+                }
+                List<WorkFlow> oldWorkFlows = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
+                        .eq(WorkFlow::getMachineType, 1)
+                        .eq(WorkFlow::getWorkStatus, -1));
+                if (oldWorkFlows.isEmpty()) {
+                    // 判断下是否有装载机任务还未生成
+                    List<WorkFlow> notCreatedMWLWorks = new ArrayList<>();
+                    findWorks("", notCreatedMWLWorks, "MWL", getCurrentWorkDate());
+                    if (!notCreatedMWLWorks.isEmpty()) {
+                        // 仍有未生成的装载机任务，跳过
+                        return;
+                    }
+                    // 查询平地机
+                    List<WorkFlow> mgWorks = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
+                            .eq(WorkFlow::getMachineType, 2)
+                            .eq(WorkFlow::getWorkStatus, -1));
+                    if (mgWorks.isEmpty()) {
+                        // 没有平地机任务，跳过
+                        return;
+                    }
+                    needDistributeWorks.addAll(mgWorks);
+                } else {
+                    needDistributeWorks.addAll(oldWorkFlows);
+                }
+            }
+            // 最终需要存储的数据
+            List<GoodsToStation> finalGoodsToStations;// 物料分配
+            List<ELocationConfig> finalELocationConfigs = new ArrayList<>();// 标签库位分配
+            // 获取当前站台所有可用的电子标签库位
+            List<ETagLocation> thisStandELocations = eTagLocationService.list(new LambdaQueryWrapper<ETagLocation>()
+                    .eq(ETagLocation::getWorkStation, workStation)
+                    .eq(ETagLocation::getELocationStatus, 0)
+                    .orderByAsc(ETagLocation::getSequenceId));
+            // 获取已经添加的电子标签库位分配
+            List<ELocationConfig> allELocationConfigs = eLocationConfigService.list();
+            // 筛选出剩余可用的电子标签库位
+            List<String> usedELocationIds = allELocationConfigs.stream().map(ELocationConfig::getELocationId).distinct().toList();
+            List<String> remainELocationIds = new ArrayList<>();
+            for (ETagLocation eTagLocation : thisStandELocations) {
+                if (usedELocationIds.contains(eTagLocation.getELocationId())) {
+                    continue;
+                }
+                remainELocationIds.add(eTagLocation.getELocationId());
+            }
+            if (remainELocationIds.isEmpty()) {
+                // 当前站台没有可用电子标签库位分配了，跳过
+                return;
+            }
+            // 然后获取大盒子-订单的map
+            Map<String, List<WorkFlow>> workFlowsByBigBoxMap = new HashMap<>();
+            // 获取工站配置
+            List<WorkStationConfig> workStationConfigs = workStationConfigService.list();
+            // 根据小盒子号生成map
+            Map<String, String> smallBoxToBigBoxConfigMap = workStationConfigs.stream().collect(Collectors.toMap(WorkStationConfig::getSmallBox, WorkStationConfig::getBigBox));
+            for (WorkFlow workFlow : needDistributeWorks) {
+                if (smallBoxToBigBoxConfigMap.containsKey(workFlow.getWorkCenter())) {
+                    if (workFlowsByBigBoxMap.containsKey(smallBoxToBigBoxConfigMap.get(workFlow.getWorkCenter()))) {
+                        String bigBox = smallBoxToBigBoxConfigMap.get(workFlow.getWorkCenter());
+                        List<WorkFlow> thisBoxWorkFlows = new ArrayList<>(workFlowsByBigBoxMap.get(bigBox));
+                        thisBoxWorkFlows.add(workFlow);
+                        workFlowsByBigBoxMap.replace(bigBox, thisBoxWorkFlows);
+                    } else {
+                        workFlowsByBigBoxMap.put(smallBoxToBigBoxConfigMap.get(workFlow.getWorkCenter()), List.of(workFlow));
+                    }
+                }
+            }
+            // 根据订单量，对大盒子号进行一个排序
+            List<String> bigBoxes = workFlowsByBigBoxMap.keySet().stream().sorted(Comparator.comparingInt(o -> workFlowsByBigBoxMap.get(o).size())).toList();
+            // 对已有的大盒子进行一个配置
+            Map<String, String> stationOfBigBoxMap = new HashMap<>();
+            // 针对此站台的料盒号（工单@工作中心）生成一个map
+            Map<String, String> eLocationIdOfBoxMap = new HashMap<>();
+            for (ELocationConfig oldELocationConfig : allELocationConfigs) {
+                if (!stationOfBigBoxMap.containsKey(oldELocationConfig.getWorkCenter())) {
+                    // 默认大盒子 = 小盒子
+                    String bigBox = oldELocationConfig.getWorkCenter();
+                    if (smallBoxToBigBoxConfigMap.containsKey(oldELocationConfig.getWorkCenter())) {
+                        // 设置为实际的大盒子
+                        bigBox = smallBoxToBigBoxConfigMap.get(oldELocationConfig.getWorkCenter());
+                    }
+                    stationOfBigBoxMap.put(bigBox, oldELocationConfig.getWorkStation());
+                }
+                // 更新料盒号-电子标签库位Map
+                if (!eLocationIdOfBoxMap.containsKey(oldELocationConfig.getOrderBoxNo())) {
+                    eLocationIdOfBoxMap.put(oldELocationConfig.getOrderBoxNo(), oldELocationConfig.getELocationId());
+                }
+            }
+            // 开始分配电子标签库位
+            List<WorkFlow> thisTimeDistributeWorkFlows = new ArrayList<>();
+            for (String bigBox : bigBoxes) {
+                if (remainELocationIds.isEmpty()) {
+                    // 当前站台没有剩余电子标签位置可以分配了
+                    break;
+                }
+                // 判断这个大盒子是否分配了站台
+                if (stationOfBigBoxMap.containsKey(bigBox) && !stationOfBigBoxMap.get(bigBox).equals(workStation)) {
+                    continue;
+                }
+                // 获取到这个大盒子下面的所有工作流
+                List<WorkFlow> thisBigBoxWorks = workFlowsByBigBoxMap.get(bigBox);
+                // 未分配的工作流，按照boxNo分组
+                Map<String, List<WorkFlow>> notDistributeYetWorksByBoxMap = new HashMap<>();
+                for (WorkFlow workFlow : thisBigBoxWorks) {
+                    String boxNo = workFlow.getWorkOrder() + "@" + workFlow.getWorkCenter();
+                    if (!eLocationIdOfBoxMap.containsKey(boxNo)) {
+                        if (notDistributeYetWorksByBoxMap.containsKey(boxNo)) {
+                            List<WorkFlow> thisBoxNotDistributeYetWorks = new ArrayList<>(notDistributeYetWorksByBoxMap.get(boxNo));
+                            thisBoxNotDistributeYetWorks.add(workFlow);
+                            notDistributeYetWorksByBoxMap.replace(boxNo, thisBoxNotDistributeYetWorks);
+                        } else {
+                            notDistributeYetWorksByBoxMap.put(boxNo, List.of(workFlow));
+                        }
+                    }
+                }
+                if (notDistributeYetWorksByBoxMap.isEmpty()) {
+                    // 当前大盒子全部分配完毕
+                    continue;
+                }
+                // 判断电子标签库位是否足够
+                if (notDistributeYetWorksByBoxMap.size() > remainELocationIds.size()) {
+                    // 这个大盒子的位置不够了，整个大盒子都不分配。
+                    continue;
+                }
+                for (String boxNo : notDistributeYetWorksByBoxMap.keySet()) {
+                    if (eLocationIdOfBoxMap.containsKey(boxNo)) {
+                        continue;
+                    }
+                    // 获取一个电子标签库位
+                    String eLocationId = remainELocationIds.get(0);
+                    ELocationConfig eLocationConfig = new ELocationConfig();
+                    eLocationConfig.setWorkOrder(boxNo.split("@")[0]);
+                    eLocationConfig.setWorkCenter(boxNo.split("@")[1]);
+                    eLocationConfig.setWorkStation(workStation);
+                    eLocationConfig.setELocationId(eLocationId);
+                    eLocationConfig.setOrderBoxNo(boxNo);
+                    // 添加配置
+                    finalELocationConfigs.add(eLocationConfig);
+                    eLocationIdOfBoxMap.put(boxNo, eLocationId);
+                    // 添加此次分配列表
+                    thisTimeDistributeWorkFlows.addAll(notDistributeYetWorksByBoxMap.get(boxNo));
+                    // 移除这个库位
+                    remainELocationIds.remove(eLocationId);
+                }
+            }
+            // 处理分配
+            List<GoodsToStation> oldGoodsStations = goodsToStationService.list(
+                    new LambdaQueryWrapper<GoodsToStation>().eq(GoodsToStation::getWorkStation, workStation)
+            );
+            // 根据料号Map一下
+            Map<String, GoodsToStation> oldGoodsStationsMap = oldGoodsStations.stream().collect(Collectors.toMap(GoodsToStation::getGoodsId, goodsToStation -> goodsToStation));
+            // 新增
+            Map<String, GoodsToStation> newGoodsToStationMap = new HashMap<>();
+            for (WorkFlow workFlow : thisTimeDistributeWorkFlows) {
+                if (newGoodsToStationMap.containsKey(workFlow.getGoodsId())) {
+                    // 更新totalNum，并把状态改成分配中
+                    GoodsToStation goodsToStation = newGoodsToStationMap.get(workFlow.getGoodsId());
+                    goodsToStation.setTotalNum(goodsToStation.getTotalNum().add(workFlow.getNeedNum()));
+                    newGoodsToStationMap.replace(workFlow.getGoodsId(), goodsToStation);
+                } else {
+                    GoodsToStation newGoodsToStation = new GoodsToStation();
+                    if (oldGoodsStationsMap.containsKey(workFlow.getGoodsId())) {
+                        // 以前分配过，添加老数据，只更新totalNum与状态
+                        newGoodsToStation.setConfigId(oldGoodsStationsMap.get(workFlow.getGoodsId()).getConfigId());
+                        newGoodsToStation.setTotalNum(oldGoodsStationsMap.get(workFlow.getGoodsId()).getTotalNum().add(workFlow.getNeedNum()));
+                        newGoodsToStation.setDistributeStatus(1);
+                    } else {
+                        newGoodsToStation.setConfigId(generateId(""));
+                        newGoodsToStation.setGoodsId(workFlow.getGoodsId());
+                        newGoodsToStation.setWorkStation(workStation);
+                        newGoodsToStation.setDistributeStatus(0);
+                        newGoodsToStation.setDistributedNum(BigDecimal.ZERO);
+                        newGoodsToStation.setTotalNum(workFlow.getNeedNum());
+                    }
+                    newGoodsToStationMap.put(workFlow.getGoodsId(), newGoodsToStation);
+                }
+            }
+            finalGoodsToStations = newGoodsToStationMap.values().stream().toList();
+            // 以下开始更新数据
+            if (!finalGoodsToStations.isEmpty()) {
+                goodsToStationService.saveOrUpdateBatch(finalGoodsToStations);
+            }
+            // 添加电子标签库位分配数据
+            if (!finalELocationConfigs.isEmpty()) {
+                // 添加电子标签库位配置
+                eLocationConfigService.saveBatch(finalELocationConfigs);
+            }
+            // 更新工作流数据
+            List<String> flowIds = thisTimeDistributeWorkFlows.stream().map(WorkFlow::getWorkFlowId).toList();
+            if (!flowIds.isEmpty()) {
+                workFlowService.update(new LambdaUpdateWrapper<WorkFlow>()
+                        .set(WorkFlow::getWorkStatus, 0)
+                        .set(WorkFlow::getWorkStation, workStation)
+                        .in(WorkFlow::getWorkFlowId, flowIds));
+            }
+        } catch (Exception e) {
+            logger.error("分配站台：{}工作发生异常：{}", workStation, convertJsonString(e));
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+        } finally {
+            // 当前站台创建任务完成
+            workCreatingStations.remove(workStation);
+        }
+    }
+
     /**
      * 新版开始工作
      */