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

pom.xml

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

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

@@ -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()) {
+            for(Task notCompleteTask : notCompleteTasks) {
-                return; // 存在未完成的任务，退出函数
+                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));
         }

src/main/java/com/wms/bussiness/TaskOperation.java

@@ -1,21 +1,23 @@
 package com.wms.bussiness;
 
-import com.wms.constants.enums.LocationStatus;
+import com.alibaba.fastjson2.JSON;
-import com.wms.constants.enums.StockStatus;
+import com.wms.constants.enums.*;
-import com.wms.constants.enums.TaskType;
+import com.wms.entity.app.ResponseEntity;
-import com.wms.constants.enums.WmsTaskStatus;
+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) {
-        /* 将任务更新为完成，将库存更新为正常库存，将库位更新为占用 */
+        /* 找出任务，完成该任务；找出该任务终点，更新库存为OK */
-        // 更新任务状态
+        // 完成任务
-        Task updateTask = new Task();
+        Task completeTask = new Task();
-        updateTask.setTaskId(task.getTaskId());
+        completeTask.setTaskId(task.getTaskId());
-        updateTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
+        completeTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
-        updateTask.setFinishTime(new Date());
+        completeTask.setFinishTime(new Date());
-        int updateRow = taskMapper.executeTask(updateTask);
+        taskMapper.executeTask(completeTask); // 完成任务
-        if(updateRow != 1) {
+        // 占掉新库位，生成的时候会占，这里重复操作保护
-            log.warn(String.format("完成入库任务更新任务状态失败，任务号：%s", task.getTaskId()));
+        Location occupyLocation = new Location();
-            return false;
+        occupyLocation.setLocationId(task.getDestination());
-        }
+        occupyLocation.setLocationStatus(LocationStatus.OCCUPY.getCode());
-        // 更新库存状态
+        occupyLocation.setVehicleId(task.getVehicleNo());
-        Stock stockQuery = new Stock();
+        locationMapper.modifyLocation(occupyLocation); // 更新库位
-        stockQuery.setLocationId(task.getDestination());
+        // 更新库存为 ok
-        List<Stock> stocks = stockMapper.selStocks(stockQuery);
+        int updateStock = stockMapper.updateStockStatusWithLocationId(task.getDestination(), StockStatus.OK.getCode());
-        if(stocks == null) {
+        if(updateStock > 0){
-            log.warn(String.format("完成入库任务查询库存 查询数据库失败，任务号：%s", task.getTaskId()));
+            log.info("入库完成更新库存成功，任务：{}", task.toLoggerString());
-            return false;
+            // 入库完成发送mes
-        }
+            Stock checkIsExist = new Stock();
-        if(stocks.isEmpty()) {
+            checkIsExist.setLocationId(task.getDestination());
-            log.warn(String.format("完成入库任务查询库存没有库存数据，任务号：%s", task.getTaskId()));
+            List<Stock> checkIsExistListResult = stockMapper.selStocks(checkIsExist);
-            return false;
+            sendMesPutInGoods(checkIsExistListResult.get(0), task.getDestination()); // 发送 mes 入库上架
-        }
-        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()));
-            }
-        }
             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();
+        Task completeTask = new Task();
-        updateTask.setTaskId(task.getTaskId());
+        completeTask.setTaskId(task.getTaskId());
-        updateTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
+        completeTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
-        updateTask.setFinishTime(new Date());
+        completeTask.setFinishTime(new Date());
-        int updateRow = taskMapper.executeTask(updateTask);
+        taskMapper.executeTask(completeTask); // 完成任务
-        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()));
-            }
-        }
         // 释放库位
-        Location location = new Location();
+        Location updateLocation = new Location();
-        location.setLocationId(task.getDestination());
+        updateLocation.setLocationId(task.getOrigin());
-        location.setLocationStatus(LocationStatus.EMPTY.getCode());
+        updateLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
-        locationMapper.modifyLocation(location);
+        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());
+        Task completeTask = new Task();
-        updateTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
+        completeTask.setTaskId(task.getTaskId());
-        updateTask.setFinishTime(new Date());
+        completeTask.setTaskStatus(WmsTaskStatus.FINISH.getCode());
-        int updateRow = taskMapper.executeTask(updateTask);
+        completeTask.setFinishTime(new Date());
-        if(updateRow != 1) {
+        taskMapper.executeTask(completeTask); // 完成任务
-            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;
-        }
         // 释放原库位
-        Location location = new Location();
+        // 释放库位
-        location.setLocationId(task.getOrigin());
+        Location updateLocation = new Location();
-        location.setLocationStatus(LocationStatus.EMPTY.getCode());
+        updateLocation.setLocationId(task.getOrigin());
-        locationMapper.modifyLocation(location);
+        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) {
-        /* 将任务更新为取消，将库存删除，将库位更新为空闲 */
+        /* 找出任务，取消该任务；找出该任务终点，更新库存为OK */
-        // 更新任务状态
+        // 取消任务
-        Task updateTask = new Task();
+        Task completeTask = new Task();
-        updateTask.setTaskId(task.getTaskId());
+        completeTask.setTaskId(task.getTaskId());
-        updateTask.setTaskStatus(WmsTaskStatus.CANCEL.getCode());
+        completeTask.setTaskStatus(WmsTaskStatus.CANCEL.getCode());
-        updateTask.setFinishTime(new Date());
+        completeTask.setFinishTime(new Date());
-        int updateRow = taskMapper.executeTask(updateTask);
+        taskMapper.executeTask(completeTask); // 取消任务
-        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()));
-        }
         // 释放库位
-        Location location = new Location();
+        Location updateLocation = new Location();
-        location.setLocationId(task.getDestination());
+        updateLocation.setLocationId(task.getDestination());
-        location.setLocationStatus(LocationStatus.EMPTY.getCode());
+        updateLocation.setLocationStatus(LocationStatus.EMPTY.getCode());
-        locationMapper.modifyLocation(location);
+        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();
+        Task completeTask = new Task();
-        updateTask.setTaskId(task.getTaskId());
+        completeTask.setTaskId(task.getTaskId());
-        updateTask.setTaskStatus(WmsTaskStatus.CANCEL.getCode());
+        completeTask.setTaskStatus(WmsTaskStatus.CANCEL.getCode());
-        updateTask.setFinishTime(new Date());
+        completeTask.setFinishTime(new Date());
-        int updateRow = taskMapper.executeTask(updateTask);
+        taskMapper.executeTask(completeTask); // 取消任务
-        if(updateRow != 1) {
+        // 更新库存为 ok
-            log.warn(String.format("取消出库任务更新任务状态失败，任务号：%s", task.getTaskId()));
+        int updateStock = stockMapper.updateStockStatusWithLocationId(task.getDestination(), StockStatus.OK.getCode());
-            return false;
+        if(updateStock > 0){
-        }
+            log.info("出库取消更新库存成功，任务：{}", task.toLoggerString());
-        // 更新库存信息为库存中
-        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) {
+        /* 找出任务，取消该任务；找出该任务终点，删除库存；释放库位 */
+        // 取消任务
+        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()));
+     * @param task 任务
-        }
+     * @return 取消结果
-        // 释放新库位
+     */
-        Location location = new Location();
+    private boolean cancelMoveTask(Task task) {
-        location.setLocationId(task.getDestination());
+        /* 找出任务，更新任务为取消；释放新库位；更新库存为OK */
-        location.setLocationStatus(LocationStatus.EMPTY.getCode());
+        // 取消任务
-        locationMapper.modifyLocation(location);
+        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

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

@@ -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_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.151:18990/api/Wms/WmsTask/ChangeTaskStatus"),
+    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;

src/main/java/com/wms/controller/others/ContainerController.java

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

src/main/java/com/wms/controller/others/WcsController.java

@@ -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(0, "存在入库任务，申请成功");
-            return new ResponseEntity(1, "存在入库任务，申请成功");
         }
-        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(taskStatus.equals(3)) { // 任务完成
-            if(task.getTaskType().equals(TaskType.IN.getCode())) { // 入库
+            boolean completedTask = taskOperation.completeTask(task);
-                /* 找出任务，完成该任务；找出该任务终点，更新库存为OK */
+            if(!completedTask) {
-                // 完成任务
+                return new ResponseEntity(-1, "任务完成失败，请稍后再试");
-                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, "移库库位更新失败");
             }
+            return new ResponseEntity(0, "任务完成成功");
         }
         if(taskStatus.equals(WmsTaskStatus.CANCEL.getCode())) { // 任务取消
-            if(task.getTaskType().equals(TaskType.IN.getCode())) { // 入库
+            boolean cancelledTask = taskOperation.cancelTask(task);
-                /* 找出任务，取消该任务；找出该任务终点，更新库存为OK */
+            if(!cancelledTask) {
-                // 取消任务
+                return new ResponseEntity(-1, "任务取消失败，请稍后再试");
-                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, "任务取消成功");
         }
         return new ResponseEntity(0, "不处理的状态");
     }

src/main/java/com/wms/entity/app/mes/OutNoticeRequest.java

@@ -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;
+
 
     /**
      * 计划交货日期

src/main/java/com/wms/entity/app/mes/SendMesGoodsInventoryRequest.java

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

src/main/java/com/wms/entity/app/mes/SendMesGoodsInventoryRow.java

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

src/main/java/com/wms/entity/app/mes/SendMesGoodsMoveRequest.java

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

src/main/java/com/wms/entity/app/mes/SendMesPutOutGoodsRequest.java

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

src/main/java/com/wms/entity/app/mes/SendMesPutOutGoodsRow.java

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

src/main/java/com/wms/service/serviceImplements/parent/ContainerImplement.java

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

src/main/java/com/wms/service/serviceImplements/parent/MesServiceImplement.java

@@ -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.*;
-import java.util.Arrays;
-import java.util.Date;
-import java.util.List;
 
 /**
  * 上位系统交互
@@ -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("");

src/main/java/com/wms/utils/WmsUtils.java

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

src/main/resources/application.yml

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