lsh#

1

1 天以前 af1ee01622373808c0c8a82f3c4e292fb5d917ba

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

@@ -89,8 +89,8 @@
    public void svaeOrUpdateOrderItem(AsnOrderAndItemsParams params, Long loginUserId) throws Exception {
        WkOrder orders = params.getOrders();
        params.getItems().forEach(item -> {
            item.put("asnId", orders.getId());
            item.put("asnCode", orders.getCode());
            item.put("orderId", orders.getId());
            item.put("orderCode", orders.getCode());
            item.put("poCode", orders.getPoCode());
            item.put("createBy", loginUserId);
            item.put("updateBy", loginUserId);
@@ -98,9 +98,9 @@
                throw new CoolException("明细保存失败！！");
            }
        });
        List<AsnOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<AsnOrderItem>()
                .eq(AsnOrderItem::getAsnId, params.getOrders().getId()));
        Double sum = orderItems.stream().mapToDouble(AsnOrderItem::getAnfme).sum();
        List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>()
                .eq(WkOrderItem::getOrderId, params.getOrders().getId()));
        Double sum = orderItems.stream().mapToDouble(WkOrderItem::getAnfme).sum();
        orders.setAnfme(sum);
        if (!this.updateById(orders)) {
            throw new CoolException("计划收货数量修改失败！！");
@@ -129,9 +129,9 @@
            throw new CoolException("当前单据状态为" + AsnExceStatus.getExceStatus(order.getExceStatus()) + "， 不可执行取消操作！！");
        }

        List<AsnOrderItem> orderItems = outStockItemService.list(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getAsnId, id));
        List<WkOrderItem> orderItems = outStockItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderId, id));
        if (!orderItems.isEmpty()) {
            for (AsnOrderItem orderItem : orderItems) {
            for (WkOrderItem orderItem : orderItems) {
                if (!Objects.isNull(orderItem.getPoDetlId())) {
                    DeliveryItem deliveryItem = deliveryItemService.getById(orderItem.getPoDetlId());
                    Double workQty = Math.round((deliveryItem.getWorkQty() - orderItem.getAnfme()) * 10000) / 10000.0;
@@ -155,9 +155,7 @@
        if (!this.remove(new LambdaQueryWrapper<WkOrder>().eq(WkOrder::getId, id))) {
            throw new CoolException("主单删除失败！！");
        }
        if (!outStockItemService.remove(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getAsnId, id))) {
            throw new CoolException("单据明细删除失败！！");
        }
        outStockItemService.remove(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderId, id));
        return R.ok("操作成功");
    }

@@ -201,10 +199,10 @@
            if (!this.save(order)) {
                throw new CoolException("主单保存失败！！");
            }
            List<AsnOrderItem> orderItems = new ArrayList<>();
            List<WkOrderItem> orderItems = new ArrayList<>();
            listMap.get(key).forEach(item -> {
                DeliveryItem deliveryItem = deliveryItemService.getById(item.getId());
                AsnOrderItem orderItem = new AsnOrderItem();
                WkOrderItem orderItem = new WkOrderItem();
                if (item.getAnfme().compareTo(0.0) <= 0) {
                    throw new CoolException("出库数量不能小于或等于零！！");
                }
@@ -221,8 +219,8 @@
                        .setFieldsIndex(item.getFieldsIndex())
                        .setAnfme(item.getAnfme())
                        .setWorkQty(0.0)
                        .setAsnId(order.getId())
                        .setAsnCode(order.getCode())
                        .setOrderId(order.getId())
                        .setOrderCode(order.getCode())
                        .setStockUnit(item.getUnit())
                        .setPurUnit(item.getUnit())
                        .setPlatWorkCode(item.getPlatWorkCode())
@@ -241,7 +239,7 @@
                }
            });

            Double sum = orderItems.stream().mapToDouble(AsnOrderItem::getAnfme).sum();
            Double sum = orderItems.stream().mapToDouble(WkOrderItem::getAnfme).sum();
            //修改计划数量
            order.setAnfme(sum).setWorkQty(0.0);
            if (!this.saveOrUpdate(order)) {
@@ -304,9 +302,9 @@
        }

        List<Long> list = orders.stream().map(WkOrder::getId).collect(Collectors.toList());
        List<AsnOrderItem> orderItems = asnOrderItemService
                .list(new LambdaQueryWrapper<AsnOrderItem>()
                        .in(AsnOrderItem::getAsnId, list).apply("anfme > work_qty"));
        List<WkOrderItem> orderItems = asnOrderItemService
                .list(new LambdaQueryWrapper<WkOrderItem>()
                        .in(WkOrderItem::getOrderId, list).apply("anfme > work_qty"));
        if (orderItems.isEmpty()) {
            throw new CoolException("单据不存在！！");
        }
@@ -330,7 +328,7 @@
         *订单信息存储至逻辑关联表
         */
        for (WaveItem item : waveItems) {
            List<AsnOrderItem> items = orderItems.stream()
            List<WkOrderItem> items = orderItems.stream()
                    .filter(orderItem -> item.getMatnrId()
                            .equals(orderItem.getMatnrId()))
                    .collect(Collectors.toList());
@@ -338,7 +336,7 @@
            items.forEach(orderItem -> {
                WaveOrderRela orderRela = new WaveOrderRela();
                orderRela.setId(null)
                        .setOrderId(orderItem.getAsnId())
                        .setOrderId(orderItem.getOrderId())
                        .setOrderItemId(orderItem.getId())
                        .setWaveId(wave.getId())
                        .setWaveItemId(item.getId());
@@ -456,6 +454,33 @@
        return R.ok(locItems);
    }

    @Override
    public R getOrderOutTaskItem(OrderOutTaskParam param,Long orderItemId) {

        OrderOutTaskParam orderOutTaskParam = new OrderOutTaskParam();
        orderOutTaskParam.setWaveId(param.getWaveId());

        if (Cools.isEmpty(param.getWaveId())) {
            throw new CoolException("策略参数为空");
        }
        if (Cools.isEmpty(param.getOrderId())) {
            throw new CoolException("单据ID为空");
        }
        WkOrderItem byId = asnOrderItemService.getById(orderItemId);
        param.setOrderId(byId.getOrderId());

        WaveRule waveRule = waveRuleService.getOne(new LambdaQueryWrapper<WaveRule>()
                .eq(WaveRule::getId, param.getWaveId()));
        if (Cools.isEmpty(waveRule)) {
            throw new CoolException("未找到当前策略");
        }
        List<OrderOutItemDto> locItems = null;
        List<Long> itemIds = new ArrayList<>();
        itemIds.add(orderItemId);
        locItems = getOutOrderList(param.getOrderId(), waveRule,itemIds);
        return R.ok(locItems);
    }

    /**
     * 生成出库任务
     *
@@ -485,11 +510,11 @@
                List<LocItem> locItems = new ArrayList<>();
                LocItem locItem = locItemService.getById(param.getId());

                AsnOrderItem orderItem = outStockItemService.getOne(new LambdaQueryWrapper<AsnOrderItem>()
                        .eq(AsnOrderItem::getAsnId, outId)
                        .eq(StringUtils.isNotBlank(locItem.getBatch()), AsnOrderItem::getSplrBatch, locItem.getBatch())
                        .eq(StringUtils.isNotBlank(locItem.getFieldsIndex()), AsnOrderItem::getFieldsIndex, locItem.getFieldsIndex())
                        .eq(AsnOrderItem::getMatnrId, locItem.getMatnrId()));
                WkOrderItem orderItem = outStockItemService.getOne(new LambdaQueryWrapper<WkOrderItem>()
                        .eq(WkOrderItem::getOrderId, outId)
                        .eq(StringUtils.isNotBlank(locItem.getBatch()), WkOrderItem::getSplrBatch, locItem.getBatch())
                        .eq(StringUtils.isNotBlank(locItem.getFieldsIndex()), WkOrderItem::getFieldsIndex, locItem.getFieldsIndex())
                        .eq(WkOrderItem::getMatnrId, locItem.getMatnrId()));

                if (Objects.isNull(orderItem)) {
                    throw new CoolException("单据明细不存在！！");
@@ -498,7 +523,7 @@
                locItem.setOutQty(param.getOutQty())
                        .setBatch(param.getBatch())
                        .setSourceId(outId)
                        .setSourceCode(orderItem.getAsnCode())
                        .setSourceCode(orderItem.getOrderCode())
                        .setSource(orderItem.getId());
                locItems.add(locItem);

@@ -561,16 +586,16 @@

    @Override
    @Transactional(rollbackFor = Exception.class)
    public R cancelOutOrderByItems(List<AsnOrderItem> orderItems) {
        Map<Long, List<AsnOrderItem>> listMap = orderItems.stream().collect(Collectors.groupingBy(AsnOrderItem::getAsnId));
    public R cancelOutOrderByItems(List<WkOrderItem> orderItems) {
        Map<Long, List<WkOrderItem>> listMap = orderItems.stream().collect(Collectors.groupingBy(WkOrderItem::getOrderId));
        for (Long key : listMap.keySet()) {
            WkOrder order = this.getById(key);
            if (Objects.isNull(order)) {
                throw new CoolException("单据不存在！！");
            }
            List<AsnOrderItem> items = listMap.get(key);
            List<WkOrderItem> items = listMap.get(key);
            if (!items.isEmpty()) {
                for (AsnOrderItem orderItem : items) {
                for (WkOrderItem orderItem : items) {
                    DeliveryItem deliveryItem = deliveryItemService.getById(orderItem.getPoDetlId());
                    Double workQty = Math.round((deliveryItem.getWorkQty() - orderItem.getAnfme()) * 10000) / 10000.0;
                    deliveryItem.setWorkQty(workQty.compareTo(0.0) >= 0 ? workQty : 0);
@@ -592,8 +617,8 @@
            if (!this.remove(new LambdaQueryWrapper<WkOrder>().eq(WkOrder::getId, key))) {
                throw new CoolException("主单删除失败！！");
            }
            if (!outStockItemService.remove(new LambdaQueryWrapper<AsnOrderItem>()
                    .eq(AsnOrderItem::getAsnId, key))) {
            if (!outStockItemService.remove(new LambdaQueryWrapper<WkOrderItem>()
                    .eq(WkOrderItem::getOrderId, key))) {
                throw new CoolException("单据明细删除失败！！");
            }
        }
@@ -602,24 +627,24 @@


    private List<OrderOutItemDto> getOutOrderList(Long orderId, WaveRule waveRule) {
        List<AsnOrderItem> asnOrderItems = asnOrderItemService.list(new LambdaQueryWrapper<AsnOrderItem>()
                .eq(AsnOrderItem::getAsnId, orderId));
        List<WkOrderItem> wkOrderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>()
                .eq(WkOrderItem::getOrderId, orderId));
        List<OrderOutItemDto> list = new ArrayList<>();
        Set<ExistDto> existDtos = new HashSet<>();
        for (AsnOrderItem asnOrderItem : asnOrderItems) {
            BigDecimal issued = new BigDecimal(asnOrderItem.getAnfme().toString())
                    .subtract(new BigDecimal(asnOrderItem.getWorkQty().toString())
        for (WkOrderItem wkOrderItem : wkOrderItems) {
            BigDecimal issued = new BigDecimal(wkOrderItem.getAnfme().toString())
                    .subtract(new BigDecimal(wkOrderItem.getWorkQty().toString())
                    );
            if (issued.doubleValue() <= 0) {
                continue;
            }
            List<LocItem> locItems = new ArrayList<>();
            if (WaveRuleType.Efficiency_First.type.equals(waveRule.getType())) {
                locItems = LocManageUtil.getEfficiencyFirstItemList(asnOrderItem.getMatnrCode(), asnOrderItem.getSplrBatch(), asnOrderItem.getAnfme());
                locItems = LocManageUtil.getEfficiencyFirstItemList(wkOrderItem.getMatnrCode(), wkOrderItem.getSplrBatch(), wkOrderItem.getAnfme());
            } else if (WaveRuleType.First_In_First_Out.type.equals(waveRule.getType())) {
                locItems = LocManageUtil.getFirstInFirstOutItemList(asnOrderItem.getMatnrCode(), asnOrderItem.getSplrBatch(), asnOrderItem.getAnfme());
                locItems = LocManageUtil.getFirstInFirstOutItemList(wkOrderItem.getMatnrCode(), wkOrderItem.getSplrBatch(), wkOrderItem.getAnfme());
            } else {
                locItems = LocManageUtil.getFirstInFirstOutItemList(asnOrderItem.getMatnrCode(), asnOrderItem.getSplrBatch(), asnOrderItem.getAnfme());
                locItems = LocManageUtil.getFirstInFirstOutItemList(wkOrderItem.getMatnrCode(), wkOrderItem.getSplrBatch(), wkOrderItem.getAnfme());
            }
            for (LocItem locItem : locItems) {
                Loc loc = locService.getById(locItem.getLocId());
@@ -660,13 +685,89 @@
            if (issued.doubleValue() > 0) {
                LocItem locItem = new LocItem()
                        .setId(new Random().nextLong())
                        .setMatnrCode(asnOrderItem.getMatnrCode())
                        .setMaktx(asnOrderItem.getMaktx())
                        .setMatnrCode(wkOrderItem.getMatnrCode())
                        .setMaktx(wkOrderItem.getMaktx())
                        .setAnfme(0.00)
                        .setWorkQty(issued.doubleValue())
                        .setOutQty(issued.doubleValue())
                        .setUnit(asnOrderItem.getStockUnit())
                        .setBatch(asnOrderItem.getSplrBatch());
                        .setUnit(wkOrderItem.getStockUnit())
                        .setBatch(wkOrderItem.getSplrBatch());
                OrderOutItemDto orderOutItemDto = new OrderOutItemDto();
                orderOutItemDto.setLocItem(locItem);
                list.add(orderOutItemDto);
            }
        }

        return list;

    }

    private List<OrderOutItemDto> getOutOrderList(Long orderId, WaveRule waveRule,List<Long> orderItemIdList) {
        List<WkOrderItem> wkOrderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>()
                        .in(WkOrderItem::getId, orderItemIdList).eq(WkOrderItem::getOrderId, orderId));
        List<OrderOutItemDto> list = new ArrayList<>();
        Set<ExistDto> existDtos = new HashSet<>();
        for (WkOrderItem wkOrderItem : wkOrderItems) {
            BigDecimal issued = new BigDecimal(wkOrderItem.getAnfme().toString())
                    .subtract(new BigDecimal(wkOrderItem.getWorkQty().toString())
                    );
            if (issued.doubleValue() <= 0) {
                continue;
            }
            List<LocItem> locItems = new ArrayList<>();
            if (WaveRuleType.Efficiency_First.type.equals(waveRule.getType())) {
                locItems = LocManageUtil.getEfficiencyFirstItemList(wkOrderItem.getMatnrCode(), wkOrderItem.getSplrBatch(), wkOrderItem.getAnfme());
            } else if (WaveRuleType.First_In_First_Out.type.equals(waveRule.getType())) {
                locItems = LocManageUtil.getFirstInFirstOutItemList(wkOrderItem.getMatnrCode(), wkOrderItem.getSplrBatch(), wkOrderItem.getAnfme());
            } else {
                locItems = LocManageUtil.getFirstInFirstOutItemList(wkOrderItem.getMatnrCode(), wkOrderItem.getSplrBatch(), wkOrderItem.getAnfme());
            }
            for (LocItem locItem : locItems) {
                Loc loc = locService.getById(locItem.getLocId());
                List<LocItem> itemList = locItemService.list(new LambdaQueryWrapper<LocItem>().eq(LocItem::getLocCode, locItem.getLocCode()));
                if (issued.doubleValue() > 0) {
                    ExistDto existDto = new ExistDto().setBatch(locItem.getBatch()).setMatnr(locItem.getMatnrCode()).setLocNo(locItem.getLocCode());
                    if (existDtos.add(existDto)) {
                        locItem.setOutQty(issued.doubleValue() >= locItem.getAnfme() ? locItem.getAnfme() : issued.doubleValue());
                        locItem.setBarcode(loc.getBarcode());
                        OrderOutItemDto orderOutItemDto = new OrderOutItemDto();
                        orderOutItemDto.setLocItem(locItem);

                        List<DeviceSite> deviceSites = deviceSiteService.list(new LambdaQueryWrapper<DeviceSite>()
                                .eq(DeviceSite::getChannel, loc.getChannel())
                                .eq(DeviceSite::getType, issued.doubleValue() >= locItem.getAnfme() && itemList.size() == 1 ? TaskType.TASK_TYPE_OUT.type : TaskType.TASK_TYPE_PICK_AGAIN_OUT.type)
                        );

                        if (!deviceSites.isEmpty()) {
                            List<OrderOutItemDto.staListDto> maps = new ArrayList<>();
                            for (DeviceSite sta : deviceSites) {
                                OrderOutItemDto.staListDto staListDto = new OrderOutItemDto.staListDto();
                                staListDto.setStaNo(sta.getSite());
                                staListDto.setStaName(sta.getSite());
                                maps.add(staListDto);
                            }
                            orderOutItemDto.setStaNos(maps);
                            //默认获取第一站点
                            DeviceSite deviceSite = deviceSites.stream().findFirst().get();
                            orderOutItemDto.setSiteNo(deviceSite.getSite());
                        }

                        list.add(orderOutItemDto);

                        issued = issued.subtract(new BigDecimal(locItem.getAnfme().toString()));
                    }
                }
            }
            if (issued.doubleValue() > 0) {
                LocItem locItem = new LocItem()
                        .setId(new Random().nextLong())
                        .setMatnrCode(wkOrderItem.getMatnrCode())
                        .setMaktx(wkOrderItem.getMaktx())
                        .setAnfme(0.00)
                        .setWorkQty(issued.doubleValue())
                        .setOutQty(issued.doubleValue())
                        .setUnit(wkOrderItem.getStockUnit())
                        .setBatch(wkOrderItem.getSplrBatch());
                OrderOutItemDto orderOutItemDto = new OrderOutItemDto();
                orderOutItemDto.setLocItem(locItem);
                list.add(orderOutItemDto);
@@ -685,7 +786,7 @@
     * @description 合并生成波次
     * @time 2025/4/25 10:07
     */
    private List<WaveItem> mergeWave(List<AsnOrderItem> orderItems, Wave wave) {
    private List<WaveItem> mergeWave(List<WkOrderItem> orderItems, Wave wave) {
        List<WaveItem> items = new ArrayList<>();
        orderItems.forEach(order -> {
            Double anfme = Math.round((order.getAnfme() - order.getWorkQty()) * 10000) / 10000.0;
@@ -730,4 +831,25 @@

        return waveItems;
    }


    /**
     * @param id
     * @return
     * @author Ryan
     * @description 完成出库单
     * @time 2025/4/25 10:07
     */
    @Override
    public R completeOutOrderById(Long id) {
        WkOrder order = this.getById(id);
        if (Objects.isNull(order)) {
            return R.error("出库单不存在！！");
        }
        order.setExceStatus(AsnExceStatus.OUT_STOCK_STATUS_TASK_DONE.val);
        if (!this.updateById(order)) {
            throw new CoolException("完成出库单失败！！");
        }
         return R.ok("完成出库单成功！！");
    }
}