#移库规则

lty

2026-01-20 ae6e248abee1211e2c4d0af4a13974d000ca3ab5

#移库规则

 src/main/java/com/zy/asrs/entity/param/LockingCheckResultParam.java

@@ -51,7 +51,7 @@
     * 快速创建成功结果（默认 ASC 方向）
     */
    public static LockingCheckResultParam success(List<LocMast> sortedSelected) {
        return new LockingCheckResultParam(true, "ASC", sortedSelected);
        return new LockingCheckResultParam(true, "DEC", sortedSelected);
    }

    /**

 src/main/java/com/zy/asrs/service/impl/WorkServiceImpl.java

@@ -11,6 +11,7 @@
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.param.*;
import com.zy.asrs.entity.result.FindLocNoAttributeVo;
import com.zy.asrs.entity.result.WrkCancel;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.Utils;
@@ -31,6 +32,7 @@
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;

/**
@@ -254,16 +256,83 @@
            throw new CoolException("分组内未找到目标库位，请检查数据一致性: " + locNo);
        }
    }
    private boolean isInNormalRule(LocMast lm) {
        List<LocGroupOrder> locGroupAscOrder = slaveProperties.getLocGroupAscOrder();
        if (locGroupAscOrder == null || locGroupAscOrder.isEmpty()) {
            return false;
        }
        Integer row = lm.getRow1();
        if (row == null) return false;

        return locGroupAscOrder.stream()
                .anyMatch(group ->
                        group.getRowList() != null &&
                                group.getRowList().contains(row)
                );
    }
    /**
     * 检查正常库位前方是否堵塞（深库位规则：前方排是否有货或入库任务）
     *
     * 只对属于出库分组规则内的库位进行检查
     * 如果库位不在分组规则内，则视为不需要严格检查（返回 false，不触发补齐）
     *
     * @param normalMasts 需要检查的正常库位列表（已通过 isInNormalRule 过滤）
     * @return true = 前方有堵塞（需要补齐），false = 前方清空或无需检查
     */
    private boolean checkDeepLocationBlocked(List<LocMast> normalMasts) {
        if (normalMasts == null || normalMasts.isEmpty()) {
            return false;
        }
        // 获取出库分组配置（用于确认规则范围）
        List<LocGroupOrder> locGroupAscOrder = slaveProperties.getLocGroupAscOrder();
        if (locGroupAscOrder == null || locGroupAscOrder.isEmpty()) {
            return false; // 无配置时默认不检查
        }

        // 遍历每个正常库位
        for (LocMast lm : normalMasts) {
            Integer currentRow = lm.getRow1();
            Integer bay1 = lm.getBay1();
            Integer lev1 = lm.getLev1();

            if (currentRow == null || bay1 == null || lev1 == null) {
                continue;
            }

            // 深库位检查方向：假设 row 越大越深（前方是更大 row 的位置）
            // 你可以根据实际出库方向调整循环条件（例如从小 row 到大 row 或反之）
            for (int row = currentRow + 1; row <= 5; row++) { // 假设深库位范围到 5 排，可调整
                LocMast front = getLocMastByRow(row, bay1, lev1);
                if (front == null) {
                    continue;
                }

                // 有货（F状态） → 堵塞
                if ("F".equals(front.getLocSts())) {
                    return true;
                }

                // 有入库任务 → 堵塞
                WrkMast frontTask = wrkMastService.selectOne(
                        new EntityWrapper<WrkMast>()
                                .eq("source_loc_no", front.getLocNo())
                                .eq("io_type", 100) // 假设 100 为入库类型，可调整
                );
                if (frontTask != null) {
                    return true;
                }
            }
        }

        // 所有正常库位前方都清空（或无前方）
        return false;
    }
    @Override
    @Transactional
    public void stockOut(BasDevp staNo, List<LocDetlDto> locDetlDtos, IoWorkType ioWorkType, Long userId) {
        Date now = new Date();

        // 从配置获取分组（和空板出库保持一致）
        List<LocGroupOrder> locGroupAscOrder = slaveProperties.getLocGroupAscOrder();

        // 合并同类项（相同 locNo 的明细合并）
        // 保留：合并同类项（同一库位合并明细）
        Set<String> locNos = new HashSet<>();
        List<OutLocDto> dtos = new ArrayList<>();
        for (LocDetlDto locDetlDto : locDetlDtos) {
@@ -280,67 +349,106 @@
                dtos.add(new OutLocDto(locNo, locDetlDto));
            }
        }
        // 使用出库专用分组配置
        List<LocGroupOrder> locGroupAscOrder = slaveProperties.getLocGroupAscOrder();
        // 确定正常出库类型（和原来保持类似）
        int ioTypeNormal = 101; // 默认整托出库
        if (ioWorkType != null && ioWorkType.equals(IoWorkType.CHECK_OUT)) {
            ioTypeNormal = 107;
        } else if (!dtos.isEmpty() && !dtos.get(0).isAll()) {
            ioTypeNormal = 103; // 部分出库
        }

        Integer ioType = null;
        // 1. 查询所有选中的库位主信息
        List<LocMast> allSelectedMasts = locMastService.selectList(
                new EntityWrapper<LocMast>().in("loc_no", locNos)
        );

        // 按列和层分组库位（bay + lev）
        Map<String, List<OutLocDto>> locGroups = dtos.stream()
                .collect(Collectors.groupingBy(dto -> {
                    String column = dto.getLocNo().substring(3, 6); // 列号
                    String level = dto.getLocNo().substring(6);     // 层号
                    return column + "-" + level;
                }));
        if (allSelectedMasts.size() != locNos.size()) {
            throw new CoolException("部分选中库位不存在或数据异常");
        }

        // 遍历每组
        for (Map.Entry<String, List<OutLocDto>> entry : locGroups.entrySet()) {
            List<OutLocDto> groupDtos = entry.getValue();
        // 2. 区分正常库位（需要严格深库位检查）与补充库位
        List<LocMast> normalMasts = new ArrayList<>();
        List<LocMast> supplementMasts = new ArrayList<>();

            // 组内优先级重新从100开始（原有逻辑）
            double priority = 100;
        // 假设我们有某种“分组规则”（如按列层或排范围），这里简化用一个示例判断
        // 你可以替换成实际的规则（如 getLocGroupOrderOut() 或其他）
        for (LocMast lm : allSelectedMasts) {
            boolean isNormal = isInNormalRule(lm); // ← 你需要实现这个判断方法
            if (isNormal) {
                normalMasts.add(lm);
            } else {
                supplementMasts.add(lm);
            }
        }

            // 排序组内库位（排号倒序，原有逻辑）
            groupDtos.sort(Comparator.comparing((OutLocDto dto) -> Integer.valueOf(dto.getLocNo().substring(0, 2))).reversed());
        // 3. 对正常库位进行深库位前方检查（类似之前的连续段 + 清空）
        AtomicReference<Boolean> isLeftSideSupplement = new AtomicReference<>(false);

            for (OutLocDto dto : groupDtos) {
                String locNo = dto.getLocNo();
        if (!normalMasts.isEmpty()) {
            // 这里模拟深库位前方检查（你可以替换成你实际的检查方法）
            boolean hasBlockage = checkDeepLocationBlocked(normalMasts);

                // 获取库位信息（提前获取，用于检查和后续使用）
                LocMast locMast = locMastService.selectById(locNo);
                if (Cools.isEmpty(locMast)) {
                    throw new CoolException(locNo + "库位不存在");
            if (hasBlockage) {
                // 前方堵塞 → 自动补充最少一侧
                supplementBothSidesBlocked(normalMasts, locGroupAscOrder, supplementMasts, isLeftSideSupplement);
            }
        }

        // 4. 合并所有要出库的库位
        List<LocMast> allMasts = new ArrayList<>();
        allMasts.addAll(normalMasts);
        allMasts.addAll(supplementMasts);

        if (allMasts.isEmpty()) {
            throw new CoolException("没有有效的出库库位");
        }

        // 5. 统一按排号（row）倒序排序（高排先出）
        List<LocMast> sortedAll = allMasts.stream()
                .sorted(Comparator.comparing(LocMast::getRow1, Comparator.reverseOrder()))
                .collect(Collectors.toList());

        // 6. 生成任务（从后往前遍历）
        double basePriority = 100.0;
        for (int index = sortedAll.size() - 1; index >= 0; index--) {
            LocMast locMast = sortedAll.get(index);
            String locNo = locMast.getLocNo();

            boolean isSupplement = supplementMasts.contains(locMast);
            int ioType = isSupplement ? 11 : ioTypeNormal;
            // 优先级计算
            double priority;
            if (isSupplement) {
                if (Boolean.TRUE.equals(isLeftSideSupplement.get())) {
                    // 左侧补充 → 晚出
                    priority = basePriority - index * 1.0;
                } else {
                    // 右侧补充 → 早出
                    priority = basePriority + index * 1.0;
                }
                if (!locMast.getLocSts().equals("F")) {
                    throw new CoolException(locNo + "托盘非在库状态");
                }

                // =====================================
                // 深库位前方堵塞检查（新逻辑，按分组顺序）
                checkDeepPositionBlocking(locMast, locNo, locGroupAscOrder);
                // =====================================

                // 计算优先级（原有逻辑）
                dto.setPriority(priority);
                priority--;

                // 判断入出库类型
                if (ioWorkType == null) {
                    ioType = dto.isAll() ? 101 : 103;
                } else if (ioWorkType.equals(IoWorkType.CHECK_OUT)) {
                    ioType = 107;
                }
                assert ioType != null;

                Integer outSta = staNo.getDevNo();

                // 获取路径
                StaDesc staDesc = staDescService.queryCrnStn(ioType, locMast.getCrnNo(), outSta);

                // 生成工作号
                int workNo = commonService.getWorkNo(WorkNoType.getWorkNoType(ioType));
                String pick = ioType == 101 ? "N" : "Y";

            } else {
                priority = basePriority - index * 1.0;
            }
            OutLocDto dto;
            Integer outSta = staNo.getDevNo();
            StaDesc staDesc = null;
            if(ioType != 11){
                staDesc = staDescService.queryCrnStn(ioType, locMast.getCrnNo(), outSta);
            }
            LocMast locMastNew = null;
            WrkMast wrkMast = new WrkMast();
            String locSts;
            int workNo = commonService.getWorkNo(WorkNoType.getWorkNoType(ioType));
            String pick = (ioType == 101) ? "N" : "Y";
            if((ioType == 101 || ioType == 103 || ioType == 107) && staDesc != null) {
                // 找到对应的 OutLocDto
                dto = dtos.stream()
                        .filter(d -> d.getLocNo().equals(locNo))
                        .findFirst()
                        .orElseThrow(() -> new CoolException("找不到对应的出库明细：" + locNo));
                // 生成工作档
                WrkMast wrkMast = new WrkMast();
                wrkMast.setWrkNo(workNo);
                wrkMast.setIoTime(now);
                wrkMast.setWrkSts(0L);
@@ -360,11 +468,8 @@
                wrkMast.setAppeTime(now);
                wrkMast.setModiUser(userId);
                wrkMast.setModiTime(now);
                if (!wrkMastService.insert(wrkMast)) {
                    throw new CoolException("保存工作档失败，出库库位号：" + locNo);
                }

                // 生成工作档明细
                locSts = ioType != 101? "R" : "P";
                // 生成工作档明细（保留原逻辑）
                for (LocDetlDto detlDto : dto.getLocDetlDtos()) {
                    if (detlDto.getCount() == null || detlDto.getCount() <= 0.0D) {
                        continue;
@@ -384,19 +489,81 @@
                        throw new CoolException("保存工作档明细失败");
                    }
                }
            }else{
                List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no",locNo));
                FindLocNoAttributeVo findLocNoAttributeVo = new FindLocNoAttributeVo();
                findLocNoAttributeVo.setMatnr(locDetls.get(0).getMatnr());
                findLocNoAttributeVo.setBatch(locDetls.get(0).getBatch());
                LocTypeDto locTypeDto = new LocTypeDto();
                locTypeDto.setLocType1(locMast.getLocType1());
                locMastNew = commonService.searchMaxPallet(findLocNoAttributeVo,locTypeDto);
                // 生成工作档
                wrkMast.setWrkNo(workNo);
                wrkMast.setIoTime(now);
                wrkMast.setWrkSts(0L);
                wrkMast.setIoType(ioType);
                wrkMast.setIoPri(priority);
                wrkMast.setCrnNo(locMast.getCrnNo());
                wrkMast.setSourceStaNo(null);
                wrkMast.setStaNo(null);
                wrkMast.setSourceLocNo(locNo);
                wrkMast.setLocNo(locMastNew.getLocNo());
                wrkMast.setFullPlt("Y");
                wrkMast.setPicking(pick);
                wrkMast.setExitMk("N");
                wrkMast.setEmptyMk("N");
                wrkMast.setLinkMis("N");
                wrkMast.setBarcode(locMast.getBarcode());
                wrkMast.setAppeUser(userId);
                wrkMast.setAppeTime(now);
                wrkMast.setModiUser(userId);
                wrkMast.setModiTime(now);
                locSts = "R";
                // 生成工作档明细（保留原逻辑）
                if(locDetls != null && locDetls.size() > 0) {
                    for (LocDetl locDetl : locDetls) {
                        WrkDetl wrkDetl = new WrkDetl();
                        wrkDetl.sync(locDetl);
                        wrkDetl.setWrkNo(workNo);
                        wrkDetl.setIoTime(now);

                // 修改库位状态
                locMast = locMastService.selectById(locNo);  // 重新获取最新状态
                if (locMast.getLocSts().equals("F")) {
                    locMast.setLocSts(ioType == 101 ? "R" : "P");
                    locMast.setModiUser(userId);
                    locMast.setModiTime(now);
                    if (!locMastService.updateById(locMast)) {
                        throw new CoolException("预约库位状态失败，库位号：" + locNo);
                        wrkDetl.setAppeTime(now);
                        wrkDetl.setAppeUser(userId);
                        wrkDetl.setModiTime(now);
                        wrkDetl.setModiUser(userId);
                        if (!wrkDetlService.insert(wrkDetl)) {
                            throw new CoolException("保存工作档明细失败");
                        }
                    }
                }
            }
            if (!wrkMastService.insert(wrkMast)) {
                throw new CoolException("保存工作档失败，库位：" + locNo);
            }

            if(locMastNew != null){
                if ("O".equals(locMastNew.getLocSts())) {
                    locMastNew.setLocSts("S");
                    locMastNew.setModiUser(userId);
                    locMastNew.setModiTime(now);
                    if (!locMastService.updateById(locMastNew)) {
                        throw new CoolException("更新库位状态失败，库位：" + locNo);
                    }
                } else {
                    throw new CoolException(locNo + "库位不是在库状态");
                    throw new CoolException("库位状态异常，非空板状态：" + locNo);
                }
            }
            // 更新库位状态
            locMast = locMastService.selectById(locNo);
            if ("F".equals(locMast.getLocSts())) {
                locMast.setLocSts(locSts);
                locMast.setModiUser(userId);
                locMast.setModiTime(now);
                if (!locMastService.updateById(locMast)) {
                    throw new CoolException("预约库位状态失败，库位号：" + locNo);
                }
            } else {
                throw new CoolException(locNo + " 库位不是在库状态");
            }
        }
    }
@@ -628,7 +795,7 @@
                }
            }

            // 4. 至少有一侧清空才允许出库
            // 4. 至少有一侧清空才允许出库（修改：放宽，如果两侧都堵，返回特定错误码或继续）
            if (!leftClear && !rightClear) {
                return LockingCheckResultParam.fail(
                        "选中段 " + fullRows.get(minIndex) + "~" + fullRows.get(maxIndex) +
@@ -674,6 +841,83 @@
                .eq("lev1", lev1)
                .eq("row1", row));
    }

    /**
     * 当选中段两侧前方都堵塞时，判断补哪一侧需要的空板最少，并把那些库位加入补充列表
     */
    private void supplementBothSidesBlocked(
            List<LocMast> normalMasts,
            List<LocGroupOrder> locGroupAscOrder,
            List<LocMast> supplementMasts,
    AtomicReference<Boolean> isLeftSideSupplement) {

        // 假设所有 normalMasts 在同一个分组（如果多分组，可循环处理每个分组）
        LocGroupOrder group = locGroupAscOrder.stream()
                .filter(g -> g.getRowList().contains(normalMasts.get(0).getRow1()))
                .findFirst()
                .orElseThrow(() -> new CoolException("分组异常"));

        List<Integer> fullRows = group.getRowList();

        // 取选中段的 min/max row
        Set<Integer> selectedRowSet = normalMasts.stream()
                .map(LocMast::getRow1)
                .collect(Collectors.toSet());

        int minRow = Collections.min(selectedRowSet);
        int maxRow = Collections.max(selectedRowSet);

        int minIndex = fullRows.indexOf(minRow);
        int maxIndex = fullRows.indexOf(maxRow);

        // 假设所有库位在同 bay 和 lev
        Integer bay1 = normalMasts.get(0).getBay1();
        Integer lev1 = normalMasts.get(0).getLev1();

        // 计算左侧前方需要补充的 D 状态库位数量（从 0 到 minIndex-1 的 D 状态库位）
        int leftSupplementCount = 0;
        List<LocMast> leftSupplementLocs = new ArrayList<>();
        for (int i = 0; i < minIndex; i++) {
            LocMast loc = getLocMastByRow(fullRows.get(i), bay1, lev1);
            if (loc != null && "D".equals(loc.getLocSts())) {
                leftSupplementCount++;
                leftSupplementLocs.add(loc);
            }
        }

        // 计算右侧前方需要补充的 D 状态库位数量（从 maxIndex+1 到 end 的 D 状态库位）
        int rightSupplementCount = 0;
        List<LocMast> rightSupplementLocs = new ArrayList<>();
        for (int i = maxIndex + 1; i < fullRows.size(); i++) {
            LocMast loc = getLocMastByRow(fullRows.get(i), bay1, lev1);
            if (loc != null && "D".equals(loc.getLocSts())) {
                rightSupplementCount++;
                rightSupplementLocs.add(loc);
            }
        }

        // 选择需要补充最少的一侧（如果相等，优先左侧）
        List<LocMast> chosenSupplementLocs;
        boolean isLeft = false;
        if (leftSupplementCount <= rightSupplementCount) {
            chosenSupplementLocs = leftSupplementLocs;
            isLeft = true;
            log.info("选择补充左侧前方，共 {} 个库位", leftSupplementCount);
        } else {
            chosenSupplementLocs = rightSupplementLocs;
            isLeft = false;
            log.info("选择补充右侧前方，共 {} 个库位", rightSupplementCount);
        }
        // 记录选择的侧
        isLeftSideSupplement.set(isLeft);
        // 添加到 supplementMasts（避免重复添加）
        for (LocMast supp : chosenSupplementLocs) {
            if (!supplementMasts.contains(supp) && !normalMasts.contains(supp)) {
                supplementMasts.add(supp);
            }
        }
    }

    @Override
    @Transactional
    public void emptyPlateOut(EmptyPlateOutParam param, Long userId) {
@@ -681,30 +925,83 @@
            throw new CoolException("站点不存在");
        }

        // 使用新的出库专用分组配置
        // 使用出库专用分组配置
        List<LocGroupOrder> locGroupAscOrder = slaveProperties.getLocGroupAscOrderOut();

        // 1. 先进行整体阻塞检查（包含连续性 + 双向前方清空校验）
        LockingCheckResultParam checkResult = checkEmptyPlateBlocking(param.getLocNos(), locGroupAscOrder);
        // 1. 查询所有选中的库位信息
        List<LocMast> selectedMasts = locMastService.selectList(
                new EntityWrapper<LocMast>().in("loc_no", param.getLocNos())
        );

        if (!checkResult.isSuccess()) {
            throw new CoolException(checkResult.getErrorMessage());
        if (selectedMasts.size() != param.getLocNos().size()) {
            throw new CoolException("部分选中库位不存在或数据异常");
        }

        // 2. 获取按出库方向排序好的库位列表
        List<LocMast> orderedLocMasts = checkResult.getSortedSelected();
        // 2. 区分正常分组内的库位 和 需要补充的库位（规则外的）
        List<LocMast> normalMasts = new ArrayList<>();
        List<LocMast> supplementMasts = new ArrayList<>();
        for (LocMast lm : selectedMasts) {
            boolean inAnyGroup = locGroupAscOrder.stream()
                    .anyMatch(g -> g.getRowList().contains(lm.getRow1()));
            if (inAnyGroup) {
                normalMasts.add(lm);
            } else {
                supplementMasts.add(lm);
            }
        }
        // 新增：记录是否因为左侧前方被补充
        AtomicReference<Boolean> isLeftSideSupplement = new AtomicReference<>(false);
        // 3. 对正常分组内的库位进行检查（放宽两侧堵塞规则）
        if (!normalMasts.isEmpty()) {
            List<String> normalLocNos = normalMasts.stream()
                    .map(LocMast::getLocNo)
                    .collect(Collectors.toList());

        // 3. 优先级基础参数（数值越大优先级越高）
        double BASE_PRI = 10.0;          // 最低优先级组基准（数值最大）
        double GROUP_STEP = 100.0;       // 组间差距
        double IN_GROUP_STEP = 1.0;      // 组内位置差距
            LockingCheckResultParam checkResult = checkEmptyPlateBlocking(
                    normalLocNos,
                    locGroupAscOrder
            );

            if (!checkResult.isSuccess()) {
                String errMsg = checkResult.getErrorMessage();
                if (errMsg.contains("两侧前方都有空板/故障")) {
                    // 两侧都堵 → 进入补齐逻辑
                    supplementBothSidesBlocked(normalMasts, locGroupAscOrder, supplementMasts, isLeftSideSupplement);
                } else {
                    // 其他错误（如不连续、非D状态）抛出
                    throw new CoolException(errMsg);
                }
            }
            // 如果有一侧清空，则正常继续
        }

        // 4. 合并所有库位（正常 + 补充的，包括规则外的和前方补的）
        List<LocMast> allMasts = new ArrayList<>();
        allMasts.addAll(normalMasts);
        allMasts.addAll(supplementMasts);

        if (allMasts.isEmpty()) {
            throw new CoolException("没有有效的空板库位可出库");
        }

        // 5. 统一按 row → bay → lev 排序（从小到大）
        List<LocMast> sortedAll = allMasts.stream()
                .sorted(Comparator.comparing(LocMast::getRow1)
                        .thenComparing(LocMast::getBay1)
                        .thenComparing(LocMast::getLev1))
                .collect(Collectors.toList());

        Date now = new Date();

        // 4. 逐个处理排序后的库位，生成出库任务
        for (int index = orderedLocMasts.size(); index > 0; index--) {
            LocMast locMast = orderedLocMasts.get(index);
        // 6. 按排序后的顺序生成出库任务（从后往前生成）
        for (int index = 0; index <sortedAll.size() ; index ++) {
            LocMast locMast = sortedAll.get(index);
            String locNo = locMast.getLocNo();

            // 判断是否为补充库位（规则外的 或 前方补的）
            boolean isSupplement = supplementMasts.contains(locMast);

            int ioType = isSupplement ? 11 : 110;

            // 获取工作号
            int workNo = commonService.getWorkNo(WorkNoType.PAKOUT.type);
@@ -715,58 +1012,86 @@
                    .eq("stn_no", param.getOutSite())
                    .eq("crn_no", locMast.getCrnNo());
            StaDesc staDesc = staDescService.selectOne(wrapper);
            Integer sourceStaNo = staDesc.getCrnStn();
            Integer sourceStaNo = staDesc != null ? staDesc.getCrnStn() : null;

            if (Cools.isEmpty(sourceStaNo)) {
                throw new CoolException("检索源站失败，库位：" + locNo);
            }

            // 计算动态优先级（组优先级 + 组内顺序偏移）
            // 这里假设所有选中的库位在同一个分组（多分组可再细分）
            int groupIndex = locGroupAscOrder.indexOf(
                    locGroupAscOrder.stream()
                            .filter(g -> g.getRowList().contains(locMast.getRow1()))
                            .findFirst()
                            .orElse(null)
            );

            if (groupIndex == -1) {
                throw new CoolException("分组索引异常: " + locNo);
            }

            double groupBasePri = BASE_PRI + (locGroupAscOrder.size() + 1 - groupIndex) * GROUP_STEP;

            // 组内偏移：按出库顺序（index越小越先出，优先级越高 → 数值越大）
            // 如果是 DESC 方向，index 已经是倒序的，所以直接用
            double inGroupOffset = index * IN_GROUP_STEP;

            double ioPri = groupBasePri + inGroupOffset;  // 数值越大优先级越高

            // 生成工作档
            // 计算优先级（示例：补充的优先级稍低）
            double BASE_PRI = 200.0;
            double ioPri;
            WrkMast wrkMast = new WrkMast();
            wrkMast.setWrkNo(workNo);
            wrkMast.setIoTime(now);
            wrkMast.setWrkSts(0L);           // 待发送
            wrkMast.setIoType(110);          // 空板出库
            wrkMast.setIoPri(ioPri);
            wrkMast.setSourceStaNo(sourceStaNo);
            wrkMast.setStaNo(param.getOutSite());
            wrkMast.setCrnNo(locMast.getCrnNo());
            wrkMast.setSourceLocNo(locNo);
            wrkMast.setFullPlt("N");
            wrkMast.setPicking("N");
            wrkMast.setExitMk("N");
            wrkMast.setEmptyMk("Y");
            wrkMast.setLinkMis("N");
            wrkMast.setAppeUser(userId);
            wrkMast.setAppeTime(now);
            wrkMast.setModiUser(userId);
            wrkMast.setModiTime(now);
            LocMast locMastNew = null;
            if(isSupplement){
                // 补充的库位：根据是左侧还是右侧补充，决定优先级方向
                if (Boolean.TRUE.equals(isLeftSideSupplement.get())) {
                    // 左侧补充 → 优先级较低（晚出）
                    ioPri = BASE_PRI - index * 1.0;
                } else {
                    // 右侧补充 → 优先级较高（早出）
                    ioPri = BASE_PRI + index * 1.0;
                }
                locMastNew = commonService.searchEmptyPallet(null);
                wrkMast.setWrkNo(workNo);
                wrkMast.setIoTime(now);
                wrkMast.setWrkSts(0L);
                wrkMast.setIoType(ioType);
                wrkMast.setIoPri(ioPri);
                wrkMast.setSourceStaNo(null);
                wrkMast.setLocNo(locMastNew.getLocNo());
                wrkMast.setStaNo(null);
                wrkMast.setCrnNo(locMast.getCrnNo());
                wrkMast.setSourceLocNo(locNo);
                wrkMast.setFullPlt("N");
                wrkMast.setPicking("N");
                wrkMast.setExitMk("N");
                wrkMast.setEmptyMk("Y");
                wrkMast.setLinkMis("N");
                wrkMast.setAppeUser(userId);
                wrkMast.setAppeTime(now);
                wrkMast.setModiUser(userId);
                wrkMast.setModiTime(now);
            }else{
                ioPri = BASE_PRI + index * 1.0;
                wrkMast.setWrkNo(workNo);
                wrkMast.setIoTime(now);
                wrkMast.setWrkSts(0L);
                wrkMast.setIoType(ioType);
                wrkMast.setIoPri(ioPri);
                wrkMast.setSourceStaNo(sourceStaNo);
                wrkMast.setStaNo(param.getOutSite());
                wrkMast.setCrnNo(locMast.getCrnNo());
                wrkMast.setSourceLocNo(locNo);
                wrkMast.setFullPlt("N");
                wrkMast.setPicking("N");
                wrkMast.setExitMk("N");
                wrkMast.setEmptyMk("Y");
                wrkMast.setLinkMis("N");
                wrkMast.setAppeUser(userId);
                wrkMast.setAppeTime(now);
                wrkMast.setModiUser(userId);
                wrkMast.setModiTime(now);
            }

            if (!wrkMastService.insert(wrkMast)) {
                throw new CoolException("保存工作档失败，库位：" + locNo);
            }

            // 更新库位状态 D → R（出库预约）
            if(locMastNew != null){
                if ("O".equals(locMastNew.getLocSts())) {
                    locMastNew.setLocSts("S");
                    locMastNew.setModiUser(userId);
                    locMastNew.setModiTime(now);
                    if (!locMastService.updateById(locMastNew)) {
                        throw new CoolException("更新库位状态失败，库位：" + locNo);
                    }
                } else {
                    throw new CoolException("库位状态异常，非空板状态：" + locNo);
                }
            }

            // 更新库位状态 D → R
            if ("D".equals(locMast.getLocSts())) {
                locMast.setLocSts("R");
                locMast.setModiUser(userId);
@@ -1135,7 +1460,7 @@
        } else if (wrkMast.getIoType() > 100 && wrkMast.getWrkSts() != 14) {
            locNo = wrkMast.getSourceLocNo();
            // 出库 ===>> F.在库
            if (wrkMast.getIoType() == 101 || wrkMast.getIoType() == 103) {
            if (wrkMast.getIoType() == 101 || wrkMast.getIoType() == 103 || wrkMast.getIoType() == 107) {
                locSts = "F";
            // 空板出库 ===>> D.空桶/空栈板
            } else if (wrkMast.getIoType() == 110) {

 src/main/java/com/zy/asrs/task/handler/WCSReportHandler.java

@@ -40,6 +40,7 @@
    private String outDevp;
    @Value("${wcs-slave.warehouse}")
    private String warehouse;
    static String namespace = null;
    @Autowired
    private ApiLogService apiLogService;
    @Autowired
@@ -53,7 +54,7 @@
        String groupId = dateFormat.format(date)+"-"+i;
        workIssuedResult.setGroupId(groupId);//组号
        workIssuedResult.setMsgTime(dateFormat.format(date));
        workIssuedResult.setWarehouse("aryd");
        workIssuedResult.setWarehouse("ZYNMG");

        List<WorkIssuedResult.Tasks> tasks = new ArrayList<>();
        WorkIssuedResult.Tasks task = new WorkIssuedResult.Tasks();
@@ -68,38 +69,54 @@
            workIssuedResult.setPriorityCode(14);//优先级
            task.setTaskType(0);//入库
            task.setStartNode(inDevp);
            LocNo = Utils.getLocNo(Utils.getRow(wrkMast.getLocNo()),Utils.getBay(wrkMast.getLocNo()),Utils.getLev(wrkMast.getLocNo()));
            LocNo = Utils.getLocNoToWcs(Utils.getRow(wrkMast.getLocNo()),Utils.getBay(wrkMast.getLocNo()),Utils.getLev(wrkMast.getLocNo()));
            task.setEndNode(LocNo);//目标库位

            task.setCargoSize(null);
            switch (wrkMast.getIoType()){
                case 1: namespace= "全板入库下发";break;
                case 53: namespace= "拣料再入库下发";break;
                case 57: namespace= "盘点再入库下发";break;
            }

        }else if(wrkMast.getIoType() == 10 ){//空板入库
            workIssuedResult.setPriorityCode(12);//优先级
            task.setTaskType(0);//入库
            task.setStartNode(inDevp);
            LocNo = Utils.getLocNo(Utils.getRow(wrkMast.getLocNo()),Utils.getBay(wrkMast.getLocNo()),Utils.getLev(wrkMast.getLocNo()));
            LocNo = Utils.getLocNoToWcs(Utils.getRow(wrkMast.getLocNo()),Utils.getBay(wrkMast.getLocNo()),Utils.getLev(wrkMast.getLocNo()));
            task.setEndNode(LocNo);//目标库位
            task.setCargoSize(null);
            namespace = "空板入库";

        }else if(wrkMast.getIoType() == 101 || wrkMast.getIoType() == 103 || wrkMast.getIoType() == 107){//出库
            workIssuedResult.setPriorityCode(15);//优先级
            task.setTaskType(1);//出库
            sourceLocNo = Utils.getLocNo(Utils.getRow(wrkMast.getSourceLocNo()),Utils.getBay(wrkMast.getSourceLocNo()),Utils.getLev(wrkMast.getSourceLocNo()));
            sourceLocNo = Utils.getLocNoToWcs(Utils.getRow(wrkMast.getSourceLocNo()),Utils.getBay(wrkMast.getSourceLocNo()),Utils.getLev(wrkMast.getSourceLocNo()));
            task.setStartNode(sourceLocNo);//源库位
            task.setEndNode(outDevp);
            task.setCargoSize(null);
            switch (wrkMast.getIoType()){
                case 101: namespace= "全板出库下发";break;
                case 103: namespace= "拣料出库下发";break;
                case 107: namespace= "盘点出库下发";break;
            }

        }else if(wrkMast.getIoType() == 11){//移库
            workIssuedResult.setPriorityCode(11);//优先级
            task.setTaskType(2);//移库
            sourceLocNo = Utils.getLocNo(Utils.getRow(wrkMast.getSourceLocNo()),Utils.getBay(wrkMast.getSourceLocNo()),Utils.getLev(wrkMast.getSourceLocNo()));
            LocNo = Utils.getLocNo(Utils.getRow(wrkMast.getLocNo()),Utils.getBay(wrkMast.getLocNo()),Utils.getLev(wrkMast.getLocNo()));
            sourceLocNo = Utils.getLocNoToWcs(Utils.getRow(wrkMast.getSourceLocNo()),Utils.getBay(wrkMast.getSourceLocNo()),Utils.getLev(wrkMast.getSourceLocNo()));
            LocNo = Utils.getLocNoToWcs(Utils.getRow(wrkMast.getLocNo()),Utils.getBay(wrkMast.getLocNo()),Utils.getLev(wrkMast.getLocNo()));
            task.setStartNode(sourceLocNo);//源库位
            task.setEndNode(LocNo);//目标库位

            task.setCargoSize(null);
            namespace = "移库下发";
        } else {//空板出库
            workIssuedResult.setPriorityCode(13);//优先级
            task.setTaskType(1);//出库
            sourceLocNo = Utils.getLocNo(Utils.getRow(wrkMast.getSourceLocNo()),Utils.getBay(wrkMast.getSourceLocNo()),Utils.getLev(wrkMast.getSourceLocNo()));
            sourceLocNo = Utils.getLocNoToWcs(Utils.getRow(wrkMast.getSourceLocNo()),Utils.getBay(wrkMast.getSourceLocNo()),Utils.getLev(wrkMast.getSourceLocNo()));
            task.setStartNode(sourceLocNo);//源库位
            task.setEndNode(outDevp);
            task.setCargoSize(null);
            namespace = "空板出库下发";
        }
        tasks.add(task);
        workIssuedResult.setTasks(tasks);
@@ -118,7 +135,7 @@
                wrkMast.setWrkSts(1L);
                wrkMastService.updateById(wrkMast);
            } else {
                log.error("wms下发任务给wcs失败！！！url：{}；request：{}；response：{}", url+"/"+workIssued, JSON.toJSONString(workIssuedResult), response);
                log.error("{}}下发任务给wcs失败！！！url：{}；request：{}；response：{}",namespace, url+"/"+workIssued, JSON.toJSONString(workIssuedResult), response);
                throw new CoolException("wms下发任务给wcs失败");
            }
        } catch (Exception e) {
@@ -129,7 +146,7 @@
            try {
                // 保存接口日志
                apiLogService.save(
                        "wms下发任务给wcs",
                        namespace,
                        url+"/"+workIssued,
                        null,
                        "127.0.0.1",

 src/main/java/com/zy/common/web/WcsController.java

@@ -85,8 +85,8 @@
        if (Cools.isEmpty(param.getCargoHeight())) {
            return Re.error("高低库类型不能为空");
        }
        if (Cools.isEmpty(param.getFromPort())) {
            return Re.error("源站编号不能为空");
        if (Cools.isEmpty(param.getFromPort()) && !param.getFromPort().equals("1001")) {
            return Re.error("入库站点编号错误:"+param.getFromPort());
        }
        if(Cools.isEmpty(param.getWarehouse())){
            return Re.error("仓库编号不能为空");
@@ -95,12 +95,24 @@
            return Re.error("仓库编号不匹配");
        }
        List<WaitPakin> waitPakins = null;
        if (param.getFromPort().equals("101")) {

        WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("barcode", param.getBarCode()));

        if(wrkMast != null && (wrkMast.getIoType() == 103 || wrkMast.getIoType() == 107)){
            switch (wrkMast.getIoType()){
                case 103:param.setIoType(103);break;//拣料
                case 107:param.setIoType(107);break;//盘点
            }
        }else{
            //全板入库
            param.setIoType(1);
        }
        if (param.getFromPort().equals("1001") && param.getIoType()!=103 && param.getIoType() != 107) {

            //有空板出库时禁止入库
            int wrkCount = wrkMastService.selectCount(new EntityWrapper<WrkMast>().eq("io_type", 110).eq("sta_no", 100).notIn("wrk_sts", 7));
            int wrkCount = wrkMastService.selectCount(new EntityWrapper<WrkMast>().eq("io_type", 110).eq("sta_no", 1001).notIn("wrk_sts", 7));
            if(wrkCount > 0){
                return Re.error("有空板出库到100站时时禁止入库");
                return Re.error("有空板出库到1001站时时禁止入库");
            }

            if (Cools.isEmpty(param.getBarCode())) {
@@ -108,7 +120,7 @@
            }
            waitPakins = waitPakinService.selectList(new EntityWrapper<WaitPakin>().eq("zpallet", param.getBarCode()));
            if (Cools.isEmpty(waitPakins)) {
                WrkMast wrkMast = wrkMastService.selectByBarcode(param.getBarCode());
//                WrkMast wrkMast = wrkMastService.selectByBarcode(param.getBarCode());
                if (wrkMast != null && wrkMast.getIoType() == 103) {
                    return Re.parse(CodeRes.PICK_600);
                }
@@ -121,7 +133,7 @@
            }
        } else {
            //有满板出库时禁止空板入库
            int wrkCount = wrkMastService.selectCount(new EntityWrapper<WrkMast>().eq("sta_no", 100).andNew().eq("io_type", 101).or().eq("io_type", 110));
            int wrkCount = wrkMastService.selectCount(new EntityWrapper<WrkMast>().eq("sta_no", 1001).andNew().eq("io_type", 101).or().eq("io_type", 110));
            if (wrkCount > 0) {
                return Re.error("有满板出库时禁止空板入库");
            }
@@ -140,6 +152,9 @@

        // 源站点状态检测
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(Integer.valueOf(param.getFromPort()), true);
        if(sourceStaNo == null){
            return Re.error("站点不存在");
        }
        sourceStaNo.setLocType1(param.getCargoHeight().shortValue()); // 高低库位
//        if (param.getBarCode().startsWith("7")){
//            sourceStaNo.setLocType2((short) 1); // 宽窄库位 1.窄库位1200*1000*990
@@ -150,17 +165,14 @@

        StartupDto dto = null;

        //全板入库
        param.setIoType(1);

        switch (param.getIoType()) {
            case 1://满托盘入库
                assert waitPakins != null;
                dto = startupFullPutStore(Integer.valueOf(param.getFromPort()), param.getBarCode(), locTypeDto, waitPakins);
                break;
//            case 10://空托盘入库
//                dto = emptyPlateIn(Integer.valueOf(param.getFromPort()), locTypeDto, param.getBarCode());
//                break;
            case 103:startupFullPutStore103(Integer.valueOf(param.getFromPort()), param.getBarCode(), locTypeDto, wrkMast);break;
            case 107:startupFullPutStore107(Integer.valueOf(param.getFromPort()), param.getBarCode(), locTypeDto, wrkMast);break;
            default:
                break;
        }
@@ -179,9 +191,10 @@
            return Re.error("仓库编号不匹配");
        }

        // 源站点状态检测
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(Integer.valueOf(param.getFromPort()), true);
        LocTypeDto locTypeDto = new LocTypeDto(sourceStaNo);
//        // 源站点状态检测
//        BasDevp sourceStaNo = basDevpService.checkSiteStatus(Integer.valueOf(param.getFromPort()), true);
        LocTypeDto locTypeDto = new LocTypeDto();
        locTypeDto.setLocType1((short) 2);

        StartupDto dto = null;

@@ -374,6 +387,147 @@
        return dto;
    }

    /**
     * 盘点入库
     */
    @Transactional
    public StartupDto startupFullPutStore107(Integer devpNo, String barcode, LocTypeDto locTypeDto, WrkMast wrkMast) {
        // 源站点状态检测
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(devpNo, true);
        FindLocNoAttributeVo findLocNoAttributeVo = new FindLocNoAttributeVo();
        List<WrkDetl> wrkDetlList = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
        WrkDetl wrkDetl = wrkDetlList.get(0);
        findLocNoAttributeVo.setMatnr(wrkDetl.getMatnr());
        findLocNoAttributeVo.setBatch(wrkDetl.getBatch());
//        StartupDto dto = commonService.getLocNo(1, devpNo, matnrs.get(0), batchs.get(0), null, locTypeDto);
        StartupDto dto = commonService.getLocNoNew(1, devpNo, findLocNoAttributeVo, locTypeDto,barcode);
        if (dto == null) {
            throw new CoolException("没有检索到空库位");
        }
        Date now = new Date();
        // 生成工作档
        try{
            // 保存工作明细档历史档
            if (wrkMastMapper.saveWrkDetlLog(wrkMast.getWrkNo()) == 0) {
                throw new CoolException("保存工作明细档历史档失败");
            }
            // 保存工作主档历史档
            if (wrkMastMapper.saveWrkMastLog(wrkMast.getWrkNo()) == 0) {
                throw new CoolException("保存工作主档历史档失败");
            }
            // 更新工作档数据状态
            wrkMast.setIoTime(now);
            wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
            wrkMast.setWrkSts(0L); // 工作状态: 2.设备上走
            wrkMast.setSourceStaNo(wrkMast.getStaNo()); // 源站
            wrkMast.setStaNo(dto.getStaNo()); // 目标站
            wrkMast.setLocNo(dto.getLocNo()); // 目标库位 = 出库时的源库位
            wrkMast.setSourceLocNo(""); // 源库位清空
            wrkMast.setModiTime(now);
            wrkMast.setMk("N");//是否完成上报wcs
            // 操作人员数据
            wrkMast.setAppeTime(now);
            wrkMast.setModiTime(now);
            if (wrkMastMapper.updateById(wrkMast) == 0) {
                throw new CoolException("更新工作档数据状态失败");
            }
            // 更新明细档io_time (历史档关联使用）
            wrkDetlService.updateIoTime(wrkMast.getWrkNo(), now);
            // 更新源站点信息
            sourceStaNo.setWrkNo(wrkMast.getWrkNo());
            sourceStaNo.setModiTime(now);
            if (!basDevpService.updateById(sourceStaNo)) {
                throw new CoolException("更新源站失败");
            }
            // 更新目标库位状态
            LocMast locMast = locMastService.selectById(dto.getLocNo());
            if (locMast.getLocSts().equals("O")) {
                locMast.setLocSts("Q"); // S.入库预约
                locMast.setModiTime(now);
                if (!locMastService.updateById(locMast)) {
                    throw new CoolException("改变库位状态失败");
                }
            } else {
                throw new CoolException(dto.getLocNo() + "目标库位已被占用");
            }
        } catch (Exception e) {
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
        return dto;
    }


    /**
     * 盘点入库
     */
    @Transactional
    public StartupDto startupFullPutStore103(Integer devpNo, String barcode, LocTypeDto locTypeDto, WrkMast wrkMast) {
        // 源站点状态检测
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(devpNo, true);
        FindLocNoAttributeVo findLocNoAttributeVo = new FindLocNoAttributeVo();
        List<WrkDetl> wrkDetlList = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast.getWrkNo()));
        WrkDetl wrkDetl = wrkDetlList.get(0);
        findLocNoAttributeVo.setMatnr(wrkDetl.getMatnr());
        findLocNoAttributeVo.setBatch(wrkDetl.getBatch());
//        StartupDto dto = commonService.getLocNo(1, devpNo, matnrs.get(0), batchs.get(0), null, locTypeDto);
        StartupDto dto = commonService.getLocNoNew(1, devpNo, findLocNoAttributeVo, locTypeDto,barcode);
        if (dto == null) {
            throw new CoolException("没有检索到空库位");
        }
        Date now = new Date();
        // 生成工作档
        try{
            // 保存工作明细档历史档
            if (wrkMastMapper.saveWrkDetlLog(wrkMast.getWrkNo()) == 0) {
                throw new CoolException("保存工作明细档历史档失败");
            }
            // 保存工作主档历史档
            if (wrkMastMapper.saveWrkMastLog(wrkMast.getWrkNo()) == 0) {
                throw new CoolException("保存工作主档历史档失败");
            }
            // 更新工作档数据状态
            wrkMast.setIoTime(now);
            wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
            wrkMast.setWrkSts(0L); // 工作状态: 2.设备上走
            wrkMast.setSourceStaNo(wrkMast.getStaNo()); // 源站
            wrkMast.setStaNo(dto.getStaNo()); // 目标站
            wrkMast.setLocNo(dto.getLocNo()); // 目标库位 = 出库时的源库位
            wrkMast.setSourceLocNo(""); // 源库位清空
            wrkMast.setModiTime(now);
            wrkMast.setMk("N");//是否完成上报wcs
            // 操作人员数据
            wrkMast.setAppeTime(now);
            wrkMast.setModiTime(now);
            if (wrkMastMapper.updateById(wrkMast) == 0) {
                throw new CoolException("更新工作档数据状态失败");
            }
            // 更新明细档io_time (历史档关联使用）
            wrkDetlService.updateIoTime(wrkMast.getWrkNo(), now);
            // 更新源站点信息
            sourceStaNo.setWrkNo(wrkMast.getWrkNo());
            sourceStaNo.setModiTime(now);
            if (!basDevpService.updateById(sourceStaNo)) {
                throw new CoolException("更新源站失败");
            }
            // 更新目标库位状态
            LocMast locMast = locMastService.selectById(dto.getLocNo());
            if (locMast.getLocSts().equals("O")) {
                locMast.setLocSts("Q"); // S.入库预约
                locMast.setModiTime(now);
                if (!locMastService.updateById(locMast)) {
                    throw new CoolException("改变库位状态失败");
                }
            } else {
                throw new CoolException(dto.getLocNo() + "目标库位已被占用");
            }
        } catch (Exception e) {
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
        return dto;
    }

    @Transactional
    public StartupDto emptyPlateIn(Integer devpNo, LocTypeDto locTypeDto) {
        // 源站点状态检测
@@ -445,46 +599,8 @@
         * 任务中断,4-放货
         * 完成,8-任务结束
         */

        if (statusParam.getTaskStatus() == 0) {
            //拣料和盘点再入库判断
            if ((wrkMast.getIoType() == 103 || wrkMast.getIoType() == 107) && wrkMast.getWrkSts() == 14) {
                List<WrkDetl> wrkDetls = wrkDetlService.selectByWrkNo(wrkMast.getWrkNo());
                String sourcecLocNo = wrkMast.getSourceLocNo();
                // 获取后两位的层数（高低库位数据）
                String layerStr = sourcecLocNo.substring(sourcecLocNo.length() - 2);
                int layer = Integer.parseInt(layerStr);
                // 判断层数
                Short locType1 = (short) ((layer == 1) ? 1 : 2);
                LocTypeDto locTypeDto = new LocTypeDto();
                locTypeDto.setLocType1(locType1);
                //注意一个板只能放同一种物料（检索新库位）
//                StartupDto dto = commonService.getLocNoRunPick(4, 1, 101, wrkDetls.get(0).getMatnr(), wrkDetls.get(0).getBatch(), null, 4, locTypeDto, 2);
                FindLocNoAttributeVo findLocNoAttributeVo = new FindLocNoAttributeVo();
                findLocNoAttributeVo.setMatnr(wrkDetls.get(0).getMatnr());
                StartupDto dto = commonService.getLocNoNew(1, 101, findLocNoAttributeVo,locTypeDto,null);
                Date now = new Date();
                wrkMast.setIoTime(now);
                wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
                wrkMast.setWrkSts(1L);//1.已接收
                wrkMast.setSourceStaNo(101); // 源站
                wrkMast.setStaNo(null); // 目标站
                wrkMast.setLocNo(dto.getLocNo()); // 目标库位
                wrkMast.setSourceLocNo(sourcecLocNo);
                wrkMast.setModiTime(now);
                wrkDetlService.updateIoTime(wrkMast.getWrkNo(), now);

                // 修改库位状态 Q.拣料/盘点/并板再入库
                LocMast locMast2 = locMastService.selectById(dto.getLocNo());
                locMast2.setLocSts("Q");
                locMast2.setModiTime(new Date());
                if (!locMastService.updateById(locMast2)) {

                    throw new CoolException("修改库位状态失败");
                }
            } else {
                wrkMast.setWrkSts(1L);//1.已接收
            }
            wrkMast.setWrkSts(1L);//1.已接收
        } else if (statusParam.getTaskStatus() == 1) {
            wrkMast.setWrkSts(2L);//2.任务开始
        } else if (statusParam.getTaskStatus() == 2) {
@@ -523,21 +639,21 @@
            } else if ((wrkMast.getIoType() == 101 || wrkMast.getIoType() == 110) && statusParam.getTaskStatus() != 8) {
                wrkMast.setWrkSts(7L);//7.出库完成
            } else if (wrkMast.getWrkSts() == 7 && statusParam.getTaskStatus() == 8){
                wrkMast.setWrkSts(15L);//15.出库更新完成，任务结束
                wrkMast.setWrkSts(14L);//15.出库更新完成，任务结束
            }
        }
        wrkMastService.updateById(wrkMast);
        //已入库未确认历史档更新
        if(wrkMast.getWrkSts() == 14){
            // 保存工作主档历史档
            if (!wrkMastLogService.save(wrkMast.getWrkNo())) {
                throw new CoolException("保存工作历史档失败");
            }
            // 保存工作明细档历史档
            if (!wrkDetlLogService.save(wrkMast.getWrkNo())) {
                throw new CoolException("保存工作明细历史档失败");
            }
        }
//        //已入库未确认历史档更新
//        if(wrkMast.getWrkSts() == 14 && (wrkMast.getIoType() == 103 || wrkMast.getIoType() == 107)){
//            // 保存工作主档历史档
//            if (!wrkMastLogService.save(wrkMast.getWrkNo())) {
//                throw new CoolException("保存工作历史档失败");
//            }
//            // 保存工作明细档历史档
//            if (!wrkDetlLogService.save(wrkMast.getWrkNo())) {
//                throw new CoolException("保存工作明细历史档失败");
//            }
//        }
        return Re.ok();
    }

@@ -548,7 +664,7 @@
        for (LocMast locMast : locMasts) {
            if (locMast.getLocSts() != "X" && locMast.getLocSts() != "G" ) {
                HashMap<String, Object> map = new HashMap<>();
                map.put("warehouse", "aryd");
                map.put("warehouse", "ddth");
                map.put("posiX", locMast.getRow1());
                map.put("posiY", locMast.getBay1());
                map.put("posiZ", locMast.getLev1());
@@ -562,7 +678,7 @@
            }
            if(locMast.getLocSts() == "G"){
                HashMap<String, Object> map = new HashMap<>();
                map.put("warehouse", "aryd");
                map.put("warehouse", "ddth");
                map.put("posiX", locMast.getRow1());
                map.put("posiY", locMast.getBay1());
                map.put("posiZ", locMast.getLev1());
@@ -572,7 +688,7 @@
            }
            if(locMast.getLocSts() == "X"){
                HashMap<String, Object> map = new HashMap<>();
                map.put("warehouse", "aryd");
                map.put("warehouse", "ddth");
                map.put("posiX", locMast.getRow1());
                map.put("posiY", locMast.getBay1());
                map.put("posiZ", locMast.getLev1());