无理由订单出库入库规则调整

sd-business/src/main/java/com/sd/business/entity/sku/po/SkuSpec.java

@@ -51,6 +51,16 @@ public class SkuSpec extends BasePo {
     private String barCode;
 
     /**
+     * E10成品品号
+     */
+    private String erpCode;
+
+    /**
+     * E10成品特征码
+     */
+    private String featureCode;
+
+    /**
      * 品名
      */
     private String name;

sd-business/src/main/java/com/sd/business/scheduled/InventoryFinishedTask.java

@@ -0,0 +1,27 @@
+package com.sd.business.scheduled;
+
+import com.sd.business.service.inventory.InventoryFinishedOrderService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Profile;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+/**
+ * 成品库定时任务
+ */
+@Profile({"test", "prod"})
+@Component
+public class InventoryFinishedTask {
+
+    @Autowired
+    private InventoryFinishedOrderService inventoryFinishedOrderService;
+
+    /**
+     * 无理由订单成品入库
+     * 将前一天无理由订单成品入库数据修改为无来源可出库数据
+     */
+    @Scheduled(cron = "0 0 0 * * ?")
+    public void syncYesterdayNoReasonOrderInventory() {
+        inventoryFinishedOrderService.syncYesterdayNoReasonOrderInventory();
+    }
+}

sd-business/src/main/java/com/sd/business/service/inventory/InventoryFinishedOrderService.java

@@ -69,4 +69,9 @@ public interface InventoryFinishedOrderService extends BaseService<InventoryFini
      * 根据订单id列表查询没有销货出库的订单
      */
     List<Long> getNotSalesOutOfWarehouseOrderByIds(List<Long> orderIdList);
+
+    /**
+     * 同步昨日无理由订单成品入库
+     */
+    void syncYesterdayNoReasonOrderInventory();
 }

sd-business/src/main/java/com/sd/business/service/inventory/impl/InventoryFinishedOrderServiceImpl.java

@@ -291,6 +291,7 @@ public class InventoryFinishedOrderServiceImpl extends ServiceImpl<InventoryFini
         TemplateExcelUtil.writeBrowserMultiSheet("inOutStorageDetails.xlsx", 2, fileName, response, inOutStorageErpExportVoList, inOutStorageBomErpExportVoList);
     }
 
+    @Transactional(rollbackFor = Exception.class)
     @Override
     public void noSourceSaleOutOfWarehouse(List<OrderSku> orderSkuList) {
         if (ObjectUtil.isEmpty(orderSkuList)) {
@@ -334,8 +335,8 @@ public class InventoryFinishedOrderServiceImpl extends ServiceImpl<InventoryFini
                     detail.setQuantity(existingQuantity);
                 } else {
                     inventoryFinishedOrder.setExistingQuantity(existingQuantity.subtract(orderSkuQuantity));
-                    orderSkuQuantity = BigDecimal.ZERO;
                     detail.setQuantity(orderSkuQuantity);
+                    orderSkuQuantity = BigDecimal.ZERO;
                 }
                 // 保存需要操作的数据
                 updateInventoryFinishedOrderList.add(inventoryFinishedOrder);
@@ -362,4 +363,33 @@ public class InventoryFinishedOrderServiceImpl extends ServiceImpl<InventoryFini
         return orderIdList;
     }
 
+    @Transactional(rollbackFor = Exception.class)
+    @Override
+    public void syncYesterdayNoReasonOrderInventory() {
+        // 获取昨日无理由订单
+        List<OrderInfo> orderInfoList = orderService.list(q -> q
+                .eq(OrderInfo::getStatus, OrderStatusEnum.COMPLETION_PRODUCTION.getKey())
+                .ge(OrderInfo::getShippingTime, DateUtil.beginOfDay(DateUtil.yesterday())));
+        List<Long> orderIds = orderInfoList.stream().map(BaseIdPo::getId).collect(Collectors.toList());
+        // 获取在库的成品入库数据
+        List<InventoryFinishedOrder> finishedOrderList = this.list(q -> q.in(InventoryFinishedOrder::getOrderInfoId, orderIds)
+                .eq(InventoryFinishedOrder::getStatus, StatusConstant.YES));
+
+        List<Long> finishedOrderIds = finishedOrderList.stream().map(BaseIdPo::getId).collect(Collectors.toList());
+        if (finishedOrderIds.isEmpty()) {
+            return;
+        }
+        // 入库明细
+        List<InventoryFinishedOrderDetail> detailList = inventoryFinishedOrderDetailService.list(q -> q.in(InventoryFinishedOrderDetail::getInventoryFinishedOrderId, finishedOrderIds));
+        List<Long> detailIds = detailList.stream().map(BaseIdPo::getId).collect(Collectors.toList());
+
+        // 修改为无来源可出库成品
+        this.update(q -> q.set(InventoryFinishedOrder::getOrderInfoId, null)
+                .set(InventoryFinishedOrder::getOrderSkuId, null)
+                .in(BaseIdPo::getId, finishedOrderIds));
+        inventoryFinishedOrderDetailService.update(q -> q.set(InventoryFinishedOrderDetail::getOrderInfoId, null)
+                .set(InventoryFinishedOrderDetail::getOrderSkuId, null)
+                .in(BaseIdPo::getId, detailIds));
+    }
+
 }

sd-business/src/main/java/com/sd/business/service/production/impl/StockPreparationServiceImpl.java

@@ -318,15 +318,15 @@ public class StockPreparationServiceImpl implements StockPreparationService {
                 .set(OrderSku::getStockPreparationTime, stockPreparationTime)
                 .set(OrderSku::getStockPreparationStatus, StatusConstant.YES));
 
-        // 成品库出库
+        // 订单出库
         if (Objects.equals(dto.getOrderStockType(), 1)) {
+            // 成品库出库
             orderFinishedDelivery(list, dto);
-            return;
+        } else {
+            // 半成品出库
+            orderDelivery(list, dto);
         }
 
-        // 订单出库
-        orderDelivery(list, dto);
-
         List<ProductionWorkOrder> productionWorkOrderList = new ArrayList<>();
 
         // 生产工单
@@ -380,99 +380,48 @@ public class StockPreparationServiceImpl implements StockPreparationService {
                 statementOfAccountService.add(statement);
             }
 
-            List<OrderSku> finishedSkuList = new ArrayList<>();
-            for (Long orderId : orderIds) {
-                finishedSkuList.addAll(orderSkuMap.getOrDefault(orderId, Collections.emptyList()));
-            }
-
             // 生产入库
-            inventoryFinishedService.noSourceInWarehousing(finishedSkuList);
-
-            // 无理由订单的快递包材退料
-            List<OrderPackageBom> orderPackageBomList = orderPackageBomService.list(q -> q.in(OrderPackageBom::getOrderId, orderIds));
-            Map<Long, InOutStorageBom> inStorageBomMap = orderPackageBomList.stream()
-                    .map(item -> {
-                        InOutStorageBom inStorageBom = new InOutStorageBom();
-                        inStorageBom.setBomSpecId(item.getBomSpecId());
-                        inStorageBom.setQuantity(item.getQuantity());
-                        return inStorageBom;
-                    }).collect(Collectors.toMap(
-                            InOutStorageBom::getBomSpecId,
-                            Function.identity(),
-                            (v1, v2) -> {
-                                v1.setQuantity(v1.getQuantity().add(v2.getQuantity()));
-                                return v1;
-                            }
-                    ));
-            InOutStorageDto packageBomInStorageDto = new InOutStorageDto();
-            packageBomInStorageDto.setType(InOutTypeEnum.IN.getKey());
-            packageBomInStorageDto.setDetailType(InDetailTypeEnum.RETURN_GOODS.getKey());
-            packageBomInStorageDto.setWarehouseId(WarehouseConstant.PACKAGING_MATERIAL);
-            packageBomInStorageDto.setDepartmentId(DepartmentConstant.SD_SPORTS);
-            packageBomInStorageDto.setApplicant(SecurityUtils.getLoginUser().getUser().getNickName());
-            packageBomInStorageDto.setRemark("无理由订单快递包材退料入库");
-            packageBomInStorageDto.setInOutStorageBomList(new ArrayList<>(inStorageBomMap.values()));
-            inOutStorageService.add(packageBomInStorageDto);
+            inventoryFinishedService.productionWarehousing(orderIds);
         }
 
-        // 把生产工单发送到mq
-        productionWorkOrderService.sendMq(productionWorkOrderList);
-
+        // 成品出库不需要生产裸垫
+        if (Objects.equals(dto.getOrderStockType(), 0)) {
+            // 把生产工单发送到mq
+            productionWorkOrderService.sendMq(productionWorkOrderList);
+        }
     }
 
     private void orderFinishedDelivery(List<StockPreparationVo> list, StockPreparationDto dto) {
         List<Long> orderIdList = list.stream().map(StockPreparationVo::getOrderId).distinct().collect(Collectors.toList());
 
-        // 出库快递包装包材
-        List<OrderPackageBom> orderPackageBomList = orderPackageBomService.list(q -> q.in(OrderPackageBom::getOrderId, orderIdList));
-        if (!orderPackageBomList.isEmpty()) {
-            // 快递包材
-            List<InOutStorageBom> outStorageBomList = orderPackageBomList.stream()
-                    .map(item -> {
-                        InOutStorageBom inOutStorageBom = new InOutStorageBom();
-                        inOutStorageBom.setBomSpecId(item.getBomSpecId());
-                        inOutStorageBom.setQuantity(item.getQuantity());
-                        return inOutStorageBom;
-                    })
-                    .collect(Collectors.toList());
-            productionOut(WarehouseConstant.PACKAGING_MATERIAL, dto, outStorageBomList, StatusConstant.NO);
+        // 查询出委外订单，委外订单不出库主材
+        List<OrderInfo> noReasonOrderList = orderService.list(q -> q
+                .in(BaseIdPo::getId, orderIdList)
+                .eq(OrderInfo::getClassify, OrderClassifyEnum.NO_REASON_ORDER.getKey())
+                .select(BaseIdPo::getId));
+        List<Long> noReasonOrderIds = noReasonOrderList.stream().map(BaseIdPo::getId).collect(Collectors.toList());
+
+        List<Long> orderPackageIds = new ArrayList<>(orderIdList);
+        orderPackageIds.removeAll(noReasonOrderIds);
+
+        if (!orderPackageIds.isEmpty()) {
+            // 出库快递包装包材
+            List<OrderPackageBom> orderPackageBomList = orderPackageBomService.list(q -> q.in(OrderPackageBom::getOrderId, orderPackageIds));
+            if (!orderPackageBomList.isEmpty()) {
+                // 快递包材
+                List<InOutStorageBom> outStorageBomList = orderPackageBomList.stream()
+                        .map(item -> {
+                            InOutStorageBom inOutStorageBom = new InOutStorageBom();
+                            inOutStorageBom.setBomSpecId(item.getBomSpecId());
+                            inOutStorageBom.setQuantity(item.getQuantity());
+                            return inOutStorageBom;
+                        })
+                        .collect(Collectors.toList());
+                productionOut(WarehouseConstant.PACKAGING_MATERIAL, dto, outStorageBomList, StatusConstant.NO);
+            }
         }
         // 成品出库
         inventoryFinishedService.noSourceSaleOutOfWarehouse(orderIdList);
-
-        // 生产工单
-        List<ProductionWorkOrder> productionWorkOrderList = new ArrayList<>();
-        Map<Long, List<StockPreparationVo>> map = list.stream().collect(Collectors.groupingBy(StockPreparationVo::getOrderId));
-        List<OrderSku> orderSkuList = orderSkuService.list(q -> q.in(OrderSku::getOrderId, map.keySet()));
-        // 筛选掉赠品sku
-        List<Long> skuSpecIds = orderSkuList.stream().map(OrderSku::getSkuSpecId).collect(Collectors.toList());
-        Set<Long> giftSkuSpecIds = skuSpecService.getGiftIdListByIdList(skuSpecIds);
-
-        Map<Long, List<OrderSku>> orderSkuMap = orderSkuList.stream()
-                .filter(item -> giftSkuSpecIds.isEmpty() || !giftSkuSpecIds.contains(item.getSkuSpecId()))
-                .collect(Collectors.groupingBy(OrderSku::getOrderId));
-
-        map.forEach((orderId, stockPreparationVoList) -> {
-            StockPreparationVo stockPreparationVo = stockPreparationVoList.get(0);
-            String orderCode = stockPreparationVo.getOrderCode();
-            String orderWlnCode = stockPreparationVo.getOrderWlnCode();
-            addWorkOrder(orderId, ObjectUtil.defaultIfNull(orderWlnCode, orderCode),
-                    orderSkuMap.getOrDefault(orderId, Collections.emptyList()), productionWorkOrderList);
-        });
-
-        skuSpecService.attributeAssign(productionWorkOrderList, ProductionWorkOrder::getSkuSpecId,
-                (item, skuSpec) -> item.setMachinedPanel(skuSpec.getMachinedPanel()));
-
-        // 直接完成生产任务
-        productionWorkOrderList.forEach(item -> {
-            item.setStatus(3);
-            item.setCompleteTime(new Date());
-        });
-
-        orderService.update(q -> q
-                .in(BaseIdPo::getId, orderIdList)
-                .set(OrderInfo::getStatus, OrderStatusEnum.COMPLETION_PRODUCTION.getKey()));
-        productionWorkOrderService.saveBatch(productionWorkOrderList);
     }
 
     @Override
@@ -524,14 +473,32 @@ public class StockPreparationServiceImpl implements StockPreparationService {
 
         List<Long> orderIdList = stockPreparationVoList.stream().map(StockPreparationVo::getOrderId).distinct().collect(Collectors.toList());
         // 查询出委外订单，委外订单不出库主材
-        List<Long> outsourceOrderIds = orderService.list(q -> q
-                        .in(BaseIdPo::getId, orderIdList)
-                        .eq(OrderInfo::getType, 2)
-                        .select(BaseIdPo::getId))
-                .stream().map(BaseIdPo::getId).collect(Collectors.toList());
+        List<OrderInfo> specialOrderList = orderService.list(q -> q
+                .in(BaseIdPo::getId, orderIdList)
+                .and(e -> e.eq(OrderInfo::getType, 2).or().eq(OrderInfo::getClassify, OrderClassifyEnum.NO_REASON_ORDER.getKey()))
+                .select(BaseIdPo::getId, OrderInfo::getType));
+        // 委外订单id集合
+        List<Long> outsourceOrderIds = specialOrderList.stream()
+                .filter(item -> Objects.equals(item.getType(), 2))
+                .map(BaseIdPo::getId)
+                .collect(Collectors.toList());
+        // 无理由订单id集合
+        List<Long> noReasonOrderIds = specialOrderList.stream()
+                .filter(item -> !Objects.equals(item.getType(), 2))
+                .map(BaseIdPo::getId)
+                .collect(Collectors.toList());
+
         List<OrderSku> orderSkuList = orderSkuService.list(q -> q.in(OrderSku::getOrderId, orderIdList));
         List<OrderSkuBom> orderSkuBomList = orderSkuBomService.list(q -> q.in(OrderSkuBom::getOrderId, orderIdList));
-        List<OrderPackageBom> orderPackageBomList = orderPackageBomService.list(q -> q.in(OrderPackageBom::getOrderId, orderIdList));
+        // 无理由订单不出库快递包材
+        List<Long> orderPackageIds = new ArrayList<>(orderIdList);
+        orderPackageIds.removeAll(noReasonOrderIds);
+        List<OrderPackageBom> orderPackageBomList;
+        if (orderPackageIds.isEmpty()) {
+            orderPackageBomList = Collections.emptyList();
+        } else {
+            orderPackageBomList = orderPackageBomService.list(q -> q.in(OrderPackageBom::getOrderId, orderPackageIds));
+        }
         Map<Long, OrderSku> orderSkuMap = orderSkuList.stream().collect(Collectors.toMap(BaseIdPo::getId, Function.identity()));
         // 筛选掉赠品sku
         List<Long> skuSpecIds = orderSkuList.stream().map(OrderSku::getSkuSpecId).collect(Collectors.toList());
@@ -713,7 +680,18 @@ public class StockPreparationServiceImpl implements StockPreparationService {
             outSkuVo.setInventoryQuantity(inventoryMap.getOrDefault(skuSpecId, BigDecimal.ZERO));
         }
 
-        // 获取快递包装包材
+        // 获取快递包装包材，筛选委外订单不出库主材
+        List<OrderInfo> noReasonOrderList = orderService.list(q -> q
+                .in(BaseIdPo::getId, orderIdList)
+                .eq(OrderInfo::getClassify, OrderClassifyEnum.NO_REASON_ORDER.getKey())
+                .select(BaseIdPo::getId));
+        List<Long> noReasonOrderIds = noReasonOrderList.stream().map(BaseIdPo::getId).collect(Collectors.toList());
+        orderIdList.removeAll(noReasonOrderIds);
+
+        if (orderIdList.isEmpty()) {
+            return outBomVoList;
+        }
+
         List<OrderPackageBom> orderPackageBomList = orderPackageBomService.list(q -> q.in(OrderPackageBom::getOrderId, orderIdList));
         if (orderPackageBomList.isEmpty()) {
             return outBomVoList;
@@ -835,17 +813,35 @@ public class StockPreparationServiceImpl implements StockPreparationService {
                 item -> ObjectUtil.defaultIfNull(item.getLockStorage(), StatusConstant.NO),
                 (v1, v2) -> v1)
         );
+        Set<Long> orderIdList = orderIdLockStorageMap.keySet();
         // 查询出委外订单，委外订单不出库主材
-        List<Long> outsourceOrderIds = orderService.list(q -> q
-                        .in(BaseIdPo::getId, orderIdLockStorageMap.keySet())
-                        .eq(OrderInfo::getType, 2)
-                        .select(BaseIdPo::getId))
-                .stream().map(BaseIdPo::getId).collect(Collectors.toList());
+        List<OrderInfo> specialOrderList = orderService.list(q -> q
+                .in(BaseIdPo::getId, orderIdList)
+                .and(e -> e.eq(OrderInfo::getType, 2).or().eq(OrderInfo::getClassify, OrderClassifyEnum.NO_REASON_ORDER.getKey()))
+                .select(BaseIdPo::getId, OrderInfo::getType));
+        // 委外订单id集合
+        List<Long> outsourceOrderIds = specialOrderList.stream()
+                .filter(item -> Objects.equals(item.getType(), 2))
+                .map(BaseIdPo::getId)
+                .collect(Collectors.toList());
+        // 无理由订单id集合
+        List<Long> noReasonOrderIds = specialOrderList.stream()
+                .filter(item -> !Objects.equals(item.getType(), 2))
+                .map(BaseIdPo::getId)
+                .collect(Collectors.toList());
 
-        List<OrderSku> orderSkuList = orderSkuService.list(q -> q.in(OrderSku::getOrderId, orderIdLockStorageMap.keySet()));
-        List<OrderSkuBom> orderSkuBomList = orderSkuBomService.list(q -> q.in(OrderSkuBom::getOrderId, orderIdLockStorageMap.keySet()));
+        List<OrderSku> orderSkuList = orderSkuService.list(q -> q.in(OrderSku::getOrderId, orderIdList));
+        List<OrderSkuBom> orderSkuBomList = orderSkuBomService.list(q -> q.in(OrderSkuBom::getOrderId, orderIdList));
         Map<Long, OrderSku> orderSkuMap = orderSkuList.stream().collect(Collectors.toMap(BaseIdPo::getId, Function.identity()));
-        List<OrderPackageBom> orderPackageBomList = orderPackageBomService.list(q -> q.in(OrderPackageBom::getOrderId, orderIdLockStorageMap.keySet()));
+        // 无理由订单不出库快递包材
+        List<Long> orderPackageIds = new ArrayList<>(orderIdList);
+        orderPackageIds.removeAll(noReasonOrderIds);
+        List<OrderPackageBom> orderPackageBomList;
+        if (orderPackageIds.isEmpty()) {
+            orderPackageBomList = Collections.emptyList();
+        } else {
+            orderPackageBomList = orderPackageBomService.list(q -> q.in(OrderPackageBom::getOrderId, orderPackageIds));
+        }
         // 筛选掉赠品sku
         List<Long> skuSpecIds = orderSkuList.stream().map(OrderSku::getSkuSpecId).collect(Collectors.toList());
         Set<Long> giftSkuSpecIds = skuSpecService.getGiftIdListByIdList(skuSpecIds);

sd-wln/src/main/java/com/sd/wln/service/impl/OrderHandleServiceImpl.java

@@ -1,8 +1,11 @@
 package com.sd.wln.service.impl;
 
 import cn.hutool.core.collection.ListUtil;
+import cn.hutool.core.util.ObjectUtil;
 import com.alibaba.fastjson2.JSONObject;
 import com.baomidou.dynamic.datasource.annotation.DSTransactional;
+import com.fjhx.tenant.entity.dict.po.DictCommonData;
+import com.fjhx.tenant.service.dict.DictCommonDataService;
 import com.ruoyi.common.constant.StatusConstant;
 import com.ruoyi.common.exception.ServiceException;
 import com.ruoyi.framework.mybatis.holder.LogicHolder;
@@ -31,6 +34,9 @@ public class OrderHandleServiceImpl implements OrderHandleService {
     @Autowired
     private WlnOrderService wlnOrderService;
 
+    @Autowired
+    private DictCommonDataService dictCommonDataService;
+
     @DSTransactional
     @Override
     public synchronized void resynchronization(ResynchronizationDto dto) {
@@ -68,6 +74,12 @@ public class OrderHandleServiceImpl implements OrderHandleService {
         Map<String, OrderInfo> orderInfoMap = list.stream().collect(Collectors.toMap(OrderInfo::getWlnCode, Function.identity()));
         Map<String, List<OrderInfo>> map = list.stream().collect(Collectors.groupingBy(OrderInfo::getWlnStorageCode));
 
+        List<String> storageCodeList = getStorageCodeList();
+        if (ObjectUtil.isEmpty(storageCodeList)) {
+            log.error("订单手动同步失败，仓库字典:warehouse_code 为空");
+            return;
+        }
+
         for (String warehouseCode : map.keySet()) {
             List<JSONObject> wlnOrderList = new ArrayList<>();
 
@@ -91,6 +103,12 @@ public class OrderHandleServiceImpl implements OrderHandleService {
             OrderContext context = new OrderContext(warehouseCode, wlnOrderList);
 
             for (JSONObject wlnOrder : wlnOrderList) {
+                // 非指定事业部订单不同步
+                String storageCode = wlnOrder.getString("storage_code");
+                if (!storageCodeList.contains(storageCode)) {
+                    continue;
+                }
+
                 OrderInfo orderInfo = orderInfoMap.get(wlnOrder.getString("trade_no"));
                 if (Objects.equals(wlnOrder.getLong("modify_time"), orderInfo.getWlnModifyTimestamp())) {
                     continue;
@@ -103,4 +121,13 @@ public class OrderHandleServiceImpl implements OrderHandleService {
 
     }
 
+    private List<String> getStorageCodeList() {
+        List<DictCommonData> warehouseCodeList = dictCommonDataService.list(
+                q -> q.eq(DictCommonData::getDictCode, "warehouse_code"));
+        if (warehouseCodeList.isEmpty()) {
+            return Collections.emptyList();
+        }
+        return warehouseCodeList.stream().map(DictCommonData::getDictValue).collect(Collectors.toList());
+    }
+
 }

sd-wln/src/main/java/com/sd/wln/service/impl/WlnOrderServiceImpl.java

@@ -773,7 +773,6 @@ public class WlnOrderServiceImpl implements WlnOrderService {
         List<OrderSkuBom> saveOrderSkuBomList = context.getSaveOrderSkuBomList();
         List<OrderSkuProductionCost> saveOrderSkuProductionCostList = context.getSaveOrderSkuProductionCostList();
         List<OrderPackageBom> orderPackageBomList = context.getOrderPackageBomList();
-        Map<Long, List<OrderSku>> existOrderSkuMap = context.getExistOrderSkuMap();
 
         if (!saveOrderList.isEmpty()) {
             orderService.saveBatch(saveOrderList);
@@ -782,18 +781,21 @@ public class WlnOrderServiceImpl implements WlnOrderService {
             orderService.updateBatchById(updateOrderList);
         }
         if (!saveStatementOrderList.isEmpty()) {
-            saveStatementOrderList.forEach(item -> {
-                // 生成对账单
+            Map<Long, List<OrderInfo>> saveStatementOrderMap = saveStatementOrderList.stream().collect(Collectors.groupingBy(OrderInfo::getDepartmentId));
+            // 生成对账单
+            saveStatementOrderMap.forEach((departmentId, orderList) -> {
+                List<Long> orderIds = orderList.stream().map(BaseIdPo::getId).collect(Collectors.toList());
                 StatementOfAccountDto statement = new StatementOfAccountDto();
-                statement.setDepartmentId(item.getDepartmentId());
-                statement.setOrderIdList(Collections.singletonList(item.getId()));
+                statement.setDepartmentId(departmentId);
+                statement.setOrderIdList(orderIds);
                 statementOfAccountService.add(statement);
-
-                // 生产入库
-                inventoryFinishedService.noSourceInWarehousing(existOrderSkuMap.getOrDefault(item.getId(), Collections.emptyList()));
             });
 
             List<Long> noReasonOrderIds = saveStatementOrderList.stream().map(BaseIdPo::getId).collect(Collectors.toList());
+
+            // 生产入库
+            inventoryFinishedService.productionWarehousing(noReasonOrderIds);
+
             // 无理由订单的快递包材退料
             List<OrderPackageBom> noReasonOrderPackageBomList = orderPackageBomService.list(q -> q.in(OrderPackageBom::getOrderId, noReasonOrderIds));
             Map<Long, InOutStorageBom> inStorageBomMap = noReasonOrderPackageBomList.stream()