YangHuOperation/web/maintain/std_glj_lib/js/gljComponent.js

/**
 * Created by Zhong on 2017/8/15.
 */

let gljComponentOprObj = {
    workBook: null,
    processDecimal: -6,
    setting: {
        owner: "gljComponent",
        header:[
            {headerName:"编码",headerWidth:80,dataCode:"code", dataType: "String", formatter: "@", hAlign: "left", vAlign: "center"},
            {headerName:"名称",headerWidth:90,dataCode:"name", dataType: "String", formatter: "@", hAlign: "left", vAlign: "center"},
            {headerName:"单位",headerWidth:45,dataCode:"unit", dataType: "String", hAlign: "center", vAlign: "center"},
            {headerName:"单价",headerWidth:60,dataCode:"basePrice", dataType: "Number", formatter: "0.00", hAlign: "right", vAlign: "center"},
            {headerName:"消耗量",headerWidth:70,dataCode:"consumeAmt", dataType: "Number", formatter: "0.000", hAlign: "right", vAlign: "center"}
        ],
        view: {
            lockedCols:[1, 2, 3]
        }
    },
    //生成列头（多单价）(多消耗量)
    initHeaders: function (priceProperties, consumeAmtProperties) {
        let headers = [
            {headerName:"编码",headerWidth:80,dataCode:"code", dataType: "String", formatter: "@", hAlign: "left", vAlign: "center"},
            {headerName:"名称",headerWidth:90,dataCode:"name", dataType: "String", formatter: "@", hAlign: "left", vAlign: "center"},
            {headerName:"单位",headerWidth:45,dataCode:"unit", dataType: "String", hAlign: "center", vAlign: "center"},
        ];
        //生成消耗量列
        if(!consumeAmtProperties || consumeAmtProperties.length === 0){
            headers.push({headerName:"消耗量",headerWidth:70,dataCode:"consumeAmt", dataType: "Number", formatter: "0.000", hAlign: "right", vAlign: "center"});
        }
        else {
            for(let consumeAmtProp of consumeAmtProperties){
                let colData = {
                    headerName: consumeAmtProp.consumeAmt.dataName,
                    headerWidth: 60,
                    dataCode: consumeAmtProp.consumeAmt.dataCode,
                    dataType: 'Number',
                    formatter: '0.000',
                    hAlign: 'right',
                    vAlign: 'center'
                };
                headers.push(colData);
            }
        }
        //生成单价列
        if(!priceProperties || priceProperties.length === 0){
            headers.push({headerName:"定额价",headerWidth:80,dataCode:"basePrice", dataType: "Number", formatter: "0.00", hAlign: "right", vAlign: "center"});
        }
        else {
            for(let priceProp of priceProperties){
                let colData = {
                    headerName: priceProp.price.dataName,
                    headerWidth: 100,
                    dataCode: priceProp.price.dataCode,
                    dataType: 'Number',
                    formatter: '0.00',
                    hAlign: 'right',
                    vAlign: 'center'
                };
                headers.push(colData);
            }
        }
        return headers;
    },
    setFrozen: function (sheet) {
        const fixedHeadersLen = 3;
        let frozenCol = 0;
        if(consumeAmtProperties && consumeAmtProperties.length > 0){
            frozenCol = fixedHeadersLen + consumeAmtProperties.length;
        }
        else if(priceProperties && priceProperties.length > 0){
            frozenCol = fixedHeadersLen + 1;
        }
        if(frozenCol > 0){
            sheet.frozenColumnCount(frozenCol);
        }
    },
    buildSheet: function(container) {
        let me = gljComponentOprObj;
        //生成人材机组成物表格列头
        me.setting.header = me.initHeaders(priceProperties, consumeAmtProperties);
        //生成人材机组成物列映射
        sheetCommonObj.initColMapping(me, me.setting.header);
        repositoryGljObj.initPriceCols.call(me, priceProperties, me.colMapping);
        me.initConsumeAmtCols(consumeAmtProperties, me.colMapping);
        me.workBook = sheetCommonObj.buildSheet(container, me.setting, 30, me);
        me.setFrozen(me.workBook.getSheet(0));
        sheetCommonObj.bindEscKey(me.workBook, [{sheet: me.workBook.getSheet(0), editStarting: me.onCellEditStart, editEnded: me.onCellEditEnd}]);
        me.workBook.getSheet(0).setColumnWidth(0, 20, GC.Spread.Sheets.SheetArea.rowHeader);
        me.workBook.getSheet(0).setFormatter(-1, 0, "@", GC.Spread.Sheets.SheetArea.viewport);
        sheetCommonObj.cleanSheet(me.workBook.getSheet(0), me.setting, -1);

        me.gljComponentDelOpr();
        me.onContextmenuOpr();
        me.workBook.bind(GC.Spread.Sheets.Events.ClipboardPasting, me.onClipboardPasting);
        me.workBook.bind(GC.Spread.Sheets.Events.ClipboardPasted, me.onClipboardPasted);
        me.workBook.getSheet(0).bind(GC.Spread.Sheets.Events.EditStarting, me.onCellEditStart);
        me.workBook.getSheet(0).bind(GC.Spread.Sheets.Events.EditEnded, me.onCellEditEnd);
    },
    getRowData: function (sheet, row, setting) {
        let rst = {priceProperty: {}, consumeAmtProperty: {}};
        for(let i = 0; i < setting.header.length; i++){
            let v = sheet.getValue(row, i);
            if(this.pricePropertyCols.includes(i)){
                rst.priceProperty[setting.header[i].dataCode] = v && v !== '' ? v : 0;
            }
            else if(this.consumeAmtPropertyCols.includes(i)){
                rst.consumeAmtProperty[setting.header[i].dataCode] = v && v !== '' ? v : 0;
            }
            else {
                rst[setting.header[i].dataCode] = v;
            }
        }
        return rst;
    },
    getComponent: function (sheet, rowCount) {
        let component = [];
        for(let row = 0; row < rowCount; row++){
            let obj = {};
            obj.consumeAmt = sheet.getValue(row, 4);
            obj.ID = sheet.getTag(row, 0);
            component.push(obj);
        }
        return component;
    },
    //根据消耗量字段设置组成物消耗量
    setConsumeAmt: function (component, field, value) {
        const compareStr = 'consumeAmt';
        if(field.includes(compareStr)){
            if(field === compareStr){
                component[field] = value;
            }
            else {
                component['consumeAmtProperty'][field] = value;
            }
        }
    },
    initConsumeAmtCols: function (consumeAmtProperties, colMapping) {
        let consumeAmtCols = [],
            consumeAmtPropertyCols = [];
        if(!consumeAmtProperties || consumeAmtProperties.length === 0){
            consumeAmtCols.push(colMapping.fieldToCol['consumeAmt']);
        }
        for(let consumeAmtProp of consumeAmtProperties){
            consumeAmtPropertyCols.push(colMapping.fieldToCol[consumeAmtProp.consumeAmt.dataCode]);
            consumeAmtCols.push(colMapping.fieldToCol[consumeAmtProp.consumeAmt.dataCode]);
        }
        this.consumeAmtCols = consumeAmtCols;
        this.consumeAmtPropertyCols = consumeAmtPropertyCols;
    },
    //消耗量赋初值
    initConsumeAmt: function (component) {
        if(!consumeAmtProperties || consumeAmtProperties.length === 0){
            component.consumeAmt = 0;
        }
        else {
            let consumeAmtProperty = {};
            for(let consumeAmtProp of consumeAmtProperties){
                consumeAmtProperty[consumeAmtProp.consumeAmt.dataCode] = 0;
            }
            component.consumeAmtProperty = consumeAmtProperty;
        }
    },
    consumeAmtChanged: function (component, consumeAmt, col) {
        if(!consumeAmtProperties || consumeAmtProperties.length === 0){
            if(consumeAmt !== component.consumeAmt){
                return true;
            }
        }
        else {
            if(consumeAmt !== component.consumeAmtProperty[this.colMapping.colToField[col]]){
                return true;
            }
        }
        return false;
    },
    consumeAmtIsEqual: function (consumeAmtA, consumeAmtB) {
        if(!consumeAmtProperties || consumeAmtProperties.length === 0){
            return consumeAmtA.consumeAmt === consumeAmtB.consumeAmt;
        }
        return _.isEqual(consumeAmtA.consumeAmtProperty, consumeAmtB.consumeAmtProperty);
    },
    gljComponentDelOpr: function () {
        let me = gljComponentOprObj, that = repositoryGljObj, updateArr = [], removeArr = [], isUpdate = false, updateBasePrc= [];
        me.workBook.commandManager().register('gljComponentDel', function () {
            let sels = me.workBook.getSheet(0).getSelections();
            if(sels.length > 0 && that.currentComponent.length > 0){
                let component = that.currentGlj.component;
                for(let i = 0; i < sels.length > 0; i++){
                    let selField = me.colMapping.colToField(sels[i].col);
                    if(sels[i].colCount === me.setting.header.length){//可删除
                        for(let j = 0; j < sels[i].rowCount; j++){
                            if(sels[i].row + j < that.currentComponent.length){
                                removeArr.push(that.currentComponent[sels[i].row + j].ID);

                            }
                        }
                    }
                    else if(selField === 'code'){
                            //编码不可为空
                            alert("编码不可为空！");

                    }
                    else if(selField.includes('consumeAmt')){//消耗量修改为0
                        if(sels[i].row === -1){//全修改
                           for(let j = 0; j < that.currentComponent.length; j++){
                               isUpdate = true;
                               //that.currentComponent[j].consumeAmt = 0;
                               me.setConsumeAmt(that.currentComponent[j], selField, 0);
                               for(let k = 0; k < component.length; k++){
                                   if(component[k].ID === that.currentComponent[j].ID){
                                       //component[k].consumeAmt = 0;
                                       me.setConsumeAmt(component[k], selField, 0);
                                       break;
                                   }
                               }
                           }
                        }
                        else{//部分修改
                            for(let j = 0; j < sels[i].rowCount; j++){
                                if(sels[i].row + j < that.currentComponent.length){
                                    isUpdate = true;
                                    me.setConsumeAmt(that.currentComponent[sels[i].row + j], selField, 0);
                                    //that.currentComponent[sels[i].row + j].consumeAmt = 0;
                                    for(let k = 0; k < component.length; k++){
                                        if(component[k].ID === that.currentComponent[sels[i].row + j].ID){
                                            //component[k].consumeAmt = 0;
                                            me.setConsumeAmt(component[k], selField, 0);
                                            break;
                                        }
                                    }

                                }
                            }
                        }
                    }
                }
                if(removeArr.length > 0 || isUpdate){
                    for(let i = 0; i < removeArr.length; i++){
                        for(let j = 0; j < that.currentComponent.length; j++){
                            if(that.currentComponent[j].ID === removeArr[i]){
                                that.currentComponent.splice(j--, 1);
                            }
                        }
                        for(let j = 0; j < component.length; j++){
                            if(component[j].ID === removeArr[i]){
                                component.splice(j--, 1);
                            }
                        }
                    }
                    updateArr.push(that.currentGlj);
                    me.updateComponent(updateArr);
                }
            }
        });
        me.workBook.commandManager().setShortcutKey(null, GC.Spread.Commands.Key.del, false, false, false, false);
        me.workBook.commandManager().setShortcutKey('gljComponentDel', GC.Spread.Commands.Key.del, false, false, false, false);
    },
    onContextmenuOpr: function () {
        let me = gljComponentOprObj, that = repositoryGljObj, co = componentOprObj;
        $.contextMenu({
            selector: '#gljComponentSheet',
            build: function($triggerElement, e){
                //控制允许右键菜单在哪个位置出现
                let sheet = me.workBook.getSheet(0);
                let offset = $("#gljComponentSheet").offset(),
                    x = e.pageX - offset.left,
                    y = e.pageY - offset.top;
                let target = sheet.hitTest(x, y);
                if(target.hitTestType === 3 && typeof target.row !== 'undefined' && typeof target.col !== 'undefined'){//在表格内
                    sheet.setActiveCell(target.row, target.col);
                    //getCurrentGlj
                    let thatRow = that.workBook.getSheet(0).getSelections()[0].row;
                    that.currentGlj = thatRow < that.currentCache.length ? that.currentCache[thatRow] : null;
                    that.currentComponent = that.currentGlj ?  that.getCurrentComponent(that.currentGlj.component) : [];
                    //控制按钮是否可用
                    let insertDis = false,
                        delDis = false;
                    if(!(that.currentGlj && allowComponent.includes(that.currentGlj.gljType)) || //机械组成物，应可选择无组成物的普通材料
                        ([4].includes(that.currentGlj.gljType) && that.isComponent(that.currentGlj.ID, that.gljList))){
                        insertDis = true;
                    }
                    if(!that.currentGlj || typeof that.currentComponent === 'undefined' ||
                        (typeof that.currentComponent !== 'undefined' && target.row >= that.currentComponent.length)){//右键定位在有组成物的行，删除键才显示可用
                        delDis = true;
                    }
                    return {
                        callback: function(){},
                        items: {
                            "batchInsert": {name: '批量插入', disabled: insertDis, icon: 'fa-sign-in', callback: function (key, opt) {
                                co.initRadio();
                                co.gljCurTypeId = null;
                                if(co.rootNode){
                                    co.treeObj.selectNode(co.rootNode);
                                    componentTypeTreeOprObj.onClick(null, 'componentTree', co.rootNode);
                                }
                                co.insertType = 'batch';
                                $('#component').modal('show');
                            }},
                            "insert": {name: "插入", disabled: insertDis, icon: "fa-sign-in", callback: function (key, opt) {
                                //默认radio所有工料机
                                co.initRadio();
                                co.gljCurTypeId = null;
                                //默认点击树根节点
                                if(co.rootNode){
                                    co.treeObj.selectNode(co.rootNode);
                                    componentTypeTreeOprObj.onClick(null, 'componentTree', co.rootNode);
                                }
                                co.insertType = 'single';
                                //弹出窗口
                                $('#componentBtn').click();
                            }},
                            "delete": {name: "删除", disabled: delDis, icon: "fa-remove", callback: function (key, opt) {
                                //删除
                                let deleteObj = that.currentComponent[target.row];
                                let gljComponent = that.currentGlj.component;
                                let updateArr = [], updateBasePrcArr = [];
                                //更新当前工料机的组成物列表
                                for(let i = 0, len = gljComponent.length; i < len; i++){
                                    if(gljComponent[i].ID === deleteObj.ID){
                                        gljComponent.splice(i, 1);
                                        break;
                                    }
                                }
                                updateArr.push(that.currentGlj);
                                me.updateComponent(updateArr);
                            }},
                            "batchClear": {name: '批量删除消耗量为0的组成物', disabled: insertDis, icon: 'fa-remove', callback: function (key, opt) {
                                co.insertType = 'batchClear';
                                co.batchUpdateComponent();
                            }}
                        }
                    };
                }
                else{
                    return false;
                }
            }
        });
    },
    onCellEditStart: function(sender, args) {
        let me = gljComponentOprObj, that = repositoryGljObj;
        console.log(me.colMapping);
        if(me.isPending){
            args.cancel = true;
        }
        let rObj = me.getRowData(args.sheet, args.row, me.setting);
        me.currentEditingComponent = rObj;
        let thatRow = that.workBook.getSheet(0).getSelections()[0].row;
        if(thatRow < that.currentCache.length){
            that.currentGlj = that.currentCache[thatRow];
            //编码和消耗量可编辑
            if(!(me.colMapping.colToField[args.col] === 'code' || me.colMapping.colToField[args.col].includes('consumeAmt')) || !allowComponent.includes(that.currentGlj.gljType) ||
                (that.currentGlj.gljType === 4 && that.isComponent(that.currentGlj.ID, that.gljList)) ||
                (args.col === 4 && (!that.currentComponent|| args.row >= that.currentComponent.length))){
                args.cancel = true;
            }
        }
        else {
            args.cancel = true;
        }
    },
    onCellEditEnd: function (sender, args) {
        let me = gljComponentOprObj, that = repositoryGljObj, updateBasePrc = [];
        let gljList = that.gljList, updateArr = [];
        let dataCode = me.colMapping.colToField[args.col];
        //if(args.editingText !== me.currentEditingComponent.code){
        //编辑编码
        if(dataCode === 'code' && args.editingText && args.editingText.trim().length > 0 && args.editingText !== me.currentEditingComponent.code){
            let component = that.currentGlj.component, hasCode = false;
            for(let i = 0; i < gljList.length; i++){
                if(gljList[i].code === args.editingText){//有效的组成物
                    hasCode = true;
                    if((materialAllowComponent.includes(that.currentGlj.gljType) && gljList[i].gljType === 201)
                        || (machineAllowComponent.includes(that.currentGlj.gljType) && machineComponent.includes(gljList[i].gljType))
                        || (that.currentGlj.gljType === 302 && gljList[i].gljType === 201)){
                        //是否与原有组成物不同
                        let isExist = false;
                        for(let j = 0; j < component.length; j++){
                            if(component[j].ID === gljList[i].ID){
                                isExist = true;
                                break;
                            }
                        }
                        if(!isExist){
                            let rObj = {};
                            rObj.ID = gljList[i].ID;
                            //rObj.basePrice = gljList[i].basePrice;
                            if(typeof that.currentComponent[args.row] !== 'undefined'){
                                if(!consumeAmtProperties || consumeAmtProperties.length === 0){
                                    rObj.consumeAmt = that.currentComponent[args.row].consumeAmt;
                                }
                                else{
                                    rObj.consumeAmtProperty = that.currentComponent[args.row].consumeAmtProperty;
                                }
                                //rObj.consumeAmt = that.currentComponent[args.row].consumeAmt;
                                let index;
                                for(let j = 0; j < component.length; j++){
                                    if(component[j].ID === that.currentComponent[args.row].ID){
                                        index = j;
                                        break;
                                    }
                                }
                                component.splice(index, 1);
                                component.splice(index, 0, rObj);
                                updateArr.push(that.currentGlj);
                            }
                            else{
                                me.initConsumeAmt(rObj);
                                //rObj.consumeAmt = 0;
                                component.push(rObj);
                                updateArr.push(that.currentGlj);
                            }
                            break;
                        }
                        else{
                            //已存在
                            alert("已存在！");
                            args.sheet.setValue(args.row, args.col, me.currentEditingComponent[me.setting.header[args.col].dataCode] ?
                                me.currentEditingComponent[me.setting.header[args.col].dataCode]: '');
                        }

                    }
                    else{
                        if(materialAllowComponent.includes(that.currentGlj.gljType)){
                            alert("无效的组成物！");
                        }
                        else if(machineAllowComponent.includes(that.currentGlj.gljType)){
                            alert("无效的组成物！")
                        }
                        args.sheet.setValue(args.row, args.col, me.currentEditingComponent[me.setting.header[args.col].dataCode] ?
                            me.currentEditingComponent[me.setting.header[args.col].dataCode]: '');
                        //无效
                    }
                }
            }
            if(!hasCode){
                alert("不存在此人材机，请先添加！");
                args.sheet.setValue(args.row, args.col, me.currentEditingComponent[me.setting.header[args.col].dataCode] ?
                    me.currentEditingComponent[me.setting.header[args.col].dataCode] : '');
                //不存在
            }
        }
        //编辑消耗量
        else if(dataCode.includes('consumeAmt') && me.currentEditingComponent.code && args.editingText && args.editingText.trim().length > 0){//消耗量
            let consumeAmt = parseFloat(args.editingText);
            if(!isNaN(consumeAmt) && me.consumeAmtChanged(me.currentEditingComponent, consumeAmt, args.col)){
                let roundCons = scMathUtil.roundTo(parseFloat(consumeAmt), -3);
                let component = that.currentGlj.component;
                for(let i = 0; i < component.length; i++){
                    if(component[i].ID === that.currentComponent[args.row].ID){
                        me.setConsumeAmt(component[i], dataCode, roundCons);
                        //component[i].consumeAmt = roundCons;
                    }
                }
                //that.currentComponent[args.row].consumeAmt = roundCons;
                me.setConsumeAmt(that.currentComponent[args.row], dataCode, roundCons);
                updateArr.push(that.currentGlj);
            }
            else{
                //只能输入数值
                sheetsOprObj.showData(me, me.workBook.getSheet(0), me.setting, that.currentComponent);

            }
        }
        else{
            sheetsOprObj.showData(me, me.workBook.getSheet(0), me.setting, that.currentComponent);
        }
        if(updateArr.length > 0){
            me.updateComponent(updateArr);
            if(updateBasePrc.length > 0 && that.rationLibs.length > 0){
                me.isPending = true;
                that.updateRationBasePrcRq(updateBasePrc, me.workBook, function () {
                    me.isPending = false;
                });
            }
        }
        let focusInter = setInterval(function () {
            if(!$('#loadingPage').is(':visible')){
                me.workBook.focus(true);
                clearInterval(focusInter);
            }
        }, 100);
    },
    onClipboardPasting: function (sender, info) {
        let me = gljComponentOprObj;
        if(me.isPending){
            info.cancel = true
        }
        let that = repositoryGljObj;
        let maxCol = info.cellRange.col + info.cellRange.colCount - 1;
        //粘贴的字段只能含有编码和消耗量
        for(let i = 0; i < info.cellRange.colCount; i++){
            let col = info.cellRange.col + i;
            let dataCode = me.colMapping.colToField[col];
            if(dataCode !== 'code' && !dataCode.includes('consumeAmt')){
                info.cancel = true;
                return;
            }
        }
        //复制的列数超过正确的列数，不可复制
        if(maxCol > me.setting.header.length - 1){
            info.cancel = true;
        }
    },
    onClipboardPasted: function (sender, info) {
        let me = gljComponentOprObj, that = repositoryGljObj, updateArr = [],
            component = that.currentGlj.component, isChange = false, updateBasePrc = [];
        let items = sheetCommonObj.analyzePasteData(me.setting, info);
        let gljCache = that.gljList;
        if(info.cellRange.col === 0){
            for(let i = 0; i < items.length; i++){
                let existCode = false;
                for(let j = 0; j < gljCache.length; j++){
                    if(items[i].code === gljCache[j].code){
                        existCode = true;
                        if((materialAllowComponent.includes(that.currentGlj.gljType) && gljCache[j].gljType === 201)
                            || (machineAllowComponent.includes(that.currentGlj.gljType) && machineComponent.includes(gljCache[j].gljType))
                            || (that.currentGlj.gljType === 302 && gljCache[j].gljType === 201)){
                            //是否与原有组成物不同
                            let isExist = false;
                            for(let k = 0; k < component.length; k++){
                                if(component[k].ID === gljCache[j].ID){
                                    isExist = true;
                                    me.workBook.getSheet(0).setValue(info.cellRange.row + i, info.cellRange.col,
                                        typeof that.currentComponent[info.cellRange.row + i] !== 'undefined'? that.currentComponent[info.cellRange.row + i].code : '');
                                    break;
                                }
                            }
                            if(!isExist){
                                isChange = true;
                                let obj = {};
                                obj.ID = gljCache[j].ID;
                                if(typeof that.currentComponent[info.cellRange.row + i] !== 'undefined'){//更新
                                    //obj.consumeAmt = that.currentComponent[info.cellRange.row + i].consumeAmt;
                                    if(!consumeAmtProperties || consumeAmtProperties.length === 0){
                                        obj.consumeAmt = that.currentComponent[info.cellRange.row + i].consumeAmt;
                                    }
                                    else{
                                        obj.consumeAmtProperty = that.currentComponent[info.cellRange.row + i].consumeAmtProperty;
                                    }
                                    let index;
                                    for(let k = 0; k < component.length; k++){
                                        if(that.currentComponent[info.cellRange.row + i].ID === component[k].ID){
                                            index = k;
                                            break;
                                        }
                                    }
                                    component.splice(index, 1);
                                    component.splice(index, 0, obj);
                                }
                                else{//新增
                                    me.initConsumeAmt(obj);
                                    component.push(obj);
                                }
                                break;
                            }

                        }
                        else{
                            me.workBook.getSheet(0).setValue(info.cellRange.row + i, info.cellRange.col,
                            typeof that.currentComponent[info.cellRange.row + i] !== 'undefined'? that.currentComponent[info.cellRange.row + i].code : '');

                        }

                    }
                }
                if(!existCode){
                    me.workBook.getSheet(0).setValue(info.cellRange.row + i, info.cellRange.col,
                        typeof that.currentComponent[info.cellRange.row + i] !== 'undefined'? that.currentComponent[info.cellRange.row + i].code : '');
                }
            }
            if(isChange){
                updateArr.push(that.currentGlj);
            }
        }
        //消耗量
        else if(me.colMapping.colToField[info.cellRange.col].includes('consumeAmt')){
            let items = sheetCommonObj.analyzePasteData(me.setting, info);
            let row = info.cellRange.row;
            for(let i = 0; i < items.length; i++){
                if(row + i < that.currentComponent.length){
                    let currentObj = that.currentComponent[row + i];
                    if(!me.consumeAmtIsEqual(items[i], currentObj)){
                        isChange = true;
                        if(!consumeAmtProperties || consumeAmtProperties.length === 0){
                            let roundCons = scMathUtil.roundTo(parseFloat(items[i].consumeAmt), -3);
                            currentObj.consumeAmt = roundCons;
                            for(let j = 0; j < component.length; j++){
                                if(component[j].ID === currentObj.ID){
                                    component[j].consumeAmt = currentObj.consumeAmt;
                                    break;
                                }
                            }
                        }
                        else{
                            for(let attr in items[i]){
                                //是消耗量字段
                                if(attr.includes('consumeAmt') && items[i][attr] && !isNaN(parseFloat(items[i][attr]))){
                                    let roundCons = scMathUtil.roundTo(parseFloat(items[i][attr]), -3);
                                    currentObj.consumeAmtProperty[attr] =roundCons;
                                }
                            }
                            for(let j = 0; j < component.length; j++){
                                if(component[j].ID === currentObj.ID){
                                    component[j].consumeAmtProperty = currentObj.consumeAmtProperty;
                                    break;
                                }
                            }
                        }
                    }
                    else{
                        sheetsOprObj.showData(me, me.workBook.getSheet(0), me.setting, that.currentComponent);
                        //me.workBook.getSheet(0).setValue(row + i, info.cellRange.col, currentObj.consumeAmt);
                    }
                }
                else{
                    me.workBook.getSheet(0).setValue(row + i, info.cellRange.col, '');
                }
            }
            if(isChange){
                updateArr.push(that.currentGlj);
            }
        }
        if(updateArr.length > 0){
            me.updateComponent(updateArr);
            if(updateBasePrc.length > 0){
                me.isPending = true;
                that.updateRationBasePrcRq(updateBasePrc, me.workBook, function () {
                    me.isPending = false;
                });
            }
        }
        else {
            sheetCommonObj.cleanData(me.workBook.getSheet(0), me.setting, -1);
            sheetsOprObj.showData(me, me.workBook.getSheet(0), me.setting, that.currentComponent);
        }
        let focusInter = setInterval(function () {
            if(!$('#loadingPage').is(':visible')){
                me.workBook.focus(true);
                clearInterval(focusInter);
            }
        }, 100);
    },
    updateComponent: function (updateArr) {
        let me = gljComponentOprObj, that = repositoryGljObj;
        repositoryGljObj.saveInString(updateArr);
        $.ajax({
            type: 'post',
            url: 'api/updateComponent',
            data: {libId: pageOprObj.gljLibId, updateArr: updateArr, oprtor: userAccount},
            dataType: 'json',
            success: function (result) {
                if(result.data.length > 0){
                    if(result.data[0]){
                        that.currentComponent =  that.getCurrentComponent(result.data[0].component);
                        sheetCommonObj.cleanData(me.workBook.getSheet(0), me.setting, -1);
                        sheetsOprObj.showData(me, me.workBook.getSheet(0), me.setting, that.currentComponent);
                    }
                }
            }
        })
    },
    reCalGljBasePrc: function (components) {
        let me = gljComponentOprObj, re = repositoryGljObj;
        //只有一个单价的情况，只有一个单价则只有一个消耗量
        if(!priceProperties || priceProperties.length === 0){
            let gljBasePrc = 0;
            for(let i = 0; i < components.length; i++){
                let roundBasePrc = scMathUtil.roundTo(parseFloat(components[i].basePrice), -2);
                let roundConsumeAmt = scMathUtil.roundTo(parseFloat(components[i].consumeAmt), -3);
                gljBasePrc = scMathUtil.roundTo(scMathUtil.roundTo(roundBasePrc * roundConsumeAmt, me.processDecimal) + gljBasePrc, me.processDecimal);
            }
            return scMathUtil.roundTo(gljBasePrc, -2);
        }
        //多单价的情况
        else {
            let gljPriceProperty = re.getPriceProperty(priceProperties);
            for(let priceProp in gljPriceProperty){
                let consumeAmtField = re.getConsumeAmtField(consumeAmtProperties, priceProp);
                for(let component of components){
                    let roundBasePrc = scMathUtil.roundTo(parseFloat(component['priceProperty'][priceProp]), -2);
                    let roundConsumeAmt = scMathUtil.roundTo(parseFloat(component['consumeAmtProperty'][consumeAmtField]), -3);
                    gljPriceProperty[priceProp] = scMathUtil.roundTo(scMathUtil.roundTo(roundBasePrc * roundConsumeAmt, me.processDecimal) + gljPriceProperty[priceProp], me.processDecimal);
                }
                scMathUtil.roundTo(gljPriceProperty[priceProp], -2);
            }
            return gljPriceProperty;
        }
    }
};