代码优化

skyouc

18 小时以前 ebdfa825c07189b5f8e89f147d96d1bc612589db

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

@@ -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::getAsnId, 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::getAsnId, 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,7 +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))) {
        if (!outStockItemService.remove(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getAsnId, id))) {
            throw new CoolException("单据明细删除失败！！");
        }
        return R.ok("操作成功");
@@ -201,10 +201,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("出库数量不能小于或等于零！！");
                }
@@ -241,7 +241,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 +304,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::getAsnId, list).apply("anfme > work_qty"));
        if (orderItems.isEmpty()) {
            throw new CoolException("单据不存在！！");
        }
@@ -330,7 +330,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());
@@ -485,11 +485,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::getAsnId, 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("单据明细不存在！！");
@@ -561,16 +561,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::getAsnId));
        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 +592,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::getAsnId, key))) {
                throw new CoolException("单据明细删除失败！！");
            }
        }
@@ -602,24 +602,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::getAsnId, 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 +660,13 @@
            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);
@@ -685,7 +685,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;