代码改进

public/web/common_util.js

@@ -18,3 +18,12 @@ function parseFloatPlus(value){
     let rst = parseFloat(value);
     return  isNaN(rst) ? 0 : rst;
 };
+
+// 将arr2合并到arr1，并去重复。
+function mergeArr(arr1, arr2){
+    if (arr2.length > 0){
+        for (let cNode of arr2){
+            if (!arr1.includes(cNode)) arr1.push(cNode);
+        };
+    }
+};

web/building_saas/main/js/models/calc_program.js

@@ -343,12 +343,12 @@ let executeObj = {
                 for (let glj of me.treeNode.data.gljList) {
                     if (glj.type == gljType.GENERAL_MACHINE) {
                         // 获取机械组成物
-                        let mds = projectObj.project.composition.getCompositionByCode(glj.code);
+                        let mds = projectObj.project.composition.getCompositionByGLJ(glj);
                         if (!mds) mds = [];
                         for (let md of mds){
                             if (base.gljTypes.indexOf(md.glj_type) >= 0) {
                                 let q = md["consumption"] ? md["consumption"] : 0;
-                                let p = md["base_price"] ? md["base_price"] : 0;
+                                let p = md["basePrice"] ? md["basePrice"] : 0;
                                 mdSum = mdSum + (q * p).toDecimal(decimalObj.process);
                                 mdSum = (mdSum).toDecimal(decimalObj.process);
                             }
@@ -979,7 +979,7 @@ class CalcProgram {
     };
 
     // 计算本节点、所有父节点(默认,可选)、公式引用节点。
-    calculate(treeNode, calcParents = true){
+    calculate(treeNode, calcParents = true, calcFormulas = true){
         let me = this;
         let changedNodes = [];
 
@@ -996,7 +996,9 @@ class CalcProgram {
             };
 
             // 父结点算完，再计算所有的公式结点(必须先算完父结点，再算公式结点)
-            me.calcFormulaNodes(changedNodes);
+            if (calcFormulas) {
+                me.calcFormulaNodes(changedNodes);
+            };
         };
 
         return changedNodes;
@@ -1017,15 +1019,15 @@ class CalcProgram {
                     calcNodes(node.children);
                 };
 
-                if ((calcType == calcAllType.catAll) || (calcType == node.sourceType)) {
-                    me.calculate(node, false);
-                    if (node.changed) changedNodes.push(node);
+                if ((calcType == calcAllType.catAll || calcType == node.sourceType) && node.calcType != treeNodeCalcType.ctCalcBaseValue) {
+                    me.innerCalc(node, changedNodes);
                 };
             }
         };
 
         calcNodes(me.project.mainTree.roots);
-        // me.saveNodes(changedNodes);   保存要与计算分离，否则实际应用场景中，会产生多次通讯。
+
+        me.calcFormulaNodes(changedNodes);
         return changedNodes;
     };
 
@@ -1053,43 +1055,38 @@ class CalcProgram {
         };
     };
 
-    // 计算叶子清单下的所有子结点(如定额、量价、工料机定额等), 并计算自身和所有父结点。最后打包存储。
+    // 计算叶子清单下的所有子结点、自身、所有父结点、公式引用结点(即跟该叶子清单相关的所有结点)。最后打包存储。
     calcLeafAndSave(treeNode){
         let me = this;
         if(!treeNodeTools.isLeafBill(treeNode)) return;
         if (treeNode.children && treeNode.children.length > 0) {
             let changedNodes = [];
             for (let child of treeNode.children){
-                me.calculate(child, false);
-                if (child.changed) changedNodes.push(child);
-            };
-
-            me.calculate(treeNode);
-            let cur = treeNode;
-            while (cur) {
-                if (cur.changed) changedNodes.push(cur);
-                cur = cur.parent;
+                me.innerCalc(child, changedNodes);
             };
 
+            let curChangeds = me.calculate(treeNode);
+            mergeArr(changedNodes, curChangeds);
             me.saveNodes(changedNodes);
         };
     };
 
     // 计算多条零散的定额，并计算他们所属的清单、父级清单，然后打包存储。如：批量替换工料机后受影响的定额。
     calcRationsAndSave(rationNodes){
-        let me = this, leafBills = [], changedNodes = [];
+        let me = this, leafBills = [], allChangedNodes = [];
         for (let node of rationNodes) {
-            me.innerCalc(node, changedNodes);
+            me.innerCalc(node, allChangedNodes);
             let leafBill = node.parent;
             // 多条定额同属一条叶子清单时，避免叶子清单重复计算
             if (leafBill && leafBills.indexOf(leafBill) < 0) leafBills.push(leafBill);
         };
 
         for (let node of leafBills){
-            me.calculate(node);
+            let curChangeds = me.calculate(node);
+            mergeArr(allChangedNodes, curChangeds);
         };
 
-        me.saveNodes(changedNodes);
+        me.saveNodes(allChangedNodes);
     };
 
     // 计算并保存指定的一个树节点。修改一个树节点，实际上要计算和保存的是一批树结点：层层父结点、被其它结点(的公式)引用的公式结点。