From 611118f04720931e31f87ae5d395318c4085db5e Mon Sep 17 00:00:00 2001
From: zwl <1051256694@qq.com>
Date: 星期一, 27 四月 2026 23:40:38 +0800
Subject: [PATCH] 1.双伸空托盘入库规则完善 2.完善双伸只找一边的问题 3.完善重新分配库位问题
---
src/main/java/com/zy/api/service/impl/WcsApiServiceImpl.java | 531 ++++++++++++++++++++++++++++++++++++++++------------------
1 files changed, 366 insertions(+), 165 deletions(-)
diff --git a/src/main/java/com/zy/api/service/impl/WcsApiServiceImpl.java b/src/main/java/com/zy/api/service/impl/WcsApiServiceImpl.java
index c35e848..ae42e87 100644
--- a/src/main/java/com/zy/api/service/impl/WcsApiServiceImpl.java
+++ b/src/main/java/com/zy/api/service/impl/WcsApiServiceImpl.java
@@ -17,24 +17,23 @@
import com.zy.api.service.WcsApiService;
import com.zy.asrs.entity.*;
import com.zy.asrs.service.*;
+import com.zy.asrs.task.support.OutboundBatchSeqReleaseGuard;
import com.zy.asrs.utils.Utils;
import com.zy.common.constant.MesConstant;
import com.zy.common.model.LocTypeDto;
import com.zy.common.model.StartupDto;
import com.zy.common.service.CommonService;
import com.zy.common.utils.HttpHandler;
-import com.zy.common.utils.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
-import org.springframework.transaction.support.TransactionSynchronizationAdapter;
-import org.springframework.transaction.support.TransactionSynchronizationManager;
import java.io.IOException;
import java.math.BigDecimal;
+import java.math.BigInteger;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
@@ -45,14 +44,30 @@
private static final Long WCS_SYNC_USER = 9999L;
private static final String YES = "Y";
private static final String NO = "N";
+ private static final long OUT_LOCK_REPORT_PENDING_WRK_STS = 13L;
+ private static final long OUT_LOCK_REPORT_SUCCESS_WRK_STS = 21L;
+ private static final long OUT_LOCK_REPORT_FAIL_WRK_STS = 22L;
+ private static final long OUTBOUND_CRN_COMPLETE_WRK_STS = 25L;
+ private static final long OUTBOUND_STATION_COMPLETE_WRK_STS = 26L;
+ private static final String OUT_LOCK_REPORT_PENDING_FLAG = "P";
/** 鍚屼竴 WCS 璺緞銆佸悓涓�鍗曞彿涓嬩竴缁勪笅鍙戠殑浠诲姟鏉℃暟涓婇檺 */
private static final int WCS_PUB_BATCH_SIZE = 20;
/** 涓夋柟鎺ュ彛缁熻锛氭湰绯荤粺璋冪敤 WCS 鐨� namespace 绾﹀畾 */
private static final String NS_WMS_TO_WCS = "鏈郴缁熻姹俉CS";
- private static final String REASSIGN_CRN_LOCK_KEY_PREFIX = "wcs:reassign:inbound:crn:";
- private static final long REASSIGN_CRN_LOCK_SECONDS = 180L;
+ private static final String EMPTY_PALLET_MATNR = "emptyPallet";
+ private static final int EMPTY_PALLET_REASSIGN_TARGET_LEVEL = 8;
+ private static final short EMPTY_PALLET_REASSIGN_LOC_TYPE1 = 3;
+ private static final short EMPTY_PALLET_REASSIGN_LOC_TYPE2 = 0;
+
+ private static class ReassignCrnPool {
+ private final List<Integer> crnNos;
+
+ private ReassignCrnPool(List<Integer> crnNos) {
+ this.crnNos = crnNos;
+ }
+ }
@Autowired
private LocMastService locMastService;
@@ -100,9 +115,7 @@
@Autowired
private ApiLogService apiLogService;
@Autowired
- private RowLastnoService rowLastnoService;
- @Autowired
- private RedisUtil redisUtil;
+ private OutboundBatchSeqReleaseGuard outboundBatchSeqReleaseGuard;
/**
@@ -122,6 +135,10 @@
String validateMsg = validatePubTask(params, wrkMast);
if (!Cools.isEmpty(validateMsg)) {
return R.error(validateMsg);
+ }
+ String batchBlockMsg = validateOutboundBatchSeqReady(params, wrkMast);
+ if (!Cools.isEmpty(batchBlockMsg)) {
+ return R.error(batchBlockMsg);
}
String url = resolveTaskPath(params);
String requestJson = JSON.toJSONString(params);
@@ -199,6 +216,7 @@
List<String> failMsgs = new ArrayList<>();
List<WorkTaskParams> lastSentChunk = null;
String skipGroupKey = null;
+ Set<String> blockedOutboundUserKeys = new HashSet<>();
for (List<WorkTaskParams> chunk : chunks) {
if (chunk == null || chunk.isEmpty()) {
@@ -207,8 +225,22 @@
WorkTaskParams head = chunk.get(0);
WrkMast headMast = wrkMastMap.get(head.getTaskNo());
String key = buildBatchGroupKey(head, headMast);
+ String outboundUserKey = buildOutboundUserKey(head, headMast);
if (skipGroupKey != null && skipGroupKey.equals(key)) {
+ continue;
+ }
+ if (outboundUserKey != null && blockedOutboundUserKeys.contains(outboundUserKey)) {
+ continue;
+ }
+
+ String batchBlockMsg = validateOutboundBatchSeqReady(chunk, wrkMastMap);
+ if (!Cools.isEmpty(batchBlockMsg)) {
+ skipMsgs.add(batchBlockMsg);
+ skipGroupKey = key;
+ if (outboundUserKey != null) {
+ blockedOutboundUserKeys.add(outboundUserKey);
+ }
continue;
}
@@ -302,7 +334,7 @@
}
/**
- * 鍑哄簱锛氫粎褰撳崟鍙枫�佸簭鍙峰潎鏈夋晥鏃跺仛璺冲彿鏍￠獙锛涘崟鍙风┖鎴栧簭鍙锋棤鏁堜粛涓嬪彂銆傚叆搴�/绉诲簱涓嶅鐞嗐��
+ * 鍑哄簱锛氫粎褰撳崟鍙枫�佹壒娆°�佸簭鍙峰潎鏈夋晥鏃跺仛鎵规鍐呰烦鍙锋牎楠岋紱鏃犳晥鏃朵粛涓嬪彂銆傚叆搴�/绉诲簱涓嶅鐞嗐��
*/
private List<WorkTaskParams> filterOutboundByContiguousPlt(List<WorkTaskParams> accepted, Map<String, WrkMast> wrkMastMap, List<String> skipMsgs) {
Map<String, Integer> reachCache = new HashMap<>();
@@ -314,12 +346,14 @@
}
WrkMast w = wrkMastMap.get(p.getTaskNo());
String userNo = sortUserNoForPub(p, w);
+ String batchGroup = sortBatchGroupForPub(p, w);
Integer plt = sortPltForPub(p, w);
if (Cools.isEmpty(userNo) || plt == null || plt <= 0) {
kept.add(p);
continue;
}
- int maxReach = reachCache.computeIfAbsent(userNo, wrkMastService::outboundSeqMaxContiguousPlt);
+ String cacheKey = buildOutboundBatchCacheKey(userNo, batchGroup);
+ int maxReach = reachCache.computeIfAbsent(cacheKey, key -> wrkMastService.outboundSeqMaxContiguousPlt(userNo, batchGroup));
if (plt > maxReach) {
skipMsgs.add(buildTaskMsg(p, "鍑哄簱搴忓彿璺冲彿锛岃烦杩�"));
continue;
@@ -363,7 +397,7 @@
}
/**
- * 鍚屽崟涓嬩竴缁勶細浼樺厛 WCS queryTask锛涘け璐ユ垨鏃犳暟鎹垯涓昏〃宸查潪 11 鎴栧凡杩涘巻鍙茶〃銆�
+ * 鍚屽崟鍚屾壒涓嬩竴缁勶細浼樺厛 WCS queryTask锛涘け璐ユ垨鏃犳暟鎹垯涓昏〃宸查潪 11 鎴栧凡杩涘巻鍙茶〃銆�
*/
private boolean sameOrderNextChunkAllowed(List<WorkTaskParams> lastSentChunk) {
if (lastSentChunk == null || lastSentChunk.isEmpty()) {
@@ -426,7 +460,7 @@
}
/**
- * 鍑哄簱姣忕粍涓嬪彂鍓嶏細鏈粍鏈夋湁鏁堟渶灏忓簭鍙蜂笖>1 鏃讹紝鍙牎楠屻�屾渶灏忓簭鍙�-1銆嶄竴妗ｏ紱搴忓彿鍏ㄦ棤鍒欒烦杩囨湰鏉′欢銆�
+ * 鍑哄簱姣忕粍涓嬪彂鍓嶏細鏈粍鏈夋湁鏁堟渶灏忓簭鍙蜂笖>1 鏃讹紝鍙牎楠屻�屽悓鍗曞悓鎵圭殑鏈�灏忓簭鍙�-1銆嶄竴妗ｏ紱搴忓彿鍏ㄦ棤鍒欒烦杩囨湰鏉′欢銆�
*/
private boolean outboundChunkPredecessorPltReady(List<WorkTaskParams> chunk, Map<String, WrkMast> wrkMastMap) {
if (chunk == null || chunk.isEmpty()) {
@@ -438,6 +472,7 @@
}
WrkMast headMast = wrkMastMap.get(head.getTaskNo());
String userNo = sortUserNoForPub(head, headMast);
+ String batchGroup = sortBatchGroupForPub(head, headMast);
if (Cools.isEmpty(userNo)) {
return true;
}
@@ -454,14 +489,40 @@
if (minPlt == Integer.MAX_VALUE || minPlt <= 1) {
return true;
}
- return outboundPltSlotReleasedInWms(userNo, minPlt - 1);
+ return outboundPltSlotReleasedInWms(userNo, batchGroup, minPlt - 1);
}
- private boolean outboundPltSlotReleasedInWms(String userNo, int pltType) {
- List<WrkMast> rows = wrkMastService.selectList(new EntityWrapper<WrkMast>()
- .eq("user_no", userNo)
- .eq("io_type", 101)
- .eq("plt_type", pltType));
+ private String validateOutboundBatchSeqReady(List<WorkTaskParams> chunk, Map<String, WrkMast> wrkMastMap) {
+ if (chunk == null || chunk.isEmpty()) {
+ return null;
+ }
+ WorkTaskParams head = chunk.get(0);
+ return validateOutboundBatchSeqReady(head, wrkMastMap.get(head.getTaskNo()));
+ }
+
+ private String validateOutboundBatchSeqReady(WorkTaskParams params, WrkMast wrkMast) {
+ if (params == null || !"out".equalsIgnoreCase(params.getType())) {
+ return null;
+ }
+ if (wrkMast == null || !Objects.equals(wrkMast.getIoType(), 101)) {
+ return null;
+ }
+ return outboundBatchSeqReleaseGuard.validateReady(
+ sortUserNoForPub(params, wrkMast),
+ sortBatchGroupForPub(params, wrkMast));
+ }
+
+ private boolean outboundPltSlotReleasedInWms(String userNo, String batchSeq, int pltType) {
+ EntityWrapper<WrkMast> mastWrapper = new EntityWrapper<>();
+ mastWrapper.eq("user_no", userNo);
+ mastWrapper.eq("io_type", 101);
+ mastWrapper.eq("plt_type", pltType);
+ if (batchSeq == null) {
+ mastWrapper.isNull("batch_seq");
+ } else {
+ mastWrapper.eq("batch_seq", batchSeq);
+ }
+ List<WrkMast> rows = wrkMastService.selectList(mastWrapper);
if (rows != null && !rows.isEmpty()) {
for (WrkMast m : rows) {
if (m != null && m.getWrkSts() != null && Objects.equals(m.getWrkSts(), 11L)) {
@@ -470,10 +531,16 @@
}
return true;
}
- int logCnt = wrkMastLogService.selectCount(new EntityWrapper<WrkMastLog>()
- .eq("user_no", userNo)
- .eq("io_type", 101)
- .eq("plt_type", pltType));
+ EntityWrapper<WrkMastLog> logWrapper = new EntityWrapper<>();
+ logWrapper.eq("user_no", userNo);
+ logWrapper.eq("io_type", 101);
+ logWrapper.eq("plt_type", pltType);
+ if (batchSeq == null) {
+ logWrapper.isNull("batch_seq");
+ } else {
+ logWrapper.eq("batch_seq", batchSeq);
+ }
+ int logCnt = wrkMastLogService.selectCount(logWrapper);
return logCnt > 0;
}
@@ -502,6 +569,7 @@
return Comparator
.comparing((WorkTaskParams p) -> Optional.ofNullable(p.getType()).orElse(""), String.CASE_INSENSITIVE_ORDER)
.thenComparing(p -> sortUserNoForPub(p, wrkMastMap.get(p.getTaskNo())), Comparator.nullsLast(String::compareTo))
+ .thenComparing(p -> sortBatchGroupForPub(p, wrkMastMap.get(p.getTaskNo())), WcsApiServiceImpl::compareBatchSeqNatural)
.thenComparing(p -> sortPltForPub(p, wrkMastMap.get(p.getTaskNo())), Comparator.nullsLast(Integer::compareTo));
}
@@ -518,6 +586,77 @@
return wrkMast.getPltType();
}
return p.getBatchSeq();
+ }
+
+ private static String sortBatchGroupForPub(WorkTaskParams p, WrkMast wrkMast) {
+ if (wrkMast != null) {
+ return wrkMast.getBatchSeq();
+ }
+ return null;
+ }
+
+ private static String buildOutboundUserKey(WorkTaskParams params, WrkMast wrkMast) {
+ if (params == null || !"out".equalsIgnoreCase(params.getType())) {
+ return null;
+ }
+ String userNo = sortUserNoForPub(params, wrkMast);
+ if (Cools.isEmpty(userNo)) {
+ return null;
+ }
+ return resolveSafeKey(userNo);
+ }
+
+ private static int compareBatchSeqNatural(String left, String right) {
+ String safeLeft = normalizeBatchSeq(left);
+ String safeRight = normalizeBatchSeq(right);
+ int leftIndex = 0;
+ int rightIndex = 0;
+ while (leftIndex < safeLeft.length() && rightIndex < safeRight.length()) {
+ char leftChar = safeLeft.charAt(leftIndex);
+ char rightChar = safeRight.charAt(rightIndex);
+ if (Character.isDigit(leftChar) && Character.isDigit(rightChar)) {
+ int leftStart = leftIndex;
+ int rightStart = rightIndex;
+ while (leftIndex < safeLeft.length() && Character.isDigit(safeLeft.charAt(leftIndex))) {
+ leftIndex++;
+ }
+ while (rightIndex < safeRight.length() && Character.isDigit(safeRight.charAt(rightIndex))) {
+ rightIndex++;
+ }
+ String leftNumber = safeLeft.substring(leftStart, leftIndex);
+ String rightNumber = safeRight.substring(rightStart, rightIndex);
+ int compare = new BigInteger(leftNumber).compareTo(new BigInteger(rightNumber));
+ if (compare != 0) {
+ return compare;
+ }
+ compare = Integer.compare(leftNumber.length(), rightNumber.length());
+ if (compare != 0) {
+ return compare;
+ }
+ continue;
+ }
+ int compare = Character.compare(leftChar, rightChar);
+ if (compare != 0) {
+ return compare;
+ }
+ leftIndex++;
+ rightIndex++;
+ }
+ return Integer.compare(safeLeft.length(), safeRight.length());
+ }
+
+ private static String normalizeBatchSeq(String value) {
+ return Cools.isEmpty(value) ? "" : value;
+ }
+
+ private static String resolveSafeKey(String value) {
+ return Cools.isEmpty(value) ? "_EMPTY_" : value;
+ }
+
+ private static String buildOutboundBatchCacheKey(String userNo, String batchSeq) {
+ String safeUserNo = Cools.isEmpty(userNo) ? "_NO_USER_" : userNo;
+ String safeBatchSeq = Cools.isEmpty(batchSeq) ? "_NO_BATCH_" : batchSeq;
+ return safeUserNo + "#" + safeBatchSeq;
}
/**
@@ -544,13 +683,44 @@
}
- if (params.getNotifyType().equals("task")) {
+ if (isOutboundCrnTaskRun(params)) {
+ // WCS鍑哄簱浠诲姟寮�濮嬶細鍫嗗灈鏈哄紑濮嬫墽琛屽嚭搴撲换鍔★紝宸ヤ綔鐘舵�� 12 -> 13銆�
+ if (isOutboundTask(mast) && Objects.equals(mast.getWrkSts(), 12L)) {
+ mast.setWrkSts(OUT_LOCK_REPORT_PENDING_WRK_STS);
+ mast.setExpTime(0D);
+ mast.setLogMk(OUT_LOCK_REPORT_PENDING_FLAG);
+ mast.setLogErrMemo(null);
+ mast.setLogErrTime(null);
+ mast.setModiTime(new Date());
+ if (!wrkMastService.updateById(mast)) {
+ throw new CoolException("浠诲姟鐘舵�佷慨鏀瑰け璐ワ紒锛�");
+ }
+ }
+ } else if (isOutboundCrnTaskComplete(params)) {
+ // WCS鍑哄簱浠诲姟瀹屾垚锛氬爢鍨涙満鍑哄簱浠诲姟鎵ц瀹屾垚锛屽伐浣滅姸鎬� -> 25銆�
+ if (isOutboundTask(mast) && canMarkOutboundCrnComplete(mast)) {
+ mast.setWrkSts(OUTBOUND_CRN_COMPLETE_WRK_STS);
+ mast.setModiTime(new Date());
+ if (!wrkMastService.updateById(mast)) {
+ throw new CoolException("浠诲姟鐘舵�佷慨鏀瑰け璐ワ紒锛�");
+ }
+ }
+ } else if (isOutboundStationTaskRunComplete(params)) {
+ // WCS杈撻�佺珯鐐瑰嚭搴撲换鍔¤繍琛屽畬鎴愶細鎵樼洏宸插埌鐩殑鍦帮紝宸ヤ綔鐘舵�� -> 26銆�
+ if (isOutboundTask(mast) && canMarkOutboundStationComplete(mast)) {
+ mast.setWrkSts(OUTBOUND_STATION_COMPLETE_WRK_STS);
+ mast.setModiTime(new Date());
+ if (!wrkMastService.updateById(mast)) {
+ throw new CoolException("浠诲姟鐘舵�佷慨鏀瑰け璐ワ紒锛�");
+ }
+ }
+ } else if ("task".equalsIgnoreCase(params.getNotifyType())) {
//浠诲姟
- if (params.getMsgType().equals("task_complete")) {
+ if ("task_complete".equalsIgnoreCase(params.getMsgType())) {
if (mast.getIoType() == 1 || mast.getIoType() == 2 ||mast.getIoType() == 10) {
mast.setWrkSts(4L);
- } else if ((mast.getIoType() == 101||mast.getIoType()==110) && mast.getWrkSts()<14) {
+ } else if (isOutboundTask(mast) && canMarkOutboundTaskComplete(mast)) {
mast.setWrkSts(14L);
if(Cools.isEmpty(mast.getStaNo())){
mast.setOveMk("Y");
@@ -560,27 +730,63 @@
throw new CoolException("浠诲姟鐘舵�佷慨鏀瑰け璐ワ紒锛�");
}
//wcs浠诲姟鍙栨秷鎺ュ彛
- } else if (params.getMsgType().equals("task_cancel")) {
+ } else if ("task_cancel".equalsIgnoreCase(params.getMsgType())) {
workService.cancelWrkMast(String.valueOf(mast.getWrkNo()), 9955L);
- } else if (params.getMsgType().equals("task_arrive")) {
- //鍒拌揪鐩殑鍦�
- //濡傛灉鍑哄簱浠诲姟鏄法鍖哄垯闇�瑕佺敓鎴愭柊鐨勫叆搴撲换鍔″叆搴�
- if(!Cools.isEmpty(mast.getLocNo())){
- mast.setOnlineYn("N");//绛夊緟鐢熸垚璺ㄥ尯鍏ュ簱浠诲姟
- }
- mast.setWrkSts(14L);
- if(Cools.isEmpty(mast.getStaNo())){
- mast.setOveMk("Y");
- }
- mast.setModiTime(new Date());
- if (!wrkMastService.updateById(mast)) {
- throw new CoolException("浠诲姟鐘舵�佷慨鏀瑰け璐ワ紒锛�");
- }
}
- } else if (params.getNotifyType().equals("weight")) {
-
}
return R.ok();
+ }
+
+ private boolean isOutboundCrnTaskRun(ReceviceTaskParams params) {
+ return params != null
+ && "Crn".equalsIgnoreCase(params.getNotifyType())
+ && "crn_out_task_run".equalsIgnoreCase(params.getMsgType());
+ }
+
+ private boolean isOutboundCrnTaskComplete(ReceviceTaskParams params) {
+ return params != null
+ && "Crn".equalsIgnoreCase(params.getNotifyType())
+ && "crn_out_task_complete".equalsIgnoreCase(params.getMsgType());
+ }
+
+ private boolean isOutboundStationTaskRunComplete(ReceviceTaskParams params) {
+ return params != null
+ && "Devp".equalsIgnoreCase(params.getNotifyType())
+ && "station_out_task_run_complete".equalsIgnoreCase(params.getMsgType());
+ }
+
+ private boolean isOutboundTask(WrkMast mast) {
+ return mast != null && mast.getIoType() != null && (mast.getIoType() == 101 || mast.getIoType() == 110);
+ }
+
+ private boolean canMarkOutboundCrnComplete(WrkMast mast) {
+ if (mast == null || mast.getWrkSts() == null) {
+ return false;
+ }
+ return mast.getWrkSts() < 14
+ || mast.getWrkSts().equals(OUT_LOCK_REPORT_SUCCESS_WRK_STS)
+ || mast.getWrkSts().equals(OUT_LOCK_REPORT_FAIL_WRK_STS);
+ }
+
+ private boolean canMarkOutboundTaskComplete(WrkMast mast) {
+ if (mast == null || mast.getWrkSts() == null) {
+ return false;
+ }
+ return mast.getWrkSts() < 14
+ || mast.getWrkSts().equals(OUT_LOCK_REPORT_SUCCESS_WRK_STS)
+ || mast.getWrkSts().equals(OUT_LOCK_REPORT_FAIL_WRK_STS)
+ || mast.getWrkSts().equals(OUTBOUND_CRN_COMPLETE_WRK_STS)
+ || mast.getWrkSts().equals(OUTBOUND_STATION_COMPLETE_WRK_STS);
+ }
+
+ private boolean canMarkOutboundStationComplete(WrkMast mast) {
+ if (mast == null || mast.getWrkSts() == null) {
+ return false;
+ }
+ return mast.getWrkSts() < 14
+ || mast.getWrkSts().equals(OUT_LOCK_REPORT_SUCCESS_WRK_STS)
+ || mast.getWrkSts().equals(OUT_LOCK_REPORT_FAIL_WRK_STS)
+ || mast.getWrkSts().equals(OUTBOUND_CRN_COMPLETE_WRK_STS);
}
@Override
@@ -641,21 +847,37 @@
return R.error("褰撳墠鐩爣搴撲綅涓嶅瓨鍦�");
}
- Integer preferredArea = resolveReassignArea(wrkMast, currentLoc);
- if (preferredArea == null) {
- return R.error("鏃犳硶纭畾浠诲姟鎵�灞炲簱鍖�");
+ boolean emptyPallet = isReassignEmptyPallet(wrkMast);
+ LocTypeDto locTypeDto = buildReassignLocTypeDto(currentLoc, emptyPallet);
+ BasDevp sourceStation = basDevpService.selectById(wrkMast.getSourceStaNo());
+ if (Cools.isEmpty(sourceStation)) {
+ return R.error("婧愮珯鏈厤缃叆搴撲紭鍏堟睜");
+ }
+ List<ReassignCrnPool> poolOrder;
+ try {
+ poolOrder = buildReassignCrnPoolOrder(sourceStation, wrkMast.getCrnNo());
+ } catch (CoolException e) {
+ return R.error(e.getMessage());
+ }
+ if (Cools.isEmpty(poolOrder)) {
+ return R.error("婧愮珯鏈厤缃叆搴撲紭鍏堟睜");
}
- List<Integer> candidateCrnNos = buildReassignCandidateCrnNos(preferredArea, wrkMast.getCrnNo());
- if (candidateCrnNos.isEmpty()) {
- return R.error("褰撳墠搴撳尯娌℃湁鍏朵粬鍫嗗灈鏈哄彲渚涢噸鍒嗛厤");
+ StartupDto startupDto = null;
+ Integer targetLevel = resolveReassignTargetLevel(emptyPallet);
+ for (ReassignCrnPool pool : poolOrder) {
+ List<Integer> candidateCrnNos = buildReassignCandidateCrnNos(pool.crnNos, wrkMast.getCrnNo());
+ if (candidateCrnNos.isEmpty()) {
+ continue;
+ }
+ startupDto = commonService.findRun2InboundLocByCandidateCrnNos(
+ wrkMast.getSourceStaNo(), wrkMast.getIoType(), candidateCrnNos, locTypeDto, targetLevel);
+ if (startupDto != null && !Cools.isEmpty(startupDto.getLocNo())) {
+ break;
+ }
}
-
- LocTypeDto locTypeDto = buildReassignLocTypeDto(currentLoc);
- StartupDto startupDto = commonService.findRun2InboundLocByCandidateCrnNos(
- wrkMast.getSourceStaNo(), wrkMast.getIoType(), preferredArea, candidateCrnNos, locTypeDto);
if (startupDto == null || Cools.isEmpty(startupDto.getLocNo())) {
- return R.error("褰撳墠搴撳尯娌℃湁鍙噸鏂板垎閰嶇殑绌哄簱浣�");
+ return R.error("褰撳墠浼樺厛姹犳病鏈夊彲閲嶆柊鍒嗛厤鐨勭┖搴撲綅");
}
LocMast targetLoc = locMastService.selectById(startupDto.getLocNo());
@@ -670,7 +892,6 @@
updateReassignTargetLoc(targetLoc, wrkMast, currentLoc, now);
updateReassignWorkMast(wrkMast, startupDto, now);
releaseOldReservedLocIfNeeded(currentLoc, targetLoc.getLocNo(), now);
- lockReassignedCrnAfterCommit(preferredArea, targetLoc.getCrnNo(), wrkMast.getWrkNo());
Map<String, Object> result = new LinkedHashMap<>();
result.put("locNo", Utils.WMSLocToWCSLoc(targetLoc.getLocNo()));
@@ -706,6 +927,9 @@
if ("Y".equalsIgnoreCase(wrkMast.getPauseMk())) {
return "task paused";
}
+ if (Objects.equals(wrkMast.getIoType(), 101) && Cools.isEmpty(wrkMast.getBatchSeq())) {
+ return "鍑哄簱杩涗粨缂栧彿(batchSeq)涓虹┖锛岃烦杩囦笅鍙�";
+ }
if (requiresOutboundErpConfirm(wrkMast) && !"Y".equalsIgnoreCase(wrkMast.getPdcType())) {
return "task not confirmed by erp";
}
@@ -735,92 +959,102 @@
return null;
}
- private Integer resolveReassignArea(WrkMast wrkMast, LocMast currentLoc) {
- Integer stationArea = Utils.getStationStorageArea(wrkMast.getSourceStaNo());
- if (belongsToArea(stationArea, wrkMast.getCrnNo(), currentLoc)) {
- return stationArea;
+ private List<ReassignCrnPool> buildReassignCrnPoolOrder(BasDevp sourceStation, Integer currentCrnNo) {
+ List<Integer> firstPoolCrnNos = Utils.distinctCrnNos(sourceStation.getInFirstCrnCsv());
+ List<Integer> secondPoolCrnNos = excludeReassignPoolCrnNos(
+ Utils.distinctCrnNos(sourceStation.getInSecondCrnCsv()), firstPoolCrnNos);
+ if (Cools.isEmpty(firstPoolCrnNos) && Cools.isEmpty(secondPoolCrnNos)) {
+ throw new CoolException("婧愮珯鏈厤缃叆搴撲紭鍏堟睜");
}
- Integer fallbackArea = findAreaByCurrentTask(wrkMast.getCrnNo(), currentLoc);
- if (fallbackArea != null) {
- return fallbackArea;
+ boolean inFirstPool = firstPoolCrnNos.contains(currentCrnNo);
+ boolean inSecondPool = secondPoolCrnNos.contains(currentCrnNo);
+ if (!inFirstPool && !inSecondPool) {
+ throw new CoolException("褰撳墠浠诲姟鍫嗗灈鏈烘湭閰嶇疆鍦ㄦ簮绔欏叆搴撲紭鍏堟睜");
}
- return stationArea;
+ List<ReassignCrnPool> poolOrder = new ArrayList<>();
+ if (inFirstPool) {
+ poolOrder.add(new ReassignCrnPool(firstPoolCrnNos));
+ poolOrder.add(new ReassignCrnPool(secondPoolCrnNos));
+ return poolOrder;
+ }
+ poolOrder.add(new ReassignCrnPool(secondPoolCrnNos));
+ poolOrder.add(new ReassignCrnPool(firstPoolCrnNos));
+ return poolOrder;
}
- private Integer findAreaByCurrentTask(Integer currentCrnNo, LocMast currentLoc) {
- for (int area = 1; area <= 3; area++) {
- if (belongsToArea(area, currentCrnNo, currentLoc)) {
- return area;
+ private List<Integer> excludeReassignPoolCrnNos(List<Integer> crnNos, List<Integer> excludedCrnNos) {
+ List<Integer> result = new ArrayList<>();
+ if (Cools.isEmpty(crnNos)) {
+ return result;
+ }
+ LinkedHashSet<Integer> excluded = new LinkedHashSet<>(Utils.distinctCrnNos(excludedCrnNos));
+ for (Integer crnNo : Utils.distinctCrnNos(crnNos)) {
+ if (crnNo == null || excluded.contains(crnNo)) {
+ continue;
}
+ result.add(crnNo);
+ }
+ return result;
+ }
+
+ private List<Integer> buildReassignCandidateCrnNos(List<Integer> poolCrnNos, Integer currentCrnNo) {
+ return buildReassignCrnSearchOrder(poolCrnNos, currentCrnNo);
+ }
+
+ private List<Integer> buildReassignCrnSearchOrder(List<Integer> poolCrnNos, Integer currentCrnNo) {
+ List<Integer> orderedCrnNos = Utils.distinctCrnNos(poolCrnNos);
+ Collections.sort(orderedCrnNos);
+ if (Cools.isEmpty(orderedCrnNos) || currentCrnNo == null) {
+ return orderedCrnNos;
+ }
+ List<Integer> searchOrder = new ArrayList<>();
+ for (int index = orderedCrnNos.size() - 1; index >= 0; index--) {
+ Integer crnNo = orderedCrnNos.get(index);
+ if (crnNo == null || crnNo >= currentCrnNo) {
+ continue;
+ }
+ searchOrder.add(crnNo);
+ }
+ for (int index = orderedCrnNos.size() - 1; index >= 0; index--) {
+ Integer crnNo = orderedCrnNos.get(index);
+ if (crnNo == null || crnNo <= 0 || crnNo.equals(currentCrnNo) || crnNo < currentCrnNo) {
+ continue;
+ }
+ searchOrder.add(crnNo);
+ }
+ return searchOrder;
+ }
+
+ private Integer resolveReassignTargetLevel(boolean emptyPallet) {
+ if (emptyPallet) {
+ return EMPTY_PALLET_REASSIGN_TARGET_LEVEL;
}
return null;
}
- private boolean belongsToArea(Integer area, Integer currentCrnNo, LocMast currentLoc) {
- if (area == null || area <= 0) {
+ private boolean isReassignEmptyPallet(WrkMast wrkMast) {
+ if (wrkMast == null || wrkMast.getWrkNo() == null) {
return false;
}
- RowLastno areaRowLastno = rowLastnoService.selectById(area);
- if (areaRowLastno == null) {
+ List<WrkDetl> wrkDetls = wrkDetlService.selectByWrkNo(wrkMast.getWrkNo());
+ if (Cools.isEmpty(wrkDetls)) {
return false;
}
- Integer startCrnNo = resolveAreaStartCrnNo(areaRowLastno);
- Integer endCrnNo = resolveAreaEndCrnNo(areaRowLastno, startCrnNo);
- if (currentCrnNo != null && currentCrnNo >= startCrnNo && currentCrnNo <= endCrnNo) {
- return true;
+ for (WrkDetl wrkDetl : wrkDetls) {
+ if (wrkDetl != null && EMPTY_PALLET_MATNR.equalsIgnoreCase(String.valueOf(wrkDetl.getMatnr()).trim())) {
+ return true;
+ }
}
- Integer row = currentLoc == null ? null : currentLoc.getRow1();
- Integer startRow = areaRowLastno.getsRow();
- Integer endRow = areaRowLastno.geteRow();
- return row != null && startRow != null && endRow != null && row >= startRow && row <= endRow;
+ return false;
}
- private List<Integer> buildReassignCandidateCrnNos(Integer area, Integer currentCrnNo) {
- RowLastno areaRowLastno = rowLastnoService.selectById(area);
- if (areaRowLastno == null) {
- throw new CoolException("鏈壘鍒板簱鍖鸿疆璇㈣鍒�");
- }
- int startCrnNo = resolveAreaStartCrnNo(areaRowLastno);
- int endCrnNo = resolveAreaEndCrnNo(areaRowLastno, startCrnNo);
- if (currentCrnNo == null || currentCrnNo < startCrnNo || currentCrnNo > endCrnNo) {
- throw new CoolException("褰撳墠浠诲姟鍫嗗灈鏈轰笉鍦ㄦ墍灞炲簱鍖鸿寖鍥村唴");
- }
- List<Integer> candidateCrnNos = new ArrayList<>();
- for (int crnNo = currentCrnNo - 1; crnNo >= startCrnNo; crnNo--) {
- addUnlockedReassignCandidate(candidateCrnNos, area, crnNo);
- }
- for (int crnNo = endCrnNo; crnNo > currentCrnNo; crnNo--) {
- addUnlockedReassignCandidate(candidateCrnNos, area, crnNo);
- }
- return candidateCrnNos;
- }
-
- private void addUnlockedReassignCandidate(List<Integer> candidateCrnNos, Integer area, int crnNo) {
- if (isReassignCrnLocked(area, crnNo)) {
- log.info("skip locked reassign crane. area={}, crnNo={}, ttl={}s",
- area, crnNo, redisUtil.getExpire(buildReassignCrnLockKey(area, crnNo)));
- return;
- }
- candidateCrnNos.add(crnNo);
- }
-
- private int resolveAreaStartCrnNo(RowLastno areaRowLastno) {
- if (areaRowLastno.getsCrnNo() != null && areaRowLastno.getsCrnNo() > 0) {
- return areaRowLastno.getsCrnNo();
- }
- return 1;
- }
-
- private int resolveAreaEndCrnNo(RowLastno areaRowLastno, int startCrnNo) {
- if (areaRowLastno.geteCrnNo() != null && areaRowLastno.geteCrnNo() >= startCrnNo) {
- return areaRowLastno.geteCrnNo();
- }
- int crnQty = areaRowLastno.getCrnQty() == null || areaRowLastno.getCrnQty() <= 0 ? 1 : areaRowLastno.getCrnQty();
- return startCrnNo + crnQty - 1;
- }
-
- private LocTypeDto buildReassignLocTypeDto(LocMast currentLoc) {
+ private LocTypeDto buildReassignLocTypeDto(LocMast currentLoc, boolean emptyPallet) {
LocTypeDto locTypeDto = new LocTypeDto();
+ if (emptyPallet) {
+ locTypeDto.setLocType1(EMPTY_PALLET_REASSIGN_LOC_TYPE1);
+ locTypeDto.setLocType2(EMPTY_PALLET_REASSIGN_LOC_TYPE2);
+ return locTypeDto;
+ }
if (currentLoc == null) {
return locTypeDto;
}
@@ -886,43 +1120,6 @@
if (!locMastService.updateById(currentLoc)) {
throw new CoolException("閲婃斁鍘熺洰鏍囧簱浣嶅け璐�");
}
- }
-
- private boolean isReassignCrnLocked(Integer area, Integer crnNo) {
- if (area == null || crnNo == null) {
- return false;
- }
- return redisUtil.hasKey(buildReassignCrnLockKey(area, crnNo));
- }
-
- private String buildReassignCrnLockKey(Integer area, Integer crnNo) {
- return REASSIGN_CRN_LOCK_KEY_PREFIX + area + ":" + crnNo;
- }
-
- private void lockReassignedCrnAfterCommit(Integer area, Integer crnNo, Integer wrkNo) {
- if (area == null || crnNo == null) {
- return;
- }
- Runnable action = () -> {
- String key = buildReassignCrnLockKey(area, crnNo);
- boolean locked = redisUtil.set(key, String.valueOf(wrkNo), REASSIGN_CRN_LOCK_SECONDS);
- if (!locked) {
- log.warn("failed to lock reassigned crane in redis. area={}, crnNo={}, wrkNo={}", area, crnNo, wrkNo);
- return;
- }
- log.info("locked reassigned crane in redis. area={}, crnNo={}, wrkNo={}, ttl={}s",
- area, crnNo, wrkNo, REASSIGN_CRN_LOCK_SECONDS);
- };
- if (TransactionSynchronizationManager.isActualTransactionActive()) {
- TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
- @Override
- public void afterCommit() {
- action.run();
- }
- });
- return;
- }
- action.run();
}
/**
@@ -993,21 +1190,23 @@
* <p>
* 鍒嗙粍瑙勫垯锛�
* 1. 鍏堟寜鎺ュ彛璺緞鍖哄垎锛岄伩鍏嶄笉鍚屼换鍔＄被鍨嬫贩鐢ㄥ悓涓�涓� WCS 鎺ュ彛锛�
- * 2. 鍐嶆寜 userNo 鍖哄垎锛岀‘淇濈浉鍚� userNo 鐨勪换鍔′竴璧蜂笂鎶ャ��
+ * 2. 鍐嶆寜 userNo + batchSeq 鍖哄垎锛岀‘淇濈浉鍚岃鍗曞悓鎵规鐨勪换鍔′竴璧蜂笂鎶ャ��
* <p>
* 姝ｅ父鎯呭喌涓� userNo 鍙栬嚜 work_mast.user_no锛�
- * 濡傛灉褰撳墠娌℃煡鍒板伐浣滄。锛屽垯鍥為��鍒拌姹傞噷鐨� batch 瀛楁锛屼繚璇佸吋瀹瑰凡鏈夎皟鐢ㄣ��
+ * batchSeq 鍙栬嚜 work_mast.batch_seq锛涘鏋滃綋鍓嶆病鏌ュ埌宸ヤ綔妗ｏ紝鍒欏彧鎸� userNo 鍥為��鍏煎宸叉湁璋冪敤銆�
*/
private String buildBatchGroupKey(WorkTaskParams params, WrkMast wrkMast) {
String path = resolveTaskPath(params);
String userNo = wrkMast == null ? null : wrkMast.getUserNo();
+ String batchGroup = wrkMast == null ? null : wrkMast.getBatchSeq();
if (Cools.isEmpty(userNo)) {
userNo = params.getBatch();
}
if (Cools.isEmpty(userNo)) {
userNo = "_NO_USER_";
}
- return path + "#" + userNo;
+ String batchKey = Cools.isEmpty(batchGroup) ? "_NO_BATCH_" : batchGroup;
+ return path + "#" + userNo + "#" + batchKey;
}
/**
@@ -1048,10 +1247,12 @@
if (!Cools.isEmpty(params.getStaNo())) {
task.put("staNo", params.getStaNo());
}
- if (!Cools.isEmpty(params.getBatch())) {
+ boolean includeOutBatch = !"out".equalsIgnoreCase(params.getType())
+ || (params.getBatchSeq() != null && params.getBatchSeq() > 0);
+ if (includeOutBatch && !Cools.isEmpty(params.getBatch())) {
task.put("batch", params.getBatch());
}
- if (!Objects.isNull(params.getBatchSeq())) {
+ if (includeOutBatch && !Objects.isNull(params.getBatchSeq())) {
task.put("batchSeq", params.getBatchSeq());
}
return task;
--
Gitblit v1.9.1