icewint/wms_server_yaxinke_yangzhou
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

<fix>[important]基本测试版本，已完成和其他系统交互

Browse Source
This commit is contained in:
葛林强 2024-07-18 13:26:56 +08:00
parent 0c5613e6dc
commit 5500e16ba3
16 changed files with 520 additions and 364 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>

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

@ -99,7 +99,7 @@ public class JobComponent extends BaseController {
}
}
}catch (Exception exception){
logger.error("定时器下发任务发生异常：{}", exception.getMessage());
logger.error("定时器下发任务发生异常：{}", exception.toString());
}
}
@ -111,7 +111,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.IN.getCode());
tempTask.setOrigin(task.getOrigin());
tempTask.setDestination(task.getDestination());
@ -128,6 +128,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));
}
@ -231,7 +232,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.OUT.getCode());
tempTask.setOrigin(task.getOrigin());
tempTask.setDestination(task.getDestination());
@ -248,6 +249,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 { // 四向车库
@ -259,7 +261,7 @@ 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"); // A13-34-01;A13-16-01;
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);
@ -269,6 +271,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));
}
@ -318,8 +321,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 +379,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 +396,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 {
@ -411,6 +418,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));
}

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

@ -1,21 +1,23 @@
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.alibaba.fastjson2.JSON;
import com.wms.constants.enums.*;
import com.wms.entity.app.ResponseEntity;
import com.wms.entity.app.mes.*;
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.utils.HttpUtils;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.swing.plaf.synth.Region;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
@ -75,42 +77,57 @@ 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()));
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()));
}
}
/* 找出任务，完成该任务；找出该任务终点，更新库存为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); // 更新库位
// 更新库存为 ok
int updateStock = stockMapper.updateStockStatusWithLocationId(task.getDestination(), StockStatus.OK.getCode());
if(updateStock > 0){
log.info("入库完成更新库存成功，任务：{}", task.toLoggerString());
// 入库完成发送mes
Stock checkIsExist = new Stock();
checkIsExist.setLocationId(task.getDestination());
List<Stock> checkIsExistListResult = stockMapper.selStocks(checkIsExist);
sendMesPutInGoods(checkIsExistListResult.get(0), task.getDestination()); // 发送 mes 入库上架
return true;
}
return false;
}
/**
* 发送 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());
}
}
/**
* 完成出库任务
@ -118,71 +135,190 @@ public class TaskOperation {
* @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 location = new Location();
location.setLocationId(task.getDestination());
location.setLocationStatus(LocationStatus.EMPTY.getCode());
locationMapper.modifyLocation(location);
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());
//出库完成发送mes
Stock checkIsExist = new Stock();
checkIsExist.setLocationId(task.getOrigin());
List<Stock> checkIsExistListResult = stockMapper.selStocks(checkIsExist);
sendMesPutOutGoods(checkIsExistListResult, task);
return true;
}
return false;
}
private void sendMesPutOutGoods(List<Stock> stocks, Task task) {
try {
SendMesPutOutGoodsRequest request = new SendMesPutOutGoodsRequest();
request.setGuid(task.getTaskId());
request.setTransferNo(task.getTaskGroup());
request.setType(task.getPickStand());
List<SendMesPutOutGoodsRow> rows = new ArrayList<>();
int lint = 1;
for(Stock stock : stocks) {
SendMesPutOutGoodsRow row = new SendMesPutOutGoodsRow();
row.setTransferLine(String.valueOf(lint));
row.setLosnr(stock.getBatchNo());
row.setBinCode(stock.getLocationId());
row.setLotQty(String.valueOf(stock.getRealNum() - stock.getAvailableNum()));
rows.add(row);
}
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);
}
log.warn("发送MES出库下架失败，信息：{}，返回信息：{}", requestString, responseString);
}catch (Exception e){
log.error("发送MES出库下架失败异常，信息：{}", e.getMessage());
}
}
/**
* 完成盘点任务
* @param task 任务
* @return 完成结果
*/
private boolean completeInventoryTask(Task task) {
/* 找出任务，完成该任务；找出该任务终点，删除库存；释放库位 */
// 完成任务
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());
// 盘点出库完成发送mes
Stock checkIsExist = new Stock();
checkIsExist.setLocationId(task.getOrigin());
List<Stock> checkIsExistListResult = stockMapper.selStocks(checkIsExist);
sendMesInventoryGoods(checkIsExistListResult, task);
return true;
}
return false;
}
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<>();
int lint = 1;
for(Stock stock : stocks) {
SendMesGoodsInventoryRow row = new SendMesGoodsInventoryRow();
row.setLosnr(stock.getBatchNo());
row.setBinCode(stock.getLocationId());
row.setLotQty(String.valueOf(stock.getRealNum() - stock.getAvailableNum()));
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);
}
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);
// 释放库位
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); // 更新库位
// 更新库位
int updatedLocation = stockMapper.updateLocationAndStatus(task.getOrigin(), task.getDestination(), StockStatus.OK.getCode());
if(updatedLocation > 0){
log.info("移库库位更新成功，任务：{}", task.toLoggerString());
// 移库完成发送mes
Stock checkIsExist = new Stock();
checkIsExist.setLocationId(task.getOrigin());
List<Stock> checkIsExistListResult = stockMapper.selStocks(checkIsExist);
sendMesPutMoveGoods(checkIsExistListResult.get(0), task);
return true;
}
return false;
}
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,29 +353,27 @@ 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);
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,52 +381,71 @@ 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;
}
// 更新库存信息为库存中
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()));
}
/* 找出任务，取消该任务；找出该任务终点，删除库存；释放库位 */
// 取消任务
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 cancelInventoryTask(Task task) {
/* 找出任务，取消该任务；找出该任务终点，删除库存；释放库位 */
// 取消任务
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;
}
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;
}
// 更新库存信息为库存中
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);
/**
* 取消移库任务
* @param task 任务
* @return 取消结果
*/
private boolean cancelMoveTask(Task task) {
/* 找出任务，更新任务为取消；释放新库位；更新库存为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;
}
return false;
}
//endregion

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

@ -1,10 +1,15 @@
package com.wms.constants.enums;
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_SEND_TASK("WMS向WCS发送任务", "http://172.21.80.223:18990/api/wms/wmsTask/setStackerTask"),
URL_WMS_TO_WCS_CHANGE_TASK("WMS请求变更任务状态", "http://172.21.80.223: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_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_MOVE("批次调整", "http://172.21.73.210:9000/Asimco/vmesserver/wms_interface/LotAD");
private final String description;
private final String value;

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

@ -1,5 +1,6 @@
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;
@ -7,14 +8,17 @@ import com.wms.entity.app.container.CreateInstoreTaskResponse;
import com.wms.entity.app.container.TaskStateNoticeRequest;
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 +35,10 @@ public class ContainerController extends BaseController {
*/
@PostMapping("/createInstoreTask")
public CreateInstoreTaskResponse createInstoreTask(@RequestBody @Validated CreateInstoreTaskRequest request) {
return containerService.createInstoreTask(request);
log.info("四向车扫码入库请求：{}", JSON.toJSONString(request));
CreateInstoreTaskResponse instoreTask = containerService.createInstoreTask(request);
log.info("四向车扫码入库信息返回：{}", JSON.toJSONString(instoreTask));
return instoreTask;
}
@ -42,7 +49,10 @@ public class ContainerController extends BaseController {
*/
@PostMapping("/taskStateNotice")
public ContainerApiLocalResponse taskStateNotice(@RequestBody @Validated TaskStateNoticeRequest request){
return containerService.taskStateNotice(request);
log.info("四向车任务状态通知请求：{}", JSON.toJSONString(request));
ContainerApiLocalResponse containerApiLocalResponse = containerService.taskStateNotice(request);
log.info("四向车任务状态通知信息返回：{}", JSON.toJSONString(containerApiLocalResponse));
return containerApiLocalResponse;
}

203
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;
@ -38,6 +39,11 @@ import java.util.UUID;
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class WcsController {
/**
* 任务操作类
*/
private final TaskOperation taskOperation;
/**
* 库存 Mapper
*/
@ -77,6 +83,7 @@ public class WcsController {
*/
@PostMapping("/requestIn")
public ResponseEntity requestIn(@RequestBody @Validated RequireInRequest request) {
log.info(String.format("%s 点位请求入库：%s",request.getPoint(), request.getVehicleNo()));
/* 校验库存是否存在待入库信息 */
Stock checkIsExist = new Stock();
checkIsExist.setBatchNo(request.getVehicleNo());
@ -84,7 +91,7 @@ public class WcsController {
List<Stock> checkIsExistListResult = stockMapper.selStocks(checkIsExist);
if(checkIsExistListResult == null || checkIsExistListResult.isEmpty()) {
// 记录不存在
return new ResponseEntity(0, String.format("该条码不存在待入库记录，条码号：%s", request.getVehicleNo()));
return new ResponseEntity(-1, String.format("该条码不存在待入库记录，条码号：%s", request.getVehicleNo()));
}
/* 查找一个空库位 */
Location emptyLocation = new Location();
@ -92,14 +99,14 @@ public class WcsController {
emptyLocation.setAreaId(1);
List<Location> emptyLocations = locationMapper.selLocations(emptyLocation);
if(emptyLocations == null) {
return new ResponseEntity(0, "库位查找失败，网络连接异常，请稍后再试");
return new ResponseEntity(-1, "库位查找失败，网络连接异常，请稍后再试");
}
if(emptyLocations.isEmpty()){
return new ResponseEntity(0, "没有可用库位");
return new ResponseEntity(-1, "没有可用库位");
}
Location emptyLocationItem = locationUtils.checkCanUse(emptyLocations);
if(emptyLocationItem == null) {
return new ResponseEntity(0, "没有可用库位或者库位存在干涉，请稍后再试");
return new ResponseEntity(-1, "没有可用库位或者库位存在干涉，请稍后再试");
}
// 该空库位可用，生成一个入库任务，并将库存表更新库位
// 更新库位表，占掉库位
@ -117,7 +124,7 @@ public class WcsController {
task.setTaskType(TaskType.IN.getCode());
task.setTaskStatus(WmsTaskStatus.NEW.getCode());
task.setTaskGroup(UUID.randomUUID().toString());
task.setOrigin("");
task.setOrigin(request.getPoint());
task.setDestination(emptyLocationItem.getLocationId());
task.setPickStand("");
task.setWeight(0.0);
@ -131,30 +138,11 @@ public class WcsController {
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, "存在入库任务，申请成功");
}
return new ResponseEntity(0, "添加入库任务失败，网络连接异常，请稍后再试");
return new ResponseEntity(-1, "添加入库任务失败，网络连接异常，请稍后再试");
}
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请求值
@ -170,168 +158,25 @@ public class WcsController {
String vehicleNo = wmsReceiveTaskResultEntity.getVehicleNo();
// 查找对应任务
Task taskForQuery = new Task();
taskForQuery.setTaskGroup(taskId);
taskForQuery.setTaskId(taskId);
List<Task> tasks = taskService.selTasks(taskForQuery);
if(tasks == null || tasks.isEmpty()) {
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(3)) { // 任务完成
boolean completedTask = taskOperation.completeTask(task);
if(!completedTask) {
return new ResponseEntity(-1, "任务完成失败，请稍后再试");
}
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, "移库取消库位状态更新失败");
boolean cancelledTask = taskOperation.cancelTask(task);
if(!cancelledTask) {
return new ResponseEntity(-1, "任务取消失败，请稍后再试");
}
return new ResponseEntity(0, "任务取消成功");
}
return new ResponseEntity(0, "不处理的状态");
}

11
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;
@ -40,7 +41,15 @@ public class OutNoticeRequest {
*/
@NotBlank(message = "目的库别不允许为空或者空字符串")
@JsonProperty("Twarehouse")
private String TWarehouse;
private String tWarehouse;
/**
* 出库类型
*/
@NotNull(message = "类型不允许为空")
@JsonProperty("Type")
private Integer type;
/**
* 计划交货日期

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

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

@ -0,0 +1,19 @@
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("BinCode")
private String binCode;
}

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 String type;
@JsonProperty("Row")
private List<SendMesPutOutGoodsRow> row;
}

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

@ -0,0 +1,22 @@
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("BinCode")
private String binCode;
}

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

@ -19,9 +19,14 @@ 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.Service;
import com.wms.utils.WmsUtils;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.UUID;
@ -33,6 +38,7 @@ import java.util.UUID;
public class ContainerImplement implements ContainerService {
private static final Logger log = LoggerFactory.getLogger(ContainerImplement.class);
/**
* 库存 Mapper
*/
@ -89,7 +95,7 @@ public class ContainerImplement implements ContainerService {
/* 找到可用的库位 */ /* 生成任务（生成的任务直接运行中，因为此处会把任务直接回回去），更新库存表内状态为入库中 */
// 新建任务 插入任务表
Task newInTask = new Task();
newInTask.setTaskId(UUID.randomUUID().toString());
newInTask.setTaskId(String.valueOf(Calendar.getInstance().getTimeInMillis()));
newInTask.setTaskGroup(UUID.randomUUID().toString());
newInTask.setTaskType(TaskType.IN.getCode());
newInTask.setTaskStatus(WmsTaskStatus.WAIT.getCode()); // 因为任务是直接返回去的，所以直接是已下发状态
@ -114,10 +120,11 @@ public class ContainerImplement implements ContainerService {
updateStock.setLocationId(useLocation.getLocationId());
stockMapper.modifyStock(updateStock);
}
// 释放库位
// 占用库位
Location location = new Location();
location.setLocationId(useLocation.getLocationId());
location.setLocationStatus(LocationStatus.EMPTY.getCode());
location.setLocationStatus(LocationStatus.OCCUPY.getCode());
location.setVehicleId(request.getPalletNo());
locationMapper.modifyLocation(location);
CreateInstoreTaskResponse success = new CreateInstoreTaskResponse();

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

@ -9,16 +9,14 @@ import com.wms.entity.table.*;
import com.wms.mapper.*;
import com.wms.service.MesService;
import com.wms.utils.StringUtils;
import com.wms.utils.WmsUtils;
import com.wms.utils.storage.StockUtils;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.*;
/**
* 上位系统交互
@ -111,7 +109,7 @@ public class MesServiceImplement implements MesService {
orderOut.setOrderId(request.getTransferNo());
orderOut.setWarehouseOrigin(request.getFWarehouse());
orderOut.setWarehouseDestination(request.getTWarehouse());
orderOut.setOrderType(3);
orderOut.setOrderType(request.getType());
orderOut.setDeliveryTime(StringUtils.toData(request.getRDate()));
orderOut.setRowNo(Integer.parseInt(row.getTransferLine()));
orderOut.setGoodsId(row.getItemCode());
@ -154,17 +152,16 @@ public class MesServiceImplement implements MesService {
break;
}
// 生成出库任务，更新库存为出库中
int outNum = needNum > outStock.getAvailableNum() ? outStock.getAvailableNum() : needNum; // 需要操作的数量
Task task = new Task();
task.setTaskId(String.format("%s-%s", request.getTransferNo(), outStock.getStockId()));
task.setTaskId(String.valueOf(Calendar.getInstance().getTimeInMillis()));
task.setTaskType(TaskType.OUT.getCode());
task.setTaskStatus(OrderOutStatusEnum.CREATED.getCode());
task.setTaskGroup(request.getTransferNo());
task.setOrigin(outStock.getLocationId());
task.setDestination("");
task.setPickStand("");
task.setPickStand(request.getType().toString());
task.setWeight(0.0);
task.setVehicleNo(outStock.getVehicleId());
task.setCreateTime(new Date());
@ -234,10 +231,10 @@ public class MesServiceImplement implements MesService {
return new MesApiLocalResponse(0, String.format("该库位有任务在执行，请稍后再试，库位：%s", stock.getLocationId()));
}
Task task = new Task();
task.setTaskId(String.format("%s-%s", request.getGuid(), stock.getLocationId()));
task.setTaskId(String.valueOf(Calendar.getInstance().getTimeInMillis()));
task.setTaskType(TaskType.INVENTORY.getCode());
task.setTaskStatus(OrderOutStatusEnum.CREATED.getCode());
task.setTaskGroup(request.getIWarehouse());
task.setTaskGroup(request.getInventoryNo());
task.setOrigin(stock.getLocationId());
task.setDestination("");
task.setPickStand("");

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

@ -167,4 +167,8 @@ public class WmsUtils {
public static Date getYear(int year){
return calculationYear(new Date(), year);
}
}

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

@ -1,13 +1,13 @@
spring:
# 本地测试环境
# datasource:
# url: jdbc:mysql://localhost:3306/wms_bk_xuzhou?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowMultiQueries=true
# url: jdbc:mysql://192.168.234.134:3306:3306/wms_bk_xuzhou?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowMultiQueries=true
# username: developer
# password: developer
# 在线环境
datasource:
url: jdbc:mysql://192.168.234.134:3306/wms_yaxinke_yangzhou?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowMultiQueries=true
url: jdbc:mysql://172.21.80.150:3306/wms_yaxinke_yangzhou?characterEncoding=utf8&serverTimezone=Asia/Shanghai&allowMultiQueries=true
username: developer
password: developer