1.双伸空托盘入库规则完善 2.完善双伸只找一边的问题 3.完善重新分配库位问题

zwl

4 天以前 611118f04720931e31f87ae5d395318c4085db5e

 src/main/java/com/zy/api/service/impl/WcsApiServiceImpl.java

@@ -24,15 +24,12 @@
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;
@@ -59,8 +56,18 @@

    /** 三方接口统计：本系统调用 WCS 的 namespace 约定 */
    private static final String NS_WMS_TO_WCS = "本系统请求WCS";
    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;
@@ -107,10 +114,6 @@
    private BasCrnpService basCrnpService;
    @Autowired
    private ApiLogService apiLogService;
    @Autowired
    private RowLastnoService rowLastnoService;
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private OutboundBatchSeqReleaseGuard outboundBatchSeqReleaseGuard;

@@ -844,28 +847,37 @@
            return R.error("当前目标库位不存在");
        }

        LocTypeDto locTypeDto = buildReassignLocTypeDto(currentLoc);
        List<Integer> areaOrder = buildReassignAreaOrder(wrkMast, currentLoc);
        if (Cools.isEmpty(areaOrder)) {
            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("源站未配置入库优先池");
        }

        StartupDto startupDto = null;
        Integer preferredArea = null;
        for (Integer area : areaOrder) {
            List<Integer> candidateCrnNos = buildReassignCandidateCrnNos(area, wrkMast.getCrnNo());
        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(), area, candidateCrnNos, locTypeDto);
                    wrkMast.getSourceStaNo(), wrkMast.getIoType(), candidateCrnNos, locTypeDto, targetLevel);
            if (startupDto != null && !Cools.isEmpty(startupDto.getLocNo())) {
                preferredArea = area;
                break;
            }
        }
        if (startupDto == null || Cools.isEmpty(startupDto.getLocNo())) {
            return R.error("当前库区没有可重新分配的空库位");
            return R.error("当前优先池没有可重新分配的空库位");
        }

        LocMast targetLoc = locMastService.selectById(startupDto.getLocNo());
@@ -880,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()));
@@ -948,115 +959,102 @@
        return null;
    }

    private Integer resolveReassignArea(WrkMast wrkMast, LocMast currentLoc) {
        List<Integer> stationAreas = Utils.getStationStorageAreas(wrkMast.getSourceStaNo());
        if (!Cools.isEmpty(stationAreas)) {
            for (Integer area : stationAreas) {
                if (belongsToArea(area, wrkMast.getCrnNo(), currentLoc)) {
                    return area;
                }
            }
    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 Utils.getStationStorageArea(wrkMast.getSourceStaNo());
        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 List<Integer> buildReassignAreaOrder(WrkMast wrkMast, LocMast currentLoc) {
        LinkedHashSet<Integer> areaOrder = new LinkedHashSet<>();
        List<Integer> stationAreas = Utils.getStationStorageAreas(wrkMast.getSourceStaNo());
        if (!Cools.isEmpty(stationAreas)) {
            areaOrder.addAll(stationAreas);
    private boolean isReassignEmptyPallet(WrkMast wrkMast) {
        if (wrkMast == null || wrkMast.getWrkNo() == null) {
            return false;
        }
        Integer currentArea = findAreaByCurrentTask(wrkMast.getCrnNo(), currentLoc);
        if (currentArea != null) {
            areaOrder.add(currentArea);
        List<WrkDetl> wrkDetls = wrkDetlService.selectByWrkNo(wrkMast.getWrkNo());
        if (Cools.isEmpty(wrkDetls)) {
            return false;
        }
        if (areaOrder.isEmpty()) {
            Integer resolvedArea = resolveReassignArea(wrkMast, currentLoc);
            if (resolvedArea != null) {
                areaOrder.add(resolvedArea);
        for (WrkDetl wrkDetl : wrkDetls) {
            if (wrkDetl != null && EMPTY_PALLET_MATNR.equalsIgnoreCase(String.valueOf(wrkDetl.getMatnr()).trim())) {
                return true;
            }
        }
        return new ArrayList<>(areaOrder);
        return false;
    }

    private boolean belongsToArea(Integer area, Integer currentCrnNo, LocMast currentLoc) {
        if (area == null || area <= 0) {
            return false;
        }
        RowLastno areaRowLastno = rowLastnoService.selectById(area);
        if (areaRowLastno == null) {
            return false;
        }
        Integer startCrnNo = resolveAreaStartCrnNo(areaRowLastno);
        Integer endCrnNo = resolveAreaEndCrnNo(areaRowLastno, startCrnNo);
        if (currentCrnNo != null && currentCrnNo >= startCrnNo && currentCrnNo <= endCrnNo) {
            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;
    }

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

    /**