代码更新

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

@@ -20,6 +20,11 @@ import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Isolation;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.interceptor.TransactionAspectSupport;
+
 import static com.wms.utils.StringUtils.convertJsonString;
 
 import java.time.LocalDateTime;
@@ -72,7 +77,14 @@ public class JobComponent {
      * 执行备料任务的轮询，处理站台任务
      */
 //    @Scheduled(fixedDelay = 2000)
+    @Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
     public void checkForOrders() {
+        try {
+
+        } catch (Exception e) {
+            // 回滚事务
+            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
+        }
         // 轮询工作站台，判断是否需要下发任务
         List<Stand> stands = standService.list(new LambdaQueryWrapper<Stand>()
                 .eq(Stand::getStandType, 2));

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

@@ -0,0 +1,28 @@
+package com.wms.entity.app.dto;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * 工单工位Dto
+ */
+@Data
+public class WorkCenterAndOrderDto {
+    /**
+     * 工单
+     */
+    @JsonProperty("workOrder")
+    private String workOrder;
+    /**
+     * 小工位
+     */
+    @JsonProperty("workCenter")
+    private String workCenter;
+    /**
+     * 开工日期
+     */
+    @JsonProperty("startDate")
+    private LocalDateTime startDate;
+}

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

@@ -1,6 +1,7 @@
 package com.wms.entity.table;
 
 import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.Data;
 
@@ -10,6 +11,11 @@ import lombok.Data;
 @Data
 @TableName(value = "tbl_app_e_location_config", autoResultMap = true)
 public class ELocationConfig {
+    /**
+     * 电子标签库位
+     */
+    @TableId("e_location_id")
+    private String eLocationId;
     /**
      * 工站
      */
@@ -26,8 +32,8 @@ public class ELocationConfig {
     @TableField("work_center")
     private String workCenter;
     /**
-     * 电子标签库位
+     * 盒子号
      */
-    @TableField("e_location_id")
+    @TableField("order_box_no")
-    private String eLocationId;
+    private String orderBoxNo;
 }

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

@@ -30,6 +30,8 @@ public class ETagLocation {
     private Integer sequenceId;
     /**
      * 电子标签状态
+     * 0：可用
+     * 1：不可用
      */
     @TableField("e_location_status")
     private Integer eLocationStatus;

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

@@ -76,9 +76,10 @@ public class KateOrders {
     /**
      * 工单状态
      * 0：未开始
-     * 1：已呼叫料箱
+     * 1：已生成任务
-     * 2：正在拣选
+     * 2：已呼叫料箱
-     * 3：拣选完成
+     * 3：正在拣选
+     * 4：拣选完成
      */
     @TableField("order_status")
     private Integer orderStatus;

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.LocalDateTime;
 
 /**
  * 工作站台-工单-工位的工作流
@@ -18,6 +19,11 @@ public class WorkFlow {
      */
     @TableId("work_flow_id")
     private String workFlowId;
+    /**
+     * 外键，工单表id
+     */
+    @TableField("order_id")
+    private String orderId;
     /**
      * 工作站台
      */
@@ -64,4 +70,14 @@ public class WorkFlow {
      */
     @TableField("work_status")
     private Integer workStatus;
+    /**
+     * 任务创建时间
+     */
+    @TableField("create_time")
+    private LocalDateTime createTime;
+    /**
+     * 任务完成时间
+     */
+    @TableField("finish_time")
+    private LocalDateTime finishTime;
 }

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

@@ -8,13 +8,13 @@ public interface IWorkService {
      * 创建工作
      * @param workStation 工作站台
      */
-    void createWork(String workStation);
+    void createWork(String workStation) throws Exception;
 
     /**
      * 执行工作
      * @param workStation 工作站台
      */
-    void doWork(String workStation);
+    void doWork(String workStation) throws Exception;
 
     /**
      * 完成工作

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

@@ -1,15 +1,23 @@
 package com.wms.service.business.serviceImplements;
 
-import com.wms.entity.table.WorkStationConfig;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
-import com.wms.service.WorkFlowService;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
-import com.wms.service.WorkStationConfigService;
+import com.wms.entity.app.dto.WorkCenterAndOrderDto;
+import com.wms.entity.table.*;
+import com.wms.service.*;
 import com.wms.service.business.IWorkService;
+import com.wms.utils.StringUtils;
+import com.wms.utils.WmsUtils;
 import lombok.RequiredArgsConstructor;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
-import java.util.ArrayList;
+import java.math.BigDecimal;
-import java.util.List;
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static com.wms.config.InitLocalConfig.configMap;
 
 /**
  * 工作服务接口的实现
@@ -19,47 +27,268 @@ import java.util.List;
 public class WorkServiceImplements implements IWorkService {
     private final WorkStationConfigService workStationConfigService;// 工作站配置服务
     private final WorkFlowService workFlowService;// 工作流服务
+    private final KateDBSService kateDBSService;// DBS服务
+    private final KateOrdersService kateOrdersService;// 工单服务
+    private final ETagLocationService eTagLocationService;// 电子标签服务
+    private final ELocationConfigService eLocationConfigService;// 电子标签配置服务
+    private final GoodsToStationService goodsToStationService;// 站台要料服务
+    private final OutsideVehiclesService outsideVehiclesService;// 流转中的箱子服务
+    private final List<String> workCreatingStations = new ArrayList<>();// 当前正在创建任务的站台
+    private final List<String> workDoingStations = new ArrayList<>();// 当前正在执行任务的站台
     @Override
-    public void createWork(String workStation) {
+    public void createWork(String workStation) throws Exception {
-        // 当前站台分配的工位
+        if (workCreatingStations.contains(workStation)) {
-        List<WorkStationConfig> currentStationWorkConfigs = new ArrayList<>();
+            // 当前站台正在创建任务
-        // 先找NWL机型
-        findNwl(workStation, currentStationWorkConfigs);
-        if (currentStationWorkConfigs.isEmpty()) {
-            // 找非NWL机型
-            findNotNwl(workStation, currentStationWorkConfigs);
-        }
-        // 然后判断是否还是为空
-        if (currentStationWorkConfigs.isEmpty()) {
             return;
+        } else {
+            // 添加站台
+            workCreatingStations.add(workStation);
+        }
+        if (StringUtils.isEmpty(workStation)) {
+            // 站台号为空
+            return;
+        }
+        try {
+            // 先查看当前站台已经生成的工作流是否为空
+            List<WorkFlow> currentWorkFlowList = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
+                    .eq(WorkFlow::getWorkStation, workStation));
+            // 当前站台的工作流中还存在其他任务
+            if (currentWorkFlowList != null && !currentWorkFlowList.isEmpty()) {
+                return;
+            }
+            // 当前站台分配的工位
+            List<WorkFlow> currentStationWorkFlows = new ArrayList<>();
+            // 先找NWL机型
+            findWorks(workStation, currentStationWorkFlows, "NWL");
+            if (currentStationWorkFlows.isEmpty()) {
+                // 找非NWL机型
+                findWorks(workStation, currentStationWorkFlows, "NOT_NWL");
+            }
+            // 如果当前站台有任务
+            if (!currentStationWorkFlows.isEmpty()) {
+                // 将工作流列表添加进数据库
+                workFlowService.saveBatch(currentStationWorkFlows);
+                // 获得工单列表
+                List<String> workOrderList = new ArrayList<>();
+                // 获得工单以及小工位列表
+                List<String> boxNoList = new ArrayList<>();
+                // 要料Map
+                Map<String, BigDecimal> needGoodsMap = new HashMap<>();
+                for (WorkFlow tempWorkflow : currentStationWorkFlows) {
+                    // 添加工单
+                    if (!workOrderList.contains(tempWorkflow.getWorkOrder())) {
+                        workOrderList.add(tempWorkflow.getWorkOrder());
+                    }
+                    // 添加盒子配置
+                    String boxNo = tempWorkflow.getWorkOrder() + "-" + tempWorkflow.getWorkCenter();
+                    if (!boxNoList.contains(boxNo)) {
+                        boxNoList.add(boxNo);
+                    }
+                    // 添加要料信息
+                    if (!needGoodsMap.containsKey(tempWorkflow.getGoodsId())) {
+                        // 添加物料信息
+                        needGoodsMap.put(tempWorkflow.getGoodsId(), tempWorkflow.getNeedNum());
+                    } else {
+                        // 增加需求数量
+                        needGoodsMap.replace(tempWorkflow.getGoodsId(), needGoodsMap.get(tempWorkflow.getGoodsId()).add(tempWorkflow.getNeedNum()));
+                    }
+                }
+                // 站台要料
+                List<GoodsToStation> goodsToStationList = new ArrayList<>();
+                for (String goodsId : needGoodsMap.keySet()) {
+                    GoodsToStation goodsToStation = new GoodsToStation();
+                    goodsToStation.setGoodsId(goodsId);
+                    goodsToStation.setWorkStation(workStation);
+                    goodsToStation.setDistributeStatus(0);
+                    goodsToStation.setTotalNum(needGoodsMap.get(goodsId));
+                    goodsToStationList.add(goodsToStation);
+                }
+                // 将站台要料列表存进数据库
+                goodsToStationService.saveBatch(goodsToStationList);
+                // 更新工单表
+                List<String> orderIds = currentStationWorkFlows.stream().map(WorkFlow::getOrderId).toList();
+                kateOrdersService.update(new LambdaUpdateWrapper<KateOrders>()
+                        .set(KateOrders::getOrderStatus, 1)
+                        .in(KateOrders::getOrderId, orderIds)
+                        .eq(KateOrders::getOrderStatus, 0));
+                // 更新dbs表
+                kateDBSService.update(new LambdaUpdateWrapper<KateDBS>()
+                        .set(KateDBS::getDbsStatus, 1)
+                        .in(KateDBS::getWorkOrder, workOrderList)
+                        .eq(KateDBS::getDbsStatus, 0));
+                // 电子标签库位配置
+                List<ELocationConfig> eLocationConfigList = new ArrayList<>();
+                // 查找到当前站台所有可用的电子标签
+                List<ETagLocation> eTagLocationList = eTagLocationService.list(new LambdaQueryWrapper<ETagLocation>()
+                        .eq(ETagLocation::getWorkStation, workStation)
+                        .eq(ETagLocation::getELocationStatus, 0)
+                        .orderByAsc(ETagLocation::getSequenceId));
+                if (eTagLocationList.isEmpty() || eTagLocationList.size() < boxNoList.size()) {
+                    throw new Exception("站台：" + workStation + "没有足够可用的电子标签位!");
+                }
+                for (ETagLocation eTagLocation : eTagLocationList) {
+                    if (!boxNoList.isEmpty()) {
+                        String tempBoxNo = boxNoList.get(0);
+                        ELocationConfig eLocationConfig = new ELocationConfig();
+                        eLocationConfig.setWorkOrder(tempBoxNo.split("-")[0]);
+                        eLocationConfig.setWorkCenter(tempBoxNo.split("-")[1]);
+                        eLocationConfig.setWorkStation(workStation);
+                        eLocationConfig.setELocationId(eTagLocation.getELocationId());
+                        eLocationConfig.setOrderBoxNo(tempBoxNo);
+                        // 添加配置
+                        eLocationConfigList.add(eLocationConfig);
+                        // 移除已经分配的盒子
+                        boxNoList.remove(tempBoxNo);
+                    }
+                }
+                // 将电子标签库位配置存进数据库
+                eLocationConfigService.saveBatch(eLocationConfigList);
+            }
+        } catch (Exception e) {
+            throw new Exception("创建站台：" + workStation + "工作发生异常!");
+        } finally {
+            // 当前站台创建任务完成
+            workCreatingStations.remove(workStation);
         }
     }
 
     @Override
-    public void doWork(String workStation) {
+    public void doWork(String workStation) throws Exception {
+        if (workDoingStations.contains(workStation)) {
+            // 当前站台正在创建任务
+            return;
+        } else {
+            // 添加站台
+            workDoingStations.add(workStation);
+        }
+        try {
+            // 查找当前站台未开始的工作流
+            List<WorkFlow> currentWorkFlowList = workFlowService.list(new LambdaQueryWrapper<WorkFlow>()
+                    .eq(WorkFlow::getWorkStation, workStation)
+                    .eq(WorkFlow::getWorkStatus, 0));
+            // 没有可做的任务
+            if (currentWorkFlowList == null || currentWorkFlowList.isEmpty()) {
+                return;
+            }
+            // 查站台要料表---未分配以及分配但未完全分配
+            List<GoodsToStation> goodsToStationList = goodsToStationService.list(new LambdaQueryWrapper<GoodsToStation>()
+                    .eq(GoodsToStation::getWorkStation, workStation)
+                    .eq(GoodsToStation::getDistributeStatus, 0)
+                    .or().eq(GoodsToStation::getDistributeStatus, 1));
+            for (GoodsToStation goodsToStation : goodsToStationList) {
+                // 判断当前物料是否在流转中
+                List<OutsideVehicles> outsideVehiclesList = outsideVehiclesService.list(new LambdaQueryWrapper<OutsideVehicles>()
+                        .eq(OutsideVehicles::getGoodsId, goodsToStation.getGoodsId())
+                        .gt(OutsideVehicles::getRemainNum, 0));
+            }
+            // 查流转中的箱子和物料表
 
+            // 判断是否需要生成出库任务
+            // 生成拣货任务
+            // 修改状态
+        } catch (Exception e) {
+            throw new Exception("执行站台：" + workStation + "工作发生异常!");
+        } finally {
+            // 当前站台创建任务完成
+            workDoingStations.remove(workStation);
+        }
     }
 
     @Override
     public void finishWork(String workStation) {
-
+        // TODO
     }
 
     /**
      * 先找到MWL的小工位的配置
      * @param workStation 工站
-     * @param workConfigs 工位配置
+     * @param workFlows 工作流/工作任务
+     * @param model 机型
      */
-    private void findNwl(String workStation, List<WorkStationConfig> workConfigs) {
+    private void findWorks(String workStation, List<WorkFlow> workFlows, String model) {
-        workConfigs.add(new WorkStationConfig());
+        // 查到当前站台所有的小工位
-    }
+        List<WorkStationConfig> currentStationConfigsOfNwl = workStationConfigService.list(new LambdaQueryWrapper<WorkStationConfig>()
-
+                .eq(WorkStationConfig::getWorkStation, workStation)
-    /**
+                .eq(Objects.equals(model, "NWL"), WorkStationConfig::getModel, model)
-     * 先找到非MWL的小工位的配置
+                .ne(!Objects.equals(model, "NWL"), WorkStationConfig::getModel, "NWL"));
-     * @param workStation 工站
+        // 当前站台未分配库位
-     * @param workConfigs 工位配置
+        if (currentStationConfigsOfNwl == null || currentStationConfigsOfNwl.isEmpty()) {
-     */
+            return;
-    private void findNotNwl(String workStation, List<WorkStationConfig> workConfigs) {
+        }
-        workConfigs.add(new WorkStationConfig());
+        // 今日开工的工单和小工位
+        Map<String, WorkCenterAndOrderDto> tasksOfTodayMap = new HashMap<>();
+        // 防止重复查询
+        Map<String, KateDBS> ordersAndDBSMap = new HashMap<>();
+        // 根据所有小工位，查到对应的任务
+        for (WorkStationConfig workConfig : currentStationConfigsOfNwl) {
+            // 查询当前小工位是否已经判断过开工日期
+            if (StringUtils.isEmpty(workConfig.getSmallBox()) || tasksOfTodayMap.containsKey(workConfig.getSmallBox())) {
+                continue;
+            }
+            // 通过工单表查询到对应的工单
+            List<KateOrders> kateWorkOrders = kateOrdersService.list(new LambdaQueryWrapper<KateOrders>()
+                    .eq(KateOrders::getSupplyArea, workConfig.getSmallBox())
+                    .eq(KateOrders::getOrderStatus, 0)
+                    .eq(KateOrders::getSLoc, configMap.get("SLOC_FILTER_STRING")));
+            // 当前工位没有未完成的工单
+            if (kateWorkOrders == null || kateWorkOrders.isEmpty()) {
+                continue;
+            }
+            for (KateOrders kateWorkOrder : kateWorkOrders) {
+                KateDBS kateDBS;
+                if (!ordersAndDBSMap.containsKey(kateWorkOrder.getWorkOrder())) {
+                    kateDBS = ordersAndDBSMap.get(kateWorkOrder.getWorkOrder());
+                } else {
+                    // 从DBS表查询对应的工单以及开工时间
+                    kateDBS = kateDBSService.getOne(new LambdaQueryWrapper<KateDBS>()
+                            .eq(KateDBS::getWorkOrder, kateWorkOrder.getWorkOrder())
+                            .ne(KateDBS::getDbsStatus, 2)
+                            .orderByAsc(KateDBS::getWorkSequence));
+                }
+                if (kateDBS == null || StringUtils.isEmpty(kateDBS.getWorkOrder())) {// 不存在对应的工单计划
+                    continue;
+                }
+                // 判断是否是当天开工
+                if (kateDBS.getPlanStartDate().plusDays(workConfig.getStartDateAdjust()).toLocalDate().isEqual(LocalDateTime.now().toLocalDate())) {
+                    // 已经查询过的为了不重复查询，添加map
+                    ordersAndDBSMap.put(kateWorkOrder.getWorkOrder(), kateDBS);
+                    // 添加工作计划
+                    WorkCenterAndOrderDto wcoDto = new WorkCenterAndOrderDto();
+                    wcoDto.setWorkCenter(workConfig.getSmallBox());
+                    wcoDto.setWorkOrder(kateWorkOrder.getWorkOrder());
+                    wcoDto.setStartDate(LocalDateTime.now().toLocalDate().atStartOfDay());
+                    // 减少后续重复查询数据库
+                    tasksOfTodayMap.put(workConfig.getSmallBox(), wcoDto);
+                }
+            }
+        }
+        // 判断是否有今天开工的工单和小工位
+        if (!tasksOfTodayMap.isEmpty()) {
+            for (String smallBoxKey : tasksOfTodayMap.keySet()) {
+                WorkCenterAndOrderDto currentWorkCenterAndOrderDto = tasksOfTodayMap.get(smallBoxKey);
+                // 通过工单表查询到对应的工单
+                List<KateOrders> kateWorkOrderList = kateOrdersService.list(new LambdaQueryWrapper<KateOrders>()
+                        .eq(KateOrders::getWorkOrder, currentWorkCenterAndOrderDto.getWorkOrder())
+                        .eq(KateOrders::getSupplyArea, currentWorkCenterAndOrderDto.getWorkCenter())
+                        .eq(KateOrders::getOrderStatus, 0)
+                        .eq(KateOrders::getSLoc, configMap.get("SLOC_FILTER_STRING")));
+                for (KateOrders tempOrder : kateWorkOrderList) {
+                    // 生成workFlow
+                    WorkFlow tempWorkFlow = new WorkFlow();
+                    tempWorkFlow.setWorkFlowId(WmsUtils.generateId("WORKFLOW_"));
+                    tempWorkFlow.setOrderId(tempOrder.getOrderId());
+                    tempWorkFlow.setWorkStation(workStation);
+                    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);
+                    workFlows.add(tempWorkFlow);
+                }
+            }
+        }
     }
 }

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

@@ -4,11 +4,14 @@ import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.wms.entity.table.ELocationConfig;
 import com.wms.mapper.ELocationConfigMapper;
 import com.wms.service.ELocationConfigService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 /**
  * 电子标签库位配置服务实现
  */
 @Service
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
 public class ELocationConfigServiceImpl extends ServiceImpl<ELocationConfigMapper, ELocationConfig> implements ELocationConfigService {
 }

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

@@ -4,11 +4,14 @@ import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.wms.entity.table.ETagLocation;
 import com.wms.mapper.ETagLocationMapper;
 import com.wms.service.ETagLocationService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 /**
  * 电子标签服务实现
  */
 @Service
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
 public class ETagLocationServiceImpl extends ServiceImpl<ETagLocationMapper, ETagLocation> implements ETagLocationService {
 }

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

@@ -4,11 +4,14 @@ import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.wms.entity.table.GoodsToStation;
 import com.wms.mapper.GoodsToStationMapper;
 import com.wms.service.GoodsToStationService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 /**
  * 站台要料服务实现
  */
 @Service
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
 public class GoodsToStationServiceImpl extends ServiceImpl<GoodsToStationMapper, GoodsToStation> implements GoodsToStationService {
 }

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

@@ -4,11 +4,14 @@ import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.wms.entity.table.KateDBSHistory;
 import com.wms.mapper.KateDBSHistoryMapper;
 import com.wms.service.KateDBSHistoryService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 /**
  * 卡特DBS历史记录服务实现
  */
 @Service
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
 public class KateDBSHistoryServiceImpl extends ServiceImpl<KateDBSHistoryMapper, KateDBSHistory> implements KateDBSHistoryService {
 }

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

@@ -4,11 +4,14 @@ import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.wms.entity.table.KateDBSLast;
 import com.wms.mapper.KateDBSLastMapper;
 import com.wms.service.KateDBSLastService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 /**
  * 上一次卡特DBS服务接口
  */
 @Service
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
 public class KateDBSLastServiceImpl extends ServiceImpl<KateDBSLastMapper, KateDBSLast> implements KateDBSLastService {
 }

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

@@ -4,11 +4,14 @@ import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.wms.entity.table.KateDBS;
 import com.wms.mapper.KateDBSMapper;
 import com.wms.service.KateDBSService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 /**
  * 卡特DBS服务实现
  */
 @Service
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
 public class KateDBSServiceImpl extends ServiceImpl<KateDBSMapper, KateDBS> implements KateDBSService {
 }

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

@@ -4,11 +4,14 @@ import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.wms.entity.table.KateOrdersHistory;
 import com.wms.mapper.KateOrdersHistoryMapper;
 import com.wms.service.KateOrdersHistoryService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 /**
  * 卡特历史工单服务实现
  */
 @Service
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
 public class KateOrdersHistoryServiceImpl extends ServiceImpl<KateOrdersHistoryMapper, KateOrdersHistory> implements KateOrdersHistoryService {
 }

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

@@ -4,11 +4,14 @@ import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.wms.entity.table.KateOrdersLast;
 import com.wms.mapper.KateOrdersLastMapper;
 import com.wms.service.KateOrdersLastService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 /**
  * 上一次导入的卡特工单服务实现
  */
 @Service
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
 public class KateOrdersLastServiceImpl extends ServiceImpl<KateOrdersLastMapper, KateOrdersLast> implements KateOrdersLastService {
 }

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

@@ -4,11 +4,14 @@ import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.wms.entity.table.KateOrders;
 import com.wms.mapper.KateOrdersMapper;
 import com.wms.service.KateOrdersService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 /**
  * 卡特工单服务实现
  */
 @Service
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
 public class KateOrdersServiceImpl extends ServiceImpl<KateOrdersMapper, KateOrders> implements KateOrdersService {
 }

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

@@ -4,11 +4,14 @@ import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.wms.entity.table.OutsideVehicles;
 import com.wms.mapper.OutsideVehiclesMapper;
 import com.wms.service.OutsideVehiclesService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 /**
  * 流转中的载具物料服务实现
  */
 @Service
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
 public class OutsideVehiclesServiceImpl extends ServiceImpl<OutsideVehiclesMapper, OutsideVehicles> implements OutsideVehiclesService {
 }

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

@@ -4,11 +4,14 @@ import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.wms.entity.table.PickTaskRecord;
 import com.wms.mapper.PickTaskRecordMapper;
 import com.wms.service.PickTaskRecordService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 /**
  * 拣货任务记录服务实现
  */
 @Service
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
 public class PickTaskRecordServiceImpl extends ServiceImpl<PickTaskRecordMapper, PickTaskRecord> implements PickTaskRecordService {
 }

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

@@ -4,11 +4,14 @@ import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.wms.entity.table.PickTask;
 import com.wms.mapper.PickTaskMapper;
 import com.wms.service.PickTaskService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 /**
  * 拣货任务服务实现类
  */
 @Service
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
 public class PickTaskServiceImpl extends ServiceImpl<PickTaskMapper, PickTask> implements PickTaskService {
 }

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

@@ -4,11 +4,14 @@ import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.wms.entity.table.WorkFlow;
 import com.wms.mapper.WorkFlowMapper;
 import com.wms.service.WorkFlowService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 /**
  * 工作流服务实现
  */
 @Service
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
 public class WorkFlowServiceImpl extends ServiceImpl<WorkFlowMapper, WorkFlow> implements WorkFlowService {
 }

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

@@ -4,11 +4,14 @@ import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.wms.entity.table.WorkStationConfig;
 import com.wms.mapper.WorkStationConfigMapper;
 import com.wms.service.WorkStationConfigService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 /**
  * 工站配置服务实现类
  */
 @Service
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
 public class WorkStationConfigServiceImpl extends ServiceImpl<WorkStationConfigMapper, WorkStationConfig> implements WorkStationConfigService {
 }

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

@@ -4,11 +4,14 @@ import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.wms.entity.table.WorkSummary;
 import com.wms.mapper.WorkSummaryMapper;
 import com.wms.service.WorkSummaryService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 /**
  * 工作总结服务实现
  */
 @Service
+@RequiredArgsConstructor(onConstructor = @__(@Autowired))
 public class WorkSummaryServiceImpl extends ServiceImpl<WorkSummaryMapper, WorkSummary> implements WorkSummaryService {
 }