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

modules/all_models/bills.js

@@ -63,7 +63,10 @@ let billsSchema = new Schema({
     installationKey:String,//用来记录安装增加费的关联字段
     deleteInfo: deleteSchema,
     isEstimate:{type: Number,default:0},       // 1 true 0 false 是否暂估
-    remark:String
+    remark:String,
+    engineeringContent:String,//工程内容
+    serviceContent:String,//服务内容
+    claimVisa:String//签证及索赔依据
 });
 
 mongoose.model("bills", billsSchema);

modules/all_models/project_glj.js

@@ -100,7 +100,8 @@ let modelSchema = {
         type: Number,
         default: 0
     },
-    ratio_data: Schema.Types.Mixed
+    ratio_data: Schema.Types.Mixed,
+    remark:String
 };
 mongoose.model(collectionName, new Schema(modelSchema, {versionKey: false}));
 

modules/glj/controllers/glj_controller.js

@@ -83,7 +83,7 @@ class GLJController extends BaseController {
         try {
             // 可编辑的字段
             let editableField = ['is_evaluate', 'unit_price.market_price', 'is_adjust_price', 'mix_ratio.consumption',
-                'supply', 'supply_quantity','delivery_address','delivery','materialType','materialCoe','is_main_material'];
+                'supply', 'supply_quantity','delivery_address','delivery','materialType','materialCoe','is_main_material','remark'];
             if (editableField.indexOf(field) < 0) {
                 throw '对应字段不能编辑';
             }

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

@@ -506,6 +506,15 @@ var Bills = {
                 return false;
             }
         };
+        bills.prototype.isEngineerEst = function (node) {//判断是否是“专业工程暂估价”节点
+            return node && isFlag(node.data)&&node.data.flagsIndex.fixed.flag==fixedFlag.ENGINEERING_ESITIMATE;
+        };
+        bills.prototype.isTotalService = function (node) {//判断是否是“总承包服务费”节点
+            return node && isFlag(node.data)&&node.data.flagsIndex.fixed.flag==fixedFlag.TURN_KEY_CONTRACT;
+        };
+        bills.prototype.isClaimVisa = function (node) {//判断是否是“签证及索赔计价”节点
+            return node && isFlag(node.data)&&node.data.flagsIndex.fixed.flag==fixedFlag.CLAIM_VISA;
+        };
         bills.prototype.isMeasure = function (node) {//判读是否属于措施项目部分
             let rootNode = this.getRootNode(node);
             if(isFlag(rootNode.data)&&rootNode.data.flagsIndex.fixed.flag==fixedFlag.MEASURE){

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

@@ -1418,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;
@@ -1721,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;
@@ -1743,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;
@@ -1766,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);
+    };
 
-    // 计算全部公式项。 (参数意义：将通过本方法后发生改变的节点存入changedArr中)
+    // 计算零散的、混杂的树节点：清单、定额混合等(如：用到某一计算程序的定额和清单)。
+    // 计算多条零散的定额，并计算他们所属的清单、父清单、引用清单。如：批量替换工料机后受影响的定额。
+    // 计算多条零散的清单，并计算他们的父清单、引用清单。如：花选删除树结点(如花选清单、定额等，不区分树结点类型)。
+    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中)
     calcFormulaNodes(changedArr, tender){
         let me = this;
         let formulaNodes = cbTools.getFormulaNodes(true);
@@ -1811,50 +1857,6 @@ class CalcProgram {
         };
     };
 
-    // 计算并保存指定的一个树节点。修改一个树节点，实际上要计算和保存的是一批树结点：层层父结点、被其它结点(的公式)引用的公式结点。
-    // 这个方法实际上封装了calculate()和saveNodes()两个方法，主要目的是为了外部调用方便，少写一点累赘代码。
-    calcAndSave(treeNode, callback, tender){
-        let changedNodes = this.calculate(treeNode, true, true, 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);
-        me.saveNodes(allChangedNodes, 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/quantity_detail.js

@@ -139,24 +139,29 @@ var quantity_detail = {
                 doc.refreshQuantity=true;
                 if(!selected.data.hasOwnProperty('isFromDetail')||selected.data.isFromDetail==0){
                     if(!args.replace){//为了批量粘贴时不重复提示，普通编辑时不受影响
-                        var c = confirm("确定要使用工程量明细替换原工程量吗？");
-                        if(c){
+                        hintBox.infoBox('操作确认', '确定要使用工程量明细替换原工程量吗？', 2, function () {
                             args.replace = true;
-                        }else {
+                            me.doSaveAction(doc,args,batchCallback);
+                        }, function () {
                             doc.refreshQuantity=false;
-                        }
+                            me.doSaveAction(doc,args,batchCallback);
+                        },['确定','取消']);
+                        return;
                     }
                 }
-
             }
-            var url="";
+            me.doSaveAction(doc,args,batchCallback);
+        };
+
+        quantity_detail.prototype.doSaveAction = function(doc,args,batchCallback){
+            let url="",me = this;
             $.bootstrapLoading.start();
             if(args.hasOwnProperty("insertRecode")){//右键插入或者是通过直接编辑保存
                 url = "/quantity_detail/insertRecode";
             }else{
                 url = "/quantity_detail/save";
             }
-            var callback = function (data) {
+            CommonAjax.post(url,doc,function (data) {
                 $.bootstrapLoading.end();
                 if(doc.refreshQuantity==false){//清空数据
                     me.cleanQuantityDetail();
@@ -165,16 +170,18 @@ var quantity_detail = {
                     if(batchCallback){
                         batchCallback(args)
                     }else if(data.node){
-                      me.refreshRationOrBillNodes(data.node);
+                        me.refreshRationOrBillNodes(data.node);
                     }
                     //gljOprObj.detailSheet.setActiveCell(0,0);
                     //gljOprObj.detailSheet.clearSelection();
                 }
-            }
-            CommonAjax.post(url,doc,callback,function () {
+            },function () {
                 $.bootstrapLoading.end();
             });
         };
+
+
+
         quantity_detail.prototype.refreshRationOrBillNodes=function(node){//工程量明细更新后触发定额或清单工程量改变，进行相应的更新
             var nodes = gljOprObj.refreshTreeNode(node);
             if(nodes.length>0){//触发计算
@@ -275,7 +282,7 @@ var quantity_detail = {
             return str.replace(regExp, RepText);
         };
         quantity_detail.prototype.updateQuantityDetail=function (args,dataCode,recode,selected,batchCallback) {
-            var doc ={};
+            var doc ={},me = this;
             var query={
                 ID:recode.ID,
                 projectID:recode.projectID
@@ -291,19 +298,21 @@ var quantity_detail = {
                 query.refreshQuantity=true;
                 if(!selected.data.hasOwnProperty('isFromDetail')||selected.data.isFromDetail==0){
                     if(!args.replace){//为了批量粘贴时不重复提示，普通编辑时不受影响
-                        var c = confirm("确定要使用工程量明细替换原工程量吗？");
-                        if(c){
+                        hintBox.infoBox('操作确认', '确定要使用工程量明细替换原工程量吗？', 2, function () {
                             args.replace = true;
-                        }else {
-                            this.cleanQuantityDetail(selected,true);
-                            return;
-                        }
+                            query.index = args.row;
+                            me.updateQuantityRegex(query,doc,args,batchCallback)
+                        }, function () {
+                            me.cleanQuantityDetail(selected,true);
+                        },['确定','取消']);
+                        return;
                     }
                 }
                 query.index = args.row;
-                this.updateQuantityRegex(query,doc,args,batchCallback)
+                me.updateQuantityRegex(query,doc,args,batchCallback);
+
             }else {
-                this.normalUpdate(query,doc,args,batchCallback);
+                me.normalUpdate(query,doc,args,batchCallback);
             }
         };
         quantity_detail.prototype.updateQuantityRegex=function(query,doc,args,batchCallback){
@@ -444,7 +453,7 @@ var quantity_detail = {
                 }
             }
             return invalidate;
-        }
+        };
 
         quantity_detail.prototype.replaceSqr = function(text) {
             var squarRegex = /\([^\^]+\)\^\d+/g;
@@ -511,7 +520,7 @@ var quantity_detail = {
         };
         quantity_detail.prototype.cleanQuantityDetail = function (node,needSave) {
            node =node?node:projectObj.project.mainTree.selected;
-           var query={projectID:node.data.projectID};
+           let query={projectID:node.data.projectID};
             if(node.sourceType === project.Bills.getSourceType()){
                 query.billID = node.data.ID;
                 this.deleteByBills([{type:'delete',data:node.data}]);
@@ -574,7 +583,7 @@ var quantity_detail = {
             if(node.sourceType === project.Ration.getSourceType()&&data.unit){
                 let times = parseInt(data.unit);
                 if (isNaN(times)) {
-                    times = 1
+                    times = 1;
                 }
                 value = value * times;
             }
@@ -587,22 +596,30 @@ var quantity_detail = {
                 projectObj.mainController.refreshTreeNode([node]);
             }else {
                 value=value?value:0;
-                setTimeout(function () {//spreadjs事件和提示窗口会有冲突，所以要用延时的方法
-                    if(project.quantity_detail.quantityEditChecking(value,node,fieldName)){
+                if(node.data.hasOwnProperty('isFromDetail')&&node.data.isFromDetail==1){
+                    hintBox.infoBox('操作确认', '已有工程量明细，是否清空明细表，采用手工输入的表达式？', 2, function () {
                         node.data.isFromDetail=0;
-                        project.quantity_detail.cleanQuantityDetail(node,true);
-                        if(node.sourceType === project.Bills.getSourceType()){
-                            me.updateBillQuantity(value,node,null,editingText);
-                        }else {
-                            me.updateRationQuantity(value,node,null,editingText);
-                        }
-                        gljOprObj.refreshView();
-                    }else {
+                        me.updateMainTreeNodeQuantity(value,node,editingText);
+                    }, function () {
                         projectObj.mainController.refreshTreeNode([node]);
-                    }
-                },100);
+                    },['确定','取消']);
+                    return;
+                }
+                me.updateMainTreeNodeQuantity(value,node,editingText);
             }
         };
+        quantity_detail.prototype.updateMainTreeNodeQuantity = function(value,node,editingText){
+            let me = this;
+            project.quantity_detail.cleanQuantityDetail(node,true);
+            if(node.sourceType === project.Bills.getSourceType()){
+                me.updateBillQuantity(value,node,null,editingText);
+            }else {
+                me.updateRationQuantity(value,node,null,editingText);
+            }
+            gljOprObj.refreshView();
+        };
+
+
         quantity_detail.prototype.updateBillQuantity=function (value,node,quantityEXP,editingText) {
             node.data.quantityEXP = quantityEXP?quantityEXP:editingText;
             value = scMathUtil.roundForObj(value,getDecimal("quantity",node));
@@ -706,7 +723,7 @@ var quantity_detail = {
             }else {
                 decimal = decimalObj.ration.quantity
             }
-            return;
+            return decimal;
         };
         return new quantity_detail(project);
     }

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

@@ -653,39 +653,50 @@ var Ration = {
             this.project.endUpdate();
         };
         ration.prototype.updateContain=function (value,node) {
+            let me = this;
             if(isNaN(value)){
                 alert("当前输入的数据类型不正确，请重新输入");
                 projectObj.mainController.refreshTreeNode([node]);
                 return;
             }
-            let billNode = node.parent;
-            let contain = scMathUtil.roundForObj(value,getDecimal("process"));
+
             if(node.data.quantityEXP=="GCLMXHJ"){//如果定额工程量是来自工程量明细
-                var c = confirm('已有工程量明细，是否清空明细表，采用手工输入的表达式？');
-                if(c){
+                hintBox.infoBox('操作确认', '已有工程量明细，是否清空明细表，采用手工输入的表达式？', 2, function () {
                     node.data.isFromDetail=0;
                     project.quantity_detail.cleanQuantityDetail(node,true);
-                }else {
+                    me.doContainUpdate(value,node);
+                }, function () {
                     projectObj.mainController.refreshTreeNode([node]);
-                    return;
-                }
+                },['确定','取消']);
+            }else {
+                me.doContainUpdate(value,node);
             }
+
+        };
+        ration.prototype.doContainUpdate = function (value,node) {
+
+            let billNode = node.parent;
+            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));
-            let times = parseInt(node.data.unit)
+            let times = parseInt(node.data.unit);
             if (!isNaN(times)) {
                 node.data.quantityEXP+='*'+times;
             }
-          //  node.data.quantity = projectObj.project.quantity_detail.autoTransformQuantity(node.data.quantity,node);//按单位做转换
+            //  node.data.quantity = projectObj.project.quantity_detail.autoTransformQuantity(node.data.quantity,node);//按单位做转换
             node.changed = true;
             project.calcProgram.calcAndSave(node, function () {
                 project.projectGLJ.calcQuantity();
             });
             projectObj.mainController.refreshTreeNode(node.children);//刷新子工料机树节点总消耗量
+
+
+
         };
+
         ration.prototype.addRationChecking=function(selected){
             if (selected) {// Vincent, 2018-01-02
                 if(selected.sourceType === project.Ration.getSourceType()){ // 焦点行是定额/量价/工料机，有效显示。

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

@@ -355,14 +355,12 @@ var gljOprObj = {
             args.editingText = args.editingText.replace(/（/g, "(");//替换中文左右括号;
             args.editingText = args.editingText.replace(/）/g, ")");
         }
-        setTimeout(function () {//这里须用延时执行的办法，不然的弹窗确认窗口会和spreadjs 的事件有冲突，造成定额工料机数据不会根据树结点更新的问题
-            if (args.row == detailList.length) {
-                projectObj.project.quantity_detail.saveQuantityDetail(args, me.detailSetting.header[args.col].dataCode, selected,callback);
-            }
-            if (args.row < detailList.length) {
-                projectObj.project.quantity_detail.updateQuantityDetail(args, me.detailSetting.header[args.col].dataCode, detailList[args.row], selected,callback);
-            }
-        }, 200);
+        if (args.row == detailList.length) {
+            projectObj.project.quantity_detail.saveQuantityDetail(args, me.detailSetting.header[args.col].dataCode, selected,callback);
+        }
+        if (args.row < detailList.length) {
+            projectObj.project.quantity_detail.updateQuantityDetail(args, me.detailSetting.header[args.col].dataCode, detailList[args.row], selected,callback);
+        }
 
     },
     onEditGLJSheet: function (args) {
@@ -1207,7 +1205,9 @@ var gljOprObj = {
         return rationNodes;
     },
     refreshView: function () {
-        this.showRationGLJData();
+        let node = projectObj.project.mainTree.selected;
+        this.showDataIfRationSelect(node,"111111");
+        //this.showRationGLJData();
     },
     //
     refreshTreeNode: function (obj) {

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

@@ -26,7 +26,8 @@ projectGljObject={
             {headerName: "三材系数", headerWidth: 100, dataCode: "materialCoe", hAlign: "right", dataType: "Number",validator:"number"},//,decimalField:'material'
             {headerName: "交货方式", headerWidth: 90, dataCode: "delivery", hAlign: "left", dataType: "String"},
             {headerName: "送达地点", headerWidth: 100, dataCode: "delivery_address", hAlign: "left", dataType: "String"},
-            {headerName: "不调价", headerWidth: 55, dataCode: "is_adjust_price", dataType: "String",cellType: "checkBox"}
+            {headerName: "不调价", headerWidth: 55, dataCode: "is_adjust_price", dataType: "String",cellType: "checkBox"},
+            {headerName: "备注", headerWidth: 100, dataCode: "remark", hAlign: "left", dataType: "String"}
         ],
         view: {
             lockColumns: [0,1,2,3,4,5,7]
@@ -528,7 +529,8 @@ projectGljObject={
             is_add:glj.unit_price.is_add,
             bgColour:'white',
             techQuantity:glj.techQuantity,
-            subdivisionQuantity:glj.subdivisionQuantity
+            subdivisionQuantity:glj.subdivisionQuantity,
+            remark:glj.remark
         };
         gljOprObj.setGLJPrice(data,glj);
         data.is_main_material = glj.is_main_material == 1?1:0;

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

@@ -942,6 +942,37 @@ var projectObj = {
                     callback: function () {
                         BlockController.pasteBlock(project.mainTree.selected);
                     }
+                },
+                "editEngineer": {
+                    name: '编辑工程内容',
+                    icon: 'fa-edit',
+                    visible: function(key, opt){
+                         return project.Bills.isEngineerEst(project.mainTree.selected);//当焦点行是“专业工程暂估价”时，右键可见并有效。
+                    },
+                    callback: function () {
+                        projectObj.editContent(project.mainTree.selected,'engineeringContent');
+                        //BlockController.pasteBlock(project.mainTree.selected);
+                    }
+                },
+                "editService": {
+                    name: '编辑服务内容',
+                    icon: 'fa-edit',
+                    visible: function(key, opt){
+                        return project.Bills.isTotalService(project.mainTree.selected);//当焦点行是“总承包服务费”时，右键可见并有效。
+                    },
+                    callback: function () {
+                        projectObj.editContent(project.mainTree.selected,'serviceContent');
+                    }
+                },
+                "editAccording": {
+                    name: '编辑签证及索赔依据',
+                    icon: 'fa-edit',
+                    visible: function(key, opt){
+                        return project.Bills.isClaimVisa(project.mainTree.selected);//当焦点行是“签证及索赔计价”时，右键可见并有效。
+                    },
+                    callback: function () {
+                        projectObj.editContent(project.mainTree.selected,'claimVisa');
+                    }
                 }
             }
         });
@@ -1332,6 +1363,25 @@ var projectObj = {
             $("a[name='lockBills']").prop("title","锁定清单");
             $("a[name='lockBills']").html('<i class="fa fa-lock" aria-hidden="true"></i> 锁定清单');
         }
+    },
+    editContent:function (node,fieldID) {//右键编辑工程内容、服务内容、签证及索赔依据
+        let infoText = "请输入";
+        switch (fieldID){
+            case "engineeringContent":
+                infoText +='工程内容:';
+                break;
+            case "serviceContent":
+                infoText +='服务内容:';
+                break;
+            case "claimVisa":
+                infoText +='签证及索赔依据:';
+                break;
+        }
+
+        hintBox.valueBox(infoText, node.data[fieldID], function () {
+            let newValue = hintBox.value;
+            projectObj.updateNodeField(node,newValue,fieldID);
+        });
     }
 
 };
@@ -1726,7 +1776,7 @@ function testShow() {
     }
 }
 
-$('#delete_row').on('shown.bs.modal', function (e) {
+$('#delete_row').on('show.bs.modal', function (e) {//这里用show,在shown之前调用，页面不会出现按钮闪现的情况
     var controller = projectObj.mainController, project = projectObj.project;
     var selected = controller.tree.selected, parent = selected.parent;
     var showinfo = "<label>确认要删除当前选中行吗？</label>";