[fix]

修改采购计划添加采购订单前端页面实现 ：动态监听如果更改了共享库存占用数按照下面规则更新这两个数据
设置本次采购数=(待采购数-共享库存占用数)，但需满足0 <= 本次采购数 <= 待采购数
待采购数=(计划采购数-实际采购数-共享库存占用数-作废数)
修改根据因为本次采购数的动态更新,相应的不含税总价和含税总价也要自动更新
修改请购单添加采购计划,主表和子表去掉对待采购数的赋值
重写采购计划第二步添加采购订单的后端方法,去掉对物料数据的合并,新增通过物料查询仓库库存查询记录,按照以下规则计算:
字段(待采购数):统计剩余未采购的数量，待采购数=(计划采购数-实际采购数-共享库存占用数-作废数)
 字段(共享可用库存数):仓库可被占用的库存
 字段(本次占用共享库存数):必填;默认为0，若共享可用库存数>0，则默认=共享可用库存数，可修改，需0<本次占用共享库存数≤共享可用库存数;若共享可用库存数=0，则不可输入修改
字段(本次采购数):必填;默认为=(待采购数-本次占用共享库存数);可修改需0<本次采购数<待采购数;
重写采购计划添加采购订单更新采购计划主表和采购计划子表的方法:实现下面的效果:每次添加采购单后，因为传过来的物料可能是多个采购计划单物料表合并的数据，【本次占用共享库存数】和【本次采购数】按照已选【采购计划单】创建时间正序(时间越早，则优先)进行核销，并且按照时间先后更新其本次占用库存数和实际采购数，实际采购数就为本次计划采购数。
采购计划状态按照以下规则更新:
部分申请:0<(实际采购数+共享库存占用数+作废数)<计划采购数;可添加采购订单
全部申请:0<(实际采购数+共享库存占用数+作废数)=计划采购数，作废数<计划采购数;不可添加采购订单

ruoyi-admin/src/main/java/com/ruoyi/purchase/service/impl/PurchaseOrderServiceImpl.java

@@ -43,8 +43,10 @@ import com.ruoyi.system.service.ISysAttachFileService;
 import com.ruoyi.system.service.ISysAttachService;
 import com.ruoyi.system.service.ISysRoleService;
 import com.ruoyi.system.service.ISysSupplierService;
+import com.ruoyi.warehouse.domain.WarehouseInventoryInquiry;
 import com.ruoyi.warehouse.domain.WarehouseStorageOrder;
 import com.ruoyi.warehouse.domain.WarehouseStorageOrderDetail;
+import com.ruoyi.warehouse.mapper.WarehouseInventoryInquiryMapper;
 import com.ruoyi.warehouse.mapper.WarehouseStorageOrderDetailMapper;
 import com.ruoyi.warehouse.mapper.WarehouseStorageOrderMapper;
 import lombok.extern.slf4j.Slf4j;
@@ -155,6 +157,8 @@ public class PurchaseOrderServiceImpl implements IPurchaseOrderService
     @Autowired
     private ServerConfig serverConfig;
 
+    @Autowired
+    private WarehouseInventoryInquiryMapper inventoryInquiryMapper;
 
 
     /**
@@ -455,16 +459,46 @@ public class PurchaseOrderServiceImpl implements IPurchaseOrderService
             String materialNo = purchasePlanSelectMaterialVo.getMaterialNo();
            // Integer thisPurchaseNum = purchasePlanSelectMaterialVo.getThisPurchaseNum();
 
-            // 获取旧数据中相同物料编号的数据
-            List<PurchasePlanChild> oldChildren = oldDataGroupedByMaterialNo.get(materialNo);
 
+            //共享库存占用数
+            Integer sharedInventoryOccupancyNum = purchasePlanSelectMaterialVo.getSharedInventoryOccupancyNum();
+            //库存查询
+            WarehouseInventoryInquiry warehouseInventoryInquiry = inventoryInquiryMapper.selectWarehouseInventoryInquiryByMaterialNo(materialNo);
+            if ( sharedInventoryOccupancyNum != null  && sharedInventoryOccupancyNum > 0){
+                Integer sharedAvailableStockNum = Optional.ofNullable(warehouseInventoryInquiry.getSharedAvailableStockNum()).orElse(0);
+
+                Integer availableStockNum = Optional.ofNullable(warehouseInventoryInquiry.getAvailableStockNum()).orElse(0);
+                Integer lockStockNum = Optional.ofNullable(warehouseInventoryInquiry.getLockStockNum()).orElse(0);
+                warehouseInventoryInquiry.setAvailableStockNum(availableStockNum - sharedInventoryOccupancyNum);
+                warehouseInventoryInquiry.setSharedAvailableStockNum(sharedAvailableStockNum - sharedInventoryOccupancyNum);
+                warehouseInventoryInquiry.setLockStockNum(lockStockNum + sharedInventoryOccupancyNum);
+                warehouseInventoryInquiry.setUpdateTime(new Date());
+                warehouseInventoryInquiry.setUpdateBy(ShiroUtils.getLoginName());
+                int updateInventoryInquiry = inventoryInquiryMapper.updateWarehouseInventoryInquiry(warehouseInventoryInquiry);
+                if (updateInventoryInquiry <= 0){
+                    throw new BusinessException("更新库存查询记录失败");
+                }
+
+            }
+
+            //本次采购数
             Integer thisPurchaseNum = purchasePlanSelectMaterialVo.getThisPurchaseNum();
 
-            int oldPurchaseNumSum = oldChildren.stream().mapToInt(PurchasePlanChild::getPurchaseNum).sum();
+            //共享可用库存
+            Integer sharedAvailableInventoryNum = purchasePlanSelectMaterialVo.getSharedAvailableInventoryNum();
 
-            if (oldPurchaseNumSum < thisPurchaseNum){
+            //待采购数
+            Integer purchaseNum = purchasePlanSelectMaterialVo.getPurchaseNum();
+
+            if (purchaseNum < thisPurchaseNum){
                 throw new BusinessException("本次采购数量不能大于待采购数量");
             }
+            // 获取旧数据中相同物料编号的数据
+            List<PurchasePlanChild> oldChildren = oldDataGroupedByMaterialNo.get(materialNo);
+
+
+            // 优先使用本次占用共享库存
+            Integer remainingSharedInventoryOccupancyNum = Math.min(sharedInventoryOccupancyNum, thisPurchaseNum);
 
             if (!CollectionUtils.isEmpty(oldChildren)) {
                 // 按照订单创建时间远离当前时间排序（即由远及近）
@@ -472,38 +506,51 @@ public class PurchaseOrderServiceImpl implements IPurchaseOrderService
 
             for (PurchasePlanChild oldChild : oldChildren) {
 
-                Integer purchaseNum = oldChild.getPurchaseNum();
+               // Integer oldPurchaseNum = Optional.ofNullable(oldChild.getPurchaseNum()).orElse(0);//待采购数
+                Integer planPurchaseNum = Optional.ofNullable(oldChild.getPlanPurchaseNum()).orElse(0);//计划采购数
+                Integer oldActualPurchaseNum = Optional.ofNullable(oldChild.getActualPurchaseNum()).orElse(0);//实际采购数
+                Integer cancelNum = Optional.ofNullable(oldChild.getCancelNum()).orElse(0);//作废数
+                Integer oldSharedInventoryOccupancyNum = Optional.ofNullable(oldChild.getSharedInventoryOccupancyNum()).orElse(0);//共享库存占用数
 
-                if (thisPurchaseNum <= 0) break;  // 如果本次采购数已分配完毕则退出循环
-
-                if (purchaseNum >= thisPurchaseNum) {
-                    // 当前记录的待采购数足够覆盖剩余的本次采购数
-                    oldChild.setActualPurchaseNum(thisPurchaseNum);
-                    oldChild.setPurchaseNum(purchaseNum - thisPurchaseNum);
-                    thisPurchaseNum = 0;  // 本次采购数分配完毕
-                } else {
-                    // 当前记录的待采购数不足以覆盖剩余的本次采购数
-                    oldChild.setActualPurchaseNum(purchaseNum);
-                    thisPurchaseNum -= purchaseNum;
-                    oldChild.setPurchaseNum(0);  // 该记录的待采购数清零
+                if (remainingSharedInventoryOccupancyNum <= 0){
+                    if (purchaseNum <= 0){
+                        // 更新状态
+                        updateChildPurchasePlanStatus(oldChild,sharedInventoryOccupancyNum,thisPurchaseNum,purchaseNum);
+                        // 更新其他字段
+                        oldChild.setUpdateTime(new Date());
+                        oldChild.setUpdateBy(ShiroUtils.getLoginName());
+                        //oldChild.setThisPurchaseNum(purchasePlanSelectMaterialVo.getThisPurchaseNum());
+                        oldChild.setMaterialNoRmbSum(purchasePlanSelectMaterialVo.getMaterialNoRmbSum());
+                        oldChild.setMaterialRmbSum(purchasePlanSelectMaterialVo.getMaterialRmbSum());
+                        oldChild.setLatestQuoteRmb(purchasePlanSelectMaterialVo.getLatestQuoteRmb());
+                        oldChild.setThisPurchaseNum(thisPurchaseNum);
+                        int result = purchasePlanChildMapper.updatePurchasePlanChild(oldChild);
+                        if (result <= 0){
+                            throw new BusinessException("更新采购计划子表数据失败");
+                        }
+                    }
+                    break;  // 如果本次采购数和共享库存都已分配完毕则退出循环
                 }
 
-            /*
-            * 部分申请:0<(实际采购数+共享库存占用数+作废数)<计划采购数;可添加采购订单
-            * 全部申请:0<(实际采购数+共享库存占用数+作废数)=计划采购数，作废数<计划采购数;不可添加采购订单
-            * */
+
                 // 更新状态
-                Integer planPurchaseNum = oldChild.getPlanPurchaseNum();
-                if (oldChild.getActualPurchaseNum().equals(planPurchaseNum)) {
-                    oldChild.setPurchasePlanStatus("2"); // 全部申请
-                } else {
-                    oldChild.setPurchasePlanStatus("1"); // 部分申请
+                updateChildPurchasePlanStatus(oldChild,sharedInventoryOccupancyNum,thisPurchaseNum,purchaseNum);
+
+                if (oldSharedInventoryOccupancyNum == 0){
+                    oldChild.setSharedInventoryOccupancyNum(sharedInventoryOccupancyNum);
+                }else {
+                    oldChild.setSharedInventoryOccupancyNum(oldSharedInventoryOccupancyNum + sharedInventoryOccupancyNum);
+                }
+                if (oldActualPurchaseNum == 0){
+                    oldChild.setActualPurchaseNum(thisPurchaseNum);
+                }else {
+                    oldChild.setActualPurchaseNum(oldActualPurchaseNum + thisPurchaseNum);
                 }
 
                 // 更新其他字段
                 oldChild.setUpdateTime(new Date());
                 oldChild.setUpdateBy(ShiroUtils.getLoginName());
-                oldChild.setThisPurchaseNum(purchasePlanSelectMaterialVo.getThisPurchaseNum());
+                //oldChild.setThisPurchaseNum(purchasePlanSelectMaterialVo.getThisPurchaseNum());
                 oldChild.setMaterialNoRmbSum(purchasePlanSelectMaterialVo.getMaterialNoRmbSum());
                 oldChild.setMaterialRmbSum(purchasePlanSelectMaterialVo.getMaterialRmbSum());
                 oldChild.setLatestQuoteRmb(purchasePlanSelectMaterialVo.getLatestQuoteRmb());
@@ -514,12 +561,58 @@ public class PurchaseOrderServiceImpl implements IPurchaseOrderService
             if (result <= 0){
                 throw new BusinessException("更新采购计划子表数据失败");
             }
+
             }
             }
         }
         return purchasePlanChildren;
     }
 
+    // 定义一个方法来更新采购计划状态
+    private void updateChildPurchasePlanStatus(PurchasePlanChild oldChild,Integer sharedInventoryOccupancyNum,Integer thisPurchaseNum,Integer purchaseNum) {
+
+        /*
+         * 部分申请:0<(实际采购数+共享库存占用数+作废数)<计划采购数;可添加采购订单
+         * 全部申请:0<(实际采购数+共享库存占用数+作废数)=计划采购数，作废数<计划采购数;不可添加采购订单
+         * */
+
+        Integer oldSharedInventoryOccupancyNum = Optional.ofNullable(oldChild.getSharedInventoryOccupancyNum()).orElse(0);//共享库存占用数
+        Integer planPurchaseNum = Optional.ofNullable(oldChild.getPlanPurchaseNum()).orElse(0);//计划采购数
+        Integer actualPurchaseNum = Optional.ofNullable(oldChild.getActualPurchaseNum()).orElse(0);//实际采购数
+        Integer cancelNum = Optional.ofNullable(oldChild.getCancelNum()).orElse(0);//作废数
+
+        if (oldSharedInventoryOccupancyNum == 0){
+            oldSharedInventoryOccupancyNum = sharedInventoryOccupancyNum;
+        }else {
+            oldSharedInventoryOccupancyNum += sharedInventoryOccupancyNum;
+        }
+
+
+        if (purchaseNum <= 0){
+            actualPurchaseNum = thisPurchaseNum;
+        }else {
+            actualPurchaseNum += thisPurchaseNum;
+        }
+
+
+        Integer totalApplied = actualPurchaseNum + oldSharedInventoryOccupancyNum + cancelNum;
+
+
+
+        if (totalApplied == 0 && cancelNum < planPurchaseNum) {
+            oldChild.setPurchasePlanStatus("0"); // 待申请
+        } else if (0 < totalApplied && totalApplied < planPurchaseNum) {
+            oldChild.setPurchasePlanStatus("1"); // 部分申请
+        } else if (totalApplied.equals(planPurchaseNum) && cancelNum < planPurchaseNum) {
+            oldChild.setPurchasePlanStatus("2"); // 全部申请
+        } else {
+            throw new BusinessException("采购计划状态不符合预期");
+        }
+    }
+
+
+
+
     //处理采购计划主表
     private void updatePurchasePlanByAddPurchaseOrder(AddPurchaseOrder addPurchaseOrder,List<PurchasePlanChild> purchasePlanChildList) {
 
@@ -530,7 +623,7 @@ public class PurchaseOrderServiceImpl implements IPurchaseOrderService
 
         List<PurchasePlanSelectMaterialVo> purchasePlanSelectMaterialVoList = addPurchaseOrder.getPurchasePlanSelectMaterialVoList();
 
-
+        PurchasePlanTwo purchasePlanTwo = addPurchaseOrder.getPurchasePlanTwo();
 
         PurchasePlanOne purchasePlanOne = addPurchaseOrder.getPurchasePlanOne();
         String purchasePlanCodes = purchasePlanOne.getPurchasePlanCodes();
@@ -563,15 +656,28 @@ public class PurchaseOrderServiceImpl implements IPurchaseOrderService
                     purchasePlan.setActualPurchaseSum(0);
                 }
 
-                // 累加 actualPurchaseSum
+                Integer planPurchaseSum = purchasePlan.getPlanPurchaseSum();//计划采购数
+
+                // 累加 实际采购数 actualPurchaseSum
                 int actualPurchaseSum = children.stream()
                         .mapToInt(PurchasePlanChild::getActualPurchaseNum)
                         .sum();
                 purchasePlan.setActualPurchaseSum(purchasePlan.getActualPurchaseSum() + actualPurchaseSum);
 
-                // 更新 purchaseSum
-                int currentPurchaseSum = purchasePlan.getPurchaseSum();
-                purchasePlan.setPurchaseSum(currentPurchaseSum - actualPurchaseSum);
+
+                //更新共享库存占用总数 sharedInventoryOccupancySum
+                Integer sharedInventoryOccupancySum = purchasePlanTwo.getSharedInventoryOccupancySum();
+                purchasePlan.setSharedInventoryOccupancySum(sharedInventoryOccupancySum);
+
+                //待采购数=(计划采购数-实际采购数-共享库存占用数-作废数)
+                // 更新 待采购数 purchaseSum
+                Integer currentPurchaseSum = purchasePlan.getPurchaseSum();
+                currentPurchaseSum = planPurchaseSum - purchasePlan.getActualPurchaseSum() - purchasePlan.getSharedInventoryOccupancySum() - purchasePlan.getCancelSum();
+                purchasePlan.setPurchaseSum(currentPurchaseSum);
+
+
+                //计算用于改变申请状态的数据
+                Integer totalNum = purchasePlan.getActualPurchaseSum() + purchasePlan.getSharedInventoryOccupancySum() + purchasePlan.getCancelSum();
 
                 // 计算合计值
                 double totalNoRmbSum = children.stream().mapToDouble(vo -> vo.getMaterialNoRmbSum().doubleValue()).sum();
@@ -590,9 +696,9 @@ public class PurchaseOrderServiceImpl implements IPurchaseOrderService
                 purchasePlan.setNoRmbSum(totalBigDecimalNoRmbSum.add(currentNoRmbSum));
 
                 // 更新采购计划状态
-                if (purchasePlan.getActualPurchaseSum() < purchasePlan.getPlanPurchaseSum()) {
+                if (totalNum < purchasePlan.getPlanPurchaseSum()) {
                     purchasePlan.setPurchasePlanStatus("1");
-                } else if (purchasePlan.getActualPurchaseSum().equals(purchasePlan.getPlanPurchaseSum())) {
+                } else if (totalNum.equals(purchasePlan.getPlanPurchaseSum())) {
                     purchasePlan.setPurchasePlanStatus("2");
                 }
 
@@ -713,7 +819,6 @@ public class PurchaseOrderServiceImpl implements IPurchaseOrderService
         // 用于存储每个采购计划的总变动量
         Map<String, Integer> planSumChanges = new HashMap<>();
 
-        // 将采购订单子表中的实际采购数量分配给采购计划子表
         // 将采购订单子表中的实际采购数量分配给采购计划子表
         for (PurchaseOrderChild orderChild : purchaseOrderChildList) {
             String materialNo = orderChild.getMaterialNo();

ruoyi-admin/src/main/java/com/ruoyi/purchase/service/impl/PurchasePlanServiceImpl.java

@@ -26,6 +26,8 @@ import com.ruoyi.system.mapper.SysMakeOrderMapper;
 import com.ruoyi.system.mapper.SysMakeorderBomMapper;
 import com.ruoyi.system.mapper.SysSalesOrderChildMapper;
 import com.ruoyi.system.mapper.SysSupplierMapper;
+import com.ruoyi.warehouse.domain.WarehouseInventoryInquiry;
+import com.ruoyi.warehouse.mapper.WarehouseInventoryInquiryMapper;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
@@ -79,7 +81,8 @@ public class PurchasePlanServiceImpl implements IPurchasePlanService
     @Autowired
     private SysMakeorderBomMapper sysMakeorderBomMapper;
 
-
+    @Autowired
+    private WarehouseInventoryInquiryMapper warehouseInventoryInquiryMapper;
 
 
     /**
@@ -247,47 +250,90 @@ public class PurchasePlanServiceImpl implements IPurchasePlanService
                                 item.setMaterialRmbSum(quoteHistory.getMaterialRmb());
                             }
                             return item;
-                        },
-                        (existingItem, newItem) -> {
-                            existingItem.setPurchaseNum(
-                                    (existingItem.getPurchaseNum() != null ? existingItem.getPurchaseNum() : 0) +
-                                            (newItem.getPurchaseNum() != null ? newItem.getPurchaseNum() : 0)
-                            );
-                            existingItem.setSharedAvailableInventoryNum(
-                                    (existingItem.getSharedAvailableInventoryNum() != null ? existingItem.getSharedAvailableInventoryNum() : 0) +
-                                            (newItem.getSharedAvailableInventoryNum() != null ? newItem.getSharedAvailableInventoryNum() : 0)
-                            );
-                            existingItem.setLatestQuoteRmb(
-                                    (existingItem.getLatestQuoteRmb() != null ? existingItem.getLatestQuoteRmb() : BigDecimal.ZERO)
-                                            .add(newItem.getLatestQuoteRmb() != null ? newItem.getLatestQuoteRmb() : BigDecimal.ZERO)
-                            );
-                            existingItem.setMaterialNoRmbSum(
-                                    (existingItem.getMaterialNoRmbSum() != null ? existingItem.getMaterialNoRmbSum() : BigDecimal.ZERO)
-                                            .add(newItem.getMaterialNoRmbSum() != null ? newItem.getMaterialNoRmbSum() : BigDecimal.ZERO)
-                            );
-                            existingItem.setMaterialRmbSum(
-                                    (existingItem.getMaterialRmbSum() != null ? existingItem.getMaterialRmbSum() : BigDecimal.ZERO)
-                                            .add(newItem.getMaterialRmbSum() != null ? newItem.getMaterialRmbSum() : BigDecimal.ZERO)
-                            );
-                            return existingItem;
                         }
+//                        (existingItem, newItem) -> {
+//                            existingItem.setPurchaseNum(
+//                                    (existingItem.getPurchaseNum() != null ? existingItem.getPurchaseNum() : 0) +
+//                                            (newItem.getPurchaseNum() != null ? newItem.getPurchaseNum() : 0)
+//                            );
+//                            existingItem.setSharedAvailableInventoryNum(
+//                                    (existingItem.getSharedAvailableInventoryNum() != null ? existingItem.getSharedAvailableInventoryNum() : 0) +
+//                                            (newItem.getSharedAvailableInventoryNum() != null ? newItem.getSharedAvailableInventoryNum() : 0)
+//                            );
+//                            existingItem.setLatestQuoteRmb(
+//                                    (existingItem.getLatestQuoteRmb() != null ? existingItem.getLatestQuoteRmb() : BigDecimal.ZERO)
+//                                            .add(newItem.getLatestQuoteRmb() != null ? newItem.getLatestQuoteRmb() : BigDecimal.ZERO)
+//                            );
+//                            existingItem.setMaterialNoRmbSum(
+//                                    (existingItem.getMaterialNoRmbSum() != null ? existingItem.getMaterialNoRmbSum() : BigDecimal.ZERO)
+//                                            .add(newItem.getMaterialNoRmbSum() != null ? newItem.getMaterialNoRmbSum() : BigDecimal.ZERO)
+//                            );
+//                            existingItem.setMaterialRmbSum(
+//                                    (existingItem.getMaterialRmbSum() != null ? existingItem.getMaterialRmbSum() : BigDecimal.ZERO)
+//                                            .add(newItem.getMaterialRmbSum() != null ? newItem.getMaterialRmbSum() : BigDecimal.ZERO)
+//                            );
+//                            return existingItem;
+//                        }
                 ));
 
         // 将合并后的数据转换为列表
         List<PurchasePlanChild> mergedList = new ArrayList<>(mergedMap.values());
 
+//        mergedList.forEach(item->{
+//            WarehouseInventoryInquiry warehouseInventoryInquiry = warehouseInventoryInquiryMapper.selectWarehouseInventoryInquiryByMaterialNo(item.getMaterialNo());
+//            //字段(共享库存占用数):必填;默认为0，若共享可用库存数>0，则默认=共享可用库存数，可修改;需0<=共享库存占用数<=共享可用库存数
+//            //字段(本次采购数):必填;默认为=(待采购数-共享库存占用数);可修改需0<本次采购数<待采购数;
+//            //字段(待采购数):统计剩余未采购的数量，待采购数=(计划采购数-实际采购数-共享库存占用数-作废数)
+//            item.setSharedAvailableInventoryNum(warehouseInventoryInquiry.getSharedAvailableStockNum());//共享可用库存数
+//            Integer planPurchaseNum = item.getPlanPurchaseNum();//计划采购数
+//            Integer actualPurchaseNum = item.getActualPurchaseNum();//实际采购数
+//            Integer sharedInventoryOccupancyNum = item.getSharedInventoryOccupancyNum();//共享库存占用数
+//            Integer cancelNum = item.getCancelNum();//作废数
+//            Integer thisPurchaseNum = item.getThisPurchaseNum();//本次采购数
+//            if (item.getSharedAvailableInventoryNum() != null && item.getSharedAvailableInventoryNum() > 0){
+//                item.setSharedInventoryOccupancyNum(item.getSharedAvailableInventoryNum());
+//            }else {
+//                item.setSharedInventoryOccupancyNum(0);
+//            }
+//        });
+
+        mergedList.forEach(item -> {
+            // 获取库存查询信息
+            WarehouseInventoryInquiry warehouseInventoryInquiry = warehouseInventoryInquiryMapper.selectWarehouseInventoryInquiryByMaterialNo(item.getMaterialNo());
+
+            // 设置共享可用库存数，默认为0
+            Integer sharedAvailableStockNum = Optional.ofNullable(warehouseInventoryInquiry.getSharedAvailableStockNum()).orElse(0);
+            item.setSharedAvailableInventoryNum(sharedAvailableStockNum);
+
+            // 计划采购数、实际采购数、作废数
+            Integer planPurchaseNum = Optional.ofNullable(item.getPlanPurchaseNum()).orElse(0);
+            Integer actualPurchaseNum = Optional.ofNullable(item.getActualPurchaseNum()).orElse(0);
+            Integer cancelNum = Optional.ofNullable(item.getCancelNum()).orElse(0);
+
+            // 设置共享库存占用数，默认为0或共享可用库存数（如果后者大于0）
+            Integer sharedInventoryOccupancyNum = 0;
+            if (sharedAvailableStockNum > 0) {
+                sharedInventoryOccupancyNum = sharedAvailableStockNum;
+            } else {
+                sharedInventoryOccupancyNum = 0;
+            }
+            item.setSharedInventoryOccupancyNum(sharedInventoryOccupancyNum);
+
+            // 计算待采购数
+            Integer purchaseNum = Math.max(0, planPurchaseNum - actualPurchaseNum - sharedInventoryOccupancyNum - cancelNum);
+            item.setPurchaseNum(purchaseNum);
 
+            // 设置本次采购数，默认为=(待采购数-共享库存占用数)，但需满足0 <= 本次采购数 <= 待采购数
+            Integer thisPurchaseNum = Math.max(0, purchaseNum - sharedInventoryOccupancyNum);
+            thisPurchaseNum = Math.min(thisPurchaseNum, purchaseNum); // 确保本次采购数不超过待采购数
 
-        mergedList.forEach(item->{
-//字段(本次占用共享库存数):必填;默认为0，若共享可用库存数>0，则默认=共享可用库存数，可修改;需0<=本次占用共享库存数<=共享可用库存数
-            if (item.getSharedAvailableInventoryNum() != null && item.getSharedAvailableInventoryNum() > 0){
-                item.setSharedInventoryOccupancyNum(item.getSharedAvailableInventoryNum());
-            }else {
-                item.setSharedInventoryOccupancyNum(0);
-            }
+//            item.setMaterialRmbSum(item.getMaterialRmbSum().multiply(BigDecimal.valueOf(thisPurchaseNum)));
+//            item.setMaterialNoRmbSum(item.getMaterialNoRmbSum().multiply(BigDecimal.valueOf(thisPurchaseNum)));
+            item.setThisPurchaseNum(thisPurchaseNum);
         });
+
         //过滤掉待采购数量 <= 0的数据
-        mergedList = mergedList.stream().filter(item->item.getPurchaseNum() > 0).collect(Collectors.toList());
+       // mergedList = mergedList.stream().filter(item->item.getPurchaseNum() > 0).collect(Collectors.toList());
 
         //过滤掉采购计划状态为全部申请和全部作废的数据 2为全部申请、3为全部作废
         mergedList = mergedList.stream().filter(item->!item.getPurchasePlanStatus().equals("2") || !item.getPurchasePlanStatus().equals("3")).collect(Collectors.toList());
@@ -438,10 +484,10 @@ public class PurchasePlanServiceImpl implements IPurchasePlanService
                 orderNum = oldMakeorderBom.getOrderNum();
 
                 purchasePlanChild.setPlanPurchaseNum(orderNum * filterUniqueBom.getUseNum());
-                purchasePlanChild.setPurchaseNum(orderNum * filterUniqueBom.getUseNum());
+                //purchasePlanChild.setPurchaseNum(orderNum * filterUniqueBom.getUseNum());
             }else {
                 purchasePlanChild.setPlanPurchaseNum(filterUniqueBom.getOrderNum());
-                purchasePlanChild.setPurchaseNum(filterUniqueBom.getOrderNum());
+                //purchasePlanChild.setPurchaseNum(filterUniqueBom.getOrderNum());
             }
             purchasePlanChild.setPurchasePlanStatus("0");
             purchasePlanChild.setPurchasePlanCode(purchasePlanCode);

ruoyi-admin/src/main/java/com/ruoyi/system/service/impl/BaseRequisitioningOrderServiceImpl.java

@@ -636,7 +636,7 @@ public class BaseRequisitioningOrderServiceImpl implements IBaseRequisitioningOr
                 purchasePlanChild.setMaterialProcessMethod(requisitioningOrderDetail.getProcessMethod());
                 purchasePlanChild.setMaterialType(requisitioningOrderDetail.getMaterialType());
                 purchasePlanChild.setPlanPurchaseNum(requisitioningOrderDetail.getMaterialNum());
-                purchasePlanChild.setPurchaseNum(requisitioningOrderDetail.getMaterialNum());
+               // purchasePlanChild.setPurchaseNum(requisitioningOrderDetail.getMaterialNum());
                 purchasePlanChild.setCreateTime(new Date());
                 purchasePlanChild.setCreateBy(loginName);
                 purchasePlanChildList.add(purchasePlanChild);
@@ -652,7 +652,7 @@ public class BaseRequisitioningOrderServiceImpl implements IBaseRequisitioningOr
             purchasePlan.setPurchasePlanType("2");
             purchasePlan.setMaterialSum(materialAmount);
             purchasePlan.setPlanPurchaseSum(materialNumSum);
-            purchasePlan.setPurchaseSum(materialNumSum);
+            //purchasePlan.setPurchaseSum(materialNumSum);
 
             purchasePlan.setCreateBy(requisitioningOrder.getCreateBy());
             purchasePlan.setApplyUser(requisitioningOrder.getApplyUser());

ruoyi-admin/src/main/resources/templates/purchase/purchasePlan/addPurchaseOrder.html

@@ -561,19 +561,25 @@ animation-fill-mode: none;
         {
           title: '待采购数',
           field: 'purchaseNum',
+          formatter: function(value, row) {
+            if (row) {
+              return calculatePurchaseNum(row);
+            }
+            return value || '';
+          }
         },
         {
-          title: '共享库存占用数',
-          field: 'sharedInventoryOccupancyNum',
+          title: '共享可用库存数',
+          field: 'sharedAvailableInventoryNum',
         },
         {
           title: '本次占用共享库存数',
-          field: 'sharedAvailableInventoryNum',
+          field: 'sharedInventoryOccupancyNum',
           editable: {
 
             //动态禁用行内编辑
             noEditFormatter: function(value, row, index){
-              if (row.sharedInventoryOccupancyNum === 0){
+              if (row.sharedAvailableInventoryNum === 0 &&  row.sharedInventoryOccupancyNum === 0){
                 return "0";
               }else {
                 return false;
@@ -602,14 +608,14 @@ animation-fill-mode: none;
               return "";
             }
 
-            // 检查 sharedAvailableInventoryNum 是否存在
-            if (row.sharedAvailableInventoryNum === undefined || row.sharedAvailableInventoryNum === null) {
+            // 检查 sharedInventoryOccupancyNum 是否存在
+            if (row.sharedInventoryOccupancyNum === undefined || row.sharedInventoryOccupancyNum === null) {
               return "";
             }
 
-            // 根据 sharedAvailableInventoryNum 的值决定返回值
-            if (row.sharedAvailableInventoryNum) {
-              return row.sharedAvailableInventoryNum;
+            // 根据 sharedInventoryOccupancyNum 的值决定返回值
+            if (row.sharedInventoryOccupancyNum) {
+              return row.sharedInventoryOccupancyNum;
             } else {
               return value;
             }
@@ -626,8 +632,8 @@ animation-fill-mode: none;
               if (isNaN(value)) {
                 return '请输入有效的数字';
               }
-              if (value <= 0) {
-                return '本次采购数不能小于等于0';
+              if (value < 0) {
+                return '本次采购数不能小于0';
               }
               //不能为小数
               if (value % 1 !== 0) {
@@ -661,16 +667,63 @@ animation-fill-mode: none;
         {
           title: '不含税总价',
           field: 'materialNoRmbSum',
+          formatter: function(value, row) {
+            // 如果本次采购数和不含税单价存在，则计算总价
+            if (row && row.thisPurchaseNum !== undefined && row.materialNoRmbSum !== undefined) {
+              return (row.thisPurchaseNum * row.materialNoRmbSum).toFixed(2);
+            }
+            return value || '';
+          }
+
+
         },
         {
           title: '含税总价',
           field: 'materialRmbSum',
+
+          formatter: function(value, row) {
+            // 如果本次采购数和含税单价存在，则计算总价
+            if (row && row.thisPurchaseNum !== undefined && row.materialRmbSum !== undefined) {
+              return (row.thisPurchaseNum * row.materialRmbSum).toFixed(2);
+            }
+            return value || '';
+          }
+
         },
         {
           title: '最新含税报价',
           field: 'latestQuoteRmb',
         },
+        {
+          title: '实际采购数',
+          field: 'actualPurchaseNum',
+          visible: false,
+
+        },
+        {
+          title: '作废数',
+          field: 'cancelNum',
+          visible: false,
+
+        },
       ],
+
+      onEditableSave: function(field, row, oldValue, $el) {
+        if (field === 'sharedInventoryOccupancyNum') {
+          // 确保共享占用库存数不超过共享可用库存数
+          var sharedAvailableInventoryNum = parseFloat(row.sharedAvailableInventoryNum || 0);
+          var enteredValue = parseFloat(row[field]);
+
+          if (enteredValue > sharedAvailableInventoryNum) {
+            row[field] = sharedAvailableInventoryNum; // 更新row中的值
+          }
+
+          updatePurchaseAndTotalPrices(row);
+        } else if (field === 'thisPurchaseNum') {
+          updateTotalPrices(row);
+        }
+      },
+
       onCheck: function(row) {
         updateFormValues();
       },
@@ -685,14 +738,75 @@ animation-fill-mode: none;
       },
     };
     $.table.init(options);
+
+
+
+    // 定义更新总价的方法
+    function updateTotalPrices(row) {
+      var table = $('#' + options.id).bootstrapTable('getOptions');
+      var data = $('#' + options.id).bootstrapTable('getData');
+
+      for (var i = 0; i < data.length; i++) {
+        if (data[i].purchasePlanChildId === row.purchasePlanChildId) {
+          var unitPriceWithoutTax = parseFloat(data[i].materialNoRmbSum || 0);
+          var unitPriceWithTax = parseFloat(data[i].materialRmbSum || 0);
+          var thisPurchaseNum = parseInt(row.thisPurchaseNum, 10);
+
+          data[i].materialNoRmbSum = (thisPurchaseNum * unitPriceWithoutTax).toFixed(2);
+          data[i].materialRmbSum = (thisPurchaseNum * unitPriceWithTax).toFixed(2);
+
+          $('#' + options.id).bootstrapTable('updateRow', {
+            index: i,
+            row: data[i]
+          });
+
+          break;
+        }
+      }
+    }
+
+    // 定义更新本次采购数和总价的方法
+    function updatePurchaseAndTotalPrices(row) {
+      var purchaseNum = calculatePurchaseNum(row);
+      var sharedAvailableInventoryNum = parseFloat(row.sharedAvailableInventoryNum || 0);
+      var thisPurchaseNum = Math.max(0, purchaseNum);
+
+      // 确保共享占用库存数不超过共享可用库存数
+      row.sharedInventoryOccupancyNum = Math.min(parseFloat(row.sharedInventoryOccupancyNum || 0), sharedAvailableInventoryNum);
+      row.thisPurchaseNum = thisPurchaseNum;
+      row.purchaseNum = purchaseNum;
+
+      updateTotalPrices(row);
+
+      $('#' + options.id).bootstrapTable('updateRow', {
+        index: $('#' + options.id).bootstrapTable('getRowIndex', row),
+        row: row
+      });
+    }
+
+
+    // 计算待采购数的方法
+    function calculatePurchaseNum(row) {
+      if (!row) return 0;
+
+      var planPurchaseNum = parseFloat(row.planPurchaseNum || 0);
+      var actualPurchaseNum = parseFloat(row.actualPurchaseNum || 0);
+      var sharedInventoryOccupancyNum = parseFloat(row.sharedInventoryOccupancyNum || 0);
+      var cancelNum = parseFloat(row.cancelNum || 0);
+
+      return Math.max(0, planPurchaseNum - actualPurchaseNum - sharedInventoryOccupancyNum - cancelNum);
+    }
+
+
+
     /*通过选择物料的数据计算form的数据*/
     function updateFormValues() {
       var selectedRows = $('#selectMaterial-bootstrap-table').bootstrapTable('getSelections');
 
-      //遍历选择的行，如果选择的行中sharedAvailableInventoryNum和thisPurchaseNum数据为空就进行提示
+      //遍历选择的行，如果选择的行中thisPurchaseNum数据为空就进行提示
       for (var i = 0; i < selectedRows.length; i++) {
         var row = selectedRows[i];
-        if (!row.thisPurchaseNum) {
+        if (row.thisPurchaseNum == null) {
           $.modal.alertWarning('选择数据前请填写本次采购数进行合计');
           return;
         }
@@ -707,8 +821,8 @@ animation-fill-mode: none;
       selectedRows.forEach(function(row) {
         thisPurchaseSum += parseInt(row.thisPurchaseNum || 0);
         sharedInventoryOccupancySum += parseInt(row.sharedInventoryOccupancyNum || 0);
-        noRmbSum += parseFloat(row.materialNoRmbSum || 0);
-        rmbSum += parseFloat(row.materialRmbSum || 0);
+        noRmbSum += parseFloat(row.materialNoRmbSum * row.thisPurchaseNum || 0);
+        rmbSum += parseFloat(row.materialRmbSum * row.thisPurchaseNum || 0);
       });
 
       $('#materialSum2').val(parseInt(materialSum));