From bf74d4a12912b309b4efe199d174a3e6b45304f7 Mon Sep 17 00:00:00 2001
From: youjie <272855983@qq.com>
Date: Thu, 15 Jun 2023 15:14:36 +0800
Subject: [PATCH] 把生成任务的锁定容器和库位，集中到一起
---
huaheng-wms-core/src/main/java/org/jeecg/modules/wms/api/wcs/controller/WcsController.java | 19 ++++++++-----------
huaheng-wms-core/src/main/java/org/jeecg/modules/wms/api/wcs/entity/WcsTask.java | 8 ++++++++
huaheng-wms-core/src/main/java/org/jeecg/modules/wms/api/wcs/service/WcsServiceImpl.java | 3 ---
huaheng-wms-core/src/main/java/org/jeecg/modules/wms/receipt/receiptContainerHeader/service/IReceiptContainerHeaderService.java | 7 ++++++-
huaheng-wms-core/src/main/java/org/jeecg/modules/wms/receipt/receiptContainerHeader/service/impl/ReceiptContainerHeaderServiceImpl.java | 90 ++++++++++++++++++++++++++++++++++++++----------------------------------------------------
huaheng-wms-core/src/main/java/org/jeecg/modules/wms/shipment/shipmentCombination/service/impl/ShipmentCombinationServiceImpl.java | 24 ++++++++----------------
huaheng-wms-core/src/main/java/org/jeecg/modules/wms/task/taskHeader/entity/TaskLockEntity.java | 9 +++++++++
huaheng-wms-core/src/main/java/org/jeecg/modules/wms/task/taskHeader/service/ITaskHeaderService.java | 31 +++++++++++++++++++++++++++++++
huaheng-wms-core/src/main/java/org/jeecg/modules/wms/task/taskHeader/service/impl/TaskHeaderServiceImpl.java | 406 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--------------------------------------------------------------------------------------------------------------------------------------------------------------
huaheng-wms-core/src/main/java/org/jeecg/utils/constant/QuantityConstant.java | 2 --
10 files changed, 356 insertions(+), 243 deletions(-)
create mode 100644 huaheng-wms-core/src/main/java/org/jeecg/modules/wms/task/taskHeader/entity/TaskLockEntity.java
diff --git a/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/api/wcs/controller/WcsController.java b/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/api/wcs/controller/WcsController.java
index 1457086..096921c 100644
--- a/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/api/wcs/controller/WcsController.java
+++ b/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/api/wcs/controller/WcsController.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();
diff --git a/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/api/wcs/entity/WcsTask.java b/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/api/wcs/entity/WcsTask.java
index 1e43e57..a6ac212 100644
--- a/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/api/wcs/entity/WcsTask.java
+++ b/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/api/wcs/entity/WcsTask.java
@@ -1,5 +1,7 @@
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;
+
}
diff --git a/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/api/wcs/service/WcsServiceImpl.java b/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/api/wcs/service/WcsServiceImpl.java
index 1c2a7b2..96a55c2 100644
--- a/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/api/wcs/service/WcsServiceImpl.java
+++ b/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/api/wcs/service/WcsServiceImpl.java
@@ -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:
diff --git a/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/receipt/receiptContainerHeader/service/IReceiptContainerHeaderService.java b/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/receipt/receiptContainerHeader/service/IReceiptContainerHeaderService.java
index b700566..139267c 100644
--- a/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/receipt/receiptContainerHeader/service/IReceiptContainerHeaderService.java
+++ b/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/receipt/receiptContainerHeader/service/IReceiptContainerHeaderService.java
@@ -30,7 +30,7 @@ public interface IReceiptContainerHeaderService extends IService<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<ReceiptContaine
* 更新去向toPort
*/
boolean updateToPortById(String toPort, int id);
+
+ /**
+ * 更新去向toPort和状态status
+ */
+ boolean updateToPortAndStatus(String toPort, int status, int id);
}
diff --git a/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/receipt/receiptContainerHeader/service/impl/ReceiptContainerHeaderServiceImpl.java b/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/receipt/receiptContainerHeader/service/impl/ReceiptContainerHeaderServiceImpl.java
index ae4e579..a33eaf6 100644
--- a/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/receipt/receiptContainerHeader/service/impl/ReceiptContainerHeaderServiceImpl.java
+++ b/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/receipt/receiptContainerHeader/service/impl/ReceiptContainerHeaderServiceImpl.java
@@ -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<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<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<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<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<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;
+ }
+
}
diff --git a/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/shipment/shipmentCombination/service/impl/ShipmentCombinationServiceImpl.java b/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/shipment/shipmentCombination/service/impl/ShipmentCombinationServiceImpl.java
index bb7d478..54ce4b0 100644
--- a/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/shipment/shipmentCombination/service/impl/ShipmentCombinationServiceImpl.java
+++ b/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/shipment/shipmentCombination/service/impl/ShipmentCombinationServiceImpl.java
@@ -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("生成出库任务时, 创建任务失败");
}
diff --git a/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/task/taskHeader/entity/TaskLockEntity.java b/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/task/taskHeader/entity/TaskLockEntity.java
new file mode 100644
index 0000000..c1e2f1e
--- /dev/null
+++ b/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/task/taskHeader/entity/TaskLockEntity.java
@@ -0,0 +1,9 @@
+package org.jeecg.modules.wms.task.taskHeader.entity;
+
+import lombok.Data;
+
+@Data
+public class TaskLockEntity {
+
+ private String zoneCode;
+}
diff --git a/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/task/taskHeader/service/ITaskHeaderService.java b/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/task/taskHeader/service/ITaskHeaderService.java
index 8cf5abf..a88114b 100644
--- a/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/task/taskHeader/service/ITaskHeaderService.java
+++ b/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/task/taskHeader/service/ITaskHeaderService.java
@@ -318,4 +318,35 @@ public interface ITaskHeaderService extends IService<TaskHeader> {
* @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);
+
}
diff --git a/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/task/taskHeader/service/impl/TaskHeaderServiceImpl.java b/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/task/taskHeader/service/impl/TaskHeaderServiceImpl.java
index e6299ab..01bd362 100644
--- a/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/task/taskHeader/service/impl/TaskHeaderServiceImpl.java
+++ b/huaheng-wms-core/src/main/java/org/jeecg/modules/wms/task/taskHeader/service/impl/TaskHeaderServiceImpl.java
@@ -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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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 完成入库任务结果
diff --git a/huaheng-wms-core/src/main/java/org/jeecg/utils/constant/QuantityConstant.java b/huaheng-wms-core/src/main/java/org/jeecg/utils/constant/QuantityConstant.java
index 699e298..afd9c1d 100644
--- a/huaheng-wms-core/src/main/java/org/jeecg/utils/constant/QuantityConstant.java
+++ b/huaheng-wms-core/src/main/java/org/jeecg/utils/constant/QuantityConstant.java
@@ -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、任务状态
--
libgit2 0.22.2