RCS入库流程优化

chen.lin

8 小时以前 f574055ed80a64cbccd601b200afc437a87b52eb

 rsf-server/src/main/java/com/vincent/rsf/server/api/service/impl/WcsServiceImpl.java

@@ -150,6 +150,7 @@

        // 设置工作单号并返回
        locNo.setWorkNo(ruleCode);
        locNo.setTaskId(task.getId());
        return locNo;
    }

@@ -174,7 +175,7 @@
    private WaitPakin validateWaitPakin(String barcode) {
        WaitPakin waitPakin = waitPakinService.getOne(new LambdaQueryWrapper<WaitPakin>()
                .eq(WaitPakin::getBarcode, barcode)
                .eq(WaitPakin::getIoStatus, PakinIOStatus.PAKIN_IO_STATUS_DONE.val));
                .in(WaitPakin::getIoStatus, PakinIOStatus.PAKIN_IO_STATUS_DONE.val, PakinIOStatus.PAKIN_IO_STATUS_TASK_EXCE.val));

        if (Cools.isEmpty(waitPakin)) {
            throw new CoolException("请检查组拖状态是否完成！！");
@@ -231,13 +232,30 @@

    /**
     * 获取并验证组拖明细
     * 只返回未完全使用的明细（workQty < anfme 或 workQty 为 null）
     */
    private List<WaitPakinItem> getWaitPakinItems(Long pakinId) {
        List<WaitPakinItem> waitPakinItems = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>().eq(WaitPakinItem::getPakinId, pakinId));
        List<WaitPakinItem> waitPakinItems = waitPakinItemService.list(new LambdaQueryWrapper<WaitPakinItem>()
                .eq(WaitPakinItem::getPakinId, pakinId));
        
        if (waitPakinItems.isEmpty()) {
            throw new CoolException("数据错误：组拖明细不存在");
        }
        return waitPakinItems;
        
        // 过滤掉已完全使用的明细（workQty >= anfme）
        List<WaitPakinItem> availableItems = waitPakinItems.stream()
                .filter(item -> {
                    Double workQty = item.getWorkQty() == null ? 0.0 : item.getWorkQty();
                    Double anfme = item.getAnfme() == null ? 0.0 : item.getAnfme();
                    return workQty < anfme; // 只返回未完全使用的明细
                })
                .collect(Collectors.toList());
        
        if (availableItems.isEmpty()) {
            throw new CoolException("组拖明细已全部使用，无法再次创建任务");
        }
        
        return availableItems;
    }

    /**
@@ -261,6 +279,15 @@
        if (!taskItemService.saveBatch(taskItems)) {
            throw new CoolException("任务明细保存失败！！");
        }
        
        // 更新组托明细的执行数量，标记明细已被提取使用
        waitPakinItems.forEach(item -> {
            if (!waitPakinItemService.update(new LambdaUpdateWrapper<WaitPakinItem>()
                    .set(WaitPakinItem::getWorkQty, item.getAnfme())
                    .eq(WaitPakinItem::getId, item.getId()))) {
                throw new CoolException("组托明细执行数量修改失败！！");
            }
        });
    }

    /**
@@ -467,14 +494,88 @@
            return R.error("参数不能为空！！");
        }
        log.info("========== 接收RCS回调 ==========");
        log.info("任务编号：{}，事件类型：{}", params.getSeqNum(), params.getEventType());
        Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getTaskCode, params.getSeqNum()));
        log.info("任务编号：{}，批次号：{}，事件类型：{}", params.getSeqNum(), params.getBatchNo(), params.getEventType());
        
        // 优先使用批次号查询任务主表（批次号 = 任务编码，更可靠）
        String taskCode = params.getBatchNo();
        String taskNo = params.getSeqNum();
        String locCode = null; // 库位代码（多库位任务时从任务号中提取）
        
        // 如果批次号为空，使用任务号查询
        if (StringUtils.isBlank(taskCode)) {
            taskCode = taskNo;
        }
        
        // 处理出库任务多库位的情况：任务号格式可能是 "任务编码_库位代码"
        // 如果任务号包含下划线，提取库位代码
        if (StringUtils.isNotBlank(taskNo) && taskNo.contains("_")) {
            locCode = taskNo.substring(taskNo.lastIndexOf("_") + 1);
            // 如果批次号为空，从任务号中提取原始任务编码
            if (StringUtils.isBlank(taskCode)) {
                taskCode = taskNo.substring(0, taskNo.lastIndexOf("_"));
            }
            log.info("检测到多库位任务，提取库位代码：{}，原始任务编码：{}", locCode, taskCode);
        }
        
        // 使用批次号（任务编码）查询任务主表
        Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getTaskCode, taskCode));
        
        if (Objects.isNull(task)) {
            log.error("任务不存在或已结束！任务编号：{}", params.getSeqNum());
            throw new CoolException("任务不存在或已结束！！");
            log.error("任务不存在或已结束！任务编号：{}，批次号：{}", taskNo, taskCode);
            throw new CoolException("任务不存在或已结束！！任务编号：" + taskNo + "，批次号：" + taskCode);
        }
        
        // 验证批次号和任务号的关联关系
        if (StringUtils.isNotBlank(params.getBatchNo()) && !params.getBatchNo().equals(task.getTaskCode())) {
            log.warn("批次号与任务编码不匹配！批次号：{}，任务编码：{}", params.getBatchNo(), task.getTaskCode());
        }
        log.info("查询到任务 - 任务编码：{}，任务类型：{}，当前状态：{}", 
                task.getTaskCode(), task.getTaskType(), task.getTaskStatus());
        
        // 对于多库位出库任务，通过库位代码精确关联任务明细
        List<TaskItem> relatedTaskItems = null;
        if (StringUtils.isNotBlank(locCode)) {
            // 1. 通过库位代码查询LocItem
            LocItem locItem = locItemService.getOne(new LambdaQueryWrapper<LocItem>().eq(LocItem::getLocCode, locCode));
            if (Objects.isNull(locItem)) {
                log.warn("未找到库位明细！库位代码：{}，任务编码：{}", locCode, task.getTaskCode());
            } else {
                // 2. 通过任务ID和LocItem.id（即TaskItem.source）查询对应的任务明细
                relatedTaskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>()
                        .eq(TaskItem::getTaskId, task.getId())
                        .eq(TaskItem::getSource, locItem.getId()));
                if (relatedTaskItems.isEmpty()) {
                    log.warn("未找到对应的任务明细！任务编码：{}，库位代码：{}，LocItem.id：{}", 
                            task.getTaskCode(), locCode, locItem.getId());
                } else {
                    log.info("通过库位代码精确关联到任务明细 - 任务编码：{}，库位代码：{}，任务明细数量：{}", 
                            task.getTaskCode(), locCode, relatedTaskItems.size());
                }
            }
        }
        
        // 验证任务状态：只有已下发到RCS的任务才能被回调处理
        // 入库任务：状态 >= WCS_EXECUTE_IN(2) 表示已下发
        // 出库任务：状态 >= WCS_EXECUTE_OUT(102) 表示已下发
        boolean isValidStatus = false;
        if (task.getTaskType() < 100) {
            // 入库任务
            if (task.getTaskStatus() >= TaskStsType.WCS_EXECUTE_IN.id) {
                isValidStatus = true;
            }
        } else {
            // 出库任务
            if (task.getTaskStatus() >= TaskStsType.WCS_EXECUTE_OUT.id) {
                isValidStatus = true;
            }
        }
        
        if (!isValidStatus) {
            log.error("任务状态不正确，无法处理回调！任务编码：{}，任务类型：{}，当前状态：{}，期望状态：已下发到RCS", 
                    task.getTaskCode(), task.getTaskType(), task.getTaskStatus());
            throw new CoolException("任务状态不正确，无法处理回调！任务编码：" + task.getTaskCode() + 
                    "，当前状态：" + task.getTaskStatus() + "，任务可能未下发到RCS或已被处理");
        }

        /**料箱搬运中， 修改站点状态*/
//        if (params.getEventType().equals(CallBackEvent.CALL_BACK_EVENT_OBIT.event)) {
@@ -1003,13 +1104,16 @@
        // 8. 创建并保存任务明细
        // 9. 更新组托状态
        InTaskMsgDto msgDto = createInTask(param);
        
        log.info("========== 申请入库任务成功 ==========");
        log.info("任务编码：{}，库位号：{}", msgDto.getWorkNo(), msgDto.getLocNo());
        //RCS已经在输送线上，所以不需要下发任务
        taskService.updateById(new Task(){{setId(msgDto.getTaskId());setTaskStatus(2);}});
        log.info("========== RCS-申请入库任务成功 ==========");
        log.info("RCS-返回 任务编码：{}，库位号：{}", msgDto.getWorkNo(), msgDto.getLocNo());

        // 返回结果，只返回库位号（根据接口文档要求）
        JSONObject result = new JSONObject();
        result.put("locNo", msgDto.getLocNo());
        result.put("batchNo", msgDto.getWorkNo());
        result.put("taskNo", msgDto.getWorkNo());
        return R.ok(result);
    }
}