拣货过程中的出库库存匹配

chen.lin

昨天 98d88ac8caf7f0991d741079474c262f1e252927

 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/TaskServiceImpl.java

@@ -1383,6 +1383,15 @@
            });
            log.debug("[拣料入库] 即将扣减库位 locId={}, locCode={}", loc.getId(), loc.getCode());
            subtractLocItemByTaskItems(loc, taskItems, SystemAuthUtils.getLoginUserId());
            // 料箱已全部用完则不生成拣货入库单，仅完结出库
            double totalRemaining = taskItems.stream().mapToDouble(ti -> ti.getAnfme() != null && ti.getAnfme().compareTo(0.0) > 0 ? ti.getAnfme() : 0.0).sum();
            if (totalRemaining <= 0.0) {
                task.setTaskType(TaskType.TASK_TYPE_PICK_AGAIN_OUT.type);
                task.setTaskStatus(TaskStsType.UPDATED_OUT.id);
                this.updateById(task);
                locItemWorkingService.remove(new LambdaQueryWrapper<LocItemWorking>().eq(LocItemWorking::getTaskId, task.getId()));
                return task;
            }
        }

        tempLocs.forEach(working -> {
@@ -1478,6 +1487,137 @@
    }

    /**
     * 同箱码下多条 200 拣料出库一次性处理：按相同物料合计扣减库位、更新出库单/库存明细、生成一张拣料入库单（有余量时）、更新库位状态
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void processPickOutBarcodeAll200(List<Task> all200Tasks) {
        if (all200Tasks == null || all200Tasks.isEmpty()) {
            return;
        }
        Task first = all200Tasks.get(0);
        if (!TaskType.TASK_TYPE_PICK_AGAIN_OUT.type.equals(first.getTaskType()) || !TaskStsType.UPDATED_OUT.id.equals(first.getTaskStatus())) {
            throw new CoolException("非拣料出库200任务，不可批量处理");
        }
        List<Long> taskIds = all200Tasks.stream().map(Task::getId).collect(Collectors.toList());
        List<TaskItem> allItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().in(TaskItem::getTaskId, taskIds));
        if (allItems.isEmpty()) {
            throw new CoolException("任务明细为空");
        }
        Long loginUserId = SystemAuthUtils.getLoginUserId();
        if (loginUserId == null) {
            loginUserId = 1L;
        }
        String orgLoc = first.getOrgLoc();
        Loc loc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, orgLoc));
        if (loc == null) {
            throw new CoolException("库位不存在：" + orgLoc);
        }
        // 按物料+批次+票号汇总已拣数量
        Map<String, List<TaskItem>> byKey = allItems.stream().collect(Collectors.groupingBy(ti ->
                (ti.getMatnrId() != null ? ti.getMatnrId() : "") + "_" + (ti.getBatch() != null ? ti.getBatch() : "") + "_" + (ti.getFieldsIndex() != null ? ti.getFieldsIndex() : "")));
        List<TaskItem> aggregatedForDeduct = new ArrayList<>();
        Map<String, Double> remainderByKey = new LinkedHashMap<>();
        for (Map.Entry<String, List<TaskItem>> e : byKey.entrySet()) {
            List<TaskItem> group = e.getValue();
            double totalQty = group.stream().mapToDouble(ti -> ti.getQty() != null && ti.getQty() > 0 ? ti.getQty() : (ti.getAnfme() != null ? ti.getAnfme() : 0)).sum();
            TaskItem rep = group.get(0);
            TaskItem forDeduct = new TaskItem();
            forDeduct.setMatnrId(rep.getMatnrId()).setBatch(rep.getBatch()).setFieldsIndex(rep.getFieldsIndex()).setQty(totalQty);
            aggregatedForDeduct.add(forDeduct);
            LambdaQueryWrapper<LocItem> qw = new LambdaQueryWrapper<LocItem>().eq(LocItem::getLocId, loc.getId()).eq(LocItem::getMatnrId, rep.getMatnrId());
            if (StringUtils.isNotBlank(rep.getBatch())) qw.eq(LocItem::getBatch, rep.getBatch());
            else qw.and(w -> w.isNull(LocItem::getBatch).or().eq(LocItem::getBatch, ""));
            if (StringUtils.isNotBlank(rep.getFieldsIndex())) qw.eq(LocItem::getFieldsIndex, rep.getFieldsIndex());
            else qw.and(w -> w.isNull(LocItem::getFieldsIndex).or().eq(LocItem::getFieldsIndex, ""));
            LocItem li = locItemService.getOne(qw);
            double remainder = (li != null && li.getAnfme() != null ? li.getAnfme() : 0) - totalQty;
            if (remainder > 0) {
                remainderByKey.put(e.getKey(), remainder);
            }
        }
        subtractLocItemByTaskItems(loc, aggregatedForDeduct, loginUserId);
        // 按 source 分组更新出库单并写库存流水
        Map<Long, List<TaskItem>> bySource = allItems.stream().collect(Collectors.groupingBy(TaskItem::getSource));
        for (Map.Entry<Long, List<TaskItem>> e : bySource.entrySet()) {
            Long key = e.getKey();
            List<TaskItem> items = e.getValue();
            if (first.getResource() != null && first.getResource().equals(TaskResouceType.TASK_RESOUCE_WAVE_TYPE.val)) {
                WaveItem waveItem = waveItemService.getById(key);
                if (waveItem != null) {
                    try {
                        saveOutStockItem(items, null, waveItem, null, loginUserId);
                    } catch (Exception ex) {
                        throw new CoolException(ex.getMessage());
                    }
                }
            } else if (first.getResource() != null && first.getResource().equals(TaskResouceType.TASK_RESOUCE_ORDER_TYPE.val)) {
                WkOrderItem orderItem = asnOrderItemService.getById(key);
                if (orderItem != null) {
                    try {
                        saveOutStockItem(items, orderItem, null, null, loginUserId);
                    } catch (Exception ex) {
                        throw new CoolException(ex.getMessage());
                    }
                }
            }
        }
        // 有余量则生成一张拣料入库单
        if (!remainderByKey.isEmpty()) {
            Task pickInTask = new Task();
            pickInTask.setTaskCode(SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_TASK_CODE, first));
            pickInTask.setTaskType(TaskType.TASK_TYPE_PICK_IN.type);
            pickInTask.setTaskStatus(TaskStsType.GENERATE_IN.id);
            pickInTask.setBarcode(first.getBarcode());
            pickInTask.setOrgLoc(orgLoc);
            pickInTask.setTargLoc(orgLoc);
            pickInTask.setOrgSite(first.getTargSite());
            pickInTask.setTargSite(first.getTargSite());
            pickInTask.setResource(first.getResource());
            if (!this.save(pickInTask)) {
                throw new CoolException("拣料入库任务创建失败");
            }
            List<LocItemWorking> workings = new ArrayList<>();
            for (Map.Entry<String, Double> re : remainderByKey.entrySet()) {
                String k = re.getKey();
                Double rem = re.getValue();
                if (rem == null || rem <= 0) continue;
                List<TaskItem> group = byKey.get(k);
                if (group == null || group.isEmpty()) continue;
                TaskItem rep = group.get(0);
                TaskItem ti = new TaskItem();
                ti.setTaskId(pickInTask.getId());
                ti.setMatnrId(rep.getMatnrId()).setMaktx(rep.getMaktx()).setMatnrCode(rep.getMatnrCode());
                ti.setBatch(rep.getBatch()).setFieldsIndex(rep.getFieldsIndex()).setUnit(rep.getUnit()).setSpec(rep.getSpec()).setModel(rep.getModel());
                ti.setAnfme(rem).setQty(0.0);
                taskItemService.save(ti);
                LocItemWorking w = new LocItemWorking();
                w.setTaskId(pickInTask.getId());
                w.setLocId(loc.getId());
                w.setLocCode(loc.getCode());
                w.setMatnrId(rep.getMatnrId()).setMaktx(rep.getMaktx()).setMatnrCode(rep.getMatnrCode());
                w.setBatch(rep.getBatch()).setFieldsIndex(rep.getFieldsIndex()).setUnit(rep.getUnit());
                w.setAnfme(rem);
                workings.add(w);
            }
            if (!workings.isEmpty()) {
                locItemWorkingService.saveBatch(workings);
            }
            loc.setUseStatus(LocStsType.LOC_STS_TYPE_S.type);
            locService.updateById(loc);
        } else {
            loc.setUseStatus(LocStsType.LOC_STS_TYPE_O.type);
            loc.setBarcode(null);
            loc.setUpdateBy(loginUserId);
            loc.setUpdateTime(new Date());
            locService.updateById(loc);
        }
        for (Long tid : taskIds) {
            locItemWorkingService.remove(new LambdaQueryWrapper<LocItemWorking>().eq(LocItemWorking::getTaskId, tid));
        }
    }

    /**
     * @author Ryan
     * @date 2025/5/20
     * @description: 完成出库任务，更新出库库存信息
@@ -1492,6 +1632,34 @@
        Loc loc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, task.getOrgLoc()));
        if (Objects.isNull(loc)) {
            throw new CoolException("库位不存在！！");
        }

        // 空板出库：无任务明细，不需要 PDA 拣货确认，RCS 回调后直接完成库位更新并置为 UPDATED_OUT
        if (task.getTaskType().equals(TaskType.TASK_TYPE_EMPITY_OUT.type)) {
            List<TaskItem> emptyItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
            if (emptyItems.isEmpty()) {
                if (!LocStsType.LOC_STS_TYPE_R.type.equals(loc.getUseStatus())) {
                    log.warn("空板出库任务{}的库位{}状态不是R.出库预约，跳过", task.getId(), loc.getCode());
                    return;
                }
                if (!locService.update(new LambdaUpdateWrapper<Loc>()
                        .eq(Loc::getId, loc.getId())
                        .set(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_O.type)
                        .set(Loc::getBarcode, null)
                        .set(Loc::getUpdateBy, loginUserId)
                        .set(Loc::getUpdateTime, new Date()))) {
                    throw new CoolException("空板出库库位状态更新失败！！");
                }
                if (!this.update(new LambdaUpdateWrapper<Task>()
                        .eq(Task::getId, task.getId())
                        .set(Task::getUpdateBy, loginUserId)
                        .set(Task::getUpdateTime, new Date())
                        .set(Task::getTaskStatus, TaskStsType.UPDATED_OUT.id))) {
                    throw new CoolException("空板出库任务状态更新失败！！");
                }
                log.info("[空板出库] 任务{} RCS回调后已直接完成库位更新，无需PDA确认", task.getTaskCode());
                return;
            }
        }
        
        List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
@@ -1610,15 +1778,8 @@
        
        // 根据任务类型更新库位状态
        if (task.getTaskType().equals(TaskType.TASK_TYPE_PICK_AGAIN_OUT.type) || task.getTaskType().equals(TaskType.TASK_TYPE_CHECK_OUT.type)) {
            /**修改为库位状态为S.预约入库，保留原有库位*/
            if (!locService.update(new LambdaUpdateWrapper<Loc>()
                    .set(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_S.type)
                    .set(Loc::getBarcode, null)
                    .set(Loc::getUpdateBy, loginUserId)
                    .set(Loc::getUpdateTime, new Date())
                    .eq(Loc::getId, loc.getId()))) {
                throw new CoolException("库位状态修改失败！！");
            }
            // 拣料出库/盘点出库：在未生成拣料入库单之前保持 R.预约出库，否则下发任务时查不到该库位（只查 F+R）导致“库存不足”
            // 等 PDA 确认并生成拣料入库任务时，再在 pickOrCheckTask 中将目标库位改为 S.预约入库
        } else if (task.getTaskType().equals(TaskType.TASK_TYPE_OUT.type)) {
            // 全版出库：不更新库位状态为O，等待PDA快速拣货确认时再更新
            // 库位状态保持原样（R.出库预约状态）