修改预约库位变更

chen.lin

昨天 b1123ede8199b691d6d684af6b3b58b223b6bdae

修改预约库位变更

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

@@ -247,7 +247,8 @@
        if (Objects.isNull(matnr)) {
            throw new CoolException("数据错误：物料" + wkOrderItem.getMatnrCode() + "不存在！！");
        }
        BeanUtils.copyProperties(matnr, wkOrderItem);
        // 复制时排除 id，避免物料 id 覆盖单据明细 id，导致 saveOrUpdate 误判为新增而重复插入（出库单编辑保存后 1 条变 2 条）
        BeanUtils.copyProperties(matnr, wkOrderItem, "id");
        wkOrderItem.setMatnrCode(matnr.getCode())
                .setSplrBatch(!Objects.isNull(wkOrderItem.getBatch()) ? wkOrderItem.getBatch() : null)
                .setMatnrId(matnr.getId())

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

@@ -143,6 +143,10 @@
     * @param loginUserId
     * @return
     */
    /** 入库单业务类型：拣料入库、盘点入库等不可修改明细，此处为字典 value，按实际配置补充 */
    private static final Set<String> ASN_WKTYPE_NO_EDIT = Collections.unmodifiableSet(new HashSet<>(
            Arrays.asList("53", "57"))); // 53=拣料再入库 57=盘点再入库（与 TaskType 一致，若字典不同请改为实际 value）

    @Override
    @Transactional(rollbackFor = Exception.class)
    public R updateOrderItem(AsnOrderAndItemsParams params, Long loginUserId) throws Exception {
@@ -153,11 +157,23 @@
        if (Objects.isNull(orders.getId())) {
            throw new CoolException("数据错误：单据ID不能为空！！");
        }
        if (!this.updateById(orders)) {
            throw new CoolException("主单修改失败！！");
        WkOrder currentOrder = this.getById(orders.getId());
        if (Objects.isNull(currentOrder)) {
            throw new CoolException("单据不存在！！");
        }
        // 仅未执行状态可修改
        if (!Objects.equals(currentOrder.getExceStatus(), AsnExceStatus.ASN_EXCE_STATUS_UN_EXCE.val)) {
            throw new CoolException("当前单据状态不允许修改，仅未执行状态可修改");
        }
        // 拣料入库、盘点入库类型不可修改
        if (StringUtils.isNotBlank(currentOrder.getWkType()) && ASN_WKTYPE_NO_EDIT.contains(currentOrder.getWkType())) {
            throw new CoolException("拣料入库、盘点入库类型的单据不能修改");
        }
        if (Objects.isNull(params.getItems()) || params.getItems().isEmpty()) {
            return R.ok("明细参数不能为空！！");
            throw new CoolException("明细参数不能为空！！");
        }
        if (!this.updateById(orders)) {
            throw new CoolException("主单修改失败！！");
        }

        svaeOrUpdateOrderItem(params, loginUserId);

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

@@ -218,7 +218,8 @@
                if (map.getType().equals(Constants.TASK_TYPE_ORDER_OUT_STOCK)) {
                    taskItem.setWkType(Short.parseShort(order.getWkType()))
                            .setSourceCode(order.getCode())
                            .setSourceId(order.getId());
                            .setSourceId(order.getId())
                            .setOrderItemId(item.getOrderItemId());
                } else if (map.getType().equals(Constants.TASK_TYPE_WAVE_OUT_STOCK)) {
                    taskItem.setSourceId(wave.getId())
                            .setWkType(Short.parseShort(OrderWorkType.ORDER_WORK_TYPE_OTHER.type))

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

@@ -81,6 +81,8 @@
    private LocService locService;
    @Autowired
    private WaveOrderRelaServiceImpl waveOrderRelaService;
    @Autowired
    private TaskItemService taskItemService;


    /**
@@ -419,6 +421,7 @@
     * @time 2025/4/29 13:47
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R updateOrderItem(AsnOrderAndItemsParams params, Long loginUserId) {
        WkOrder orders = params.getOrders();
        if (Objects.isNull(orders)) {
@@ -433,12 +436,102 @@
        if (Objects.isNull(params.getItems()) || params.getItems().isEmpty()) {
            throw new CoolException("明细参数不能为空！！");
        }
        // 删除/修改明细前收集当前单据下的明细 id，用于校验与同步库位状态
        List<Long> existingIds = asnOrderItemService.list(
                new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderId, orders.getId()))
                .stream().map(WkOrderItem::getId).collect(Collectors.toList());
        Set<Long> requestedIds = params.getItems().stream()
                .map(item -> item.get("id"))
                .filter(Objects::nonNull)
                .map(id -> Long.valueOf(id.toString()))
                .collect(Collectors.toSet());
        // 已生成工作档的明细不允许删除
        for (Long existingId : existingIds) {
            if (!requestedIds.contains(existingId) && hasGeneratedTask(orders.getId(), existingId)) {
                throw new CoolException("该明细已生成工作档，不能删除");
            }
        }
        // 已生成工作档的明细不允许修改
        for (Map<String, Object> item : params.getItems()) {
            Object idObj = item.get("id");
            if (idObj != null && hasGeneratedTask(orders.getId(), Long.valueOf(idObj.toString()))) {
                throw new CoolException("该明细已生成工作档，不能修改");
            }
        }
        try {
            svaeOrUpdateOrderItem(params, loginUserId);
        } catch (Exception e) {
            throw new CoolException(e.getMessage());
        }
        // 对本次被删除的明细（仅初始化状态）：先同步库位状态，再删除明细记录
        for (Long existingId : existingIds) {
            if (!requestedIds.contains(existingId)) {
                syncLocStatusOnOrderItemRemoved(orders.getId(), existingId, loginUserId);
                outStockItemService.removeById(existingId);
            }
        }
        // 重新汇总主单数量（删除明细后）
        List<WkOrderItem> afterItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>()
                .eq(WkOrderItem::getOrderId, orders.getId()));
        Double sum = afterItems.stream().mapToDouble(WkOrderItem::getAnfme).sum();
        orders.setAnfme(sum);
        this.updateById(orders);
        return R.ok();
    }

    /**
     * 判断出库单明细是否已生成工作档（存在关联的任务明细）
     */
    private boolean hasGeneratedTask(Long orderId, Long orderItemId) {
        return taskItemService.count(new LambdaQueryWrapper<TaskItem>()
                .eq(TaskItem::getSourceId, orderId)
                .eq(TaskItem::getOrderItemId, orderItemId)) > 0;
    }

    /**
     * 出库单明细被删除时同步库位状态：释放该明细关联的库位预约、回滚 LocItem.workQty、恢复库位为在库(F)
     */
    private void syncLocStatusOnOrderItemRemoved(Long orderId, Long orderItemId, Long loginUserId) {
        List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>()
                .eq(TaskItem::getSourceId, orderId)
                .eq(TaskItem::getOrderItemId, orderItemId));
        if (taskItems.isEmpty()) {
            return;
        }
        Set<Long> affectedLocIds = new HashSet<>();
        Date now = new Date();
        for (TaskItem taskItem : taskItems) {
            if (taskItem.getSource() == null) {
                continue;
            }
            LocItem locItem = locItemService.getById(taskItem.getSource());
            if (locItem == null) {
                continue;
            }
            Double anfme = taskItem.getAnfme() != null ? taskItem.getAnfme() : 0.0;
            Double newWorkQty = Math.round((locItem.getWorkQty() - anfme) * 1000000) / 1000000.0;
            locItem.setWorkQty(newWorkQty >= 0 ? newWorkQty : 0)
                    .setOrderId(null)
                    .setOrderItemId(null)
                    .setUpdateBy(loginUserId)
                    .setUpdateTime(now);
            locItemService.updateById(locItem);
            affectedLocIds.add(locItem.getLocId());
        }
        for (Long locId : affectedLocIds) {
            long stillReserved = locItemService.count(new LambdaQueryWrapper<LocItem>()
                    .eq(LocItem::getLocId, locId)
                    .isNotNull(LocItem::getOrderId));
            if (stillReserved == 0) {
                Loc loc = locService.getById(locId);
                if (loc != null && LocStsType.LOC_STS_TYPE_R.type.equals(loc.getUseStatus())) {
                    loc.setUseStatus(LocStsType.LOC_STS_TYPE_F.type)
                            .setUpdateBy(loginUserId)
                            .setUpdateTime(now);
                    locService.updateById(loc);
                }
            }
        }
    }

    @Override
@@ -579,6 +672,8 @@

                locItem.setOutQty(param.getOutQty())
                        .setBatch(param.getBatch())
                        .setOrderId(outId)
                        .setOrderItemId(orderItem.getId())
                        .setSourceId(outId)
                        .setSourceCode(orderItem.getOrderCode())
                        .setSource(orderItem.getId());
@@ -714,10 +809,13 @@
                }
                // 该库位可分配数量：取本行待分配与库位库存的较小值
                double allocatable = Math.min(issued.doubleValue(), locItem.getAnfme() != null ? locItem.getAnfme() : 0);
                // 当分配量等于库位库存时，使用库位库存精度作为出库数量，避免截断导致界面显示/库存校验不一致（如库存15.123457被截成15.123）
                double outQtyToSet = (locItem.getAnfme() != null && Math.abs(allocatable - locItem.getAnfme()) < 1e-6)
                        ? locItem.getAnfme() : allocatable;
                ExistDto existDto = new ExistDto().setBatch(locItem.getBatch()).setMatnr(locItem.getMatnrCode()).setLocNo(locItem.getLocCode());
                if (existDtos.add(existDto)) {
                    // 首次使用该库位：加入列表并扣减 issued
                    locItem.setOutQty(allocatable);
                    locItem.setOutQty(outQtyToSet);
                    locItem.setBarcode(loc.getBarcode());
                    OrderOutItemDto orderOutItemDto = new OrderOutItemDto();
                    orderOutItemDto.setLocItem(locItem);