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

/**
 * Created by CSL on 2017-05-12.
 */

var gljOprObj = {
    sheet: null,
    libID: null,
    ration: null,
    sheetData: [],
    checkb: null,
    mainTreeSelectedChange:false,
    detailSheet: null,
    detailData: [],
    GLJSelection: [],
    selectedGLJClass: null,
    parentNodeIds: {},
    activeTab: '#linkGLJ',
    setting: {},
    detailSetting: {
        header: [
            {headerName: "名称", headerWidth: 100, dataCode: "name", dataType: "String"},
            {headerName: "计算式", headerWidth: 120, dataCode: "regex", dataType: "String"},
            {headerName: "结果（C）", headerWidth: 120, dataCode: "result", dataType: "Number", decimalField: "quantity_detail"},
            {headerName: "累加", headerWidth: 120, dataCode: "isSummation", dataType: "String", cellType: "checkBox"}
        ],
        view: {
            lockColumns: [2, 3]
        }
    },
    gljTreeSetting: {
        view: {
            expandSpeed: "",
            selectedMulti: false
        },
        edit: {
            enable: false,
            editNameSelectAll: true,
            showRemoveBtn: true,
            showRenameBtn: true,
            removeTitle: "删除节点",
            renameTitle: "更改名称"
        },
        data: {
            keep: {
                parent: true,
                leaf: true
            },
            key: {
                children: "items",
                name: "Name"
            },
            simpleData: {
                enable: false,
                idKey: "ID",
                pIdKey: "ParentID",
                rootPId: -1
            }
        },
        callback: {
            onClick: function (event, treeId, treeNode) {
                if (treeId == 'gljTree') {
                    let me = gljOprObj, gljTypeId = treeNode.ID;
                    if (treeNode.ID) {
                        me.gljCurTypeId = treeNode.ID;
                        me.filterLibGLJSheetData();
                        me.showLibGLJSheetData();
                    }
                } else {
                    if (treeNode.isParent) {
                        $('#class_selected_conf').attr("disabled", "disabled");
                        $('#selected_class').val("");
                    } else {
                        $('#class_selected_conf').removeAttr("disabled");
                        $('#selected_class').val(treeNode.ID);
                    }
                }

            }
        }
    },
    gljLibSheetSetting: {
        owner: 'gljTree',
        header: [
            {headerName: "选择", headerWidth: 40, dataCode: "select", hAlign: "center", vAlign: "center", cellType: "checkBox"},
            {headerName: "编码", headerWidth: 80, dataCode: "code", dataType: "String", formatter: "@", hAlign: "left", vAlign: "center"},
            {headerName: "名称", headerWidth: 220, dataCode: "name", dataType: "String", hAlign: "left", vAlign: "center"},
            {headerName: "规格型号", headerWidth: 185, dataCode: "specs", dataType: "String", hAlign: "left", vAlign: "center"},
            {headerName: "单位", headerWidth: 40, dataCode: "unit", dataType: "String", hAlign: "center", vAlign: "center"},
            {headerName: "单价", headerWidth: 55, dataCode: "basePrice", dataType: "Number", formatter: "0.00", hAlign: "right", vAlign: "center"},
            {headerName: "类型", headerWidth: 60, dataCode: "gljType", dataType: "String", hAlign: "center", vAlign: "center"},
            {headerName: "新增", headerWidth: 40, dataCode: "isComplementary", dataType: "String", hAlign: "center", vAlign: "center", cellType: "checkBox"}
        ],
        view: {
            lockColumns: [0, 1, 2, 3, 4, 5, 6]
        }
    },
    gljLibSheet: null,
    initSheet: function (sheet) {
        var me = this;
        me.sheet = sheet;
        sheetCommonObj.initSheet(me.sheet, me.setting, 30);
        sheet.name('ration_glj');
        me.bindSheetEvent(sheet);
        sheet.bind(GC.Spread.Sheets.Events.CellDoubleClick, me.onCellDoubleClick);
        sheet.bind(GC.Spread.Sheets.Events.ClipboardChanged, me.onClipboardChanged);
        subSpread.bind(GC.Spread.Sheets.Events.ButtonClicked, me.onButtonClick);
        if(!projectReadOnly){
            gljContextMenu.loadGLJSpreadContextMenu();
            //me.bindGLJEnterKey(subSpread,sheet);
        }
        sheet.bind(GC.Spread.Sheets.Events.SelectionChanged,function (sender,args) {
            let selected = args.newSelections[0] ? args.newSelections[0] : {row: 0, col: 0};
            me.sheetInitSelection(selected);
        });
    },

    bindGLJEnterKey:function (spread,sheet) {
        let me = this;
        subSpread.commandManager().register('myEnter', enterKeyAction);
        subSpread.commandManager().setShortcutKey(null, GC.Spread.Commands.Key.enter, false, false, false, false);
        subSpread.commandManager().setShortcutKey('myEnter', GC.Spread.Commands.Key.enter, false, false, false, false);

        function enterKeyAction(spd,sheeName) {
            let editRow = sheet.getActiveRowIndex(),orgCol = sheet.getActiveColumnIndex();
            if(sheet.isEditing()) sheet.endEdit();
             //GC.Spread.Sheets.Commands.commitInputNavigationDown.execute(spd,sheeName);
            //sheet.setSelection(editRow,orgCol+1,1,1);
            GC.Spread.Sheets.Commands.navigationRight.execute(spd,sheeName);
            //sheet.setActiveCell(editRow, orgCol+1)
        }
    },
    sheetInitSelection: function (selected) {
        let me = gljOprObj;
        if(selected.row < me.sheetData.length){
            me.sheet.setStyle(selected.row, -1, me.getSelStyle(true));
        }
        me.sheet.repaint();
        if(me.preGljSelection && me.preGljSelection.row !== selected.row){
            me.sheet.setStyle(me.preGljSelection.row, -1, me.getSelStyle(false));
        }
        me.preGljSelection = selected;
    },
    initDetailSheet: function (sheet) {
        var me = this;
        me.detailSheet = sheet;
        sheetCommonObj.initSheet(me.detailSheet, me.detailSetting, 30);
        // me.detailSheet.selectionUnit(0);//0 cell,1 row,2 col;
        sheet.name('quantity_detail');
        me.bindSheetEvent(sheet);
    },
    detailSheetReadonly:function () {
        let selected = projectObj.project.mainTree.selected;
        let Bills =  projectObj.project.Bills;
        if(selected) {
            //清单锁定时只读
            if(selected.sourceType == ModuleNames.bills && projectObj.project.isBillsLocked() && projectObj.project.withinBillsLocked(selected)){
                return true;
            }
            //大项费用、分部节点层次时，工程量明细只读。
            if(indicativeInfoObj.isDXFY(selected) || indicativeInfoObj.isFB(selected)){
                return true;
            }
            //是主材或者是设备时只读
            if(selected.sourceType == ModuleNames.ration_glj){
                return true;
            }else if(gljOprObj.isInstallationNode(selected)){//是补项或者是安装类型的定额时只读
                return true;
            }
            return false;
        }
        return true;
    },
    bindSheetEvent: function (sheet) {
        var me = this;
        sheet.bind(GC.Spread.Sheets.Events.ClipboardPasting, me.onClipboardPasting);
        sheet.bind(GC.Spread.Sheets.Events.ClipboardPasted, me.onClipboardPasted);
        sheet.bind(GC.Spread.Sheets.Events.EditEnded, me.onEditEnded);
        sheet.bind(GC.Spread.Sheets.Events.RangeChanged, me.onRangeChanged);
        sheet.bind(GC.Spread.Sheets.Events.EditStarting, me.startEditChecking);
        // sheet.bind(GC.Spread.Sheets.Events.CellClick, me.onCellClick);
    },

    onClipboardPasting: function (sender, args) {
        var me = gljOprObj;
        if(args.sheetName!="quantity_detail"&&(args.cellRange.rowCount!=1||args.cellRange.colCount!=1)){//工程量明细做特殊处理
            args.cancel = true;
        }
    },

    onClipboardPasted: function (e, info) {
        var me = gljOprObj;
        console.log('past');
        //  if (!me.ration) {return;};
        // your code...
    },
    startEditChecking:function (sender,args) {
        let me = gljOprObj;
        let selected = projectObj.project.mainTree.selected;
        if(selected){
            if(me.isInstallationNode(selected)==true){
                args.cancel = true;
            }else {
                if(args.sheetName == 'quantity_detail'){//工程量明细表
                    if(me.detailSheetReadonly()){
                        args.cancel = true;
                    }else {
                        if(args.sheet.getValue(args.row,args.col)==null){//这里是为了解决当单元格里的值是null的时候，在单元格里输入数据，按键盘箭头移动光标的时候，会直接结束编辑，跳到另外的单元格。
                            args.sheet.setValue(args.row,args.col,"");
                        }
                    }
                }
                if(args.sheetName == 'ration_glj'){//定额工料机表
                    if(!me.rationGLJEditCheck(args)) args.cancel = true;
                }
            }
        }else {
            args.cancel = true;
        }
    },
    isInstallationNode:function(node){
        if(node.sourceType == ModuleNames.ration&&node.data.type == rationType.install){//是定额安装费类型时只读，原先是补项的时候也是控制只读的||(node.sourceType == ModuleNames.bills&&node.data.type==billType.BX)){//是定额安装费类型或者补项
            return true;
        }
        return false
    },
    onEditEnded: function (sender, args) {
        var me = gljOprObj;
        if (args.sheetName == 'ration_glj') {
            me.onEditGLJSheet(args)
        }
        if (args.sheetName == 'quantity_detail') {
            me.onEditDetailSheet(args);
        }
    },
    onEditDetailSheet: function (args,callback) {
        var me = gljOprObj;
        if (args.row > me.detailData.length) {
            return;
        }
        if (args.row == me.detailData.length && args.editingText == null) {
            return;
        }
        var selected = projectObj.project.mainTree.selected;//因为使用了延时方法，所以要先取得选中行;
        var detailList = me.detailData;
        if(args.editingText){
            args.editingText = args.editingText.replace(/（/g, "(");//替换中文左右括号;
            args.editingText = args.editingText.replace(/）/g, ")");
        }
        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) {
        var me = gljOprObj;
        if (args.row >= me.sheetData.length) {
            me.sheet.getCell(args.row, args.col).value(null);
            return;
        }
        me.updateRationGLJ(args);
    },
    onSelectionChanged: function (sender, args) {
        let me = gljOprObj;
        me.initSelection(args.newSelections.length > 0 ? {row: args.newSelections[0].row} : {row: 0});
    },
    getSelStyle: function (selected) {
        let style = new GC.Spread.Sheets.Style();
        style.borderLeft = new GC.Spread.Sheets.LineBorder("#D4D4D4", GC.Spread.Sheets.LineStyle.thin);
        style.borderTop = new GC.Spread.Sheets.LineBorder("#D4D4D4", GC.Spread.Sheets.LineStyle.thin);
        style.borderRight = new GC.Spread.Sheets.LineBorder("#D4D4D4", GC.Spread.Sheets.LineStyle.thin);
        style.borderBottom = new GC.Spread.Sheets.LineBorder("#D4D4D4", GC.Spread.Sheets.LineStyle.thin);
        let colorOpts = optionsOprObj.getOption(optionsOprObj.optionsTypes.COLOROPTS);
        let selectedColor = colorOpts.SELECTED.backColor,
            recColor = 'White';
        style.backColor = selected ? selectedColor : recColor;
        return style;
    },
    initSelection: function (sel) {
        let me = gljOprObj;
        if(sel){
            me.gljLibSheet.setStyle(sel.row, -1, me.getSelStyle(true));
        }
        if(me.preGljLibSelection && me.preGljLibSelection.row !== sel.row){
            me.gljLibSheet.setStyle(me.preGljLibSelection.row, -1, me.getSelStyle(false));
        }
        me.preGljLibSelection = sel;
    },
    onButtonClick: function (sender, args) {
        if(args.sheet.isEditing()){
            args.sheet.endEdit();
        }
        var me = gljOprObj;
        var sheet = args.sheet, row = args.row, col = args.col;
        var cellType = sheet.getCellType(row, col);
        if (cellType instanceof GC.Spread.Sheets.CellTypes.Button) {
            if(args.sheetName == 'rationInstallSheet'){
                installationFeeObj.onPositionButtonClick(sender,args);
            }
        } else {
            me.onCheckBoxClick(sender, args)
        }
    },
    onCheckBoxClick: function (sender, args) {
        let selected = projectObj.project.mainTree.selected;
        if(selected.sourceType == ModuleNames.ration_glj){//选中的是工料机时不可编辑
            return ;
        }
        let checkboxValue = args.sheet.getCell(args.row, args.col).value();
        if(args.sheetName == 'rationInstallSheet' && checkboxValue){
            return;
        }
        if(gljOprObj.isInstallationNode(selected)==true){
            return;
        }
        let newval = 0;
        if (checkboxValue) {
            newval = 0;
            args.sheet.getCell(args.row, args.col).value(newval);
        } else {
            newval = 1;
            args.sheet.getCell(args.row, args.col).value(newval);
        }
        if (args.sheetName == 'ration_glj') {
            gljOprObj.updateIsEstimate(args,newval);
        }  else if (args.sheetName == 'quantity_detail') {
            projectObj.project.quantity_detail.isSummationUpdate(args, gljOprObj.detailData, newval);
        } else if (args.sheetName == 'glj_lib') {
            if(gljOprObj.gljLibSheetSetting.header[args.col].dataCode === 'select'){
                gljOprObj.setGLJSelection(args, newval);
            }
        }else if(args.sheetName == 'rationInstallSheet'){
            args.newValue = newval;
            installationFeeObj.onRationInstallValueChange(sender,args);
        }
    },
    onCellDoubleClick:function (sender, args) {
        var me = gljOprObj;
        var header = me.setting.header;
        if (args.row >= me.sheetData.length) {
            return;
        }
        if (header[args.col] && header[args.col].dataCode == 'marketPrice') {
            if(me.hasComposition(me.sheetData[args.row])){
                alert("当前工料机的市场价由组成物计算得出，不可直接修改。");
            }
        }
        if (header[args.col] && header[args.col].dataCode == 'basePrice') {
            var isAdd = me.sheetData[args.row].isAdd;
            if(isAdd==1){//是新增但没有组成物时允许修改定额价
                if(me.hasComposition(me.sheetData[args.row])){//如果有组成物，不可修改
                    alert("当前工料机的定额价由组成物计算得出，不可直接修改。");
                }
            }
        }
    },
    onClipboardChanged: function (sender, info) {
        let cDatas = sheetCommonObj.getTableData(info.sheet, null);
        sheetCommonObj.copyTextToClipboard(cDatas);
        return;
    },
    rationGLJEditCheck:function (args) {//true 可以编辑，false 不能编辑
        var me = gljOprObj;
        var header = me.setting.header;
        if (_.includes(me.setting.view.lockColumns, args.col))  return false;//如果是锁定的列，不能编辑
        if(me.sheetData[args.row] != undefined){
            if(me.sheetData[args.row].isMixRatio){//对于组成物列
               return header[args.col].dataCode == 'marketPrice'//允许修改组成物市单价,其它的不可以
            }else {
                if (header[args.col] && header[args.col].dataCode == 'marketPrice') {
                    return !me.marketPriceReadOnly({data:me.sheetData[args.row]});
                }
                if (header[args.col] && header[args.col].dataCode == 'basePrice') {
                    var isAdd = me.sheetData[args.row].isAdd;
                    if(isAdd==1){//是新增但没有组成物时允许修改定额价
                        return !me.marketPriceReadOnly({data:me.sheetData[args.row]});//如果有组成物，不可修改
                    } else {
                        return false;
                    }
                }
                return true;
            }
        }else {
            return false
        }
    }
    ,
    hasComposition:function (ration_glj,isRationType) {//判断是否有组成物，有则返回true   现在主材类型的工料机也有可能有组成物。
        let type = isRationType==true? ration_glj.subType:ration_glj.type;
        if(notEditType.indexOf(type)!=-1||type==gljType.MAIN_MATERIAL){
            let keyArray = isRationType==true? rationKeyArray:gljKeyArray;
            let con_key = this.getIndex(ration_glj,keyArray);
            var mixRatioMap = projectObj.project.projectGLJ.datas.mixRatioMap;
            if(mixRatioMap[con_key]&&mixRatioMap[con_key].length>0){
                return true;
            }
        }
        return false;
    },
    onRangeChanged: function (sender, args) {
        var me = gljOprObj;
        if(args.sheetName == 'quantity_detail'){
            me.batchUpdateQuantityDetail(args);
        }else {
            if (args.action == GC.Spread.Sheets.RangeChangedAction.clear) {
                args.editingText = null;
            }else if(args.action == GC.Spread.Sheets.RangeChangedAction.paste){
                args.editingText = args.sheet.getCell(args.row,args.col).value();
            }else {
                return;
            }
            if (args.sheetName == 'ration_glj') {
                me.onEditGLJSheet(args);
            }
        }
    },
    batchUpdateQuantityDetail:function (args) {
        let me = gljOprObj;
        let updateArray = [];
        for(let i =0;i<args.changedCells.length;i++){
            let c = args.changedCells[i];
            let tem = {
                row:c.row,
                col:c.col,
                editingText:args.sheet.getCell(c.row,c.col).text(),
                sheet:args.sheet,
                sheetName:args.sheetName,
                index:i
            };
            updateArray.push(tem);
        }
        if(updateArray.length>0){
            updateArray.length == 1?me.onEditDetailSheet(updateArray[0]):me.onEditDetailSheet(updateArray[0],updateCallback);
        }

        function updateCallback(i_args) {
            let index = i_args.index;
            if(index < updateArray.length-1){
                let nextIndex = index+1;
                updateArray[nextIndex].replace = i_args.replace;
                if(nextIndex == updateArray.length-1){//是最后一个，则不用调callback了
                    me.onEditDetailSheet(updateArray[nextIndex]);
                }else {
                    me.onEditDetailSheet(updateArray[nextIndex],updateCallback);
                }

            }
        }

    },
    showDataIfRationSelect: function (node,selectedNodeId) {
        var isShow = false;
        //恢复底色
        this.sheet.setStyle(this.sheet.getActiveRowIndex(), -1, this.getSelStyle(false));
        if(projectReadOnly && this.setting.view.lockColumns){
            this.setting.view.lockColumns = null;
        }
        if(selectedNodeId){
            this.selectedNodeId = selectedNodeId;
        }
        if (node) {
            if (this.selectedNodeId && this.selectedNodeId == node.getID()) {
                return;
            } else {
                this.selectedNodeId = node.getID();
            }
            if (node.sourceType == "ration") {
                if(node.data.type==rationType.gljRation){
                    if($('#linkGLJ').hasClass('active')){
                        this.showMixRatio(node);
                    }
                }else {
                    if($('#linkGLJ').hasClass('active')){
                        this.showRationGLJData(node);
                    }
                    if($('#linkAZZJF').hasClass('active')){
                        installationFeeObj.showRationInstallationData(node);
                    }
                }
                isShow = true;
            }
            if(node.sourceType == ModuleNames.ration_glj){
                if($('#linkGLJ').hasClass('active')) {
                    this.showMixRatio(node);
                }
                isShow = true;
            }
            if($('#linkGCLMX').hasClass('active')){
                this.showQuantityDetailData(node);
            }
        } else {
            this.selectedNodeId = null;
        }
        if (!isShow) {
            this.clearSheetData();
        }
        //子目换算
        zmhs_obj.showZMHSData(node);
        //   $('#dropdown').hide();
    },
    showMixRatio:function (node) {//显示组成物到定额工料机
        let mixRatioMap = projectObj.project.projectGLJ.datas.mixRatioMap;
        let projectGljs = projectObj.project.projectGLJ.datas.gljList;
        let indexArray =node.sourceType==ModuleNames.ration?rationKeyArray:gljKeyArray;
        let connect_index = this.getIndex(node.data,indexArray);
        let gljList=[];
        if(mixRatioMap[connect_index]){ //说明是有组成物的类型
            gljList =  this.getMixRationShowDatas(mixRatioMap[connect_index], projectGljs);
        }
        if(gljList.length>0){//计算总消耗量
            if(node.sourceType==ModuleNames.ration){
                this.calcMixRationTotalQuantity(gljList,node.data.quantity);
            }else {
               let totalQuantity = this.getTotalQuantity(node.data);
               this.calcMixRationTotalQuantity(gljList,totalQuantity)
            }
        }
        this.sheetData = gljList;
        this.sheet.setRowCount(0);
        this.sheetData = sortRationGLJ(this.sheetData);
        this.sheet.getRange(-1, 0, -1, 1).cellType(this.getTreeNodeCellType([]));
        sheetCommonObj.showData(this.sheet, this.setting, this.sheetData);
        //初始选择
        this.preGljSelection = null;
        this.sheetInitSelection({row: this.sheet.getActiveRowIndex(), col: 0});
        this.sheet.getRange(-1, 0, -1, this.setting.header.length).locked(true);//锁住定额工料机的所有列
        this.detailSheet.getRange(-1, 0, -1, this.detailSetting.header.length).locked(true);//锁住工程量明细的所有列
    },
    showRationGLJData: function (node) {
        var gljList = [];
        var ration_glj = projectObj.project.ration_glj;
        node = node ? node : projectObj.project.mainTree.selected;
        if (node.sourceType == ModuleNames.ration) {
            if(node.data.type==rationType.gljRation){
                this.showMixRatio(node);
            }else {
                let ration = node.data;
                gljList = this.filterGljByRation(ration, ration_glj.datas);
                this.showInSheet(gljList);
            }
        }else if(node.sourceType == ModuleNames.ration_glj){
            this.showMixRatio(node);
        }
    },
    showRationGLJSheetData: function (init) {
        let selected = this.sheet.getSelections();
        this.combineWithProjectGlj(this.sheetData);
        this.sheet.setRowCount(0);
        this.sheetData = sortRationGLJ(this.sheetData);
        this.sumQuantity();//计算总消耗量
        this.addMixRatioToShow();//显示组成物信息
        this.initRationTree(init,this.getUnitPriceCodeMap());
        sheetCommonObj.showData(this.sheet, this.setting, this.sheetData);
        if(this.mainTreeSelectedChange == true){
            this.sheet.setSelection(0,1,1,1);//默认选中第一行，第二列（名称列）
            this.mainTreeSelectedChange = false;
        }else if(selected){//定位光标到之前的位置
            this.sheet.setSelection(selected[0].row,selected[0].col,selected[0].rowCount,selected[0].colCount);
        }
        //初始选择
        this.preGljSelection = null;
        this.sheetInitSelection({row: this.sheet.getActiveRowIndex(), col: this.sheet.getActiveColumnIndex()});

    },
    getUnitPriceCodeMap : function () {//取单价文件中，编码前缀一样的映射表
        let codeMap = {};
        let priceMap = projectObj.project.projectGLJ.datas.unitPriceMap;
        if(priceMap){
            for(let connectKey in priceMap){
                let code = priceMap[connectKey].code;
                let name = priceMap[connectKey].name;
                let specs = priceMap[connectKey].specs;
                if(code){
                    let displayText = code +" "+name +" "+specs;
                   let preCode = code.split("-")[0];
                   if(codeMap[preCode]) {
                       codeMap[preCode].push({text:displayText,value:connectKey});
                   }else {
                       codeMap[preCode]=[{text:displayText ,value:connectKey}];
                   }
                }
            }
        }
        return codeMap;
    },

    initRationTree: function (init,codeMap) {
        this.sheet.suspendPaint();
        this.sheet.suspendEvent();
        this.sheet.setRowCount(this.sheetData.length >30?this.sheetData.length:30);
        for (var i = 0; i < this.sheetData.length; i++) {
            let options = this.getCodeOptions(this.sheetData[i],codeMap);
            this.sheet.setCellType(i, 0,this.getTreeNodeCellType(this.sheetData,options),GC.Spread.Sheets.SheetArea.viewport);
            if (this.sheetData[i].hasOwnProperty('subList')) {
                var collapsed = this.sheetData[i].collapsed == undefined ? true : this.sheetData[i].collapsed;
                if (collapsed == true) {
                    this.sheet.getRange(i + 1, -1, this.sheetData[i].subList.length, -1).visible(false);
                }
            }
        }
        this.sheet.resumeEvent();
        this.sheet.resumePaint();
    },
    getCodeOptions:function (recode,codeMap) {
        let options = [];
          if(recode.isMixRatio ===true){
              return null;
          }
        let code = recode.code;
        if(code) {
            let preCode = code.split("-")[0];
            if( codeMap[preCode]) options = codeMap[preCode];
            if(options.length>0) _.remove(options,{'value':gljOprObj.getIndex(recode, gljKeyArray)})//去掉本身
        }
        return options;
    },
    filterGljByRation: function (ration, datas) {
        var gljList = [];
        if (datas && datas.length > 0) {
            gljList = _.filter(datas, {'rationID': ration.ID})
        }
        return gljList;
    },
    showInSheet: function (gljList) {
        this.sheetData = gljList;
        this.showRationGLJSheetData(true);
    },
    sumQuantity: function (node) {
        if (this.sheetData.length > 0) {
            node = node ? node : projectObj.project.mainTree.selected;
            let ration = node.data;
            let quantity = ration.quantity;
            quantity = (quantity == 0 || quantity == undefined || quantity == null || quantity == "") ? 0 : quantity;
            for (let glj of this.sheetData) {
                glj.totalQuantity= this.getTotalQuantity(glj,ration);
            }
        }
    },
    getTotalQuantity:function(glj,ration){
        ration=ration?ration: _.find(projectObj.project.Ration.datas,{"ID":glj.rationID});
        if(ration){
            let quantity = ration.quantity;
            quantity = (quantity == 0 || quantity == undefined || quantity == null || quantity == "") ? 0 : quantity;
            if (glj.isMixRatio == true) {//如果是用于显示的组成物，则不用计算，跳过
                return;
            }
            quantity = scMathUtil.roundForObj(quantity, getDecimal("ration.quantity"));//计算前进行4舍5入
            glj.quantity = scMathUtil.roundForObj(glj.quantity, getDecimal("glj.quantity"));
            glj.totalQuantity = scMathUtil.roundToString(quantity * glj.quantity, getDecimal("glj.quantity"));
            if (glj.hasOwnProperty('subList')) {//需要计算glj下挂的组成物的总消耗量
                this.calcMixRationTotalQuantity(glj.subList,glj.totalQuantity);
            }
            return  glj.totalQuantity;
        }
    },
    calcMixRationTotalQuantity(mList,pTotal){ //计算组成物的总消耗量
        for (let subG of mList) {
            subG.rationItemQuantity = scMathUtil.roundForObj(subG.rationItemQuantity, getDecimal("glj.quantity"));
            subG.totalQuantity = scMathUtil.roundToString(subG.rationItemQuantity * pTotal, getDecimal("glj.quantity"));
        }
    },
    addMixRatioToShow: function () {
        var newList = [];
        _.remove(this.sheetData, {'isMixRatio': true});
        for (var i = 0; i < this.sheetData.length; i++) {
            newList.push(this.sheetData[i]);
            if (this.sheetData[i].hasOwnProperty('subList')) {
                newList = newList.concat(this.sheetData[i].subList);
            }
        }
        this.sheetData = newList;
    },
    combineWithProjectGlj: function (ration_gljs,needRatio=true) {
        var projectGLJData = projectObj.project.projectGLJ.datas;
        var projectGljs = projectGLJData.gljList;
        var mixRatioMap = projectGLJData.mixRatioMap;
        if (ration_gljs && ration_gljs.length > 0 && projectGljs && projectGljs.length > 0) {

            for (var i = 0; i < ration_gljs.length; i++) {
                var glj = _.find(projectGljs, {'id': ration_gljs[i].projectGLJID});
                if (glj) {
                    if(projectObj.project.projectGLJ.isEstimateType(ration_gljs[i].type )){
                        ration_gljs[i].isEstimate = glj.is_evaluate;
                    }
                    ration_gljs[i].shortName =projectObj.project.projectGLJ.getShortNameByID(ration_gljs[i].type);
                    ration_gljs[i].isAdd = glj.unit_price.is_add;
                    ration_gljs[i]=this.setGLJPrice(ration_gljs[i],glj);//设置工料机价格
                    var connect_index = this.getIndex(glj, gljKeyArray);
                    if (needRatio==true&&mixRatioMap.hasOwnProperty(connect_index)) {
                        var mixRatios = this.getMixRationShowDatas(mixRatioMap[connect_index], projectGljs);
                        ration_gljs[i].subList = mixRatios;
                    }
                }
            }
        }
        return ration_gljs;
    },
    setGLJPrice:function (data,glj,isRadio = false) {//isRadio 标记是否算组成物的价格
        let proGLJ =  projectObj.project.projectGLJ;
        let calcOptions=projectInfoObj.projectInfo.property.calcOptions;
        let decimalObj = projectInfoObj.projectInfo.property.decimal;
        let labourCoeDatas =  projectObj.project.labourCoe.datas;
        glj = glj?glj:_.find(proGLJ.datas.gljList, {'id': data.projectGLJID});
        if(glj){
            let result = gljUtil.getGLJPrice(glj,proGLJ.datas,calcOptions,labourCoeDatas,decimalObj,isRadio,_,scMathUtil);
            data.marketPrice = result.marketPrice;
            data.basePrice =  result.basePrice;
            data.adjustPrice = result.adjustPrice;
            data.marketUnitFee = data.marketPrice;//更新树节点市场单价列的值
        }
        return data;

    },
    getBasePrice:function (treeNode) {//造价书中的工料机修改的节点要用到
        let proGLJ =  projectObj.project.projectGLJ;
        let glj =_.find(proGLJ.datas.gljList, {'id': treeNode.data.projectGLJID});
        if(this.calcPriceDiff(glj)==true){
            return proGLJ.getBasePrice(glj);
        }else {
            return scMathUtil.roundForObj(treeNode.data.marketUnitFee,getDecimal("glj.unitPrice"));
        }
    },
    calcPriceDiff:function (glj) {
        let calcOptions=projectInfoObj.projectInfo.property.calcOptions;
        return gljUtil.calcPriceDiff(glj,calcOptions);
    },
    getIndex(obj, pops){
        let t_index = '';
        let k_arr = [];
        for (let p of pops) {
            let tmpK = (obj[p] == undefined || obj[p] == null || obj[p] == '') ? 'null' : obj[p];
            k_arr.push(tmpK);
        }
        t_index = k_arr.join("|-|");
        return t_index;
    },
    getConditionByKey(conKey){//将连接字符串转换成对象
        let valueArray = conKey.split("|-|");
        let obj ={};
        for(let i = 0;i<valueArray.length;i++){
            if(valueArray[i]!='null'){
                if(gljKeyArray[i]=='type'){
                    valueArray[i] = parseInt(valueArray[i]);
                }
                obj[gljKeyArray[i]]=valueArray[i];
            }
        }
        return obj;
    },
    getMixRationShowDatas: function (mixRatioList, projectGljs) {
        var temRationGLJs = [];
        for (var i = 0; i < mixRatioList.length; i++) {
            var pg = _.find(projectGljs, {
                'code': mixRatioList[i].code,
                'name': mixRatioList[i].name,
                'specs': mixRatioList[i].specs,
                'type': mixRatioList[i].type,
                'unit': mixRatioList[i].unit
            });//改关联关系
            var tem = {
                projectGLJID: pg.id,
                code: pg.code,
                name: pg.name,
                specs: pg.specs,
                unit: pg.unit,
                type:mixRatioList[i].type,
                shortName: projectObj.project.projectGLJ.getShortNameByID(mixRatioList[i].type),
                consumption:mixRatioList[i].consumption,
                rationItemQuantity: mixRatioList[i].consumption,
                // quantity:mixRatioList[i].consumption,
              /*  basePrice: pg.unit_price.base_price,
                marketPrice: pg.unit_price.market_price,
                adjustPrice: pg.adjust_price,*/
                //isEstimate: pg.is_evaluate,
                isMixRatio: true,
                isAdd: pg.unit_price.is_add,
                GLJID: pg.glj_id
            };
            if(projectObj.project.projectGLJ.isEstimateType(pg.type)){
                tem.isEstimate =  pg.is_evaluate;
            }
            this.setGLJPrice(tem,pg);
            temRationGLJs.push(tem);
        }
        temRationGLJs = _.sortBy(temRationGLJs, 'code');
        return temRationGLJs;
    },
    showQuantityDetailData: function (node) {
        node = node ? node : projectObj.project.mainTree.selected;
        var quantity_detail = projectObj.project.quantity_detail;
        let field = node.sourceType == ModuleNames.ration?'rationID':'billID';
        let details = quantity_detail.getListByID(node.data.ID,field);
        sheetCommonObj.showData(this.detailSheet, this.detailSetting, details);
        this.detailData = details;
        if (MainTreeCol.readOnly.forQuantifyDetail(node)) {
            this.detailSheet.getRange(-1, 0, -1, this.detailSetting.header.length).locked(true);
        }
    },
    clearSheetData: function () {
        if($('#linkGLJ').hasClass('active')){
            sheetCommonObj.showData(this.sheet, this.setting, []);
        }
        if($('#linkAZZJF').hasClass('active')){
            installationFeeObj.rationInstallSheet.setRowCount(0);//清除combobox cell
            sheetCommonObj.showData(installationFeeObj.rationInstallSheet, installationFeeObj.rationInstallSetting, []);
        }
        //  sheetCommonObj.showData(this.detailSheet,this.detailSetting,[]);
        this.sheetData = [];
        installationFeeObj.rationInstallData = [];
        //this.detailData=[];
    },
    updateRationGLJ: function (args) {
        var me = this;
        var updateField = me.setting.header[args.col].dataCode;
        var recode = me.sheetData[args.row];
        var newval;
        if(!me.rationGLJEditCheck(args)){
            recode? me.sheet.getCell(args.row, args.col).value(recode[updateField]): me.sheet.getCell(args.row, args.col).value(null);
            return;
        }
        if (updateField == 'marketPrice' || updateField == 'customQuantity' || updateField == 'basePrice') {
            if (args.editingText == null) {
                updateField == 'marketPrice' ? newval = 0 : newval = "";
            } else {
                var decimal = updateField == 'customQuantity' ? getDecimal("glj.quantity") : 6;//对于市场价和定额价，这里只是中间的小数位数，后面更新前会根据有没有组成物再取值
                newval = number_util.checkNumberValue(args.editingText, decimal);
                if (newval == null) {
                    me.sheet.getCell(args.row, args.col).value(recode[updateField]);
                    return;
                }
            }
        } else {
            if (updateField == 'name' || updateField == 'unit') {
                if (args.editingText === null) {
                    alert(me.setting.header[args.col].headerName + '不能为空!');
                    me.sheet.getCell(args.row, args.col).value(recode[updateField]);
                    return;
                }
            }
            if(updateField == 'code'){
                if (!gljUtil.isDef(args.editingText)||args.editingText==''||args.editingText.indexOf('|-|') === -1||this.isRationGLJExit(args.editingText)) {//说明是选中自已，或者是已存在的工料机
                    me.sheet.getCell(args.row, args.col).value(recode[updateField]);
                    return;
                }
            }
            newval = args.editingText == null ? "" : args.editingText;
        }
        if (newval === recode[updateField]) {//如果值完全相等，则不需要更新
            return
        }
        if (updateField == 'marketPrice' || updateField == 'basePrice') {
            projectObj.project.projectGLJ.updatePriceFromRG(recode, updateField, newval);
        }else if(updateField == 'code'){//替换单价文件中已经有的工料机
            projectObj.project.ration_glj.updateRationGLJByChangeCode(recode, updateField, newval);
        } else {
            projectObj.project.ration_glj.updateRationGLJByEdit(recode, updateField, newval);
        }
    },
    isRationGLJExit:function (connectKey) {
        for(let rg of gljOprObj.sheetData){
            if(rg.isMixRatio == true){
                continue;
            }
            if(gljOprObj.getIndex(rg, gljKeyArray) == connectKey){//存在一样的工料机
                return true;
            }
        }
       return false;
    },
    updateRationTypeGLJ: function (value, node, fieldName,editingText) {
        let newval;
        let updatePrice = false;
        if (fieldName == "marketUnitFee") {
            updatePrice = true;
            if (value == null) {
                newval = 0;
            } else {
                var decimal = getDecimal("glj.unitPrice");
                newval = number_util.checkNumberValue(value, decimal);
            }
        } else {
            if (value != null) {
                projectObj.project.projectGLJ.updatePropertyFromMainSpread(node, fieldName, value,editingText);
                return;
                //update
            }
        }
        if (newval && updatePrice == true) {
            projectObj.project.projectGLJ.updatePriceFromRG(node.data, "marketPrice", newval);
            return
        }

        projectObj.mainController.refreshTreeNode([node]);
    },
    updateIsEstimate:function (args, newval) {
        var me = gljOprObj;
        if(me.setting.header[args.col].dataCode=="isEstimate"){
            var pspread= new ProjectGLJSpread();
            var recode = me.sheetData[args.row];
            let projectGljs = projectObj.project.projectGLJ.datas.gljList;
            let glj = _.find(projectGljs, {'id': recode.projectGLJID});
            if(glj){
                glj["is_evaluate"]=newval;
                args.fromRG=true;
                pspread.postUpdate(recode.projectGLJID,"is_evaluate",newval,args,null,successTrigger);
            }
        }
    },
    showLibGLJSheetData: function () {
        this.gljLibSheetData = _.sortBy(this.gljLibSheetData, 'code');
        sheetCommonObj.showData(this.gljLibSheet, this.gljLibSheetSetting, this.gljLibSheetData, gljOprObj.distTypeTree);
        this.gljLibSheet.setRowCount(this.gljLibSheetData.length);
    },
    filterLibGLJSheetData: function () {
        let me = this;
        let val = $("input[name='glj']:checked").val();
        if (val == 'allGljs') {
            me.gljLibSheetData = me.stdGLJ.concat(me.complementaryGLJs);
        } else {
            me.gljLibSheetData = me[val];
        }
        if ($('#actionType').val() == 'replace' || $('#actionType').val() == 'm_replace') {
            me.filterLibGLJByType();
        }else if($('#actionType').val() == 'addMix'){
            projectGljObject.filterLibGLJForMixRatio();
        }
        //文本筛选
        let searchStr = $('#gljSearchKeyword').val();
        if(searchStr && searchStr.trim() != ''){
            let reg = new RegExp(searchStr);
            me.gljLibSheetData = _.filter(me.gljLibSheetData, function (data) {
                return reg.test(data.code) || reg.test(data.name);
            });
        }
        if (me.gljCurTypeId == undefined) {
            return;
        }
        if (me.parentNodeIds["_pNodeId_" + me.gljCurTypeId]) {
            me.gljLibSheetData = _.filter(me.gljLibSheetData, function (n) {
                return _.includes(me.parentNodeIds["_pNodeId_" + me.gljCurTypeId], n.gljClass);
            });
        } else {
            me.gljLibSheetData = _.filter(me.gljLibSheetData, {'gljClass': me.gljCurTypeId});
        }
    },
    setGLJSelection: function (args, newVal) {
        if ($('#actionType').val() == 'add' || $('#actionType').val() == 'insert'|| $('#actionType').val() == 'addMix') {
            this.addGLJsSelection(args, newVal);
        } else {
            this.replaceGLJSelection(args, newVal);
        }
    },
    addGLJsSelection: function (args, newVal) {
        var con_key = this.getIndex(this.gljLibSheetData[args.row], gljLibKeyArray);
        if (newVal == 1) {
            this.GLJSelection.push(con_key);
            this.gljLibSheetData[args.row].select = 1;
        } else if (newVal == 0) {
            _.pull(this.GLJSelection, con_key);
            this.gljLibSheetData[args.row].select = 0;
        }
    },
    replaceGLJSelection: function (args, newVal) {
        var me = this;
        var oldSelection = this.GLJSelection[0];
        if (newVal == 0) {
            args.sheet.getCell(args.row, args.col).value(1);
            return;
        }
        this.GLJSelection = [me.getIndex(this.gljLibSheetData[args.row], gljLibKeyArray)];
        this.gljLibSheetData[args.row].select = 1;
        var oindex = _.findIndex(this.gljLibSheetData, function (item) {
            var i_key = me.getIndex(item, gljLibKeyArray);
            return oldSelection == i_key;
        });
        if (oindex != -1) {
            args.sheet.getCell(oindex, args.col).value(0);
            this.gljLibSheetData[oindex].select = 0;
        } else {
            var oldData = _.find(gljOprObj.AllRecode, function (item) {
                var i_key = me.getIndex(item, gljLibKeyArray);
                return oldSelection == i_key;
            });
            oldData ? oldData.select = 0 : "";
        }
    },
    filterLibGLJByType: function () {
        var me = this;
        var selected = me.sheetData[gljContextMenu.selectedRow];
        //当前人材机类型是“混凝土、砂浆、配合比、商品混凝土、商品砂浆”时，筛选的可替换的人材机类型应是“混凝土、或砂浆、或配合比、或商品混凝土、或商品砂浆”。
        let materialTypes = [202, 203, 204, 205, 206];//除了普通材料
        let filterTypes = materialTypes.includes(selected.type) ? materialTypes : [selected.type];
        me.gljLibSheetData = _.filter(me.gljLibSheetData, function (data) {
            return filterTypes.includes(data.gljType);
        });
        //me.gljLibSheetData = _.filter(me.gljLibSheetData, {'gljType': selected.type});
    },
    getComboData: function (gljDistType) {
        let me = this;
        let distType;
        let distTypeTree = {
            prefix: 'gljType',
            distTypes: {},
            comboDatas: [],
            distTypesArr: []
        };
        gljDistType.forEach(function (typeData) {
            let typeObj = {
                data: typeData,
                children: [],
                parent: null
            }
            distTypeTree.distTypes[distTypeTree.prefix + typeData.ID] = typeObj;
            distTypeTree.distTypesArr.push(typeObj);
        });
        gljDistType.forEach(function (typeData) {
            distType = distTypeTree.distTypes[distTypeTree.prefix + typeData.ID];
            let parent = distTypeTree.distTypes[distTypeTree.prefix + typeData.ParentID];
            if (parent) {
                distType.parent = parent;
                parent.children.push(distType);
            }
        });
        distTypeTree.distTypesArr.forEach(function (distTypeObj) {
            if (distTypeObj.data.fullName !== '材料' && distTypeObj.data.fullName !== '机械') {
                distTypeTree.comboDatas.push({text: distTypeObj.data.fullName, value: distTypeObj.data.ID});
            }
        });
        return distTypeTree;
    },
    doInsertGLJ: function () {
        var me = this;
        var selected = projectObj.project.mainTree.selected;
        var project = projectObj.project;
        if (me.GLJSelection.length <= 0) {
            return;
        }
        $("#glj_tree_div").modal('hide');
        $.bootstrapLoading.start();
        project.ration_glj.insertGLJAsRation(me.GLJSelection, selected, function (parentNodeID,nextNodeID,data) {
            let newNode=null;
            for (let r_glj of data) {
                r_glj.quantity = r_glj.quantity + "";
                project.Ration.datas.push(r_glj);
            }//要先更新树节点工程量，加载项目工料机并计算消耗量才有值
            project.projectGLJ.loadData(function () {
                for(let r_glj of data){
                    r_glj = me.setGLJPrice(r_glj);//设置工料机价格
                    newNode = project.mainTree.insert(parentNodeID, nextNodeID, r_glj.ID);
                    newNode.source = r_glj;
                    newNode.sourceType = project.Ration.getSourceType();
                    newNode.data = r_glj;
                    ProjectController.syncDisplayNewNode(projectObj.mainController, newNode);
                }
                project.calcProgram.calcLeafAndSave(newNode.parent);//计算父级清单的所有子节点
                projectObj.mainController.refreshTreeNode([newNode]);
                if(me.hasComposition(newNode.data,true)){
                    me.showMixRatio(newNode);
                }else {
                    me.showRationGLJSheetData();
                }
                $.bootstrapLoading.end();
            });

        })
    },
    doAddGLJ: function () {
        var selected = projectObj.project.mainTree.selected;
        var project = projectObj.project;
        gljOprObj.GLJSelection = _.filter(gljOprObj.GLJSelection, function (n) {
            var rg = _.find(gljOprObj.sheetData, function (item) {
                if(item.isMixRatio == true){
                    return false;
                }
                var i_key = gljOprObj.getIndex(item, gljKeyArray);
                return n == i_key
            });
            return rg ? false : true;
        })
        if (gljOprObj.GLJSelection.length > 0 && selected && selected.sourceType == ModuleNames.ration) {
            $("#glj_tree_div").modal('hide');
            project.ration_glj.addGLJByLib(gljOprObj.GLJSelection, selected.data, function (result) {
                if (result) {
                    selected.data.adjustState = result.adjustState;
                    //project.ration_glj.datas = project.ration_glj.datas.concat(result.newRecodes);//显示和缓存统一，这样的话就不用更新两个位置了
                    project.ration_glj.datas = project.ration_glj.datas.concat(result.showData);
                    gljOprObj.sheetData = gljOprObj.sheetData.concat(result.showData);
                    project.projectGLJ.loadData(function () {
                        project.ration_glj.addToMainTree(result.showData);
                        gljOprObj.showRationGLJSheetData();
                        project.calcProgram.calcAndSave(selected);
                        projectObj.mainController.refreshTreeNode([selected]);
                        $.bootstrapLoading.end();
                    });
                }
            });//doc.rationID=selected.data.ID;
        } else {
            $("#glj_tree_div").modal('hide');
        }

    },
    doReplaceGLJ: function () {
        var me = this;
        var oldData = me.sheetData[gljContextMenu.selectedRow];
        var project = projectObj.project;
        var selectCode = gljOprObj.GLJSelection[0];
        var selected = projectObj.project.mainTree.selected;
        $("#glj_tree_div").modal('hide');
        project.ration_glj.replaceGLJ(selectCode, oldData, function (result) {
            if (result) {
                //result.adjustState;
                var glj_list = projectObj.project.ration_glj.datas;
                var data = result.data;
                var index = _.findIndex(gljOprObj.sheetData, {'ID': data.ID});
                var list_index = _.findIndex(glj_list, {'ID': data.ID});
                var nodes = [selected];
                gljOprObj.sheetData[index] = data;
                glj_list[list_index] = data;
                project.projectGLJ.loadData(function () {//加载完项目工料机再计算
                    gljOprObj.showRationGLJSheetData();
                    if (project.ration_glj.needShowToTree(data)) {//当替换的是主材或设备时，刷新对应的树节点
                        var node = project.ration_glj.findGLJNodeByID(data.ID);
                        if (node) {
                            project.ration_glj.transferToNodeData(data);
                            node.source = data;
                            node.data = data;
                        }
                        node ? nodes.push(node) : "";
                    }
                    //project.ration_glj.addToMainTree(data);
                    selected.data.adjustState = result.adjustState;
                    selected.data.name = result.name;
                    projectObj.mainController.refreshTreeNode(nodes);
                    project.calcProgram.calcAndSave(selected);
                    $.bootstrapLoading.end();
                });
            }
        })
    },
    doMReplaceGLJ: function () {
        let me = this;
        let oldData = me.sheetData[gljContextMenu.selectedRow];
        let project = projectObj.project;
        let selectCode = me.GLJSelection[0];
        $("#glj_tree_div").modal('hide');
        project.ration_glj.mReplaceGLJ(selectCode, oldData, function (result,updateMap) {
            if(result == null){
                return;
            }
            let data = result.data;
            let stateList = result.stateList;
            //let n_index = me.getIndex(data.query, gljKeyArray);
            let nodes = [];
            _.forEach(project.ration_glj.datas, function (t) {
           //     let t_index = me.getIndex(t, gljKeyArray);
                if (updateMap[t.ID]) {
                    me.updateProperty(t, data.doc);
                    me.updateProperty(t, updateMap[t.ID]);
                    if (project.ration_glj.needShowToTree(t)) {//如果是造价书中的树节点，则也须刷新
                        project.ration_glj.transferToNodeData(t);
                        var node = project.ration_glj.findGLJNodeByID(t.ID);
                        node ? nodes.push(node):'';
                    }
                }
            })
            project.projectGLJ.loadData(function () {
                me.showRationGLJSheetData();
                var rationNodes = me.refreshStateAfterMreplace(stateList, nodes);
                project.calcProgram.calcNodesAndSave(rationNodes);
                $.bootstrapLoading.end();
            });
        })
    },
    updateProperty: function (obj, doc) {
        _.forEach(doc, function (n, key) {
            obj[key] = n;
        });
    },
    refreshStateAfterMreplace: function (stateList, gljNodes) {
        var nodes = [];
        var rationNodes = [];
        _.forEach(stateList, function (s) {
            var node = _.find(projectObj.project.mainTree.items, function (n) {
                return n.sourceType == ModuleNames.ration && n.data.ID == s.rationID;
            })
            if (node) {
                node.data.adjustState = s.adjustState;
                node.data.name = s.name;
                nodes.push(node);
                rationNodes.push(node);
            }
        });
        gljNodes.length > 0 ? nodes = nodes.concat(gljNodes) : "";
        projectObj.mainController.refreshTreeNode(nodes);
        return rationNodes;
    },
    refreshView: function () {
        let node = projectObj.project.mainTree.selected;
        this.showDataIfRationSelect(node,"111111");
        //this.showRationGLJData();
    },
    //
    refreshTreeNode: function (obj) {
        if (!obj) {
            return;
        }
        var objectArray = [];
        var nodes = [];
        if (obj instanceof Array) {
            objectArray.concat(obj);
        } else {
            objectArray.push(obj);
        }
        for (let o of objectArray) {
            let node = this.updateDataNodeProperty(o.ID,o.data);
            if (node) {
                nodes.push(node);
            }
        }
        projectObj.mainController.refreshTreeNode(nodes);
        return nodes;

    },
    updateDataNodeProperty:function(nodeID,data){
        let node =  projectObj.project.mainTree.findNode(nodeID);
        if (node) {
            for (let k in data) {
                node.data[k] = data[k];
            }
        }
        return node;
    },
    getTreeNodeCellType: function (data,comboboxOptions) {
        var ns = GC.Spread.Sheets;
        var rectW = 10;
        var rectH = 10;
        var margin = 3;

        function TreeNodeCellType() {
        }

        function drowRect(ctx, x, y, w, h) {
            ctx.save();
            ctx.strokeStyle = "gray";
            ctx.translate(0.5, 0.5);
            ctx.beginPath();
            var rectX = x + margin;
            var rectY = y + Math.round(h / 2) - rectH / 2;
            ctx.moveTo(rectX, rectY);
            ctx.lineTo(rectX, rectY + rectH);
            ctx.lineTo(rectX + rectW, rectY + rectH);
            ctx.lineTo(rectX + rectW, rectY);
            ctx.lineTo(rectX, rectY);
            ctx.moveTo(rectX + rectW, y + Math.round(h / 2));
            ctx.lineTo(rectX + rectW + 5, y + Math.round(h / 2));
            ctx.stroke();
            ctx.restore();
        }

        function drowSymbol(ctx, x, y, w, h, collapsed) {
            ctx.save();
            ctx.strokeStyle = "#000000";
            ctx.translate(0.5, 0.5);
            ctx.beginPath();
            ctx.moveTo(x + margin + 2, y + Math.round(h / 2));
            ctx.lineTo(x + margin + 8, y + Math.round(h / 2));
            var rectY = y + Math.round(h / 2) - rectH / 2;
            if (collapsed) {
                ctx.moveTo(x + margin + rectW / 2, rectY + 2);
                ctx.lineTo(x + margin + rectW / 2, rectY + 2 + 6);
            }
            ctx.stroke();
            ctx.restore();
        }

        function drowSubItem(ctx, x, y, w, h, offset, nextItem) {
            offset += 6;
            ctx.save();
            ctx.strokeStyle = "gray";
            ctx.translate(0.5, 0.5);
            ctx.beginPath();
            ctx.moveTo(x + offset, y);
            ctx.lineTo(x + offset, y + Math.round(h / 2));
            offset += 9;
            ctx.lineTo(x + offset, y + Math.round(h / 2));
            if (nextItem && nextItem.isMixRatio) {
                ctx.moveTo(x + offset - 9, y + Math.round(h / 2));
                ctx.lineTo(x + offset - 9, y + h);
            }
            ctx.stroke();
            ctx.restore();
            return offset;
        }

        TreeNodeCellType.prototype =  comboboxOptions?sheetCommonObj.getDynamicCombo():new ns.CellTypes.Text();

        TreeNodeCellType.prototype.paint = function (ctx, value, x, y, w, h, style, options) {
            if (style.backColor) {//先画背景色
                ctx.save();
                ctx.fillStyle = style.backColor;
                ctx.fillRect(x, y, w, h);
                ctx.restore();
            } else {
                ctx.clearRect(x, y, w, h);
            }
            if (value != null) {
                var offset = margin + rectW + 6;
                var recode = data[options.row];
                if (recode && recode.hasOwnProperty('subList')) {
                    drowRect(ctx, x, y, w, h);
                    var collapsed = recode.collapsed == undefined ? true : recode.collapsed;//options.sheet.getTag(options.row,options.col);
                    drowSymbol(ctx, x, y, w, h, collapsed);
                } else if (recode && recode.isMixRatio) {
                    offset = drowSubItem(ctx, x, y, w, h, offset, data[options.row + 1]);
                    offset += 1;
                }
                arguments[2] = x + offset;
                arguments[4] = w - offset;
                //x = x + offset;
                //w = w - offset;
                GC.Spread.Sheets.CellTypes.Text.prototype.paint.apply(this, arguments);
            }
        };
        TreeNodeCellType.prototype.getHitInfo = function (x, y, cellStyle, cellRect, context) {
            if(x < cellRect.x+cellRect.width -15){//这里要判断点击的位置来决定return的内容，不能直接用combobox的方法
                return {
                    x: x,
                    y: y,
                    row: context.row,
                    col: context.col,
                    cellStyle: cellStyle,
                    cellRect: cellRect,
                    sheetArea: context.sheetArea
                };
            }else {
                return GC.Spread.Sheets.CellTypes.ComboBox.prototype.getHitInfo.apply(this, arguments);
            }

        };
        TreeNodeCellType.prototype.processMouseDown = function (hitinfo) {
            var recode = data[hitinfo.row];
            if (recode && recode.hasOwnProperty('subList')) {
                var hoffset = hitinfo.cellRect.x + 3;
                if (hitinfo.x > hoffset && hitinfo.x < hoffset + 10) {
                    var collapsed = recode.collapsed == undefined ? true : recode.collapsed;
                    collapsed = !collapsed
                    recode.collapsed = collapsed;
                    //hitinfo.sheet.setTag(hitinfo.row,hitinfo.col,collapsed);
                    hitinfo.sheet.getRange(hitinfo.row + 1, -1, recode.subList.length, -1).visible(!collapsed);
                    hitinfo.sheet.invalidateLayout();
                    hitinfo.sheet.repaint();
                    return;
                }
            }
            GC.Spread.Sheets.CellTypes.ComboBox.prototype.processMouseDown.apply(this, arguments);
           // GC.Spread.Sheets.CellTypes.Text.prototype.paint.apply(this, arguments);
        };
        let cellType = new TreeNodeCellType();
        if(comboboxOptions){
            cellType.editorValueType(GC.Spread.Sheets.CellTypes.EditorValueType.value);
            cellType.itemHeight(comboboxOptions.length).items(comboboxOptions);
        }
        return cellType;
    },
    marketPriceReadOnly: function (node) {
        let hasCom = false;
        if(node.sourceType==ModuleNames.ration&&node.data.type==rationType.gljRation){
            hasCom = this.hasComposition(node.data,true);
        }else {
            hasCom = this.hasComposition(node.data);
        }
        return hasCom|| node.data.isEstimate == 1;
    },
    locateZTree: function(ID) {
        let zTree = $.fn.zTree.getZTreeObj("gljTree");
        let node = null;
        if (ID) node = zTree.getNodesByParam('ID', ID, null)[0]
        if (!node) node = zTree.getNodeByTId('gljTree_1');
        zTree.selectNode(node);
        gljOprObj.gljCurTypeId = ID;
        gljOprObj.filterLibGLJSheetData();
        gljOprObj.showLibGLJSheetData();
    }

}

$(function () {
    $('#glj_tree_div').on('shown.bs.modal', function (e) {
        if (gljOprObj.gljLibSpresd == undefined) {
            gljOprObj.gljLibSpresd = sheetCommonObj.buildSheet($('#gljLibSheet')[0], gljOprObj.gljLibSheetSetting, gljOprObj.stdGLJ.length + gljOprObj.complementaryGLJs.length);
            sheetCommonObj.spreadDefaultStyle(gljOprObj.gljLibSpresd);
            gljOprObj.gljLibSpresd.bind(GC.Spread.Sheets.Events.ButtonClicked, gljOprObj.onButtonClick);
            gljOprObj.gljLibSheet = gljOprObj.gljLibSpresd.getSheet(0);
            gljOprObj.gljLibSheet.bind(GC.Spread.Sheets.Events.SelectionChanged, gljOprObj.onSelectionChanged);
            gljOprObj.gljLibSheet.setColumnWidth(0, 20, GC.Spread.Sheets.SheetArea.rowHeader);
            gljOprObj.gljLibSheet.options.isProtected = true;
            gljOprObj.gljLibSheet.name('glj_lib');
        }
        gljOprObj.gljLibSheetData = gljOprObj.AllRecode;
        let gljClass = 0, selectMap = {};
        if ($('#actionType').val() == 'add' || $('#actionType').val() == 'insert') {//插入，添加
            gljOprObj.GLJSelection = [];
        } else if($('#actionType').val() =='m_replace' || $('#actionType').val() == 'replace'){//替换、批量替换
            let selected = gljOprObj.sheetData[gljContextMenu.selectedRow];
            var connect_key = gljOprObj.getIndex(selected, gljKeyArray);
            gljOprObj.GLJSelection = [connect_key];
            selectMap[connect_key] = true;
            gljOprObj.filterLibGLJByType();
        }else if($('#actionType').val() =='addMix'){//添加组成物
            gljOprObj.GLJSelection = [];
            projectGljObject.filterLibGLJForMixRatio();
            /*selections = projectGljObject.mixRatioData;  添加组成物的时候先不选中
            gljOprObj.GLJSelection = [];
            for(let s of selections){
                let s_key = gljOprObj.getIndex(s, gljKeyArray);
                selectMap[s_key] = true;
                gljOprObj.GLJSelection.push(s_key);
            }*/
        }
        for(let item of gljOprObj.gljLibSheetData){
            let item_key = gljOprObj.getIndex(item, gljLibKeyArray);
            if(selectMap[item_key]){
                item.select = 1 ;
                gljClass = item.gljClass;
            }
        }

        //替换，焦点定位至当前选中人材机
        if($('#actionType').val() =='m_replace' || $('#actionType').val() == 'replace'){
            gljOprObj.locateZTree(gljClass);
            let selected = gljOprObj.sheetData[gljContextMenu.selectedRow];
            let index = _.findIndex(gljOprObj.gljLibSheetData, {code: selected.code});
            gljOprObj.gljLibSheet.showRow(index, GC.Spread.Sheets.VerticalPosition.center);
            gljOprObj.gljLibSheet.setActiveCell(index, 0);
            gljOprObj.initSelection({row: index});
            gljOprObj.gljLibSpresd.focus(true);
        }
        else gljOprObj.showLibGLJSheetData();
    });

    $('#glj_tree_div').on('hidden.bs.modal', function () {
        $('#gljSearchKeyword').val('');
    });

    $('.glj-radio').change(function () {
        let val = $("input[name='glj']:checked").val();
        if (val == 'allGljs') {
            gljOprObj.gljLibSheetData = gljOprObj.AllRecode;
            gljOprObj.filterLibGLJSheetData();
            gljOprObj.showLibGLJSheetData();
        } else {
            gljOprObj.gljLibSheetData = gljOprObj[val];
            gljOprObj.filterLibGLJSheetData();
            gljOprObj.showLibGLJSheetData();
        }
    })
/*    //工料机搜索
    $('#gljSearchKeyword').change(function () {
        gljOprObj.filterLibGLJSheetData();
        gljOprObj.showLibGLJSheetData();
    });
     $('#gljSearchKeyword').bind('keypress', function (e) {
        if(e.keyCode === 13){
            alert('2');
            $(this).blur();
            return false;
        }
    });*/
    $('#gljSearchKeyword').bind('keyup', function (e) {
        gljOprObj.filterLibGLJSheetData();
        gljOprObj.showLibGLJSheetData();
    });

    $('#glj_selected_conf').click(function () {
        if (gljOprObj.GLJSelection.length < 1) {
            return;
        }
        if ($('#actionType').val() == 'insert') {  //造价书页面中插入定额类型的工料机
            gljOprObj.doInsertGLJ();
        } else if ($('#actionType').val() == 'add') { //添加工料机
            gljOprObj.doAddGLJ();
        } else if ($('#actionType').val() == 'replace') {//替换工料机
            gljOprObj.doReplaceGLJ();
        } else if ($('#actionType').val() == 'm_replace') {//批量替换工料机
            gljOprObj.doMReplaceGLJ();
        }else if($('#actionType').val() == 'addMix'){
            projectGljObject.addMixRatio();
        }
    })

    $('#class_selected_conf').click(function () {
        var gljClass = $('#selected_class').val();
        var glj = gljOprObj.selectedGLJClass;
        if (glj && gljClass && gljClass != "") {
            //保存到我的工料机库
            /*1 检查是否有组成物
             * 2 如果有，则检查组成物中是否有新增的记录，如果有，查看是否已经保存了，没有的话，要先添加组成物到补充工料机库
             * 3 保存

             * */
            var newItem = {
                code: glj.code,
                name: glj.name,
                specs: glj.specs,
                unit: glj.unit,
                basePrice: glj.basePrice,
                gljType: glj.type,
                shortName: glj.shortName,
                component: [],
                gljClass: gljClass
            };
            if (glj.hasOwnProperty("subList") && glj.subList.length > 0) {//有组成物，检查组成物信息，目前组成物不允许修改，所以暂时不用考虑组成物是新增的情况
                for (var i = 0; i < glj.subList.length; i++) {
                    let tem = {
                        ID: glj.subList[i].GLJID,
                        consumeAmt: glj.rationItemQuantity,
                        isStd: true
                    }
                    newItem.component.push(tem);
                }
            }
            var data = getcmpUpdateData([newItem]);
            $.bootstrapLoading.start();
            var callback = function (data) {
                $("#glj_class_div").modal('hide');
                $.bootstrapLoading.end();
            }
            CommonAjax.post("complementartGlj/api/mixUpdateGljItems", data, callback, function () {
                $.bootstrapLoading.end();
            });
        }
    })

    $('#glj_class_div').on('hidden.bs.modal', function (e) {
        gljOprObj.selectedGLJClass = null;
        $('#class_selected_conf').attr("disabled", "disabled");
        $('#selected_class').val("");
    })

    function getcmpUpdateData(items) {
        var data = {
            "updateItems": [],
            "removeIds": []
        }
        data.addItems = items;
        return data;
    }
})


function  operationWithRound(value1,value2,field,symble) {
    let decimal = getDecimal(field);
    value1 = scMathUtil.roundForObj(value1,decimal);
    value2 = scMathUtil.roundForObj(value2,decimal);
    let result;
    switch (symble){
        case "+" :
            result=scMathUtil.roundForObj(value1 + value2,decimal);
            break;
        case "-":
            result=scMathUtil.roundForObj(value1 - value2,decimal);
            break;
        case "*":
            result=scMathUtil.roundForObj(value1 * value2,decimal);
            break;
        case "/":
            result=scMathUtil.roundForObj(value1 / value2,decimal);
            break
    }
    return result;
}

function getDecimal(fieldID, node) {
    if (node) {
        return decimalObj.decimal(fieldID, node);
    } else if (fieldID.indexOf(".") != -1) {
        var keyArray = fieldID.split(".");
        return decimalObj[keyArray[0]][keyArray[1]];
    } else {
        return decimalObj.decimal(fieldID);
    }
}


function sortRationGLJ(list) {
    list = _.sortByAll(list, [function (item) {
        return item.type + "";
    }, "code"])
    return list;
}

function compareRationGLJ(a, b) {
    if ((a.type + "") < (b.type + "")) {
        return true
    }
    if ((a.type + "") == (b.type + "")) {
        if (a.code < b.code) {
            return true
        }
    }
    return false;
}