Merge branch 'master' of http://smartcost.f3322.net:3000/SmartCost/ConstructionCost

modules/all_models/ration.js

@@ -63,6 +63,7 @@ let rationSchema = new Schema({
     flags: [subSchema.flagsSchema],             // 标记字段
     rationAssList: [rationAssItemSchema],
     content: String,                            // 工作内容
+    annotation: String,                         //附注
     ruleText: String,                            // 计算规则
     prefix: {type: String, default: ''},                              //定额是补充、借用时用  补 借
 

modules/bills_lib/models/bills_lib_interfaces.js

@@ -3031,7 +3031,72 @@ billsLibDao.prototype.edUpdateItem = function(data, callback){
 };
 //
 
-billsLibDao.prototype.getStdBillsByCode = function (data, callback) {
+billsLibDao.prototype.getStdBillsByCode = async function (data, callback) {
+    let findData = function (value, field, Array) {
+        let i = 0;
+        for (i = 0; i < Array.length; i++) {
+            if (value[field] === Array[i][field]) {
+                return Array[i];
+            }
+        }
+        return null;
+    };
+    let MergeData = function (arr) {
+        let result = "", count = 0;
+        for(let i = 0; i < arr.length; i++){
+            if(arr[i].isChecked === true){
+                count += 1;
+                if (count === 1) {
+                    result += count + ". " + arr[i].content;
+                } else {
+                    result += "\n" + count + ". " + arr[i].content;
+                }
+            }
+        }
+        return result;
+    }
+    try{
+        let bills = await Bills.findOne({billsLibId: data.billsLibId, code: data.code, deleted: false}, '-_id');
+        //设置清单备注(父项清单补注)
+        if(bills.ParentID != -1){
+            let parentBills = await Bills.findOne({billsLibId: data.billsLibId, ID: bills.ParentID, deleted: false});
+            if(parentBills && parentBills.recharge){
+                bills.recharge = parentBills.recharge;
+            }
+        }
+        if(bills){
+            //设置项目特征
+            let itemCharacters = await ItemCharacter.find({billsLibId: data.billsLibId, deleted: false}, '-_id');
+            bills._doc.itemCharacter = [];
+            if(itemCharacters && bills.items){
+                for(let item of bills.items){
+                    let itemData = findData(item, 'id', itemCharacters);
+                    if(itemData){
+                        bills._doc.itemCharacter.push(itemData);
+                    }
+                }
+            }
+            bills._doc.itemCharacterText = MergeData(bills._doc.itemCharacter);
+            //设置工作内容
+            let jobContents = await JobContent.find({billsLibId: data.billsLibId, deleted: false}, '-_id');
+            bills._doc.jobContent = [];
+            if(jobContents && bills.jobs){
+                for(let job of bills.jobs){
+                    let jobData = findData(job, 'id', jobContents);
+                    jobData.isChecked = true;
+                    bills._doc.jobContent.push(jobData);
+                }
+            }
+            bills._doc.jobContentText = MergeData(bills._doc.jobContent);
+        }
+        callback(0, '', bills);
+
+    }
+    catch(err){
+        callback(1, err, null);
+    }
+};
+billsLibDao.prototype.getStdBillsByCodet = function (data, callback) {
     let findData = function (value, field, Array) {
         let i = 0;
         for (i = 0; i < Array.length; i++) {
@@ -3067,23 +3132,23 @@ billsLibDao.prototype.getStdBillsByCode = function (data, callback) {
                     if (err) {
                         callback(err, bills);
                     } else {
-                        bills.itemCharacter = [];
+                        bills._doc.itemCharacter = [];
                         if (result && bills && bills.items) {
                             for (let item of bills.items) {
                                 let itemData = findData(item, 'id', result);
                                 if (itemData) {
-                                    bills.itemCharacter.push(JSON.parse(JSON.stringify(itemData)));
+                                    bills._doc.itemCharacter.push(JSON.parse(JSON.stringify(itemData)));
                                 }
                             }
                         }
-                        bills.itemCharacterText = MergeData(bills.itemCharacter);
+                        bills._doc.itemCharacterText = MergeData(bills.itemCharacter);
                         callback(err, bills);
                     }
                 });
             } else {
                 callback(null, bills);
             }
-            
+
         },
         function (bills, callback) {
             if (bills) {

modules/main/facade/ration_facade.js

@@ -88,6 +88,7 @@ async function insertNewRation(newData,firstLibID,std,calQuantity) {//插入新
         newData.unit = std.unit;
         newData.libID = std.rationRepId;
         newData.content = std.jobContent;
+        newData.annotation = std.annotation;
         if (std.chapter) {
             newData.comments = std.chapter.explanation;
             newData.ruleText = std.chapter.ruleText;

web/building_saas/css/main.css

@@ -149,9 +149,9 @@ body {
 .bottom-tools {
     height: 30px;
     line-height: 30px;
-    background:#fff;
-    bottom:22px;
-    left:22px;
+    background:#F1F1F1;
+    bottom:30px;
+    left:2px;
     z-index: 999
 }
 .side-tabs .nav-tabs .nav-item {

web/building_saas/glj/js/composition.js

@@ -128,7 +128,7 @@ function compositionSuccess(info) {
         }
     }
     if(updateNodes.length>0){
-        projectObj.project.calcProgram.calcRationsAndSave(updateNodes);
+        projectObj.project.calcProgram.calcNodesAndSave(updateNodes);
     }
     gljOprObj.refreshView();
 }

web/building_saas/main/js/controllers/block_controller.js

@@ -272,7 +272,7 @@ let BlockController = {
              //主材设备工料机插入主树
              project.ration_glj.addToMainTree(result.ration_gljs);
              //更新计算程序模板，并进行重新计算
-             project.calcProgram.calcRationsAndSave(rationNodes,function () {
+             project.calcProgram.calcNodesAndSave(rationNodes,function () {
                  installationFeeObj.calcInstallationFee();
              });
         })

web/building_saas/main/js/models/bills.js

@@ -202,8 +202,8 @@ var Bills = {
                     data.data.unit = stdBillsData.unit;
                     // 工程量计算规则
                     data.data.ruleText = stdBillsData.ruleText;
-                    // 说明（补注）
-                    data.data.comments = stdBillsData.recharge;
+                    // 说明（清单备注）
+                    data.data.comments = stdBillsData.comments;
                     //zhong 特征及内容
                     data.data.jobContent = stdBillsData.jobContent;
                     data.data.itemCharacter = stdBillsData.itemCharacter;
@@ -751,10 +751,6 @@ var Bills = {
                     }
                     gljOprObj.refreshView();
                 });
-
-               /* project.calcProgram.calcBillsAndSave(parentNodes,function () {
-                    project.projectGLJ.loadData();
-                });*/
             }, function () {
                 $.bootstrapLoading.end();
             });

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

@@ -1230,13 +1230,11 @@ class CalcProgram {
     getSourceType () {
         return ModuleNames.calc_program;
     };
-
     // 兼容Project框架方法
     loadData (datas) {
         this.datas = datas;
         this.compileAllTemps();
     };
-
     // 兼容Project框架方法
     doAfterUpdate (err, data) {
         if(!err){
@@ -1420,56 +1418,6 @@ class CalcProgram {
         };
     };
 
-    // 存储、刷新零散的多个结点。
-    saveNodes(treeNodes, callback){
-        if (treeNodes.length < 1) {
-            $.bootstrapLoading.end();
-            return;
-        }
-
-        let me = this;
-/*        me.project.beginUpdate('');
-        for (let node of treeNodes){
-            if (node.changed){
-                let data = calcTools.cutNodeForSave(node);
-                let newData = {'updateType': 'ut_update', 'updateData': data};
-                me.project.push(node.sourceType, [newData]);
-            }
-        };
-        me.project.endUpdate();*/
-
-        let dataArr = [];
-        for (let node of treeNodes){
-            if (node.changed){
-                let data = calcTools.cutNodeForSave(node);
-                let newData = {'type': node.sourceType, 'data': data};
-                dataArr.push(newData);
-            }
-        };
-        if (dataArr.length < 1) {
-            $.bootstrapLoading.end();
-            return;
-        };
-        $.bootstrapLoading.start();
-        let startTime = +new Date();
-        me.project.updateNodes(dataArr, function (data) {
-            let endShowTime = +new Date();
-            console.log(`保存所需时间——${endShowTime - startTime}`);
-            if(callback){
-                callback(data);
-            };
-
-            for (let node of treeNodes){delete node.changed};
-            projectObj.mainController.refreshTreeNode(treeNodes);
-
-            // 批量树结点计算后，计算程序早已物是人非，所以这里要重新计算一下。
-            if (activeSubSheetIs(subSheetIndex.ssiCalcProgram)) {
-                calcProgramObj.refreshCurNodeCalcItems(me.project.mainTree.selected);
-            };
-            $.bootstrapLoading.end();
-        });
-    };
-
     // 只计算treeNode自身。changedArr: 外部传来的一个数组，专门存储发生变动的节点。
     innerCalc(treeNode, changedArr, tender){
         let me = this;
@@ -1723,6 +1671,56 @@ class CalcProgram {
         if (treeNode.changed && !changedArr.includes(treeNode)) changedArr.push(treeNode);
     };
 
+    // 存储、刷新零散的多个结点。
+    saveNodes(treeNodes, callback){
+        if (treeNodes.length < 1) {
+            $.bootstrapLoading.end();
+            return;
+        }
+
+        let me = this;
+        /*        me.project.beginUpdate('');
+                for (let node of treeNodes){
+                    if (node.changed){
+                        let data = calcTools.cutNodeForSave(node);
+                        let newData = {'updateType': 'ut_update', 'updateData': data};
+                        me.project.push(node.sourceType, [newData]);
+                    }
+                };
+                me.project.endUpdate();*/
+
+        let dataArr = [];
+        for (let node of treeNodes){
+            if (node.changed){
+                let data = calcTools.cutNodeForSave(node);
+                let newData = {'type': node.sourceType, 'data': data};
+                dataArr.push(newData);
+            }
+        };
+        if (dataArr.length < 1) {
+            $.bootstrapLoading.end();
+            return;
+        };
+        $.bootstrapLoading.start();
+        let startTime = +new Date();
+        me.project.updateNodes(dataArr, function (data) {
+            let endShowTime = +new Date();
+            console.log(`保存所需时间——${endShowTime - startTime}`);
+            if(callback){
+                callback(data);
+            };
+
+            for (let node of treeNodes){delete node.changed};
+            projectObj.mainController.refreshTreeNode(treeNodes);
+
+            // 批量树结点计算后，计算程序早已物是人非，所以这里要重新计算一下。
+            if (activeSubSheetIs(subSheetIndex.ssiCalcProgram)) {
+                calcProgramObj.refreshCurNodeCalcItems(me.project.mainTree.selected);
+            };
+            $.bootstrapLoading.end();
+        });
+    };
+
     // 计算本节点、所有父节点(默认,可选)、公式引用节点(默认,可选)。
     calculate(treeNode, calcParents = true, calcFormulas = true, tender){
         let me = this;
@@ -1745,12 +1743,17 @@ class CalcProgram {
 
         return changedNodes;
     };
+    // 计算并保存一个树节点。(修改一个树节点，实际上要计算和保存的是一批树结点：层层父结点、被其它结点(的公式)引用的公式结点)
+    calcAndSave(treeNode, callback, tender){
+        let changedNodes = this.calculate(treeNode, true, true, tender);
+        this.saveNodes(changedNodes, callback);
+    };
 
     /* 计算所有树结点(分3种情况)，并返回发生变动的零散的多个树结点。参数取值如下：
-        calcAllType.catAll       计算所有树结点 (不指定参数时的默认值)
+        calcAllType.catAll       计算所有树结点 (默认值)
         calcAllType.catBills     计算所有清单 (改变项目属性中清单取费算法时会用到)
-        calcAllType.catRations   计算所有定额、工料机形式的定额、量价，因为它们都走自己的计算程序 (改变人工系数、费率值、工料机单价时会用到)  不要用
-        缺陷：calcAllType.catRations 参数情况不会计算父结点。（calcAllType.catBills 可以，因为清单的父结点也是清单会计算）
+        calcAllType.catRations   计算所有定额、工料机形式的定额、量价，因为它们都走自己的计算程序 (改变人工系数、费率值、工料机单价时会用到)
+                                 (calcAllType.catRations时程序中做了特殊处理，实际上是计算所有树结点！)
     */
     calcAllNodes(calcType = calcAllType.catAll, tender){
         let me = this;
@@ -1768,12 +1771,53 @@ class CalcProgram {
                 };
             }
         };
+
+        // calcAllType.catRations 参数情况不会计算父结点（因为父结点是清单），所以这里进行特殊处理。
+        if (calcType == calcAllType.catRations)
+            calcType == calcAllType.catAll;
+
         calcNodes(me.project.mainTree.roots);
         me.calcFormulaNodes(changedNodes, tender);
         return changedNodes;
     };
+    // tender: null：不调价(普通计算)。 1: 正向调价   2：反向调价－调子目    3: 反向调价－调工料机
+    calcAllNodesAndSave(calcType = calcAllType.catAll, callback, tender){
+        let changedNodes = this.calcAllNodes(calcType, tender);
+        this.saveNodes(changedNodes, callback);
+    };
+
+    // 计算零散的、混杂的树节点：清单、定额混合等(如：用到某一计算程序的定额和清单)。
+    // 计算多条零散的定额，并计算他们所属的清单、父清单、引用清单。如：批量替换工料机后受影响的定额。
+    // 计算多条零散的清单，并计算他们的父清单、引用清单。如：花选删除树结点(如花选清单、定额等，不区分树结点类型)。
+    calcNodesAndSave(nodes, callback, tender){
+        let me = this, rationNodes = [], billNodes = [], leafBills = [], allChangedNodes = [];
+        for (let node of nodes) {
+            if (node.sourceType == ModuleNames.ration)
+                rationNodes.push(node)
+            else
+                billNodes.push(node);
+        };
+
+        // 多条定额同属一条叶子清单时，避免叶子清单重复计算
+        for (let ration of rationNodes) {
+            me.innerCalc(ration, allChangedNodes, tender);
+            let leafBill = ration.parent;
+            if (leafBill && leafBills.indexOf(leafBill) < 0)
+                leafBills.push(leafBill);
+        };
+
+        mergeArr(billNodes, leafBills);
+
+        for (let bill of billNodes){
+            let changeBills = me.calculate(bill, true, false, tender);
+            mergeArr(allChangedNodes, changeBills);
+        };
+
+        me.calcFormulaNodes(allChangedNodes, tender);
+        me.saveNodes(allChangedNodes, callback);
+    };
 
-    // 计算全部公式项。 (参数意义：将通过本方法后发生改变的节点存入changedArr中)
+    // 计算全部公式项。 (changedArr：将通过本方法后发生改变的节点存入changedArr中)
     calcFormulaNodes(changedArr, tender){
         let me = this;
         let formulaNodes = cbTools.getFormulaNodes(true);
@@ -1798,7 +1842,7 @@ class CalcProgram {
     };
 
     // 计算叶子清单下的所有子结点、自身、所有父结点、公式引用结点(即跟该叶子清单相关的所有结点)。最后打包存储。
-    calcLeafAndSave(treeNode){
+    calcLeafAndSave(treeNode, tender){
         let me = this;
         if(!calcTools.isLeafBill(treeNode)) return;
         if (treeNode.children && treeNode.children.length > 0) {
@@ -1807,85 +1851,12 @@ class CalcProgram {
                 me.innerCalc(child, changedNodes);
             };
 
-            let curChangeds = me.calculate(treeNode);
+            let curChangeds = me.calculate(treeNode, true, true, tender);
             mergeArr(changedNodes, curChangeds);
             me.saveNodes(changedNodes);
         };
     };
 
-    // 计算并保存指定的一个树节点。修改一个树节点，实际上要计算和保存的是一批树结点：层层父结点、被其它结点(的公式)引用的公式结点。
-    // 这个方法实际上封装了calculate()和saveNodes()两个方法，主要目的是为了外部调用方便，少写一点累赘代码。
-    calcAndSave(treeNode, callback){
-        let changedNodes = this.calculate(treeNode);
-        this.saveNodes(changedNodes, callback);
-    };
-
-    // 计算零散的、混杂的树节点：清单、定额混合等(如：用到某一计算程序的定额和清单)。
-    // 计算多条零散的定额，并计算他们所属的清单、父清单、引用清单。如：批量替换工料机后受影响的定额。
-    // 计算多条零散的清单，并计算他们的父清单、引用清单。如：花选删除树结点(如花选清单、定额等，不区分树结点类型)。
-    calcNodesAndSave(nodes, callback){
-        let me = this, rationNodes = [], billNodes = [], leafBills = [], allChangedNodes = [];
-        for (let node of nodes) {
-            if (node.sourceType == ModuleNames.ration)
-                rationNodes.push(node)
-            else
-                billNodes.push(node);
-        };
-
-        // 多条定额同属一条叶子清单时，避免叶子清单重复计算
-        for (let ration of rationNodes) {
-            me.innerCalc(ration, allChangedNodes);
-            let leafBill = ration.parent;
-            if (leafBill && leafBills.indexOf(leafBill) < 0)
-                leafBills.push(leafBill);
-        };
-
-        mergeArr(billNodes, leafBills);
-
-        for (let bill of billNodes){
-            let changeBills = me.calculate(bill, true, false);
-            mergeArr(allChangedNodes, changeBills);
-        };
-
-        me.calcFormulaNodes(allChangedNodes);
-        me.saveNodes(allChangedNodes, callback);
-    };
-    calcRationsAndSave(rationNodes, callback){
-        // let me = this, leafBills = [], allChangedNodes = [];
-        // for (let node of rationNodes) {
-        //     me.innerCalc(node, allChangedNodes);
-        //     let leafBill = node.parent;
-        //     // 多条定额同属一条叶子清单时，避免叶子清单重复计算
-        //     if (leafBill && leafBills.indexOf(leafBill) < 0) leafBills.push(leafBill);
-        // };
-        //
-        // for (let node of leafBills){
-        //     let curChangeds = me.calculate(node);
-        //     mergeArr(allChangedNodes, curChangeds);
-        // };
-        // let endShowTime = +new Date();
-        // me.saveNodes(allChangedNodes, callback);
-
-        this.calcNodesAndSave(rationNodes, callback);
-    };
-    calcBillsAndSave(billNodes,callback){
-        // let me = this, allChangedNodes = [];
-        // for (let node of billNodes) {
-        //     let curChangeds = me.calculate(node, true, false);
-        //     mergeArr(allChangedNodes, curChangeds);
-        // };
-        // me.calcFormulaNodes(allChangedNodes);
-        // me.saveNodes(allChangedNodes,callback);
-
-        this.calcNodesAndSave(billNodes, callback);
-    };
-
-    // tender: null：不调价(普通计算)。 1: 正向调价   2：反向调价－调子目    3: 反向调价－调工料机
-    calcAllNodesAndSave(calcType = calcAllType.catAll, callback, tender){
-        let changedNodes = this.calcAllNodes(calcType, tender);
-        this.saveNodes(changedNodes, callback);
-    };
-
     // 排除指定项的综合合价计算(用于带循环计算的情况。这里的汇总只到清单级别即可:清单单价取费时，汇总到清单和汇总到定额两个值不一样)
     getTotalFee(baseNodes, excludeNodes){
         let rst = 0;

web/building_saas/main/js/models/project_glj.js

@@ -282,7 +282,7 @@ ProjectGLJ.prototype.updatePrice = function (recode, updateField, newval,from,cb
             me.refreshTreeNodePriceIfNeed(glj);//刷新造价书中主树上的定额工料机;
             gljs.push(glj);
             let nodes = me.getImpactRationNodes(gljs);//取到因为改变工料机价格而受影响的定额
-            projectObj.project.calcProgram.calcRationsAndSave(nodes);//触发计算程序
+            projectObj.project.calcProgram.calcNodesAndSave(nodes);//触发计算程序
             projectGljObject.onUnitFileChange(data);
             if(cb){
                 cb(gljs);
@@ -341,7 +341,7 @@ ProjectGLJ.prototype.batchUpdatePrice = function (changeInfo,callback) {
             let pgljs = me.getProjectGLJs(parentData);
             gljs = gljs.concat(pgljs);
             let nodes = me.getImpactRationNodes(gljs);//取到因为改变工料机价格而受影响的定额
-            projectObj.project.calcProgram.calcRationsAndSave(nodes);//触发计算程序
+            projectObj.project.calcProgram.calcNodesAndSave(nodes);//触发计算程序
             gljOprObj.showRationGLJSheetData();
             projectGljObject.onUnitFileChange(gljs);
             if(callback){
@@ -527,7 +527,7 @@ ProjectGLJ.prototype.changeIsEvaluate=function (id){
             ration_nodes.push(rg);
         }
         ration_nodes.length>0?projectObj.mainController.refreshTreeNode(ration_nodes):"";
-        projectObj.project.calcProgram.calcRationsAndSave(nodes);//触发计算程序
+        projectObj.project.calcProgram.calcNodesAndSave(nodes);//触发计算程序
         return gljs;
     }
 }

web/building_saas/main/js/models/quantity_detail.js

@@ -663,14 +663,14 @@ var quantity_detail = {
             }
             if(needUpdateChildren.length>0){//清单下的定额工程量发生了改变
                 node.changed = true;//本身发生了改变，需要存储。
-                /*project.calcProgram.calcRationsAndSave(needUpdateChildren, function () {
+                /*project.calcProgram.calcNodesAndSave(needUpdateChildren, function () {
                     project.projectGLJ.loadData();
                 });*/
-                project.calcProgram.calcRationsAndSave(needUpdateChildren, function () {
+                project.calcProgram.calcNodesAndSave(needUpdateChildren, function () {
                     if(project.Bills.isFBFX(node)) { //判断是否属于分部分项工程 ，是的话才需要做计取安装费计算
                         project.installation_fee.calcInstallationFee(function (isChange,rations) {
                             if(isChange){
-                                project.calcProgram.calcRationsAndSave(rations,function () {
+                                project.calcProgram.calcNodesAndSave(rations,function () {
                                     project.projectGLJ.calcQuantity();
                                 });
                             }
@@ -708,7 +708,7 @@ var quantity_detail = {
                 if(project.Bills.isFBFX(node)) { //判断是否属于分部分项工程 ，是的话才需要做计取安装费计算
                     project.installation_fee.calcInstallationFee(function (isChange,rations) {
                         if(isChange){
-                            project.calcProgram.calcRationsAndSave(rations);
+                            project.calcProgram.calcNodesAndSave(rations);
                         }
                     });
                 }

web/building_saas/main/js/models/ration.js

@@ -424,7 +424,7 @@ var Ration = {
                 }
                 project.projectGLJ.loadData(function () {
                     gljOprObj.showDataIfRationSelect(projectObj.project.mainTree.selected,"-111111111");//这里第二个参数是为了使改前和改后selectedID不一样，删除了的话下方的定额工料机不会刷新
-                    project.calcProgram.calcRationsAndSave(refershNodes);
+                    project.calcProgram.calcNodesAndSave(refershNodes);
                     projectObj.mainController.refreshTreeNode(refershNodes, true);
                     $.bootstrapLoading.end();
                 });
@@ -524,9 +524,9 @@ var Ration = {
                             project.installation_fee.calcInstallationFee(function (isChange,rations) {
                                 if(isChange){
                                     rations = rations.concat(newNodes);
-                                    project.calcProgram.calcRationsAndSave(rations);
+                                    project.calcProgram.calcNodesAndSave(rations);
                                 }else {
-                                    project.calcProgram.calcRationsAndSave(newNodes);
+                                    project.calcProgram.calcNodesAndSave(newNodes);
                                 }
                             });
                         }else {

web/building_saas/main/js/views/glj_view.js

@@ -1177,7 +1177,7 @@ var gljOprObj = {
             project.projectGLJ.loadData(function () {
                 me.showRationGLJSheetData();
                 var rationNodes = me.refreshStateAfterMreplace(stateList, nodes);
-                project.calcProgram.calcRationsAndSave(rationNodes);
+                project.calcProgram.calcNodesAndSave(rationNodes);
                 $.bootstrapLoading.end();
             });
         })

web/building_saas/main/js/views/installation_fee_view.js

@@ -796,7 +796,7 @@ let installationFeeObj={
                     me.refreshRationInstallationRow(me.rationInstallSheet.getSelections()[0].row);
                     installation_fee.calcInstallationFee(function (isChange,rations) {
                         if(isChange){
-                            projectObj.project.calcProgram.calcRationsAndSave(rations);
+                            projectObj.project.calcProgram.calcNodesAndSave(rations);
                         }
                     });
                 });
@@ -834,7 +834,7 @@ let installationFeeObj={
             me.refreshRationInstallationRow(riselection.row);
             installation_fee.calcInstallationFee(function (isChange,rations) {
                 if(isChange){
-                    projectObj.project.calcProgram.calcRationsAndSave(rations);
+                    projectObj.project.calcProgram.calcNodesAndSave(rations);
                 }
             });
         });
@@ -1244,7 +1244,7 @@ let installationFeeObj={
         $('#calc_installation_fee').modal('hide');
         install_fee.calcInstallationFee(function (isChange,rations) {
             if(isChange){
-                projectObj.project.calcProgram.calcRationsAndSave(rations);
+                projectObj.project.calcProgram.calcNodesAndSave(rations);
             }
             installationFeeObj.showRationInstallationData(projectObj.project.mainTree.selected);
             if(callback){
@@ -1298,7 +1298,7 @@ let installationFeeObj={
             //计算安装增加费
             projectObj.project.installation_fee.calcInstallationFee(function (isChange,rations) {
                 if(isChange){
-                    projectObj.project.calcProgram.calcRationsAndSave(rations);
+                    projectObj.project.calcProgram.calcNodesAndSave(rations);
                 }
             });
         })

web/building_saas/main/js/views/project_glj_view.js

@@ -654,7 +654,7 @@ projectGljObject={
             updateNodes = updateNodes.concat(subRations);
         }
         if(updateNodes.length>0){
-            projectObj.project.calcProgram.calcRationsAndSave(updateNodes,function () {
+            projectObj.project.calcProgram.calcNodesAndSave(updateNodes,function () {
                 projectObj.mainController.refreshTreeNode(projectObj.project.mainTree.roots);
                 installationFeeObj.calcInstallationFee();//计算安装增加费
             });

web/building_saas/main/js/views/project_view.js

@@ -1431,7 +1431,7 @@ $('#upLevel').click(function () {
         project.Bills.upLevelBills(selected.source);
         controller.upLevel();
         controller.refreshTreeNode([orgParent]);
-        projectObj.project.calcProgram.calcBillsAndSave([selected,orgParent]);
+        projectObj.project.calcProgram.calcNodesAndSave([selected,orgParent]);
     }
 });
 $('#downLevel').click(function () {

web/building_saas/main/js/views/std_bills_lib.js

@@ -125,6 +125,10 @@ var billsLibObj = {
         if(projectInfoObj.projectInfo.property.lockBills == true){
             return false;
         }
+        //设置清单备注
+        if(node.parent && node.parent.data.recharge){
+            node.data.comments = node.parent.data.recharge;
+        }
         //特征及内容转化
         pageCCOprObj.setItemContentNode(node, this.getBillsJobs(stdBillsJobData, node), this.getBillsFeatures(stdBillsFeatureData, node), node.data.name);
         if (/\//.test(node.data.unit)) {
@@ -164,9 +168,8 @@ var billsLibObj = {
             $('#stdBillsRemarkTab').hide();
             billsLibObj.refreshBillsRelaSpread();
             billsLibObj.checkBillsRelaSpread();
-            billsLibObj.sortJobsAndFeatures(billsLibObj.getBillsJobs(node));
-            showJobs(billsLibObj.getBillsJobs(node));
-            showFeatures(billsLibObj.getBillsFeatures(node));
+            showJobs(billsLibObj.getBillsJobs(stdBillsJobData, node));
+            showFeatures(billsLibObj.getBillsFeatures(stdBillsFeatureData, node));
         };
         var showBillsRemark = function (node) {
             $('#stdBillsJobTab').hide();

web/building_saas/main/js/views/sub_view.js

@@ -316,13 +316,32 @@ let subViewObj = {
         $($(this).attr('href')).show();
     },
     loadComments: function (node) {
+        let comments = [];
+        let commentText = '';
         if (node) {
-            if (node.sourceType === projectObj.project.Bills.getSourceType()) {
-                $('#comments>textarea').val(node.data.comments)
+            if (node.sourceType === projectObj.project.Bills.getSourceType() &&
+                (node.data.type === billType.FX || node.data.type === billType.BX || node.data.type === billType.BILL)) {
+                if(node.data.comments && node.data.comments !== ''){
+                    comments.push('清单注释：');
+                    comments.push(node.data.comments);
+                }
+                if(node.data.ruleText && node.data.ruleText !== ''){
+                    comments.push('工程量计算规则:');
+                    comments.push(node.data.ruleText);
+                }
             } else if (node.sourceType === projectObj.project.Ration.getSourceType()) {
-                $('#comments>textarea').val(node.data.content);
+                if(node.data.content && node.data.content !== ''){
+                    comments.push('工作内容：');
+                    comments.push(node.data.content);
+                }
+                if(node.data.annotation && node.data.annotation !== ''){
+                    comments.push('附注：');
+                    comments.push(node.data.annotation);
+                }
             }
+            commentText = comments.join('\n');
         }
+        $('#comments>textarea').val(commentText);
     },
     saveComments: function (node) {
         let text = $('#comments>textarea').val();