ConstructionCost/web/building_saas/complementary_glj_lib/js/glj.js

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

$(document).ready(function () {
    $('#component').on('shown.bs.modal', function () {
        if (componentOprObj.workBook) {
            componentOprObj.workBook.refresh();
        }
    });
    let moduleName = 'compleGLj';
    SlideResize.loadHorizonWidth(moduleName, [$('#rightResize'), $('#leftResize')], [$('#leftContent'), $('#midContent'), $('#rightContent')], function () {
        refreshALlWorkBook();
    });
    //章节树与人材机表
    let leftElesObj = {};
    leftElesObj.module = moduleName;
    leftElesObj.resize = $('#leftResize');
    leftElesObj.parent = $('#dataRow');
    leftElesObj.left = $('#leftContent');
    leftElesObj.right = $('#midContent');
    SlideResize.horizontalSlide(leftElesObj, { min: 200, max: `$('#dataRow').width() - $('#rightContent').width() - 200` }, function () {
        refreshALlWorkBook();
    });
    //人材机表与人材机组成物表
    let rightElesObj = {};
    rightElesObj.module = moduleName;
    rightElesObj.resize = $('#rightResize');
    rightElesObj.parent = $('#dataRow');
    rightElesObj.left = $('#midContent');
    rightElesObj.right = $('#rightContent');
    SlideResize.horizontalSlide(rightElesObj, { min: 200, max: `$('#dataRow').width() - $('#leftContent').width() - 200` }, function () {
        let resizeRate = 500 / $('#midContent').width(),
            sheetRate = 100 - resizeRate;
        $('#leftResize').css('width', `${resizeRate}%`);
        $('#GLJListSheet').css('width', `${sheetRate}%`);
        refreshALlWorkBook();
    });
});
function refreshALlWorkBook() {
    if (gljClassTreeObj.workBook) {
        gljClassTreeObj.workBook.refresh();
    }
    if (repositoryGljObj.workBook) {
        repositoryGljObj.workBook.refresh();
    }
    if (gljComponentOprObj.workBook) {
        gljComponentOprObj.workBook.refresh();
    }
}
let pageOprObj = {
    gljLibName: null,
    stdGljLibId: null,
    userId: null,
    compilationId: null,
    initPage: function (container, containerComponent, containerC) {
        let me = pageOprObj;
        me.stdGljLibId = stdGljLibId;
        me.userId = userId;
        me.compilationId = compilationId;
        //生成人材机表格列头
        repositoryGljObj.setting.header = repositoryGljObj.initHeaders(priceProperties);
        //生成列映射
        sheetCommonObj.initColMapping(repositoryGljObj, repositoryGljObj.setting.header);
        //生成单价列下标数组
        repositoryGljObj.initPriceCols(priceProperties, repositoryGljObj.colMapping);
        repositoryGljObj.buildSheet(container);
        gljComponentOprObj.buildSheet(containerComponent);
        componentOprObj.buildSheet(containerC);
        //获得定额库中引用此工料机库中的，所有被定额所套的工料机的ID
        //repositoryGljObj.getRationGljIds(gljLibId);
        repositoryGljObj.getGljDistType(function () {
            repositoryGljObj.currentRepositoryId = me.stdGljLibId;
            gljClassTreeObj.getGljClassTree(stdGljLibId, function () {
                repositoryGljObj.getGljItems(me.stdGljLibId, function () {
                    gljClassTreeObj.initSelection(gljClassTreeObj.tree.selected);
                });
            });
        });
    }
};

let repositoryGljObj = {
    colMapping: null,
    treeObj: null,
    workBook: null,
    // 是否获取了完整的人材机数据
    // 第一次打开页面只加载补充人材机和标准人材机的编码
    // 第一次打开选择组成物的窗口才加载标准人材机剩余数据
    pullCompleteData: false,
    gljCurTypeId: -1,
    currentRepositoryId: -1,
    currentCache: null,
    parentNodeIds: {},
    gljList: [],
    stdGljList: [],
    complementaryGljList: [],
    machineModel: { textArr: ['特', '大', '中', '小'], comboItems: [{ text: '特', value: 1 }, { text: '大', value: 2 }, { text: '中', value: 3 }, { text: '小', value: 4 }] },
    machineModelIdx: { '1': '特', '2': '大', '3': '中', '4': '小' },
    taxRateTypes: [201, 205, 206, 302, 4, 5],
    distTypeTree: null,//add
    setting: {
        header: [
            { headerName: "机型", headerWidth: 60, dataCode: "model", dataType: "Number", hAlign: "center", vAlign: "center" },
            { headerName: "是否新增", headerWidth: 60, dataCode: "isComplementary", hAlign: "center", vAlign: "center" }
        ],
        view: {
            comboBox: [
                { row: -1, col: 3, rowCount: -1, colCount: 1 }
            ],
            lockedCells: [
            ]
        }
    },
    //根据费用定额的单价属性获取人材机的单价属性
    getPriceProperty: function (priceProperties) {
        let priceProperty = {};
        for (let priceProp of priceProperties) {
            priceProperty[priceProp.price.dataCode] = 0;
        }
        return priceProperty;
    },
    //根据单价字段获取消耗量字段
    getConsumeAmtField: function (consumeAmtProperties, priceField) {
        if (!consumeAmtProperties || consumeAmtProperties.length === 0) {
            return 'consumeAmt';
        }
        for (let consumeAmtProp of consumeAmtProperties) {
            if (consumeAmtProp.consumeAmt.refPrice === priceField) {
                return consumeAmtProp.consumeAmt.dataCode;
            }
        }
        return 'consumeAmt';
    },
    //初始单价相关的列（单价列、单价属性列）
    initPriceCols: function (priceProperties, colMapping) {
        let priceCols = [],
            pricePropertyCols = [];
        if (!priceProperties || priceProperties.length === 0) {
            priceCols.push(colMapping.fieldToCol['basePrice']);
        }
        for (let priceProp of priceProperties) {
            pricePropertyCols.push(colMapping.fieldToCol[priceProp.price.dataCode]);
            priceCols.push(colMapping.fieldToCol[priceProp.price.dataCode]);
        }
        this.priceCols = priceCols;
        this.pricePropertyCols = pricePropertyCols;
    },
    getPriceFields: function () {
        let rst = [];
        for (let priceCol of this.priceCols) {
            rst.push(this.colMapping.colToField[priceCol]);
        }
        return rst;
    },
    //获取更新定额价的人材机价格（人材机只有一个单价取basePrice, 人材机有多个单价，取第一个单价）
    getRationGljPrice: function (glj) {
        if (glj.priceProperty) {
            let keys = Object.keys(glj.priceProperty);
            if (keys.length > 0) {
                return glj.priceProperty[keys[0]];
            }
        }
        return glj.basePrice;
    },
    //生成列头（多单价）
    initHeaders: function (priceProperties) {
        let headers = [
            { headerName: "编码", headerWidth: 80, dataCode: "code", dataType: "String", formatter: "@", hAlign: "left", vAlign: "center" },
            { headerName: "名称", headerWidth: 160, dataCode: "name", dataType: "String", hAlign: "left", vAlign: "center" },
            { headerName: "规格型号", headerWidth: 120, dataCode: "specs", dataType: "String", formatter: "@", hAlign: "left", vAlign: "center" },
            { headerName: "单位", headerWidth: 45, dataCode: "unit", dataType: "String", hAlign: "center", vAlign: "center" },
            { headerName: "类型", headerWidth: 90, dataCode: "gljType", dataType: "String", hAlign: "center", vAlign: "center" },
        ];
        //生成单价列
        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);
            }
        }
        headers = headers.concat(this.setting.header);
        return headers;
    },
    //工料机单价赋初始值（没有单价属性，则单价字段为basePrice，否则单价字段为单价属性对象中的属性）
    initPrice: function (glj) {
        if (!priceProperties || priceProperties.length === 0) {
            glj.basePrice = glj.basePrice && !isNaN(parseFloat(glj.basePrice)) ? scMathUtil.roundTo(parseFloat(glj.basePrice), -2) : 0;
        }
        else {
            if (!glj.priceProperty) {
                glj.priceProperty = {};
            }
            for (let priceProp of priceProperties) {
                let gljPrice = glj['priceProperty'][priceProp.price.dataCode];
                gljPrice = gljPrice && !isNaN(parseFloat(gljPrice)) ? scMathUtil.roundTo(parseFloat(gljPrice), -2) : 0;
            }
        }
    },
    //人材机单价是否变化
    isGljPriceChange: function (glj, newPrice) {
        //多单价，与人材机单价属性比较
        if (typeof newPrice === 'object') {
            return !_.isEqual(glj.priceProperty, newPrice);
        }
        return !_.isEqual(glj.basePrice, newPrice);
    },
    //粘贴数据含有单价
    pasteIncludesPrice: function (pasteObj) {
        let me = repositoryGljObj;
        for (let priceCol of me.priceCols) {
            let priceField = me.colMapping.colToField[priceCol];
            if (typeof pasteObj[priceField] !== 'undefined') {
                return true;
            }
        }
        return false;
    },
    //获取人材机价格
    getPrice: function (glj, col) {
        let me = repositoryGljObj;
        if (!priceProperties || priceProperties.length === 0) {
            return glj.basePrice;
        }
        return glj.priceProperty[me.colMapping.colToField[col]];
    },
    //工料机价格是否相同
    priceIsEqual: function (gljA, gljB) {
        if (!priceProperties || priceProperties.length === 0) {
            return gljA.basePrice == gljB.basePrice;
        }
        return _.isEqual(gljA.priceProperty, gljB.priceProperty);
    },
    setPriceByCol: function (glj, newPrice, col) {
        if (!priceProperties || priceProperties.length === 0) {
            glj.basePrice = newPrice;
        }
        else {
            glj.priceProperty[this.colMapping.colToField[col]] = newPrice;
        }
    },
    setPrice: function (glj, price) {
        if (!priceProperties || priceProperties.length === 0) {
            glj.basePrice = price;
        } else {
            glj.priceProperty = price;
        }
    },
    setUnitCombo: function (sheet, headers) {
        let me = this;
        sheet.suspendPaint();
        sheet.suspendEvent();
        let combo = sheetCommonObj.getDynamicCombo();
        combo.items(rationAndGljUnits).itemHeight(10).editable(true);
        let unitCol = me.colMapping.fieldToCol.unit;
        if (unitCol) {
            sheet.getRange(-1, unitCol, -1, 1).cellType(combo);
        }
        sheet.resumePaint();
        sheet.resumeEvent();
    },
    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;
    },
    getGljDistType: function (callback) {
        let me = this;
        CommonAjax.post('complementartGlj/api/getGljDistType', {}, function (rstData) {
            if (callback) {
                me.distTypeTree = me.getComboData(rstData);
                console.log(me.distTypeTree);
                callback();
            }
        });
    },
    getGljTree: function (gljLibId, callback) {
        let me = this;
        CommonAjax.post('complementartGlj/api/getGljTree', { gljLibId: gljLibId }, function (rstData) {
            zTreeHelper.createTree(rstData, gljSetting, "repositoryTree", me);
            zTreeHelper.createTree(rstData, componentSetting, "componentTree", componentOprObj);
            if (rstData && rstData.length > 0) {
                me.gljCurTypeId = rstData[0].ID;
            } else {
                //重新创建库？
                // gljTypeTreeOprObj.addRootNode();
            }
            if (callback) {
                callback();
            }
        });
    },
    getGljItems: function (stdGljLibId, callback) {
        let me = this,
            // 一开始获取的标准人材机只包含code,提升打开页面速度
            projection = {
                _id: 0,
                ID: 1,
                code: 1,
                unit: 1,
                name: 1,
                priceProperty: 1,
                basePrice: 1
            };
        $.bootstrapLoading.start();
        CommonAjax.post('/complementartGlj/api/getGljItems', { stdGljLibId, projection }, function (rstData) {
            me.stdGljList = rstData.stdGljs;
            // TODO
            //兼容多单价情况
            for (let sGlj of me.stdGljList) {
                if (sGlj.priceProperty && typeof sGlj.priceProperty.price1 !== 'undefined') {
                    sGlj.basePrice = sGlj.priceProperty.price1;
                }
            }
            me.sortGlj(me.stdGljList);
            me.setProp('isStd', true, me.stdGljList);
            me.complementaryGljList = rstData.complementaryGljs;
            me.sortGlj(me.complementaryGljList);
            if (callback) {
                callback();
            }
            $.bootstrapLoading.end();
        }, function () {
            $.bootstrapLoading.end();
        });
    },
    // 获取标准人材机数据
    getStdItems: function (stdGljLibId, callback) {
        $.bootstrapLoading.start();
        let me = this;
        let projection = {
            _id: 0,
            ID: 1,
            specs: 1,
            gljType: 1,
            shortName: 1,
            gljClass: 1
        };
        CommonAjax.post('/complementartGlj/api/getStdItems', { stdGljLibId, projection }, function (data) {
            me.pullCompleteData = true;
            // 更新标准人材机数据
            let IDMapping = {};
            for (let glj of data) {
                IDMapping[glj.ID] = glj;
            }
            for (let glj of me.stdGljList) {
                Object.assign(glj, IDMapping[glj.ID]);
            }
            callback();
            $.bootstrapLoading.end();
        }, function () {
            $.bootstrapLoading.end();
        });
    },
    showGljItems: function (data, type) {
        let me = repositoryGljObj;
        let sheet = me.workBook.getActiveSheet();
        if (me.workBook) {
            let cacheSection = [];
            let pArr = me.parentNodeIds["_pNodeId_" + type];
            for (let i = 0; i < data.length; i++) {
                if (pArr && pArr.indexOf(data[i].gljClass) >= 0) {
                    cacheSection.push(data[i]);
                } else if (type == data[i].gljClass) {
                    cacheSection.push(data[i]);
                }
            }
            sheetOpr.cleanData(sheet, me.setting, -1);
            //清除是否新增复选框
            gljClassTreeObj.renderFunc(sheet, function () {
                let isComplementaryCol = 0;
                for (let colData of me.setting.header) {
                    if (colData.dataCode === 'isComplementary') {
                        isComplementaryCol = me.setting.header.indexOf(colData);
                    }
                }
                let baseCell = new GC.Spread.Sheets.CellTypes.Base();
                for (let row = 0; row < sheet.getRowCount(); row++) {
                    sheet.setCellType(row, isComplementaryCol, baseCell);
                }
            });
            sheetOpr.showData(me, me.workBook.getSheet(0), me.setting, cacheSection, me.distTypeTree, me.materialTypeIdx, me.machineModelIdx);;
            let gljTypeCol = me.colMapping.fieldToCol['gljType'],
                modelCol = me.colMapping.fieldToCol['model'];
            sheetCommonObj.setDynamicCombo(sheet, 0, gljTypeCol, sheet.getRowCount(), me.distTypeTree.comboDatas, false, 'text');
            sheetCommonObj.setDynamicCombo(sheet, 0, modelCol, sheet.getRowCount(), me.machineModel.comboItems, false, 'text');
            cacheSection = null;
        }
    },
    bindEnterKey: function () {
        let me = this;
        let sheet = me.workBook.getActiveSheet();
        me.workBook.commandManager().register("myEnter", function () {
            let orgRow = sheet.getActiveRowIndex();
            let orgCol = sheet.getActiveColumnIndex();
            if (sheet.isEditing()) {
                sheet.endEdit();
            }
            let codeCol = me.colMapping.fieldToCol['code'];
            let code = sheet.getValue(orgRow, codeCol);
            let newRow, newCol;
            if (!me.currentCache[orgRow] && code !== undefined && code !== null && orgCol !== me.setting.header.length - 1) {
                newRow = orgRow;
                newCol = orgCol + 1;
                sheet.setActiveCell(newRow, newCol);
            }
            else {
                newRow = orgRow + 1;
                newCol = me.currentCache[orgRow + 1] ? orgCol : 0;
                sheet.setActiveCell(newRow, newCol);
            }
            //触发事件
            //me.onLeaveCell({type: 'LeaveCell'}, {sheet: sheet, sheetName: sheet.name(), cancel: false, row: orgRow, col: orgCol});
            me.onEnterCell({ type: 'EnterCell' }, { sheet: sheet, sheetName: sheet.name(), cancel: false, row: newRow, col: newCol });
            let newSels = [{ row: newRow, rowCount: 1, col: newCol, colCount: 1 }];
            let oldSels = [{ row: orgRow, rowCount: 1, col: orgRow, colCount: 1 }];
            me.onSelectionChanged({ type: 'SelectionChanged' }, { sheet: sheet, sheetName: sheet.name(), newSelections: newSels, oldSelections: oldSels });
        });
        me.workBook.commandManager().setShortcutKey(null, GC.Spread.Commands.Key.enter, false, false, false, false);
        me.workBook.commandManager().setShortcutKey("myEnter", GC.Spread.Commands.Key.enter, false, false, false, false);
    },
    buildSheet: function (container) {
        let me = repositoryGljObj;
        me.workBook = sheetOpr.buildSheet(container, me.setting, 30);
        sheetCommonObj.spreadDefaultStyle(me.workBook);
        me.repositoryGljDelOpr();
        me.onContextmenuOpr();
        me.bindEnterKey();
        me.setUnitCombo(me.workBook.getActiveSheet(), me.setting.header);
        if (priceProperties && priceProperties.length > 0) {
            me.workBook.getSheet(0).frozenColumnCount(5);
        }
        me.workBook.getActiveSheet().bind(GC.Spread.Sheets.Events.ClipboardPasting, me.onClipboardPasting);
        me.workBook.getActiveSheet().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);
        me.workBook.getSheet(0).bind(GC.Spread.Sheets.Events.EnterCell, me.onEnterCell);
        me.workBook.getSheet(0).bind(GC.Spread.Sheets.Events.SelectionChanged, me.onSelectionChanged);
        me.workBook.bind(GC.Spread.Sheets.Events.ButtonClicked, me.onButtonClicked);//复选框点击事件
    },

    isDef: function (v) {
        return v !== undefined && v !== null;
    },

    //成为了组成物,暂时只需要判断主材的
    isComponent: function (gljId, gljList) {
        for (let i = 0, len = gljList.length; i < len; i++) {
            let gljComponent = gljList[i].component;
            if (gljList[i].gljType === 4 && this.isDef(gljComponent) && gljComponent.length > 0) {
                for (let j = 0, jLen = gljComponent.length; j < jLen; j++) {
                    if (gljComponent[j].ID === gljId) {
                        return true;
                    }
                }
            }
        }
        return false;
    },

    getCurrentComponent: function (gljComponent) {
        let me = repositoryGljObj,
            rst = [];
        for (let thisGlj of gljComponent) {
            let toFindGljList = thisGlj.isStd
                ? me.stdGljList
                : me.complementaryGljList;
            let matchGlj = toFindGljList.find(glj => glj.ID === thisGlj.ID);
            if (matchGlj) {
                rst.push({
                    isStd: thisGlj.isStd ? true : false,
                    ID: matchGlj.ID,
                    code: matchGlj.code,
                    name: matchGlj.name,
                    unit: matchGlj.unit,
                    basePrice: matchGlj.basePrice,
                    priceProperty: matchGlj.priceProperty,
                    consumeAmt: thisGlj.consumeAmt,
                    consumeAmtProperty: thisGlj.consumeAmtProperty
                });
            }
        }
        rst.sort(function (a, b) {
            let r = 0;
            if (a.code > b.code) r = 1;
            else if (a.code < b.code) r = -1;
            return r;
        });
        return rst;
    },
    //获得引用了组成物id为componentId的工料机，和重新变化组成物数组、重新计算单价
    getUpdateGljs: function (rObj, isDelete) {
        let me = repositoryGljObj, that = gljComponentOprObj,
            rst = { updateArr: [], updateBasePrcArr: [] };
        //改变单价，以便reCalGljBasePrc方法可行
        if (!isDelete) {
            for (let i = 0; i < me.complementaryGljList.length; i++) {
                if (me.complementaryGljList[i].ID === rObj.ID) {
                    me.complementaryGljList[i].basePrice = rObj.basePrice;
                    me.complementaryGljList[i].priceProperty = rObj.priceProperty || {};
                    break;
                }
            }
        }
        for (let i = 0; i < me.complementaryGljList.length; i++) {
            let thisComponent = me.complementaryGljList[i].component, isChange = false;
            for (let j = 0; j < thisComponent.length; j++) {
                if (thisComponent[j].ID === rObj.ID) {
                    //删除
                    isChange = true;
                    if (isDelete) {
                        thisComponent.splice(j--, 1);
                    }
                    else {
                        break;
                    }
                }
            }
            if (isChange) {//引用了此组成物
                let gljBasePrc = that.reCalGljBasePrc(me.getCurrentComponent(thisComponent));
                if (me.isGljPriceChange(me.complementaryGljList[i], gljBasePrc)) {
                    const orgPriceForRation = me.getRationGljPrice(me.complementaryGljList[i]);
                    me.setPrice(me.complementaryGljList[i], gljBasePrc);
                    const newPriceForRation = me.getRationGljPrice(me.complementaryGljList[i]);
                    // 多单价的情况下只有price1发生变化，才重算定额价格
                    if (orgPriceForRation !== newPriceForRation) {
                        rst.updateBasePrcArr.push({ gljId: me.complementaryGljList[i].ID, gljType: me.complementaryGljList[i].gljType, basePrice: newPriceForRation });
                    }
                }
                rst.updateArr.push(me.complementaryGljList[i]);
            }
            /* if(isChange){//引用了此组成物
                let gljBasePrc = that.reCalGljBasePrc(me.getCurrentComponent(thisComponent));
                if(me.complementaryGljList[i].basePrice !== gljBasePrc){
                    me.complementaryGljList[i].basePrice = gljBasePrc;
                    rst.updateBasePrcArr.push({gljId: me.complementaryGljList[i].ID, gljType: me.complementaryGljList[i].gljType, basePrice: me.complementaryGljList[i].basePrice});
                }
                rst.updateArr.push(me.complementaryGljList[i]);
            } */
        }
        return rst;
    },
    reshowGljBasePrc: function (glj) {
        /* let me = repositoryGljObj;
        let cacheSection = me.currentCache;
        for(let i = 0; i < cacheSection.length; i++){
            if(glj.ID === cacheSection[i].ID){
                cacheSection[i].basePrice = glj.basePrice;
                me.workBook.getSheet(0).setValue(i, 4, glj.basePrice);
                break;
            }
        } */
        let me = repositoryGljObj;
        let cacheSection = me.currentCache;
        let sheet = me.workBook.getActiveSheet();
        let row = _.findIndex(cacheSection, { ID: glj.ID });
        sheet.suspendEvent();
        sheet.suspendPaint();
        for (let priceCol of me.priceCols) {
            const dataCode = me.colMapping.colToField[priceCol];
            const priceObj = dataCode === 'basePrice' ? glj : glj.priceProperty;
            sheet.setValue(row, priceCol, priceObj[dataCode]);
        }
        sheet.resumeEvent();
        sheet.resumePaint();
    },
    onSelectionChanged: function (sender, info) {
        let me = repositoryGljObj, that = gljComponentOprObj;
        //混凝土202、砂浆203、配合比204、机械3
        if (typeof info.oldSelections || info.oldSelections.length === 0 && info.newSelections.length > 0 || info.oldSelections[0].row !== info.newSelections[0].row) {
            let row = info.newSelections[0].row;
            me.initSel(row);
        }
    },
    initSel: function (row) {
        let me = repositoryGljObj, that = gljComponentOprObj, componentCanEdit = false;
        sheetOpr.cleanData(that.workBook.getSheet(0), that.setting, -1);
        me.workBook.focus(true);
        me.currentComponent = [];
        that.workBook.getSheet(0).setRowCount(5);
        if (row < me.currentCache.length) {
            //标记当前工料机
            me.currentGlj = me.currentCache[row];
            if (allowComponent.includes(me.currentCache[row].gljType)) {
                componentCanEdit = true;
                //展示数据
                if (me.currentGlj.component.length > 0) {
                    me.currentComponent = me.getCurrentComponent(me.currentGlj.component);
                    if (me.currentComponent.length > 0) {
                        //sheetOpr.showData(that.workBook.getSheet(0), that.setting, me.currentComponent);
                        sheetOpr.showData(that, that.workBook.getSheet(0), that.setting, me.currentComponent);
                    }
                }
            }
        }
        else {
            me.currentGlj = null;
        }
        //减少触发
        if (me.preComponentCanEdit !== componentCanEdit) {
            me.spreadControl(componentCanEdit);
            refreshALlWorkBook();
        }
        me.preComponentCanEdit = componentCanEdit;
    },
    //组成物表能编辑则显示，否则隐藏该工作表
    spreadControl: function (showComponent) {
        let leftWidth = getLocalCache('compleGLjleftContentWidth') || '28%',
            midWidth = getLocalCache('compleGLjmidContentWidth') || '47%',
            rightWidth = getLocalCache('compleGLjrightContentWidth') || '25%';
        [leftWidth, midWidth, rightWidth] = [leftWidth, midWidth, rightWidth].map((v) => parseFloat(v.replace('%', '')));
        let curMidWidth = parseFloat($('#midContent')[0].style.width.replace('%', '')),
            curRightWidth = parseFloat($('#rightContent')[0].style.width.replace('%', ''));
        if (showComponent) {
            if (leftWidth + midWidth + rightWidth > 100) {
                leftWidth = 50;
                midWidth = rightWidth = 25;
            }
        } else {
            midWidth = curMidWidth + curRightWidth;
            rightWidth = 0;
            leftWidth = 100 - midWidth;
        }
        $('#leftContent').css('width', `${leftWidth}%`);
        $('#midContent').css('width', `${midWidth}%`);
        $('#rightContent').css('width', `${rightWidth}%`);
    },
    onEnterCell: function (sender, args) {
        let me = repositoryGljObj;
        args.sheet.repaint();
        me.cellRowIdx = args.row;
        let isHasData = false;
        if (me.addGljObj) {
            for (let i = 0; i < me.setting.header.length; i++) {
                if (me.addGljObj[me.setting.header[i].dataCode]) {
                    isHasData = true;
                    break;
                }
            }
        }
        if (isHasData) {
            if (me.editingRowIdx !== me.cellRowIdx) {
                let isComple = true;
                let focusToCol;
                function getFocusToCol(me) {
                    if (!me.addGljObj.code) {
                        $('#alertGljTxt').text('编号不能为空，继续增加人材机?');
                        return me.colMapping.fieldToCol.code;
                    }
                    else if (!me.addGljObj.name) {
                        $('#alertGljTxt').text('名称不能为空，继续增加人材机?');
                        return me.colMapping.fieldToCol.name;
                    }
                    else if (!me.addGljObj.unit) {
                        $('#alertGljTxt').text('计量单位不能为空，继续增加人材机?');
                        return me.colMapping.fieldToCol.unit;
                    }
                    else if (!me.addGljObj.gljType) {
                        $('#alertGljTxt').text('类型不能为空，继续增加人材机?');
                        return me.colMapping.fieldToCol.gljType;
                    }
                    else {
                        return -1;
                    }
                }
                focusToCol = getFocusToCol(me);
                if (focusToCol === -1) {

                }
                else {
                    $('#gljAlertBtn').click();
                    $('#aleConfBtn').unbind('click');
                    $('#aleConfBtn').bind('click', function () {
                        args.sheet.setActiveCell(me.editingRowIdx, focusToCol);
                    });
                    $('#gljAleClose').unbind('click');
                    $('#gljAleClose').bind('click', function () {
                        args.sheet.setActiveCell(me.editingRowIdx, focusToCol);
                    });
                    $('#aleCanceBtn').unbind('click');
                    $('#aleCanceBtn').bind('click', function () {
                        me.addGljObj = null;
                        args.sheet.suspendPaint();
                        args.sheet.suspendEvent();
                        for (let col = 0; col < me.setting.header.length; col++) {
                            if (col === 0) {
                                args.sheet.getCell(me.editingRowIdx, 0).formatter("@");
                            }
                            args.sheet.getCell(me.editingRowIdx, col).value('');
                        }
                        args.sheet.setActiveCell(me.editingRowIdx, 0);
                        args.sheet.resumePaint();
                        args.sheet.resumeEvent();
                    });
                }
            }
        }
    },
    onButtonClicked: function (sender, args) {
        let me = repositoryGljObj;
        if (me.setting.header[args.col].dataCode === 'isComplementary' && args.row < me.currentCache.length) {
            args.sheet.setValue(args.row, args.col, true);
        }
    },
    onCellEditStart: function (sender, args) {
        let me = repositoryGljObj;
        me.orgCode = args.sheet.getValue(args.row, me.colMapping.fieldToCol['code']);
        let rObj = sheetOpr.combineRowData(me.workBook.getSheet(0), me.setting, args.row, me);
        me.currentEditingGlj = rObj;
        me.orgCode = me.workBook.getSheet(0).getValue(args.row, 0);
        if (args.row < me.currentCache.length) {
            let dataCode = me.setting.header[args.col].dataCode;
            me.currentGlj = me.currentCache[args.row];
            if (dataCode === 'code'
                || (dataCode === 'taxRate' && !me.taxRateTypes.includes(me.currentGlj.gljType))
                || (me.priceCols.includes(args.col) && allowComponent.includes(me.currentGlj.gljType) && me.currentGlj.component.length > 0)
                || (dataCode === 'model' && me.currentGlj.gljType !== 301)
                || dataCode === 'isComplementary') {
                args.cancel = true;
            } else {
                rObj.ID = me.currentGlj.ID;
                rObj.gljClass = me.currentGlj.gljClass;
            }
        } else {
            me.currentGlj = null;
        }
    },
    dataChanged: function (objA, objB, col) {
        let me = repositoryGljObj;
        if (me.priceCols.includes(col)) {
            if (!priceProperties || priceProperties.length === 0) {
                return objA.basePrice !== objB.basePrice;
            }
            else {
                return objA.priceProperty[me.colMapping.colToField[col]] !== objB.priceProperty[me.colMapping.colToField[col]]
            }
        }
        return objA[me.colMapping.colToField[col]] !== objB[[me.colMapping.colToField[col]]];
    },
    onCellEditEnd: function (sender, args) {
        let me = repositoryGljObj,
            that = gljComponentOprObj;
        // 输入编号、名称、规格时，如果输入回车符或粘贴回车符，提交时应转换为空格。
        let deESCFields = ['code', 'name', 'specs'];
        if (deESCFields.includes(me.setting.header[args.col]['dataCode'])) {
            args.editingText = me.isDef(args.editingText) ? args.editingText.toString().replace(/[\r\n]/g, ' ') : '';
            args.sheet.setValue(args.row, args.col, args.editingText);
        }
        let rObj = sheetOpr.combineRowData(me.workBook.getSheet(0), me.setting, args.row, me),
            updateArr = [],
            addArr = [],
            updateBasePrcArr = [];
        me.editingRowIdx = args.row;
        //rObj.basePrice = rObj.basePrice ? rObj.basePrice : 0;
        me.initPrice(rObj);
        //更新
        if (me.currentEditingGlj["ID"]) {
            rObj["ID"] = me.currentEditingGlj["ID"];
            rObj.gljClass = me.currentEditingGlj.gljClass;
            if (me.dataChanged(me.currentEditingGlj, rObj, args.col)) {
                //me.addGljObj = rObj;
                //编码、名称、单位、类型不可为空
                if (rObj.code && rObj.name && rObj.unit && rObj.gljType
                    && rObj.code.toString().trim().length !== 0 && rObj.name.toString().trim().length !== 0 && rObj.unit.toString().trim().length !== 0 &&
                    rObj.gljType.toString().trim().length !== 0) {
                    if (rObj.gljType !== me.currentEditingGlj.gljType) {//修改了工料机类型
                        if (me.currentGlj) {
                            me.currentGlj.component = [];
                        }
                        // 工料机类型不为普通材料、商品混凝土、商品砂浆、机械组成物、主材、设备时，清空税率
                        if (!me.taxRateTypes.includes(rObj.gljType)) {
                            rObj.taxRate = null;
                        }
                        //工料机类型不为机械台班时，清空机型
                        if (me.currentEditingGlj.gljType === 301 && rObj.gljType !== 301 && me.currentEditingGlj.model) {
                            rObj.model = null;
                        }
                        if (componentType.includes(me.currentEditingGlj.gljType) &&
                            !(machineComponent.includes(me.currentEditingGlj.gljType) && machineComponent.includes(rObj.gljType))
                            && !(materialComponent.includes(me.currentEditingGlj.gljType) && materialComponent.includes(rObj.gljType))) {//修改了原本是组成物的工料机
                            //寻找所有引用了此组成物的工料机,并从组成物中删去此工料机,并重算单价
                            let updateGljs = me.getUpdateGljs(rObj, true);
                            if (updateGljs.updateArr.length > 0 || updateGljs.updateBasePrcArr.length > 0) {
                                for (let i = 0; i < updateGljs.updateArr.length; i++) {
                                    updateArr.push(updateGljs.updateArr[i]);
                                }
                                for (let i = 0; i < updateGljs.updateBasePrcArr.length; i++) {
                                    updateBasePrcArr.push(updateGljs.updateBasePrcArr[i]);
                                }
                            }
                        }
                        sheetOpr.cleanData(that.workBook.getSheet(0), that.setting, me.colMapping.fieldToCol.gljType);
                    }
                    // 修改了税率
                    else if (rObj.taxRate !== me.currentEditingGlj.taxRate) {
                        if (isNaN(rObj.taxRate)) {
                            args.sheet.setValue(args.row, args.col, me.currentEditingGlj.taxRate || '');
                            alert('税率只能输入数值！');
                            return;
                        }
                        rObj.taxRate = scMathUtil.roundTo(parseFloat(rObj.taxRate), -2);
                    }
                    else if (!me.priceIsEqual(rObj, me.currentEditingGlj)) {//修改了单价,可修改单价的必为可成为组成物的
                        let rObjPrice = me.getPrice(rObj, args.col),
                            editingGljPrice = me.getPrice(me.currentEditingGlj, args.col);
                        //寻找所有引用了此组成物的工料机,并从组成物中删去此工料机,并重算单价
                        if (isNaN(parseFloat(rObjPrice))) {
                            alert('单价只能输入数值！');
                            args.sheet.setValue(args.row, args.col, editingGljPrice ? editingGljPrice : 0);
                            return;
                        }
                        me.setPriceByCol(rObj, scMathUtil.roundTo(parseFloat(rObjPrice), -2), args.col);
                        let updateGljs = me.getUpdateGljs(rObj);
                        if (updateGljs.updateArr.length > 0 || updateGljs.updateBasePrcArr.length > 0) {
                            for (let i = 0; i < updateGljs.updateArr.length; i++) {
                                updateArr.push(updateGljs.updateArr[i]);
                            }
                            for (let i = 0; i < updateGljs.updateBasePrcArr.length; i++) {
                                updateBasePrcArr.push(updateGljs.updateBasePrcArr[i]);
                            }
                        }
                    }
                    rObj.component = me.currentGlj.component;
                    updateArr.push(rObj);
                }
                else {
                    if (me.setting.header[args.col].dataCode === 'gljType') {
                        let distTypeVal = me.distTypeTree.distTypes[me.distTypeTree.prefix + me.currentEditingGlj[me.setting.header[args.col].dataCode]].data.fullName;
                        args.sheet.setValue(args.row, args.col, distTypeVal);
                    }
                    else {
                        args.sheet.setValue(args.row, args.col, me.currentEditingGlj[me.setting.header[args.col].dataCode]);
                    }
                }
            }
            // 价格发生变化，需要重算补充定额
            if (!me.priceIsEqual(rObj, me.currentEditingGlj)) {
                //update basePrice of ration when editting basePrice of glj
                let gljType = -1;
                let gljTypeParent = me.distTypeTree.distTypes[me.distTypeTree.prefix + me.currentEditingGlj.gljType].parent;
                if (gljTypeParent && gljTypeParent.data.ID <= 3) {
                    gljType = gljTypeParent.data.ID;
                }
                if (!gljTypeParent && me.currentEditingGlj.gljType <= 3) {
                    gljType = me.currentEditingGlj.gljType;
                }
                let gljBasePrcObj = { gljId: me.currentEditingGlj.ID, gljType: gljType, basePrice: me.getRationGljPrice(rObj) };
                if (gljBasePrcObj.gljType !== -1) {
                    updateBasePrcArr.push(gljBasePrcObj);
                }
            }
            // 人材机类型发生变化，需要重算补充定额
            else if (me.currentEditingGlj.gljType !== rObj.gljType) {
                let gljTypeObj = { gljId: me.currentEditingGlj.ID, gljType: rObj.gljType, basePrice: me.getRationGljPrice(rObj) };
                updateBasePrcArr.push(gljTypeObj);
            }
            //-----------------------------------------------------------
        }
        //新增
        else {
            if (typeof rObj.code !== 'undefined') {
                me.addGljObj = rObj;
                let isCanSav = true;
                if (!rObj.code || !rObj.name || !rObj.unit || !rObj.gljType) {
                    isCanSav = false;
                }
                if (isCanSav) {
                    me.addGljObj = null;
                    rObj.component = [];
                    me.initPrice(rObj);
                    addArr.push(rObj);
                }
            }
        }
        if (!me.parentNodeIds["_pNodeId_" + me.gljCurTypeId]) {
            rObj.gljClass = me.gljCurTypeId;
        }
        /* if (updateBasePrcArr.length) {
            me.updateRationBasePrcRq(updateBasePrcArr);
        } */
        if (updateArr.length > 0 || addArr.length > 0) {
            me.currentEditingGlj = null;
            me.mixUpdateRequest(updateArr, addArr, []);
        }
    },
    delGljs: function (sels) {
        let me = repositoryGljObj;
        let sheet = me.workBook.getSheet(0),
            updateArr = [], removeArr = [],
            tempRemoveArr = [],
            refGljCodes = [], //已被引用的工料机
            updateBasePrcArr = [],//删除基价单位后重新计算
            canUpdate = false,
            cacheSection = me.currentCache;
        if (sels.length > 0 && cacheSection.length > 0) {
            for (let i = 0; i < sels.length; i++) {
                if (sels[i].colCount === me.setting.header.length) {
                    for (let j = 0; j < sels[i].rowCount; j++) {
                        if (sels[i].row + j < cacheSection.length) {
                            //删除了已被引用成组成物的工料机，重新计算所有引用此组成物的工料机的单价、组成物数组
                            let updateGljs = me.getUpdateGljs(cacheSection[sels[i].row + j], true);
                            if (updateGljs.updateArr.length > 0 || updateGljs.updateBasePrcArr.length > 0) {
                                for (let i = 0; i < updateGljs.updateArr.length; i++) {
                                    updateArr.push(updateGljs.updateArr[i]);
                                }
                                for (let i = 0; i < updateGljs.updateBasePrcArr.length; i++) {
                                    updateBasePrcArr.push(updateGljs.updateBasePrcArr[i]);
                                }
                            }
                            removeArr.push(cacheSection[sels[i].row + j].ID);
                            //tempRemoveArr.push({ID: cacheSection[sels[i].row + j].ID, code: cacheSection[sels[i].row + j].code});
                            //删除后重新计算引用了此工料机的定额单价
                            updateBasePrcArr.push({ gljId: cacheSection[sels[i].row + j].ID, gljType: cacheSection[sels[i].row + j].gljType, basePrice: 0, delete: 1 });
                        }
                    }
                }
                else {
                    let maxCol = sels[i].col + sels[i].colCount - 1;
                    if (sels[i].col >= 2 && maxCol <= 4) {
                        for (let j = 0; j < sels[i].rowCount; j++) {
                            if (sels[i].row + j < cacheSection.length) {
                                let updateObj = cacheSection[sels[i].row + j];
                                for (let col = sels[i].col; col <= maxCol; col++) {
                                    if (me.setting.header[col].dataCode === 'basePrice') {
                                        //如果类型不为混凝土、砂浆、配合比、机械，才可删除单价 basePrice = 0
                                        if (!allowComponent.includes(updateObj.gljType)) {
                                            canUpdate = true;
                                            updateObj[me.setting.header[col].dataCode] = 0;
                                            updateBasePrcArr.push({ gljId: updateObj.ID, gljType: updateObj.gljType, basePrice: 0 });
                                        }
                                    }
                                    else {
                                        canUpdate = true;
                                        updateObj[me.setting.header[col].dataCode] = '';
                                    }
                                }
                                if (canUpdate) {
                                    updateArr.push(updateObj);
                                }
                            }
                        }
                    }
                    //编号、名称、单位、类型不可为空
                    else {
                        if (sels[i].row < cacheSection.length) {
                            let text = '', cantNullStr = ['编码', '名称', '类型'];
                            for (let col = sels[i].col; col <= sels[i].col + sels[i].colCount - 1; col++) {
                                if (cantNullStr.indexOf(me.setting.header[col].headerName) !== -1) {
                                    text += me.setting.header[col].headerName + " ";
                                }
                            }
                            $('#alertText').text(text + "不可为空！");
                            $('#codeAlertBtn').click();
                            $('#codAleConfBtn').click(function () {
                            });
                            $('#codAleClose').click(function () {
                            });
                        }
                    }
                }
            }
            if (removeArr.length > 0 || updateArr.length > 0) {
                //删除警告
                $('#alertGljTxt').text('可能已有定额引用了当前工料机，导致定额查找不到此工料机。确定要删除吗？');
                $('#gljAlertBtn').click();
                //确认
                $('#aleConfBtn').unbind('click');
                $('#aleConfBtn').bind('click', function () {
                    me.mixUpdateRequest(updateArr, [], removeArr);
                    /*if(updateBasePrcArr.length > 0 && me.rationLibs.length > 0){
                     me.updateRationBasePrcRq(updateBasePrcArr);
                     }*/
                });
            }
        }
    },
    repositoryGljDelOpr: function () {
        let me = repositoryGljObj;
        /*  me.workBook.commandManager().register('repositoryGljDel', function () {
             let sels = me.workBook.getActiveSheet().getSelections();
             me.delGljs(sels);
         }); */
        me.workBook.commandManager().setShortcutKey(null, GC.Spread.Commands.Key.del, false, false, false, false);
        me.workBook.commandManager().setShortcutKey('repositoryGljDel', GC.Spread.Commands.Key.del, false, false, false, false);
    },
    onContextmenuOpr: function () {
        let me = repositoryGljObj;
        $.contextMenu({
            selector: '#GLJListSheet',
            build: function ($triggerElement, e) {
                //控制允许右键菜单在哪个位置出现
                let sheet = me.workBook.getSheet(0);
                let offset = $("#GLJListSheet").offset(),
                    x = e.pageX - offset.left,
                    y = e.pageY - offset.top;
                let target = sheet.hitTest(x, y);
                let sel = sheet.getSelections()[0];
                if (sel.row === -1) {
                    sel.row = 0;
                }
                if (sel.col === -1) {
                    sel.col = 0;
                }
                if (target.hitTestType === 3 && typeof target.row !== 'undefined' && typeof target.col !== 'undefined') {//在表格内
                    me.initSel(target.row);
                    if (sel.row > target.row || sel.row + sel.rowCount - 1 < target.row ||
                        sel.col > target.col || sel.col + sel.colCount - 1 < target.col) {
                        sheet.setActiveCell(target.row, target.col);
                    }
                    return {
                        callback: function () { },
                        items: {
                            "delete": {
                                name: "删除",
                                disabled: function () {
                                    return !(me.currentCache && me.currentCache[target.row]);
                                },
                                icon: "fa-remove",
                                callback: function (key, opt) {
                                    let curSel = _.cloneDeep(sheet.getSelections()[0]);
                                    curSel.colCount = me.setting.header.length;
                                    me.delGljs([curSel]);
                                }
                            }
                        }
                    };
                }
                else {
                    return false;
                }
            }
        });
    },
    validUpdateObj: function (pasteObj, rowIdx) {
        let rst = { updateGlj: [], updateBasePrcArr: [] }, backUpObj = {},
            me = repositoryGljObj,
            that = gljComponentOprObj,
            tempObj = me.currentCache[rowIdx],
            reCalBasePrc = false,
            isValid = true;
        //备份原始数据
        for (let atr in tempObj) {
            backUpObj[atr] = tempObj[atr];
        }
        if (typeof pasteObj.code !== 'undefined') {
            if (pasteObj.code.trim().length !== 0) {
                let isExist = false;
                for (let i = 0; i < me.stdGljList.length; i++) {
                    if (me.stdGljList[i].code === pasteObj.code) {
                        isExist = true;
                        break;
                    }
                }
                if (!isExist) {
                    for (let i = 0; i < me.complementaryGljList.length; i++) {
                        if (me.complementaryGljList[i].code === pasteObj.code) {
                            isExist = true;
                            break;
                        }
                    }
                }
                if (!isExist) {
                    tempObj.code = pasteObj.code;
                }
                else isValid = false;
            }
            else isValid = false;
        }
        if (typeof pasteObj.name !== 'undefined') {
            if (pasteObj.name.trim().length === 0) isValid = false;
            else tempObj.name = pasteObj.name;
        }
        if (typeof pasteObj.specs !== 'undefined') {
            tempObj.specs = pasteObj.specs;
        }
        if (typeof pasteObj.unit !== 'undefined') {
            tempObj.unit = pasteObj.unit;
        }
        if (typeof pasteObj.gljType !== 'undefined') {
            let isExsit = false;
            for (let i = 0; i < me.distTypeTree.comboDatas.length; i++) {
                if (pasteObj.gljType === me.distTypeTree.comboDatas[i].text) {
                    pasteObj.gljType = me.distTypeTree.comboDatas[i].value;
                    isExsit = true;
                    reCalBasePrc = true;
                    if (!me.taxRateTypes.includes(pasteObj.taxRate) && me.taxRateTypes.includes(tempObj.taxRate)) {
                        tempObj.taxRate = null;
                    }
                    if (pasteObj.gljType !== 301 && tempObj.gljType === 301) {
                        tempObj.model = null;
                    }
                    if (componentType.includes(tempObj.gljType) &&
                        !(machineComponent.includes(tempObj.gljType) && machineComponent.includes(pasteObj.gljType)) &&
                        !(materialComponent.includes(tempObj.gljType) && materialComponent.includes(pasteObj.gljType))) {//修改了原本是组成物的工料机
                        //寻找所有引用了此组成物的工料机,并从组成物中删去此工料机,并重算单价
                        let updateGljs = me.getUpdateGljs(tempObj, true);
                        if (updateGljs.updateArr.length > 0 || updateGljs.updateBasePrcArr.length > 0) {
                            for (let i = 0; i < updateGljs.updateArr.length; i++) {
                                rst.updateGlj.push(updateGljs.updateArr[i]);
                            }
                            for (let i = 0; i < updateGljs.updateBasePrcArr.length; i++) {
                                rst.updateBasePrcArr.push(updateGljs.updateBasePrcArr[i]);
                            }
                        }
                    }
                    tempObj.component = tempObj.gljType === me.distTypeTree.comboDatas[i].value ? tempObj.component : [];
                    /*if(me.allowComponent.indexOf(tempObj.gljType) !== -1){
                        tempObj.basePrice = tempObj.gljType === me.distTypeTree.comboDatas[i].value ? tempObj.basePrice : 0;
                    }*/
                    tempObj.gljType = me.distTypeTree.comboDatas[i].value;
                    tempObj.shortName = me.distTypeTree.distTypes[me.distTypeTree.prefix + tempObj.gljType].data.shortName;
                    break;
                }
            }
            if (!isExsit) isValid = false;
        }
        if (typeof pasteObj.taxRate !== 'undefined'
            && typeof pasteObj.gljType === 'undefined') {
            if (me.taxRateTypes.includes(tempObj.gljType)) {
                tempObj.taxRate = pasteObj.taxRate && !isNaN(pasteObj.taxRate) ? scMathUtil.roundTo(parseFloat(pasteObj.taxRate), -2) : null;
            } else {
                isValid = false;
            }
        }
        //
        /* pasteObj.basePrice = !isNaN(parseFloat(pasteObj.basePrice)) && (pasteObj.basePrice && typeof pasteObj.basePrice !== 'undefined') ? scMathUtil.roundTo(parseFloat(pasteObj.basePrice), 2) :
            me.currentCache[rowIdx].basePrice;
        if (pasteObj.basePrice !== me.currentCache[rowIdx].basePrice) {
            reCalBasePrc = true;
            tempObj.basePrice = pasteObj.basePrice;
            let updateGljs = me.getUpdateGljs(tempObj, false);
            if (updateGljs.updateArr.length > 0 || updateGljs.updateBasePrcArr.length > 0) {
                for (let i = 0; i < updateGljs.updateArr.length; i++) {
                    rst.updateGlj.push(updateGljs.updateArr[i]);
                }
                for (let i = 0; i < updateGljs.updateBasePrcArr.length; i++) {
                    rst.updateBasePrcArr.push(updateGljs.updateBasePrcArr[i]);
                }
            }
        } */
        //单价相关
        if (me.pasteIncludesPrice(pasteObj)) {
            if (!priceProperties || priceProperties.length === 0) {
                pasteObj.basePrice = pasteObj.basePrice && !isNaN(parseFloat(pasteObj.basePrice)) ?
                    scMathUtil.roundTo(parseFloat(pasteObj.basePrice), -2) : me.currentCache[rowIdx].basePrice;
                if (pasteObj.basePrice !== me.currentCache[rowIdx].basePrice) {
                    reCalBasePrc = true;
                    tempObj.basePrice = pasteObj.basePrice;
                }
            }
            else {
                //多单价粘贴
                let pastePriceProperty = {};
                let priceFields = me.getPriceFields();
                for (let priceField of priceFields) {
                    if (typeof pasteObj[priceField] !== 'undefined' && pasteObj[priceField] && !isNaN(parseFloat(pasteObj[priceField]))) {
                        pastePriceProperty[priceField] = scMathUtil.roundTo(parseFloat(pasteObj[priceField]), -2);
                    }
                }
                if (!me.priceIsEqual(tempObj, pasteObj)) {
                    reCalBasePrc = true;
                    //更新人材机单价
                    for (let priceField in pastePriceProperty) {
                        tempObj.priceProperty[priceField] = pastePriceProperty[priceField];
                    }
                }
            }
            let updateGljs = me.getUpdateGljs(tempObj, false);
            if (updateGljs.updateArr.length > 0 || updateGljs.updateBasePrcArr.length > 0) {
                for (let i = 0; i < updateGljs.updateArr.length; i++) {
                    rst.updateGlj.push(updateGljs.updateArr[i]);
                }
                for (let i = 0; i < updateGljs.updateBasePrcArr.length; i++) {
                    rst.updateBasePrcArr.push(updateGljs.updateBasePrcArr[i]);
                }
            }
        }
        if (typeof pasteObj.model !== 'undefined') {
            if (!me.machineModel.textArr.includes(pasteObj.model)) {
                isValid = false;
            }
            else {
                let existsModel = false;
                if ((typeof pasteObj.gljType !== 'undefined' && pasteObj.gljType === 301) ||
                    (tempObj.gljType && tempObj.gljType === 301)) {
                    me.machineModel.comboItems.forEach(function (item) {
                        if (item.text === pasteObj.model) {
                            tempObj.model = item.value;
                            existsModel = true;
                        }
                    });
                    if (!existsModel) {
                        isValid = false;
                    }
                }
                else {
                    isValid = false;
                }
            }
        }
        if (isValid) {
            rst.updateGlj.push(tempObj);
            if (reCalBasePrc) {
                //重新计算定额基价对象
                //rst.updateBasePrc = {gljId: tempObj.ID, gljType: tempObj.gljType, basePrice: tempObj.basePrice};
                let newReObj = { gljId: tempObj.ID, gljType: tempObj.gljType, basePrice: me.getRationGljPrice(tempObj) };
                rst.updateBasePrcArr.push(newReObj);
            }
        }
        else {
            for (let attr in backUpObj) {
                tempObj[attr] = backUpObj[attr];
            }
        }
        return rst;
    },
    //粘贴的数据是否是可添加的数据,只有含有编号，名称，类型才可添加
    isValidObj: function (pasteObj) {
        let me = repositoryGljObj;
        if (!(pasteObj.code && typeof pasteObj.code !== 'undefined') || !(pasteObj.name && typeof pasteObj.name !== 'undefined') ||
            !(pasteObj.gljType && typeof pasteObj.gljType !== 'undefined')) {
            return false;
        }
        if (pasteObj.gljType && typeof pasteObj.gljType !== 'undefined') {
            let isExist = false;
            for (let i = 0; i < me.distTypeTree.comboDatas.length; i++) {
                if (me.distTypeTree.comboDatas[i].text === pasteObj.gljType) {
                    isExist = true;
                    pasteObj.gljType = me.distTypeTree.comboDatas[i].value;
                    pasteObj.shortName = me.distTypeTree.distTypes[me.distTypeTree.prefix + pasteObj.gljType].data.shortName;
                    break;
                }
            }
            if (!isExist) {
                return false;
            }
        }
        if (pasteObj.code && typeof pasteObj.code !== 'undefined') {
            for (let i = 0; i < me.stdGljList.length; i++) {
                if (me.stdGljList[i].code === pasteObj.code) {
                    return false;
                }
            }
            for (let i = 0; i < me.complementaryGljList.length; i++) {
                if (me.complementaryGljList[i].code === pasteObj.code) {
                    return false;
                }
            }

        }
        if (pasteObj.taxRate && (isNaN(pasteObj.taxRate) || !me.taxRateTypes.includes(pasteObj.gljType))) {
            return false;
        }
        if (typeof pasteObj.model !== 'undefined' && pasteObj.model) {
            if (!me.machineModel.textArr.includes(pasteObj.model) || pasteObj.gljType !== 301) {
                return false;
            }
            me.machineModel.comboItems.forEach(function (item) {
                if (item.text === pasteObj.model) {
                    pasteObj.model = item.value;
                }
            });
        }
        //pasteObj.basePrice = !isNaN(parseFloat(pasteObj.basePrice)) && (pasteObj.basePrice && typeof pasteObj.basePrice !== 'undefined') ? parseFloat(pasteObj.basePrice) : 0;
        if (!priceProperties || priceProperties.length === 0) {
            pasteObj.basePrice = !isNaN(parseFloat(pasteObj.basePrice)) && (pasteObj.basePrice && typeof pasteObj.basePrice !== 'undefined') ? parseFloat(pasteObj.basePrice) : 0;

        } else {
            let pastePriceProperty = {};
            let priceFields = me.getPriceFields();
            for (let priceField of priceFields) {
                if (typeof pasteObj[priceField] !== 'undefined' && pasteObj[priceField] && !isNaN(parseFloat(pasteObj[priceField]))) {
                    pastePriceProperty[priceField] = scMathUtil.roundTo(parseFloat(pasteObj[priceField]), -2);
                }
                else {
                    pastePriceProperty[priceField] = 0;
                }
            }
            pasteObj.priceProperty = pastePriceProperty;
        }
        if (!me.parentNodeIds["_pNodeId_" + me.gljCurTypeId]) {
            pasteObj.gljClass = me.gljCurTypeId;
        }
        return true;
    },
    canPasted: function (info) {
        let rst = true;
        let me = repositoryGljObj;
        if (me.gljCurTypeId < 0) {
            return false;
        }
        const maxCol = info.cellRange.col + info.cellRange.colCount - 1;
        if (maxCol > me.setting.header.length - 2) {
            return false;
        }
        if (info.cellRange.row < me.currentCache.length) {
            const minPriceCol = Math.min(...me.priceCols);
            const maxPriceCol = Math.max(...me.priceCols)
            if (info.cellRange.col === 0) {
                return false;
            }
            for (let i = 0, len = info.cellRange.rowCount; i < len; i++) {
                let row = i + info.cellRange.row;
                if (row < me.currentCache.length
                    && allowComponent.includes(me.currentCache[row].gljType)
                    && me.currentCache[row].component.length
                    && !(maxCol < minPriceCol || info.cellRange.col > maxPriceCol)) {// 包含了价格列
                    return false;
                } else {
                    break;
                }
            }
        }
        return rst;
    },
    onClipboardPasting: function (sender, args) {
        let me = repositoryGljObj;
        if (!me.canPasted(args)) {
            args.cancel = true;
        }
    },
    onClipboardPasted: function (e, info) {
        //  if(info.pasteData.text.trim().length > 0){
        let me = repositoryGljObj;
        let updateArr = [], addArr = [];
        let items = sheetOpr.analyzePasteData(me.setting, info);
        let beginRow = info.cellRange.row, endRow = info.cellRange.row + info.cellRange.rowCount - 1,//复制的起始行数和结束行数
            maxRow = me.currentCache.length - 1,//当前数据最大行数
            updateBasePrcArr = [],
            updateCount, resumeArr = [];
        if (endRow <= maxRow) {
            for (let i = 0; i < items.length; i++) {
                let updateObj = me.validUpdateObj(items[i], info.cellRange.row + i);
                if (updateObj && typeof updateObj.updateGlj !== 'undefined' && updateObj.updateGlj.length > 0) {
                    updateArr = updateArr.concat(updateObj.updateGlj);
                    if (typeof updateObj.updateBasePrcArr !== 'undefined') {
                        updateBasePrcArr = updateBasePrcArr.concat(updateObj.updateBasePrcArr);
                    }
                }
            }
        }
        else if (beginRow <= maxRow && endRow > maxRow) {
            updateCount = maxRow - beginRow + 1;
            for (let i = 0; i < updateCount; i++) {
                let updateObj = me.validUpdateObj(items[i], info.cellRange.row + i);
                if (updateObj && typeof updateObj.updateGlj !== 'undefined') {
                    updateArr = updateArr.concat(updateObj.updateGlj);
                    if (typeof updateObj.updateBasePrcArr !== 'undefined') {
                        updateBasePrcArr = updateBasePrcArr.concat(updateObj.updateBasePrcArr);
                    }
                }
            }
            for (let i = updateCount; i < items.length; i++) {
                if (me.isValidObj(items[i])) {
                    items[i].component = [];
                    addArr.push(items[i]);
                }
            }
        }
        else {
            for (let i = 0; i < items.length; i++) {
                if (me.isValidObj(items[i])) {
                    items[i].component = [];
                    addArr.push(items[i]);
                }
            }
        }
        //repaint
        for (let i = 0; i < info.cellRange.rowCount; i++) {
            resumeArr.push(info.cellRange.row + i);
        }
        if (resumeArr.length > 0) {
            let sheet = me.workBook.getActiveSheet();
            sheet.suspendPaint();
            for (let i = 0; i < resumeArr.length; i++) {
                if (resumeArr[i] < me.currentCache.length) {
                    for (let col = 0; col < me.setting.header.length - 1; col++) {
                        if (me.setting.header[col].dataCode === 'gljType') {
                            let gljType = me.currentCache[resumeArr[i]][me.setting.header[col].dataCode];
                            sheet.setValue(resumeArr[i], col, me.distTypeTree.distTypes["gljType" + gljType].data.fullName);
                        }
                        else if (me.setting.header[col].dataCode === 'model') {
                            sheet.setValue(resumeArr[i], col, me.currentCache[resumeArr[i]][me.setting.header[col].dataCode] ? me.machineModelIdx[me.currentCache[resumeArr[i]][me.setting.header[col].dataCode]] : '');
                        }
                        else {
                            sheet.setValue(resumeArr[i], col, me.currentCache[resumeArr[i]][me.setting.header[col].dataCode]);
                        }
                    }
                }
                else {
                    for (let col = 0; col < me.setting.header.length - 1; col++) {
                        sheet.setValue(resumeArr[i], col, '', GC.Spread.Sheets.SheetArea.viewport);
                    }
                }
            }
            sheet.resumePaint();
        }
        if (updateArr.length > 0 || addArr.length > 0) {
            me.mixUpdateRequest(updateArr, addArr, []);
        }
        /* if (updateBasePrcArr.length > 0 && me.rationLibs.length > 0) {
            me.updateRationBasePrcRq(updateBasePrcArr);
        } */
        // }
    },
    updateRationBasePrcRq: function (basePrcArr) {
        CommonAjax.post('/complementartGlj/api/updateRationBasePrc', { basePrcArr: basePrcArr }, function (rstData) {
        });
    },
    /*  getRationGljIds: function (repId) {
          let me = repositoryGljObj;
          $.ajax({
              type: 'post',
              url: 'api/getRationGljIds',
              data: {data: JSON.stringify({repId: repId})},
              dataType: 'json',
              success: function(result){
                  if(!result.error){
                      me.rationGljIds = result.data;
                  }
              }
          });
      },*/
    mixUpdateRequest: function (updateArr, addArr, removeIds) {
        let me = repositoryGljObj;
        if (updateArr.length > 0) {
            me.saveInString(updateArr);
        }
        if (addArr.length > 0) {
            me.saveInString(addArr);
        }
        let url = 'complementartGlj/api/mixUpdateGljItems';
        let post = { updateItems: updateArr, addItems: addArr, removeIds: removeIds };
        let scCaller = function (rstData) {
            me.updateCache(addArr, updateArr, removeIds, rstData);
            me.sortGlj(me.complementaryGljList);
            if (me.currentOprParent === 1) {
                me.currentCache = me.getParentCache(me.parentNodeIds["_pNodeId_" + me.gljCurTypeId]);
            }
            else {
                me.currentCache = me.getCache();
            }
            me.showGljItems(me.complementaryGljList, me.gljCurTypeId);
            //getCurrentGlj
            let row = me.workBook.getSheet(0).getSelections()[0].row;
            me.initSel(row);
        }
        let errCaller = function (err) {
            alert('保存失败');
        };
        CommonAjax.post(url, post, scCaller, errCaller);
    },
    saveInString: function (datas) {
        for (let i = 0, len = datas.length; i < len; i++) {
            let data = datas[i];
            if (_exist(data, 'basePrice')) {
                data['basePrice'] = data['basePrice'].toString();
            }
            if (_exist(data, 'component')) {
                for (let j = 0, jLen = data['component'].length; j < jLen; j++) {
                    let comGljObj = data['component'][j];
                    if (_exist(comGljObj, 'consumeAmt')) {
                        comGljObj['consumeAmt'] = comGljObj['consumeAmt'].toString();
                    }
                }
            }
        }
        function _exist(data, attr) {
            return data && data[attr] !== undefined && data[attr];
        }
    },
    getParentCache: function (nodes) {
        let me = repositoryGljObj, rst = [];
        for (let i = 0; i < me.complementaryGljList.length; i++) {
            if (nodes.indexOf(me.complementaryGljList[i].gljClass) !== -1) {
                rst.push(me.complementaryGljList[i]);
            }
        }
        rst.sort(function (a, b) {
            let rst = 0;
            if (a.code > b.code) rst = 1;
            else if (a.code < b.code) rst = -1;
            return rst;
        });
        return rst;
    },
    getCache: function () {
        let me = this, rst = [];
        for (let i = 0; i < me.complementaryGljList.length; i++) {
            if (me.complementaryGljList[i].gljClass == me.gljCurTypeId) {
                rst.push(me.complementaryGljList[i]);
            }
        }
        return rst;
    },
    updateCache: function (addArr, updateArr, removeIds, rstData) {
        let me = this, cacheSection = me.complementaryGljList;
        if (addArr.length > 0) {
            me.complementaryGljList = me.complementaryGljList.concat(addArr);
            cacheSection = me.complementaryGljList;
        }
        for (let i = removeIds.length - 1; i >= 0; i--) {
            for (let j = cacheSection.length - 1; j >= 0; j--) {
                if (cacheSection[j]["ID"] == removeIds[i]) {
                    cacheSection.splice(j, 1);
                }
            }
        }
        if (rstData && rstData.ops && rstData.ops.length > 0) {
            for (let i = 0; i < rstData.ops.length; i++) {
                for (let j = 0; j < cacheSection.length; j++) {
                    if (cacheSection[j][me.setting.header[0].dataCode] == rstData.ops[i][me.setting.header[0].dataCode]) {
                        cacheSection[j]["ID"] = rstData.ops[i]["ID"];
                    }
                }
            }
        }
        for (let i = 0; i < updateArr.length; i++) {
            for (let j = 0; j < cacheSection.length; j++) {
                if (updateArr[i]["ID"] && cacheSection[j]["ID"]) {
                    if (cacheSection[j]["ID"] == updateArr[i]["ID"]) {
                        cacheSection[j] = updateArr[i];
                    }
                } else if (cacheSection[j].code === updateArr[i].code) {
                    cacheSection[j] = updateArr[i];
                }
            }
        }
        //allgljs
    },
    updateParentNodeIds: function (nodes, caller) {
        let private_build_parentNodeIds = function (pNodeId, nodesArr) {
            let rst = [];
            for (let i = 0; i < nodesArr.length; i++) {
                if (nodesArr[i].children.length > 0) {
                    rst = rst.concat(private_build_parentNodeIds(nodesArr[i].data.ID, nodesArr[i].children));
                } else {
                    rst.push(nodesArr[i].data.ID);
                }
            }
            if (pNodeId && rst.length > 0) {
                caller.parentNodeIds["_pNodeId_" + pNodeId] = rst;
            }
            return rst;
        };
        if (caller.parentNodeIds) {
            private_build_parentNodeIds(null, nodes);
        }
    },
    setProp: function (prop, value, gljList) {
        let me = this;
        for (let i = 0, len = gljList.length; i < len; i++) {
            gljList[i][prop] = value;
        }
    },
    sortGlj: function (gljList) {
        let me = this;
        gljList.sort(function (a, b) {
            let rst = 0;
            if (a.code > b.code) rst = 1
            else if (a.code < b.code) rst = -1;
            return rst;
        });
    }
}

let gljTypeTreeOprObj = {
    onClick: function (event, treeId, treeNode) {
        let me = repositoryGljObj,
            that = gljComponentOprObj,
            gljTypeId = treeNode.ID;
        me.gljCurTypeId = treeNode.ID;
        //消除新增到一半的数据
        me.addGljObj = null;
        //me.currentCache = me.getCache();
        sheetOpr.cleanData(that.workBook.getSheet(0), that.setting, 5);
        if (me.parentNodeIds["_pNodeId_" + treeNode.ID]) {
            me.currentOprParent = 1;
            me.currentCache = me.getParentCache(me.parentNodeIds["_pNodeId_" + treeNode.ID]);
            me.workBook.getSheet(0).setRowCount(me.currentCache.length);
        } else {
            me.currentOprParent = 0;
            me.currentCache = me.getCache();
        }
        me.showGljItems(me.complementaryGljList, gljTypeId);
    }
}