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

modules/all_models/bills.js

@@ -20,6 +20,7 @@ let billsSchema = new Schema({
     name: String,
     unit: String,
     quantity: String, // Decimal
+    quantity2:String,//预算项目中的数量2
     quantityEXP:String,//工程量表达式
     feeRateID:Number,
     feeRate:String,
@@ -64,6 +65,7 @@ let billsSchema = new Schema({
     installationKey:String,//用来记录安装增加费的关联字段
     deleteInfo: deleteSchema,
     isEstimate:{type: Number,default:0},       // 1 true 0 false 是否暂估
+    unitPriceAnalysis:{type: Number,default:0},       // 1 true 0 false 单价分析
     specialProvisional:String,
     remark:String,
     engineeringContent:String,//工程内容

public/web/id_tree.js

@@ -141,7 +141,7 @@ var idTree = {
             this.tree = tree;
             this.data = data;
             this.children = [];
-
+            this.updateData={};
             this.parent = null;
             this.nextSibling = null;
             this.preSibling = null;

web/building_saas/main/js/models/cache_tree.js

@@ -108,7 +108,7 @@ var cacheTree = {
             // ���µ����ԣ�����Ԫ��������ֱ���޸�
             this.tree = tree;
             this.children = [];
-
+            this.updateData={};
             this.parent = null;
             this.nextSibling = null;
             this.preSibling = null;

web/building_saas/main/js/models/calc_base.js

@@ -1705,9 +1705,9 @@ let calcBase = {
 
             //存储
             me.success = true;
-            node.data.calcBase = exp;
-            node.data.calcBaseValue = parseFloat(calcBaseValue).toDecimal(decimalObj.decimal('totalPrice', node));
-            node.data.tenderCalcBaseValue = parseFloat(tenderCalcBaseValue).toDecimal(decimalObj.decimal('totalPrice', node));
+            node.updateData.calcBase = exp;
+            node.updateData.calcBaseValue = parseFloat(calcBaseValue).toDecimal(decimalObj.decimal('totalPrice', node));
+            node.updateData.tenderCalcBaseValue = parseFloat(tenderCalcBaseValue).toDecimal(decimalObj.decimal('totalPrice', node));
             node.changed = true;
         }
         catch (err){

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

@@ -148,6 +148,8 @@ let calcTools = {
         if (!treeNode.data.fees) {
             treeNode.data.fees = [];
             treeNode.data.feesIndex = {};
+            treeNode.updateData.fee = [];
+            treeNode.updateData.feesIndex = {};
             treeNode.changed = true;
         }
         else if (!treeNode.data.feesIndex){
@@ -170,6 +172,7 @@ let calcTools = {
             };
             treeNode.data.fees.push(fee);
             treeNode.data.feesIndex[fieldName] = fee;
+            treeNode.updateData.fees = _.cloneDeep(treeNode.data.fees);
             treeNode.changed = true;
         };
     },
@@ -215,9 +218,10 @@ let calcTools = {
             let arr = fieldName.split('.');
             this.initFeeField(treeNode, arr[1]);
             treeNode.data.feesIndex[arr[1]][arr[2]] = value;
+            treeNode.updateData.feesIndex[arr[1]][arr[2]] = value;
         }
         else{
-            treeNode.data[fieldName] = value;
+            treeNode.updateData[fieldName] = value;
         };
         treeNode.changed = true;
     },
@@ -229,6 +233,12 @@ let calcTools = {
                 safetyFee: 0,
                 chargeFee: 0
             };
+            treeNode.updateData.summaryFees = {
+                totalFee: 0,
+                estimateFee: 0,
+                safetyFee: 0,
+                chargeFee: 0
+            };
             treeNode.changed = true;
         };
     },
@@ -679,44 +689,36 @@ let calcTools = {
         let me = this;
         /*  subType、quantity、calcBase、programID、marketUnitFee等等字段较为特殊，它们的改变一定会触发计算并导致计算
             结果的变化，从而引发保存动作。将这些字段放在该位置跟计算结果一起保存，可减少前端跟后端的通讯频率。              */
-        let data = {
-            projectID: projectObj.project.ID(),
-            ID: treeNode.data.ID,
-            unit: treeNode.data.unit,   //对清单来说，改变单位，工程量精度会跟着改变从而影响计算。
-            subType: treeNode.data.subType,
-            quantity: treeNode.data.quantity,
-            calcBase: treeNode.data.calcBase,
-            calcBaseValue: treeNode.data.calcBaseValue,
-            programID: treeNode.data.programID,
-            marketUnitFee: treeNode.data.marketUnitFee,
-            marketTotalFee: treeNode.data.marketTotalFee,
-            fees: treeNode.data.fees,
-            isFromDetail:treeNode.data.isFromDetail,
-            feeRate: treeNode.data.feeRate,
-            feeRateID: treeNode.data.feeRateID,
-            contain: treeNode.data.contain,
-            quantityEXP: treeNode.data.quantityEXP,
-            summaryFees: treeNode.data.summaryFees,
-            name:treeNode.data.name,
-            rationQuantityCoe: treeNode.data.rationQuantityCoe,
-            quantityCoe: treeNode.data.quantityCoe == null ? {} : treeNode.data.quantityCoe,
-            targetUnitFee: treeNode.data.targetUnitFee,
-            targetTotalFee: treeNode.data.targetTotalFee,
-            specialProvisional:treeNode.data.specialProvisional
-        };
-
+        let data = treeNode.updateData;
+        data.projectID = projectObj.project.ID();
+        data.ID = treeNode.data.ID;
+        //对比计算结果与原数据的值，有改变的才提交保存
+        if(treeNode.temData){
+            for(let key in treeNode.data){
+                if(key == "feesIndex" || key =="flagsIndex" || key =="gljList" || key =="calcTemplate") continue;// 这两个字段不用保存到后台;
+                if(treeNode.data[key]&& typeof treeNode.data[key] == "object"){//对象类型转换成字符串比较
+                    if(Array.isArray(treeNode.data[key])) treeNode.data[key].sort();
+                    if(Array.isArray(treeNode.temData[key])) treeNode.temData[key].sort();
+                    if(JSON.stringify(treeNode.temData[key])!== JSON.stringify(treeNode.data[key]) ){
+                        data[key] = treeNode.data[key];
+                    }
+                }else if(treeNode.temData[key]!==treeNode.data[key]){
+                    data[key] = treeNode.data[key];
+                }
+            }
+        }
         // 定额大类
         if (me.isRationCategory(treeNode)) {
-            data.isSubcontract = treeNode.data.isSubcontract;
-            data.evaluationProject = treeNode.data.evaluationProject;
+            // 这4个位置要分别找到更新的地方按新的来更新
+           // data.isSubcontract = treeNode.data.isSubcontract;
+           // data.evaluationProject = treeNode.data.evaluationProject;
             //定额类型的工料机做特殊处理
             if(me.isGljRation(treeNode)){
-                data.code = treeNode.data.code;
-                data.projectGLJID = treeNode.data.projectGLJID;
+             //   data.code = treeNode.data.code;
+              //  data.projectGLJID = treeNode.data.projectGLJID;
                 delete data.marketUnitFee;
             };
         };
-
         // 优化掉 undefined 属性
         data = JSON.parse(JSON.stringify(data));
         return data;
@@ -911,16 +913,35 @@ let rationCalcBasesNameKinds = {
 };
 
 let rationCalcBases = {
-    '定额基价人工费': function (node, isTender) {
+    '人工费': function (node, isTender) {
+        return calcTools.rationBaseFee(node, [gljType.LABOUR], priceTypes.ptMarketPrice, isTender);
+    },
+    '材料费': function (node, isTender) {
+        return calcTools.rationBaseFee(node, baseMaterialTypes, priceTypes.ptMarketPrice, isTender);
+    },
+    '施工机具费': function (node, isTender) {
+        return calcTools.rationBaseFee(node, [gljType.GENERAL_MACHINE], priceTypes.ptMarketPrice, isTender);
+    },
+    '商品砼费': function (node, isTender) {
+        return calcTools.rationBaseFee(node, [gljType.COMMERCIAL_CONCRETE, gljType.COMMERCIAL_MORTAR], priceTypes.ptMarketPrice, isTender);
+    },
+    '设备购置费': function (node, isTender) {
+        return calcTools.rationBaseFee(node, [gljType.EQUIPMENT], priceTypes.ptMarketPrice, isTender);
+    },
+    '定额人工费': function (node, isTender) {
         return calcTools.rationBaseFee(node, [gljType.LABOUR], priceTypes.ptBasePrice, isTender);
     },
-    '定额基价材料费': function (node, isTender) {
+    '定额材料费': function (node, isTender) {
         return calcTools.rationBaseFee(node, baseMaterialTypes, priceTypes.ptBasePrice, isTender);
     },
-    '定额基价机械费': function (node, isTender) {
+    '定额施工机具使用费': function (node, isTender) {
         return calcTools.rationBaseFee(node, [gljType.GENERAL_MACHINE], priceTypes.ptBasePrice, isTender);
     },
-    '定额基价机上人工费': function (node, isTender) {
+    '定额设备费': function (node, isTender) {
+        return calcTools.rationBaseFee(node, [gljType.EQUIPMENT], priceTypes.ptBasePrice, isTender);
+    }
+
+/*    '定额基价机上人工费': function (node, isTender) {
         return calcTools.machineDetailFee(node, node.data.gljList, [], gljType.MACHINE_LABOUR, isTender);
     },
     '人工费价差': function (node, isTender) {
@@ -1015,7 +1036,7 @@ let rationCalcBases = {
             return calcTools.labourDays(node, isTender)
         else
             return 0;
-    }
+    }*/
 };
 
 let analyzer = {
@@ -1581,9 +1602,10 @@ class CalcProgram {
     // 只计算treeNode自身。changedArr: 外部传来的一个数组，专门存储发生变动的节点。
     innerCalc(treeNode, changedArr, tender){
         let me = this;
+        me.setUpdateDataToNode(treeNode);//先更新要计算的节点信息
+        if(!treeNode.temData) treeNode.temData = _.cloneDeep(treeNode.data); //有可能会有多次计算，只有第一次才保存原始数据，用来对于更新。
         // 仅用作树节点显示的工料机不能参与计算。
         if (treeNode.sourceType === ModuleNames.ration_glj) return;
-
         treeNode.calcType = calcTools.getCalcType(treeNode);
         let nQ = calcTools.uiNodeQty(treeNode);
         let nTQ = calcTools.uiNodeTenderQty(treeNode);
@@ -1831,14 +1853,12 @@ class CalcProgram {
 
                 if (tender == tenderTypes.ttReverseRation || tender == tenderTypes.ttReverseGLJ)
                     this.calcTenderReverse(treeNode, tender);
-
                 deleteUselessFees(treeNode, fnArr);
             };
         };
 
         if (!calcTools.isTotalCostBill(treeNode))  // 已在上面的分支中计算过
             calcTools.estimateFee(treeNode);
-
         if (treeNode.changed && !changedArr.includes(treeNode)) changedArr.push(treeNode);
     };
 
@@ -1861,11 +1881,13 @@ class CalcProgram {
                 me.project.endUpdate();*/
 
         let dataArr = [];
+        let updateMap = {};
         for (let node of treeNodes){
             if (node.changed){
                 let data = calcTools.cutNodeForSave(node);
                 let newData = {'type': node.sourceType, 'data': data};
                 dataArr.push(newData);
+                updateMap[node.data.ID] = data;
             }
         };
         if (dataArr.length < 1) {
@@ -1877,13 +1899,15 @@ class CalcProgram {
         me.project.updateNodes(dataArr, function (data) {
             let endShowTime = +new Date();
             console.log(`保存所需时间——${endShowTime - startTime}`);
+            for (let node of treeNodes){
+                delete node.changed;
+                delete node.temData;
+                node.updateData = {};
+            };
             if(callback){
                 callback(data);
             };
-
-            for (let node of treeNodes){delete node.changed};
             projectObj.mainController.refreshTreeNode(treeNodes);
-
             // 批量树结点计算后，计算程序早已物是人非，所以这里要重新计算一下。警告：第二个参数千万不能改成3，否则死循环！
             if (activeSubSheetIsCalcProgram())
                 calcProgramObj.refreshCalcProgram(projectObj.project.mainTree.selected, 2);
@@ -1915,8 +1939,9 @@ class CalcProgram {
     };
     // 计算并保存一个树节点。(修改一个树节点，实际上要计算和保存的是一批树结点：层层父结点、被其它结点(的公式)引用的公式结点)
     calcAndSave(treeNode, callback, tender){
-        let changedNodes = this.calculate(treeNode, true, true, tender);
-        this.saveNodes(changedNodes, callback);
+        this.calcNodesAndSave([treeNode],callback,tender)
+      /*  let changedNodes = this.calculate(treeNode, true, true, tender); 统一调用相同的方法
+        this.saveNodes(changedNodes, callback);*/
     };
 
     /* 计算所有树结点(分3种情况)，并返回发生变动的零散的多个树结点。参数取值如下：
@@ -1930,6 +1955,7 @@ class CalcProgram {
         let changedNodes = [];
         function calcNodes(nodes) {
             for (let node of nodes) {
+                me.setUpdateDataToNode(node);
                 if (node.children.length > 0) {
                     calcNodes(node.children);
                 };
@@ -1955,6 +1981,13 @@ class CalcProgram {
         let changedNodes = this.calcAllNodes(calcType, tender);
         this.saveNodes(changedNodes, callback);
     };
+    setUpdateDataToNode(node){//将updateData里面的值设到node.data上，计算结点时才能拿到最新的值
+        if(!_.isEmpty(node.updateData)){
+            for(let key in node.updateData){
+                node.data[key] = node.updateData[key];
+            }
+        }
+    };
 
     // 计算零散的、混杂的树节点：清单、定额混合等(如：用到某一计算程序的定额和清单)。
     // 计算多条零散的定额，并计算他们所属的清单、父清单、引用清单。如：批量替换工料机后受影响的定额。
@@ -1962,6 +1995,7 @@ class CalcProgram {
     calcNodesAndSave(nodes, callback, tender){
         let me = this, rationNodes = [], billNodes = [], leafBills = [], allChangedNodes = [];
         for (let node of nodes) {
+          me.setUpdateDataToNode(node);//多节点更新的情况，要先更新值，因为计算过程中有可能要引用新的值
             if (node.sourceType == ModuleNames.ration)
                 rationNodes.push(node)
             else

web/building_saas/main/js/models/fee_rate.js

@@ -389,8 +389,8 @@ var FeeRate = {
             var me =this;
             if(node.sourceType === project.Bills.getSourceType()){
                 if(value === ''||value ===null ||value === undefined){//费费为空或空字符串时，请空对应的费率值和ID
-                    node.data.feeRateID = null;
-                    node.data.feeRate = null;
+                    node.updateData.feeRateID = null;
+                    node.updateData.feeRate = null;
                     node.changed = true;
                     project.calcProgram.calcAndSave(node);
                 }else {

web/building_saas/main/js/models/main_consts.js

@@ -276,48 +276,26 @@ const billText = {
 };
 
 let cpFeeTypes = [
-    {type: 'direct', name: '直接费'},
-    {type: 'labour', name: '人工费'},
-    {type: 'material', name: '材料费'},
-    {type: 'machine', name: '机械费'},
-    {type: 'mainMaterial', name: '主材费'},
-    {type: 'equipment', name: '设备费'},
+    {type: 'marketLabour', name: '人工费'},
+    {type: 'marketMaterial', name: '材料费'},
+    {type: 'marketMachine', name: '施工机具使用费'},
+    {type: 'marketEquipment', name: '设备费'},
+    {type: 'marketDirect', name: '直接费'},
+    {type: 'labour', name: '定额人工费'},
+    {type: 'material', name: '定额材料费'},
+    {type: 'machine', name: '定额施工机具使用费'},
+    {type: 'equipment', name: '定额设备费'},
+    {type: 'direct', name: '定额直接费'},
+    {type: 'measure', name: '措施费'},
+    {type: 'measure1', name: '措施费I'},
+    {type: 'measure2', name: '措施费II'},
     {type: 'manage', name: '企业管理费'},
+    {type: 'force', name: '规费'},
     {type: 'profit', name: '利润'},
-    {type: 'risk', name: '风险费'},
-    {type: 'labourDiff', name: '人工价差'},
-    {type: 'materialDiff', name: '材料价差'},
-    {type: 'machineDiff', name: '机械价差'},
-    {type: 'adjustLabour', name: '调整人工费'},
-    {type: 'adjustMachineLabour', name: '调整机上人工费'},
-    {type: 'unratedMaterial', name: '未计价材料费'},
-    {type: 'organizeMeasures', name: '组织措施费'},
-    {type: 'safeCivilization', name: '安全文明施工费'},
-    {type: 'night', name: '夜间施工费'},
-    {type: 'secondHandling', name: '二次搬运费'},
-    {type: 'winterRainy', name: '冬雨季施工增加费'},
-    {type: 'protection', name: '已完工程及设备保护费'},
-    {type: 'clean', name: '工程定位复测点交及场地清理费'},
-    {type: 'quotaDetermine', name: '工程定额测定费'},
-    {type: 'materialInspect', name: '材料检验试验费'},
-    {type: 'acceptance', name: '住宅工程质量分户验收费'},
-    {type: 'docManage', name: '档案管理费'},
-    {type: 'forceFee', name: '规费'},
-    {type: 'fiveOne', name: '五险一金'},
-    {type: 'sewage', name: '工程排污费'},
     {type: 'tax', name: '税金'},
-
-// {type: 'estimate', name: '暂估费'},
-    {type: 'common', name: '工程造价'},
-    {type: 'fee1', name: '费用1'}//,
-    // {type: 'fee2', name: '费用2'},
-    // {type: 'fee3', name: '费用3'},
-    // {type: 'fee4', name: '费用4'},
-    // {type: 'fee5', name: '费用5'},
-    // {type: 'fee6', name: '费用6'},
-    // {type: 'fee7', name: '费用7'},
-    // {type: 'fee8', name: '费用8'},
-    // {type: 'fee9', name: '费用9'}
+    {type: 'common', name: '建安费'}
+    // {type: 'fee1', name: '费用1'},
+    // {type: 'fee2', name: '费用2'}
 
 ];
 //8-27 zhang 这个已经不能用来判断工程类型了

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

@@ -236,14 +236,14 @@ ProjectGLJ.prototype.updateGLJProperty = function (node, updateField, newval) {
     $.bootstrapLoading.start();
     CommonAjax.post("/glj/modifyKeyValue", postData, function (result) {
         console.log(result);  //更新节点信息
-        rationTypeGLJ[updateField] = newval;
-        rationTypeGLJ.projectGLJID = result.id;
-        rationTypeGLJ.code = result.code;
-        rationTypeGLJ.basePrice = result.unit_price.base_price;
-        rationTypeGLJ.marketUnitFee = result.unit_price.market_price;
-        rationTypeGLJ.isAdd = result.unit_price.is_add;
-        rationTypeGLJ.isEstimate = result.is_evaluate;
-        rationTypeGLJ.shortName = result.unit_price.short_name;
+        node.updateData[updateField] = newval;
+        node.updateData.projectGLJID = result.id;
+        node.updateData.code = result.code;
+        node.updateData.basePrice = result.unit_price.base_price;
+        node.updateData.marketUnitFee = result.unit_price.market_price;
+        node.updateData.isAdd = result.unit_price.is_add;
+        node.updateData.isEstimate = result.is_evaluate;
+        node.updateData.shortName = result.unit_price.short_name;
         //触发计算并更新节点信息
         node.changed = true;
         projectObj.project.projectGLJ.loadData(function () {

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

@@ -725,14 +725,14 @@ var quantity_detail = {
 
         quantity_detail.prototype.updateBillQuantity=function (value,node,quantityEXP,editingText) {
             let oldQuantityEXP =  node.data.quantityEXP;
-            node.data.quantityEXP = quantityEXP?quantityEXP:editingText;
+            node.updateData.quantityEXP = quantityEXP?quantityEXP:editingText;
             value = scMathUtil.roundForObj(value,getDecimal("quantity",node));
             let newQuantity =  value+"";
             if(quantityEXP!="GCLMXHJ"&& oldQuantityEXP == node.data.quantityEXP && node.data.quantity == newQuantity){ //除了修改工程量明细表达式进来的操作，相当于什么都没改，不用做提交操作
                 projectObj.mainController.refreshTreeNode([node]);//这里要再刷新一下，因为工程量要把手工输入的值刷新为转换后的值再显示
                 return;
             }
-            node.data.quantity = newQuantity;
+            node.updateData.quantity = newQuantity;
             let needUpdateChildren = [];//需更新的子定额
             let gljNodes=[];//当定额工程量改变时需刷新的子工料机
             if(node.children.length>0){//如果有子项
@@ -745,8 +745,8 @@ var quantity_detail = {
                             if(isNaN(times)){
                                 times = 1;
                             }
-                            rationNode.data.quantity = scMathUtil.roundForObj(ration_value / times,getDecimal("quantity",rationNode));
-                            rationNode.data.contain = scMathUtil.roundForObj(rationNode.data.quantity/value,getDecimal("process"));
+                            rationNode.updateData.quantity = scMathUtil.roundForObj(ration_value / times,getDecimal("quantity",rationNode));
+                            rationNode.updateData.contain = scMathUtil.roundForObj(rationNode.data.quantity/value,getDecimal("process"));
                             rationNode.changed = true;
                             needUpdateChildren.push(rationNode);
                             if (rationNode.children.length>0){//如果有子工料机
@@ -760,7 +760,7 @@ var quantity_detail = {
                             // children_quantity = scMathUtil.roundForObj(this.reverseQuantity(children_quantity,rationNode),getDecimal("quantity",rationNode));  原先是要反算的，现在改成不用反算了
                             tem_contain =scMathUtil.roundForObj(children_quantity/value,getDecimal("process"));
                         }
-                        rationNode.data.contain = tem_contain;
+                        rationNode.updateData.contain = tem_contain;
                         rationNode.changed = true;
                         needUpdateChildren.push(rationNode);
                     }
@@ -797,7 +797,7 @@ var quantity_detail = {
         };
         quantity_detail.prototype.updateRationQuantity=function(value,node,quantityEXP,editingText){
             let oldQuantityEXP =  node.data.quantityEXP;
-            node.data.quantityEXP = quantityEXP?quantityEXP:editingText;
+            node.updateData.quantityEXP = quantityEXP?quantityEXP:editingText;
             //value = scMathUtil.roundForObj(value,getDecimal("ration.quantity"));
             value = project.quantity_detail.autoTransformQuantity(value,node);//先转换再4舍5入
             value = scMathUtil.roundForObj(value,decimalObj.decimal("quantity",node));
@@ -805,12 +805,12 @@ var quantity_detail = {
                 projectObj.mainController.refreshTreeNode([node]);//这里要再刷新一下，因为工程量要把手工输入的值刷新为转换后的值再显示
                 return;
             }
-            node.data.quantity=value;
+            node.updateData.quantity=value;
             if(node.parent.data.quantity&&node.parent.data.quantity!=0&&node.parent.data.quantity!=""){
                 var billQuantity = scMathUtil.roundForObj(node.parent.data.quantity,getDecimal("quantity",node.parent));
-                node.data.contain = scMathUtil.roundForObj(value/billQuantity,getDecimal("process"));
+                node.updateData.contain = scMathUtil.roundForObj(value/billQuantity,getDecimal("process"));
             }else {
-                node.data.contain=0;
+                node.updateData.contain=0;
             }
             node.changed = true;
             project.calcProgram.calcAndSave(node, function () {

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

@@ -775,12 +775,12 @@ var Ration = {
             let contain = scMathUtil.roundForObj(value,getDecimal("process"));
             let billQuantity = billNode.data.quantity||billNode.data.quantity!=""?billNode.data.quantity:0;
             billQuantity = parseFloat(billQuantity);
-            node.data.contain = contain;
-            node.data.quantityEXP="QDL*"+contain;
-            node.data.quantity=scMathUtil.roundForObj(billQuantity*contain,getDecimal("quantity",node));
+            node.updateData.contain = contain;
+            node.updateData.quantityEXP="QDL*"+contain;
+            node.updateData.quantity=scMathUtil.roundForObj(billQuantity*contain,getDecimal("quantity",node));
             let times = parseInt(node.data.unit);
             if (!isNaN(times)) {
-                node.data.quantityEXP+='*'+times;
+                node.updateData.quantityEXP+='*'+times;
             }
             //  node.data.quantity = projectObj.project.quantity_detail.autoTransformQuantity(node.data.quantity,node);//按单位做转换
             node.changed = true;

web/building_saas/main/js/views/fee_rate_view.js

@@ -934,8 +934,8 @@ var feeRateObject={
        if(selected.data.feeRateID === parseInt(rate.ID)) return $("#calcBaseFeeRate").modal('hide');
         $.bootstrapLoading.start();
         projectObj.project.FeeRate.submitFeeRateFromBill(rate,selected.data,function (data) {
-            selected.data.feeRateID= parseInt(rate.ID);
-            selected.data.feeRate=scMathUtil.roundToString(rate.rate,getDecimal("feeRate"));
+            selected.updateData.feeRateID= parseInt(rate.ID);
+            selected.updateData.feeRate=scMathUtil.roundToString(rate.rate,getDecimal("feeRate"));
             selected.changed = true;
             projectObj.project.calcProgram.calcAndSave(selected);
             $("#calcBaseFeeRate").modal('hide');

web/building_saas/main/js/views/main_tree_col.js

@@ -226,6 +226,11 @@ let MainTreeCol = {
             }
             return false;
         },
+        forQuantity2:function (node) {
+            if(node.sourceType !== ModuleNames.bills) return true;//不是清单，只读
+            if(node.data.type==billType.DXFY||(node.data.type==billType.BILL&&MainTreeCol.readOnly.billsParent(node))) return true;//大项费用、清单父项行，工程量只读。
+            return false
+        },
         forMarketPrice: function (node) {
             return MainTreeCol.readOnly.bills(node) ||
                 (node.sourceType === ModuleNames.ration && node.data.type == rationType.ration) ||
@@ -347,11 +352,11 @@ let MainTreeCol = {
                 return new GC.Spread.Sheets.CellTypes.CheckBox();
             }
         },
+        unitPriceAnalysis:function (node) {
+            if(node.sourceType == ModuleNames.bills) return new GC.Spread.Sheets.CellTypes.CheckBox();
+        },
         evaluationProject:function (node) {
-            if(node.sourceType == ModuleNames.ration){
-                return new GC.Spread.Sheets.CellTypes.CheckBox();
-            }
-
+            if(node.sourceType == ModuleNames.ration) return new GC.Spread.Sheets.CellTypes.CheckBox();
         },
         commonTotalFee: function () {
             return projectObj.getCommonTotalFeeCellType();

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

@@ -504,7 +504,7 @@ var projectObj = {
                     if(value === node.data.calcBase){
                         return;
                     }
-                    node.data.userCalcBase = value;
+                    node.updateData.userCalcBase = value;
                     project.calcBase.calculate(node);
                     if(!project.calcBase.success){
                         let activeCell = projectObj.mainSpread.getActiveSheet().getSelections()[0];
@@ -517,26 +517,23 @@ var projectObj = {
                 if(fieldName !== 'calcBase'){
                     calcTools.setFieldValue(node, fieldName, value);
                 };
-
                 project.calcProgram.calcAndSave(node);
                 gljOprObj.showRationGLJSheetData();
-            } else if (node.sourceType === project.Bills.getSourceType()&&(fieldName === 'unit'||fieldName === 'specialProvisional')){
-
-                //node.sourceType === project.Bills.getSourceType()&&fieldName === 'unit'
-                node.data[fieldName] = value;
+            } else if (node.sourceType === project.Bills.getSourceType()&&fieldName === 'unit'){
+                node.updateData[fieldName] = value;
                 node.changed = true;
-                if(fieldName === 'unit' && node.data.quantity)  node.data.quantity =scMathUtil.roundForObj(node.data.quantity,getDecimal("quantity",node));//修改清单单位的时候清单工程量要重新4舍5入
-                project.calcProgram.calcAndSave(node);
-            } else {
-                if (node.sourceType === project.Bills.getSourceType()) {
-                    project.Bills.updateField(node.source, fieldName, value, false);
-                } else if (node.sourceType === project.Ration.getSourceType()) {
-                    project.Ration.updateField(node.source, fieldName, value);
+                if(node.data.quantity){
+                    node.updateData.quantity = scMathUtil.roundForObj(node.data.quantity,getDecimal("quantity",node));//修改清单单位的时候清单工程量要重新4舍5入;
                 }
+                project.calcProgram.calcAndSave(node);
+            } else {//不涉及计算的，只改updateData的值就好了
+                node.updateData[fieldName] = value;
+                node.changed = true;
                 if (colSetting.data.wordWrap) {
                     this.mainSpread.getActiveSheet().autoFitRow(node.serialNo());
                 }
-                projectObj.mainController.refreshTreeNode([node]);
+                project.calcProgram.calcAndSave(node);
+               // projectObj.mainController.refreshTreeNode([node]);
             }
         } else if(value==null && fieldName ==='feeRate'){
             project.FeeRate.cleanFeeRateID(node);
@@ -1699,21 +1696,21 @@ var projectObj = {
             projectObj.onIsEstimateClick(node,info);
         }else if(fieldName == "evaluationProject"){
             projectObj.onEvaluationProjectClic(node,info);
+        }else if(fieldName == "unitPriceAnalysis"){
+            projectObj.onUnitPriceAnalysisClick(node,info);
         }
-
     },
     onEvaluationProjectClic:function (node,info) {
         let checkboxValue = info.sheet.getCell(info.row, info.col).value();
         let newval = checkboxValue?0:1;
         projectObj.project.updateEvalproject(newval,node.data,function (programID) {
-            node.data.evaluationProject = newval;
-            node.data.programID = programID;
+            node.updateData.evaluationProject = newval;
+            node.updateData.programID = programID;
             node.changed=true;
             projectObj.project.calcProgram.calcAndSave(node);
         })
     },
-
-    onIsEstimateClick: function(node,info){
+    setAndGetCheckBoxVal:function (info) {
         let checkboxValue = info.sheet.getCell(info.row, info.col).value();
         let cell = info.sheet.getCell(info.row, info.col), newval = 0;
         if (checkboxValue) {
@@ -1723,6 +1720,10 @@ var projectObj = {
             newval = 1;
             cell.value(newval);
         }
+        return newval;
+    },
+    onIsEstimateClick: function(node,info){
+        let newval = projectObj.setAndGetCheckBoxVal(info);
         if(MainTreeCol.readOnly.bills(node)){
             projectObj.updateNodeField(node,newval,'isEstimate');
         }else if(node.data.projectGLJID){//更新的是定额类型的工料机或者是显示在造价书页面的主材、设备
@@ -1731,9 +1732,47 @@ var projectObj = {
             projectObj.project.projectGLJ.pGljUpdate(updateData);
         }
     },
+    onUnitPriceAnalysisClick:function (unode,info) {
+        let updateDatas=[],nodes=[];
+        let newval = projectObj.setAndGetCheckBoxVal(info);
+         //仅对大项费用、清单有效，修改父项清单，子项清单跟随修改。
+        if(unode.sourceType == ModuleNames.bills) unitPriceAnalysisUpdate(unode,newval);
+        if(updateDatas.length > 0){
+            $.bootstrapLoading.start();
+            projectObj.project.updateNodes(updateDatas,function () {
+                for(let n of nodes){
+                    n.data.unitPriceAnalysis = newval;
+                }
+                projectObj.mainController.refreshTreeNode(nodes);
+                $.bootstrapLoading.end();
+            })
+        }
+
+
+         function unitPriceAnalysisUpdate(node,val){
+             updateDatas.push(getUnitPriceUpdataData(node,val));
+             nodes.push(node);
+             if(node.children.length > 0 && node.children[0].sourceType == ModuleNames.bills) {//仅对大项费用、清单有效
+                 for(let i = 0;i<node.children.length;i++ ){
+                     unitPriceAnalysisUpdate(node.children[i],val)
+                 }
+             }
+         }
+
+         function getUnitPriceUpdataData(node,val) {
+             let data =  {
+                 type:node.sourceType,
+                 data:{
+                     ID:node.data.ID,
+                     unitPriceAnalysis:val
+                 }
+             };
+             return data;
+         }
+    },
     onSubcontractClick:function (node) {//点击分包费checkbox
-        if (node.data.isSubcontract) node.data.isSubcontract = false;
-        else node.data.isSubcontract = true;
+        if (node.updateData.isSubcontract) node.updateData.isSubcontract = false;
+        else node.updateData.isSubcontract = true;
         node.changed = true;
         projectObj.project.calcProgram.calcAndSave(node);
     },
@@ -3277,8 +3316,8 @@ $('#calcBaseFeeRateConf').click(function () {
             newVal = number_util.checkNumberValue( $("#customFeeRate").val(),getDecimal("feeRate"));
             if(newVal == null) return
         }
-        selected.data.feeRateID = null;
-        selected.data.feeRate = newVal;
+        selected.updateData.feeRateID = null;
+        selected.updateData.feeRate = newVal;
         selected.changed = true;
         needToSave = true;
         cusFeeRate = true;

web/over_write/js/chongqing_2018.js

@@ -46,9 +46,9 @@ if(typeof materialComponent !== 'undefined'){
 }
 
 // CSL, 2018-08-21 计算程序、基数 的覆盖。---------------------------------------------------------------------------------
-let isCQ2018 = true;
+// let isCQ2018 = true;
 
-if(typeof baseMaterialTypes !== 'undefined'){
+/*if(typeof baseMaterialTypes !== 'undefined'){
     baseMaterialTypes.push(gljType.OTHER_MATERIAL);
     allMaterialTypes.delete(gljType.EQUIPMENT);
     baseMachineTypes.delete(gljType.MACHINE_COMPOSITION);
@@ -56,10 +56,10 @@ if(typeof baseMaterialTypes !== 'undefined'){
         gljType.INSPECTION_FEE, gljType.MAINTENANCE, gljType.DISMANTLING_FREIGHT_FEE,
         gljType.VERIFICATION_FEE, gljType.OTHER_FEE, gljType.OTHER_MACHINE_USED);
     baseMachineMasterTypes.push(gljType.INSTRUMENT);
-}
+}*/
 
 
-function overwriteRationCalcBases (taxType){
+/*function overwriteRationCalcBases (taxType){
     if (rationCalcBases){
         for (let key in rationCalcBases) {
             delete rationCalcBases[key];
@@ -90,7 +90,7 @@ function overwriteRationCalcBases (taxType){
         rationCalcBases['材料费价差'] = function (node, isTender) {
             return calcTools.rationBaseFee(node, baseMaterialTypes, priceTypes.ptDiffPrice, isTender);
         };
-/*        if (isJY){
+/!*        if (isJY){
             rationCalcBases['计价材料价差'] = function (node, isTender) {
                 let baseMaterialTypesWithoutOtherMaterial = [
                     gljType.GENERAL_MATERIAL,
@@ -102,7 +102,7 @@ function overwriteRationCalcBases (taxType){
                 ];
                 return calcTools.rationBaseFee(node, baseMaterialTypesWithoutOtherMaterial, priceTypes.ptDiffPrice, isTender);
             };
-        };*/
+        };*!/
         rationCalcBases['机上人工费价差'] = function (node, isTender) {
             return calcTools.rationBaseFee(node, [gljType.MACHINE_LABOUR], priceTypes.ptDiffPrice, isTender);
         };
@@ -131,9 +131,9 @@ function overwriteRationCalcBases (taxType){
             rationCalcBases['安拆费及场外运输费'] = function (node, isTender) {
                 return calcTools.machineDetailFee(node, node.data.gljList, [], gljType.DISMANTLING_FREIGHT_FEE, isTender);
             };
-/*            rationCalcBases['燃料动力费'] = function (node, isTender) {
+/!*            rationCalcBases['燃料动力费'] = function (node, isTender) {
                 return calcTools.machineDetailFee(node, node.data.gljList, [], gljType.FUEL_POWER_FEE, isTender);
-            };*/
+            };*!/
             rationCalcBases['定额仪器仪表费'] = function (node, isTender) {
                 return calcTools.rationBaseFee(node, [gljType.INSTRUMENT], priceTypes.ptBasePrice, isTender);
             };
@@ -175,9 +175,9 @@ function overwriteRationCalcBases (taxType){
         //         return 0;
         // };
     };
-};
+};*/
 
-(function overwriteFeeTypes() {
+/*(function overwriteFeeTypes() {
     if (typeof cpFeeTypes == 'undefined') return;
     cpFeeTypes = [
         {type: 'marketLabour', name: '人工费'},
@@ -199,7 +199,7 @@ function overwriteRationCalcBases (taxType){
         {type: 'tax', name: '税金'},
         {type: 'common', name: '建安费'}
     ];
-})();
+})();*/
 
 
 //清单计算基数相关