luyifan/wms-serve-mule
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

<fix>[important]基本测试版本，已完成和其他系统交互feat(wms_serve): 实现空托盘入库和补盘功能

Browse Source 
- 实现空托盘入库逻辑，包括生成虚拟托盘号和创建入库任务
- 添加补盘功能，处理空托盘出库和创建出库任务
This commit is contained in:
葛林强 2024-07-18 13:26:56 +08:00 committed by Huluwa22
parent 0c5613e6dc
commit 42635073fe
71 changed files with 4154 additions and 808 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
pom.xml
View File

@ -132,11 +132,6 @@
<artifactId>springfox-swagger-ui</artifactId>
<version>2.9.2</version>
</dependency>
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-core</artifactId>
<version>9.0.68</version>
</dependency>
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-core</artifactId>

266
src/main/java/com/wms/bussiness/JobComponent.java
View File

@ -1,16 +1,19 @@
package com.wms.bussiness;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.wms.constants.enums.*;
import com.wms.controller.BaseController;
import com.wms.entity.app.ResponseEntity;
import com.wms.entity.app.container.ContainerApiLocalResponse;
import com.wms.entity.app.container.CreateInstoreTaskRequest;
import com.wms.entity.app.container.SendContainerTaskRequest;
import com.wms.entity.app.wcs.WcsTask;
import com.wms.entity.table.*;
import com.wms.mapper.LocationMapper;
import com.wms.mapper.StockMapper;
import com.wms.mapper.TaskMapper;
import com.wms.mapper.VehicleMapper;
import com.wms.service.*;
import com.wms.utils.HttpUtils;
import com.wms.utils.StringUtils;
@ -71,6 +74,7 @@ public class JobComponent extends BaseController {
private final StockService stockService;
private final TaskRecordService taskRecordService;
private final StockMapper stockMapper;
private final VehicleMapper vehicleMapper;
@Scheduled(fixedDelay = 1000)
@ -85,11 +89,11 @@ public class JobComponent extends BaseController {
return;
}
for(Task task : tasks){
if(task.getTaskType().equals(TaskType.IN.getCode())|| task.getTaskType().equals(TaskType.INVENTORY.getCode())){
if(task.getTaskType().equals(TaskType.IN.getCode())) {
sendTasksInToWcs(task);
return;
}
if(task.getTaskType().equals(TaskType.OUT.getCode())){
if(task.getTaskType().equals(TaskType.OUT.getCode()) || task.getTaskType().equals(TaskType.INVENTORY.getCode())){
sendTasksOutToWcs(task);
return;
}
@ -99,7 +103,7 @@ public class JobComponent extends BaseController {
}
}
}catch (Exception exception){
logger.error("定时器下发任务发生异常：{}", exception.getMessage());
logger.error("定时器下发任务发生异常：{}", exception.toString());
}
}
@ -108,28 +112,78 @@ public class JobComponent extends BaseController {
* @param task 任务
*/
private void sendTasksInToWcs(Task task) {
List<WcsTask> request = new ArrayList<>();
// 创建发送的任务
WcsTask tempTask = new WcsTask();
tempTask.setTaskId(task.getTaskGroup());
tempTask.setTaskType(TaskType.IN.getCode());
tempTask.setOrigin(task.getOrigin());
tempTask.setDestination(task.getDestination());
tempTask.setVehicleNo(task.getVehicleNo());
tempTask.setVehicleSize(1);
tempTask.setWeight(task.getWeight() == null ? 0 : task.getWeight());
tempTask.setPriority(task.getTaskPriority());
request.add(tempTask);
// 发送任务
ResponseEntity result = JSON.parseObject(HttpUtils.sendHttpPostWithoutToken(UrlEnums.URL_WMS_TO_WCS_SEND_TASK.getValue(), JSON.toJSONString(request)), ResponseEntity.class);
if (result != null && Objects.equals(ResponseCode.OK.getCode(), result.getCode())) {
logger.info("下发入库任务成功，任务ID：{}", tempTask.getTaskId());
Task taskForUpdate = new Task();
taskForUpdate.setTaskId(task.getTaskId());
taskForUpdate.setTaskStatus(WmsTaskStatus.WAIT.getCode());
taskService.executeTask(taskForUpdate);
try {
List<Location> thisLocations = locationService.selLocations(new Location(task.getDestination()));
if(thisLocations == null) {
logger.warn("下发入库任务查询库位详细信息失败，数据库网络连接异常，任务号：{}", task.getTaskId());
return;
}
if(thisLocations.isEmpty()) {
logger.warn("下发入库任务查询库位详细信息异常，不存在详细信息，该库位可能不存在，任务号：{}", task.getTaskId());
Task taskForUpdate = new Task();
taskForUpdate.setTaskId(task.getTaskId());
taskForUpdate.setTaskStatus(WmsTaskStatus.EXCEPTION.getCode());
taskForUpdate.setRemark1("该库位不存在");
taskService.executeTask(taskForUpdate);
return;
}
Location thisLocation = thisLocations.get(0);
if(thisLocation.getAreaId() == 1){
List<WcsTask> request = new ArrayList<>();
// 创建发送的任务
WcsTask tempTask = new WcsTask();
tempTask.setTaskId(task.getTaskId());
tempTask.setTaskType(TaskType.IN.getCode());
tempTask.setOrigin(task.getOrigin());
tempTask.setDestination(task.getDestination());
tempTask.setVehicleNo(task.getVehicleNo());
tempTask.setVehicleSize(1);
tempTask.setWeight(task.getWeight() == null ? 0 : task.getWeight());
tempTask.setPriority(task.getTaskPriority());
request.add(tempTask);
// 发送任务
ResponseEntity result = JSON.parseObject(HttpUtils.sendHttpPostWithoutToken(UrlEnums.URL_WMS_TO_WCS_SEND_TASK.getValue(), JSON.toJSONString(request)), ResponseEntity.class);
if (result != null && Objects.equals(ResponseCode.OK.getCode(), result.getCode())) {
logger.info("下发立库入库任务成功，任务ID：{}，任务信息：{}", tempTask.getTaskId(), JSON.toJSONString(request));
Task taskForUpdate = new Task();
taskForUpdate.setTaskId(task.getTaskId());
taskForUpdate.setTaskStatus(WmsTaskStatus.WAIT.getCode());
taskService.executeTask(taskForUpdate);
return;
}
logger.info("下发立库入库任务失败，任务ID：{}，信息：{}", tempTask.getTaskId(), JSON.toJSONString(result));
}
// else { //四向车库
// //List<WcsTask> request = new ArrayList<>();
// // 创建发送的任务
// String uuid = UUID.randomUUID().toString();
// CreateInstoreTaskRequest request = new CreateInstoreTaskRequest();
// request.setRequestId(uuid);
// request.setKey(StringUtils.containerMd5(uuid).toUpperCase());
// request.setPalletNo(task.getVehicleNo());
// request.setHeight("0");
// request.setWeight("0");
// request.setFromCellNo(task.getOrigin());
// // 发送任务
// String requestString = JSON.toJSONString(request);
// String responseString = HttpUtils.sendHttpPostWithoutToken(UrlEnums.URL_WMS_TO_WCS_CONTAINERIN_TASK.getValue(), requestString);
// if (responseString == null || responseString.isEmpty()) {
// logger.error("Response string is null or empty");
// }
// ContainerApiLocalResponse result = JSON.parseObject(responseString, ContainerApiLocalResponse.class);
// if (result != null && result.getCode().equals("200")) {
// logger.info("下发托盘库入库任务成功，任务ID：{}", task.getTaskId());
// Task taskForUpdate = new Task();
// taskForUpdate.setTaskId(task.getTaskId());
// taskForUpdate.setTaskStatus(WmsTaskStatus.WAIT.getCode());
// taskService.executeTask(taskForUpdate);
// return;
// }
// logger.info("下发托盘库入库任务失败，任务ID：{}，信息：{}", task.getTaskId(), JSON.toJSONString(result));
// }
}catch (Exception exception){
logger.error("下发入库任务发生异常：{}", exception.toString());
}
logger.info("下发入库任务失败，任务ID：{}，信息：{}", tempTask.getTaskId(), JSON.toJSONString(result));
}
/**
@ -141,10 +195,12 @@ public class JobComponent extends BaseController {
List<Location> thisLocations = locationService.selLocations(new Location(task.getOrigin()));
if(thisLocations == null) {
logger.warn("下发出库任务查询库位详细信息失败，数据库网络连接异常，任务号：{}", task.getTaskId());
logger.info("下发出库任务查询库位详细信息失败，数据库网络连接异常");
return;
}
if(thisLocations.isEmpty()) {
logger.warn("下发出库任务查询库位详细信息异常，不存在详细信息，该库位可能不存在，任务号：{}", task.getTaskId());
logger.info("下发出库任务查询库位详细信息异常，不存在详细信息，该库位可能不存在");
Task taskForUpdate = new Task();
taskForUpdate.setTaskId(task.getTaskId());
taskForUpdate.setTaskStatus(WmsTaskStatus.EXCEPTION.getCode());
@ -158,35 +214,43 @@ public class JobComponent extends BaseController {
depth--;
/* 检查该库位有没有任务，若有则退出函数，若没有则检查有没有库存，若没有库存则继续，若有库存则生成一个移库任务，生成之后退出函数 */
Location beforLocationsQuery = new Location();
// logger.info("{},{},{},{},{}",thisLocation.getAreaId(),thisLocation.getQueue(),thisLocation.getLine(),thisLocation.getLayer(),depth);
beforLocationsQuery.setAreaId(thisLocation.getAreaId());
beforLocationsQuery.setQueue(thisLocation.getQueue());
//beforLocationsQuery.setQueue(thisLocation.getQueue());
beforLocationsQuery.setLine(thisLocation.getLine());
beforLocationsQuery.setLayer(thisLocation.getLayer());
beforLocationsQuery.setLocationType(1);
beforLocationsQuery.setDepth(depth);
List<Location> beforLocations = locationService.selLocations(beforLocationsQuery);
if(beforLocations == null) {
logger.warn("下发出库任务查询库位详细信息失败，数据库网络连接异常，任务号：{}", task.getTaskId());
logger.info("下发出库任务查询库位详细信息失败，数据库网络连接异常");
return;
}
if(beforLocations.isEmpty()) {
logger.info("beforLocations.isEmpty()");
return;
}
Location beforLocation = beforLocations.get(0); // 前一个库位
List<Task> notCompleteTasks = taskMapper.haveNotCompleteTask(beforLocation.getLocationId());
if(notCompleteTasks == null) {
logger.info("notCompleteTasks为null");
return;
}
if(!notCompleteTasks.isEmpty()) {
logger.info("存在未完成的任务，退出函数");
return; // 存在未完成的任务，退出函数
}
// 检查是否有库存、
Stock stockQuery = new Stock();
stockQuery.setLocationId(beforLocation.getLocationId());
List<Stock> stocks = stockService.selStocks(stockQuery);
if(stocks == null) {
// 检查是否有库存，因为存在空框所以不在库存表中检验
Vehicle nextVehicle = new Vehicle();
nextVehicle.setCurrentLocation(beforLocation.getLocationId());
List<Vehicle> beforVehicleCheckIfEmpty = vehicleMapper.selVehicles(nextVehicle);
if(beforVehicleCheckIfEmpty == null) {
logger.info("beforLocationsCheckIfEmpty == null");
return;
}
if(stocks.isEmpty()) {
if(beforVehicleCheckIfEmpty.isEmpty()) {
logger.info("位置{}没有框",beforLocation.getLocationId());
continue; // 没有库存，继续
}
/* 生成一个移库任务 */
@ -196,13 +260,17 @@ public class JobComponent extends BaseController {
emptyLocation.setAreaId(beforLocation.getAreaId());
List<Location> emptyLocations = locationMapper.selLocations(emptyLocation);
if(emptyLocations == null) {
logger.info("emptyLocations == null");
return;
}
if(emptyLocations.isEmpty()){
logger.warn("移库没有可用库位，任务号：{}", task.getTaskId());
logger.info("移库没有可用库位");
return; // 移库没有可用库位
}
Location emptyLocationItem = locationUtils.checkCanUse(emptyLocations); // 取得新库位
if(emptyLocationItem == null) {
logger.info("emptyLocationItem == null");
return; // 没有可用库位或者m库位存在干涉
}
// 锁定旧库位库存
@ -212,26 +280,46 @@ public class JobComponent extends BaseController {
locationForUpdate.setLocationId(emptyLocationItem.getLocationId());
locationForUpdate.setLocationStatus(LocationStatus.OCCUPY.getCode());
locationMapper.modifyLocation(locationForUpdate);
// 构造移库任务
//创建移库任务
Task moveTask = new Task();
moveTask.setTaskId(UUID.randomUUID().toString());
moveTask.setTaskGroup(task.getTaskGroup());
moveTask.setTaskId(String.valueOf(Calendar.getInstance().getTimeInMillis()));
moveTask.setTaskType(TaskType.MOVE.getCode());
moveTask.setTaskGroup(task.getTaskGroup());
moveTask.setTaskStatus(OrderOutStatusEnum.CREATED.getCode());
moveTask.setOrigin(beforLocation.getLocationId());
moveTask.setDestination(emptyLocationItem.getLocationId());
moveTask.setVehicleNo(stocks.get(0).getVehicleId());
moveTask.setVehicleSize(0);
moveTask.setPickStand(null);
moveTask.setWeight(0.0);
moveTask.setTaskPriority(9);
moveTask.setTaskStatus(WmsTaskStatus.NEW.getCode());
taskService.addTask(moveTask);
moveTask.setVehicleNo(beforVehicleCheckIfEmpty.get(0).getVehicleId());
moveTask.setCreateTime(new Date());
moveTask.setUserName("WMS");
if(depth == 2){
moveTask.setTaskPriority(8);
} else if (depth == 1) {
moveTask.setTaskPriority(9);
}
if (beforVehicleCheckIfEmpty.get(0).getIsEmpty() == 1){
moveTask.setRemark1("空框");
}else {
moveTask.setRemark1("带料");
}
int a = taskService.addTask(moveTask);
if (a == 1 && depth == 2){
logger.info("生成移库任务成功，任务号：{}", moveTask.getTaskId());
continue;
} else if (a == 1 && depth == 1) {
return;
} else {
logger.info("生成移库任务失败，任务号：{}", moveTask.getTaskId());
}
return;
}
if(thisLocation.getAreaId() == 1) { // 宝开立库
List<WcsTask> request = new ArrayList<>();
// 创建发送的任务
WcsTask tempTask = new WcsTask();
tempTask.setTaskId(task.getTaskGroup());
tempTask.setTaskId(task.getTaskId());
tempTask.setTaskType(TaskType.OUT.getCode());
tempTask.setOrigin(task.getOrigin());
tempTask.setDestination(task.getDestination());
@ -248,8 +336,9 @@ public class JobComponent extends BaseController {
taskForUpdate.setTaskId(task.getTaskId());
taskForUpdate.setTaskStatus(WmsTaskStatus.WAIT.getCode());
taskService.executeTask(taskForUpdate);
return;
}
logger.info("下发立库出库任务失败，任务ID：{}，信息：{}", tempTask.getTaskId(), JSON.toJSONString(result));
logger.info("下发立库出库任务失败，任务ID：{}，信息：{}，result结果：{}", tempTask.getTaskId(), JSON.toJSONString(result),result.getCode());
} else { // 四向车库
String uuid = UUID.randomUUID().toString();
SendContainerTaskRequest request = new SendContainerTaskRequest();
@ -259,9 +348,10 @@ public class JobComponent extends BaseController {
request.setPalletno(task.getVehicleNo());
request.setTasktype("2"); // 出库
request.setFromcellno(task.getOrigin());
request.setTocellno("A13-34-01"); // A13-34-01;A13-16-01;
request.setTocellno("111"); // ???????
String requestString = JSON.toJSONString(request);
String responseString = HttpUtils.sendHttpPostWithoutToken(UrlEnums.URL_WMS_TO_WCS_CONTAINER_TASK.getValue(), requestString);
//JSONObject jsonResponse = JSON.parseObject(responseString);
ContainerApiLocalResponse result = JSON.parseObject(responseString, ContainerApiLocalResponse.class);
if(result != null && result.getCode().equals("200")) {
logger.info("下发四向车出库任务成功，任务ID：{}", task.getTaskId());
@ -269,6 +359,7 @@ public class JobComponent extends BaseController {
taskForUpdate.setTaskId(task.getTaskId());
taskForUpdate.setTaskStatus(WmsTaskStatus.WAIT.getCode());
taskService.executeTask(taskForUpdate);
return;
}
logger.info("下发四向车出库任务失败，任务ID：{}，信息：{}", task.getTaskId(), JSON.toJSONString(result));
}
@ -278,7 +369,79 @@ public class JobComponent extends BaseController {
* 发送移库任务给WCS
* @param task 任务
*/
private void sendTasksMoveToWcs(Task task) {
private void sendTasksMoveToWcs(Task task){
/* 检查该库位前一个深度是否存在库存，若存在库存则生成一个移库任务，此任务暂不下发 */
List<Location> thisLocations = locationService.selLocations(new Location(task.getOrigin()));
if(thisLocations == null) {
logger.info("下发移库任务查询库位详细信息失败，数据库网络连接异常");
return;
}
if(thisLocations.isEmpty()) {
logger.info("下发移库任务查询库位详细信息异常，不存在详细信息，该库位可能不存在");
Task taskForUpdate = new Task();
taskForUpdate.setTaskId(task.getTaskId());
taskForUpdate.setTaskStatus(WmsTaskStatus.EXCEPTION.getCode());
taskForUpdate.setRemark1("该库位不存在");
taskService.executeTask(taskForUpdate);
return;
}
Location thisLocation = thisLocations.get(0); // 找出当前库位详细信息
int depth = thisLocation.getDepth();
while (depth > 1) {
depth--;
/* 检查该库位有没有任务，若有则退出函数，若没有则检查有没有库存，若没有库存则继续，若有库存则生成一个移库任务，生成之后退出函数 */
Location beforLocationsQuery = new Location();
// logger.info("{},{},{},{},{}",thisLocation.getAreaId(),thisLocation.getQueue(),thisLocation.getLine(),thisLocation.getLayer(),depth);
beforLocationsQuery.setAreaId(thisLocation.getAreaId());
//beforLocationsQuery.setQueue(thisLocation.getQueue());
beforLocationsQuery.setLine(thisLocation.getLine());
beforLocationsQuery.setLayer(thisLocation.getLayer());
beforLocationsQuery.setLocationType(1);
beforLocationsQuery.setDepth(depth);
List<Location> beforLocations = locationService.selLocations(beforLocationsQuery);
if (beforLocations == null) {
logger.info("下发移库任务查询库位详细信息失败，数据库网络连接异常");
return;
}
if (beforLocations.isEmpty()) {
logger.info(".isEmpty()");
return;
}
Location beforLocation = beforLocations.get(0); // 前一个库位
List<Task> notCompleteTasks = taskMapper.haveNotCompleteTask(beforLocation.getLocationId());
if (notCompleteTasks == null) {
logger.info("eteTasks为null");
return;
}
if (!notCompleteTasks.isEmpty()) {
return; // 存在未完成的任务，退出函数
}
}
logger.info("开始发送移库任务给WCS，任务号：{}", task.getTaskId());
String uuid = UUID.randomUUID().toString();
SendContainerTaskRequest request = new SendContainerTaskRequest();
request.setRequestid(uuid);
request.setKey(StringUtils.containerMd5(uuid).toUpperCase());
request.setWmstaskid(task.getTaskId());
request.setPalletno(task.getVehicleNo());
request.setTasktype("3"); // 移库
request.setFromcellno(task.getOrigin());
request.setTocellno(task.getDestination());
String requestString = JSON.toJSONString(request);
String responseString = HttpUtils.sendHttpPostWithoutToken(UrlEnums.URL_WMS_TO_WCS_CONTAINER_TASK.getValue(), requestString);
ContainerApiLocalResponse result = JSON.parseObject(responseString, ContainerApiLocalResponse.class);
if(result != null && result.getCode().equals("200")) {
logger.info("下发四向车移库任务成功，任务ID：{}", task.getTaskId());
Task taskForUpdate = new Task();
taskForUpdate.setTaskId(task.getTaskId());
taskForUpdate.setTaskStatus(WmsTaskStatus.WAIT.getCode());
taskService.executeTask(taskForUpdate);
return;
}
logger.info("下发四向车移库任务失败，任务ID：{}，信息：{}", task.getTaskId(), JSON.toJSONString(result));
}
private void sendTasksMoveToWcs1(Task task) {
/* 检查该库位前一个深度是否存在库存，若存在库存则生成一个移库任务，此任务暂不下发 */
List<Location> thisLocations = locationService.selLocations(new Location(task.getOrigin()));
if(thisLocations == null) {
@ -318,8 +481,11 @@ public class JobComponent extends BaseController {
if(notCompleteTasks == null) {
return;
}
if(!notCompleteTasks.isEmpty()) {
return; // 存在未完成的任务，退出函数
for(Task notCompleteTask : notCompleteTasks) {
String taskId = notCompleteTask.getTaskId();
if(!taskId.equals(task.getTaskId())) {
return;
}
}
// 检查是否有库存、
Stock stockQuery = new Stock();
@ -373,7 +539,7 @@ public class JobComponent extends BaseController {
List<WcsTask> request = new ArrayList<>();
// 创建发送的任务
WcsTask tempTask = new WcsTask();
tempTask.setTaskId(task.getTaskGroup());
tempTask.setTaskId(task.getTaskId());
tempTask.setTaskType(TaskType.MOVE.getCode());
tempTask.setOrigin(task.getOrigin());
tempTask.setDestination(task.getDestination());
@ -390,6 +556,7 @@ public class JobComponent extends BaseController {
taskForUpdate.setTaskId(task.getTaskId());
taskForUpdate.setTaskStatus(WmsTaskStatus.WAIT.getCode());
taskService.executeTask(taskForUpdate);
return;
}
logger.info("下发立库移库任务失败，任务ID：{}，信息：{}", tempTask.getTaskId(), JSON.toJSONString(result));
} else {
@ -406,13 +573,14 @@ public class JobComponent extends BaseController {
String responseString = HttpUtils.sendHttpPostWithoutToken(UrlEnums.URL_WMS_TO_WCS_CONTAINER_TASK.getValue(), requestString);
ContainerApiLocalResponse result = JSON.parseObject(responseString, ContainerApiLocalResponse.class);
if(result != null && result.getCode().equals("200")) {
logger.info("下发四向车移库任务成功，任务ID：{}", task.getTaskId());
// logger.info("下发四向车移库任务成功，任务ID：{}", task.getTaskId());
Task taskForUpdate = new Task();
taskForUpdate.setTaskId(task.getTaskId());
taskForUpdate.setTaskStatus(WmsTaskStatus.WAIT.getCode());
taskService.executeTask(taskForUpdate);
return;
}
logger.info("下发四向车移库任务失败，任务ID：{}，信息：{}", task.getTaskId(), JSON.toJSONString(result));
// logger.info("下发四向车移库任务失败，任务ID：{}，信息：{}", task.getTaskId(), JSON.toJSONString(result));
}
}
@ -532,7 +700,7 @@ public class JobComponent extends BaseController {
* 每天查询一次是否有过期记录
* 每天晚上10点执行一次
*/
@Scheduled(cron = "0 0 22 * * ?")
//@Scheduled(cron = "0 0 22 * * ?")
public void deleteOutOfDateData() {
logger.info("执行定时任务：删除过期数据");
taskRecordService.deleteTaskRecordRegularly();

29
src/main/java/com/wms/bussiness/OrderTimer.java
View File

@ -1,29 +0,0 @@
package com.wms.bussiness;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
/**
* 订单定时器
*/
@Component
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class OrderTimer {
@Scheduled(fixedDelay = 1000)
public void parseOutOrder() {
//解析出库订单 ---- 出库订单已经由api插入数据库
}
}

809
src/main/java/com/wms/bussiness/TaskOperation.java
View File

@ -1,23 +1,29 @@
package com.wms.bussiness;
import com.wms.constants.enums.LocationStatus;
import com.wms.constants.enums.StockStatus;
import com.wms.constants.enums.TaskType;
import com.wms.constants.enums.WmsTaskStatus;
import com.wms.entity.table.Location;
import com.wms.entity.table.Stock;
import com.wms.entity.table.Task;
import com.wms.mapper.LocationMapper;
import com.wms.mapper.StockMapper;
import com.wms.mapper.TaskMapper;
import com.alibaba.fastjson2.JSON;
import com.wms.constants.enums.*;
import com.wms.entity.app.ResponseEntity;
import com.wms.entity.app.mes.*;
import com.wms.entity.app.wcs.WmsReceiveTaskResultEntity;
import com.wms.entity.common.WmsApiResponse;
import com.wms.entity.table.*;
import com.wms.mapper.*;
import com.wms.service.PartInfoService;
import com.wms.utils.HttpUtils;
import com.wms.utils.WmsUtils;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.formula.functions.Now;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestBody;
import javax.swing.plaf.synth.Region;
import java.util.Date;
import java.util.List;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.*;
/**
@ -43,13 +49,24 @@ public class TaskOperation {
*/
private final LocationMapper locationMapper;
private final VehicleMapper vehicleMapper;
private final OrderOutMapper orderOutMapper;
/**
* 零件
*/
private final PartInfoService partInfoService;
/**
* 订单入库
*/
private final com.wms.mapper.AppOrderInMapper appOrderInMapper;
//region 完成任务
/**
* 完成任务
* @param task 要完成的任务
* @param task 要完成的任务A21-15-2
* @return 操作结果
*/
public boolean completeTask(Task task) {
@ -75,114 +92,577 @@ public class TaskOperation {
* @return 结果
*/
private boolean completeInTask(Task task) {
/* 将任务更新为完成，将库存更新为正常库存，将库位更新为占用 */
// 更新任务状态
Task updateTask = new Task();
updateTask.setTaskId(task.getTaskId());
updateTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
updateTask.setFinishTime(new Date());
int updateRow = taskMapper.executeTask(updateTask);
if(updateRow != 1) {
log.warn(String.format("完成入库任务更新任务状态失败，任务号：%s", task.getTaskId()));
/* 找出任务，完成该任务；找出该任务终点，更新库存为OK */
// 完成任务
Task completeTask = new Task();
completeTask.setTaskId(task.getTaskId());
completeTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
completeTask.setFinishTime(new Date());
taskMapper.executeTask(completeTask); // 完成任务
// 占掉新库位，生成的时候会占，这里重复操作保护
Location occupyLocation = new Location();
occupyLocation.setLocationId(task.getDestination());
occupyLocation.setLocationStatus(LocationStatus.OCCUPY.getCode());
occupyLocation.setVehicleId(task.getVehicleNo());
locationMapper.modifyLocation(occupyLocation); // 更新库位
//根据task表的载具号前16位去入库表里面找对应的批次号的入库单数据 数量相等 入库单载具号为空
// 根据载具号获取入库单入库数据行
List<AppOrderIn> appOrderIns = appOrderInMapper.selectWithVehicle(task.getVehicleNo());
if (appOrderIns == null || appOrderIns.isEmpty()) {
log.error("四向车入库完成更新库存失败，任务：{}，原因：没有找到入库单入库数据行", task.toLoggerString());
return false;
}
// 更新库存状态
Stock stockQuery = new Stock();
stockQuery.setLocationId(task.getDestination());
List<Stock> stocks = stockMapper.selStocks(stockQuery);
if(stocks == null) {
log.warn(String.format("完成入库任务查询库存 查询数据库失败，任务号：%s", task.getTaskId()));
return false;
}
if(stocks.isEmpty()) {
log.warn(String.format("完成入库任务查询库存没有库存数据，任务号：%s", task.getTaskId()));
return false;
}
for(Stock stock : stocks) {
Stock updateStock = new Stock();
updateStock.setStockId(stock.getStockId());
updateStock.setStockStatus(StockStatus.OK.getCode());
updateStock.setLastUpdateTime(new Date());
updateStock.setCreateTime(new Date());
int updateStockResult = stockMapper.modifyStock(updateStock);
if(updateStockResult != 1) {
log.warn(String.format("完成入库任务更新库存状态失败，任务号：%s , 库存号：%s", task.getTaskId(), stock.getStockId()));
AppOrderIn appOrderInForCheck = appOrderIns.get(0);
if (appOrderInForCheck.getGoodsId() == null || appOrderInForCheck.getGoodsId().isEmpty()){
//表示这个为空托盘入库，没有零件号，不记录到库存表中,更新到料箱监控表中。
Vehicle a = new Vehicle();
a.setVehicleId(appOrderInForCheck.getVehicleNo());
a.setCurrentLocation(task.getDestination());
a.setIsEmpty(1);
a.setVehicleStatus(2);
int b = vehicleMapper.addVehicle(a);
if (b == 0){
log.error("四向车空托盘入库完成更新料箱监控失败，任务：{}，原因：更新载具为空状态失败", task.toLoggerString());
return false;
}else{
log.info("四向车空托盘入库完成更新料箱监控成功，任务：{}", task.toLoggerString());
}
//删除入库单
int dele = appOrderInMapper.delete(appOrderInForCheck.getRowId());
if (dele == 0){
log.info("四向车空托入库删除订单入库单数据行失败，任务：{}，原因：删除失败", task.toLoggerString());
}else if (dele == 1){
log.info("四向车空托入库删除订单入库单数据行成功，任务：{}", task.toLoggerString());
}
}else{
// 将入库数据行数据插入库存表
for (AppOrderIn appOrderIn : appOrderIns){
//将批次号一部分裁下来做生产日期
Stock addStock = new Stock();
addStock.setStockId(WmsUtils.generateUUIDString());
addStock.setWarehouseName("四向车立体库");
addStock.setLocationId(task.getDestination());
//addStock.setLocationId(appOrderIn.getVehicleNo());
addStock.setVehicleId(appOrderIn.getVehicleNo());
addStock.setGoodsId(appOrderIn.getGoodsId());
addStock.setGoodsName("");
addStock.setBatchNo("");
addStock.setAvailableNum(appOrderIn.getGoodsNum().intValue());
addStock.setRealNum(appOrderIn.getGoodsNum().intValue());
addStock.setProviderId("");
addStock.setProviderName("");
//addStock.setProductionDate(null);
addStock.setExpirationDate(null);
addStock.setStockStatus(0);
addStock.setGoodsStatus(null);
addStock.setCreateTime(new Date());
addStock.setLastUpdateTime(null);
addStock.setLastUpdateUser(null);
addStock.setRemark(appOrderIn.getRemark());
addStock.setProductionDate(null);
//添加到库存里
if (Objects.equals(addStock.getVehicleId(), task.getVehicleNo())){
int a = stockMapper.addStock(addStock);//？？？？？？
if (a == 0){//表示添加库存失败
log.info("四向车入库完成更新库存失败，任务：{}，原因：添加库存失败", task.toLoggerString());
for (int i = 0; i < 5; i++) {
int b =stockMapper.addStock(addStock);
if (b != 0){
log.info("四向车入库更新库存重试成功，任务：{}", task.toLoggerString());
break;
}
}
}else {
log.info("四向车入库完成更新库存成功，任务：{}", task.toLoggerString());
}
int b = appOrderInMapper.delete(appOrderIn.getRowId());
if (b == 0){
log.info("四向车入库删除订单入库数据行失败，任务：{}，原因：删除失败", task.toLoggerString());
}else if (b == 1){
log.info("四向车入库删除订单入库数据行成功，任务：{}", task.toLoggerString());
}
}else{
log.error("四向车入库完成更新库存失败，任务：{}，原因：载具号前16位与入库单载具号前16位不一致", task.toLoggerString());
}
}
Vehicle ab = new Vehicle();
ab.setVehicleId(appOrderIns.get(0).getVehicleNo());
ab.setCurrentLocation(task.getDestination());
ab.setIsEmpty(0);
ab.setVehicleStatus(2);
int bd = vehicleMapper.addVehicle(ab);
if (bd == 0){
log.error("四向车入库完成更新料箱监控失败，任务：{}，原因：更新载具为空状态失败", task.toLoggerString());
return false;
}else{
log.info("四向车入库完成更新料箱监控成功，任务：{}", task.toLoggerString());
}
}
return true;
}
// /**
// * 发送 mes 上架入库信息
// * @param stock 库存记录
// * @param locationId 库位
// */
// private void sendMesPutInGoods(Stock stock, String locationId) {
// try {
// SendMesPutInGoodsRequest request = new SendMesPutInGoodsRequest();
// request.setGuid(stock.getStockId());
// request.setLosnr(stock.getBatchNo());
// request.setItemCode(stock.getGoodsId());
// request.setLotQty(String.valueOf(stock.getRealNum()));
// request.setBinCode(locationId);
// String requestString = JSON.toJSONString(request);
// String responseString = HttpUtils.sendHttpPostWithoutToken(UrlEnums.URL_WMS_TO_MES_IN.getValue(), requestString);
// MesApiLocalResponse result = JSON.parseObject(responseString, MesApiLocalResponse.class);
// if(result != null && result.getTransFlag().equals(1)) {
// log.info("发送MES入库上架成功，信息：{}", requestString);
// }
// log.warn("发送MES入库上架失败，信息：{}，返回信息：{}", requestString, responseString);
// }catch (Exception e){
// log.error("发送MES入库上架失败异常，信息：{}", e.getMessage());
// }
// }
// private void sendMesLocation(Stock stock, String locationId) {
// try {
// SendMesStockRequest request = new SendMesStockRequest();
// request.setGuid(stock.getStockId());
// request.setWarehouse(stock.getWarehouseName());
// request.setItemCode(stock.getGoodsId());
// request.setLosnr(stock.getBatchNo());
// request.setLotQty(Integer.toString(stock.getAvailableNum()));
// request.setUnit(null);
// request.setBinCode(locationId);
// request.setVehicleNo(stock.getVehicleId());
// String requestString = JSON.toJSONString(request);
// String responseString = HttpUtils.sendHttpPostWithoutToken(UrlEnums.URL_WMS_TO_MES_STOCK.getValue(), requestString);
// MesApiLocalResponse result = JSON.parseObject(responseString, MesApiLocalResponse.class);
// if (result != null && result.getTransFlag().equals(1)){
// log.info("发送MES库存成功，信息：{}", requestString);
// }else {
// log.warn("发送MES库存失败，信息：{}，返回信息：{}", requestString, responseString);
// }
// }catch (Exception e){
// log.error("发送MES库存失败异常，信息：{}", e.getMessage());
// }
// }
/**
* 完成出库任务
* @param task 要完成的出库任务
* @return 执行结果
*/
private boolean completeOutTask(Task task) {
/* 将任务更新为完成，删除库存，将库位释放 */
// 更新任务状态
Task updateTask = new Task();
updateTask.setTaskId(task.getTaskId());
updateTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
updateTask.setFinishTime(new Date());
int updateRow = taskMapper.executeTask(updateTask);
if(updateRow != 1) {
log.warn(String.format("完成出库任务更新任务状态失败，任务号：%s", task.getTaskId()));
return false;
}
// 删除库存
Stock stockQuery = new Stock();
stockQuery.setLocationId(task.getDestination());
List<Stock> stocks = stockMapper.selStocks(stockQuery);
if(stocks == null) {
log.warn(String.format("完成出库任务查询库存 查询数据库失败，任务号：%s", task.getTaskId()));
return false;
}
if(stocks.isEmpty()) {
log.warn(String.format("完成出库任务查询库存没有库存数据，任务号：%s", task.getTaskId()));
return false;
}
for(Stock stock : stocks) {
int deleteStockResult = stockMapper.deleteStock(stock.getStockId());
if(deleteStockResult != 1) {
log.warn(String.format("完成出库任务删除库存状态失败，任务号：%s , 库存号：%s", task.getTaskId(), stock.getStockId()));
/* 找出任务，完成该任务；找出该任务终点，删除库存；释放库位 */
// 完成任务
Task completeTask = new Task();
completeTask.setTaskId(task.getTaskId());
completeTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
completeTask.setFinishTime(new Date());
taskMapper.executeTask(completeTask); // 完成任务
// 释放库位
Location updateLocation = new Location();
updateLocation.setLocationId(task.getOrigin());
updateLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
updateLocation.setVehicleId("");
locationMapper.modifyLocation(updateLocation); // 更新库位为空
if (Objects.equals(task.getRemark1(), "手动出库")){
// 根据起点拉取库位库存,剩下数量不为零的数据搬运到入库单 生成回库任务，删除该库位所有库存
List<Stock> stocks = stockMapper.selStocksByLocationId(task.getOrigin());
if (stocks == null || stocks.isEmpty()){
log.error("拉取库存失败，任务：{}，原因：没有找到库存数据", task.toLoggerString());
return false;
}
int totalNum = stocks.size();
if (totalNum > 1){
for (Stock stock : stocks){
if (stock.getAvailableNum() > 0){
AppOrderIn appOrderIn = new AppOrderIn();
appOrderIn.setRowId(WmsUtils.generateUUIDString());
appOrderIn.setGuid(stock.getStockId());
appOrderIn.setInType(1);
appOrderIn.setBatchNo(stock.getBatchNo());
appOrderIn.setVehicleNo(task.getVehicleNo());
appOrderIn.setGoodsId(stock.getGoodsId());
appOrderIn.setGoodsNum(BigDecimal.valueOf(stock.getAvailableNum()));
appOrderIn.setWareHouse("A");
if (stock.getVehicleId() != null && !stock.getVehicleId().isEmpty()){
appOrderIn.setOrderStatus(2);
}else {
appOrderIn.setOrderStatus(0);
}
//appOrderIn.setOrderStatus(2);
appOrderIn.setCreateTime(LocalDateTime.now());
appOrderIn.setUpdateTime(LocalDateTime.now());
appOrderIn.setCreatePerson("BACK");
appOrderIn.setRemark("回库");
int isSuessInsert = appOrderInMapper.insert(appOrderIn);
if(isSuessInsert > 0){
log.info("多物料回库任务生成成功，任务：{}", task.toLoggerString());
}else{
log.error("多物料回库任务生成失败，任务：{}", task.toLoggerString());
}
}
}
} else{
for (Stock stock : stocks){
if (stock.getAvailableNum() > 0){
AppOrderIn appOrderIn = new AppOrderIn();
appOrderIn.setRowId(WmsUtils.generateUUIDString());
appOrderIn.setGuid(stock.getStockId());
appOrderIn.setInType(1);
appOrderIn.setBatchNo(stock.getBatchNo());
appOrderIn.setVehicleNo(task.getVehicleNo());
appOrderIn.setGoodsId(stock.getGoodsId());
appOrderIn.setGoodsNum(BigDecimal.valueOf(stock.getAvailableNum()));
appOrderIn.setWareHouse("A");
if (stock.getVehicleId() != null && !stock.getVehicleId().isEmpty()){
appOrderIn.setOrderStatus(2);
}else {
appOrderIn.setOrderStatus(0);
}
//appOrderIn.setOrderStatus(2);
appOrderIn.setCreateTime(LocalDateTime.now());
appOrderIn.setUpdateTime(LocalDateTime.now());
appOrderIn.setCreatePerson("BACK");
appOrderIn.setRemark("回库");
int isSuessInsert = appOrderInMapper.insert(appOrderIn);
if(isSuessInsert > 0){
log.info("回库任务生成成功，任务：{}", task.toLoggerString());
}else{
log.error("回库任务生成失败，任务：{}", task.toLoggerString());
}
}else{
log.error("库存数量为零，即将生成空托盘回库任务");
AppOrderIn appOrderIn = new AppOrderIn();
appOrderIn.setRowId(UUID.randomUUID().toString());
appOrderIn.setGuid(UUID.randomUUID().toString());
appOrderIn.setInType(1);
appOrderIn.setBatchNo(null);
appOrderIn.setVehicleNo(task.getVehicleNo());
appOrderIn.setGoodsId(null);
appOrderIn.setGoodsNum(null);
appOrderIn.setWareHouse("A");
appOrderIn.setOrderStatus(0);
appOrderIn.setCreateTime(LocalDateTime.now());
appOrderIn.setCreatePerson("WMS");
appOrderIn.setUpdateTime(LocalDateTime.now());
appOrderIn.setRemark("空托盘入库");
//appOrderIn.setProductionDate(request.abcSelect);
int a = appOrderInMapper.insert(appOrderIn);
if (a > 0){
log.info("空托盘回库任务生成成功，任务：{}", task.toLoggerString());
}else{
log.error("空托盘回库任务生成失败，任务：{}", task.toLoggerString());
}
}
}
}
//出库完成删除出库单
int deleteOrderOut = orderOutMapper.deleteOrderOut(task.getPickStand());
if (deleteOrderOut > 0){
log.info("出库单删除成功，任务：{}", task.toLoggerString());
}else{
log.error("出库单删除失败，任务：{}", task.toLoggerString());
}
//出库完成发送mes
Stock checkIsExist = new Stock();
checkIsExist.setLocationId(task.getOrigin());
List<Stock> checkIsExistListResult = stockMapper.selStocks(checkIsExist);
//List<Stock> stockUseSend = new ArrayList<>();
if (checkIsExistListResult == null || checkIsExistListResult.isEmpty()){
log.info("没有找到对应的数据，表中数据为空，信息：{}", task.toLoggerString());
return false;
}
Vehicle ab = new Vehicle();
ab.setVehicleId(checkIsExistListResult.get(0).getVehicleId());
ab.setCurrentLocation(task.getOrigin());
ab.setIsEmpty(0);
ab.setVehicleStatus(2);
int bd = vehicleMapper.deleteVehicle(ab);
if (bd == 0){
log.error("四向车出库完成更新料箱监控失败，任务：{}，原因：更新载具为空状态失败", task.toLoggerString());
//return false;
}else{
log.info("四向车出库完成更新料箱监控成功，任务：{}", task.toLoggerString());
}
// 删除库存
int updateStock = stockMapper.deleteStockWithLocationId(task.getOrigin());
if(updateStock > 0){
log.info("出库完成删除库存成功，任务：{}", task.toLoggerString());
return true;
}else{
log.error("出库完成删除库存失败，任务：{}", task.toLoggerString());
return false;
}
} else if (Objects.equals(task.getRemark1(), "空托盘出库")) {
//出库完成删除出库单
int deleteOrderOut = orderOutMapper.deleteOrderOut(task.getPickStand());
if (deleteOrderOut > 0){
log.info("空托盘出库单删除成功，任务：{}", task.toLoggerString());
}else{
log.error("空托盘出库单删除失败，任务：{}", task.toLoggerString());
}
Vehicle ab = new Vehicle();
ab.setVehicleId(task.getVehicleNo());
ab.setCurrentLocation(task.getOrigin());
ab.setIsEmpty(1);
ab.setVehicleStatus(2);
int bd = vehicleMapper.deleteVehicle(ab);
if (bd == 0){
log.error("四向车空托出库完成更新料箱监控失败，任务：{}，原因：更新载具为空状态失败", task.toLoggerString());
return false;
}else{
log.info("四向车空托出库完成更新料箱监控成功，任务：{}", task.toLoggerString());
return true;
}
}
// 释放库位
Location location = new Location();
location.setLocationId(task.getDestination());
location.setLocationStatus(LocationStatus.EMPTY.getCode());
locationMapper.modifyLocation(location);
return true;
log.error("不处理的出库任务，表中数据为空，信息：{}", task.toLoggerString());
return false;
}
/**
* 发送 mes 出库下架信息
* @param stocks 库存记录
* @param task 任务
*/
// private void sendMesPutOutGoods(List<Stock> stocks, Task task) {
// try {
// SendMesPutOutGoodsRequest request = new SendMesPutOutGoodsRequest();
// request.setGuid(task.getTaskId());
// request.setTransferNo(task.getTaskGroup());
// if (Objects.equals(task.getRemark1(), "手动出库")){
// request.setType(4);
// }else{
// request.setType(task.getTaskType());
// }
// List<SendMesPutOutGoodsRow> rows = new ArrayList<>();
// int lint = 1;
// if (stocks == null || stocks.isEmpty()){
// log.error("发送MES出库下架失败，没有收到ROW所需要的数据，信息：{}", task.toLoggerString());
// return;
// }
// for(Stock stock : stocks) {
// SendMesPutOutGoodsRow row = new SendMesPutOutGoodsRow();
// row.setTransferLine(String.valueOf(lint));
// row.setLosnr(stock.getBatchNo());
// row.setVehicleNo(stock.getVehicleId());
// row.setWarehouse(stock.getWarehouseName());
// row.setLotQty(String.valueOf(stock.getRealNum() - stock.getAvailableNum()));
// rows.add(row);
// lint++;
// }
// request.setRow(rows);
// String requestString = JSON.toJSONString(request);
// String responseString = HttpUtils.sendHttpPostWithoutToken(UrlEnums.URL_WMS_TO_MES_OUT.getValue(), requestString);
// MesApiLocalResponse result = JSON.parseObject(responseString, MesApiLocalResponse.class);
// if(result != null && result.getTransFlag().equals(1)) {
// log.info("发送MES出库下架成功，信息：{}", requestString);
// }else{
// log.warn("发送MES出库下架失败，信息：{}，返回信息：{}", requestString, responseString);
// }
// }catch (Exception e){
// log.error("发送MES出库下架失败异常，信息：{}", e.getMessage());
// }
// }
/**
* 完成盘点任务
* @param task 任务
* @return 完成结果
*/
private boolean completeInventoryTask(Task task) {
return true;
/* 找出任务，完成该任务；找出该任务终点，删除库存；释放库位 */
// 完成任务
Task completeTask = new Task();
completeTask.setTaskId(task.getTaskId());
completeTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
completeTask.setFinishTime(new Date());
taskMapper.executeTask(completeTask); // 完成任务
// 释放库位
Location updateLocation = new Location();
updateLocation.setLocationId(task.getOrigin());
updateLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
updateLocation.setVehicleId("");
locationMapper.modifyLocation(updateLocation); // 更新库位为空
// 根据起点拉取库位库存,剩下数量不为零的数据搬运到入库单 生成回库任务，删除该库位所有库存
List<Stock> stocks = stockMapper.selStocksByLocationId(task.getOrigin());
if (stocks == null || stocks.isEmpty()){
log.error("完成盘点出库拉取库存失败，任务：{}，原因：没有找到库存数据", task.toLoggerString());
return false;
}
for (Stock stock : stocks){
if (stock.getAvailableNum() > 0){
AppOrderIn appOrderIn = new AppOrderIn();
appOrderIn.setRowId(WmsUtils.generateUUIDString());
appOrderIn.setGuid(stock.getStockId());
appOrderIn.setInType(1);
appOrderIn.setBatchNo(stock.getBatchNo());
appOrderIn.setVehicleNo(task.getVehicleNo());
appOrderIn.setGoodsId(stock.getGoodsId());
appOrderIn.setGoodsNum(BigDecimal.valueOf(stock.getAvailableNum()));
appOrderIn.setWareHouse(stock.getWarehouseName());
if (stock.getVehicleId() != null && !stock.getVehicleId().isEmpty()){
appOrderIn.setOrderStatus(2);
}else {
appOrderIn.setOrderStatus(0);
}
//appOrderIn.setOrderStatus(2);
appOrderIn.setCreateTime(LocalDateTime.now());
appOrderIn.setUpdateTime(LocalDateTime.now());
appOrderIn.setCreatePerson("BACK");
appOrderIn.setRemark("盘点回库");
int isSuessInsert = appOrderInMapper.insert(appOrderIn);
if(isSuessInsert > 0){
log.info("盘点回库任务生成成功，任务：{}", task.toLoggerString());
}else{
log.error("盘点回库任务生成失败，任务：{}", task.toLoggerString());
}
}
}
// 盘点出库完成发送mes
// Stock checkIsExist = new Stock();
// checkIsExist.setLocationId(task.getOrigin());
// List<Stock> checkIsExistListResult = stockMapper.selStocks(checkIsExist);
// sendMesInventoryGoods(checkIsExistListResult, task);
// Stock addStock = stocks.get(0);
// addStock.setAvailableNum(0);
// 发送库存接口给mes
//sendMesLocation(addStock, task.getOrigin());
// 删除库存????
int updateStock = stockMapper.deleteStockWithLocationId(task.getOrigin());
if(updateStock > 0){
log.info("盘点出库完成删除库存成功，任务：{}", task.toLoggerString());
return true;
}
return false;
}
// /**
// * 完成盘点任务
// * @param task 任务
// */
// private void sendMesInventoryGoods(List<Stock> stocks, Task task) {
// try {
// SendMesGoodsInventoryRequest request = new SendMesGoodsInventoryRequest();
// request.setGuid(task.getTaskId());
// request.setInventoryNo(task.getTaskGroup());
//
// List<SendMesGoodsInventoryRow> rows = new ArrayList<>();
// for(Stock stock : stocks) {
// SendMesGoodsInventoryRow row = new SendMesGoodsInventoryRow();
// row.setLosnr(stock.getBatchNo());
// row.setWarehouse(stock.getWarehouseName());
// row.setLotQty(String.valueOf(stock.getRealNum()));
// rows.add(row);
// }
// request.setRow(rows);
// String requestString = JSON.toJSONString(request);
// String responseString = HttpUtils.sendHttpPostWithoutToken(UrlEnums.URL_WMS_TO_MES_INVENTORY.getValue(), requestString);
// MesApiLocalResponse result = JSON.parseObject(responseString, MesApiLocalResponse.class);
// if(result != null && result.getTransFlag().equals(1)) {
// log.info("发送MES盘点执行成功，信息：{}", requestString);
// }else{
// log.warn("发送MES盘点执行失败，信息：{}，返回信息：{}", requestString, responseString);
// }
// }catch (Exception e){
// log.error("发送MES盘点执行失败异常，信息：{}", e.getMessage());
// }
// }
/**
* 完成移库任务
* @param task 任务
* @return 完成结果
*/
private boolean completeMoveTask(Task task) {
/* 将任务更新为完成；更新库存状态；更新库位状态 */
Task updateTask = new Task();
updateTask.setTaskId(task.getTaskId());
updateTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
updateTask.setFinishTime(new Date());
int updateRow = taskMapper.executeTask(updateTask);
if(updateRow != 1) {
log.warn(String.format("完成移库任务更新任务状态失败，任务号：%s", task.getTaskId()));
return false;
}
// 更新库存
int updateLocationResult = stockMapper.updateLocationAndStatus(task.getOrigin(), task.getDestination(), StockStatus.OK.getCode());
if(updateLocationResult < 1) {
log.warn(String.format("完成移库任务更新库存状态失败，任务号：%s ，原库位：%s，新库位：%s", task.getTaskId(), task.getOrigin(), task.getDestination()));
return false;
}
/* 找出任务，更新任务为完成；释放原库位；更新库存到新库位 */
// 完成任务
Task completeTask = new Task();
completeTask.setTaskId(task.getTaskId());
completeTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
completeTask.setFinishTime(new Date());
taskMapper.executeTask(completeTask); // 完成任务
// 释放原库位
Location location = new Location();
location.setLocationId(task.getOrigin());
location.setLocationStatus(LocationStatus.EMPTY.getCode());
locationMapper.modifyLocation(location);
return true;
// 释放库位
Location updateLocation = new Location();
updateLocation.setLocationId(task.getOrigin());
updateLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
updateLocation.setVehicleId("");
locationMapper.modifyLocation(updateLocation); // 更新库位为空
// 占掉新库位，生成的时候会占，这里重复操作保护
Location occupyLocation = new Location();
occupyLocation.setLocationId(task.getDestination());
occupyLocation.setLocationStatus(LocationStatus.OCCUPY.getCode());
occupyLocation.setVehicleId(task.getVehicleNo());
locationMapper.modifyLocation(occupyLocation); // 更新库位
String checkUse = task.getRemark1();
// if (Objects.equals(checkUse, "空框")){
//只需要更新料箱监控
Vehicle vehicle = new Vehicle();
vehicle.setCurrentLocation(task.getDestination());
vehicle.setVehicleId(task.getVehicleNo());
int a = vehicleMapper.modifyVehicle(vehicle);
if (a > 0){
log.info("更新料箱监控成功");
}else{
log.info("更新料箱监控失败");
}
// }
if (Objects.equals(checkUse, "带料")) {
//需要额外更新库存
int updatedLocation = stockMapper.updateLocationAndStatus(task.getOrigin(), task.getDestination(), StockStatus.OK.getCode());
if(updatedLocation > 0){
log.info("移库库位更新成功，任务：{}", task.toLoggerString());
return true;
}else {
log.info("移库库位更新失败，任务：{}", task.toLoggerString());
}
} else if (Objects.equals(checkUse, "空框")) {
log.info("空框移库库位更新成功");
return true;
}
// 更新库位
return false;
}
// /**
// * 完成移库任务
// * @param task 任务
// * @return 完成结果
// */
// private void sendMesPutMoveGoods(Stock stock, Task task) {
// try {
// SendMesGoodsMoveRequest request = new SendMesGoodsMoveRequest();
// request.setGuid(stock.getStockId());
// request.setLosnr(stock.getBatchNo());
// request.setFBinCode(task.getOrigin());
// request.setLotQty(String.valueOf(stock.getRealNum()));
// request.setTBinCode(task.getDestination());
// String requestString = JSON.toJSONString(request);
// String responseString = HttpUtils.sendHttpPostWithoutToken(UrlEnums.URL_WMS_TO_MES_MOVE.getValue(), requestString);
// MesApiLocalResponse result = JSON.parseObject(responseString, MesApiLocalResponse.class);
// if(result != null && result.getTransFlag().equals(1)) {
// log.info("发送MES批次调整（移库）成功，信息：{}", requestString);
// }
// log.warn("发送MES批次调整（移库）失败，信息：{}，返回信息：{}", requestString, responseString);
// }catch (Exception e){
// log.error("发送MES批次调整（移库）失败异常，信息：{}", e.getMessage());
// }
// }
//endregion
@ -217,28 +697,26 @@ public class TaskOperation {
* @return 结果
*/
private boolean cancelInTask(Task task) {
/* 将任务更新为取消，将库存删除，将库位更新为空闲 */
// 更新任务状态
Task updateTask = new Task();
updateTask.setTaskId(task.getTaskId());
updateTask.setTaskStatus(WmsTaskStatus.CANCEL.getCode());
updateTask.setFinishTime(new Date());
int updateRow = taskMapper.executeTask(updateTask);
if(updateRow != 1) {
log.warn(String.format("取消入库任务更新任务状态失败，任务号：%s", task.getTaskId()));
return false;
}
// 删除库存
int deleteResult = stockMapper.deleteStockWithLocationId(task.getDestination());
if(deleteResult < 1) {
log.warn(String.format("取消入库删除库存失败，任务号：%s，入库点位：%s -> %s", task.getTaskId(), task.getOrigin(), task.getDestination()));
}
/* 找出任务，取消该任务；找出该任务终点，更新库存为OK */
// 取消任务
Task completeTask = new Task();
completeTask.setTaskId(task.getTaskId());
completeTask.setTaskStatus(WmsTaskStatus.CANCEL.getCode());
completeTask.setFinishTime(new Date());
taskMapper.executeTask(completeTask); // 取消任务
// 释放库位
Location location = new Location();
location.setLocationId(task.getDestination());
location.setLocationStatus(LocationStatus.EMPTY.getCode());
locationMapper.modifyLocation(location);
return true;
Location updateLocation = new Location();
updateLocation.setLocationId(task.getDestination());
updateLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
updateLocation.setVehicleId("");
locationMapper.modifyLocation(updateLocation); // 更新库位为空
// 更新库存为 ok ???????
int updateStock = stockMapper.updateStockStatusWithLocationId(task.getDestination(), StockStatus.OK.getCode());
if(updateStock > 0){
log.info("入库取消更新库存成功，任务：{}", task.toLoggerString());
return true;
}
return false;
}
/**
@ -247,51 +725,70 @@ public class TaskOperation {
* @return 执行结果
*/
private boolean cancelOutTask(Task task) {
/* 将任务更新为取消，将库存更新为库存中 */
// 更新任务状态
Task updateTask = new Task();
updateTask.setTaskId(task.getTaskId());
updateTask.setTaskStatus(WmsTaskStatus.CANCEL.getCode());
updateTask.setFinishTime(new Date());
int updateRow = taskMapper.executeTask(updateTask);
if(updateRow != 1) {
log.warn(String.format("取消出库任务更新任务状态失败，任务号：%s", task.getTaskId()));
return false;
/* 找出任务，取消该任务；找出该任务终点，删除库存；释放库位 */
// 取消任务
Task completeTask = new Task();
completeTask.setTaskId(task.getTaskId());
completeTask.setTaskStatus(WmsTaskStatus.CANCEL.getCode());
completeTask.setFinishTime(new Date());
taskMapper.executeTask(completeTask); // 取消任务
// 更新库存为 ok
int updateStock = stockMapper.updateStockStatusWithLocationId(task.getDestination(), StockStatus.OK.getCode());
if(updateStock > 0){
log.info("出库取消更新库存成功，任务：{}", task.toLoggerString());
return true;
}
// 更新库存信息为库存中
int updateResult = stockMapper.updateStockStatusWithLocationId(task.getOrigin(), StockStatus.OK.getCode());
if(updateResult < 1) {
log.warn(String.format("取消出库任务更新库存状态失败，任务号：%s，出库点位：%s -> %s", task.getTaskId(), task.getOrigin(), task.getDestination()));
}
return true;
return false;
}
/**
* 取消盘点任务
* @param task 任务
* @return 取消结果
*/
private boolean cancelInventoryTask(Task task) {
return true;
/* 找出任务，取消该任务；找出该任务终点，删除库存；释放库位 */
// 取消任务
Task completeTask = new Task();
completeTask.setTaskId(task.getTaskId());
completeTask.setTaskStatus(WmsTaskStatus.CANCEL.getCode());
completeTask.setFinishTime(new Date());
taskMapper.executeTask(completeTask); // 取消任务
// 更新库存为 ok
int updateStock = stockMapper.updateStockStatusWithLocationId(task.getDestination(), StockStatus.OK.getCode());
if(updateStock > 0){
log.info("盘点出库取消更新库存成功，任务：{}", task.toLoggerString());
return true;
}
return false;
}
/**
* 取消移库任务
* @param task 任务
* @return 取消结果
*/
private boolean cancelMoveTask(Task task) {
/* 将任务更新为取消；更新库存状态为正常；释放终点库位 */
Task updateTask = new Task();
updateTask.setTaskId(task.getTaskId());
updateTask.setTaskStatus(WmsTaskStatus.CANCEL.getCode());
updateTask.setFinishTime(new Date());
int updateRow = taskMapper.executeTask(updateTask);
if(updateRow != 1) {
log.warn(String.format("完成移库任务更新任务状态失败，任务号：%s", task.getTaskId()));
return false;
/* 找出任务，更新任务为取消；释放新库位；更新库存为OK */
// 取消任务
Task completeTask = new Task();
completeTask.setTaskId(task.getTaskId());
completeTask.setTaskStatus(WmsTaskStatus.CANCEL.getCode());
completeTask.setFinishTime(new Date());
taskMapper.executeTask(completeTask); // 取消任务
// 释放库位
Location updateLocation = new Location();
updateLocation.setLocationId(task.getDestination());
updateLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
updateLocation.setVehicleId("");
locationMapper.modifyLocation(updateLocation); // 更新库位为空
// 更新库位
int updatedLocation = stockMapper.updateStockStatusWithLocationId(task.getOrigin(), StockStatus.OK.getCode());
if(updatedLocation > 0){
log.info("移库取消库位状态更新成功，任务：{}", task.toLoggerString());
return true;
}
// 更新库存信息为库存中
int updateResult = stockMapper.updateStockStatusWithLocationId(task.getOrigin(), StockStatus.OK.getCode());
if(updateResult < 1) {
log.warn(String.format("取消出库任务更新库存状态失败，任务号：%s，出库点位：%s -> %s", task.getTaskId(), task.getOrigin(), task.getDestination()));
}
// 释放新库位
Location location = new Location();
location.setLocationId(task.getDestination());
location.setLocationStatus(LocationStatus.EMPTY.getCode());
locationMapper.modifyLocation(location);
return true;
return false;
}

26
src/main/java/com/wms/constants/enums/OrderInStatusEnum.java Normal file
View File

@ -0,0 +1,26 @@
package com.wms.constants.enums;
import lombok.Data;
import lombok.Getter;
/**
* 订单入库状态枚举
*
* @author 菻蔃
*/
@Getter
public enum OrderInStatusEnum {
CREATE(0, "创建"),
IN(1, "入库中"),
BINDING(2, "已绑定"),
;
private final int code;
private final String desc;
OrderInStatusEnum(int code, String desc) {
this.code = code;
this.desc = desc;
}
}

3
src/main/java/com/wms/constants/enums/OrderOutStatusEnum.java
View File

@ -8,7 +8,8 @@ import lombok.Getter;
@Getter
public enum OrderOutStatusEnum {
CREATED(0, "已创建");
CREATED(0, "已创建"),
RUNNING(1, "执行中");
private final int code;

2
src/main/java/com/wms/constants/enums/StockStatus.java
View File

@ -5,9 +5,7 @@ package com.wms.constants.enums;
*/
public enum StockStatus {
WAIT_IN(-2, "待入库"),
IN_ING(-1, "正在入库"),
OK(0, "库存正常"),
OUT(1, "准备出库"),
MOVING(2, "正在出库"),

17
src/main/java/com/wms/constants/enums/UrlEnums.java
View File

@ -1,10 +1,17 @@
package com.wms.constants.enums;
//172.21.80.151
public enum UrlEnums {
URL_WMS_TO_WCS_SEND_TASK("WMS向WCS发送任务", "http://172.21.80.151:18990/api/Wms/WmsTask/SetStackerTask"),
URL_WMS_TO_WCS_CHANGE_TASK("WMS请求变更任务状态", "http://172.21.80.151:18990/api/Wms/WmsTask/ChangeTaskStatus"),
URL_WMS_TO_WCS_CONTAINER_TASK("WMS向四向车发送任务","http://172.21.80.150:9991/api/Wcs/PushTask"),
URL_WMS_TO_MES_IN("扫码上架", "");
URL_WMS_TO_WCS_SEND_TASK("WMS向WCS发送任务", "http://172.168.1.99:18990/api/wms/wmsTask/setStackerTask"),
URL_WMS_TO_WCS_CHANGE_TASK("WMS请求变更任务状态", "http://172.168.1.99:18990/api/Wms/WmsTask/ChangeTaskStatus"),
URL_WMS_TO_WCS_CONTAINER_TASK("WMS向四向车发送任务","http://172.168.1.99:9991/api/Wcs/PushTask"),
URL_WMS_TO_WCS_CONTAINERIN_TASK("WMS向四向车发送入库任务","http://172.168.1.99:19990/api/container/createInstoreTask");
//URL_WMS_TO_MES_IN("扫码上架", "http://172.21.73.210:9000/Asimco/vmesserver/wms_interface/LotGround"),
//URL_WMS_TO_MES_OUT("批次出库", "http://172.21.73.210:9000/Asimco/vmesserver/wms_interface/ReceiptOut"),
//URL_WMS_TO_MES_INVENTORY("盘点执行", "http://172.21.73.210:9000/Asimco/vmesserver/wms_interface/InventoryResult"),
//URL_WMS_TO_MES_STOCK("库存", "http://172.21.73.210:9000/Asimco/vmesserver/wms_interface/WMSStorage");
//URL_WMS_TO_MES_MOVE("批次调整", "http://172.21.73.210:9000/Asimco/vmesserver/wms_interface/LotAD");
private final String description;
private final String value;

8
src/main/java/com/wms/controller/LocationController.java
View File

@ -69,8 +69,12 @@ public class LocationController extends BaseController {
ResponseEntity rsp = new ResponseEntity();
try {
// 查询出所有符合条件的库位
List<Location> locations = locationService.selLocations(location);
if (locations.size() < 1) {
Location location1 = new Location();
//location1.setLocationId("A11-15-2");
//location1.setWareArea("A");
location1.setAreaId(2);
List<Location> locations = locationService.selLocations(location1);
if (locations.isEmpty()) {
logger.error("查询库位发生错误：库位不存在");
// 返回错误
rsp.setCode(ResponseCode.ERROR.getCode());

60
src/main/java/com/wms/controller/OrderCheckController.java Normal file
View File

@ -0,0 +1,60 @@
package com.wms.controller;
import com.wms.entity.common.WmsApiResponse;
import com.wms.entity.dto.orderCheck.queryOrderCheckRequest;
import com.wms.entity.table.OrderCheck;
import com.wms.service.IOrderCheckService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@Slf4j
@RestController
@CrossOrigin
@RequestMapping(value = "/wms/api/orderCheck")
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class OrderCheckController {
private final IOrderCheckService orderCheckService;
/**
* 查询订单
*/
@PostMapping(value = "/queryOrderCheck")
public WmsApiResponse<List<OrderCheck>> getOrderCheck(@RequestBody queryOrderCheckRequest request) {
return orderCheckService.queryOrderCheck(request);
}
/**
* 执行订单
*/
@PutMapping(value = "/executeOrderCheck/{recordId}") //更新
public WmsApiResponse<Object> executeOrderCheck(@PathVariable String recordId) {
return orderCheckService.executeOrderCheck(recordId);
}
/**
* 删除订单
*/
@DeleteMapping(value = "/deleteCheck/{recordId}")
public WmsApiResponse<Object> deleteOrderIn(@PathVariable String recordId) {
return orderCheckService.deleteOrderCheck(recordId);
}
@DeleteMapping(value = "/deleteCheckAll/{remarkReturn}")
public WmsApiResponse<Object> deleteOrderInAll(@PathVariable String remarkReturn){
return orderCheckService.deleteOrderCheckAll(remarkReturn);
}
/**
* 下发一个盘点任务
*/
@PostMapping(value = "/downInventoryTask")
public WmsApiResponse<Object> issueOrderCheck() {
return orderCheckService.issueOrderCheck();
}
}

100
src/main/java/com/wms/controller/OrderInController.java Normal file
View File

@ -0,0 +1,100 @@
package com.wms.controller;
import com.wms.entity.common.WmsApiResponse;
import com.wms.entity.dto.orderIn.bindingVehicleRequest;
import com.wms.entity.dto.orderIn.downOrderInRequest;
import com.wms.entity.dto.orderIn.queryOrderInRequest;
import com.wms.entity.dto.orderIn.updateNumRequest;
import com.wms.entity.table.AppOrderIn;
import com.wms.service.IOrderInService;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.math.BigDecimal;
import java.util.List;
@Slf4j
@RestController
@CrossOrigin
@RequestMapping(value = "/wms/api/orderIn")
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class OrderInController {
private final IOrderInService iOrderInService;
/**
* 查询入库单
* @param request 请求参数
* @return 返回结果
*/
@PostMapping(value = "/queryOrderIn")
public WmsApiResponse<List<AppOrderIn>> queryOrderIn(@RequestBody queryOrderInRequest request) {
return iOrderInService.queryOrderIn(request);
}
/**
* 新增入库单
* @param request 请求参数
* @return 返回结果
*/
@PostMapping(value = "/addOrderIn")
public WmsApiResponse<Object> addOrderIn(@RequestBody downOrderInRequest request) {
return iOrderInService.addOrderIn(request);
}
/**
* 绑定载具
* @param request 请求参数
* @return 返回结果
*/
@PostMapping(value = "/bindingVehicle")
public WmsApiResponse<Object> bindingVehicle(@RequestBody bindingVehicleRequest request) {
return iOrderInService.bindingVehicle(request);
}
/**
* 更新数量
* @return 更新结果
*/
@PostMapping(value = "/updateForNum")
public WmsApiResponse<Object> updateForNum(@RequestBody updateNumRequest request) {
return iOrderInService.updateForNum(request);
}
/**
* 根据载具号查询入库单
* @param vehicleNo 载具号
* @return 查询结果
*/
@GetMapping(value = "/getOrderInWithVehicleNo")
public WmsApiResponse<List<AppOrderIn>> getOrderInWithVehicleNo(@RequestParam("vehicleNo") String vehicleNo) {
return iOrderInService.getOrderInWithVehicleNo(vehicleNo);
}
/**
* 解绑载具
* @param rowId 行号
* @return 解绑结果
*/
@PutMapping(value = "/unBindingVehicle/{rowId}")
public WmsApiResponse<Object> unBindingVehicle(@PathVariable String rowId) {
return iOrderInService.unBindingVehicle(rowId);
}
/**
* 删除入库单
* @param rowId 行号
* @return 删除结果
*/
@DeleteMapping(value = "/deleteOrderIn/{rowId}")
public WmsApiResponse<Object> deleteOrderIn(@PathVariable String rowId) {
return iOrderInService.deleteOrderIn(rowId);
}
}

90
src/main/java/com/wms/controller/OrderOutController.java Normal file
View File

@ -0,0 +1,90 @@
package com.wms.controller;
import com.wms.entity.common.WmsApiResponse;
import com.wms.entity.dto.orderOut.handOrderOutRequest;
import com.wms.entity.dto.orderOut.queryOrderOutRequest;
import com.wms.entity.table.OrderOut;
import com.wms.service.IOrderOutService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@Slf4j
@RestController
@CrossOrigin
@RequestMapping(value = "/wms/api/orderOut")
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class OrderOutController {
private final IOrderOutService orderOutService;
/**
* 查询出库单
* @param request 请求参数
* @return 结果
*/
@PostMapping(value = "/queryOrderOut") //刪除
public WmsApiResponse<List<OrderOut>> queryOrderOut(@RequestBody queryOrderOutRequest request) {
return orderOutService.queryOrderOut(request);
}
/**
* 执行出库单
* @param rowId 数据行号
* @return 执行结果
*/
@PutMapping(value = "/executeOrderOut/{rowId}") //更新
public WmsApiResponse<Object> executeOrderOut(@PathVariable String rowId) {
return orderOutService.executeOrderOut(rowId);
}
/**
* 出库单出库
* @param rowId 数据行号
* @return 出库结果
*/
// @PutMapping(value = "/outRowStock/{rowId}") //更新
// public WmsApiResponse<Object> outRowStock(@PathVariable String rowId) {
// return orderOutService.outRowStock(rowId);
// }
/**
* 删除出库单
* @param rowId 数据行号
* @return 删除结果
*/
@DeleteMapping(value = "/deleteOrderOut/{rowId}") //刪除
public WmsApiResponse<Object> deleteOrderOut(@PathVariable String rowId) {
return orderOutService.deleteOrderOut(rowId);
}
/**
* 创建手动出库单
* @return 创建结果
*/
@PostMapping(value = "/addOrderOut")
public WmsApiResponse<Object> createOrderOut(@RequestBody handOrderOutRequest request) {
return orderOutService.createOrderOut(request);
}
@PostMapping(value = "/addOrderByInsertEmpty")
public WmsApiResponse<Object> InsertEmpty(@RequestBody handOrderOutRequest request) {
if (orderOutService.createEmptyLocation(request)){
return new WmsApiResponse<>(0, "添加成功", null);
}else {
return new WmsApiResponse<>(1, "添加失败", null);
}
}
//@PostMapping(value = "/addOrderOutjklove")
public WmsApiResponse<Object> updateLocation(@RequestBody handOrderOutRequest request) {
return orderOutService.updateLocation(request);
}
}

96
src/main/java/com/wms/controller/TaskController.java
View File

@ -7,12 +7,16 @@ import com.wms.constants.enums.*;
import com.wms.entity.app.*;
import com.wms.entity.app.wcs.*;
import com.wms.entity.page.PageDomain;
import com.wms.mapper.StockMapper;
import com.wms.mapper.TaskMapper;
import com.wms.entity.page.TableRequest;
import com.wms.entity.page.TableResponse;
import com.wms.entity.table.*;
import com.wms.constants.WmsConstants;
import com.wms.utils.storage.LocationUtils;
import com.wms.service.*;
import com.wms.utils.HttpUtils;
import com.wms.mapper.LocationMapper;
import com.wms.utils.StringUtils;
import com.wms.utils.WmsUtils;
import jakarta.servlet.http.HttpServletRequest;
@ -42,10 +46,23 @@ public class TaskController extends BaseController {
* 任务服务
*/
private final TaskService taskService;
/**
* 任务 Mapper
*/
private final TaskMapper taskMapper;
/**
* 库存 Mapper
*/
private final StockMapper stockMapper;
/**
* 库存服务
*/
private final StockService stockService;
/**
* 库位操作类
*/
private final LocationUtils locationUtils;
/**
* 零件
*/
@ -71,6 +88,14 @@ public class TaskController extends BaseController {
*/
private final HttpServletRequest servletRequest;
/**
* 订单入库 Mapper
*/
private final com.wms.mapper.AppOrderInMapper appOrderInMapper;
/**
* 库位 Mapper
*/
private final LocationMapper locationMapper;
/**
* 创建入库任务（人工入库）
*
@ -430,6 +455,7 @@ public class TaskController extends BaseController {
rsp.setMessage("当前箱子不可用，请确认！");
return JSON.toJSONString(rsp);
}
int needNum = taskOutRequest.getNeedNum();
// 生成任务
Task tempTask = new Task();
tempTask.setVehicleNo(taskOutRequest.getVehicleNo());
@ -474,9 +500,78 @@ public class TaskController extends BaseController {
stockQuery.setVehicleId(taskOutRequest.getVehicleNo());
List<Stock> stocks = stockService.selStocks(stockQuery);
for (Stock tempStock : stocks) {
if (needNum <= 0){
break;
}
tempStock.setStockStatus(StockStatus.OUT.getCode());
needNum = needNum - tempStock.getRealNum();
stockService.modifyStock(tempStock);
}
// for (Stock tempStock : stocks){
// if (!Objects.equals(tempStock.getStockStatus(), StockStatus.OUT.getCode())){
// //生成回库任务
// String vehicleNo = taskOutRequest.getVehicleNo(); // 载具号
// /* 查找一个空库位 */
// Location emptyLocation = new Location();
// emptyLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
// emptyLocation.setAreaId(1);
// List<Location> emptyLocations = locationMapper.selLocations(emptyLocation);
// if(emptyLocations == null) {
// rsp.setCode(ResponseCode.ERROR.getCode());
// rsp.setMessage("库位查找失败，网络连接异常，请稍后再试");
// return JSON.toJSONString(rsp);
// }
// if(emptyLocations.isEmpty()){
// rsp.setCode(ResponseCode.ERROR.getCode());
// rsp.setMessage("没有可用库位");
// return JSON.toJSONString(rsp);
// }
// Location emptyLocationItem = locationUtils.checkCanUse(emptyLocations);
// if(emptyLocationItem == null) {
// rsp.setCode(ResponseCode.ERROR.getCode());
// rsp.setMessage("没有可用库位或者库位存在干涉，请稍后再试");
// return JSON.toJSONString(rsp);
// }
// // 该空库位可用，生成一个入库任务，并将库存表更新库位
// // 更新库位表，占掉库位
// Location updateLocation = new Location();
// updateLocation.setLocationId(emptyLocationItem.getLocationId());
// updateLocation.setLocationStatus(LocationStatus.OCCUPY.getCode());
// updateLocation.setVehicleId(taskOutRequest.getVehicleNo());
// locationMapper.modifyLocation(updateLocation); // 占掉库位
// // ---- 更新库存中库位
// stockMapper.updateLocationIdWithBetchNo(taskOutRequest.getVehicleNo(), emptyLocationItem.getLocationId()); // 绑定载具和库位
// // 更新入库单
// appOrderInMapper.updateStatusWithVehicleNo(vehicleNo, OrderInStatusEnum.IN.getCode()); // 更新入库单为入库中
// // 添加入库任务
// Task task = new Task();
// task.setTaskId(UUID.randomUUID().toString());
// task.setTaskType(TaskType.IN.getCode());
// task.setTaskStatus(WmsTaskStatus.NEW.getCode());
// task.setTaskGroup(UUID.randomUUID().toString());
// task.setOrigin(tempTask.getDestination());
// task.setDestination(emptyLocationItem.getLocationId());
// task.setPickStand("");
// task.setWeight(0.0);
// task.setVehicleNo(taskOutRequest.getVehicleNo());
// task.setCreateTime(new Date());
// task.setUserName("wcs");
// task.setGoodsId(vehicleNo);
// task.setGoodsName("");
// task.setOperateNum(0);
// task.setTotalNum(0);
// task.setTaskPriority(1);
// int addTask = taskMapper.addTask(task);
// if(addTask > 0) {
// rsp.setCode(ResponseCode.ERROR.getCode());
// rsp.setMessage("存在入库任务，申请成功！");
// return JSON.toJSONString(rsp);
// }
// rsp.setCode(ResponseCode.ERROR.getCode());
// rsp.setMessage("添加入库任务失败，网络连接异常，请稍后再试");
// return JSON.toJSONString(rsp);
// }
// }
logger.info("更新库存状态成功");
logger.info("下发出库任务成功");
rsp.setCode(ResponseCode.OK.getCode());
@ -563,6 +658,7 @@ public class TaskController extends BaseController {
Task task = new Task();
// 任务编号
task.setTaskId(WmsUtils.generateId("PDCK"));
//task.setTaskId(UUID);
// 任务类型
task.setTaskType(TaskType.INVENTORY.getCode());
// 起点

17
src/main/java/com/wms/controller/TestController.java
View File

@ -46,17 +46,18 @@ public class TestController extends BaseController {
@ResponseBody
public String genLocations() {
// 巷道1 一共2排45列12层
for (int i = 1; i <= 2; i++) {// 排
for (int j = 1; j <= 45; j++) {// 列
for (int k = 1; k <= 12; k++) {// 层
for (int i = 3; i <= 6; i++) {// 排-
for (int j = 1; j < 2; j++) {// 列
for (int k = 1; k <= 5; k++) {// 层
Location tempLocation = new Location();
tempLocation.setLocationId(StringUtils.leftPad(String.valueOf(i), 2, "0") + StringUtils.leftPad(String.valueOf(j), 2, "0") + StringUtils.leftPad(String.valueOf(k), 2, "0"));
tempLocation.setAreaId(1);
//tempLocation.setLocationId(StringUtils.leftPad(String.valueOf(i), 2, "0") + StringUtils.leftPad(String.valueOf(j), 2, "0") + StringUtils.leftPad(String.valueOf(k), 2, "0"));
tempLocation.setLocationId("A"+ i + "-" + j + "-" + k);
tempLocation.setAreaId(2);
tempLocation.setTunnelId(1);
tempLocation.setEquipmentId(1);
tempLocation.setEquipmentId(2);
tempLocation.setLocationType(0);
tempLocation.setQueue(i);
tempLocation.setLine(j);
tempLocation.setQueue(1);
tempLocation.setLine(i);
tempLocation.setLayer(k);
tempLocation.setDepth(1);
tempLocation.setIsLock(0);

44
src/main/java/com/wms/controller/others/ContainerController.java
View File

@ -1,20 +1,21 @@
package com.wms.controller.others;
import com.alibaba.fastjson2.JSON;
import com.wms.controller.BaseController;
import com.wms.entity.app.container.ContainerApiLocalResponse;
import com.wms.entity.app.container.CreateInstoreTaskRequest;
import com.wms.entity.app.container.CreateInstoreTaskResponse;
import com.wms.entity.app.container.TaskStateNoticeRequest;
import com.wms.entity.app.container.*;
import com.wms.service.ContainerService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
/**
* 四向车交互
* @author icewint
*/
@Slf4j
@RestController
@CrossOrigin
@RequestMapping(value = "/api/container")
@ -31,7 +32,16 @@ public class ContainerController extends BaseController {
*/
@PostMapping("/createInstoreTask")
public CreateInstoreTaskResponse createInstoreTask(@RequestBody @Validated CreateInstoreTaskRequest request) {
return containerService.createInstoreTask(request);
try {
log.info("四向车扫码入库请求：{}", JSON.toJSONString(request));
CreateInstoreTaskResponse instoreTask = containerService.createInstoreTask(request);
log.info("四向车扫码入库信息返回：{}", JSON.toJSONString(instoreTask));
return instoreTask;
}catch (Exception e){
log.info("四向车扫码入库失败，出现异常，请稍后再试");
return new CreateInstoreTaskResponse("400", "四向车扫码入库异常,请稍后再试");
}
}
@ -42,8 +52,28 @@ public class ContainerController extends BaseController {
*/
@PostMapping("/taskStateNotice")
public ContainerApiLocalResponse taskStateNotice(@RequestBody @Validated TaskStateNoticeRequest request){
return containerService.taskStateNotice(request);
// try {
log.info("四向车任务状态通知请求：{}", JSON.toJSONString(request));
ContainerApiLocalResponse containerApiLocalResponse = containerService.taskStateNotice(request);
log.info("四向车任务状态通知信息返回：{}", JSON.toJSONString(containerApiLocalResponse));
return containerApiLocalResponse;
// }catch (Exception e){
// log.info("接收到任务反馈失败异常，请稍后再试");
// return new ContainerApiLocalResponse("400", "接收到任务反馈失败，请稍后再试");
// }
}
/**
* 补盘请求
* @param request
* @return
*/
@PostMapping("/createFeedPalletTask")
public CreateFeedPalletTaskResponse createFeedPallet(@RequestBody @Validated CreateFeedPalletTaskRequest request){
log.info("四向车请求补盘：{}", JSON.toJSONString(request));
CreateFeedPalletTaskResponse response = containerService.createFeedPallet(request);
log.info("四向车请求补盘返回通知：{}", JSON.toJSONString(response));
return response;
}
}

487
src/main/java/com/wms/controller/others/WcsController.java
View File

@ -1,6 +1,7 @@
package com.wms.controller.others;
import com.alibaba.fastjson2.JSON;
import com.wms.bussiness.TaskOperation;
import com.wms.constants.enums.*;
import com.wms.entity.app.ResponseEntity;
import com.wms.entity.app.container.ContainerApiLocalResponse;
@ -8,12 +9,12 @@ import com.wms.entity.app.mes.MesApiLocalResponse;
import com.wms.entity.app.mes.SendMesPutInGoodsRequest;
import com.wms.entity.app.wcs.RequireInRequest;
import com.wms.entity.app.wcs.WmsReceiveTaskResultEntity;
import com.wms.entity.table.Location;
import com.wms.entity.table.Stock;
import com.wms.entity.table.Task;
import com.wms.entity.common.WmsApiResponse;
import com.wms.entity.table.*;
import com.wms.mapper.LocationMapper;
import com.wms.mapper.StockMapper;
import com.wms.mapper.TaskMapper;
import com.wms.service.StockService;
import com.wms.service.TaskService;
import com.wms.utils.HttpUtils;
import com.wms.utils.storage.LocationUtils;
@ -27,9 +28,13 @@ import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.Date;
import java.util.List;
import java.util.UUID;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
@Slf4j
@RestController
@ -38,6 +43,11 @@ import java.util.UUID;
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class WcsController {
/**
* 任务操作类
*/
private final TaskOperation taskOperation;
/**
* 库存 Mapper
*/
@ -54,6 +64,10 @@ public class WcsController {
private final TaskMapper taskMapper;
/**
* 库存服务
*/
private final StockService stockService;
/**
* 库位操作类
*/
@ -69,6 +83,11 @@ public class WcsController {
*/
private final TaskService taskService;
/**
* 订单入库 Mapper
*/
private final com.wms.mapper.AppOrderInMapper appOrderInMapper;
/**
* 立库申请入库
@ -77,84 +96,179 @@ public class WcsController {
*/
@PostMapping("/requestIn")
public ResponseEntity requestIn(@RequestBody @Validated RequireInRequest request) {
/* 校验库存是否存在待入库信息 */
Stock checkIsExist = new Stock();
checkIsExist.setBatchNo(request.getVehicleNo());
checkIsExist.setStockStatus(StockStatus.WAIT_IN.getCode());
List<Stock> checkIsExistListResult = stockMapper.selStocks(checkIsExist);
if(checkIsExistListResult == null || checkIsExistListResult.isEmpty()) {
// 记录不存在
return new ResponseEntity(0, String.format("该条码不存在待入库记录，条码号：%s", request.getVehicleNo()));
try {
log.info(String.format("%s 点位请求入库：%s",request.getPoint(), request.getVehicleNo()));
/* 校验库存是否存在对应箱号的入库单 */
AppOrderIn queryVehicleNoOrder = new AppOrderIn();
queryVehicleNoOrder.setVehicleNo(request.getVehicleNo());
queryVehicleNoOrder.setOrderStatus(OrderInStatusEnum.BINDING.getCode());
List<AppOrderIn> queryVehicleNoOrderListResult = appOrderInMapper.select(queryVehicleNoOrder);
if(queryVehicleNoOrderListResult == null) {
return new ResponseEntity(-1, String.format("该条码数据异常，请重试，条码号：%s", request.getVehicleNo()));
}
String code = request.getVehicleNo();
if(code.length() == 22) { // 没有绑定的载具，查找直接单包的数据
//String code = request.getVehicleNo();
// if(code.length() != 22) {
// return new ResponseEntity(999, "条码长度错误" + code.length(), null);
// }
// 前八位是零件号，后面六位是批次，后面一位是班次，最后五位是数量
String goodsId = code.substring(0, 10); // 物料编码
String batchNo = code.substring(0, 16); // 批次 ---- 这个批次应该是料号加中间六位
//String shift = code.substring(16, 17); // 班次
String productionDate = code.substring(10, 16); //生产日期
SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");
Date date;
try {
// 将字符串解析成Date对象
date = dateFormat.parse(productionDate);
} catch (ParseException e) {
throw new RuntimeException(e);
}
String goodsNumStr = code.substring(17, 22); // 数量字符串
if(!goodsNumStr.matches("[0-9]+")) {
return new ResponseEntity(999, "数量格式错误", null);
}
BigDecimal goodsNum = new BigDecimal(goodsNumStr); // 数量
AppOrderIn appOrderIn = new AppOrderIn();
appOrderIn.setBatchNo(batchNo);
appOrderIn.setGoodsNum(goodsNum);
appOrderIn.setOrderStatus(OrderInStatusEnum.CREATE.getCode());
List<AppOrderIn> selectRows = appOrderInMapper.select(appOrderIn);
if(selectRows == null || selectRows.isEmpty()) {
return new ResponseEntity(999, String.format("条码找不到入库单，无法绑定，条码：%s, 批次: %s, 数量: %s", code, batchNo, goodsNum), null);
}
AppOrderIn orderIn = selectRows.get(0); // 这条数据
/* 查找一个空库位 */
Location emptyLocation = new Location();
emptyLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
emptyLocation.setAreaId(1);
List<Location> emptyLocations = locationMapper.selLocations(emptyLocation);
if(emptyLocations == null) {
return new ResponseEntity(-1, "库位查找失败，网络连接异常，请稍后再试");
}
if(emptyLocations.isEmpty()){
return new ResponseEntity(-1, "没有可用库位");
}
Location emptyLocationItem = locationUtils.checkCanUse(emptyLocations);
if(emptyLocationItem == null) {
return new ResponseEntity(-1, "没有可用库位或者库位存在干涉，请稍后再试");
}
// 该空库位可用，生成一个入库任务，并将库存表更新库位
// 更新库位表，占掉库位
Location updateLocation = new Location();
updateLocation.setLocationId(emptyLocationItem.getLocationId());
updateLocation.setLocationStatus(LocationStatus.OCCUPY.getCode());
updateLocation.setVehicleId(request.getVehicleNo());
locationMapper.modifyLocation(updateLocation); // 占掉库位
// ---- 更新库存中库位
stockMapper.updateLocationIdWithBetchNo(request.getVehicleNo(), emptyLocationItem.getLocationId()); // 绑定载具和库位
// 更新入库单
AppOrderIn orderInUpdate = new AppOrderIn();
orderInUpdate.setRowId(orderIn.getRowId());
orderInUpdate.setOrderStatus(OrderInStatusEnum.IN.getCode());
orderInUpdate.setUpdateTime(LocalDateTime.now());
//orderInUpdate.setProductionDate(date);
appOrderInMapper.update(orderInUpdate); // 更新入库单为入库中
// 添加入库任务
Task task = new Task();
task.setTaskId(UUID.randomUUID().toString());
task.setTaskType(TaskType.IN.getCode());
task.setTaskStatus(WmsTaskStatus.NEW.getCode());
task.setTaskGroup(UUID.randomUUID().toString());
task.setOrigin(request.getPoint());
task.setDestination(emptyLocationItem.getLocationId());
task.setPickStand("");
task.setWeight(0.0);
task.setVehicleNo(request.getVehicleNo());
task.setCreateTime(new Date());
task.setUserName("wcs");
task.setGoodsId(goodsId);
task.setGoodsName("");
task.setOperateNum(0);
task.setTotalNum(0);
task.setTaskPriority(1);
task.setProductionDate(date);
task.setRemark1(appOrderIn.getRemark());
//appOrderInMapper.insert(orderIn);
int addTask = taskMapper.addTask(task);
if(addTask > 0) {
//stockMapper.insert(task);
return new ResponseEntity(0, "存在入库任务，申请成功");
}
return new ResponseEntity(-1, "添加入库任务失败，网络连接异常，请稍后再试");
} else if (code.length() == 19) {
// 绑定完载具的数据入库
//根据母码去找入库单
AppOrderIn appOrderIn = new AppOrderIn();
appOrderIn.setVehicleNo(request.getVehicleNo());
appOrderIn.setOrderStatus(OrderInStatusEnum.BINDING.getCode());
List<AppOrderIn> selectRows = appOrderInMapper.select(appOrderIn);
if(selectRows == null || selectRows.isEmpty()) {
return new ResponseEntity(999, String.format("条码找不到入库单，无法绑定，条码：%s", code), null);
}
String vehicleNo = request.getVehicleNo(); // 载具号
/* 查找一个空库位 */
Location emptyLocation = new Location();
emptyLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
emptyLocation.setAreaId(1);
List<Location> emptyLocations = locationMapper.selLocations(emptyLocation);
if(emptyLocations == null) {
return new ResponseEntity(-1, "库位查找失败，网络连接异常，请稍后再试");
}
if(emptyLocations.isEmpty()){
return new ResponseEntity(-1, "没有可用库位");
}
Location emptyLocationItem = locationUtils.checkCanUse(emptyLocations);
if(emptyLocationItem == null) {
return new ResponseEntity(-1, "没有可用库位或者库位存在干涉，请稍后再试");
}
// 该空库位可用，生成一个入库任务，并将库存表更新库位
// 更新库位表，占掉库位
Location updateLocation = new Location();
updateLocation.setLocationId(emptyLocationItem.getLocationId());
updateLocation.setLocationStatus(LocationStatus.OCCUPY.getCode());
updateLocation.setVehicleId(request.getVehicleNo());
locationMapper.modifyLocation(updateLocation); // 占掉库位
// ---- 更新库存中库位
stockMapper.updateLocationIdWithBetchNo(request.getVehicleNo(), emptyLocationItem.getLocationId()); // 绑定载具和库位
// 更新入库单
appOrderInMapper.updateStatusWithVehicleNo(vehicleNo, OrderInStatusEnum.IN.getCode()); // 更新入库单为入库中
// List<AppOrderIn> selectRows = appOrderInMapper.selectWithVehicle(request.getVehicleNo());
// Date productionDate = new Date();
//添加入库任务
Task task = new Task();
task.setTaskId(UUID.randomUUID().toString());
task.setTaskType(TaskType.IN.getCode());
task.setTaskStatus(WmsTaskStatus.NEW.getCode());
task.setTaskGroup(UUID.randomUUID().toString());
task.setOrigin(request.getPoint());
task.setDestination(emptyLocationItem.getLocationId());
task.setPickStand("");
task.setWeight(0.0);
task.setVehicleNo(request.getVehicleNo());
task.setCreateTime(new Date());
task.setUserName("wcs");
task.setGoodsId(vehicleNo);
task.setGoodsName("");
task.setOperateNum(0);
task.setTotalNum(0);
task.setTaskPriority(1);
//task.setProductionDate();
//appOrderInMapper.insertList(emptyLocations);
int addTask = taskMapper.addTask(task);
if(addTask > 0) {
return new ResponseEntity(0, "存在入库任务，申请成功");
}
return new ResponseEntity(-1, "添加入库任务失败，网络连接异常，请稍后再试");
}
return new ResponseEntity(999, "条码长度错误" + code.length(), null);
}catch (Exception e){
log.info("入库申请失败，出现异常，请稍后再试");
return new ResponseEntity(-1, "入库申请失败，网络连接异常，请稍后再试");
}
/* 查找一个空库位 */
Location emptyLocation = new Location();
emptyLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
emptyLocation.setAreaId(1);
List<Location> emptyLocations = locationMapper.selLocations(emptyLocation);
if(emptyLocations == null) {
return new ResponseEntity(0, "库位查找失败，网络连接异常，请稍后再试");
}
if(emptyLocations.isEmpty()){
return new ResponseEntity(0, "没有可用库位");
}
Location emptyLocationItem = locationUtils.checkCanUse(emptyLocations);
if(emptyLocationItem == null) {
return new ResponseEntity(0, "没有可用库位或者库位存在干涉，请稍后再试");
}
// 该空库位可用，生成一个入库任务，并将库存表更新库位
// 更新库位表，占掉库位
Location updateLocation = new Location();
updateLocation.setLocationId(emptyLocationItem.getLocationId());
updateLocation.setLocationStatus(LocationStatus.OCCUPY.getCode());
updateLocation.setVehicleId(request.getVehicleNo());
locationMapper.modifyLocation(updateLocation);
// ---- 更新库存中库位
stockMapper.updateLocationIdWithBetchNo(request.getVehicleNo(), emptyLocationItem.getLocationId());
stockMapper.updateStockStatusWithLocationId(emptyLocationItem.getLocationId(), StockStatus.IN_ING.getCode());
// 添加入库任务
Task task = new Task();
task.setTaskId(UUID.randomUUID().toString());
task.setTaskType(TaskType.IN.getCode());
task.setTaskStatus(WmsTaskStatus.NEW.getCode());
task.setTaskGroup(UUID.randomUUID().toString());
task.setOrigin("");
task.setDestination(emptyLocationItem.getLocationId());
task.setPickStand("");
task.setWeight(0.0);
task.setVehicleNo(request.getVehicleNo());
task.setCreateTime(new Date());
task.setUserName("wcs");
task.setGoodsId("");
task.setGoodsName("");
task.setOperateNum(0);
task.setTotalNum(0);
task.setTaskPriority(1);
int addTask = taskMapper.addTask(task);
if(addTask > 0) {
sendMesPutInGoods(checkIsExistListResult.get(0), emptyLocationItem.getLocationId()); // 发送 mes 入库上架
return new ResponseEntity(1, "存在入库任务，申请成功");
}
return new ResponseEntity(0, "添加入库任务失败，网络连接异常，请稍后再试");
}
private void sendMesPutInGoods(Stock stock, String locationId) {
SendMesPutInGoodsRequest request = new SendMesPutInGoodsRequest();
request.setGuid(stock.getStockId());
request.setLosnr(stock.getBatchNo());
request.setItemCode(stock.getGoodsId());
request.setLotQty(String.valueOf(stock.getRealNum()));
request.setBinCode(locationId);
String requestString = JSON.toJSONString(request);
String responseString = HttpUtils.sendHttpPostWithoutToken(UrlEnums.URL_WMS_TO_MES_IN.getValue(), requestString);
MesApiLocalResponse result = JSON.parseObject(responseString, MesApiLocalResponse.class);
if(result != null && result.getTransFlag().equals(1)) {
log.info("发送MES入库上架成功，信息：{}", requestString);
}
log.info("发送MES入库上架失败，信息：{}，返回信息：{}", requestString, responseString);
}
/**
* 收到 wcs 返回的任务状态
* @param wmsReceiveTaskResultEntity wcs请求值
@ -163,177 +277,48 @@ public class WcsController {
@PostMapping("/sendTaskResult")
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public ResponseEntity receiveTaskResult(@RequestBody @Validated WmsReceiveTaskResultEntity wmsReceiveTaskResultEntity) {
log.info("接收到任务反馈：{}，ip地址：{}", wmsReceiveTaskResultEntity.toLoggerString(), HttpUtils.getIpAddr(servletRequest));
// 获取任务号
String taskId = wmsReceiveTaskResultEntity.getTaskId();
Integer taskStatus = wmsReceiveTaskResultEntity.getTaskStatus();
String vehicleNo = wmsReceiveTaskResultEntity.getVehicleNo();
// 查找对应任务
Task taskForQuery = new Task();
taskForQuery.setTaskGroup(taskId);
List<Task> tasks = taskService.selTasks(taskForQuery);
if(tasks == null || tasks.isEmpty()) {
return new ResponseEntity(-1, "没有找到对应的任务");
try{
log.info("接收到任务反馈1：{}，ip地址：{}", wmsReceiveTaskResultEntity.toLoggerString(), HttpUtils.getIpAddr(servletRequest));
// 获取任务号
String taskId = wmsReceiveTaskResultEntity.getTaskId();
Integer taskStatus = wmsReceiveTaskResultEntity.getTaskStatus();
String vehicleNo = wmsReceiveTaskResultEntity.getVehicleNo();
if (taskId == null){
log.info("获取任务号失败");
}
log.info("获取任务号成功");
// 查找对应任务
Task taskForQuery = new Task();
taskForQuery.setTaskId(taskId);
List<Task> tasks = taskService.selTasks(taskForQuery);
if(tasks == null || tasks.isEmpty()) {
log.info("没有找到对应的任务");
return new ResponseEntity(-1, "没有找到对应的任务");
}
Task task = tasks.get(0);
if(taskStatus.equals(WmsTaskStatus.FINISH.getCode())) { // 任务完成
boolean completedTask = taskOperation.completeTask(task);
if(!completedTask) {
log.info("任务完成失败");
return new ResponseEntity(-1, "任务完成失败，请稍后再试");
}
log.info("任务完成成功");
return new ResponseEntity(0, "任务完成成功");
}
if(taskStatus.equals(WmsTaskStatus.CANCEL.getCode())) { // 任务取消
boolean cancelledTask = taskOperation.cancelTask(task);
if(!cancelledTask) {
return new ResponseEntity(-1, "任务取消失败，请稍后再试");
}
return new ResponseEntity(0, "任务取消成功");
}
log.info("不处理的状态");
return new ResponseEntity(0, "不处理的状态");
}catch (Exception e){
log.error("接收到任务反馈失败，ip地址：{}", HttpUtils.getIpAddr(servletRequest), e);
return new ResponseEntity(-1, "接收到任务反馈失败，请稍后再试");
}
Task task = tasks.get(0);
if(taskStatus.equals(WmsTaskStatus.FINISH.getCode())) { // 任务完成
if(task.getTaskType().equals(TaskType.IN.getCode())) { // 入库
/* 找出任务，完成该任务；找出该任务终点，更新库存为OK */
// 完成任务
Task completeTask = new Task();
completeTask.setTaskId(task.getTaskId());
completeTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
completeTask.setFinishTime(new Date());
taskMapper.executeTask(completeTask); // 完成任务
// 更新库存为 ok
int updateStock = stockMapper.updateStockStatusWithLocationId(task.getDestination(), StockStatus.OK.getCode());
if(updateStock > 0){
log.info("入库完成更新库存成功，任务：{}", task.toLoggerString());
return new ResponseEntity(0, "入库完成");
}
return new ResponseEntity(0, "入库完成，更新库存失败");
}
if(task.getTaskType().equals(TaskType.OUT.getCode())) { // 出库
/* 找出任务，完成该任务；找出该任务终点，删除库存；释放库位 */
// 完成任务
Task completeTask = new Task();
completeTask.setTaskId(task.getTaskId());
completeTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
completeTask.setFinishTime(new Date());
taskMapper.executeTask(completeTask); // 完成任务
// 释放库位
Location updateLocation = new Location();
updateLocation.setLocationId(task.getOrigin());
updateLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
updateLocation.setVehicleId("");
locationMapper.modifyLocation(updateLocation); // 更新库位为空
// 删除库存
int updateStock = stockMapper.deleteStockWithLocationId(task.getOrigin());
if(updateStock > 0){
log.info("出库完成删除库存成功，任务：{}", task.toLoggerString());
return new ResponseEntity(0, "出库完成");
}
return new ResponseEntity(0, "出库完成，删除库存失败");
}
if(task.getTaskType().equals(TaskType.INVENTORY.getCode())) { // 盘点
/* 找出任务，完成该任务；找出该任务终点，删除库存；释放库位 */
// 完成任务
Task completeTask = new Task();
completeTask.setTaskId(task.getTaskId());
completeTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
completeTask.setFinishTime(new Date());
taskMapper.executeTask(completeTask); // 完成任务
// 释放库位
Location updateLocation = new Location();
updateLocation.setLocationId(task.getOrigin());
updateLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
updateLocation.setVehicleId("");
locationMapper.modifyLocation(updateLocation); // 更新库位为空
// 删除库存
int updateStock = stockMapper.deleteStockWithLocationId(task.getOrigin());
if(updateStock > 0){
log.info("盘点出库完成删除库存成功，任务：{}", task.toLoggerString());
return new ResponseEntity(0, "盘点出库完成");
}
return new ResponseEntity(0, "盘点出库完成，删除库存失败");
}
if(task.getTaskType().equals(TaskType.MOVE.getCode())) { // 移库
/* 找出任务，更新任务为完成；释放原库位；更新库存到新库位 */
// 完成任务
Task completeTask = new Task();
completeTask.setTaskId(task.getTaskId());
completeTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
completeTask.setFinishTime(new Date());
taskMapper.executeTask(completeTask); // 完成任务
// 释放原库位
// 释放库位
Location updateLocation = new Location();
updateLocation.setLocationId(task.getOrigin());
updateLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
updateLocation.setVehicleId("");
locationMapper.modifyLocation(updateLocation); // 更新库位为空
// 更新库位
int updatedLocation = stockMapper.updateLocationAndStatus(task.getOrigin(), task.getDestination(), StockStatus.OK.getCode());
if(updatedLocation > 0){
log.info("移库库位更新成功，任务：{}", task.toLoggerString());
return new ResponseEntity(0, "移库库位更新成功");
}
return new ResponseEntity(0, "移库库位更新失败");
}
}
if(taskStatus.equals(WmsTaskStatus.CANCEL.getCode())) { // 任务取消
if(task.getTaskType().equals(TaskType.IN.getCode())) { // 入库
/* 找出任务，取消该任务；找出该任务终点，更新库存为OK */
// 取消任务
Task completeTask = new Task();
completeTask.setTaskId(task.getTaskId());
completeTask.setTaskStatus(WmsTaskStatus.CANCEL.getCode());
completeTask.setFinishTime(new Date());
taskMapper.executeTask(completeTask); // 取消任务
// 更新库存为 ok
int updateStock = stockMapper.updateStockStatusWithLocationId(task.getDestination(), StockStatus.OK.getCode());
if(updateStock > 0){
log.info("入库取消更新库存成功，任务：{}", task.toLoggerString());
return new ResponseEntity(0, "入库取消");
}
return new ResponseEntity(0, "入库取消，更新库存失败");
}
if(task.getTaskType().equals(TaskType.OUT.getCode())) { // 出库
/* 找出任务，取消该任务；找出该任务终点，删除库存；释放库位 */
// 取消任务
Task completeTask = new Task();
completeTask.setTaskId(task.getTaskId());
completeTask.setTaskStatus(WmsTaskStatus.CANCEL.getCode());
completeTask.setFinishTime(new Date());
taskMapper.executeTask(completeTask); // 取消任务
// 更新库存为 ok
int updateStock = stockMapper.updateStockStatusWithLocationId(task.getDestination(), StockStatus.OK.getCode());
if(updateStock > 0){
log.info("出库取消更新库存成功，任务：{}", task.toLoggerString());
return new ResponseEntity(0, "出库取消");
}
return new ResponseEntity(0, "出库取消，更新库存失败");
}
if(task.getTaskType().equals(TaskType.INVENTORY.getCode())) { // 盘点
/* 找出任务，取消该任务；找出该任务终点，删除库存；释放库位 */
// 取消任务
Task completeTask = new Task();
completeTask.setTaskId(task.getTaskId());
completeTask.setTaskStatus(WmsTaskStatus.CANCEL.getCode());
completeTask.setFinishTime(new Date());
taskMapper.executeTask(completeTask); // 取消任务
// 更新库存为 ok
int updateStock = stockMapper.updateStockStatusWithLocationId(task.getDestination(), StockStatus.OK.getCode());
if(updateStock > 0){
log.info("盘点出库取消更新库存成功，任务：{}", task.toLoggerString());
return new ResponseEntity(0, "盘点出库取消");
}
return new ResponseEntity(0, "盘点出库取消，更新库存失败");
}
if(task.getTaskType().equals(TaskType.MOVE.getCode())) { // 移库
/* 找出任务，更新任务为取消；释放新库位；更新库存为OK */
// 取消任务
Task completeTask = new Task();
completeTask.setTaskId(task.getTaskId());
completeTask.setTaskStatus(WmsTaskStatus.CANCEL.getCode());
completeTask.setFinishTime(new Date());
taskMapper.executeTask(completeTask); // 取消任务
// 释放库位
Location updateLocation = new Location();
updateLocation.setLocationId(task.getDestination());
updateLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
updateLocation.setVehicleId("");
locationMapper.modifyLocation(updateLocation); // 更新库位为空
// 更新库位
int updatedLocation = stockMapper.updateStockStatusWithLocationId(task.getOrigin(), StockStatus.OK.getCode());
if(updatedLocation > 0){
log.info("移库取消库位状态更新成功，任务：{}", task.toLoggerString());
return new ResponseEntity(0, "移库取消库位状态更新成功");
}
return new ResponseEntity(0, "移库取消库位状态更新失败");
}
}
return new ResponseEntity(0, "不处理的状态");
}
}

32
src/main/java/com/wms/entity/app/container/CreateFeedPalletTaskRequest.java Normal file
View File

@ -0,0 +1,32 @@
package com.wms.entity.app.container;
import com.fasterxml.jackson.annotation.JsonProperty;
import jakarta.validation.constraints.NotBlank;
import lombok.Data;
@Data
public class CreateFeedPalletTaskRequest {
/**
* 请求ID
*/
@NotBlank
@JsonProperty("requestid")
private String requestId;
/**
* 密钥
*/
@NotBlank
@JsonProperty("key")
private String key;
/**
* 补盘口
*/
@NotBlank
@JsonProperty("tocellno")
private String toCellNo;
}

55
src/main/java/com/wms/entity/app/container/CreateFeedPalletTaskResponse.java Normal file
View File

@ -0,0 +1,55 @@
package com.wms.entity.app.container;
import com.fasterxml.jackson.annotation.JsonProperty;
import jakarta.validation.constraints.NotBlank;
import lombok.Data;
@Data
public class CreateFeedPalletTaskResponse {
public CreateFeedPalletTaskResponse() {
}
public CreateFeedPalletTaskResponse(String code, String message) {
this.code = code;
this.message = message;
}
/**
* 响应代码
*/
@JsonProperty("code")
private String code;
/**
* wms 任务号
*/
@JsonProperty("wmstaskid")
private String wmsTaskId;
/**
* 载具号
*/
@JsonProperty("palletno")
private String palletNo;
/**
* 出盘口
*/
@JsonProperty("fromcellno")
private String fromCellNo;
/**
* 入盘口
*/
@JsonProperty("tocellno")
private String toCellNo;
/**
* 信息
*/
@JsonProperty("message")
private String message;
}

1
src/main/java/com/wms/entity/app/container/CreateInstoreTaskRequest.java
View File

@ -28,7 +28,6 @@ public class CreateInstoreTaskRequest {
/**
* 托盘号
*/
@NotBlank(message = "托盘号不允许为空")
@JsonProperty("palletno")
private String palletNo;

13
src/main/java/com/wms/entity/app/mes/OutNoticeRequest.java
View File

@ -3,6 +3,7 @@ package com.wms.entity.app.mes;
import com.fasterxml.jackson.annotation.JsonProperty;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Pattern;
import lombok.Data;
@ -38,9 +39,17 @@ public class OutNoticeRequest {
/**
* 目的库别
*/
@NotBlank(message = "目的库别不允许为空或者空字符串")
//@NotBlank(message = "目的库别不允许为空或者空字符串")
@JsonProperty("Twarehouse")
private String TWarehouse;
private String tWarehouse;
/**
* 出库类型
*/
@NotNull(message = "类型不允许为空")
@JsonProperty("Type")
private Integer type;
/**
* 计划交货日期

9
src/main/java/com/wms/entity/app/mes/OutNoticeRequestRow.java
View File

@ -27,11 +27,16 @@ public class OutNoticeRequestRow {
private String itemCode;
/**
* 数量
* 数量??????
*/
@Pattern(regexp = "^\\d+$", message = "数量必须为数字")
//@Pattern(regexp = "^\\\\d*(\\\\.\\\\d+)?$", message = "数量必须为数字")
//@Pattern(regexp = "^\\d+$", message = "数量必须为数字")
@JsonProperty("Qty")
private String qty;
// @Pattern(regexp = ".*", message = "数量必须为字符串")
// @JsonProperty("Qty")
// private String qty;
/**
* 单位

14
src/main/java/com/wms/entity/app/mes/ReceiptInRequest.java
View File

@ -35,13 +35,19 @@ public class ReceiptInRequest {
* 批次号
*/
@JsonProperty("Losnr")
@NotBlank(message = "批次号不允许为空")
//@NotBlank(message = "批次号不允许为空")
public String losnr;
/**
* 载具号
*/
@JsonProperty("VehicleNo")
public String vehicleNo;
/**
* 料号
*/
@JsonProperty("Itemcode")
@JsonProperty("ItemCode")
@NotBlank(message = "料号不允许为空")
public String itemCode;
@ -50,7 +56,9 @@ public class ReceiptInRequest {
*/
@JsonProperty("LotQty")
@NotNull(message = "数量不允许为空")
@Pattern(regexp = "^\\d+$", message = "数量必须为数字")
//@Pattern(regexp = "^\\d+$", message = "数量必须为数字")
//@Pattern(regexp = "^\\\\d*(\\\\.\\\\d+)?$", message = "数量必须为数字")
//@Pattern(regexp = "^\\d*(\\.\\d+)?$", message = "数量必须为有效的数字字符串")
public String lotQty;
/**

26
src/main/java/com/wms/entity/app/mes/SendMesGoodsInventoryRequest.java Normal file
View File

@ -0,0 +1,26 @@
package com.wms.entity.app.mes;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
import java.util.List;
/**
* 发送mes 盘点执行
*/
@Data
public class SendMesGoodsInventoryRequest {
@JsonProperty("guid")
private String guid;
@JsonProperty("InventoryNo")
private String inventoryNo;
@JsonProperty("Row")
private List<SendMesGoodsInventoryRow> row;
}

20
src/main/java/com/wms/entity/app/mes/SendMesGoodsInventoryRow.java Normal file
View File

@ -0,0 +1,20 @@
package com.wms.entity.app.mes;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
@Data
public class SendMesGoodsInventoryRow {
@JsonProperty("Losnr")
private String losnr;
@JsonProperty("LotQty")
private String lotQty;
@JsonProperty("Warehouse")
private String warehouse;
}

29
src/main/java/com/wms/entity/app/mes/SendMesGoodsMoveRequest.java Normal file
View File

@ -0,0 +1,29 @@
package com.wms.entity.app.mes;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
/**
* 发送mes移库完成
*/
@Data
public class SendMesGoodsMoveRequest {
@JsonProperty("guid")
private String guid;
@JsonProperty("Losnr")
private String losnr;
@JsonProperty("LotQty")
private String lotQty;
@JsonProperty("FBinCOde")
private String fBinCode;
@JsonProperty("TBinCode")
private String tBinCode;
}

27
src/main/java/com/wms/entity/app/mes/SendMesPutOutGoodsRequest.java Normal file
View File

@ -0,0 +1,27 @@
package com.wms.entity.app.mes;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
import java.util.List;
/**
* 发送mes出库信息
*/
@Data
public class SendMesPutOutGoodsRequest {
@JsonProperty("guid")
private String guid;
@JsonProperty("TransferNo")
private String transferNo;
@JsonProperty("Type")
private int type;
@JsonProperty("Row")
private List<SendMesPutOutGoodsRow> row;
}

31
src/main/java/com/wms/entity/app/mes/SendMesPutOutGoodsRow.java Normal file
View File

@ -0,0 +1,31 @@
package com.wms.entity.app.mes;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
@Data
public class SendMesPutOutGoodsRow {
//行号
@JsonProperty("TransferLine")
private String transferLine;
//批次
@JsonProperty("Losnr")
private String losnr;
//数量
@JsonProperty("LotQty")
private String lotQty;
//箱号
@JsonProperty("VehicleNo")
private String vehicleNo;
//仓库
@JsonProperty("Warehouse")
private String warehouse;
}

32
src/main/java/com/wms/entity/app/mes/SendMesStockRequest.java Normal file
View File

@ -0,0 +1,32 @@
package com.wms.entity.app.mes;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
@Data
public class SendMesStockRequest {
@JsonProperty("guid")
private String guid;
@JsonProperty("Warehouse")
private String Warehouse;
@JsonProperty("ItemCode")
private String ItemCode;
@JsonProperty("Losnr")
private String Losnr;
@JsonProperty("LotQty")
private String LotQty;
@JsonProperty("Unit")
private String Unit;
@JsonProperty("BinCode")
private String BinCode;
@JsonProperty("VehicleNo")
private String VehicleNo;
}

30
src/main/java/com/wms/entity/common/WmsApiResponse.java Normal file
View File

@ -0,0 +1,30 @@
package com.wms.entity.common;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
@Data
@AllArgsConstructor
public class WmsApiResponse<T> {
/**
* 返回代码
*/
@JsonProperty(value = "code")
private Integer code;
/**
* 返回消息
*/
@JsonProperty(value = "message")
private String message;
/**
* 返回信息
*/
@JsonProperty(value = "returnData")
private T returnData;
}

21
src/main/java/com/wms/entity/dto/orderCheck/queryOrderCheckRequest.java Normal file
View File

@ -0,0 +1,21 @@
package com.wms.entity.dto.orderCheck;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
import java.util.List;
@Data
public class queryOrderCheckRequest {
/**
* 查询参数
*/
@JsonProperty(value = "searchStr")
private String searchStr;
/**
* 状态
*/
@JsonProperty(value = "orderStatus")
public List<Integer> orderStatus;
}

12
src/main/java/com/wms/entity/dto/orderCheck/remarkOrderCheckRequest.java Normal file
View File

@ -0,0 +1,12 @@
package com.wms.entity.dto.orderCheck;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
@Data
public class remarkOrderCheckRequest {
@JsonProperty(value = "remarkReturn")
private String remarkReturn;
}

21
src/main/java/com/wms/entity/dto/orderIn/bindingVehicleRequest.java Normal file
View File

@ -0,0 +1,21 @@
package com.wms.entity.dto.orderIn;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
@Data
public class bindingVehicleRequest {
/**
* 载具号
*/
@JsonProperty(value = "vehicleNo")
private String vehicleNo;
/**
* 条码
*/
@JsonProperty(value = "code")
private String code;
}

39
src/main/java/com/wms/entity/dto/orderIn/downOrderInRequest.java Normal file
View File

@ -0,0 +1,39 @@
package com.wms.entity.dto.orderIn;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
@Data
public class downOrderInRequest {
/**
* 零件号
*/
@JsonProperty(value = "goodsId")
public String goodsId;
/**
* 数量
*/
@JsonProperty(value = "goodsNum")
public int goodsNum;
/**
* 载具号
*/
@JsonProperty(value = "vehicleNo")
public String vehicleNo;
/**
* 仓库区域
*/
@JsonProperty(value = "abcSelect")
public String abcSelect;
/**
* 入库种类，e为单，f为多种
*/
@JsonProperty(value = "efSelect")
public String efSelect;
}

25
src/main/java/com/wms/entity/dto/orderIn/queryOrderInRequest.java Normal file
View File

@ -0,0 +1,25 @@
package com.wms.entity.dto.orderIn;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
import java.time.LocalDate;
import java.util.List;
@Data
public class queryOrderInRequest {
/**
* 查询参数
*/
@JsonProperty(value = "searchStr")
private String searchStr;
/**
* 状态
*/
@JsonProperty(value = "orderStatus")
public List<Integer> orderStatus;
}

18
src/main/java/com/wms/entity/dto/orderIn/updateNumRequest.java Normal file
View File

@ -0,0 +1,18 @@
package com.wms.entity.dto.orderIn;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
import java.math.BigDecimal;
@Data
public class updateNumRequest {
@JsonProperty(value = "rowId")
private String rowId;
@JsonProperty(value = "realNum")
private BigDecimal realNum;
}

36
src/main/java/com/wms/entity/dto/orderOut/handOrderOutRequest.java Normal file
View File

@ -0,0 +1,36 @@
package com.wms.entity.dto.orderOut;
import com.fasterxml.jackson.annotation.JsonProperty;
import java.util.List;
public class handOrderOutRequest {
/**
* 查询参数
*/
@JsonProperty(value = "goodsId")
public String goodsId;
/**
* 状态
*/
@JsonProperty(value = "goodsNum")
public int goodsNum;
/**
* 载具号
*/
@JsonProperty(value = "vehicleNo")
public String vehicleNo;
/**
* 库位
*/
@JsonProperty(value = "location")
public String location;
}

23
src/main/java/com/wms/entity/dto/orderOut/queryOrderOutRequest.java Normal file
View File

@ -0,0 +1,23 @@
package com.wms.entity.dto.orderOut;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
import java.util.List;
@Data
public class queryOrderOutRequest {
/**
* 查询参数
*/
@JsonProperty(value = "searchStr")
private String searchStr;
/**
* 状态
*/
@JsonProperty(value = "orderStatus")
public List<Integer> orderStatus;
}

128
src/main/java/com/wms/entity/table/AppOrderIn.java Normal file
View File

@ -0,0 +1,128 @@
package com.wms.entity.table;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.wms.utils.excel.ExcelExport;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.poi.hpsf.Decimal;
import org.springframework.format.annotation.DateTimeFormat;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.Date;
/**
* tbl_app_order_in 的实体类
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class AppOrderIn {
public AppOrderIn(String guid) {
this.guid = guid;
}
public AppOrderIn(String betchId, BigDecimal goodsNum, Integer orderStatus) {
this.batchNo = betchId;
this.goodsNum = goodsNum;
this.orderStatus = orderStatus;
}
/**
* 主键
*/
@JsonProperty(value = "rowId")
private String rowId;
/**
* 唯一标识
*/
@JsonProperty(value = "guid")
private String guid;
/**
* 订单类型
*/
@JsonProperty(value = "inType")
private Integer inType;
/**
* 批次号
*/
@JsonProperty(value = "batchNo")
private String batchNo;
/**
* 载具号
*/
@JsonProperty(value = "vehicleNo")
private String vehicleNo;
/**
* 商品id
*/
@JsonProperty(value = "goodsId")
private String goodsId;
/**
* 商品数量
*/
@JsonProperty(value = "goodsNum")
private BigDecimal goodsNum;
/**
* 仓库
*/
@JsonProperty(value = "wareHouse")
private String wareHouse;
/**
* 订单状态
*/
@JsonProperty(value = "orderStatus")
private Integer orderStatus;
/**
* 创建时间
*/
@JsonProperty(value = "createTime")
private LocalDateTime createTime;
// /**
// * 生产日期
// */
@JsonProperty(value = "productionDate")
private String productionDate;
// @ExcelExport("生产日期")
// @DateTimeFormat(pattern = "yyyy-MM-dd")
// @JsonFormat(pattern = "yyyy-MM-dd")
// private Date productionDate;
/**
* 创建人
*/
@JsonProperty(value = "createPerson")
private String createPerson;
/**
* 修改时间
*/
@JsonProperty(value = "updateTime")
private LocalDateTime updateTime;
/**
* 备注
*/
@JsonProperty(value = "remark")
private String remark;
}

10
src/main/java/com/wms/entity/table/Location.java
View File

@ -12,6 +12,16 @@ public class Location extends BaseEntity {
*/
private String locationId;
private String wareArea;
public String getWareArea() {
return wareArea;
}
public void setWareArea(String wareArea) {
this.wareArea = wareArea;
}
/**
* 库区编号
*/

8
src/main/java/com/wms/entity/table/OrderCheck.java
View File

@ -1,5 +1,6 @@
package com.wms.entity.table;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Data;
import java.util.Date;
@ -14,36 +15,43 @@ public class OrderCheck {
/**
* 记录号，唯一识别号
*/
@JsonProperty(value = "recordId")
private String recordId;
/**
* 盘点通知单号
*/
@JsonProperty(value = "checkId")
private String checkId;
/**
* 库别
*/
@JsonProperty(value = "warehouse")
private String warehouse;
/**
* 状态
*/
@JsonProperty(value = "status")
private Integer status;
/**
* 创建时间
*/
@JsonProperty(value = "createTime")
private Date createTime;
/**
* 完成时间
*/
@JsonProperty(value = "completeTime")
private Date completeTime;
/**
* 备注
*/
@JsonProperty(value = "remark")
private String remark;

40
src/main/java/com/wms/entity/table/OrderOut.java
View File

@ -1,6 +1,9 @@
package com.wms.entity.table;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
@ -9,26 +12,44 @@ import java.util.Date;
* tbl_app_order_out
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class OrderOut {
public OrderOut(String rowId) {
this.rowId = rowId;
}
/**
* 主键
*/
@JsonProperty(value = "rowId")
private String rowId;
/**
* 记录号
*/
@JsonProperty(value = "recordId")
private String recordId;
/**
* 出库通知单号
*/
@JsonProperty(value = "orderId")
private String orderId;
/**
* 起始库区
*/
@JsonProperty(value = "warehouseOrigin")
private String warehouseOrigin;
/**
* 目的库区
*/
@JsonProperty(value = "warehouseDestination")
private String warehouseDestination;
/**
@ -37,52 +58,69 @@ public class OrderOut {
* 2：调拨出库单
* 3：出货通知单
*/
@JsonProperty(value = "orderType")
private Integer orderType;
/**
* 交货时间
*/
@JsonProperty(value = "deliveryTime")
private Date deliveryTime;
/**
* 行号
*/
@JsonProperty(value = "rowNo")
private Integer rowNo;
/**
* 物料编号
*/
@JsonProperty(value = "goodsId")
private String goodsId;
/**
* 物料名称
*/
@JsonProperty(value = "goodsName")
private String goodsName;
/**
* 物料数量
*/
private Integer goodsNum;
@JsonProperty(value = "goodsNum")
private String goodsNum;
/**
* 单位
*/
@JsonProperty(value = "unit")
private String unit;
/**
* 状态
*/
@JsonProperty(value = "status")
private Integer status;
/**
* 创建时间
*/
@JsonProperty(value = "createTime")
private Date createTime;
/**
* 备注
*/
@JsonProperty(value = "remark")
private String remark;
/**
* 批次号
*/
@JsonProperty(value = "batchNo")
private String batchNo;
}

1
src/main/java/com/wms/entity/table/Task.java
View File

@ -12,6 +12,7 @@ import java.util.Date;
*/
public class Task extends BaseEntity {
/**
* 物料编号
*/

1
src/main/java/com/wms/entity/table/Vehicle.java
View File

@ -10,6 +10,7 @@ public class Vehicle extends BaseEntity {
* 载具编号
*/
private String vehicleId;
/**
* 当前所在位置
*/

99
src/main/java/com/wms/mapper/AppOrderInMapper.java Normal file
View File

@ -0,0 +1,99 @@
package com.wms.mapper;
import com.wms.entity.table.AppOrderIn;
import com.wms.entity.table.Location;
import com.wms.entity.table.OrderOut;
import com.wms.entity.table.Vehicle;
import org.apache.ibatis.annotations.Param;
import org.mapstruct.Mapper;
import java.math.BigDecimal;
import java.util.List;
import java.util.Map;
@Mapper
public interface AppOrderInMapper {
/**
* 条件查询，结果会按照创建时间倒序排列
* @param queryParam 查询条件
* @return 查询结果
*/
List<AppOrderIn> select(AppOrderIn queryParam);
/**
* 插入一条数据
* @param appOrderIn 要插入的数据
* @return 插入的数据行数
*/
int insert(AppOrderIn appOrderIn);
/**
* 批量插入数据
* @param appOrderInList 要插入的数据
* @return 插入的数据行数
*/
int insertList(List<Location> appOrderInList);
/**
* 更新一条数据
* @param appOrderIn 要更新的数据
* @return 更新的数据行数
*/
int update(AppOrderIn appOrderIn);
/**
* 删除一条数据
* @param rowId 要删除的数据的rowId
* @return 删除的数据行数
*/
int delete(String rowId);
/**
* 条件查询
* @param searchStr 查询字符串
* @param orderStatus 状态
* @return 查询结果
*/
List<AppOrderIn> selectWithParams(@Param("searchStr") String searchStr, @Param("orderStatus") List<Integer> orderStatus);
/**
* 根据车辆编号更新状态
* @param vehicleNo 车辆编号
* @param orderStatus 状态
* @return 更新的数据行数
*/
int updateStatusWithVehicleNo(@Param("vehicleNo") String vehicleNo, @Param("orderStatus") Integer orderStatus);
/**
* 根据车辆编号查询
* @param vehicleNo 车辆编号
* @return 查询结果
*/
List<AppOrderIn> selectWithVehicle(@Param("vehicleNo") String vehicleNo);
List<AppOrderIn> selectWithGoodsId(@Param("goodsId") String goodsId);
List<AppOrderIn> selectWithRowId(@Param("rowId") String rowId);
//List<AppOrderIn> selectWithBatchNo(@Param("batchNo") String batchNo, @Param("goodsNum") BigDecimal goodsNum);
List<AppOrderIn> selectWithBatchNo(Map<String, Object> params);
int deleteByCheckNoGood(String remark);
}

3
src/main/java/com/wms/mapper/LocationMapper.java
View File

@ -8,11 +8,14 @@ import java.util.List;
@Mapper
public interface LocationMapper {
int selectAll(Location location);
/**
* 查询库位列表
* @param location
* @return
*/
List<Location> selLocations(Location location);

10
src/main/java/com/wms/mapper/OrderCheckMapper.java
View File

@ -22,6 +22,7 @@ public interface OrderCheckMapper {
*/
List<OrderCheck> query(OrderCheck orderCheck);
List<OrderCheck> queryByRecordId(String recordId);
/**
* 插入 批量
* @param orderChecks 记录
@ -29,4 +30,13 @@ public interface OrderCheckMapper {
*/
int insertList(List<OrderCheck> orderChecks);
List<OrderCheck> queryAll();
int delete(String record_id);
}

24
src/main/java/com/wms/mapper/OrderOutMapper.java
View File

@ -1,6 +1,7 @@
package com.wms.mapper;
import com.wms.entity.table.OrderOut;
import org.apache.ibatis.annotations.Param;
import org.mapstruct.Mapper;
import java.util.List;
@ -15,9 +16,20 @@ public interface OrderOutMapper {
*/
int insert(OrderOut data);
int update(OrderOut data);
/**
* 批量插入
* @param data 要插入的数据
* @return 插入的行数
*/
int insertList(List<OrderOut> data);
/**
* 删除
* @param rowId 要删除的数据的rowId
* @return 删除的行数
*/
int deleteOrderOut(String rowId);
/**
* 查询数据
@ -26,4 +38,14 @@ public interface OrderOutMapper {
*/
List<OrderOut> query(OrderOut data);
List<OrderOut> queryWithRowId(@Param("rowId") String rowId);
/**
* 查询数据
* @param searchStr 查询条件
* @param orderStatus 查询条件
* @return 查到的数据
*/
List<OrderOut> queryWithParams(@Param("searchStr") String searchStr, @Param("orderStatus") List<Integer> orderStatus);
}

68
src/main/java/com/wms/mapper/StockMapper.java
View File

@ -1,9 +1,12 @@
package com.wms.mapper;
import com.wms.entity.table.AppOrderIn;
import com.wms.entity.table.Stock;
import com.wms.entity.table.Task;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.Date;
import java.util.List;
@Mapper
@ -37,6 +40,18 @@ public interface StockMapper {
*/
int modifyStock(Stock stock);
/**
* 根据批次号分组查询库存
* @param
* @return
*/
List<Stock> groupByVehicleNo(@Param("locationId") String locationId);
List<Stock> groupByBatchNo(@Param("locationId") String locationId);
/**
* 修改库存存储的位置
* @param oldLocationId 旧库位
@ -76,17 +91,70 @@ public interface StockMapper {
*/
int updateStockStatusWithLocationId(@Param("locationId") String locationId, @Param("status") Integer status);
/**
* 根据库存id更新库存可用数量
* @param stockId 库存id
* @param availableNum 可用数量
* @return 更新结果
*/
int updateStockAvailableNumWithStockId(@Param("stockId") String stockId, @Param("availableNum") Integer availableNum);
/**
* 根据库存id更新库存生产日期
* @param stockId 库存id
* @param productionDate 生产日期
* @return 更新结果
*/
int updateStockProductionDateWithStockId(@Param("stockId") String stockId, @Param("productionDate") Date productionDate);
int updateLocationIdWithBetchNo(@Param("batchNo") String batchNo, @Param("locationId") String locationId);
/**
* 根据商品id查询库存
* @param stock
* @return
*/
List<Stock> selStocksByGoodsId(Stock stock);
/**
* 根据库位查询库存
* @param
* @return
*/
List<Stock> selStocksByLocationId(@Param("locationId") String locationId);
/**
* 查询过期库存
* @return
*/
List<Stock> selStockOutOfDate();
/**
* 查询库存快过期的库存
* @param nearInterval 快过期的间隔天数
* @return
*/
List<Stock> selStockNearDeadLine(int nearInterval);
/**
* 查询库存长时间未使用
* @param nearInterval 长时间未使用的间隔天数
* @return
*/
List<Stock> selStockLongTimeNoUse(int nearInterval);
/**
* 重置库存
* @param stock
* @return
*/
int resetStock(Stock stock);
}

3
src/main/java/com/wms/mapper/TaskMapper.java
View File

@ -15,6 +15,9 @@ public interface TaskMapper {
*/
List<Task> selTasks(Task task);
List<Task> selTasksByTaskId(Task task);
/**
* 添加任务
* @param task

12
src/main/java/com/wms/service/ContainerService.java
View File

@ -1,9 +1,6 @@
package com.wms.service;
import com.wms.entity.app.container.ContainerApiLocalResponse;
import com.wms.entity.app.container.CreateInstoreTaskRequest;
import com.wms.entity.app.container.CreateInstoreTaskResponse;
import com.wms.entity.app.container.TaskStateNoticeRequest;
import com.wms.entity.app.container.*;
/**
* 四向车api的Service
@ -24,4 +21,11 @@ public interface ContainerService {
* @return 响应信息
*/
ContainerApiLocalResponse taskStateNotice( TaskStateNoticeRequest request);
/**
* 接受四向车补盘通知
* @param request
* @return
*/
CreateFeedPalletTaskResponse createFeedPallet(CreateFeedPalletTaskRequest request);
}

21
src/main/java/com/wms/service/IOrderCheckService.java Normal file
View File

@ -0,0 +1,21 @@
package com.wms.service;
import com.wms.entity.common.WmsApiResponse;
import com.wms.entity.dto.orderCheck.queryOrderCheckRequest;
import com.wms.entity.table.OrderCheck;
import java.util.List;
public interface IOrderCheckService {
WmsApiResponse<List<OrderCheck>> queryOrderCheck(queryOrderCheckRequest request);
WmsApiResponse<Object> executeOrderCheck(String recordId);
WmsApiResponse<Object> deleteOrderCheck(String recordId);
WmsApiResponse<Object> deleteOrderCheckAll(String remarkReturn);
WmsApiResponse<Object> issueOrderCheck();
}

28
src/main/java/com/wms/service/IOrderInService.java Normal file
View File

@ -0,0 +1,28 @@
package com.wms.service;
import com.wms.entity.common.WmsApiResponse;
import com.wms.entity.dto.orderIn.bindingVehicleRequest;
import com.wms.entity.dto.orderIn.downOrderInRequest;
import com.wms.entity.dto.orderIn.queryOrderInRequest;
import com.wms.entity.dto.orderIn.updateNumRequest;
import com.wms.entity.table.AppOrderIn;
import java.math.BigDecimal;
import java.util.List;
public interface IOrderInService {
WmsApiResponse<List<AppOrderIn>> queryOrderIn(queryOrderInRequest request);
WmsApiResponse<Object> addOrderIn(downOrderInRequest request);
WmsApiResponse<Object> bindingVehicle(bindingVehicleRequest request);
WmsApiResponse<Object> updateForNum(updateNumRequest request);
WmsApiResponse<List<AppOrderIn>> getOrderInWithVehicleNo(String vehicleNo);
WmsApiResponse<Object> unBindingVehicle(String rowId);
WmsApiResponse<Object> deleteOrderIn(String rowId);
}

26
src/main/java/com/wms/service/IOrderOutService.java Normal file
View File

@ -0,0 +1,26 @@
package com.wms.service;
import com.wms.entity.common.WmsApiResponse;
import com.wms.entity.dto.orderOut.handOrderOutRequest;
import com.wms.entity.dto.orderOut.queryOrderOutRequest;
import com.wms.entity.table.OrderOut;
import java.util.List;
public interface IOrderOutService {
WmsApiResponse<List<OrderOut>> queryOrderOut(queryOrderOutRequest request);
WmsApiResponse<Object> executeOrderOut(String rowId);
WmsApiResponse<Object> deleteOrderOut(String rowId);
WmsApiResponse<Object> createOrderOut(handOrderOutRequest request);
boolean createEmptyLocation(handOrderOutRequest request);
WmsApiResponse<Object> updateLocation(handOrderOutRequest request);
//WmsApiResponse<Object> outRowStock(String rowId);
}

2
src/main/java/com/wms/service/TaskService.java
View File

@ -20,6 +20,8 @@ public interface TaskService{
*/
int addTask(Task task);
List<Task> selTasksByTaskId(Task task);
/**
* 执行任务
* @param task 任务

168
src/main/java/com/wms/service/serviceImplements/OrderCheckImplements.java Normal file
View File

@ -0,0 +1,168 @@
package com.wms.service.serviceImplements;
import com.wms.constants.enums.OrderCheckStatusEnum;
import com.wms.constants.enums.OrderOutStatusEnum;
import com.wms.constants.enums.TaskType;
import com.wms.entity.app.mes.MesApiLocalResponse;
import com.wms.entity.common.WmsApiResponse;
import com.wms.entity.dto.orderCheck.queryOrderCheckRequest;
import com.wms.entity.table.AppOrderIn;
import com.wms.entity.table.OrderCheck;
import com.wms.entity.table.Stock;
import com.wms.entity.table.Task;
import com.wms.mapper.AppOrderInMapper;
import com.wms.mapper.OrderCheckMapper;
import com.wms.mapper.StockMapper;
import com.wms.service.IOrderCheckService;
import com.wms.utils.WmsUtils;
import lombok.RequiredArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.*;
@Service
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class OrderCheckImplements implements IOrderCheckService {
private final OrderCheckMapper orderCheckMapper;
private final StockMapper stockMapper;
private final com.wms.mapper.TaskMapper taskMapper;
private final AppOrderInMapper appOrderInMapper;
private static final Logger log = LoggerFactory.getLogger(OrderOutImplements.class);
/**
* 查询订单
*/
public WmsApiResponse<List<OrderCheck>> queryOrderCheck(queryOrderCheckRequest request){
if(request.getOrderStatus() == null || request.getOrderStatus().isEmpty()) {
return new WmsApiResponse<>(0, "查询成功", new ArrayList<>()); // 没有查询参数，返回空
}
List<OrderCheck> orderChecks = orderCheckMapper.queryAll();
return new WmsApiResponse<>(0, "查询成功", orderChecks);
}
/**
* 执行盘点订单
*/
public WmsApiResponse<Object> executeOrderCheck(String recordId){
//根据recordId去盘点单中找对应的盘点任务
List<OrderCheck> orderCheckTask = orderCheckMapper.queryByRecordId(recordId);
if(orderCheckTask == null || orderCheckTask.isEmpty()) {
return new WmsApiResponse<>(0, "该条记录不存在", null);
}
OrderCheck orderCheck = orderCheckTask.get(0);
// 将该盘点单号对应的库别全部生成盘点任务
List<Task> checkTasks = new ArrayList<>(); // 盘点任务列表
Stock queryStock = new Stock();
queryStock.setWarehouseName("四向车库");
queryStock.setStockStatus(0);
List<Stock> stockList = stockMapper.selStocks(queryStock);
if(stockList == null || stockList.isEmpty()) {
return new WmsApiResponse<>(0, String.format("该库别没有库存，请稍后再试，库别：%s", orderCheck.getWarehouse()), null);
}
// 检查这些应该盘点的库位有没有任务在执行
for(Stock stock : stockList) {
List<Task> notCompleteTasks = taskMapper.haveNotCompleteTask(stock.getLocationId());
if(notCompleteTasks == null) {
return new WmsApiResponse<>(0, String.format("数据库校验任务失败，请稍后再试，库位：%s", stock.getLocationId()), null);
}
if(!notCompleteTasks.isEmpty()) {
return new WmsApiResponse<>(0, String.format("该库位有任务在执行，请稍后再试，库位：%s", stock.getLocationId()), null);
}
Task task = new Task();
task.setTaskId(String.valueOf(Calendar.getInstance().getTimeInMillis()));
task.setTaskType(TaskType.INVENTORY.getCode());
task.setTaskStatus(OrderOutStatusEnum.CREATED.getCode());
task.setTaskGroup(orderCheck.getCheckId());
task.setOrigin(stock.getLocationId());
task.setDestination("111");
task.setPickStand("");
task.setWeight(0.0);
task.setVehicleNo(stock.getVehicleId());
task.setCreateTime(new Date());
task.setUserName("mes");
task.setGoodsId(stock.getGoodsId());
task.setGoodsName(stock.getGoodsName());
task.setOperateNum(stock.getRealNum());
task.setTotalNum(stock.getRealNum());
task.setTaskPriority(1);
task.setRemark1("盘点出库");
checkTasks.add(task);
}
int addTasks = taskMapper.addTasks(checkTasks);
if(addTasks == checkTasks.size()) {
//删除对应的盘点单
int deleteResult = orderCheckMapper.delete(recordId);
if (deleteResult > 0){
log.info("添加任务成功，删除盘点单成功，任务：{}", checkTasks);
}
return new WmsApiResponse<>(1, "添加成功", null);
}
return new WmsApiResponse<>(0, "添加失败", null);
}
/**
* 删除订单
*/
public WmsApiResponse<Object> deleteOrderCheck(String recordId) {
try {
// 确保 orderId 不为空
if (recordId == null) {
return new WmsApiResponse<>(1, "执行失败，参数错误", null);
}
// 调用 Mapper 方法执行删除操作
int deletedResult = orderCheckMapper.delete(recordId);
// 检查删除是否成功
if (deletedResult > 0) {
return new WmsApiResponse<>(0, "删除成功", true);
} else {
return new WmsApiResponse<>(1, "订单不存在", false);
}
} catch (Exception e) {
// 记录异常
return new WmsApiResponse<>(1, "删除失败", false);
}
}
public WmsApiResponse<Object> deleteOrderCheckAll(String remarkReturn){
try {
int deletedResult = appOrderInMapper.deleteByCheckNoGood("盘点回库");
if (deletedResult > 0) {
return new WmsApiResponse<>(0, "删除成功", true);
} else {
return new WmsApiResponse<>(1, "订单不存在", false);
}
}catch (Exception e){
return new WmsApiResponse<>(1, "删除失败", false);
}
}
public WmsApiResponse<Object> issueOrderCheck(){
try {
OrderCheck orderCheck = new OrderCheck();
orderCheck.setRecordId(WmsUtils.generateUUIDString());
orderCheck.setCheckId(WmsUtils.generateUUIDString());
orderCheck.setWarehouse("100001");
orderCheck.setStatus(OrderCheckStatusEnum.CREATED.getCode());
orderCheck.setCreateTime(new Date());
int insertOrderCheckResult = orderCheckMapper.insert(orderCheck);
if(insertOrderCheckResult > 0) {
return new WmsApiResponse<>(1, "添加成功", true);
}
return new WmsApiResponse<>(0, "添加失败，请稍后再试",false);
}catch (Exception e){
return new WmsApiResponse<>(1, "生成盘点任务异常", false);
}
}
}

291
src/main/java/com/wms/service/serviceImplements/OrderInImplement.java Normal file
View File

@ -0,0 +1,291 @@
package com.wms.service.serviceImplements;
import com.wms.constants.enums.OrderInStatusEnum;
import com.wms.constants.enums.OrderOutStatusEnum;
import com.wms.entity.common.WmsApiResponse;
import com.wms.entity.dto.orderIn.bindingVehicleRequest;
import com.wms.entity.dto.orderIn.downOrderInRequest;
import com.wms.entity.dto.orderIn.queryOrderInRequest;
import com.wms.entity.dto.orderIn.updateNumRequest;
import com.wms.entity.table.AppOrderIn;
import com.wms.entity.table.OrderOut;
import com.wms.service.IOrderInService;
import com.wms.utils.StringUtils;
import lombok.RequiredArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
@Service
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class OrderInImplement implements IOrderInService {
private static final Logger log = LoggerFactory.getLogger(OrderInImplement.class);
private final com.wms.mapper.AppOrderInMapper appOrderInMapper;
/**
* 查询入库单
* @param request 查询参数
* @return 返回结果
*/
public WmsApiResponse<List<AppOrderIn>> queryOrderIn(queryOrderInRequest request) {
if(request.getOrderStatus() == null || request.getOrderStatus().isEmpty()) {
return new WmsApiResponse<>(0, "查询成功", new ArrayList<>()); // 没有查询参数，返回空
}
List<AppOrderIn> appOrderIns = appOrderInMapper.selectWithParams(request.getSearchStr(), request.getOrderStatus());
return new WmsApiResponse<>(0, "查询成功", appOrderIns);
}
/**
* 添加入库单
* @param request 入库单参数
* @return 返回结果
*/
public WmsApiResponse<Object> addOrderIn(downOrderInRequest request){
if (Objects.equals(request.efSelect, "G")){
log.info("托盘{}为空托盘入库", request.vehicleNo);
AppOrderIn appOrderIn = new AppOrderIn();
appOrderIn.setRowId(UUID.randomUUID().toString());
appOrderIn.setGuid(UUID.randomUUID().toString());
appOrderIn.setInType(1);
appOrderIn.setBatchNo(null);
appOrderIn.setVehicleNo(request.vehicleNo);
appOrderIn.setGoodsId(null);
appOrderIn.setGoodsNum(null);
appOrderIn.setWareHouse(request.abcSelect);
appOrderIn.setOrderStatus(0);
appOrderIn.setCreateTime(LocalDateTime.now());
appOrderIn.setCreatePerson("WMS");
appOrderIn.setUpdateTime(LocalDateTime.now());
appOrderIn.setRemark("空托盘入库");
//appOrderIn.setProductionDate(request.abcSelect);
appOrderInMapper.insert(appOrderIn);
return new WmsApiResponse<>(0, "添加成功", appOrderIn);
}else{
AppOrderIn selectOrderIn = new AppOrderIn();
selectOrderIn.setRemark("空托盘入库");
selectOrderIn.setVehicleNo(request.vehicleNo);
List<AppOrderIn> selEmpty = appOrderInMapper.select(selectOrderIn);
if (selEmpty == null || selEmpty.isEmpty()){
if (request.goodsNum <= 0){
return new WmsApiResponse<>(1, "数量必须大于0", null);
}
/* 插入数据，插入记录表 */
//OrderOut orderOutList = new OrderOut();
AppOrderIn appOrderIn = new AppOrderIn();
appOrderIn.setRowId(UUID.randomUUID().toString());
appOrderIn.setGuid(UUID.randomUUID().toString());
appOrderIn.setInType(1);
appOrderIn.setBatchNo(null);
appOrderIn.setVehicleNo(request.vehicleNo);
appOrderIn.setGoodsId(request.goodsId);
appOrderIn.setGoodsNum(BigDecimal.valueOf(request.goodsNum));
appOrderIn.setWareHouse(request.abcSelect);
if (Objects.equals(request.efSelect, "E")){
appOrderIn.setOrderStatus(0);
}else {
appOrderIn.setOrderStatus(2);
}
appOrderIn.setCreateTime(LocalDateTime.now());
appOrderIn.setCreatePerson("WMS");
appOrderIn.setUpdateTime(LocalDateTime.now());
appOrderIn.setRemark("");
//appOrderIn.setProductionDate(request.abcSelect);
appOrderInMapper.insert(appOrderIn);
return new WmsApiResponse<>(0, "添加成功", appOrderIn);
}else {
return new WmsApiResponse<>(1, "必须先删除空托盘入库任务！", null);
}
}
}
/**
* 修改数量
* @param request 修改数量参数
* @return 返回结果
*/
public WmsApiResponse<Object> updateForNum(updateNumRequest request){
// if (request.get){
//
// }
AppOrderIn appOrderIn = new AppOrderIn();
appOrderIn.setRowId(request.getRowId());
List<AppOrderIn> appOrderIns = appOrderInMapper.select(appOrderIn);
if (appOrderIns.get(0).getGoodsId() == null || appOrderIns.get(0).getGoodsId().isEmpty()){
return new WmsApiResponse<>(999, "空托盘不允许修改物料数量，修改失败", null);
}
appOrderIn.setGoodsNum(request.getRealNum());
int i = appOrderInMapper.update(appOrderIn);
if(i > 0) {
return new WmsApiResponse<>(0, "修改成功", null);
}else {
return new WmsApiResponse<>(999, "修改失败", null);
}
}
/**
* 绑定载具
* @param request 绑定参数
* @return 返回结果
*/
public WmsApiResponse<Object> bindingVehicle(bindingVehicleRequest request) {
String vehicleNo = request.getVehicleNo();
String code = request.getCode();
if(StringUtils.isEmpty(vehicleNo) || StringUtils.isEmpty(code)) {
return new WmsApiResponse<>(999, "载具号或者条码为空", null);
}
// 拆分条码
// 前八位是零件号，后面六位是批次，后面一位是班次，最后五位是数量
if(code.length() == 22) {
//return new WmsApiResponse<>(999, "条码长度错误", null);
String goodsId = code.substring(0, 10); // 物料编码
String productionDate = code.substring(10, 16); //生产日期
SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");
Date date;
try {
// 将字符串解析成Date对象
date = dateFormat.parse(productionDate);
} catch (ParseException e) {
throw new RuntimeException(e);
}
String batchNo = code.substring(0, 16); // 批次 ---- 这个批次应该是料号加中间六位
String shift = code.substring(17, 18); // 班次
String goodsNumStr = code.substring(18, 22); // 数量字符串
if(!goodsNumStr.matches("[0-9]+")) {
return new WmsApiResponse<>(999, "数量错误", null);
}
BigDecimal goodsNum = new BigDecimal(goodsNumStr); // 数量
List<AppOrderIn> selectRows = appOrderInMapper.select(new AppOrderIn(batchNo, goodsNum, OrderInStatusEnum.CREATE.getCode()));
if(selectRows == null || selectRows.isEmpty()) {
return new WmsApiResponse<>(999, String.format("条码找不到入库单，无法绑定，条码：%s, 批次: %s, 数量: %s", code, batchNo, goodsNum), null);
}
AppOrderIn orderIn = selectRows.get(0); // 这条数据
// 绑定载具
AppOrderIn bindingOrderIn = new AppOrderIn();
bindingOrderIn.setRowId(orderIn.getRowId());
bindingOrderIn.setVehicleNo(vehicleNo);
bindingOrderIn.setOrderStatus(OrderInStatusEnum.BINDING.getCode());
bindingOrderIn.setUpdateTime(java.time.LocalDateTime.now());
//bindingOrderIn.setProductionDate(date);
//bindingOrderIn.setUpdateTime(date);
if(appOrderInMapper.update(bindingOrderIn) > 0) {
return new WmsApiResponse<>(0, "绑定成功", null);
}
return new WmsApiResponse<>(999, "绑定失败，未知异常，请重试", null);
} else if (code.length() == 20) {
//String goodsId = code.substring(0, 10); // 物料编码
String productionDate = code.substring(8, 14); //生产日期
SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");
Date date;
try {
// 将字符串解析成Date对象
date = dateFormat.parse(productionDate);
} catch (ParseException e) {
throw new RuntimeException(e);
}
String batchNo = code.substring(0, 14); // 批次 ---- 这个批次应该是料号加中间六位
//String shift = code.substring(17, 18); // 班次
String goodsNumStr = code.substring(16, 20); // 数量字符串
if(!goodsNumStr.matches("[0-9]+")) {
return new WmsApiResponse<>(999, "数量错误", null);
}
BigDecimal goodsNum = new BigDecimal(goodsNumStr); // 数量
List<AppOrderIn> selectRows = appOrderInMapper.select(new AppOrderIn(batchNo, goodsNum, OrderInStatusEnum.CREATE.getCode()));
if(selectRows == null || selectRows.isEmpty()) {
return new WmsApiResponse<>(999, String.format("条码找不到入库单，无法绑定，条码：%s, 批次: %s, 数量: %s", code, batchNo, goodsNum), null);
}
AppOrderIn orderIn = selectRows.get(0); // 这条数据
// 绑定载具
AppOrderIn bindingOrderIn = new AppOrderIn();
bindingOrderIn.setRowId(orderIn.getRowId());
bindingOrderIn.setVehicleNo(vehicleNo);
bindingOrderIn.setOrderStatus(OrderInStatusEnum.BINDING.getCode());
bindingOrderIn.setUpdateTime(java.time.LocalDateTime.now());
//bindingOrderIn.setProductionDate(date);
//bindingOrderIn.setUpdateTime(date);
if(appOrderInMapper.update(bindingOrderIn) > 0) {
return new WmsApiResponse<>(0, "绑定成功", null);
}
return new WmsApiResponse<>(999, "绑定失败，未知异常，请重试", null);
}
return new WmsApiResponse<>(999, "条码长度错误", null);
}
/**
* 根据载具号查询入库单
* @param vehicleNo 载具号
* @return 返回结果
*/
public WmsApiResponse<List<AppOrderIn>> getOrderInWithVehicleNo(String vehicleNo) {
if(vehicleNo == null || vehicleNo.isEmpty()) {
return new WmsApiResponse<>(999, "载具号不能为空", null);
}
AppOrderIn appOrderInQuery = new AppOrderIn();
appOrderInQuery.setVehicleNo(vehicleNo);
appOrderInQuery.setOrderStatus(OrderInStatusEnum.BINDING.getCode());
List<AppOrderIn> appOrderIns = appOrderInMapper.select(appOrderInQuery);
if(appOrderIns == null) {
return new WmsApiResponse<>(999, "查询失败，请重试", new ArrayList<>());
}
return new WmsApiResponse<>(0, "查询成功", appOrderIns);
}
/**
* 解绑载具
* @param rowId 入库单行号
* @return 返回结果
*/
public WmsApiResponse<Object> unBindingVehicle(String rowId) {
if(rowId == null || rowId.isEmpty()) {
return new WmsApiResponse<>(999, "入库单行号不能为空", null);
}
AppOrderIn unBindingVehicle = new AppOrderIn();
unBindingVehicle.setRowId(rowId);
unBindingVehicle.setOrderStatus(OrderInStatusEnum.CREATE.getCode());
unBindingVehicle.setVehicleNo("");
unBindingVehicle.setUpdateTime(java.time.LocalDateTime.now());
int updateResult = appOrderInMapper.update(unBindingVehicle);
if(updateResult > 0) {
return new WmsApiResponse<>(0, "解绑成功", null);
}
return new WmsApiResponse<>(999, "解绑失败，请重试", null);
}
public WmsApiResponse<Object> deleteOrderIn(String rowId) {
try {
// 确保 orderId 不为空
if (rowId == null) {
return new WmsApiResponse<>(1, "执行失败，参数错误", null);
}
// 调用 Mapper 方法执行删除操作
int deletedResult = appOrderInMapper.delete(rowId);
// 检查删除是否成功
if (deletedResult > 0) {
return new WmsApiResponse<>(0, "删除成功", true);
} else {
return new WmsApiResponse<>(1, "订单不存在", false);
} } catch (Exception e) {
// 记录异常
return new WmsApiResponse<>(1, "删除失败", false);
}
}
}

333
src/main/java/com/wms/service/serviceImplements/OrderOutImplements.java Normal file
View File

@ -0,0 +1,333 @@
package com.wms.service.serviceImplements;
import com.wms.constants.enums.LocationStatus;
import com.wms.constants.enums.OrderOutStatusEnum;
import com.wms.constants.enums.StockStatus;
import com.wms.entity.common.WmsApiResponse;
import com.wms.entity.dto.orderOut.handOrderOutRequest;
import com.wms.entity.dto.orderOut.queryOrderOutRequest;
import com.wms.entity.table.*;
import com.wms.mapper.LocationMapper;
import com.wms.mapper.OrderOutMapper;
import com.wms.mapper.StockMapper;
import com.wms.mapper.VehicleMapper;
import com.wms.service.IOrderOutService;
import lombok.RequiredArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.sql.Timestamp;
import java.util.*;
@Service
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class OrderOutImplements implements IOrderOutService {
private static final Logger log = LoggerFactory.getLogger(OrderOutImplements.class);
private final OrderOutMapper orderOutMapper;
private final StockMapper stockMapper;
private final LocationMapper locationMapper;
private final com.wms.mapper.TaskMapper taskMapper;
private final VehicleMapper vehicleMapper;
/**
* 查询出库单
* @param request 请求参数
* @return 结果
*/
public WmsApiResponse<List<OrderOut>> queryOrderOut(queryOrderOutRequest request){
if(request.getOrderStatus() == null || request.getOrderStatus().isEmpty()) {
return new WmsApiResponse<>(0, "查询成功", new ArrayList<>()); // 没有查询参数，返回空
}
List<OrderOut> orderOuts = orderOutMapper.queryWithParams(request.getSearchStr(), request.getOrderStatus());
return new WmsApiResponse<>(0, "查询成功", orderOuts);
}
//
// /**
// * 执行库存出库
// * @param rowId 出库单ID
// * @return 结果
// */
// public WmsApiResponse<Object> outRowStock(String rowId) {
// if(rowId == null || rowId.isEmpty()) {
// return new WmsApiResponse<>(1, "执行失败，参数错误", null);
// }
// }
/**
* 执行出库单
* @param rowId 出库单ID
* @return 结果
*/
public WmsApiResponse<Object> executeOrderOut(String rowId) {
if(rowId == null || rowId.isEmpty()) {
return new WmsApiResponse<>(1, "执行失败，参数错误", null);
}
List<OrderOut> queryResult = orderOutMapper.queryWithRowId(rowId);
if(queryResult == null) {
return new WmsApiResponse<>(1, "执行失败，请重试", null);
}
if(queryResult.isEmpty()) {
return new WmsApiResponse<>(1, "执行失败，该任务不存在，请刷新后再试", null);
}
OrderOut orderOut = queryResult.get(0); // 出库单数据
// 计算出库
List<Task> outTasks = new ArrayList<>(); // 出库任务列表
/* 查询库存 */
// 拉出该物料的所有库存
if(Objects.equals(orderOut.getRemark(), "手动出库")){
Stock queryStock = new Stock();
//queryStock.setGoodsId(orderOut.getGoodsId());
queryStock.setGoodsId(orderOut.getGoodsId() != null ? orderOut.getGoodsId().trim() : null);
queryStock.setWarehouseName(orderOut.getWarehouseOrigin());
queryStock.setStockStatus(StockStatus.OK.getCode());
if (orderOut.getDeliveryTime() != null){
queryStock.setProductionDate(orderOut.getDeliveryTime());
}
List<Stock> stockList = stockMapper.selStocks(queryStock);
if(stockList == null) {
return new WmsApiResponse<>(1, String.format("库存拉取失败，请稍后再试，物料号：%s", orderOut.getGoodsId()), null);
}
if(stockList.isEmpty()) {
return new WmsApiResponse<>(1, String.format("该物料没有库存，物料号：%s，其他物料也一并拒绝出库", orderOut.getGoodsId()), null);
}
Integer availableNum = com.wms.utils.storage.StockUtils.sumStcokAvailableNum(stockList); // 拥有的数量
int needNum = Integer.parseInt(orderOut.getGoodsNum()); // 需要的数量
if(availableNum.compareTo(needNum) < 0) {
return new WmsApiResponse<>(1, String.format("该物料库存不足，物料号：%s，库存数量：%d，出库数量：%s", orderOut.getGoodsId(), availableNum, orderOut.getGoodsNum()), null);
}
// 手动出库的生成出库任务
for(Stock outStock : stockList) {
if(needNum <= 0) {
break;
}
// 生成出库任务，更新库存为出库中
int outNum = needNum > outStock.getAvailableNum() ? outStock.getAvailableNum() : needNum; // 需要操作的数量
if(outTasks.stream().filter(task -> task.getOrigin().equals(outStock.getLocationId())).toList().isEmpty()) {
Task task = new Task();
task.setTaskId(String.valueOf(Calendar.getInstance().getTimeInMillis()));
task.setTaskType(2);
task.setTaskGroup(orderOut.getOrderId());
task.setTaskStatus(OrderOutStatusEnum.CREATED.getCode());
task.setOrigin(outStock.getLocationId());
task.setDestination("111");
task.setPickStand(orderOut.getRowId());
task.setWeight(0.0);
task.setVehicleNo(outStock.getVehicleId());
task.setCreateTime(new Date());
task.setUserName("WMS");
task.setGoodsId(outStock.getGoodsId());
task.setGoodsName(outStock.getGoodsName());
task.setOperateNum(outNum);
task.setTotalNum(outStock.getRealNum());
task.setTaskPriority(1);
task.setRemark1("手动出库");
outTasks.add(task);
}
// 把这条库存记录可用数量更新为 0
stockMapper.updateStockAvailableNumWithStockId(outStock.getStockId(), outStock.getAvailableNum()-outNum);
// 更新库存为出库中
stockMapper.updateStockStatusWithLocationId(outStock.getLocationId(), StockStatus.OUT.getCode());
// 重新计算需求数量
needNum -= outNum;
}
} else if (Objects.equals(orderOut.getRemark(), "空托盘出库")) {
//先判断这个托盘到底是不是空托盘
Stock queryStock = new Stock();
queryStock.setVehicleId(orderOut.getWarehouseDestination());
List<Stock> s = stockMapper.selStocks(queryStock);
if (s == null || s.isEmpty()){
Location outLocation = new Location();
outLocation.setVehicleId(orderOut.getWarehouseDestination());
List<Location> locations = locationMapper.selLocations(outLocation);
if (locations.isEmpty()){
return new WmsApiResponse<>(1, "没有找到该托盘对应的库位，请检查库位是否正确", null);
}
Task task = new Task();
task.setTaskId(String.valueOf(Calendar.getInstance().getTimeInMillis()));
task.setTaskType(2);
task.setTaskGroup(orderOut.getOrderId());
task.setTaskStatus(OrderOutStatusEnum.CREATED.getCode());
task.setOrigin(locations.get(0).getLocationId());
task.setDestination("111");
task.setPickStand(orderOut.getRowId());
task.setWeight(0.0);
task.setVehicleNo(orderOut.getWarehouseDestination());
task.setCreateTime(new Date());
task.setUserName("WMS");
task.setGoodsId(null);
task.setGoodsName(null);
task.setOperateNum(null);
task.setTotalNum(null);
task.setTaskPriority(1);
task.setRemark1("空托盘出库");
outTasks.add(task);
}else {
return new WmsApiResponse<>(1, "该托盘不是空托盘，请检查", null);
}
}
if(outTasks.isEmpty()) {
return new WmsApiResponse<>(1, "无法生成任务，请稍后再试", null);
}
int addResult = taskMapper.addTasks(outTasks);
if(addResult == outTasks.size()) {
// //删除出库单对应的任务
// int deleteResult =orderOutMapper.deleteOrderOut(orderOut.getRowId());
// if (deleteResult > 0){
// log.info("添加任务成功，删除出库单成功，任务：{}", outTasks);
// }
//更改出库单状态为出库中
OrderOut orderOutUpdateStatus = new OrderOut();
orderOutUpdateStatus.setRowId(rowId);
orderOutUpdateStatus.setStatus(OrderOutStatusEnum.RUNNING.getCode());
int a = orderOutMapper.update(orderOutUpdateStatus);
if (a > 0){
log.info("更新出库单状态成功");
}else {
log.info("更新出库单状态失败");
}
return new WmsApiResponse<>(0, "添加成功", null);
}
return new WmsApiResponse<>(1, "添加失败，请重试", null);
}
public boolean createEmptyLocation(handOrderOutRequest request){
Location occupyLocation = new Location();
occupyLocation.setLocationId(request.location);
occupyLocation.setLocationStatus(LocationStatus.OCCUPY.getCode());
occupyLocation.setVehicleId(request.vehicleNo);
int x = locationMapper.modifyLocation(occupyLocation);
if (x == 0){
log.error("四向车空托盘入库完成更新库位表失败");
return false;
}else{
log.info("四向车空托盘入库完成更新库位表成功");
}
Vehicle a = new Vehicle();
a.setVehicleId(request.vehicleNo);
a.setCurrentLocation(request.location);
a.setIsEmpty(1);
a.setVehicleStatus(2);
int b = vehicleMapper.addVehicle(a);
if (b == 0){
log.error("四向车空托盘入库完成更新料箱监控失败");
return false;
}else{
log.info("四向车空托盘入库完成更新料箱监控成功");
}
return true;
}
public WmsApiResponse<Object> updateLocation(handOrderOutRequest request){
Vehicle vehicle = new Vehicle();
vehicle.setVehicleStatus(2);
vehicle.setIsEmpty(1);
List<Vehicle> userList = vehicleMapper.selVehicles(vehicle);
for (Vehicle user : userList){
Location location = new Location();
location.setLocationStatus(1);
location.setVehicleId(user.getVehicleId());
location.setLocationId(user.getCurrentLocation());
int x = locationMapper.modifyLocation(location);
if (x == 0){
log.error("四向车更新库位表失败");
return new WmsApiResponse<>(1, "四向车更新库位表失败", null);
}else{
log.info("四向车更新库位表成功");
}
}
return null;
}
/**
* 创建出库单
*/
public WmsApiResponse<Object> createOrderOut(handOrderOutRequest request) {
if (request.vehicleNo == null || request.vehicleNo.isEmpty()){
//正常出库
if (request.goodsId == null|| request.goodsId.isEmpty()){
return new WmsApiResponse<>(1, "物料号不能为空", null);
}
if (request.goodsNum <= 0){
return new WmsApiResponse<>(1, "数量必须大于0", null);
}
/* 插入数据，插入记录表 */
//OrderOut orderOutList = new OrderOut();
OrderOut orderOut = new OrderOut();
orderOut.setRowId(UUID.randomUUID().toString());
orderOut.setRecordId(UUID.randomUUID().toString());
orderOut.setOrderId(UUID.randomUUID().toString());
orderOut.setWarehouseOrigin("四向车立体库");
orderOut.setWarehouseDestination("");
orderOut.setOrderType(1);
orderOut.setRowNo(1);
orderOut.setGoodsId(request.goodsId);
orderOut.setGoodsNum(String.valueOf(request.goodsNum));
orderOut.setUnit("");
orderOut.setStatus(OrderOutStatusEnum.CREATED.getCode());
orderOut.setCreateTime(new Timestamp(System.currentTimeMillis()));
orderOut.setRemark("手动出库");
orderOut.setBatchNo(null);
orderOutMapper.insert(orderOut);
return new WmsApiResponse<>(0, "添加成功", orderOut);
}else{
//空托盘出库
/* 插入数据，插入记录表 */
//OrderOut orderOutList = new OrderOut();
OrderOut orderOut = new OrderOut();
orderOut.setRowId(UUID.randomUUID().toString());
orderOut.setRecordId(UUID.randomUUID().toString());
orderOut.setOrderId(UUID.randomUUID().toString());
orderOut.setWarehouseOrigin("四向车立体库");
orderOut.setWarehouseDestination(request.vehicleNo); //借用这个字段表示载具号
orderOut.setOrderType(1);
orderOut.setRowNo(1);
orderOut.setGoodsId(request.goodsId);
orderOut.setGoodsNum(String.valueOf(request.goodsNum));
//Integer.parseInt(row.getQty())
orderOut.setUnit("");
orderOut.setStatus(OrderOutStatusEnum.CREATED.getCode());
orderOut.setCreateTime(new Timestamp(System.currentTimeMillis()));
orderOut.setRemark("空托盘出库");
orderOut.setBatchNo(null);
orderOutMapper.insert(orderOut);
return new WmsApiResponse<>(0, "添加成功", orderOut);
}
}
/**
* 删除出库单
* @param rowId 出库单ID
* @return 结果
*/
public WmsApiResponse<Object> deleteOrderOut(String rowId) {
try {
// 确保 orderId 不为空
if (rowId == null) {
return new WmsApiResponse<>(1, "执行失败，参数错误", null);
}
// 调用 Mapper 方法执行删除操作
int deletedResult = orderOutMapper.deleteOrderOut(rowId);
// 检查删除是否成功
if (deletedResult > 0) {
return new WmsApiResponse<>(0, "删除成功", true);
} else {
return new WmsApiResponse<>(1, "订单不存在", false);
}
} catch (Exception e) {
// 记录异常
return new WmsApiResponse<>(1, "删除失败", false);
}
}
}

5
src/main/java/com/wms/service/serviceImplements/TaskServiceImplements.java
View File

@ -28,6 +28,11 @@ public class TaskServiceImplements implements TaskService {
return taskMapper.addTask(task);
}
@Override
public List<Task> selTasksByTaskId(Task task) {
return taskMapper.selTasksByTaskId(task);
}
@Override
public int executeTask(Task task) {
return taskMapper.executeTask(task);

378
src/main/java/com/wms/service/serviceImplements/parent/ContainerImplement.java
View File

@ -1,29 +1,32 @@
package com.wms.service.serviceImplements.parent;
import com.wms.bussiness.TaskOperation;
import com.wms.constants.enums.LocationStatus;
import com.wms.constants.enums.StockStatus;
import com.wms.constants.enums.TaskType;
import com.wms.constants.enums.WmsTaskStatus;
import com.wms.entity.app.container.ContainerApiLocalResponse;
import com.wms.entity.app.container.CreateInstoreTaskRequest;
import com.wms.entity.app.container.CreateInstoreTaskResponse;
import com.wms.entity.app.container.TaskStateNoticeRequest;
import com.wms.entity.table.Location;
import com.wms.entity.table.Stock;
import com.wms.entity.table.Task;
import com.wms.mapper.LocationMapper;
import com.wms.mapper.StockMapper;
import com.wms.mapper.TaskMapper;
import com.wms.constants.enums.*;
import com.wms.entity.app.ResponseEntity;
import com.wms.entity.app.container.*;
import com.wms.entity.common.WmsApiResponse;
import com.wms.entity.table.*;
import com.wms.mapper.*;
import com.wms.service.ContainerService;
import com.wms.utils.StringUtils;
import com.wms.utils.storage.LocationUtils;
import lombok.RequiredArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;
import com.wms.utils.WmsUtils;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import java.util.List;
import java.util.UUID;
import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.*;
/**
* 四向车 api service 的实现
@ -33,6 +36,7 @@ import java.util.UUID;
public class ContainerImplement implements ContainerService {
private static final Logger log = LoggerFactory.getLogger(ContainerImplement.class);
/**
* 库存 Mapper
*/
@ -53,80 +57,188 @@ public class ContainerImplement implements ContainerService {
*/
private final LocationMapper locationMapper;
/**
* 载具 Mapper
*/
private final com.wms.mapper.VehicleMapper vehicleMapper;
/**
* 任务操作类
*/
private final TaskOperation taskOperation;
/**
* 订单入库 Mapper
*/
private final com.wms.mapper.AppOrderInMapper appOrderInMapper;
/**
* 订单出库 Mapper
*/
private final OrderOutMapper orderOutMapper;
/**
* 接收四向车请求扫码入库
* @param request 请求信息
* @return 响应信息
*/
@Override
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public CreateInstoreTaskResponse createInstoreTask(CreateInstoreTaskRequest request) {
//进行MD5加密的验证
String md5 = StringUtils.containerMd5(request.getRequestId());
if(!md5.equals(request.getKey())) {
return new CreateInstoreTaskResponse("400", "请求失败，密钥校验未通过");
}
/* 判断条码是否存在任务，条码扫出来的是批次号 */
Stock waitInStockQuery = new Stock();
waitInStockQuery.setBatchNo(request.getPalletNo());
waitInStockQuery.setStockStatus(StockStatus.WAIT_IN.getCode());
List<Stock> waitInStockList = stockMapper.selStocks(waitInStockQuery); // 查找待入库的批次号
if(waitInStockList.isEmpty()) {
return new CreateInstoreTaskResponse("400", String.format("条码：%s 不存在待入库的任务", request.getPalletNo()));
}
/* 查找可用库位 */
List<Location> canUseLocations = locationUtils.getNewLocation(2);
if(canUseLocations.isEmpty()){
return new CreateInstoreTaskResponse("400", "没有可用库位");
}
Location useLocation = locationUtils.checkCanUse(canUseLocations);
if(useLocation == null) {
return new CreateInstoreTaskResponse("400", "暂没有可以直接使用的库位，因为存在互锁的库位，请等待当前任务都执行完成后再试");
}
/* 找到可用的库位 */ /* 生成任务（生成的任务直接运行中，因为此处会把任务直接回回去），更新库存表内状态为入库中 */
// 新建任务 插入任务表
Task newInTask = new Task();
newInTask.setTaskId(UUID.randomUUID().toString());
newInTask.setTaskGroup(UUID.randomUUID().toString());
newInTask.setTaskType(TaskType.IN.getCode());
newInTask.setTaskStatus(WmsTaskStatus.WAIT.getCode()); // 因为任务是直接返回去的，所以直接是已下发状态
newInTask.setOrigin(request.getFromCellNo());
newInTask.setDestination(useLocation.getLocationId());
newInTask.setGoodsId(String.format("%s 等 %d 个物料", waitInStockList.get(0).getGoodsId(), waitInStockList.size()));
newInTask.setWeight(Double.valueOf(request.getWeight()));
newInTask.setCreateTime(new java.util.Date());
newInTask.setUserName("四向车API");
newInTask.setVehicleSize(Integer.valueOf(request.getHeight()));
newInTask.setVehicleNo(request.getPalletNo());
newInTask.setTaskPriority(1);
int insertTaskResult = taskMapper.addTask(newInTask); // 添加入库任务
if(insertTaskResult < 1) {
return new CreateInstoreTaskResponse("400", "生成任务失败，无法插入新的入库任务");
}
// 更新库存中的待入库记录为入库中，并将库位更新进去
for(Stock waitInStock : waitInStockList) {
Stock updateStock = new Stock();
updateStock.setStockId(waitInStock.getStockId());
updateStock.setStockStatus(StockStatus.IN_ING.getCode());
updateStock.setLocationId(useLocation.getLocationId());
stockMapper.modifyStock(updateStock);
}
// 释放库位
Location location = new Location();
location.setLocationId(useLocation.getLocationId());
location.setLocationStatus(LocationStatus.EMPTY.getCode());
locationMapper.modifyLocation(location);
CreateInstoreTaskResponse success = new CreateInstoreTaskResponse();
success.setCode("200");
success.setMessage("生成入库任务成功");
success.setWmsTaskId(newInTask.getTaskId());
success.setPalletNo(request.getPalletNo());
success.setFromCellNo(request.getFromCellNo());
success.setToCellNo(useLocation.getLocationId());
// 判断是否为空托盘
if("B0000001".equals(request.getPalletNo())) {
String virtualVehicleNo = WmsUtils.generateUUIDString();
log.info("无托盘号,生成虚拟托盘号{}",virtualVehicleNo);
// 设置虚拟托盘号
AppOrderIn appOrderIn = new AppOrderIn();
String rowId = UUID.randomUUID().toString();
String Guid = UUID.randomUUID().toString();
appOrderIn.setRowId(rowId);
appOrderIn.setGuid(Guid);
appOrderIn.setInType(1);
appOrderIn.setBatchNo(null);
appOrderIn.setVehicleNo(virtualVehicleNo);
appOrderIn.setGoodsId("00000");
appOrderIn.setGoodsNum(null);
appOrderIn.setWareHouse("A");
appOrderIn.setOrderStatus(0);
appOrderIn.setCreateTime(LocalDateTime.now());
appOrderIn.setCreatePerson("WMS");
appOrderIn.setUpdateTime(LocalDateTime.now());
appOrderIn.setRemark("空托盘入库");
//appOrderIn.setProductionDate(request.abcSelect);
int insert = appOrderInMapper.insert(appOrderIn);
if (insert <= 0) {
return new CreateInstoreTaskResponse("400", "创建入库单失败");
}
/* 查找可用库位 */
List<Location> canUseLocations = locationUtils.getNewLocation(2,appOrderIn);
if(canUseLocations.isEmpty()){
log.info("无可用库位");
return new CreateInstoreTaskResponse("400", "没有可用库位");
}
Location useLocation = locationUtils.checkCanUse(canUseLocations);
if(useLocation == null) {
log.info("暂没有可以直接使用的库位，因为存在互锁的库位，请等待当前任务都执行完成后再试");
return new CreateInstoreTaskResponse("400", "暂没有可以直接使用的库位，因为存在互锁的库位，请等待当前任务都执行完成后再试");
}
Task newInTask = new Task();
newInTask.setTaskId(String.valueOf(Calendar.getInstance().getTimeInMillis()));
newInTask.setTaskGroup(UUID.randomUUID().toString());
newInTask.setTaskType(TaskType.IN.getCode());
newInTask.setTaskStatus(WmsTaskStatus.WAIT.getCode()); // 因为任务是直接返回去的，所以直接是已下发状态
newInTask.setOrigin(request.getFromCellNo());
newInTask.setDestination(useLocation.getLocationId());
newInTask.setGoodsId("00000");
newInTask.setWeight(Double.valueOf(request.getWeight()));
newInTask.setCreateTime(new java.util.Date());
newInTask.setUserName("四向车API");
newInTask.setVehicleSize(Integer.valueOf(request.getHeight()));
newInTask.setVehicleNo(virtualVehicleNo);
newInTask.setTaskPriority(1);
newInTask.setProductionDate(null);
int insertTaskResult = taskMapper.addTask(newInTask);
if(insertTaskResult < 1) {
log.info("生成任务失败，无法插入新的入库任务");
return new CreateInstoreTaskResponse("400", "生成任务失败，无法插入新的入库任务");
}
// 更新入库单状态
AppOrderIn updateAppOrderIn = new AppOrderIn();
updateAppOrderIn.setRowId(rowId);
updateAppOrderIn.setOrderStatus(OrderInStatusEnum.IN.getCode());
updateAppOrderIn.setUpdateTime(LocalDateTime.now());
appOrderInMapper.update(updateAppOrderIn);
// 修改库位信息
Location location = new Location();
location.setLocationId(useLocation.getLocationId());
location.setLocationStatus(LocationStatus.OCCUPY.getCode());
location.setVehicleId(virtualVehicleNo);
locationMapper.modifyLocation(location);
success.setCode("200");
success.setMessage("生成入库任务成功");
success.setWmsTaskId(newInTask.getTaskId());
success.setPalletNo(virtualVehicleNo);
success.setFromCellNo(request.getFromCellNo());
success.setToCellNo(useLocation.getLocationId());
}else {
// 查询待入库的批次号
AppOrderIn waitInStockQuery = new AppOrderIn();
waitInStockQuery.setVehicleNo(request.getPalletNo());
//waitInStockQuery.setOrderStatus(OrderInStatusEnum.CREATE.getCode());
List<AppOrderIn> waitInStockList = appOrderInMapper.select(waitInStockQuery); // 查找待入库的批次号
if(waitInStockList.isEmpty()) {
return new CreateInstoreTaskResponse("400", String.format("条码：%s 不存在待入库的任务", request.getPalletNo()));
}
AppOrderIn appOrderIn = waitInStockList.get(0);
/* 查找可用库位 */
List<Location> canUseLocations = locationUtils.getNewLocation(2,appOrderIn);
if(canUseLocations.isEmpty()){
return new CreateInstoreTaskResponse("400", "没有可用库位");
}
Location useLocation = locationUtils.checkCanUse(canUseLocations);
if(useLocation == null) {
return new CreateInstoreTaskResponse("400", "暂没有可以直接使用的库位，因为存在互锁的库位，请等待当前任务都执行完成后再试");
}
/* 找到可用的库位 */ /* 生成任务（生成的任务直接运行中，因为此处会把任务直接回回去），更新库存表内状态为入库中 */
// 新建任务 插入任务表
Task newInTask = new Task();
newInTask.setTaskId(String.valueOf(Calendar.getInstance().getTimeInMillis()));
newInTask.setTaskGroup(UUID.randomUUID().toString());
newInTask.setTaskType(TaskType.IN.getCode());
newInTask.setTaskStatus(WmsTaskStatus.WAIT.getCode()); // 因为任务是直接返回去的，所以直接是已下发状态
newInTask.setOrigin(request.getFromCellNo());
newInTask.setDestination(useLocation.getLocationId());
//newInTask.setGoodsId(String.format("%s 等 %d 个物料", waitInStockList.get(0).getGoodsId(), waitInStockList.size()));
if (!waitInStockList.isEmpty() && waitInStockList.get(0) != null) {
newInTask.setGoodsId(waitInStockList.get(0).getGoodsId());
} else {
newInTask.setGoodsId(null); // 或者你可以选择不设置
}
newInTask.setWeight(Double.valueOf(request.getWeight()));
newInTask.setCreateTime(new java.util.Date());
newInTask.setUserName("四向车API");
newInTask.setVehicleSize(Integer.valueOf(request.getHeight()));
newInTask.setVehicleNo(request.getPalletNo());
newInTask.setTaskPriority(1);
newInTask.setProductionDate(null);
int insertTaskResult = taskMapper.addTask(newInTask); // 添加入库任务
if(insertTaskResult < 1) {
return new CreateInstoreTaskResponse("400", "生成任务失败，无法插入新的入库任务");
}
// 更新库存中的待入库记录为入库中，并将库位更新进去
for(AppOrderIn waitInStock : waitInStockList) {
AppOrderIn updateAppOrderIn = new AppOrderIn();
updateAppOrderIn.setRowId(waitInStock.getRowId());
updateAppOrderIn.setOrderStatus(OrderInStatusEnum.IN.getCode());
updateAppOrderIn.setUpdateTime(LocalDateTime.now());
appOrderInMapper.update(updateAppOrderIn);
}
// 占用库位
Location location = new Location();
location.setLocationId(useLocation.getLocationId());
location.setLocationStatus(LocationStatus.OCCUPY.getCode());
location.setVehicleId(request.getPalletNo());
locationMapper.modifyLocation(location);
success.setCode("200");
success.setMessage("生成入库任务成功");
success.setWmsTaskId(newInTask.getTaskId());
success.setPalletNo(request.getPalletNo());
success.setFromCellNo(request.getFromCellNo());
success.setToCellNo(useLocation.getLocationId());
}
return success;
}
@ -170,4 +282,124 @@ public class ContainerImplement implements ContainerService {
}
/**
* 请求补盘通知
* @param request
* @return
*/
@Override
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED)
public CreateFeedPalletTaskResponse createFeedPallet(CreateFeedPalletTaskRequest request) {
// 校验
String md5 = StringUtils.containerMd5(request.getRequestId());
if(!md5.equals(request.getKey())) {
return new CreateFeedPalletTaskResponse("400", "请求失败，密钥校验未通过");
}
// 找出空托盘位置
Vehicle vehicle = new Vehicle();
vehicle.setVehicleStatus(VehicleStatus.ON.getCode());
vehicle.setIsEmpty(1);
List<Vehicle> emptyVehicle = vehicleMapper.selVehicles(vehicle);
if (CollectionUtils.isEmpty(emptyVehicle)) {
log.info("没有空托盘");
return new CreateFeedPalletTaskResponse("400", "没有空托盘");
}
// 可用空托盘列表
List<Location> usefulLocation = new ArrayList<>();
for (Vehicle empty : emptyVehicle) {
// 根据空托盘位置信息查找对应载具信息
Location location = locationMapper.selLocations(new Location(empty.getCurrentLocation()))
.stream().filter(l -> l.getLayer() == 1)
.findFirst().orElse(null);
if (location == null) {
log.info("该空托盘无库位信息");
return new CreateFeedPalletTaskResponse("400", "该空托盘无库位信息");
}
// 判断空托盘状态
if (location.getLocationStatus().equals(LocationStatus.EMPTY) || location.getIsLock().equals(1) ){
log.info("该空托盘不可用");
return new CreateFeedPalletTaskResponse("400", "该空托盘不可用");
}
usefulLocation.add(location);
}
if (CollectionUtils.isEmpty(usefulLocation)) {
log.info("无可用空托盘");
return new CreateFeedPalletTaskResponse("400", "无可用空托盘");
}
OrderOut orderOut = new OrderOut();
String orderOutRowId = UUID.randomUUID().toString();
orderOut.setRowId(orderOutRowId);
orderOut.setRecordId(UUID.randomUUID().toString());
orderOut.setOrderId(UUID.randomUUID().toString());
orderOut.setWarehouseOrigin("四向车立体库");
orderOut.setWarehouseDestination(usefulLocation.get(0).getVehicleId()); //借用这个字段表示载具号
orderOut.setOrderType(1);
orderOut.setRowNo(1);
orderOut.setGoodsNum(String.valueOf(1));
//Integer.parseInt(row.getQty())
orderOut.setUnit("");
orderOut.setStatus(OrderOutStatusEnum.CREATED.getCode());
orderOut.setCreateTime(new Timestamp(System.currentTimeMillis()));
orderOut.setRemark("空托盘出库");
orderOut.setBatchNo(null);
int insertOrderOut = orderOutMapper.insert(orderOut);
if (insertOrderOut <= 0) {
return new CreateFeedPalletTaskResponse("400", "创建入库单失败");
}
List<Task> outTasks = new ArrayList<>(); // 出库任务列表
Task task = new Task();
task.setTaskId(String.valueOf(Calendar.getInstance().getTimeInMillis()));
task.setTaskType(2);
task.setTaskGroup(orderOut.getOrderId());
task.setTaskStatus(OrderOutStatusEnum.CREATED.getCode());
task.setOrigin(usefulLocation.get(0).getLocationId());
task.setDestination("113");
task.setPickStand(orderOut.getRowId());
task.setWeight(0.0);
task.setVehicleNo(orderOut.getWarehouseDestination());
task.setCreateTime(new Date());
task.setUserName("WMS");
task.setGoodsId(null);
task.setGoodsName(null);
task.setOperateNum(null);
task.setTotalNum(null);
task.setTaskPriority(1);
task.setRemark1("空托盘出库");
outTasks.add(task);
int addResult = taskMapper.addTasks(outTasks);
if(addResult < 1) {
log.info("添加任务失败");
return new CreateFeedPalletTaskResponse("400", "创建入库单失败");
}
//更改出库单状态为出库中
OrderOut orderOutUpdateStatus = new OrderOut();
orderOutUpdateStatus.setRowId(orderOutRowId);
orderOutUpdateStatus.setStatus(OrderOutStatusEnum.RUNNING.getCode());
int a = orderOutMapper.update(orderOutUpdateStatus);
if (a > 0){
log.info("更新出库单状态成功");
}else {
log.info("更新出库单状态失败");
}
CreateFeedPalletTaskResponse response = new CreateFeedPalletTaskResponse();
response.setCode("200");
response.setMessage("成功");
response.setWmsTaskId(task.getTaskId());
response.setPalletNo(usefulLocation.get(0).getVehicleId());
response.setFromCellNo(usefulLocation.get(0).getLocationId());
response.setToCellNo(request.getToCellNo());
return response ;
}
}

326
src/main/java/com/wms/service/serviceImplements/parent/MesServiceImplement.java
View File

@ -9,16 +9,15 @@ import com.wms.entity.table.*;
import com.wms.mapper.*;
import com.wms.service.MesService;
import com.wms.utils.StringUtils;
import com.wms.utils.storage.StockUtils;
import com.wms.utils.WmsUtils;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.time.LocalDateTime;
import java.util.*;
/**
* 上位系统交互
@ -30,9 +29,9 @@ import java.util.List;
public class MesServiceImplement implements MesService {
/**
* 库存 Mapper
* 入库单 Mapper
*/
private final StockMapper stockMapper;
private final AppOrderInMapper appOrderInMapper;
/**
* 出库通知单 Mapper
@ -44,9 +43,8 @@ public class MesServiceImplement implements MesService {
*/
private final OrderCheckMapper orderCheckMapper;
/**
* 任务 Mapper
*/
private final StockMapper stockMapper;
private final TaskMapper taskMapper;
@ -58,34 +56,44 @@ public class MesServiceImplement implements MesService {
*/
@Override
public MesApiLocalResponse receiptIn(ReceiptInRequest request) {
/* 校验库存是否存在 */
Stock checkIsExist = new Stock();
checkIsExist.setStockId(request.getGuid());
List<Stock> checkIsExistListResult = stockMapper.selStocks(checkIsExist);
if(!checkIsExistListResult.isEmpty()) {
// 记录已经存在
return new MesApiLocalResponse(0, String.format("该条记录已经存在，记录号：%s", request.getGuid()));
try{
/* 校验入库单是否存在 */
List<AppOrderIn> checkIsExistListResult = appOrderInMapper.select(new AppOrderIn(request.getGuid()));
if(checkIsExistListResult == null) {
// 数据库查询失败
return new MesApiLocalResponse(0, String.format("记录号校验失败，请重试，记录号：%s", request.getGuid()));
}
if(!checkIsExistListResult.isEmpty()) {
// 记录已经存在
return new MesApiLocalResponse(0, String.format("该条记录已经存在，记录号：%s", request.getGuid()));
}
/* 添加信息进入入库单，标记为创建状态 */
AppOrderIn orderIn = new AppOrderIn();
orderIn.setRowId(UUID.randomUUID().toString());
orderIn.setGuid(request.getGuid());
orderIn.setInType(request.getType());
orderIn.setBatchNo(request.getLosnr());
orderIn.setVehicleNo(request.getVehicleNo());
orderIn.setGoodsId(request.getItemCode());
orderIn.setGoodsNum(new BigDecimal(request.getLotQty()));
orderIn.setWareHouse(request.getWarehouse());
// if (Objects.equals(request.getWarehouse(), "100001")){
// orderIn.setOrderStatus(OrderInStatusEnum.CREATE.getCode());
// } else if (Objects.equals(request.getWarehouse(), "300002")) {
// orderIn.setOrderStatus(OrderInStatusEnum.BINDING.getCode());
// }
orderIn.setOrderStatus(OrderInStatusEnum.CREATE.getCode());
orderIn.setCreateTime(LocalDateTime.now());
orderIn.setCreatePerson("MES_API");
orderIn.setUpdateTime(LocalDateTime.now());
int addResult = appOrderInMapper.insert(orderIn);
if(addResult == 1) {
return new MesApiLocalResponse(1, "入库单添加成功");
}
return new MesApiLocalResponse(0, "入库单添加失败");
}catch (Exception e){
return new MesApiLocalResponse(0, "入库单添加异常");
}
/* 添加信息，标记为待入库状态 */
Stock needInStock = new Stock();
needInStock.setStockId(request.getGuid());
needInStock.setLocationId("-");
needInStock.setVehicleId(request.getLosnr());
needInStock.setRemark(request.getType().toString());
needInStock.setBatchNo(request.getLosnr());
needInStock.setGoodsId(request.getItemCode());
needInStock.setGoodsName("-");
needInStock.setRealNum(Integer.parseInt(request.getLotQty()));
needInStock.setAvailableNum(Integer.parseInt(request.getLotQty()));
needInStock.setWarehouseName(request.getWarehouse());
needInStock.setCreateTime(new Date());
needInStock.setStockStatus(StockStatus.WAIT_IN.getCode());
int addResult = stockMapper.addStock(needInStock);
if(addResult == 1) {
return new MesApiLocalResponse(1, "添加成功");
}
return new MesApiLocalResponse(0, "添加失败");
}
@ -97,98 +105,44 @@ public class MesServiceImplement implements MesService {
@Override
public MesApiLocalResponse outNotice(OutNoticeRequest request) {
/* 检验记录是否存在 */
OrderOut checkIsExist = new OrderOut();
checkIsExist.setRecordId(request.getGuid());
List<OrderOut> checkIsExistListResult = orderOutMapper.query(checkIsExist);
if(!checkIsExistListResult.isEmpty()) {
return new MesApiLocalResponse(0, String.format("该条记录已经存在，记录号：%s", request.getGuid()));
}
/* 插入数据，插入记录表 */
List<OrderOut> orderOutList = new ArrayList<>();
for(var row : request.getRow()) {
OrderOut orderOut = new OrderOut();
orderOut.setRecordId(request.getGuid());
orderOut.setOrderId(request.getTransferNo());
orderOut.setWarehouseOrigin(request.getFWarehouse());
orderOut.setWarehouseDestination(request.getTWarehouse());
orderOut.setOrderType(3);
orderOut.setDeliveryTime(StringUtils.toData(request.getRDate()));
orderOut.setRowNo(Integer.parseInt(row.getTransferLine()));
orderOut.setGoodsId(row.getItemCode());
orderOut.setGoodsNum(Integer.parseInt(row.getQty()));
orderOut.setUnit(row.getUnit());
orderOut.setStatus(OrderOutStatusEnum.CREATED.getCode());
orderOut.setCreateTime(new Timestamp(System.currentTimeMillis()));
orderOutList.add(orderOut);
}
if(orderOutList.isEmpty()) {
return new MesApiLocalResponse(0, "没有数据");
}
int addOrderResult = orderOutMapper.insertList(orderOutList);
if(addOrderResult != orderOutList.size()) {
try{
OrderOut checkIsExist = new OrderOut();
checkIsExist.setRecordId(request.getGuid());
List<OrderOut> checkIsExistListResult = orderOutMapper.query(checkIsExist);
if(!checkIsExistListResult.isEmpty()) {
return new MesApiLocalResponse(0, String.format("该条记录已经存在，记录号：%s", request.getGuid()));
}
/* 插入数据，插入记录表 */
List<OrderOut> orderOutList = new ArrayList<>();
for(var row : request.getRow()) {
OrderOut orderOut = new OrderOut();
orderOut.setRowId(UUID.randomUUID().toString());
orderOut.setRecordId(request.getGuid());
orderOut.setOrderId(request.getTransferNo());
orderOut.setWarehouseOrigin(request.getFWarehouse());
orderOut.setWarehouseDestination(request.getTWarehouse());
orderOut.setOrderType(request.getType());
orderOut.setDeliveryTime(StringUtils.toData(request.getRDate()));
orderOut.setRowNo(Integer.parseInt(row.getTransferLine()));
orderOut.setGoodsId(row.getItemCode());
orderOut.setGoodsNum(row.getQty());
//Integer.parseInt(row.getQty())
orderOut.setUnit(row.getUnit());
orderOut.setStatus(OrderOutStatusEnum.CREATED.getCode());
orderOut.setCreateTime(new Timestamp(System.currentTimeMillis()));
orderOutList.add(orderOut);
}
if(orderOutList.isEmpty()) {
return new MesApiLocalResponse(0, "没有数据");
}
int addOrderResult = orderOutMapper.insertList(orderOutList);
if(addOrderResult == orderOutList.size()) {
return new MesApiLocalResponse(1, "添加出库单成功");
}
return new MesApiLocalResponse(0, "添加失败，请稍后再试");
}catch (Exception e){
return new MesApiLocalResponse(0, "添加失败，请稍后再试");
}
// 计算出库
List<Task> outTasks = new ArrayList<>(); // 出库任务列表
/* 查询库存 */
for(var goods : request.getRow()) {
// 拉出该物料的所有库存
Stock queryStock = new Stock();
queryStock.setBatchNo(goods.getItemCode());
queryStock.setStockStatus(StockStatus.OK.getCode());
List<Stock> stockList = stockMapper.selStocks(queryStock);
if(stockList == null) {
return new MesApiLocalResponse(0, String.format("库存拉取失败，请稍后再试，物料号：%s", goods.getItemCode()));
}
if(stockList.isEmpty()) {
return new MesApiLocalResponse(0, String.format("该物料没有库存，物料号：%s，其他物料也一并拒绝出库", goods.getItemCode()));
}
Integer availableNum = StockUtils.sumStcokAvailableNum(stockList); // 拥有的数量
int needNum = Integer.parseInt(goods.getQty()); // 需要的数量
if(availableNum.compareTo(Integer.parseInt(goods.getQty())) < 0) {
return new MesApiLocalResponse(0, String.format("该物料库存不足，物料号：%s，库存数量：%d，出库数量：%s", goods.getItemCode(), availableNum, goods.getQty()));
}
// 生成出库任务
for(Stock outStock : stockList) {
if(needNum <= 0) {
break;
}
// 生成出库任务，更新库存为出库中
int outNum = needNum > outStock.getAvailableNum() ? outStock.getAvailableNum() : needNum; // 需要操作的数量
Task task = new Task();
task.setTaskId(String.format("%s-%s", request.getTransferNo(), outStock.getStockId()));
task.setTaskType(TaskType.OUT.getCode());
task.setTaskStatus(OrderOutStatusEnum.CREATED.getCode());
task.setTaskGroup(request.getTransferNo());
task.setOrigin(outStock.getLocationId());
task.setDestination("");
task.setPickStand("");
task.setWeight(0.0);
task.setVehicleNo(outStock.getVehicleId());
task.setCreateTime(new Date());
task.setUserName("mes");
task.setGoodsId(outStock.getGoodsId());
task.setGoodsName(outStock.getGoodsName());
task.setOperateNum(outNum);
task.setTotalNum(outStock.getRealNum());
task.setTaskPriority(1);
outTasks.add(task);
// 更新库存为出库中
stockMapper.updateStockStatusWithLocationId(outStock.getLocationId(), StockStatus.OUT.getCode());
// 重新计算需求数量
needNum -= outNum;
}
}
if(outTasks.isEmpty()) {
return new MesApiLocalResponse(0, "无法生成任务，请稍后再试");
}
int addResult = taskMapper.addTasks(outTasks);
if(addResult == outTasks.size()) {
return new MesApiLocalResponse(1, "添加成功");
}
return new MesApiLocalResponse(0, "添加失败");
}
/**
@ -199,63 +153,71 @@ public class MesServiceImplement implements MesService {
@Override
public MesApiLocalResponse checkNotice(CheckNoticeRequest request) {
/* 检测这条记录存不存在 */
OrderCheck checkIsExist = new OrderCheck();
checkIsExist.setRecordId(request.getGuid());
List<OrderCheck> checkIsExistListResult = orderCheckMapper.query(checkIsExist);
if(!checkIsExistListResult.isEmpty()) {
return new MesApiLocalResponse(0, String.format("该条记录已经存在，记录号：%s", request.getGuid()));
}
/* 添加盘点记录 */
OrderCheck orderCheck = new OrderCheck();
orderCheck.setRecordId(request.getGuid());
orderCheck.setCheckId(request.getInventoryNo());
orderCheck.setWarehouse(request.getIWarehouse());
orderCheck.setStatus(OrderCheckStatusEnum.CREATED.getCode());
orderCheck.setCreateTime(new Date());
int insertOrderCheckResult = orderCheckMapper.insert(orderCheck);
if(insertOrderCheckResult < 1) {
return new MesApiLocalResponse(0, "添加失败，数据库连接异常，请稍后再试");
}
// 将该盘点单号对应的库别全部生成盘点任务
List<Task> checkTasks = new ArrayList<>(); // 盘点任务列表
Stock queryStock = new Stock();
queryStock.setWarehouseName(request.getIWarehouse());
List<Stock> stockList = stockMapper.selStocks(queryStock);
if(stockList == null || stockList.isEmpty()) {
return new MesApiLocalResponse(0, String.format("该库别没有库存，请稍后再试，库别：%s", request.getIWarehouse()));
}
// 检查这些应该盘点的库位有没有任务在执行
for(Stock stock : stockList) {
List<Task> notCompleteTasks = taskMapper.haveNotCompleteTask(stock.getLocationId());
if(notCompleteTasks == null) {
return new MesApiLocalResponse(0, String.format("数据库校验任务失败，请稍后再试，库位：%s", stock.getLocationId()));
try{
OrderCheck checkIsExist = new OrderCheck();
checkIsExist.setRecordId(request.getGuid());
List<OrderCheck> checkIsExistListResult = orderCheckMapper.query(checkIsExist);
if(!checkIsExistListResult.isEmpty()) {
return new MesApiLocalResponse(0, String.format("该条记录已经存在，记录号：%s", request.getGuid()));
}
if(!notCompleteTasks.isEmpty()) {
return new MesApiLocalResponse(0, String.format("该库位有任务在执行，请稍后再试，库位：%s", stock.getLocationId()));
/* 添加盘点记录 */
OrderCheck orderCheck = new OrderCheck();
orderCheck.setRecordId(request.getGuid());
orderCheck.setCheckId(request.getInventoryNo());
orderCheck.setWarehouse(request.getIWarehouse());
orderCheck.setStatus(OrderCheckStatusEnum.CREATED.getCode());
orderCheck.setCreateTime(new Date());
int insertOrderCheckResult = orderCheckMapper.insert(orderCheck);
if(insertOrderCheckResult > 0) {
return new MesApiLocalResponse(1, "添加成功");
}
Task task = new Task();
task.setTaskId(String.format("%s-%s", request.getGuid(), stock.getLocationId()));
task.setTaskType(TaskType.INVENTORY.getCode());
task.setTaskStatus(OrderOutStatusEnum.CREATED.getCode());
task.setTaskGroup(request.getIWarehouse());
task.setOrigin(stock.getLocationId());
task.setDestination("");
task.setPickStand("");
task.setWeight(0.0);
task.setVehicleNo(stock.getVehicleId());
task.setCreateTime(new Date());
task.setUserName("mes");
task.setGoodsId(stock.getGoodsId());
task.setGoodsName(stock.getGoodsName());
task.setOperateNum(stock.getRealNum());
task.setTotalNum(stock.getRealNum());
task.setTaskPriority(1);
checkTasks.add(task);
return new MesApiLocalResponse(0, "添加失败，请稍后再试");
}catch (Exception e){
return new MesApiLocalResponse(0, "添加异常，请稍后再试");
}
int addTasks = taskMapper.addTasks(checkTasks);
if(addTasks == checkTasks.size()) {
return new MesApiLocalResponse(1, "添加成功");
}
return new MesApiLocalResponse(0, "添加失败，请稍后再试");
//
// // 将该盘点单号对应的库别全部生成盘点任务
// List<Task> checkTasks = new ArrayList<>(); // 盘点任务列表
// Stock queryStock = new Stock();
// queryStock.setWarehouseName(request.getIWarehouse());
// List<Stock> stockList = stockMapper.selStocks(queryStock);
// if(stockList == null || stockList.isEmpty()) {
// return new MesApiLocalResponse(0, String.format("该库别没有库存，请稍后再试，库别：%s", request.getIWarehouse()));
// }
// // 检查这些应该盘点的库位有没有任务在执行
// for(Stock stock : stockList) {
// List<Task> notCompleteTasks = taskMapper.haveNotCompleteTask(stock.getLocationId());
// if(notCompleteTasks == null) {
// return new MesApiLocalResponse(0, String.format("数据库校验任务失败，请稍后再试，库位：%s", stock.getLocationId()));
// }
// if(!notCompleteTasks.isEmpty()) {
// return new MesApiLocalResponse(0, String.format("该库位有任务在执行，请稍后再试，库位：%s", stock.getLocationId()));
// }
// Task task = new Task();
// task.setTaskId(WmsUtils.generateUUIDString());
// task.setTaskType(TaskType.INVENTORY.getCode());
// task.setTaskStatus(OrderOutStatusEnum.CREATED.getCode());
// task.setTaskGroup(request.getInventoryNo());
// task.setOrigin(stock.getLocationId());
// task.setDestination("");
// task.setPickStand("");
// task.setWeight(0.0);
// task.setVehicleNo(stock.getVehicleId());
// task.setCreateTime(new Date());
// task.setUserName("mes");
// task.setGoodsId(stock.getGoodsId());
// task.setGoodsName(stock.getGoodsName());
// task.setOperateNum(stock.getRealNum());
// task.setTotalNum(stock.getRealNum());
// task.setTaskPriority(1);
// checkTasks.add(task);
// }
// int addTasks = taskMapper.addTasks(checkTasks);
// if(addTasks == checkTasks.size()) {
// return new MesApiLocalResponse(1, "添加成功");
// }
}
}

5
src/main/java/com/wms/utils/MyPassword.java
View File

@ -110,4 +110,9 @@ public class MyPassword {
}
return result;
}
public static void main(String[] args) {
String pwd = decrypt("812C0C84E2970FA98456DDC5B0B59594");
System.out.println(pwd);
}
}

5
src/main/java/com/wms/utils/WmsUtils.java
View File

@ -1,6 +1,7 @@
package com.wms.utils;
import org.apache.commons.lang3.StringUtils;
import org.hibernate.validator.constraints.Length;
import java.text.ParseException;
import java.text.SimpleDateFormat;
@ -167,4 +168,8 @@ public class WmsUtils {
public static Date getYear(int year){
return calculationYear(new Date(), year);
}
}

62
src/main/java/com/wms/utils/storage/LocationUtils.java
View File

@ -1,6 +1,8 @@
package com.wms.utils.storage;
import com.wms.constants.enums.LocationStatus;
import com.wms.entity.app.container.CreateInstoreTaskResponse;
import com.wms.entity.table.AppOrderIn;
import com.wms.entity.table.Location;
import com.wms.entity.table.Stock;
import com.wms.entity.table.Task;
@ -8,10 +10,13 @@ import com.wms.mapper.LocationMapper;
import com.wms.mapper.StockMapper;
import com.wms.mapper.TaskMapper;
import lombok.RequiredArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Objects;
/**
* 库位工具类
@ -20,6 +25,7 @@ import java.util.List;
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class LocationUtils {
private static final Logger log = LoggerFactory.getLogger(LocationUtils.class);
/**
* 库存 Mapper
*/
@ -37,14 +43,58 @@ public class LocationUtils {
/**
* 获取一个区域的可用的库位
* @param areaId 区域ID
*
* @param areaId 区域ID
* @param appOrderIn
* @return 可用的库位排序
*/
public List<Location> getNewLocation(Integer areaId) {
Location query = new Location();
query.setAreaId(areaId);
query.setLocationStatus(LocationStatus.EMPTY.getCode());
return locationMapper.selNextLocation(query);
public List<Location> getNewLocation(Integer areaId, AppOrderIn appOrderIn) {
if (Objects.equals(appOrderIn.getWareHouse(), "A")){
Location query = new Location();
query.setAreaId(areaId);
query.setWareArea("A");
query.setLocationStatus(LocationStatus.EMPTY.getCode());
List<Location> canUseLocations = locationMapper.selNextLocation(query);
if(canUseLocations.isEmpty()){
log.info("A级优先级没有可用库位，开始寻找B级库位");
query.setAreaId(areaId);
query.setWareArea("B");
query.setLocationStatus(LocationStatus.EMPTY.getCode());
List<Location> canUseLocations2 = locationMapper.selNextLocation(query);
if (canUseLocations2.isEmpty()){
log.info("A,B级优先级没有可用库位，开始寻找C级库位");
query.setAreaId(areaId);
query.setWareArea("C");
query.setLocationStatus(LocationStatus.EMPTY.getCode());
return locationMapper.selNextLocation(query);
}
return canUseLocations2;
}
return canUseLocations;
} else if (Objects.equals(appOrderIn.getWareHouse(), "B")) {
Location query = new Location();
query.setAreaId(areaId);
query.setWareArea("B");
query.setLocationStatus(LocationStatus.EMPTY.getCode());
List<Location> canUseLocations = locationMapper.selNextLocation(query);
if(canUseLocations.isEmpty()){
log.info("B级优先级没有可用库位，开始寻找C级库位");
query.setAreaId(areaId);
query.setWareArea("C");
query.setLocationStatus(LocationStatus.EMPTY.getCode());
return locationMapper.selNextLocation(query);
}
return canUseLocations;
} else if (Objects.equals(appOrderIn.getWareHouse(), "C")) {
Location query = new Location();
query.setAreaId(areaId);
query.setWareArea(appOrderIn.getWareHouse());
query.setLocationStatus(LocationStatus.EMPTY.getCode());
return locationMapper.selNextLocation(query);
}else{
return null;
}
}
/**

14
src/main/resources/application.yml
View File

@ -1,15 +1,15 @@
spring:
# 本地测试环境
# datasource:
# url: jdbc:mysql://localhost:3306/wms_bk_xuzhou?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowMultiQueries=true
# username: developer
# password: developer
# url: jdbc:mysql://localhost:3306/wms_fdbk_xuzhou?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowMultiQueries=true
# username: root
# password: "000000"
# 在线环境
# 在线环境
datasource:
url: jdbc:mysql://192.168.234.134:3306/wms_yaxinke_yangzhou?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowMultiQueries=true
username: developer
password: developer
url: jdbc:mysql://localhost:3306/wms_fdbk_xuzhou?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowMultiQueries=true
username: root
password: 123456
profiles:
active: online

170
src/main/resources/mapper/AppOrderInMapper.xml Normal file
View File

@ -0,0 +1,170 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.wms.mapper.AppOrderInMapper">
<resultMap type="AppOrderIn" id="AppOrderInMap">
<result property="rowId" column="row_id"/>
<result property="guid" column="guid"/>
<result property="inType" column="in_type"/>
<result property="batchNo" column="batch_no"/>
<result property="vehicleNo" column="vehicle_no"/>
<result property="goodsId" column="goods_id"/>
<result property="goodsNum" column="goods_num"/>
<result property="wareHouse" column="ware_house"/>
<result property="orderStatus" column="order_status"/>
<result property="createTime" column="create_time"/>
<result property="createPerson" column="create_person"/>
<result property="updateTime" column="update_time"/>
<result property="remark" column="remark"/>
<result property="productionDate" column="production_date"/>
</resultMap>
<!-- 条件插查询并将结果倒序排列-->
<select id="select" parameterType="AppOrderIn" resultMap="AppOrderInMap">
select row_id, guid, in_type, batch_no, vehicle_no, goods_id, goods_num,
ware_house, order_status, create_time, create_person, update_time, remark
from tbl_app_order_in
<where>
<if test="rowId != null"> and row_id = #{rowId}</if>
<if test="guid != null"> and guid = #{guid}</if>
<if test="inType != null"> and in_type = #{inType}</if>
<if test="batchNo != null"> and batch_no = #{batchNo}</if>
<if test="vehicleNo != null"> and vehicle_no = #{vehicleNo}</if>
<if test="goodsId != null"> and goods_id = #{goodsId}</if>
<if test="goodsNum != null"> and goods_num = #{goodsNum}</if>
<if test="wareHouse != null"> and ware_house = #{wareHouse}</if>
<if test="orderStatus != null"> and order_status = #{orderStatus}</if>
<if test="createPerson != null"> and create_person = #{createPerson}</if>
<if test="remark != null"> and remark = #{remark}</if>
</where>
order by create_time desc
</select>
<!-- 插入一条数据-->
<insert id="insert" parameterType="AppOrderIn">
insert into tbl_app_order_in
(row_id, guid, in_type, batch_no, vehicle_no, goods_id, goods_num,
ware_house, order_status, create_time, create_person, update_time, remark, production_date)
values (#{rowId}, #{guid}, #{inType}, #{batchNo}, #{vehicleNo}, #{goodsId}, #{goodsNum},
#{wareHouse}, #{orderStatus}, #{createTime}, #{createPerson}, #{updateTime}, #{remark}, #{productionDate})
</insert>
<insert id="insertList" parameterType="java.util.List">
insert into tbl_app_order_in(row_id, guid, in_type, batch_no, vehicle_no, goods_id, goods_num,
ware_house, order_status, create_time, create_person, update_time, remark)
values
<foreach collection="list" index="index" item="item" separator=",">
(#{rowId}, #{guid}, #{inType}, #{batchNo}, #{vehicleNo}, #{goodsId}, #{goodsNum},
#{wareHouse}, #{orderStatus}, #{createTime}, #{createPerson}, #{updateTime}, #{remark})
</foreach>
</insert>
<!-- 根据 row_id 更新数据-->
<update id="update" parameterType="AppOrderIn">
update tbl_app_order_in
<set>
<if test="guid != null">guid = #{guid},</if>
<if test="inType != null">in_type = #{inType},</if>
<if test="batchNo != null">batch_no = #{batchNo},</if>
<if test="vehicleNo != null">vehicle_no = #{vehicleNo},</if>
<if test="goodsId != null">goods_id = #{goodsId}, </if>
<if test="goodsNum != null">goods_num = #{goodsNum},</if>
<if test="wareHouse != null">ware_house = #{wareHouse},</if>
<if test="orderStatus != null">order_status = #{orderStatus},</if>
<if test="createPerson != null">create_person = #{createPerson},</if>
<if test="updateTime != null">update_time = #{updateTime},</if>
<if test="remark != null">remark = #{remark},</if>
<if test="createTime != null">create_time = #{createTime},</if>
<if test="productionDate != null">production_date = #{productionDate},</if>
</set>
where row_id = #{rowId}
</update>
<!-- 根据 row_id 删除数据-->
<delete id="delete" parameterType="String">
delete from tbl_app_order_in where row_id = #{rowId}
</delete>
<select id="selectWithParams" resultMap="AppOrderInMap">
select row_id, guid, in_type, batch_no, vehicle_no, goods_id, goods_num,
ware_house, order_status, create_time, create_person, update_time, remark
from tbl_app_order_in
<where>
order_status in
<foreach collection="orderStatus" item="orderStatus" separator="," open="(" close=")">
#{orderStatus}
</foreach>
<if test="searchStr != null and searchStr != ''">
and (row_id like concat('%', #{searchStr}, '%') or guid like concat('%', #{searchStr}, '%')
or in_type like concat('%', #{searchStr}, '%')
or batch_no like concat('%', #{searchStr}, '%')
or vehicle_no like concat('%', #{searchStr}, '%')
or goods_id like concat('%', #{searchStr}, '%')
or ware_house like concat('%', #{searchStr}, '%'))
</if>
</where>
order by create_time desc
</select>
<select id="selectWithVehicle" parameterType="String" resultMap="AppOrderInMap">
select row_id, guid, in_type, batch_no, vehicle_no, goods_id, goods_num,
ware_house, order_status, create_time, create_person, update_time, remark, production_date
from tbl_app_order_in
<where>
<if test="vehicleNo != null"> and vehicle_no = #{vehicleNo}</if>
</where>
order by create_time asc
</select>
<select id="selectWithGoodsId" parameterType="String" resultMap="AppOrderInMap">
select row_id, guid, in_type, batch_no, vehicle_no, goods_id, goods_num,
ware_house, order_status, create_time, create_person, update_time, remark
from tbl_app_order_in
<where>
<if test="goodsId != null"> and goods_id = #{goodsId}</if>
</where>
order by create_time asc
</select>
<select id="selectWithRowId" parameterType="String" resultMap="AppOrderInMap">
select row_id, guid, in_type, batch_no, vehicle_no, goods_id, goods_num,
ware_house, order_status, create_time, create_person, update_time, remark, production_date
from tbl_app_order_in
<where>
<if test="rowId != null"> and row_id = #{rowId}</if>
</where>
order by create_time asc
</select>
<select id="selectWithBatchNo" parameterType="Map" resultMap="AppOrderInMap">
select row_id, guid, in_type, batch_no, vehicle_no, goods_id, goods_num,
ware_house, order_status, create_time, create_person, update_time, remark, production_date
from tbl_app_order_in
<where>
<if test="batch_no != null"> and batch_no = #{batchNo}</if>
<if test="goods_num != null"> and goods_num = #{goodsNum}</if>
<if test="production_date != null"> and production_date = #{date}</if>
<if test="goods_id != null"> and goods_id = #{goodsId}</if>
</where>
order by update_time desc
</select>
<update id="updateStatusWithVehicleNo">
update tbl_app_order_in
set order_status = #{orderStatus}
where vehicle_no = #{vehicleNo}
</update>
<delete id="deleteByCheckNoGood" parameterType="String">
delete from tbl_app_order_in where remark = #{remark}
</delete>
</mapper>

10
src/main/resources/mapper/LocationMapper.xml
View File

@ -15,10 +15,11 @@
<result property="isLock" column="is_lock"/>
<result property="locationStatus" column="location_status"/>
<result property="vehicleId" column="vehicle_id"/>
<result property="wareArea" column="ware_area"/>
</resultMap>
<sql id="selectAll">
select location_id, area_id, tunnel_id, equipment_id, location_type, queue, line, layer, depth, is_lock, location_status, vehicle_id
select location_id, area_id, tunnel_id, equipment_id, location_type, queue, line, layer, depth, is_lock, location_status, vehicle_id, ware_area
from tbl_app_location
</sql>
@ -37,6 +38,7 @@
<if test="isLock != null"> and is_lock = #{isLock}</if>
<if test="locationStatus != null"> and location_status = #{locationStatus}</if>
<if test="vehicleId != null and vehicleId != ''"> and vehicle_id = #{vehicleId}</if>
<if test="wareArea != null and wareArea != ''"> and ware_area = #{wareArea}</if>
</where>
order by depth desc, line asc, layer asc
</select>
@ -64,11 +66,16 @@
<if test="tunnelId != null"> and tunnel_id = #{tunnelId}</if>
<if test="equipmentId != null"> and equipment_id = #{equipmentId}</if>
<if test="locationType != null"> and location_type = #{locationType}</if>
<if test="wareArea != null"> and ware_area = #{wareArea}</if>
and is_lock = 0 and location_status = 0
</where>
order by depth desc, layer asc, line desc
for update
</select>
<select id="selectAll" resultType="java.lang.Integer">
select location_id, area_id, tunnel_id, equipment_id, location_type, queue, line, layer, depth, is_lock, location_status, vehicle_id, ware_area
from tbl_app_location
</select>
<insert id="addLocation" parameterType="Location">
insert into tbl_app_location
@ -108,6 +115,7 @@
<if test="isLock != null">is_lock = #{isLock},</if>
<if test="locationStatus != null">location_status = #{locationStatus},</if>
<if test="vehicleId != null">vehicle_id = #{vehicleId},</if>
<if test="wareArea != null">ware_area = #{wareArea},</if>
</trim>
where location_id = #{locationId}
</update>

21
src/main/resources/mapper/OrderCheckMapper.xml
View File

@ -26,6 +26,22 @@
</where>
</select>
<select id="queryByRecordId" parameterType="orderCheck" resultMap="OrderCheckMap">
select record_id, check_id, warehouse, status, create_time, complete_time, remark
from tbl_app_order_check
<where>
<if test="recordId != null"> and record_id = #{recordId}</if>
order by create_time desc
</where>
</select>
<select id="queryAll" parameterType="orderCheck" resultMap="OrderCheckMap">
select record_id, check_id, warehouse, status, create_time, complete_time, remark
from tbl_app_order_check
</select>
<!-- 插入一条-->
<insert id="insert" parameterType="orderCheck">
insert into tbl_app_order_check(record_id, check_id, warehouse, status, create_time, complete_time, remark)
@ -42,4 +58,9 @@
</insert>
<delete id="delete" parameterType="String">
delete from tbl_app_order_check where record_id = #{record_id}
</delete>
</mapper>

60
src/main/resources/mapper/OrderOutMapper.xml
View File

@ -3,6 +3,7 @@
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.wms.mapper.OrderOutMapper">
<resultMap type="OrderOut" id="OrderOutMap">
<result property="rowId" column="row_id"/>
<result property="recordId" column="record_id"/>
<result property="orderId" column="order_id"/>
<result property="warehouseOrigin" column="warehouse_origin"/>
@ -10,7 +11,7 @@
<result property="orderType" column="order_type"/>
<result property="deliveryTime" column="delivery_time"/>
<result property="rowNo" column="row_no"/>
<result property="batchNo" column="batch_no"/>
<result property="goodsId" column="goods_id"/>
<result property="goodsName" column="goods_name"/>
<result property="goodsNum" column="goods_num"/>
@ -23,27 +24,42 @@
<!-- 插入一条数据-->
<insert id="insert" parameterType="orderOut">
insert into tbl_app_order_out(record_id, order_id, warehouse_origin, warehouse_destination, order_type, delivery_time, row_no, goods_id, goods_name, goods_num, unit, status, create_time, remark)
values(#{recordId}, #{orderId}, #{warehouseOrigin}, #{warehouseDestination}, #{orderType}, #{deliveryTime}, #{rowNo}, #{goodsId}, #{goodsName}, #{goodsNum}, #{unit}, #{status}, #{createTime}, #{remark})
insert into tbl_app_order_out(row_id, record_id, order_id, warehouse_origin, warehouse_destination, order_type, delivery_time, row_no, goods_id, goods_name, goods_num, unit, status, create_time, remark, batch_no)
values(#{rowId}, #{recordId}, #{orderId}, #{warehouseOrigin}, #{warehouseDestination}, #{orderType}, #{deliveryTime}, #{rowNo}, #{goodsId}, #{goodsName}, #{goodsNum}, #{unit}, #{status}, #{createTime}, #{remark}, #{batchNo})
</insert>
<update id="update" parameterType="orderOut">
update tbl_app_order_out
<trim prefix="SET" suffixOverrides=",">
<if test="status != null">status = #{status},</if>
</trim>
where row_id = #{rowId}
</update>
<!-- 插入多条数据-->
<insert id="insertList" parameterType="java.util.List">
insert into tbl_app_order_out(record_id, order_id, warehouse_origin, warehouse_destination, order_type, delivery_time, row_no, goods_id, goods_name, goods_num, unit, status, create_time, remark)
insert into tbl_app_order_out(row_id, record_id, order_id, warehouse_origin, warehouse_destination, order_type, delivery_time, row_no, goods_id, goods_name, goods_num, unit, status, create_time, remark)
values
<foreach collection="list" index="index" item="item" separator=",">
(#{item.recordId}, #{item.orderId}, #{item.warehouseOrigin}, #{item.warehouseDestination}, #{item.orderType},
(#{item.rowId}, #{item.recordId}, #{item.orderId}, #{item.warehouseOrigin}, #{item.warehouseDestination}, #{item.orderType},
#{item.deliveryTime}, #{item.rowNo}, #{item.goodsId},
#{item.goodsName}, #{item.goodsNum}, #{item.unit},
#{item.status}, #{item.createTime}, #{item.remark})
</foreach>
</insert>
<!--删除一条记录以 rowId 为条件 -->
<delete id="deleteOrderOut" parameterType="String">
delete from tbl_app_order_out where row_id = #{rowId}
</delete>
<!-- 条件查询-->
<select id="query" parameterType="orderOut" resultMap="OrderOutMap">
select record_id, order_id, warehouse_origin, warehouse_destination, order_type, delivery_time, row_no, goods_id, goods_name, goods_num, unit, remark
select row_id, record_id, order_id, warehouse_origin, warehouse_destination, order_type, delivery_time, row_no, goods_id, goods_name, goods_num, unit, remark, batch_no, status, create_time
from tbl_app_order_out
<where>
<if test="rowId != null"> and row_id = #{rowId}</if>
<if test="recordId != null"> and record_id = #{recordId}</if>
<if test="orderId != null"> and order_id = #{orderId}</if>
<if test="warehouseOrigin != null"> and warehouse_origin = #{warehouseOrigin}</if>
@ -55,10 +71,40 @@
<if test="goodsName != null"> and goods_name = #{goodsName}</if>
<if test="goodsNum != null"> and goods_num = #{goodsNum}</if>
<if test="unit != null"> and unit = #{unit}</if>
<if test="status != null"> and status = #{status}</if>
<if test="status != null"> and this.status = #{status}</if>
<if test="remark != null"> and remark = #{remark}</if>
<if test="batchNo != null"> and batch_no = #{batchNo}</if>
order by record_id desc
</where>
</select>
<select id="queryWithRowId" parameterType="orderOut" resultMap="OrderOutMap">
select row_id, record_id, order_id, warehouse_origin, warehouse_destination, order_type, delivery_time, row_no, goods_id, goods_name, goods_num, unit, remark, batch_no, status, create_time
from tbl_app_order_out
<where>
<if test="rowId != null"> and row_id = #{rowId}</if>
order by record_id desc
</where>
</select>
<select id="queryWithParams" resultMap="OrderOutMap">
select row_id, record_id, order_id, warehouse_origin, warehouse_destination, order_type, delivery_time, row_no, goods_id, goods_name, goods_num, unit, status, create_time, remark
from tbl_app_order_out
<where>
status in
<foreach collection="orderStatus" item="orderStatus" separator="," open="(" close=")">
#{orderStatus}
</foreach>
<if test="searchStr != null and searchStr != ''">
and (order_id like concat('%', #{searchStr}, '%')
or record_id like concat('%', #{searchStr}, '%')
or warehouse_origin like concat('%', #{searchStr}, '%')
or warehouse_destination like concat('%', #{searchStr}, '%')
or goods_id like concat('%', #{searchStr}, '%')
or goods_name like concat('%', #{searchStr}, '%'))
</if>
</where>
order by create_time desc
</select>
</mapper>

46
src/main/resources/mapper/StockMapper.xml
View File

@ -30,7 +30,7 @@
</resultMap>
<sql id="selectAll">
select stock_id, location_id, vehicle_id, goods_id, goods_name, batch_no, available_num, remain_num, real_num, provider_id,
select stock_id, warehouse_name, location_id, vehicle_id, goods_id, goods_name, batch_no, available_num, remain_num, real_num, provider_id,
provider_name, production_date, expiration_date, stock_status, goods_status, create_time, last_update_time, last_update_user, remark,
is_inventory, inventory_task_id, current_location, shelf_life
from tbl_app_stock
@ -52,6 +52,24 @@
group by goods_id, goods_name
</select>
<select id="selStocksByLocationId" parameterType="string" resultMap="StockMap">
select stock_id, warehouse_name, location_id, vehicle_id, goods_id, goods_name, batch_no, available_num, remain_num, real_num, provider_id,
provider_name, production_date, expiration_date, stock_status, goods_status, create_time, last_update_time, last_update_user, remark,
is_inventory, inventory_task_id, current_location, shelf_life
from tbl_app_stock
<where>
<if test="locationId != null and locationId != ''"> and location_id = #{locationId}</if>
</where>
</select>
<select id="selStockOutOfDate" resultMap="StockMap">
<include refid="selectAll" />
where expiration_date &lt; now() and goods_status != 3
@ -95,7 +113,7 @@
<if test="currentLocation != null and currentLocation != ''"> and current_location = #{currentLocation}</if>
<if test="shelfLife != null"> and shelf_life = #{shelfLife}</if>
</where>
order by goods_status desc, create_time asc
order by goods_status desc, available_num asc , create_time asc
</select>
<insert id="addStock" parameterType="Stock">
@ -190,6 +208,19 @@
update tbl_app_stock set location_id = #{newLocationId}, stock_status = #{status} where location_id = #{oldLocationId}
</update>
<select id="groupByVehicleNo" parameterType="Stock" resultMap="StockMap">
SELECT batch_no ,SUM(available_num) AS available_num,MAX(stock_id) AS stock_id,MAX(warehouse_name) AS warehouse_name,MAX(goods_id) AS goods_id
FROM tbl_app_stock where location_id = #{locationId}
GROUP BY batch_no
</select>
<select id="groupByBatchNo" parameterType="Stock" resultMap="StockMap">
SELECT vehicle_id ,SUM(available_num) AS available_num,MAX(stock_id) AS stock_id,MAX(warehouse_name) AS warehouse_name,MAX(goods_id) AS goods_id
FROM tbl_app_stock where location_id = #{locationId}
GROUP BY vehicle_id
</select>
<update id="resetStock" parameterType="Stock">
@ -210,6 +241,17 @@
update tbl_app_stock set stock_status = #{status} where location_id = #{locationId}
</update>
<update id="updateStockAvailableNumWithStockId">
update tbl_app_stock set available_num = #{availableNum} where stock_id = #{stockId}
</update>
<update id="updateStockProductionDateWithStockId">
update tbl_app_stock set production_date = #{productionDate} where stock_id = #{stockId}
</update>
<update id="updateLocationIdWithBetchNo">
update tbl_app_stock set location_id = #{locationId} where batch_no = #{batchNo}
</update>

9
src/main/resources/mapper/TaskMapper.xml
View File

@ -63,6 +63,15 @@
order by task_priority desc, task_status desc, create_time desc
</select>
<select id="selTasksByTaskId" parameterType="Task" resultMap="TaskMap">
<include refid="selectAll" />
<where>
<if test="taskId != null and taskId != ''"> and task_id = #{taskId}</if>
</where>
order by task_priority desc, task_status desc, create_time desc
</select>
<insert id="addTask" parameterType="Task">
insert into tbl_app_task
<trim prefix="(" suffix=")" suffixOverrides=",">

2
src/main/resources/mapper/VehicleMapper.xml
View File

@ -22,7 +22,7 @@
<if test="vehicleStatus != null"> and vehicle_status = #{vehicleStatus}</if>
<if test="isEmpty != null"> and is_empty = #{isEmpty}</if>
</where>
order by vehicle_id
order by is_empty desc
</select>
<select id="selVehicleById" parameterType="String" resultMap="VehicleMap">