把生成任务的锁定容器和库位，集中到一起

肖超群
1 parent 4a0ebc6b
Showing 10 changed files with 356 additions and 243 deletions
huaheng-wms-core/src/main/java/org/jeecg/modules/wms/api/wcs/controller/WcsController.java
huaheng-wms-core/src/main/java/org/jeecg/modules/wms/api/wcs/entity/WcsTask.java
huaheng-wms-core/src/main/java/org/jeecg/modules/wms/api/wcs/service/WcsServiceImpl.java
huaheng-wms-core/src/main/java/org/jeecg/modules/wms/receipt/receiptContainerHeader/service/IReceiptContainerHeaderService.java
huaheng-wms-core/src/main/java/org/jeecg/modules/wms/receipt/receiptContainerHeader/service/impl/ReceiptContainerHeaderServiceImpl.java
huaheng-wms-core/src/main/java/org/jeecg/modules/wms/shipment/shipmentCombination/service/impl/ShipmentCombinationServiceImpl.java
huaheng-wms-core/src/main/java/org/jeecg/modules/wms/task/taskHeader/entity/TaskLockEntity.java
huaheng-wms-core/src/main/java/org/jeecg/modules/wms/task/taskHeader/service/ITaskHeaderService.java
huaheng-wms-core/src/main/java/org/jeecg/modules/wms/task/taskHeader/service/impl/TaskHeaderServiceImpl.java
huaheng-wms-core/src/main/java/org/jeecg/utils/constant/QuantityConstant.java
@@ -5,22 +5,14 @@ import javax.servlet.http.HttpServletRequest;
 import org.jeecg.common.api.vo.Result;
 import org.jeecg.common.aspect.annotation.AutoLog;
-import org.jeecg.modules.wms.api.wcs.entity.ArriveEntity;
-import org.jeecg.modules.wms.api.wcs.entity.ManyEmptyDomain;
-import org.jeecg.modules.wms.api.wcs.entity.ManyEmptyOutDomain;
-import org.jeecg.modules.wms.api.wcs.entity.MaterialInfoEntity;
-import org.jeecg.modules.wms.api.wcs.entity.TaskEntity;
-import org.jeecg.modules.wms.api.wcs.entity.WarecellDomain;
+import org.jeecg.modules.wms.api.wcs.entity.*;
 import org.jeecg.modules.wms.api.wcs.service.WcsService;
 import org.jeecg.modules.wms.framework.controller.HuahengBaseController;
 import org.jeecg.modules.wms.task.taskHeader.service.ITaskHeaderService;
 import org.jeecg.utils.StringUtils;
+import org.jeecg.utils.interceptor.AccessLimit;
 import org.jeecg.utils.support.ApiLogger;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.RequestBody;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.ResponseBody;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.*;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
@@ -46,6 +38,7 @@ public class WcsController extends HuahengBaseController {
     @ResponseBody
     @ApiOperation("仓位分配")
     @ApiLogger(apiName = "仓位分配", from = "WCS")
+    @AccessLimit(seconds = 5, maxCount = 5)
     public Result warecellAllocation(@RequestBody WarecellDomain warecellDomain, HttpServletRequest req) {
         String warehouseCode = warecellDomain.getWarehouseCode();
         String taskNo = warecellDomain.getTaskNo();
@@ -82,6 +75,7 @@ public class WcsController extends HuahengBaseController {
     @ResponseBody
     @ApiOperation("申请空托盘组入库")
     @ApiLogger(apiName = "申请空托盘组入库", from = "WCS")
+    @AccessLimit(seconds = 5, maxCount = 5)
     public Result manyEmptyIn(@RequestBody ManyEmptyDomain manyEmptyDomain) {
         String containerCode = manyEmptyDomain.getContainerCode();
         String warehouseCode = manyEmptyDomain.getWarehouseCode();
@@ -117,6 +111,7 @@ public class WcsController extends HuahengBaseController {
     @ResponseBody
     @ApiOperation("申请空托盘组出库")
     @ApiLogger(apiName = "申请空托盘组出库", from = "WCS")
+    @AccessLimit(seconds = 5, maxCount = 5)
     public Result manyEmptyOut(@RequestBody ManyEmptyOutDomain manyEmptyOutDomain) {
         String toPortCode = manyEmptyOutDomain.getPort();
         String warehouseCode = manyEmptyOutDomain.getWarehouseCode();
@@ -150,6 +145,7 @@ public class WcsController extends HuahengBaseController {
     @ResponseBody
     @ApiOperation("WCS任务完成")
     @ApiLogger(apiName = "WCS任务完成", from = "WCS")
+    @AccessLimit(seconds = 5, maxCount = 5)
     public Result completeTaskByWMS(@RequestBody TaskEntity taskEntity) {
         String taskNo = taskEntity.getTaskNo();
         String lockKey = taskNo;
@@ -185,6 +181,7 @@ public class WcsController extends HuahengBaseController {
     @ResponseBody
     @ApiOperation("到达拣选台")
     @ApiLogger(apiName = "到达拣选台", from = "WCS")
+    @AccessLimit(seconds = 5, maxCount = 5)
     public Result arrivedNotice(@RequestBody ArriveEntity arriveEntity) {
         String taskNo = arriveEntity.getTaskNo();
         String port = arriveEntity.getPort();
 package org.jeecg.modules.wms.api.wcs.entity;
+import org.jeecg.utils.constant.QuantityConstant;
+
 import io.swagger.annotations.ApiModelProperty;
 import lombok.Data;
@@ -92,6 +94,11 @@ public class WcsTask {
     private String zoneCode;
     /**
+     * 平台
+     */
+    @ApiModelProperty(value = "平台")
+    private String platform = QuantityConstant.PLATFORM_WMS;
+    /**
      * 备注
      */
     @ApiModelProperty(value = "备注")
@@ -114,4 +121,5 @@ public class WcsTask {
      */
     @ApiModelProperty(value = "顺序数量")
     private int sequenceNumber;
+
 }
@@ -39,7 +39,6 @@ import org.jeecg.modules.wms.task.taskHeader.service.ITaskHeaderService;
 import org.jeecg.utils.OkHttpUtils;
 import org.jeecg.utils.StringUtils;
 import org.jeecg.utils.constant.QuantityConstant;
-import org.jeecg.utils.support.ApiLogger;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -262,7 +261,6 @@ public class WcsServiceImpl implements WcsService {
     @Override
     @Transactional(rollbackFor = Exception.class)
-    @ApiLogger(apiName = "任务下发", from = "WCS")
     @OperationLog(bizId = "#taskHeader.getId()", bizType = "'任务追踪'", tag = "'任务下发'", extra = "''",
         msg = "'任务类型：' + #taskHeader.getTaskType() + '，起始库位：' + #taskHeader.getFromLocationCode() + '，目标库位：' + #taskHeader.getToLocationCode() + '，容器编码：' + #taskHeader.getContainerCode()",
         recordReturnValue = true)
@@ -471,7 +469,6 @@ public class WcsServiceImpl implements WcsService {
                 wcsTask.setTaskType(800);
                 break;
             case QuantityConstant.TASK_TYPE_OVER_STATION:
-            case QuantityConstant.TASK_TYPE_MANY_OVER_STATION:
                 wcsTask.setTaskType(1000);
                 break;
             default:
@@ -30,7 +30,7 @@ public interface IReceiptContainerHeaderService extends IService&lt;ReceiptContaine
     ReceiptContainerHeader getUnCompleteReceiptContainerByCode(String containerCode, String warehouseCode);
-    public Result<TaskHeader> createReceiptTask(ReceiptContainerHeader receiptContainerHeader, String warehouseCode);
+    Result<TaskHeader> createReceiptTask(ReceiptContainerHeader receiptContainerHeader, String warehouseCode);
     boolean updateStatusById(int status, int id);
@@ -65,4 +65,9 @@ public interface IReceiptContainerHeaderService extends IService&lt;ReceiptContaine
      * 更新去向toPort
      */
     boolean updateToPortById(String toPort, int id);
+
+    /**
+     * 更新去向toPort和状态status
+     */
+    boolean updateToPortAndStatus(String toPort, int status, int id);
 }
@@ -11,9 +11,7 @@ import javax.annotation.Resource;
 import org.jeecg.common.api.vo.Result;
 import org.jeecg.common.exception.JeecgBootException;
-import org.jeecg.modules.wms.config.container.entity.Container;
 import org.jeecg.modules.wms.config.container.service.IContainerService;
-import org.jeecg.modules.wms.config.location.entity.Location;
 import org.jeecg.modules.wms.config.location.service.ILocationService;
 import org.jeecg.modules.wms.config.parameterConfiguration.service.IParameterConfigurationService;
 import org.jeecg.modules.wms.inventory.inventoryHeader.service.IInventoryHeaderService;
@@ -28,6 +26,7 @@ import org.jeecg.modules.wms.receipt.receiptHeader.service.IReceiptDetailService
 import org.jeecg.modules.wms.receipt.receiptHeader.service.IReceiptHeaderService;
 import org.jeecg.modules.wms.task.taskHeader.entity.TaskDetail;
 import org.jeecg.modules.wms.task.taskHeader.entity.TaskHeader;
+import org.jeecg.modules.wms.task.taskHeader.entity.TaskLockEntity;
 import org.jeecg.modules.wms.task.taskHeader.service.ITaskDetailService;
 import org.jeecg.modules.wms.task.taskHeader.service.ITaskHeaderService;
 import org.jeecg.utils.StringUtils;
@@ -115,63 +114,40 @@ public class ReceiptContainerHeaderServiceImpl extends ServiceImpl&lt;ReceiptContai
     public Result<TaskHeader> createReceiptTask(ReceiptContainerHeader receiptContainerHeader, String warehouseCode) {
         log.info("开始创建入库任务");
         if (!receiptContainerHeader.getWarehouseCode().equals(warehouseCode)) {
-            return Result.error("id:" + receiptContainerHeader.getId() + "的入库组盘不能在" + warehouseCode + "仓库操作");
+            return Result.error("创建入库任务, id:" + receiptContainerHeader.getId() + "的入库组盘不能在" + warehouseCode + "仓库操作");
         }
         String containerCode = receiptContainerHeader.getContainerCode();
-        Container container = containerService.getContainerByCode(containerCode, warehouseCode);
-        if (container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_LOCK)) {
-            return Result.error("托盘已经锁定，不能生成任务");
-        }
+        String fromLocationCode = receiptContainerHeader.getFromLocationCode();
+        String toLocationCode = receiptContainerHeader.getToLocationCode();
+        int taskType = receiptContainerHeader.getTaskType();
+        boolean success = false;
         List<ReceiptContainerDetail> receiptContainerDetailList =
             receiptContainerDetailService.getReceiptContainerDetailListByHeaderId(receiptContainerHeader.getId());
         if (receiptContainerDetailList.size() == 0) {
-            return Result.error("id:" + receiptContainerHeader.getId() + "的入库组盘，没有组盘明细，请先组盘！");
-        }
-        boolean success = containerService.updateStatus(containerCode, QuantityConstant.STATUS_CONTAINER_LOCK, warehouseCode);
-        if (!success) {
-            throw new JeecgBootException("更新容器状态失败");
-        }
-        String fromLocationCode = receiptContainerHeader.getFromLocationCode();
-        String toLocaitonCode = receiptContainerHeader.getToLocationCode();
-        if (StringUtils.isNotEmpty(fromLocationCode)) {
-            success = locationService.updateStatus(fromLocationCode, QuantityConstant.STATUS_LOCATION_LOCK, warehouseCode);
-            if (!success) {
-                throw new JeecgBootException("更新起始库位状态失败");
-            }
-        }
-        String zoneCode = null;
-        if (StringUtils.isNotEmpty(toLocaitonCode)) {
-            if (!toLocaitonCode.equals(fromLocationCode)) {
-                success = locationService.updateStatus(toLocaitonCode, QuantityConstant.STATUS_LOCATION_LOCK, warehouseCode);
-                if (!success) {
-                    throw new JeecgBootException("更新目标库位状态失败");
-                }
-            }
-            Location toLocation = locationService.getLocationByCode(toLocaitonCode, warehouseCode);
-            if (!toLocation.getWarehouseCode().equals(warehouseCode)) {
-                throw new JeecgBootException("库位对应的仓库不匹配");
-            }
-            zoneCode = toLocation.getZoneCode();
-            // 旁边库位有任务
-            if (taskHeaderService.haveUncompleteTaskInNear(toLocation)) {
-                throw new JeecgBootException("旁边库位任务数大于0");
-            }
+            return Result.error("创建入库任务, id:" + receiptContainerHeader.getId() + "的入库组盘，没有组盘明细，请先组盘！");
         }
         int receiptContainerStatus = receiptContainerHeader.getStatus();
         if (receiptContainerStatus != QuantityConstant.RECEIPT_CONTAINER_BUILD) {
-            throw new JeecgBootException("入库组盘状态不是创建状态");
+            return Result.error("创建入库任务, 入库组盘状态不是创建状态");
         }
         String containerFillStatus = QuantityConstant.STATUS_CONTAINER_FILL_SOME;
         if (!StringUtils.isEmpty(receiptContainerHeader.getContainerFillStatus())) {
             containerFillStatus = receiptContainerHeader.getContainerFillStatus();
         }
+        // 锁定容器和库位
+        Result result = taskHeaderService.createTaskLockContainerAndLocation(taskType, containerCode, fromLocationCode, toLocationCode, warehouseCode);
+        if (!result.isSuccess()) {
+            return result;
+        }
+        TaskLockEntity taskLockEntity = (TaskLockEntity)result.getResult();
+        String zoneCode = taskLockEntity.getZoneCode();
         TaskHeader taskHeader = new TaskHeader();
         taskHeader.setContainerCode(containerCode);
         taskHeader.setContainerFillStatus(containerFillStatus);
         taskHeader.setTaskType(receiptContainerHeader.getTaskType());
         taskHeader.setInnernalTaskType(QuantityConstant.TASK_INTENERTYPE_RECEIPT);
         taskHeader.setFromLocationCode(fromLocationCode);
-        taskHeader.setToLocationCode(toLocaitonCode);
+        taskHeader.setToLocationCode(toLocationCode);
         taskHeader.setStatus(QuantityConstant.TASK_STATUS_BUILD);
         taskHeader.setCompanyCode(receiptContainerHeader.getCompanyCode());
         taskHeader.setReceiptContainerHeaderId(receiptContainerHeader.getId());
@@ -180,7 +156,7 @@ public class ReceiptContainerHeaderServiceImpl extends ServiceImpl&lt;ReceiptContai
         taskHeader.setToPortCode(receiptContainerHeader.getToPort());
         success = taskHeaderService.save(taskHeader);
         if (!success) {
-            throw new JeecgBootException("任务生成失败");
+            throw new JeecgBootException("创建入库任务, 任务生成失败");
         }
         int taskHeaderId = taskHeader.getId();
         List<TaskDetail> taskDetailList = new ArrayList<>();
@@ -206,7 +182,7 @@ public class ReceiptContainerHeaderServiceImpl extends ServiceImpl&lt;ReceiptContai
             taskDetailList.add(taskDetail);
             ReceiptDetail receiptDetail = receiptDetailService.getById(receiptContainerDetail.getReceiptDetailId());
             if (receiptDetail == null) {
-                throw new JeecgBootException("根据id:" + receiptContainerDetail.getReceiptDetailId() + ",没有找到入库单详情");
+                throw new JeecgBootException("创建入库任务, 根据id:" + receiptContainerDetail.getReceiptDetailId() + ",没有找到入库单详情");
             }
             Integer receiptId = receiptDetail.getReceiptId();
             receiptDetail = new ReceiptDetail();
@@ -215,33 +191,33 @@ public class ReceiptContainerHeaderServiceImpl extends ServiceImpl&lt;ReceiptContai
             receiptDetail.setStatus(QuantityConstant.RECEIPT_HEADER_WAIT_SHELF);
             receiptDetailList.add(receiptDetail);
         }
+        if (taskDetailList.size() == 0) {
+            throw new JeecgBootException("创建入库任务, 任务详情为空");
+        }
         success = taskDetailService.saveBatch(taskDetailList);
         if (!success) {
-            throw new JeecgBootException("任务详情生成失败");
+            throw new JeecgBootException("创建入库任务， 任务详情生成失败");
         }
         if (receiptContainerHeader.getTaskType() == QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT) {
             success = inventoryHeaderService.updateInventoryContainerStatusByContainerCode(containerCode, warehouseCode);
             if (!success) {
-                throw new JeecgBootException("生成任务时, 更新库存头失败");
+                throw new JeecgBootException("创建入库任务, 更新库存头失败");
             }
         }
-        ReceiptContainerHeader receiptContainerHeader1 = new ReceiptContainerHeader();
-        receiptContainerHeader1.setId(receiptContainerHeader.getId());
-        receiptContainerHeader1.setToPort(receiptContainerHeader.getToPort());
-        receiptContainerHeader1.setStatus(QuantityConstant.RECEIPT_CONTAINER_TASK);
-        success = this.updateById(receiptContainerHeader1);
+        success = receiptContainerHeaderService.updateToPortAndStatus(receiptContainerHeader.getToPort(), QuantityConstant.RECEIPT_CONTAINER_TASK,
+            receiptContainerHeader.getId());
         if (!success) {
-            throw new JeecgBootException("生成任务时，更新入库组盘头失败");
+            throw new JeecgBootException("创建入库任务，更新入库组盘头失败");
         }
         success = receiptDetailService.updateBatchById(receiptDetailList);
         if (!success) {
-            throw new JeecgBootException("更新入库单明细失败");
+            throw new JeecgBootException("创建入库任务，更新入库单明细失败");
         }
         List<Integer> receiptIdList = receiptDetailList.stream().map(ReceiptDetail::getReceiptId).distinct().collect(Collectors.toList());
         for (Integer receiptId : receiptIdList) {
             success = receiptHeaderService.updateReceiptHeaderStatus(receiptId);
             if (!success) {
-                throw new JeecgBootException("更新入库单明细失败");
+                throw new JeecgBootException("创建入库任务, 更新入库单明细失败");
             }
         }
         LogRecordContext.putVariable("taskHeader", taskHeader);// 操作日志收集
@@ -447,4 +423,14 @@ public class ReceiptContainerHeaderServiceImpl extends ServiceImpl&lt;ReceiptContai
         return success;
     }
+    @Override
+    public boolean updateToPortAndStatus(String toPort, int status, int id) {
+        ReceiptContainerHeader receiptContainerHeader = new ReceiptContainerHeader();
+        receiptContainerHeader.setToPort(toPort);
+        receiptContainerHeader.setStatus(status);
+        receiptContainerHeader.setId(id);
+        boolean success = updateById(receiptContainerHeader);
+        return success;
+    }
+
 }
@@ -470,6 +470,7 @@ public class ShipmentCombinationServiceImpl implements IShipmentCombinationServi
         if (StringUtils.isEmpty(fromLocationCode)) {
             return Result.error("生成出库任务时， 出库组盘头没有起始库位号");
         }
+        // 出库时，外侧库位的任务，如果对应的内侧有任务，那么内侧任务执行完成以后，再执行出库任务。
         Location location = locationService.getLocationByCode(fromLocationCode, warehouseCode);
         if (location == null) {
             return Result.error("生成出库任务时, 库位号" + fromLocationCode + "没有找到库位");
@@ -484,21 +485,7 @@ public class ShipmentCombinationServiceImpl implements IShipmentCombinationServi
                 }
             }
         }
-        Container container = containerService.getContainerByCode(containerCode, warehouseCode);
-        if (container == null) {
-            return Result.error("生成出库任务时, 托盘不存在" + containerCode);
-        }
-        if (container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_LOCK)) {
-            return Result.error("生成出库任务时, 托盘已经锁定" + containerCode);
-        }
-        boolean success = containerService.updateStatus(containerCode, QuantityConstant.STATUS_CONTAINER_LOCK, warehouseCode);
-        if (!success) {
-            throw new JeecgBootException("生成出库任务时, 更新容器失败" + containerCode);
-        }
-        success = locationService.updateStatus(fromLocationCode, QuantityConstant.STATUS_LOCATION_LOCK, warehouseCode);
-        if (!success) {
-            throw new JeecgBootException("生成出库任务时, 更新库位失败" + fromLocationCode);
-        }
+        // 根据出库数量，判断任务类型
         List<InventoryDetail> inventoryDetailList = inventoryDetailService.getInventoryDetailListByContainerCode(containerCode, warehouseCode);
         BigDecimal inventoryTotal = BigDecimal.ZERO;
         for (InventoryDetail inventoryDetail : inventoryDetailList) {
@@ -521,6 +508,11 @@ public class ShipmentCombinationServiceImpl implements IShipmentCombinationServi
         if (shipmentTaskRule == QuantityConstant.RULE_TASK_PICK_SHIPMENT) {
             taskType = QuantityConstant.TASK_TYPE_SORTINGSHIPMENT;
         }
+        // 锁定容器、库位
+        Result result = taskHeaderService.createTaskLockContainerAndLocation(taskType, containerCode, fromLocationCode, toLocationCode, warehouseCode);
+        if (!result.isSuccess()) {
+            return result;
+        }
         String zoneCode = location.getZoneCode();
         TaskHeader taskHeader = new TaskHeader();
         taskHeader.setPreTaskNo(preTaskNo);
@@ -539,7 +531,7 @@ public class ShipmentCombinationServiceImpl implements IShipmentCombinationServi
             taskHeader.setToLocationCode(toLocationCode);
         }
         taskHeader.setShipmentContainerHeaderId(shipmentContainerHeader.getId());
-        success = taskHeaderService.save(taskHeader);
+        boolean success = taskHeaderService.save(taskHeader);
         if (!success) {
             throw new JeecgBootException("生成出库任务时, 创建任务失败");
         }
+package org.jeecg.modules.wms.task.taskHeader.entity;
+
+import lombok.Data;
+
+@Data
+public class TaskLockEntity {
+
+    private String zoneCode;
+}
@@ -318,4 +318,35 @@ public interface ITaskHeaderService extends IService&lt;TaskHeader&gt; {
      * @return
      */
     boolean combineInventoryDetail(TaskHeader taskHeader);
+
+    /**
+     * 根据任务区分，在生产任务的时候，锁定容器和库位
+     * @param
+     */
+    Result createTaskLockContainerAndLocation(int taskType, String containerCode, String fromLocationCode, String toLocationCode, String warehouseCode);
+
+    /**
+     * 入库任务，在生产任务的时候，锁定容器和库位
+     * @param
+     */
+    Result createReceiptTaskLockContainerAndLocation(String containerCode, String toLocationCode, String warehouseCode);
+
+    /**
+     * 出库任务，在生产任务的时候，锁定容器和库位
+     * @param
+     */
+    Result createShipmentTaskLockContainerAndLocation(String containerCode, String warehouseCode);
+
+    /**
+     * 分拣任务，在生产任务的时候，锁定容器和库位
+     * @param
+     */
+    Result createSortTaskLockContainerAndLocation(String containerCode, String fromLocationCode, String toLocationCode, String warehouseCode);
+
+    /**
+     * 跨站任务，在生产任务的时候，锁定容器和库位
+     * @param
+     */
+    Result createOverStationTaskLockContainer(String containerCode, String warehouseCode);
+
 }
@@ -53,6 +53,7 @@ import org.jeecg.modules.wms.stocktaking.cycleCountDetail.service.impl.CycleCoun
 import org.jeecg.modules.wms.stocktaking.cycleCountHeader.service.impl.CycleCountHeaderServiceImpl;
 import org.jeecg.modules.wms.task.taskHeader.entity.TaskDetail;
 import org.jeecg.modules.wms.task.taskHeader.entity.TaskHeader;
+import org.jeecg.modules.wms.task.taskHeader.entity.TaskLockEntity;
 import org.jeecg.modules.wms.task.taskHeader.mapper.TaskDetailMapper;
 import org.jeecg.modules.wms.task.taskHeader.mapper.TaskHeaderMapper;
 import org.jeecg.modules.wms.task.taskHeader.service.ITaskDetailService;
@@ -183,6 +184,7 @@ public class TaskHeaderServiceImpl extends ServiceImpl&lt;TaskHeaderMapper, TaskHea
     @Transactional(rollbackFor = Exception.class)
     public Result<TaskHeader> createTransferTask(String fromLocationCode, String toLocationCode, String warehouseCode) {
         log.info("开始创建移库任务,起始库位" + fromLocationCode + ",目标库位" + toLocationCode);
+        int preTaskNo = 0;
         if (StringUtils.isEmpty(fromLocationCode)) {
             return Result.error("创建移库任务时，起始库位为空");
         }
@@ -190,18 +192,14 @@ public class TaskHeaderServiceImpl extends ServiceImpl&lt;TaskHeaderMapper, TaskHea
             return Result.error("创建移库任务时，目标库位为空");
         }
         Location fromLocation = locationService.getLocationByCode(fromLocationCode, warehouseCode);
-        Location toLocation = locationService.getLocationByCode(toLocationCode, warehouseCode);
-        Integer preTaskNo = 0;
-        // 1. 判断起点库位和终点库位是否满足移库条件
         if (fromLocation == null) {
             return Result.error("创建移库任务时，起始库位：" + fromLocationCode + "未找到");
         }
-        if (!QuantityConstant.STATUS_LOCATION_EMPTY.equals(fromLocation.getStatus())) {
-            return Result.error("创建移库任务时，起始库位：" + fromLocationCode + "状态非空闲");
-        }
-        if (StringUtils.isEmpty(fromLocation.getContainerCode())) {
-            return Result.error("创建移库任务时，起始库位：" + fromLocationCode + "不存在托盘");
+        Location toLocation = locationService.getLocationByCode(toLocationCode, warehouseCode);
+        if (fromLocation == null) {
+            return Result.error("创建移库任务时，起始库位：" + fromLocationCode + "未找到");
         }
+        String containerCode = fromLocation.getContainerCode();
         // 这里增加组盘校验，如果此托盘存在未完成的组盘数据，则不能移库
         // 校验入库组盘
         if (receiptContainerHeaderService.havaUnCompleteCombineByLocationCode(fromLocationCode, warehouseCode)) {
@@ -212,15 +210,6 @@ public class TaskHeaderServiceImpl extends ServiceImpl&lt;TaskHeaderMapper, TaskHea
             return Result.error("创建移库任务时，起始库位：" + fromLocationCode + "存在出库组盘，不能移库");
         }
-        if (toLocation == null) {
-            return Result.error("创建移库任务时，目标库位：" + toLocationCode + "未找到");
-        }
-        if (!QuantityConstant.STATUS_LOCATION_EMPTY.equals(toLocation.getStatus())) {
-            return Result.error("创建移库任务时，目标库位：" + toLocationCode + "状态非空闲");
-        }
-        if (StringUtils.isNotEmpty(toLocation.getContainerCode())) {
-            return Result.error("创建移库任务时，目标库位：" + toLocationCode + "存在托盘");
-        }
         // 校验入库组盘
         if (receiptContainerHeaderService.havaUnCompleteCombineByLocationCode(toLocationCode, warehouseCode)) {
             return Result.error("创建移库任务时，目标库位：" + toLocationCode + "存在入库组盘，不能移库");
@@ -232,7 +221,6 @@ public class TaskHeaderServiceImpl extends ServiceImpl&lt;TaskHeaderMapper, TaskHea
         if (taskHeaderService.haveUncompleteTaskInNear(toLocation)) {
             return Result.error("创建移库任务时，目标库位：" + toLocationCode + "旁边存在任务，请完成任务以后再分配");
         }
-
         if (!fromLocation.getRoadWay().equals(toLocation.getRoadWay())) {
             return Result.error("创建移库任务时，目标库位和源库位不在同一个巷道");
         }
@@ -266,6 +254,11 @@ public class TaskHeaderServiceImpl extends ServiceImpl&lt;TaskHeaderMapper, TaskHea
             }
         }
+        Result result = taskHeaderService.createTaskLockContainerAndLocation(QuantityConstant.TASK_TYPE_TRANSFER, containerCode, fromLocationCode, toLocationCode,
+            warehouseCode);
+        if (!result.isSuccess()) {
+            return result;
+        }
         // 4. 判断源库位旁边有托盘但是没有任务,那么不允许移库
         TaskHeader taskHeader = new TaskHeader();
         taskHeader.setWarehouseCode(warehouseCode);
@@ -281,21 +274,9 @@ public class TaskHeaderServiceImpl extends ServiceImpl&lt;TaskHeaderMapper, TaskHea
         if (!success) {
             throw new JeecgBootException("创建移库任务时，创建任务失败");
         }
-
-        success = locationService.updateStatus(fromLocationCode, QuantityConstant.STATUS_LOCATION_LOCK, warehouseCode);
-        if (!success) {
-            throw new JeecgBootException("创建移库任务时， 起始库位" + fromLocationCode + "更新失败");
-        }
-        success = locationService.updateStatus(toLocationCode, QuantityConstant.STATUS_LOCATION_LOCK, warehouseCode);
-        if (!success) {
-            throw new JeecgBootException("创建移库任务时， 终点库位" + toLocationCode + "更新失败");
-        }
-        success = containerService.updateStatus(fromLocation.getContainerCode(), QuantityConstant.STATUS_CONTAINER_LOCK, warehouseCode);
         log.info("完成创建移库任务,起始库位" + fromLocationCode + ",目的库位" + toLocationCode);
-        if (!success) {
-            throw new JeecgBootException("创建移库任务时，容器" + fromLocation.getContainerCode() + "更新失败");
-        }
         return Result.OK("创建移库任务成功", taskHeader);
+
     }
     @Override
@@ -315,10 +296,13 @@ public class TaskHeaderServiceImpl extends ServiceImpl&lt;TaskHeaderMapper, TaskHea
         if (container == null) {
             return Result.error("创建出库查看任务时，容器为空");
         }
-        if (container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_LOCK)) {
-            return Result.error("创建出库查看任务时，容器是锁定状态");
-        }
         String fromLocationCode = container.getLocationCode();
+        String toLocationCode = QuantityConstant.EMPTY_STRING;
+        String value = parameterConfigurationService.getValueByCode(QuantityConstant.RULE_TASK_LOCATION);
+        int taskLocationRule = Integer.parseInt(value);
+        if (taskLocationRule == QuantityConstant.RULE_TASK_SET_LOCATION) {
+            toLocationCode = fromLocationCode;
+        }
         if (StringUtils.isEmpty(fromLocationCode)) {
             return Result.error("创建出库查看任务时，容器不在库位上");
         }
@@ -331,6 +315,11 @@ public class TaskHeaderServiceImpl extends ServiceImpl&lt;TaskHeaderMapper, TaskHea
         if (port == null) {
             return Result.error("创建出库查看任务时，没有找到出库口:" + toPortCode);
         }
+        Result result = taskHeaderService.createTaskLockContainerAndLocation(QuantityConstant.TASK_TYPE_CHECK_OUT, containerCode, fromLocationCode, toLocationCode,
+            warehouseCode);
+        if (!result.isSuccess()) {
+            return result;
+        }
         boolean success = false;
         LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
         inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getContainerCode, containerCode).eq(InventoryDetail::getWarehouseCode, warehouseCode)
@@ -350,14 +339,6 @@ public class TaskHeaderServiceImpl extends ServiceImpl&lt;TaskHeaderMapper, TaskHea
                 throw new JeecgBootException("创建出库查看任务时，更新库存详情失败");
             }
         }
-        success = locationService.updateStatus(fromLocationCode, QuantityConstant.STATUS_LOCATION_LOCK, warehouseCode);
-        if (!success) {
-            throw new JeecgBootException("创建出库查看任务时，更新库位状态失败");
-        }
-        success = containerService.updateStatus(containerCode, QuantityConstant.STATUS_CONTAINER_LOCK, warehouseCode);
-        if (!success) {
-            throw new JeecgBootException("创建出库查看任务时，更新容器状态失败");
-        }
         TaskHeader taskHeader = new TaskHeader();
         taskHeader.setWarehouseCode(warehouseCode);
         taskHeader.setTaskType(QuantityConstant.TASK_TYPE_CHECK_OUT);
@@ -366,11 +347,7 @@ public class TaskHeaderServiceImpl extends ServiceImpl&lt;TaskHeaderMapper, TaskHea
         taskHeader.setZoneCode(zoneCode);
         taskHeader.setFromLocationCode(fromLocationCode);
         taskHeader.setToPortCode(toPortCode);
-        String value = parameterConfigurationService.getValueByCode(QuantityConstant.RULE_TASK_LOCATION);
-        int taskLocationRule = Integer.parseInt(value);
-        if (taskLocationRule == QuantityConstant.RULE_TASK_SET_LOCATION) {
-            taskHeader.setToLocationCode(fromLocationCode);
-        }
+        taskHeader.setToLocationCode(toLocationCode);
         taskHeader.setStatus(QuantityConstant.TASK_STATUS_BUILD);
         success = taskHeaderService.save(taskHeader);
         log.info("完成创建出库查看任务,容器编码" + containerCode + "目标站台号" + toPortCode);
@@ -396,16 +373,6 @@ public class TaskHeaderServiceImpl extends ServiceImpl&lt;TaskHeaderMapper, TaskHea
         if (StringUtils.isEmpty(warehouseCode)) {
             return Result.error("创建跨站任务时，仓库编码为空");
         }
-        Container container = containerService.getContainerByCode(containerCode, warehouseCode);
-        if (container == null) {
-            return Result.error("创建跨站任务时，容器为空");
-        }
-        if (!container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_EMPTY)) {
-            return Result.error("创建跨站任务时, 容器状态不为空闲状态");
-        }
-        if (!container.getFillStatus().equals(QuantityConstant.STATUS_CONTAINER_FILL_EMPTY)) {
-            return Result.error("创建跨站任务时，容器状态不为空托盘");
-        }
         Port fromPort = portService.getPortByCode(fromPortCode, warehouseCode);
         if (fromPort == null) {
             return Result.error("创建跨站任务时，起始站台为空");
@@ -414,7 +381,11 @@ public class TaskHeaderServiceImpl extends ServiceImpl&lt;TaskHeaderMapper, TaskHea
         if (toPort == null) {
             return Result.error("创建跨站任务时，目标站台为空");
         }
-
+        Result result = taskHeaderService.createTaskLockContainerAndLocation(QuantityConstant.TASK_TYPE_OVER_STATION, containerCode, QuantityConstant.EMPTY_STRING,
+            QuantityConstant.EMPTY_STRING, warehouseCode);
+        if (!result.isSuccess()) {
+            return result;
+        }
         TaskHeader taskHeader = new TaskHeader();
         taskHeader.setWarehouseCode(warehouseCode);
         taskHeader.setContainerCode(containerCode);
@@ -427,11 +398,7 @@ public class TaskHeaderServiceImpl extends ServiceImpl&lt;TaskHeaderMapper, TaskHea
         if (!success) {
             return Result.error("创建跨站任务时, 创建任务失败");
         }
-        success = containerService.updateStatus(containerCode, QuantityConstant.STATUS_CONTAINER_LOCK, warehouseCode);
         log.info("完成创建跨站任务，容器号" + containerCode + ",起始站台号" + fromPortCode + ",目标站台号" + toPortCode);
-        if (!success) {
-            return Result.error("创建跨站任务时, 更新容器状态失败");
-        }
         return Result.ok("创建跨站任务成功");
     }
@@ -511,35 +478,13 @@ public class TaskHeaderServiceImpl extends ServiceImpl&lt;TaskHeaderMapper, TaskHea
         }
         log.info("开始创建空托盘组入库任务，容器编码" + containerCode + ",库位编码" + toLocationCode);
         String zoneCode = null;
-        Container container = containerService.getContainerByCode(containerCode, warehouseCode);
-        if (container == null) {
-            return Result.error("创建空托盘组入库任务时，没有找到容器");
-        }
-        if (StringUtils.isNotEmpty(container.getLocationCode())) {
-            return Result.error("创建空托盘组入库任务时, 容器已在库位" + container.getLocationCode() + "上");
-        }
-        if (!container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_EMPTY)) {
-            return Result.error("创建空托盘组入库任务时，容器状态不为空闲状态");
-        }
-        if (!container.getFillStatus().equals(QuantityConstant.STATUS_CONTAINER_FILL_EMPTY)) {
-            return Result.error("创建空托盘组入库任务时，容器状态不为空托盘");
-        }
-        boolean success = containerService.updateStatus(containerCode, QuantityConstant.STATUS_CONTAINER_LOCK, warehouseCode);
-        if (!success) {
-            throw new JeecgBootException("创建空托盘组入库任务时, 更新容器状态失败");
+        Result result = taskHeaderService.createTaskLockContainerAndLocation(QuantityConstant.TASK_TYPE_MANY_EMPTYRECEIPT, containerCode,
+            QuantityConstant.EMPTY_STRING, toLocationCode, warehouseCode);
+        if (!result.isSuccess()) {
+            return result;
         }
         if (StringUtils.isNotEmpty(toLocationCode)) {
             Location toLocation = locationService.getLocationByCode(toLocationCode, warehouseCode);
-            if (toLocation == null) {
-                return Result.error("创建空托盘组入库任务时，没有找到目标库位");
-            }
-            if (!toLocation.getStatus().equals(QuantityConstant.STATUS_LOCATION_EMPTY)) {
-                return Result.error("创建空托盘组入库任务时，目标库位状态不是空闲");
-            }
-            success = locationService.updateStatus(toLocationCode, QuantityConstant.STATUS_LOCATION_LOCK, warehouseCode);
-            if (!success) {
-                throw new JeecgBootException("创建空托盘组入库任务时, 更新库位状态失败");
-            }
             zoneCode = toLocation.getZoneCode();
         }
         TaskHeader taskHeader = new TaskHeader();
@@ -550,7 +495,7 @@ public class TaskHeaderServiceImpl extends ServiceImpl&lt;TaskHeaderMapper, TaskHea
         taskHeader.setToLocationCode(toLocationCode);
         taskHeader.setZoneCode(zoneCode);
         taskHeader.setStatus(QuantityConstant.TASK_STATUS_BUILD);
-        success = taskHeaderService.save(taskHeader);
+        boolean success = taskHeaderService.save(taskHeader);
         log.info("完成创建空托盘组入库任务，容器编码" + containerCode + ",库位编码" + toLocationCode);
         if (!success) {
             throw new JeecgBootException("创建空托盘组入库任务时, 创建任务失败");
@@ -571,20 +516,13 @@ public class TaskHeaderServiceImpl extends ServiceImpl&lt;TaskHeaderMapper, TaskHea
         if (StringUtils.isEmpty(warehouseCode)) {
             return Result.error("创建空托盘组出库任务时，仓库编码为空");
         }
-        Container container = containerService.getContainerByCode(containerCode, warehouseCode);
-        if (container == null) {
-            return Result.error("创建空托盘组出库任务时, 没有找到容器：" + containerCode);
-        }
-        if (!QuantityConstant.STATUS_CONTAINER_EMPTY.equals(container.getStatus())) {
-            return Result.error("创建空托盘组出库任务时, 容器状态不为空闲状态");
-        }
-        if (!QuantityConstant.STATUS_CONTAINER_FILL_MANY.equals(container.getFillStatus())) {
-            return Result.error("创建空托盘组出库任务时, 容器填充状态不为空托盘组状态");
+        Result result = taskHeaderService.createTaskLockContainerAndLocation(QuantityConstant.TASK_TYPE_MANY_EMPTYSHIPMENT, containerCode,
+            QuantityConstant.EMPTY_STRING, QuantityConstant.EMPTY_STRING, warehouseCode);
+        if (!result.isSuccess()) {
+            return result;
         }
+        Container container = containerService.getContainerByCode(containerCode, warehouseCode);
         String fromLocationCode = container.getLocationCode();
-        if (StringUtils.isEmpty(fromLocationCode)) {
-            return Result.error("创建空托盘组出库任务时, 该容器不在库位上");
-        }
         Location fromLocation = locationService.getLocationByCode(fromLocationCode, warehouseCode);
         if (fromLocation == null) {
             return Result.error("创建空托盘组出库任务时, 没有找到库位：" + fromLocationCode);
@@ -593,14 +531,6 @@ public class TaskHeaderServiceImpl extends ServiceImpl&lt;TaskHeaderMapper, TaskHea
         if (StringUtils.isEmpty(zoneCode)) {
             return Result.error("创建空托盘组出库任务时, 库区为空");
         }
-        boolean success = containerService.updateStatus(containerCode, QuantityConstant.STATUS_CONTAINER_LOCK, warehouseCode);
-        if (!success) {
-            throw new JeecgBootException("创建空托盘组出库任务时， 更新容器状态失败");
-        }
-        success = locationService.updateStatus(fromLocationCode, QuantityConstant.STATUS_LOCATION_LOCK, warehouseCode);
-        if (!success) {
-            throw new JeecgBootException("创建空托盘组出库任务时， 更新库位状态失败");
-        }
         TaskHeader taskHeader = new TaskHeader();
         taskHeader.setWarehouseCode(warehouseCode);
         taskHeader.setZoneCode(zoneCode);
@@ -610,7 +540,7 @@ public class TaskHeaderServiceImpl extends ServiceImpl&lt;TaskHeaderMapper, TaskHea
         taskHeader.setFromLocationCode(fromLocationCode);
         taskHeader.setToPortCode(toPortCode);
         taskHeader.setStatus(QuantityConstant.TASK_STATUS_BUILD);
-        success = taskHeaderService.save(taskHeader);
+        boolean success = taskHeaderService.save(taskHeader);
         log.info("完成创建空托盘组出库任务，容器编码" + containerCode + ",去向位置编码" + toPortCode);
         if (!success) {
             throw new JeecgBootException("创建空托盘组出库任务时,生成任务失败");
@@ -982,36 +912,11 @@ public class TaskHeaderServiceImpl extends ServiceImpl&lt;TaskHeaderMapper, TaskHea
         if (StringUtils.isEmpty(warehouseCode)) {
             return Result.error("创建空托盘入库时, 仓库编码为空");
         }
-        Container container = containerService.getContainerByCode(containerCode, warehouseCode);
-        if (container == null) {
-            return Result.error("创建空托盘入库时, 没有找到托盘" + containerCode);
-        }
-        if (!container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_EMPTY)) {
-            return Result.error("创建空托盘入库时, 托盘状态并非空托盘状态");
-        }
-        if (StringUtils.isNotEmpty(container.getLocationCode())) {
-            return Result.error("创建空托盘入库时， 容器已在库位" + container.getLocationCode() + "上");
-        }
-        if (StringUtils.isNotEmpty(toLocationCode)) {
-            Location toLocation = locationService.getLocationByCode(toLocationCode, warehouseCode);
-            if (toLocation == null) {
-                return Result.error("创建空托盘入库时，" + toLocationCode + "目标库位不存在");
-            }
-            if (StringUtils.isNotEmpty(toLocation.getContainerCode())) {
-                return Result.error("创建空托盘入库时，" + toLocationCode + "上已存在容器" + toLocation.getContainerCode());
-            }
-            if (!QuantityConstant.STATUS_LOCATION_EMPTY.equals(toLocation.getStatus())) {
-                return Result.error("创建空托盘入库时， 目标库位非空闲");
-            }
-            boolean success = locationService.updateStatus(toLocationCode, QuantityConstant.STATUS_LOCATION_LOCK, warehouseCode);
-            if (!success) {
-                throw new JeecgBootException("创建空托盘入库时，更新库位状态失败");
-            }
-        }
-        boolean success = containerService.updateStatus(containerCode, QuantityConstant.STATUS_CONTAINER_LOCK, warehouseCode);
-        if (!success) {
-            throw new JeecgBootException("创建空托盘入库时，更新容器状态失败");
+        Result result = taskHeaderService.createTaskLockContainerAndLocation(QuantityConstant.TASK_TYPE_EMPTYRECEIPT, containerCode, QuantityConstant.EMPTY_STRING,
+            toLocationCode, warehouseCode);
+        if (!result.isSuccess()) {
+            return result;
         }
         TaskHeader taskHeader = new TaskHeader();
         taskHeader.setWarehouseCode(warehouseCode);
@@ -1020,7 +925,7 @@ public class TaskHeaderServiceImpl extends ServiceImpl&lt;TaskHeaderMapper, TaskHea
         taskHeader.setInnernalTaskType(QuantityConstant.TASK_INTENERTYPE_RECEIPT);
         taskHeader.setToLocationCode(toLocationCode);
         taskHeader.setStatus(QuantityConstant.TASK_STATUS_BUILD);
-        success = taskHeaderService.save(taskHeader);
+        boolean success = taskHeaderService.save(taskHeader);
         log.info("完成创建空托入库任务");
         if (!success) {
             throw new JeecgBootException("创建空托盘入库时，保存任务失败");
@@ -1049,15 +954,11 @@ public class TaskHeaderServiceImpl extends ServiceImpl&lt;TaskHeaderMapper, TaskHea
             return Result.error("创建空托盘出库时, 仓库编码为空");
         }
         Container container = containerService.getContainerByCode(containerCode, warehouseCode);
-        if (container == null) {
-            return Result.error("创建空托盘出库时, 没有找到托盘" + containerCode);
-        }
-        if (!container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_EMPTY)) {
-            return Result.error("创建空托盘出库时, 托盘状态并非空托盘状态");
-        }
         String fromLocationCode = container.getLocationCode();
-        if (StringUtils.isEmpty(fromLocationCode)) {
-            return Result.error("创建空托盘出库时， 容器不在库位上");
+        Result result = taskHeaderService.createTaskLockContainerAndLocation(QuantityConstant.TASK_TYPE_EMPTYSHIPMENT, containerCode, QuantityConstant.EMPTY_STRING,
+            QuantityConstant.EMPTY_STRING, warehouseCode);
+        if (!result.isSuccess()) {
+            return result;
         }
         Location fromLocation = locationService.getLocationByCode(fromLocationCode, warehouseCode);
         if (fromLocation == null) {
@@ -1071,14 +972,6 @@ public class TaskHeaderServiceImpl extends ServiceImpl&lt;TaskHeaderMapper, TaskHea
         if (port == null) {
             return Result.error("创建空托盘出库时， 没有找到出库口" + toPortCode);
         }
-        boolean success = locationService.updateStatus(fromLocationCode, QuantityConstant.STATUS_LOCATION_LOCK, warehouseCode);
-        if (!success) {
-            throw new JeecgBootException("创建空托盘出库时，更新库位状态失败");
-        }
-        success = containerService.updateStatus(containerCode, QuantityConstant.STATUS_CONTAINER_LOCK, warehouseCode);
-        if (!success) {
-            throw new JeecgBootException("创建空托盘出库时，更新容器状态失败");
-        }
         TaskHeader taskHeader = new TaskHeader();
         taskHeader.setWarehouseCode(warehouseCode);
         taskHeader.setZoneCode(zoneCode);
@@ -1088,7 +981,7 @@ public class TaskHeaderServiceImpl extends ServiceImpl&lt;TaskHeaderMapper, TaskHea
         taskHeader.setFromLocationCode(fromLocationCode);
         taskHeader.setStatus(QuantityConstant.TASK_STATUS_BUILD);
         taskHeader.setToPortCode(toPortCode);
-        success = taskHeaderService.save(taskHeader);
+        boolean success = taskHeaderService.save(taskHeader);
         log.info("完成创建空托出库任务" + containerCode);
         if (!success) {
             throw new JeecgBootException("创建空托盘出库时，保存任务失败");
@@ -1238,7 +1131,6 @@ public class TaskHeaderServiceImpl extends ServiceImpl&lt;TaskHeaderMapper, TaskHea
         if (!success) {
             throw new JeecgBootException("完成入库任务时，更新入库组盘头表状态失败");
         }
-
         success = inventoryDetailService.saveBatch(inventoryDetailList);
         if (!success) {
             throw new JeecgBootException("完成入库任务时，保存库存详情失败");
@@ -1578,6 +1470,204 @@ public class TaskHeaderServiceImpl extends ServiceImpl&lt;TaskHeaderMapper, TaskHea
     }
     /**
+     * 锁定容器和库位分4种情况，入库任务、出库任务、分拣任务、换站任务
+     * @param
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public Result createTaskLockContainerAndLocation(int taskType, String containerCode, String fromLocationCode, String toLocationCode, String warehouseCode) {
+        Result result = null;
+        switch (taskType) {
+            case QuantityConstant.TASK_TYPE_WHOLERECEIPT:
+            case QuantityConstant.TASK_TYPE_EMPTYRECEIPT:
+            case QuantityConstant.TASK_TYPE_MANY_EMPTYRECEIPT:
+                result = taskHeaderService.createReceiptTaskLockContainerAndLocation(containerCode, toLocationCode, warehouseCode);
+                break;
+            case QuantityConstant.TASK_TYPE_WHOLESHIPMENT:
+            case QuantityConstant.TASK_TYPE_EMPTYSHIPMENT:
+            case QuantityConstant.TASK_TYPE_MANY_EMPTYSHIPMENT:
+                result = taskHeaderService.createShipmentTaskLockContainerAndLocation(containerCode, warehouseCode);
+                break;
+            case QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT:
+            case QuantityConstant.TASK_TYPE_SORTINGSHIPMENT:
+            case QuantityConstant.TASK_TYPE_CYCLECOUNT:
+            case QuantityConstant.TASK_TYPE_TRANSFER:
+            case QuantityConstant.TASK_TYPE_CHECK_OUT:
+                result = taskHeaderService.createSortTaskLockContainerAndLocation(containerCode, fromLocationCode, toLocationCode, warehouseCode);
+                break;
+            case QuantityConstant.TASK_TYPE_OVER_STATION:
+                result = taskHeaderService.createOverStationTaskLockContainer(containerCode, warehouseCode);
+                break;
+        }
+        return result;
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public Result createReceiptTaskLockContainerAndLocation(String containerCode, String toLocationCode, String warehouseCode) {
+        boolean success = false;
+        TaskLockEntity taskLockEntity = new TaskLockEntity();
+        String zoneCode = null;
+        Container container = containerService.getContainerByCode(containerCode, warehouseCode);
+        if (container == null) {
+            return Result.error("创建入库任务时, 没有找到托盘" + containerCode);
+        }
+        if (!container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_EMPTY)) {
+            return Result.error("创建入库任务时, 托盘状态并非空闲状态");
+        }
+        if (StringUtils.isNotEmpty(container.getLocationCode())) {
+            return Result.error("创建入库任务时， 容器已在库位" + container.getLocationCode() + "上");
+        }
+        if (StringUtils.isNotEmpty(toLocationCode)) {
+            String value = parameterConfigurationService.getValueByCode(QuantityConstant.RULE_ALLOCATION);
+            if (StringUtils.isEmpty(value)) {
+                return Result.error("创建入库任务时, 未绑定定位规则");
+            }
+            int allocationRule = Integer.parseInt(value);
+            if (allocationRule == QuantityConstant.DOUBLE_FORK) {
+                return Result.error("创建入库任务时, 双伸位库位不能手动指定库位");
+            }
+            Location toLocation = locationService.getLocationByCode(toLocationCode, warehouseCode);
+            if (toLocation == null) {
+                return Result.error("创建入库任务时，" + toLocationCode + "目标库位不存在");
+            }
+            if (StringUtils.isNotEmpty(toLocation.getContainerCode())) {
+                return Result.error("创建入库任务时，" + toLocationCode + "上已存在容器" + toLocation.getContainerCode());
+            }
+            if (!QuantityConstant.STATUS_LOCATION_EMPTY.equals(toLocation.getStatus())) {
+                return Result.error("创建入库任务时， 目标库位非空闲");
+            }
+            zoneCode = toLocation.getZoneCode();
+        }
+        taskLockEntity.setZoneCode(zoneCode);
+        success = containerService.updateStatus(containerCode, QuantityConstant.STATUS_CONTAINER_LOCK, warehouseCode);
+        if (!success) {
+            throw new JeecgBootException("创建入库任务时，更新容器状态失败");
+        }
+        if (StringUtils.isNotEmpty(toLocationCode)) {
+            success = locationService.updateStatus(toLocationCode, QuantityConstant.STATUS_LOCATION_LOCK, warehouseCode);
+            if (!success) {
+                throw new JeecgBootException("创建入库任务时，更新库位状态失败");
+            }
+        }
+        return Result.OK("创建入库任务成功", taskLockEntity);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public Result createShipmentTaskLockContainerAndLocation(String containerCode, String warehouseCode) {
+        boolean success = false;
+        TaskLockEntity taskLockEntity = new TaskLockEntity();
+        String zoneCode = null;
+        Container container = containerService.getContainerByCode(containerCode, warehouseCode);
+        if (container == null) {
+            return Result.error("创建出库任务时, 没有找到托盘" + containerCode);
+        }
+        if (!container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_EMPTY)) {
+            return Result.error("创建出库任务时, 托盘状态并非空闲状态");
+        }
+        if (StringUtils.isEmpty(container.getLocationCode())) {
+            return Result.error("创建出库任务时， 容器不在库位" + container.getLocationCode() + "上");
+        }
+        String fromLocationCode = container.getLocationCode();
+        Location fromLocation = locationService.getLocationByCode(fromLocationCode, warehouseCode);
+        if (fromLocation == null) {
+            return Result.error("创建出库任务时， 起始库位为空");
+        }
+        if (StringUtils.isEmpty(fromLocation.getContainerCode())) {
+            return Result.error("创建出库任务时，" + fromLocationCode + "上已存在容器" + fromLocation.getContainerCode());
+        }
+        if (!QuantityConstant.STATUS_LOCATION_EMPTY.equals(fromLocation.getStatus())) {
+            return Result.error("创建出库任务时， 起始库位非空闲");
+        }
+        zoneCode = fromLocation.getZoneCode();
+        taskLockEntity.setZoneCode(zoneCode);
+        success = containerService.updateStatus(containerCode, QuantityConstant.STATUS_CONTAINER_LOCK, warehouseCode);
+        if (!success) {
+            throw new JeecgBootException("创建出库任务时，更新容器状态失败");
+        }
+        success = locationService.updateStatus(fromLocationCode, QuantityConstant.STATUS_LOCATION_LOCK, warehouseCode);
+        if (!success) {
+            throw new JeecgBootException("创建出库任务时，更新库位状态失败");
+        }
+        return Result.OK("创建出库任务成功", taskLockEntity);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public Result createSortTaskLockContainerAndLocation(String containerCode, String fromLocationCode, String toLocationCode, String warehouseCode) {
+        boolean success = false;
+        TaskLockEntity taskLockEntity = new TaskLockEntity();
+        String zoneCode = null;
+        Container container = containerService.getContainerByCode(containerCode, warehouseCode);
+        if (container == null) {
+            return Result.error("创建分拣任务时, 没有找到托盘" + containerCode);
+        }
+        if (!container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_EMPTY)) {
+            return Result.error("创建分拣任务时, 托盘状态并非空闲状态");
+        }
+        if (StringUtils.isEmpty(container.getLocationCode())) {
+            return Result.error("创建分拣任务时， 容器不在库位" + container.getLocationCode() + "上");
+        }
+        Location fromLocation = locationService.getLocationByCode(fromLocationCode, warehouseCode);
+        if (fromLocation == null) {
+            return Result.error("创建分拣任务时， 起始库位为空");
+        }
+        if (StringUtils.isEmpty(fromLocation.getContainerCode())) {
+            return Result.error("创建分拣任务时，" + fromLocationCode + "上已存在容器" + fromLocation.getContainerCode());
+        }
+        if (!QuantityConstant.STATUS_LOCATION_EMPTY.equals(fromLocation.getStatus())) {
+            return Result.error("创建分拣任务时， 起始库位非空闲");
+        }
+        zoneCode = fromLocation.getZoneCode();
+        taskLockEntity.setZoneCode(zoneCode);
+        if (StringUtils.isNotEmpty(toLocationCode)) {
+            Location toLocation = locationService.getLocationByCode(toLocationCode, warehouseCode);
+            if (toLocation == null) {
+                return Result.error("创建分拣任务时，" + toLocationCode + "目标库位不存在");
+            }
+            if (StringUtils.isNotEmpty(toLocation.getContainerCode())) {
+                return Result.error("创建分拣任务时，" + toLocationCode + "上已存在容器" + toLocation.getContainerCode());
+            }
+            if (!QuantityConstant.STATUS_LOCATION_EMPTY.equals(toLocation.getStatus())) {
+                return Result.error("创建分拣任务时， 目标库位非空闲");
+            }
+        }
+        success = containerService.updateStatus(containerCode, QuantityConstant.STATUS_CONTAINER_LOCK, warehouseCode);
+        if (!success) {
+            throw new JeecgBootException("创建分拣任务时，更新容器状态失败");
+        }
+        success = locationService.updateStatus(fromLocationCode, QuantityConstant.STATUS_LOCATION_LOCK, warehouseCode);
+        if (!success) {
+            throw new JeecgBootException("创建分拣任务时，更新库位状态失败");
+        }
+        if (StringUtils.isNotEmpty(toLocationCode)) {
+            success = locationService.updateStatus(toLocationCode, QuantityConstant.STATUS_LOCATION_LOCK, warehouseCode);
+            if (!success) {
+                throw new JeecgBootException("创建分拣任务时，更新库位状态失败");
+            }
+        }
+        return Result.OK("创建分拣任务成功", taskLockEntity);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public Result createOverStationTaskLockContainer(String containerCode, String warehouseCode) {
+        Container container = containerService.getContainerByCode(containerCode, warehouseCode);
+        if (container == null) {
+            return Result.error("创建跨站任务时，容器为空");
+        }
+        if (!container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_EMPTY)) {
+            return Result.error("创建跨站任务时, 容器状态不为空闲状态");
+        }
+        boolean success = containerService.updateStatus(containerCode, QuantityConstant.STATUS_CONTAINER_LOCK, warehouseCode);
+        if (!success) {
+            throw new JeecgBootException("创建跨站任务时，更新容器状态失败");
+        }
+        return Result.ok("创建跨站任务成功");
+    }
+
+    /**
      * 完成空托盘入库任务
      * @param  taskHeader 任务
      * @return            Result 完成入库任务结果
@@ -185,8 +185,6 @@ public class QuantityConstant {
     /** 空托盘组出库 */
     public static final int TASK_TYPE_MANY_EMPTYSHIPMENT = 1200;
-    /** 空托盘组换站 */
-    public static final int TASK_TYPE_MANY_OVER_STATION = 1300;
     // 7、任务状态