From ebdfa825c07189b5f8e89f147d96d1bc612589db Mon Sep 17 00:00:00 2001
From: skyouc
Date: 星期二, 15 七月 2025 08:32:17 +0800
Subject: [PATCH] 代码优化

---
 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/OutStockServiceImpl.java |   74 ++++++++++++++++++------------------
 1 files changed, 37 insertions(+), 37 deletions(-)

diff --git a/rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/OutStockServiceImpl.java b/rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/OutStockServiceImpl.java
index cc537cf..dd29375 100644
--- a/rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/OutStockServiceImpl.java
+++ b/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;

--
Gitblit v1.9.1