FeiDaBaoKai/wms_server_kate_suzhou
11
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

代码更新

Browse Source
This commit is contained in:
梁州 2024-07-17 17:11:49 +08:00
parent d3b1445cda
commit 4fc4a7e0aa
23 changed files with 377 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/main/java/com/wms/controller/JobComponent.java
View File

@ -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));

28
src/main/java/com/wms/entity/app/dto/WorkCenterAndOrderDto.java Normal file
View File

@ -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;
}

12
src/main/java/com/wms/entity/table/ELocationConfig.java
View File

@ -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")
private String eLocationId;
@TableField("order_box_no")
private String orderBoxNo;
}

2
src/main/java/com/wms/entity/table/ETagLocation.java
View File

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

7
src/main/java/com/wms/entity/table/KateOrders.java
View File

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

16
src/main/java/com/wms/entity/table/WorkFlow.java
View File

@ -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;
}

4
src/main/java/com/wms/service/business/IWorkService.java
View File

@ -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;
/**
* 完成工作

289
src/main/java/com/wms/service/business/serviceImplements/WorkServiceImplements.java
View File

@ -1,15 +1,23 @@
package com.wms.service.business.serviceImplements;
import com.wms.entity.table.WorkStationConfig;
import com.wms.service.WorkFlowService;
import com.wms.service.WorkStationConfigService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
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.util.List;
import java.math.BigDecimal;
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) {
// 当前站台分配的工位
List<WorkStationConfig> currentStationWorkConfigs = new ArrayList<>();
// 先找NWL机型
findNwl(workStation, currentStationWorkConfigs);
if (currentStationWorkConfigs.isEmpty()) {
// 找非NWL机型
findNotNwl(workStation, currentStationWorkConfigs);
}
// 然后判断是否还是为空
if (currentStationWorkConfigs.isEmpty()) {
public void createWork(String workStation) throws Exception {
if (workCreatingStations.contains(workStation)) {
// 当前站台正在创建任务
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) {
workConfigs.add(new WorkStationConfig());
}
/**
* 先找到非MWL的小工位的配置
* @param workStation 工站
* @param workConfigs 工位配置
*/
private void findNotNwl(String workStation, List<WorkStationConfig> workConfigs) {
workConfigs.add(new WorkStationConfig());
private void findWorks(String workStation, List<WorkFlow> workFlows, String model) {
// 查到当前站台所有的小工位
List<WorkStationConfig> currentStationConfigsOfNwl = workStationConfigService.list(new LambdaQueryWrapper<WorkStationConfig>()
.eq(WorkStationConfig::getWorkStation, workStation)
.eq(Objects.equals(model, "NWL"), WorkStationConfig::getModel, model)
.ne(!Objects.equals(model, "NWL"), WorkStationConfig::getModel, "NWL"));
// 当前站台未分配库位
if (currentStationConfigsOfNwl == null || currentStationConfigsOfNwl.isEmpty()) {
return;
}
// 今日开工的工单和小工位
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);
}
}
}
}
}

3
src/main/java/com/wms/service/serviceImplements/ELocationConfigServiceImpl.java
View File

@ -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 {
}

3
src/main/java/com/wms/service/serviceImplements/ETagLocationServiceImpl.java
View File

@ -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 {
}

3
src/main/java/com/wms/service/serviceImplements/GoodsToStationServiceImpl.java
View File

@ -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 {
}

3
src/main/java/com/wms/service/serviceImplements/KateDBSHistoryServiceImpl.java
View File

@ -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 {
}

3
src/main/java/com/wms/service/serviceImplements/KateDBSLastServiceImpl.java
View File

@ -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 {
}

3
src/main/java/com/wms/service/serviceImplements/KateDBSServiceImpl.java
View File

@ -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 {
}

3
src/main/java/com/wms/service/serviceImplements/KateOrdersHistoryServiceImpl.java
View File

@ -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 {
}

3
src/main/java/com/wms/service/serviceImplements/KateOrdersLastServiceImpl.java
View File

@ -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 {
}

3
src/main/java/com/wms/service/serviceImplements/KateOrdersServiceImpl.java
View File

@ -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 {
}

3
src/main/java/com/wms/service/serviceImplements/OutsideVehiclesServiceImpl.java
View File

@ -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 {
}

3
src/main/java/com/wms/service/serviceImplements/PickTaskRecordServiceImpl.java
View File

@ -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 {
}

3
src/main/java/com/wms/service/serviceImplements/PickTaskServiceImpl.java
View File

@ -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 {
}

3
src/main/java/com/wms/service/serviceImplements/WorkFlowServiceImpl.java
View File

@ -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 {
}

3
src/main/java/com/wms/service/serviceImplements/WorkStationConfigServiceImpl.java
View File

@ -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 {
}

3
src/main/java/com/wms/service/serviceImplements/WorkSummaryServiceImpl.java
View File

@ -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 {
}