ConstructionCost/web/building_saas/main/js/models/exportStandardInterface.js

'use strict';

/**
 *
 *
 * @author Zhong
 * @date 2019/3/15
 * @version
 */

/*
* 数据标准接口
* 导出符合标准接口要求的xml
* */

const XMLStandard = (function () {
    return function (userID, granularity) {
        this.GRANULARITY = {
            PROJECT: 1,         //导出建设项目
            ENGINEERING: 2,     //导出单项工程
            TENDER: 3           //导出单位工程
        };
        //默认导出建设项目
        if (!granularity || ![1, 2, 3].includes(granularity)) {
            granularity = this.GRANULARITY.PROJECT;
        }
        //属性类型
        const TYPE = {
            DATE: 1,        //日期类型YYYY-MM-DD
            DATE_TIME: 2,   //日期类型YYY-MM-DDTHH:mm:ss
            INT: 3,         //整数类型
            DECIMAL: 4,     //数值类型，不限制小数位数
            NUM2: 5,        //数值类型2：最多两位小数
            BOOL: 6         //布尔型
        };
        const WHITE_SPACE = {
            COLLAPSE: 1 //移除所有空白字符（换行、回车、空格以及制表符会被替换为空格，开头和结尾的空格会被移除，而多个连续的空格会被缩减为一个单一的空格）
        };
        //加载数据间隔，减少服务器压力
        const TIMEOUT_TIME = 500;

        /*
         * 检查
         * 创建节点时检查节点的数据
         * 1.长度限制minLen，maxLen
         * 2.值的限制，固定范围：enumeration
         * @param {Array}datas(需要检查的属性数据)
         * @return {Object} failHints没通过的属性提示 filterAttrs过滤后的属性数据(失败提示在属性是必须的时候才提示，如果该属性失败了，但是是非必要属性，那么该属性不显示)
         * */
        function check(datas) {
            let rst = {failHints: [], filterAttrs: []};
            let dateReg = /([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3})-(((0[13578]|1[02])-(0[1-9]|[12][0-9]|3[01]))|((0[469]|11)-(0[1-9]|[12][0-9]|30))|(02-(0[1-9]|[1][0-9]|2[0-8])))/;
            for (let data of datas) {
                data.value = typeof data.value === 'undefined' || data.value === null ? '' : data.value.toString();
                if (data.whiteSpace && data.whiteSpace === WHITE_SPACE.COLLAPSE) {  //处理空格相关
                    data.value = data.value.replace(/[\r,\n,\t]/g, ' ');
                    data.value = data.value.trim();
                    data.value = data.value.replace(/\s{1,}/g, ' ');
                }
                if (!data.value && !data.minLen && !data.enumeration) {  //值为空，且没有限制最小字符数，且没有限制值，则不需判断
                    rst.filterAttrs.push(data);
                    continue;
                }
                let isFail = false;
                if (data.minLen && data.value.length < data.minLen){
                    isFail = true;
                    rst.failHints.push(`“${data.name}”字符数不可小于${data.minLen}个`);
                } else if (data.maxLen && data.value.length > data.maxLen) {
                    isFail = true;
                    rst.failHints.push(`“${data.name}”字符数不可大于${data.maxLen}个`);
                } else if (data.enumeration && !data.enumeration.includes(data.value)) {
                    isFail = true;
                    rst.failHints.push(`“${data.name}”只能从“${data.enumeration.join(';')}”中选择`);
                } else if (data.type && data.type === TYPE.DATE && !dateReg.test(data.value)) {
                    isFail = true;
                    rst.push(`“${data.name}”日期格式必须是YYYY-MM-DD`);
                } else if (data.type && data.type === TYPE.INT && !Number.isInteger(parseFloat(data.value))) {
                    isFail = true;
                    rst.failHints.push(`“${data.name}”必须为整数`);
                } else if (data.type && data.type === TYPE.DECIMAL && isNaN(parseFloat(data.value))) {
                    isFail = true;
                    rst.failHints.push(`“${data.name}”必须为数值`)
                } else if (data.type && data.type === TYPE.NUM2) {
                    let v = parseFloat(data.value);
                    if (isNaN(v)) {
                        isFail = true;
                        rst.failHints.push(`“${data.name}”必须为数值`);
                    } else if (!data.value.length || (data.value.split('.').length > 1 && data.value.split('.')[1].length > 2)){
                        isFail = true;
                        rst.failHints.push(`“${data.name}”小数位数不得多于两位`);
                    }
                } else if (data.type && data.type === TYPE.BOOL && !['true', 'false'].includes(data.value.toString())) {
                    isFail = true;
                    rst.failHints.push(`“${data.name}”必须为true或false`);
                }
                if (!isFail || data.required) {
                    rst.filterAttrs.push(data);
                }
            }
            return rst;
        }
        //从fees数组中获取相关费用
        function getFee(fees, feeFields) {
            if (!fees) {
                return 0;
            }
            let fields = feeFields.split('.');
            let fee = fees.find(data => data.fieldName === fields[0]);
            if (!fee) {
                return 0;
            }
            return fee[fields[1]] || 0;
        }
        //根据字段获取基本信息、工程特征
        function getValueByKey(data, key) {
            for (let d of data) {
                if (d.key === key) {
                    return d.value;
                }
                if (d.items && d.items.length > 0) {
                    let findData = d.items.find(x => x.key === key);
                    if (findData) {
                        return findData.value;
                    }
                }
            }
            return '';
        }
        //造成导出失败
        let failList = [];
        /*
         * 定义不设置一个Node方法统一进入的原因：模板化比较直观，不分开定义节点的话，调用传参也很麻烦而且不直观。
         * 一个节点对应一个构造方法，方便调整配置、方便其他版本开发、接手的人看起来更直观
         * @param {String}name(节点名) {Array}attrs(节点属性数据)
         * @return {void}
         * */
        function element(name, attrs) {
            this.name = name;
            let checkData = check(attrs);
            this.fail = checkData.failHints;
            this.attrs = checkData.filterAttrs;
            this.children = [];
            for (let fail of this.fail) {
                failList.push(`${name}-${fail}`);
            }
        }
        //建设项目定义
        //source:来源数据
        function Project(source) {
            let attrs = [
                {name: '项目编号', value: getValueByKey(source.basicInformation, 'projNumber'), required: true, minLen: 1, maxLen: 255, whiteSpace: WHITE_SPACE.COLLAPSE},
                {name: '项目名称', value: source.name, required: true, minLen: 1, maxLen: 255, whiteSpace: WHITE_SPACE.COLLAPSE},
                {name: '建设单位', value: getValueByKey(source.basicInformation, 'constructionUnit'), required: true},
                {name: '标准版本号', value: '3.2.2', required: true},
                {name: '标准名称', value: '重庆造价软件数据交换标准(清单计价)', required: true,},
                {name: '文件类型', value: getValueByKey(source.basicInformation, 'fileKind'), required: true, enumeration: ['招标', '投标', '控制价', '结算', '其他']},
                {name: '计税方法', value: 'todo', required: true},
            ];
            //唯一约束
            this.constraints = {
                engCode: [],    //单项工程编号
                tenderCode: [], //单位工程编号
            };
            element.call(this, '标段', attrs);
        }
        //项目信息定义
        function ProjectInfo(source) {
            let attrs = [
                {name: '工程规模', value: getValueByKey(source.basicInformation, 'projectScale'), required: true},
                {name: '工程所在地', value: getValueByKey(source.basicInformation, 'projLocation'), required: true},
                {name: '工程地址', value: getValueByKey(source.basicInformation, 'projAddress'), required: true},
                {name: '施工单位', value: getValueByKey(source.basicInformation, 'buildingUnit')},
                {name: '编制单位', value: getValueByKey(source.basicInformation, 'establishmentUnit'), required: true},
                {name: '审核单位', value: getValueByKey(source.basicInformation, 'auditUnit')},
                {name: '编制人', value: getValueByKey(source.basicInformation, 'buildingUnitAuthor'), required: true},
                {name: '审核人', value: 'todo'},
                {name: '开工日期', value: getValueByKey(source.basicInformation, 'commencementDate'), type: TYPE.DATE},
                {name: '竣工日期', value: getValueByKey(source.basicInformation, 'completionDate'), type: TYPE.DATE},
                {name: '编制日期', value: getValueByKey(source.basicInformation, 'establishDate'), type: TYPE.DATE, required: true},
                {name: '审核日期', value: getValueByKey(source.basicInformation, 'auditDate'), type: TYPE.DATE},
                {name: '材料价格期', value: getValueByKey(source.basicInformation, 'materialPricePeriod'), required: true},
                {name: '合同价类型', value: getValueByKey(source.basicInformation, 'contractPriceType')},

            ];
            element.call(this, '项目信息', attrs);
        }
        //招标信息定义
        function BiddingInfo(source) {
            let attrs = [
                {name: '招标代理机构', value: getValueByKey(source.basicInformation, 'tenderingAgency')},
                {name: '造价工程师', value: getValueByKey(source.basicInformation, 'tenderCostEngineer'), required: true},
                {name: '造价工程师注册证号', value: getValueByKey(source.basicInformation, 'tenderCostEngineerNo'), required: true},
                {name: '招标工期', value: getValueByKey(source.basicInformation, 'tenderPeriod'), required: true, type: TYPE.INT},
                {name: '控制总价', value: source.summaryInfo.engineeringCost, required: true, type: TYPE.NUM2},
            ];
            element.call(this, '招标信息', attrs);
        }
        //投标信息定义
        function BidInfo(source) {
            let attrs = [
                {name: '投标人', value: getValueByKey(source.basicInformation, 'bidder'), required: true},
                {name: '造价工程师', value: getValueByKey(source.basicInformation, 'bidCostEngineer'), required: true},
                {name: '造价工程师注册证号', value: getValueByKey(source.basicInformation, 'bidCostEngineerNo'), required: true},
                {name: '项目经理', value: getValueByKey(source.basicInformation, 'projectManager')},
                {name: '投标工期', value: getValueByKey(source.basicInformation, 'biddingPeriod')},
                {name: '投标保证金', value: getValueByKey(source.basicInformation, 'biddingMargin'), type: TYPE.NUM2},
                {name: '质量承诺', value: getValueByKey(source.basicInformation, 'qualityCommitment')},
                {name: '担保类型', value: getValueByKey(source.basicInformation, 'guaranteeType')},
                {name: '投标总价', value: source.summaryInfo.engineeringCost, required: true, type: TYPE.NUM2},
            ];
            element.call(this, '投标信息', attrs);
        }
        //编制说明定义
        function CompilationIllustration(source) {
            let attrs = [
                {name: '内容', value: source.compilationIllustration, required: true},
            ];
            element.call(this, '编制说明', attrs);
        }
        //系统信息定义
        function SystemInfo(source) {
            let attrs = [
                {name: 'ID1', value: source.softInfo, required: true},
                {name: 'ID2', value: '', required: true},
                {name: '生成时间', value: source.generatedTime, type: TYPE.DATE_TIME, required: true},
            ];
            element.call(this, '系统信息', attrs);
        }
        //费用构成定义
        function FeeFrom(summaryInfo) {
            let attrs = [
                {name: '工程费合计', value: summaryInfo.engineeringCost, required: true, type: TYPE.NUM2},
                {name: '分部分项清单合计', value: summaryInfo.subEngineering, required: true, type: TYPE.NUM2},
                {name: '措施项目清单合计', value: summaryInfo.measure, required: true, type: TYPE.NUM2},
                {name: '安全文明施工专项费', value: summaryInfo.safetyConstruction, required: true, type: TYPE.NUM2},
                {name: '其他项目清单合计', value: summaryInfo.other, required: true, type: TYPE.NUM2},
                {name: '规费', value: summaryInfo.charge, required: true, type: TYPE.NUM2},
                {name: '税金', value: summaryInfo.tax, required: true, type: TYPE.NUM2},
            ];
            element.call(this, '费用构成', attrs);
        }
        //单项工程定义
        function Engineering(source) {
            let attrs = [
                {name: '编号', value: source.code, required: true, minLen: 1, maxLen: 255, whiteSpace: WHITE_SPACE.COLLAPSE},
                {name: '名称', value: source.name, required: true, minLen: 1, maxLen: 255, whiteSpace: WHITE_SPACE.COLLAPSE},
                {name: '金额', value: source.summaryInfo.engineeringCost, type: TYPE.NUM2},
            ];
            element.call(this, '单项工程', attrs);
        }
        //单位工程定义
        function Tender(source) {
            const TAX = {
                1: '一般计税',
                2: '简易计税'
            };
            let attrs = [
                {name: '编号', value: source.code, required: true, minLen: 1, maxLen: 255, whiteSpace: WHITE_SPACE.COLLAPSE},
                {name: '名称', value: source.name, required: true, minLen: 1, maxLen: 255, whiteSpace: WHITE_SPACE.COLLAPSE},
                {name: '专业', value: source.engineeringName, required: true, enumeration: [
                    '土建工程', '装饰工程', '安装工程', '市政工程', '园林绿化工程',
                    '仿古建筑工程', '房修工程', '轨道工程', '构筑物工程', '机械(爆破)土石方',
                    '围墙工程', '幕墙工程', '市政安装工程', '城市轨道交通安装', '人工土石方',
                    '房屋安装修缮工程', '房屋修缮单拆除'
                ]},
                {name: '金额', value: source.summaryInfo.engineeringCost, type: TYPE.NUM2},
                {name: '定额库编码', value: source.defaultRationLibCode},
                {name: '计税方法', value: TAX[source.taxType], required: true},
            ];
            this.constraints = {
                billsCode: [],                 //清单项目项目编码
                formulaMeasureNo: [],          //公式计算措施项序号
                gljCode: [],                   //人材机代码
                provisionalDetailCode: [],     //暂列金额明细编号
                engEstimateDetailCode: [],     //专业工程暂估明细
                turnKeyContractCode: [],       //总承包服务费费用项编号
                labourDayWorkCode: [],         //人工计日工项目编号
                materialDayWorkCode: [],       //材料计日工项目编号
                machineDayWorkCode: [],        //机械计日工项目编号
                otherItemNo: [],               //其他列项序号
                feeItemNo: [],                 //费用项序号
                mainBillsCode: [],             //主要清单明细项目编码 （标准文件中constraint中没有定义此唯一性，但是主要清单明细的备注那里说明了，这里处理一下）
            };
            element.call(this, '单位工程', attrs);
        }
        //工程特征定义
        function EngFeature(source) {
            let attrs = [
                {name: '建筑分类', value: source.feature.buildingClass, required: true},
                {name: '工程分类', value: source.feature.projClass, required: true},
                {name: '建设规模', value: 'todo', required: true},
                {name: '工程类别', value: getValueByKey(source.basicInformation, 'projectCategory'), required: true} //取建设项目的工程类别
            ];
            element.call(this, '工程特征', attrs);
        }
        //特征项定义
        function FeatureItem(feature) {
            let attrs = [
                {name: '编码', value: ''},
                {name: '名称', value: feature.dispName, required: true},
                {name: '内容', value: feature.value, required: true},
            ];
            element.call(this, '特征项', attrs);
        }
        //单位工程费汇总定义
        function TenderFeeSummary() {
            element.call(this, '单位工程费汇总', []);
        }
        //计价程序费用行定义
        function DXFYRow(source) {
            let attrs = [
                {name: '序号', value: source.code},
                {name: '行代号', value: source.rowCode, required: true},
                {name: '项目名称', value: source.name, required: true},
                {name: '计算基础表达式', value: source.calcBase, required: true},
                {name: '计算基础说明', value: source.calcBase},
                {name: '费率', value: source.feeRate},
                {name: '金额', value: getFee(source.fees, 'common.totalFee'), type: TYPE.NUM2},
                {name: '其中暂估价', value: getFee(source.fees, 'estimate.totalFee'), type: TYPE.NUM2},
                {name: '费用类别', value: source.feeType, type: TYPE.INT, required: true},
                {name: '备注', value: source.remark},
            ];
            element.call(this, '计价程序费用行', attrs);
        }
        //分部分项清单
        function FBFXBills() {
            element.call(this, '分部分项清单', []);
        }
        //清单分部定义
        function FBBills(source) {
            let attrs = [
                {name: '编号', value: source.code, required: true, maxLen: 20},
                {name: '名称', value: source.name, required: true, minLen: 1, maxLen: 255, whiteSpace: WHITE_SPACE.COLLAPSE},
                {name: '金额', value: getFee(source.fees, 'common.totalFee'), required: true, type: TYPE.NUM2},
                {name: '其中暂估价', value: getFee(source.fees, 'estimate.totalFee'), required: true},
                {name: '备注', value: source.remark}
            ];
            element.call(this, '清单分部', attrs);
        }
        //清单项目定义
        function FXbills(source) {
            let attrs = [
                {name: '项目编码', value: source.code, required: true, minLen: 1, maxLen: 20, whiteSpace: WHITE_SPACE.COLLAPSE},
                {name: '项目名称', value: source.name, required: true, minLen: 1, maxLen: 500, whiteSpace: WHITE_SPACE.COLLAPSE},
                {name: '单位', value: source.unit, required: true, minLen: 1, maxLen: 20, whiteSpace: WHITE_SPACE.COLLAPSE},
                {name: '工程量', value: source.quantity, required: true, type: TYPE.DECIMAL},
                {name: '综合单价', value: getFee(source.fees, 'common.unitFee'), required: true, type: TYPE.DECIMAL},
                {name: '综合合价', value: getFee(source.fees, 'common.totalFee'), required: true, type: TYPE.NUM2},
                {name: '其中暂估价', value: getFee(source.fees, 'estimate.totalFee'), required: true, type: TYPE.NUM2},
                {name: '主要清单标志', value: !!source.mainBills, type: TYPE.BOOL},
                {name: '暂估清单标志', value: !!source.isEstimate, type: TYPE.BOOL},
                {name: '备注', value: source.remark},
            ];
            element.call(this, '清单项目', attrs);
        }
        //项目特征定义
        function ItemCharacter() {
            element.call(this, '项目特征', []);
        }
        //特征定义
        function Feature(source) {
            let attrs = [
                {name: '特征名称', value: source.name, required: true},
                {name: '特征描述', value: source.value, required: true},
            ];
            element.call(this, '特征', attrs);
        }
        //工程内容定义
        function JobContent() {
            element.call(this, '工程内容', []);
        }
        //内容定义
        function Content(content) {
            let attrs = [
                {name: '内容', value: content, required: true}
            ];
            element.call(this, '内容', attrs);
        }
        //组价内容定义
        function PriceContent() {
            element.call(this, '组价内容', []);
        }
        //定额子目定义
        function Ration(source) {
            let attrs = [
                {name: '定额编号', value: source.viewCode, required: true, minLen: 1, maxLen: 80, whiteSpace: WHITE_SPACE.COLLAPSE},
                {name: '项目名称', value: source.name, required: true, minLen: 1, maxLen: 255, whiteSpace: WHITE_SPACE.COLLAPSE},
                {name: '单位', value: source.unit, required: true, minLen: 1, maxLen: 20, whiteSpace: WHITE_SPACE.COLLAPSE},
                {name: '定额库编码', value: source.libCode, required: true}, //todo
                {name: '原始定额编号', value: source.code, minLen: 1, maxLen: 80, whiteSpace: WHITE_SPACE.COLLAPSE},
                {name: '子目类型', value: source.subType, required: true, type: TYPE.INT, enumeration: ['0', '1', '2', '3', '4', '5', '6']},  //todo
                {name: '工程量', value: source.quantity, required: true, type: TYPE.DECIMAL},
                {name: '工程量计算式', value: source.quantityEXP},
                {name: '定额单价', value: getFee(source.fees, 'rationUnitPrice.unitFee'), required: true, type: TYPE.DECIMAL},
                {name: '定额合价', value: getFee(source.fees, 'rationUnitPrice.totalFee'), required: true, type: TYPE.NUM2},
                {name: '综合单价', value: getFee(source.fees, 'common.unitFee'), required: true, type: TYPE.DECIMAL},
                {name: '综合合价', value: getFee(source.fees, 'common.totalFee'), required: true, type: TYPE.NUM2},
                {name: '单价构成文件ID', value: 0, required: true, type: TYPE.INT}, //todo
                {name: '分包标志', value: !!source.isSubcontract, type: TYPE.BOOL},
                {name: '备注', value: source.remark}
            ];
            element.call(this, '定额子目', attrs);
        }
        //工料分析定义
        function GljAnalyze() {
            element.call(this, '工料分析', []);
        }
        //人材机含量定义
        function GljContent(source) {
            let attrs = [
                {name: '人材机代码', value: source.code, required: true, minLen: 1, maxLen: 20, whiteSpace: WHITE_SPACE.COLLAPSE},
                {name: '消耗量', value: source.quantity, required: true, type: TYPE.DECIMAL},
                {name: '总消耗量', value: source.totalQuantity, required: true, type: TYPE.DECIMAL},
                {name: '数量计算方式', value: 1, required: true, type: TYPE.INT},
            ];
            element.call(this, '人材机含量', attrs);
        }
        //费用组成
        function FeeContent(source) {
            let attrs = [
                {name: '基价人工费单价', value: getFee(source.fees, 'labour.unitFee'), type: TYPE.DECIMAL, required: true},
                {name: '基价人工费合价', value: getFee(source.fees, 'labour.totalFee'), type: TYPE.NUM2, required: true},
                {name: '定额人工基价调整单价', value: 0, type: TYPE.DECIMAL}, //调整价目前只有08有，默认设置成0
                {name: '定额人工基价调整合价', value: 0, type: TYPE.NUM2},
                {name: '基价材料费单价', value: getFee(source.fees, 'material.unitFee'), type: TYPE.DECIMAL, required: true},
                {name: '基价材料费合价', value: getFee(source.fees, 'material.totalFee'), type: TYPE.NUM2, required: true},
                {name: '基价机械费单价', value: getFee(source.fees, 'machine.unitFee'), type: TYPE.DECIMAL, required: true},
                {name: '基价机械费合价', value: getFee(source.fees, 'machine.totalFee'), type: TYPE.NUM2, required: true},
                {name: '定额机上人工基价调整单价', value: 0, type: TYPE.DECIMAL, required: true},
                {name: '定额机上人工基价调整合价', value: 0, type: TYPE.NUM2, required: true},
                {name: '未计材料单价', value: getFee(source.fees, 'unratedMaterial.unitFee'), type: TYPE.DECIMAL, required: true},
                {name: '未计材料合价', value: getFee(source.fees, 'unratedMaterial.totalFee'), type: TYPE.NUM2, required: true},
                {name: '人材机价差单价', value: getFee(source.fees, 'gljDiff.unitFee'), type: TYPE.DECIMAL, required: true},   //人材机价差通过人工、材料、机械价差相加得出
                {name: '人材机价差合价', value: getFee(source.fees, 'gljDiff.totalFee'), type: TYPE.NUM2, required: true},
                {name: '暂估材料单价', value: getFee(source.fees, 'estimate.unitFee'), type: TYPE.DECIMAL, required: true},
                {name: '暂估材料合价', value: getFee(source.fees, 'estimate.totalFee'), type: TYPE.NUM2, required: true},
                {name: '管理费单价', value: getFee(source.fees, 'manage.unitFee'), type: TYPE.DECIMAL, required: true},
                {name: '管理费合价', value: getFee(source.fees, 'manage.totalFee'), type: TYPE.NUM2, required: true},
                {name: '利润单价', value: getFee(source.fees, 'profit.unitFee'), type: TYPE.DECIMAL, required: true},
                {name: '利润合价', value: getFee(source.fees, 'profit.totalFee'), type: TYPE.NUM2, required: true},
                {name: '风险单价', value: getFee(source.fees, 'risk.unitFee'), type: TYPE.DECIMAL, required: true}, //重庆08叫风险费 重庆18叫一般风险费
                {name: '风险合价', value: getFee(source.fees, 'risk.totalFee'), type: TYPE.NUM2, required: true},
                {name: '一般风险单价', value: getFee(source.fees, 'risk.unitFee'), type: TYPE.DECIMAL, required: true},
                {name: '一般风险合价', value: getFee(source.fees, 'risk.totalFee'), type: TYPE.NUM2, required: true},
                {name: '其他风险单价', value: getFee(source.fees, 'otherRisk.unitFee'), type: TYPE.DECIMAL, required: true},
                {name: '其他风险合价', value: getFee(source.fees, 'otherRisk.totalFee'), type: TYPE.NUM2, required: true},
            ];
            element.call(this, '费用组成', attrs);
        }
        //措施项目清单定义
        function CSXMBills(source) {
            let attrs = [
                {name: '金额', value: getFee(source.fees, 'common.totalFee'), type: TYPE.NUM2, required: true},
                {name: '其中暂估价', value: getFee(source.fees, 'estimate.totalFee'), type: TYPE.NUM2, required: true},
            ];
            element.call(this, '措施项目清单', attrs);
        }
        //组织措施清单定义
        function ZZCSBills(source) {
            let attrs = [
                {name: '金额', value: getFee(source.fees, 'common.totalFee'), type: TYPE.NUM2, required: true},
            ];
            element.call(this, '组织措施清单', attrs);
        }
        //组织措施分类定义
        function ZZCSClass(source) {
            let attrs = [
                {name: '编码', value: source.code, maxLen: 20, required: true},
                {name: '名称', value: source.name, minLen: 1, maxLen: 255, whiteSpace: WHITE_SPACE.COLLAPSE, required: true},
                {name: '金额', value: getFee(source.fees, 'common.totalFee'), type: TYPE.NUM2, required: true},
                {name: '备注', value: source.remark}
            ];
            element.call(this, '组织措施分类', attrs);
        }
        //公式计算措施项
        function FormulaCalcMeasure(source) {
            let attrs = [
                {name: '序号', value: source.code, minLen: 1, maxLen:20, whiteSpace: WHITE_SPACE.COLLAPSE, required: true},
                {name: '名称', value: source.name, minLen: 1, maxLen: 255, whiteSpace: WHITE_SPACE.COLLAPSE, required: true},
                {name: '计算基础表达式', value: source.calcBase, required: true},
                {name: '计算基础说明', value: source.calcBase},
                {name: '费率', value: source.feeRate, required: true},
                {name: '金额', value: getFee(source.fees, 'common.totalFee'), required: true},
                {name: '暂估价标志', value: getFee(source.fees, 'common.totalFee')},
                {name: '备注', value: source.remark},
                {name: '费用类别', value: source.feeType, enumeration: ['120201', '1204', '10041', '1206'], required: true},
            ];
            element.call(this, '公式计算措施项', attrs);
        }
        //技术措施清单定义
        function JSCSBills(source) {
            let attrs = [
                {name: '技术措施清单', value: getFee(source.fees, 'common.totalFee'), type: TYPE.NUM2, required: true},
                {name: '其中暂估价', value: getFee(source.fees, 'estimate.totalFee'), type: TYPE.NUM2, required: true},
            ];
            element.call(this, '技术措施清单', attrs);
        }
        //技术措施分类
        function JSCSClass(source) {
            let attrs = [
                {name: '编号', value: source.code},
                {name: '名称', value: source.name, required: true},
                {name: '金额', value: getFee(source.fees, 'common.totalFee'), type: TYPE.NUM2, required: true},
                {name: '其中暂估价', value: getFee(source.fees, 'estimate.totalFee'), type: TYPE.DECIMAL, required: true},
            ];
            element.call(this, '技术措施分类', attrs);
        }
        //其他项目清单定义
        function OtherBills() {
            element.call(this, '其他项目清单', []);
        }
        //暂列金额定义
        function Provisional(source) {
            let attrs = [
                {name: '金额', value: getFee(source.fees, 'common.totalFee'), type: TYPE.NUM2}
            ];
            element.call(this, '暂列金额', attrs);
        }
        //暂列金额明细定义
        function ProvisionalDetail(source) {
            let attrs = [
                {name: '编号', value: source.code, minLen: 1, maxLen: 20, whiteSpace: WHITE_SPACE.COLLAPSE, required: true},
                {name: '项目名称', value: source.name, minLen: 1, maxLen: 255, whiteSpace: WHITE_SPACE.COLLAPSE, required: true},
                {name: '计量单位', value: source.unit, maxLen: 20, required: true},
                {name: '金额', value: getFee(source.fees, 'common.totalFee'), type: TYPE.NUM2, required: true},
                {name: '备注', value: source.remark, required: true}
            ];
            element.call(this, '暂列金额明细', attrs);
        }
        //专业工程暂估价定义
        function EngEstimate(source) {
            let attrs = [
                {name: '金额', value: getFee(source.fees, 'common.totalFee')}
            ];
            element.call(this, '专业工程暂估价', attrs);
        }
        //专业工程暂估明细定义
        function EngEstimateDetail(source) {
            let attrs = [
                {name: '编号', value: source.code, minLen: 1, maxLen: 20, whiteSpace: WHITE_SPACE.COLLAPSE, required: true},
                {name: '工程名称', value: source.name, minLen: 1, maxLen: 255, whiteSpace: WHITE_SPACE.COLLAPSE, required: true},
                {name: '工程内容', value: source.engineeringContent, maxLen: 2000, required: true},
                {name: '金额', value: getFee(source.fees, 'common.totalFee'), type: TYPE.NUM2, required: true},
                {name: '备注', value: source.remark, required: true}
            ];
            element.call(this, '专业工程暂估明细', attrs);
        }
        //计日工定义
        function DayWork(source) {
            let attrs = [
                {name: '金额', value: getFee(source.fees, 'common.totalFee')}
            ];
            element.call(this, '', attrs);
        }
        //人工定义
        function Labour() {
            element.call(this, '人工', []);
        }
        //材料定义
        function Material() {
            element.call(this, '材料', []);
        }
        //施工机械定义
        function Machine() {
            element.call(this, '施工机械', []);
        }
        //计日工项目定义
        function DayWorkItem(source) {
            let attrs = [
                {name: '编号', value: source.code, minLen: 1, maxLen: 20, whiteSpace: WHITE_SPACE.COLLAPSE, required: true},
                {name: '名称', value: source.name, minLen: 1, maxLen: 255, whiteSpace: WHITE_SPACE.COLLAPSE, required: true},
                {name: '单位', value: source.unit, minLen: 1, maxLen: 20, whiteSpace: WHITE_SPACE.COLLAPSE, required: true},
                {name: '数量', value: source.quantity, type: TYPE.DECIMAL, required: true},
                {name: '综合单价', value: source.quantity, type: TYPE.DECIMAL, required: true},
                {name: '综合合价', value: source.quantity, type: TYPE.NUM2, required: true},
                {name: '备注', value: source.remark}
            ];
            element.call(this, '计日工项目', attrs);
        }
        //总承包服务费定义
        function TurnKeyContract(source) {
            let attrs = [
                {name: '金额', value: getFee(source.fees, 'common.totalFee'), type: TYPE.NUM2}
            ];
            element.call(this, '总承包服务费', attrs);
        }
        //总承包服务费分类定义
        function TurnKeyContractClass(source) {
            let attrs = [
                {name:'编号', value: source.code, minLen: 1, maxLen: 20, whiteSpace: WHITE_SPACE.COLLAPSE},
                {name:'名称', value: source.name, minLen: 1, maxLen: 255, whiteSpace: WHITE_SPACE.COLLAPSE, required: true},
                {name:'备注', value: source.remark}
            ];
            element.call(this, '总承包服务费分类', attrs);
        }
        //总承包服务费费用项定义
        function TurnKeyContractItem(source) {
            let attrs = [
                {name: '编号', value: source.code, minLen: 1, maxLen: 20, whiteSpace: WHITE_SPACE.COLLAPSE, required: true},
                {name: '工程名称', value: source.name, minLen: 1, maxLen: 255, whiteSpace: WHITE_SPACE.COLLAPSE, required: true},
                {name: '计算基础', value: 0, type: TYPE.DECIMAL, required: true},   //todo
                {name: '服务内容', value: source.serviceContent, maxLen: 255, required: true},
                {name: '费率', value: source.feeRate, type: TYPE.DECIMAL, required: true},
                {name: '金额', value: getFee(source.fees, 'common.totalFee'), type: TYPE.NUM2, required: true},
                {name: '备注', value: source.remark}
            ];
            element.call(this, '总承包服务费费用项', attrs);
        }
        //签证索赔计价汇总费用项
        function ClaimVisaFeeItem(source) {
            let attrs = [
                {name: '编号', value: source.code, required: true},
                {name: '项目名称', value: source.name, required: true},
                {name: '计量单位', value: source.unit, required: true},
                {name: '数量', value: source.quantity, type: TYPE.DECIMAL, required: true},
                {name: '单价', value: getFee(source.fees, 'common.unitFee'), type: TYPE.DECIMAL, required: true},
                {name: '合价', value: getFee(source.fees, 'common.totalFee'), type: TYPE.NUM2, required: true},
                {name: '依据', value: '', required: true},
            ]
        }
        //其他定义
        function Other(source) {
            let attrs = [
                {name: '金额', value: source.commonTotalFee, type: TYPE.NUM2}
            ];
            element.call(this, '其他', attrs);
        }
        //其他列项定义
        function OtherItem(source) {
            let attrs = [
                {name: '序号', value: source.code, minLen: 1, maxLen: 20, whiteSpace: WHITE_SPACE.COLLAPSE, required: true},
                {name: '名称', value: source.name, minLen: 1, maxLen: 255, whiteSpace: WHITE_SPACE.COLLAPSE, required: true},
                {name: '计算基础', value: source.calcBase,  maxLen: 255},
                {name: '费率', value: source.feeRate, type: TYPE.DECIMAL},
                {name: '金额', value: source.commonTotalFee, type: TYPE.NUM2, required: true},
                {name: '不计入合价标志', value: !!source.isEstimate, type: TYPE.BOOL},
                {name: '备注', value: source.remark, maxLen: 255}
            ];
            element.call(this, '其他列项', attrs);
        }
        //规费和税金清单定义
        function ChargeTaxBills() {
            element.call(this, '规费和税金清单', []);
        }
        //费用项定义
        function FeeItem(source) {
            let attrs = [
                {name: '序号', value: source.code, minLen: 1, maxLen: 20, whiteSpace: WHITE_SPACE.COLLAPSE, required: true},
                {name: '行代号', value: source.rowCode, maxLen: 20, required: true},
                {name: '名称', value: source.name, minLen: 1, maxLen: 255, whiteSpace: WHITE_SPACE.COLLAPSE, required: true},
                {name: '计算基础表达式', value: source.calcBase, maxLen: 255, required: true},
                {name: '计算基础说明', value: source.calcBase, maxLen: 255},
                {name: '费率', value: source.feeRate, type: TYPE.DECIMAL, required: true},
                {name: '金额', value: getFee(source.fees, 'common.totalFee'), type: TYPE.NUM2, required: true},
                {name: '费用类别', value: source.feeType, enumeration: ['800', '900', '9001', '9002', '9003'], required: true},
                {name: '备注', value: source.remark, maxLen: 255}
            ];
            element.call(this, '费用项', attrs);
        }
        //人材机汇总定义
        function GljSummary() {
            element.call(this, '人材机汇总', []);
        }
        //人材机定义
        function Glj(source) {
            let attrs = [
                {name: '代码', value: source.code, minLen: 1, maxLen: 20, whiteSpace: WHITE_SPACE.COLLAPSE, required: true},
                {name: '名称', value: source.name, minLen: 1, maxLen: 255, whiteSpace: WHITE_SPACE.COLLAPSE, required: true},
                {name: '规格', value: source.spec, maxLen: 255},
                {name: '单位', value: source.unit, minLen: 1, maxLen: 20, whiteSpace: WHITE_SPACE.COLLAPSE, required: true},
                {name: '原始代码', value: source.orgCode, minLen: 1, maxLen: 20, whiteSpace: WHITE_SPACE.COLLAPSE},
                {name: '费用类别', value: source.feeType, enumeration: ['1', '2', '3', '4'], required: true},
                {name: '配比类别', value: '', type: TYPE.INT},  //todo
                {name: '主要材料类别', value: '', type: TYPE.INT},  //todo
                {name: '主要材料单位系数', value: '', type: TYPE.DECIMAL},  //todo
                {name: '材料耗用类型', value: '', type: TYPE.INT, required: true},  //todo
                {name: '供货方式', value: '', type: TYPE.INT},  //todo
                {name: '暂估材料标志', value: !!source.is_evaluate, type: TYPE.BOOL},
                {name: '不计税设备标志', value: !!source.is_adjust_price, type: TYPE.BOOL, required: true},  //todo
                {name: '单价不从明细汇总标志', value: !!source.excludeRatio, type: TYPE.BOOL},  //todo
                {name: '定额价', value: source.basePrice, type: TYPE.DECIMAL, required: true},
                {name: '定额价调整', value: '', type: TYPE.DECIMAL, required: true},   //todo
                {name: '市场价', value: source.marketPrice, type: TYPE.DECIMAL, required: true},
                {name: '数量', value: source.quantity, type: TYPE.DECIMAL, required: true},
                {name: '产地', value: source.originPlace, maxLen: 255},
                {name: '厂家', value: source.vender, maxLen: 255},
                {name: '质量等级', value: source.qualityGrace, maxLen: 255},
                {name: '品牌', value: source.brand, maxLen: 255},
                {name: '备注', value: source.remark, maxLen: 255},
            ];
            element.call(this, '人材机', attrs);
        }
        //人材机配比定义
        function GljRatio(source) {
            let attrs = [
                {name: '明细材料代码', value: source.code, minLen: 1, maxLen: 20, whiteSpace: WHITE_SPACE.COLLAPSE, required: true},
                {name: '数量', value: source.quantity, type: TYPE.DECIMAL, required: true}
            ];
            element.call(this, '人材机配比', attrs);
        }
        //主要清单汇总定义
        function MainBillsSummary() {
            element.call(this, '主要清单汇总', []);
        }
        //主要清单明细定义
        function MainBillsItem(source) {
            let attrs = [
                {name: '项目编码', value: source.code, minLen: 1, maxLen: 20, whiteSpace: WHITE_SPACE.COLLAPSE, required: true},
                {name: '项目名称', value: source.name, minLen: 1, maxLen: 500, whiteSpace: WHITE_SPACE.COLLAPSE, required: true},
                {name: '单位', value: source.unit, minLen: 1, maxLen: 20, whiteSpace: WHITE_SPACE.COLLAPSE, required: true},
                {name: '工程量', value: source.quantity, type: TYPE.DECIMAL, required: true},
                {name: '综合单价', value: getFee(source.fees, 'common.unitFee'), type: TYPE.DECIMAL, required: true},
                {name: '综合合价', value: getFee(source.fees, 'common.totalFee'), type: TYPE.NUM2, required: true},
                {name: '其中暂估价', value: getFee(source.fees, 'estimate.totalFee'), type: TYPE.DECIMAL},
                {name: '备注', value: source.remark, maxLen: 255},
            ];
            element.call(this, '主要清单明细', attrs);
        }

        async function setTimeoutSync(handle, time) {
            return new Promise(function(resolve, reject) {
                setTimeout(function () {
                    if (handle && typeof handle === 'function') {
                        handle();
                    }
                    resolve();
                }, time);
            });
        }

        this.failList = failList;
        this.granularity = granularity;
        //目前的数据
        let curPMData = {project: null, engineering: null, tender: null},   //项目管理项目数据
            curProjectEle = null,  //建设项目节点
            curTenderEle = null;   //单位工程节点
        //自增编码
        let incrementData = {
            projectCode: 1,     //项目编号，单项工程、单位工程编号自动生成
        };
        function getIncreamentData(field) {
            if (!incrementData[field]) {
                incrementData[field] = 1;
            }
            return incrementData[field]++;
        }
        //数组打平成对象
        function arrayToObj(arr) {
            let rst = {};
            for (let data of arr) {
                rst[data.key] = data.value;
            }
            return rst;
        }
        //获取节点固定ID
        function getNodeFlag(node) {
            if (!node || !node.data || !node.data.flags || !node.data.flags[0] || ! node.data.flags[0].flag) {
                return 0;
            }
            return node.data.flags[0].flag;
        }
        //获取节点所属固定ID
        function belongToFlag(node) {
            while (node) {
                if (node.data && node.data.flags && node.data.flags[0] && node.data.flags[0].flag) {
                    return node.data.flags[0].flag;
                }
                node = node.parent;
            }
            return null;
        }
        //获取节点后代节点
        function getPosterity(node) {
            let posterity = [];
            getNodes(node.children);
            return posterity;
            function getNodes(nodes) {
                for (let node of nodes) {
                    posterity.push(node);
                    if (node.children.length > 0){
                        getNodes(node.children);
                    }
                }
            }
        }
        //检测层数
        //@param {Number}maxDepth(最大深度) {Object}node（需要检测的清单树节点）
        //@return {Boolean}
        function validDepth(maxDepth, node) {
            let nodeDepth = node.depth();
            let allNodes = getPosterity(node);
            //检测相对深度
            for (let n of allNodes) {
                let relativeDepth = n.depth() - nodeDepth;
                if (relativeDepth > maxDepth) {
                    return false;
                }
            }
            return true;
        }
        //检测唯一性
        //@param {Object}constraints(约束池) {All}data(检测的数据) {String}hint(提示已存在的内容)
        //@return {void}
        function checkUnique(constraints, data, hint) {
            if (constraints.includes(data)) {
                failList.push(`${hint}“${data}”已存在`);
            } else if (data) {
                constraints.push(data);
            }
        }
        //根据数据的NextSiblingID进行排序，返回排序后的数组
        function sortByNext(datas) {
            let target = [],
                temp = {};
            for (let data of datas) {
                temp[data.ID] = {me: data, next: null, prev: null};
            }
            for (let data of datas) {
                let next = temp[data.NextSiblingID] || null;
                temp[data.ID].next = next;
                if (next) {
                    next.prev = temp[data.ID];
                }
            }
            let first = null;
            for (let data of datas) {
                let me = temp[data.ID];
                if (!me.prev) {
                    first = me;
                }
            }
            if (!first) {
                return datas;
            }
            while (first) {
                target.push(first.me);
                first = first.next;
            }
            return target;

        }
        //获取需要导出的项目数据
        //@param {Number}tenderID(当前界面的单位工程ID，后台根据这个单位工程，去找其建设项目下所有数据)
        //@return {Object}(eleObj)
        async function loadProject(tenderID) {
            //拉取标段数据:建设项目、单项工程、单位工程数据
            let projectData = curPMData.project = await ajaxPost('/pm/api/getProjectByGranularity', {user_id: userID, tenderID: tenderID, granularity: granularity});
            if (!projectData) {
                throw '获取项目数据错误';
            }
            //单项工程、单位工程按照树结构数据进行排序
            projectData.children = sortByNext(projectData.children);
            for (let engData of projectData.children) {
                engData.children = sortByNext(engData.children);
            }
            //标段
            let project = curProjectEle = new Project({basicInformation: projectData.property.basicInformation, name: projectData.name});
            //项目信息
            let projectInfo = new ProjectInfo({basicInformation: projectData.property.basicInformation});
            project.children.push(projectInfo);
            //招标信息
            let biddingInfo = new BiddingInfo({basicInformation: projectData.property.basicInformation, summaryInfo: projectData.summaryInfo[projectData.ID]});
            projectInfo.children.push(biddingInfo);
            //投标信息
            let bidInfo = new BidInfo({basicInformation: projectData.property.basicInformation, summaryInfo: projectData.summaryInfo[projectData.ID]});
            projectInfo.children.push(bidInfo);
            //编制说明
            let compilationIll = new CompilationIllustration({compilationIllustration: projectData.property.compilationIllustration});
            project.children.push(compilationIll);
            //系统信息
            let generatedTime = moment(Date.now()).format('YYYY-MM-DDTHH:mm:ss'),
                sysInfoSource = {softInfo: projectData.softInfo, generatedTime},
                sysInfo = new SystemInfo(sysInfoSource);
            project.children.push(sysInfo);
            //费用构成
            let feeForm = new FeeFrom(projectData.summaryInfo[projectData.ID]);
            project.children.push(feeForm);
            //主要清单汇总    主要清单明细在loadTender中设置
            let mainBillsSummaryEle = new MainBillsSummary();
            project.children.unshift(mainBillsSummaryEle);  //插入到第一个位置，必须要排在loadTender前，这样才能添加到明细数据，插在第一位方便后面排序
            //单项工程
            for (let eng of projectData.children) {
                curPMData.engineering = eng;
                let engElement = await loadEngineering(projectData.summaryInfo, eng);
                project.children.push(engElement);
            }
            //主要清单汇总 排在后面
            project.children.shift(mainBillsSummaryEle);
            project.children.push(mainBillsSummaryEle);
            return project;
        }
        /*
         * 加载单项工程数据
         * @param {Object}summaryInfo(项目汇总信息映射) {Object}engData(单项工程数据)
         * */
        async function loadEngineering(summaryInfo, engData) {
            let source = {summaryInfo: summaryInfo[engData.ID], name: engData.name, code: getIncreamentData('projectCode')};
            let engineering = new Engineering(source);
            //单项工程编号要唯一
            checkUnique(curProjectEle.constraints.engCode, source.code, '单项工程编号');
            //分批次获取单位工程
            for (let tenderData of engData.children) {
                curPMData.tender = tenderData;
                await setTimeoutSync(() => {},TIMEOUT_TIME);    //间隔一段时间再初始单位工程数据，减少服务器压力
                let tender = await loadTender(summaryInfo, tenderData);
                engineering.children.push(tender);
            }
            return engineering;
        }
        /*
        * 加载单位工程数据
        * @param {Object}summaryInfo(项目汇总信息映射) {Object}tenderData(单位工程数据)
        * @return {Object}
        * */
        async function loadTender(summaryInfo, tenderData) {
            //获取单位工程详细数据
            let tenderDetail = PROJECT.createNew(tenderData.ID, userID);
            await tenderDetail.loadDataSync();
            //单位工程
            let tenderSource = {
                code: getIncreamentData('projectCode'),
                name: tenderData.name,
                engineeringName: tenderData.property.engineeringName,
                summaryInfo: summaryInfo[tenderData.ID],
                defaultRationLibCode: tenderData.defaultRationLibCode,
                taxType: tenderData.property.taxType
            };
            let tender = curTenderEle = new Tender(tenderSource);
            //单位工程编号要唯一
            checkUnique(curProjectEle.constraints.tenderCode, tenderSource.code, '单位工程编号');
            //工程特征
            let featureObj = arrayToObj(tenderData.property.projectFeature);
            let engFeature = new EngFeature({feature:featureObj, basicInformation: curPMData.project.property.basicInformation});
            tender.children.push(engFeature);
            //特征项：每一项工程特征
            for (let data of tenderData.property.projectFeature) {
                let featureItem = new FeatureItem(data);
                engFeature.children.push(featureItem);
            }
            //单位工程费汇总
            tender.children.push(loadDXFY(tenderDetail));
            //分部分项清单
            tender.children.push(loadFBFX(tenderDetail));
            //措施项目清单
            tender.children.push(loadCSXM(tenderDetail));
            //其他项目清单
            let other = loadOtherBills(tenderDetail);
            if (other) {
                tender.children.push(other);
            }
            //规费和税金清单
            let chargeTax = loadChargeTax(tenderDetail);
            tender.children.push(chargeTax);
            //人材机汇总
            let gljSummary = loadGlj(tenderDetail);
            if (gljSummary) {
                tender.children.push(gljSummary);
            }
            //给建设项目下主要清单汇总设置主要清单明细
            let curMainBillsSummary = curProjectEle.children.find(ele => ele.name === '主要清单汇总');
            if (curMainBillsSummary) {
                loadMainBillsItems(curMainBillsSummary, tenderDetail);
            }
            return tender;
        }
        /*
        * 加载计算程序费用行
        * @param {Object}detail(单位工程的详细数据，清单定额等等)
        * @return {Object}
        * */
        function loadDXFY(detail) {
            //单位工程费汇总
            let tenderFeeSummary = new TenderFeeSummary();
            //计价程序费用行,筛选大项费用行数据
            let dxfyNodes = detail.Bills.tree.roots;
            for (let node of dxfyNodes) {
                let mainTreeNode = detail.mainTree.getNodeByID(node.data.ID),
                    serialNo = mainTreeNode ? mainTreeNode.serialNo() + 1 : 1;
                let flag = getNodeFlag(node) || 0;
                let source = {
                    code: node.data.code,
                    rowCode: `F${serialNo}`,
                    name: node.data.name,
                    calcBase: node.data.calcBase,
                    feeRate: node.data.feeRate,
                    fees: node.data.fees,
                    feeType: FEE_TYPE[flag],
                    remark: node.data.remark
                };
                let dxfy = new DXFYRow(source);
                tenderFeeSummary.children.push(dxfy);
            }
            return tenderFeeSummary;
        }
        /*
        * 加载清单项目
        * @param {Object}node(清单树节点) {Array}allRation(项目所有定额数据) {Array}allRationGlj(项目所有定额人材机数据) {Object}decimal(项目小数位数)
        * */
        function loadBills(node, allRation, allRationGlj, decimal) {
            let source = {
                code: node.data.code,
                name: node.data.name,
                unit: node.data.unit,
                quantity: node.data.quantity,
                fees: node.data.fees,
                mainBills: node.data.mainBills,
                isEstimate: node.data.isEstimate,
                remark: node.data.remark
            };
            let bills = new FXbills(source);
            //清单项目项目编码要在单位工程中唯一
            checkUnique(curTenderEle.constraints.billsCode, source.code, '清单项目项目编号');
            //加载特征及内容
            function loadFeatureContent() {
                let job = [],
                    feature = [];
                let jobText = node.data.jobContentText || '';
                let featureText = node.data.itemCharacterText || '';
                let jobSplit = jobText.split(/[\r,\n]/g),
                    featureSplit = featureText.split(/[\r,\n]/g);
                //将特征和内容分类，通过[项目特征][工作内容]区分。若没有,则不区分:工作内容列全部数据为工作内容，项目特征列全部数据为项目特征
                //@param {Array}data(splitdata) {String}field(job、feature)
                function classifyData(data, field) {
                    let rst = {
                        job: [],
                        feature: []
                    };
                    let featureIndex = data.findIndex(x => x === '[项目特征]');
                    if (featureIndex < 0) {
                        rst[field] = data;
                        return rst;
                    }
                    let jobIndex = data.findIndex(x => x === '[工作内容]');
                    if (jobIndex < 0) { //有[项目特征]，没有[工作内容]，则其数据全为项目特征数据
                        rst.feature = data;
                        return rst;
                    }
                    //有[项目特征]，有[工作内容]，进行数据分类
                    rst.feature = data.slice(featureIndex, jobIndex);
                    rst.job = data.slice(jobIndex);
                    return rst;
                }
                let classifiedJob = classifyData(jobSplit, 'job');
                job = job.concat(classifiedJob.job);
                feature = feature.concat(classifiedJob.feature);
                let classifiedFeature = classifyData(featureSplit, 'feature');
                job = job.concat(classifiedFeature.job);
                feature = feature.concat(classifiedFeature.feature);
                job = job.filter(x => x && !['[项目特征]', '[工作内容]'].includes(x));
                feature = feature.filter(x => x && !['[项目特征]', '[工作内容]'].includes(x));
                //创建项目特征节点
                if (feature.length > 0) {
                    let itemChac = new ItemCharacter();
                    let reg = /(.{0,}):(.{0,})/;
                    for (let f of feature) {
                        let source = {name: '', value: ''};
                        let execRst = reg.exec(f);
                        if (execRst) {
                           source.name = execRst[1].replace(/^\d+\.{1}/, '').trim();  //去除开头（1.）序号,首位空格
                           source.value = execRst[2].trim();
                        }
                        let featureEle = new Feature(source);
                        itemChac.children.push(featureEle);
                    }
                    bills.children.push(itemChac);
                }
                //创建工作内容节点
                if (job.length > 0) {
                    let jobContent = new JobContent();
                    for (let j of job) {
                        let data = j.replace(/^\d+\.{1}/, '').trim();
                        let content = new Content(data);
                        jobContent.children.push(content);
                    }
                    bills.children.push(jobContent);
                }
            }
            loadFeatureContent();
            /*
             * 加载定额子目
             * @param {Array}rationData(清单项目下定额数据) {Array}rationGljData(定额的人材机数据) {Object}decimal(项目小数位数)
             * @return {Object}
             * */
            function loadRation(rationData, rationGljData) {
                let viewCode = rationData.code;
                if (rationData.prefix) {
                    viewCode = rationData.prefix + viewCode;
                }
                if (rationData.adjustState) {
                    viewCode += '换';
                }
                let rationSource = {
                    viewCode: viewCode,
                    name: rationData.name,
                    unit: rationData.unit,
                    libCode: '',
                    code: rationData.code,
                    subType: 1,
                    quantity: rationData.quantity,
                    quantityEXP: rationData.quantityEXP,
                    fees: rationData.fees,
                    isSubcontract: rationData.isSubcontract,
                    remark: rationData.remark
                };
                let ration = new Ration(rationSource);
                //创建工料分析
                let gljAnalyze = new GljAnalyze();
                ration.children.push(gljAnalyze);
                //定额人材机排序
                rationGljData = gljUtil.sortRationGLJ(rationGljData);
                for (let rGlj of rationGljData) {
                    let gljSource = {
                        code: rGlj.code,
                        quantity: rGlj.quantity,
                        totalQuantity: gljUtil.getTotalQuantity(rGlj,  rationData, decimal.glj.quantity, decimal.ration.quantity)
                    };
                    let gljContent = new GljContent(gljSource);
                    gljAnalyze.children.push(gljContent);
                }
                //创建费用组成
                let feeContent = new FeeContent({fees: rationData.fees});
                ration.children.push(feeContent);
                return ration;
            }
            //加载组价内容
            let rationData = allRation.filter(x => x.billsItemID === node.data.ID);
            if (rationData.length > 0) {
                let priceContent = new PriceContent();
                bills.children.push(priceContent);
                //加载定额子目
                rationData.sort((x, y) => x.serialNo - y.serialNo); //定额排序
                for (let rData of rationData) {
                    let rationGlj = allRationGlj.filter(x => x.rationID === rData.ID);
                    priceContent.children.push(loadRation(rData, rationGlj));
                }
            }
            return bills;
        }
        /*
        * 加载分部分项清单
        *  @param {Object}detail
        *  @return {Object || NULL}
        * */
        function loadFBFX(detail) {
            let fbfxBills = new FBFXBills();
            let subEngNode = detail.Bills.tree.roots.find((node) => getNodeFlag(node) === fixedFlag.SUB_ENGINERRING);
            if (!subEngNode) {
                failList.push('不存在分部分项清单');
                return fbfxBills;
            }
            if (subEngNode.children.length === 0) {
                failList.push('分部分项清单下必须要有清单分部或清单项目');
            }
            for (let node of subEngNode.children) {
                if (node.data.type === billType.FB) {
                    if (node.children.length === 0) {
                        failList.push('清单分部下至少要有一条清单项目');
                    }
                    //创建清单分部节点
                    let fbSource = {
                        code: node.data.code,
                        name: node.data.name,
                        fees: node.data.fees,
                        remark: node.data.remark
                    };
                    let fbBills = new FBBills(fbSource);
                    fbfxBills.children.push(fbBills);
                    //创建清单项目节点
                    for (let subNode of node.children) {
                        let fx = loadBills(subNode, detail.Ration.datas, detail.ration_glj.datas, curPMData.tender.property.decimal);
                        fbBills.children.push(fx);
                    }
                } else {
                    let fxBills = loadBills(node, detail.Ration.datas, detail.ration_glj.datas, curPMData.tender.property.decimal);
                    fbfxBills.children.push(fxBills);
                }
            }
            return fbfxBills;
        }
        /*
        * 加载措施项目清单
        * @param {Object}detail
        * @return {Object}
        * */
        function loadCSXM(detail) {
            let measureNode = detail.Bills.tree.roots.find((node) => getNodeFlag(node) === fixedFlag.MEASURE);
            if (!measureNode) {
                failList.push('不存在措施项目清单');
                return new element('措施项目清单', []);
            }
            let csxmBills = new CSXMBills({fees: measureNode.data.fees});
            //加载组织措施清单
            let zzcsNode = detail.Bills.tree.items.find(node => getNodeFlag(node) === fixedFlag.CONSTRUCTION_ORGANIZATION);
            if (zzcsNode) {
                let zzcsBills = new ZZCSBills({fees: zzcsNode.data.fees});
                csxmBills.children.push(zzcsBills);
                loadZZCS(zzcsBills, zzcsNode.children);
            }
            //加载技术措施清单
            let jscsNode = detail.Bills.tree.items.find(node => getNodeFlag(node) === fixedFlag.CONSTRUCTION_TECH);
            let maxDepth = 2;   //技术措施清单最多深度是2层：技术措施分类-清单项目
            if (jscsNode) {
                let jscsBills = new JSCSBills({fees: jscsNode.data.fees});
                csxmBills.children.push(jscsBills);
                let isValidDepth = validDepth(maxDepth, jscsNode);
                if (!isValidDepth) {
                    failList.push('技术措施清单子项超过两层');
                } else {
                    loadJSCS(jscsBills, jscsNode.children);
                }
            }
            return csxmBills;
            function loadZZCS(parent, nodes) {
                for (let node of nodes) {
                    if (node.children.length > 0) {    //组织措施分类
                        let classSource = {
                            code: node.data.code,
                            name: node.data.name,
                            fees: node.data.fees,
                            remark: node.data.remark
                        };
                        let zzcsClass = new ZZCSClass(classSource);
                        parent.children.push(zzcsClass);
                        loadZZCS(zzcsClass, node.children);
                    } else {    //公式计算措施项
                        let source = {
                            code: node.data.code,
                            name: node.data.name,
                            calcBase: node.data.calcBase,
                            feeRate: node.data.feeRate,
                            fees: node.data.fees,
                            remark: node.data.remark,
                            feeType: FEE_TYPE[fixedFlag.CONSTRUCTION_ORGANIZATION]
                        };
                        let formula = new FormulaCalcMeasure(source);
                        parent.children.push(formula);
                    }
                }
            }
            function loadJSCS(parent, nodes) {
                for (let node of nodes) {
                    if (node.children.length > 0) {    //技术措施分类
                        let classSource = {
                            code: node.data.code,
                            name: node.data.name,
                            fees: node.data.fees
                        };
                        let jscsClass = new JSCSClass(classSource);
                        parent.children.push(jscsClass);
                        loadJSCS(jscsClass, node.children);
                    } else {    //清单项目
                        parent.children.push(loadBills(node, detail.Ration.datas, detail.ration_glj.datas, curPMData.tender.property.decimal));
                    }
                }
            }
        }
        /*
        * 加载其他项目清单，要出现此节点，需要遵循标准条件(至少含有一条相关明细)
        * @param {Object}detail
        * @return {Object || Null}
        * */
        function loadOtherBills(detail) {
            let otherNode = detail.Bills.tree.roots.find(node => getNodeFlag(node) === fixedFlag.OTHER);
            if (otherNode.children.length === 0) {
                return null;
            }
            //其他项目清单元素
            let otherEle = new OtherBills();
            //添加暂列金额元素
            let provisionalNode = detail.Bills.tree.items.find(node => getNodeFlag(node) === fixedFlag.PROVISIONAL);
            if (provisionalNode && provisionalNode.children.length > 0) {
                otherEle.children.push(loadProvisional(provisionalNode));
            }
            //添加专业工程暂估价元素
            let engEstimateNode = detail.Bills.tree.items.find(node => getNodeFlag(node) === fixedFlag.ENGINEERING_ESITIMATE);
            if (engEstimateNode && engEstimateNode.children.length > 0) {
                otherEle.children.push(loadEngEstimate(engEstimateNode));
            }
            //添加计日工元素
            let dayWorkNode = detail.Bills.tree.items.find(node => getNodeFlag(node) === fixedFlag.DAYWORK);
            let dayWorkEle = new DayWorkItem({fees: dayWorkNode.data.fees});
            if (dayWorkNode && dayWorkNode.children.length > 0) {
                //要显示计日工元素，人工、材料、施工机械，最少有一条含有子项（计日工项目）
                let filterNodes = dayWorkNode.children.filter(node => [fixedFlag.LABOUR, fixedFlag.MATERIAL, fixedFlag.MACHINE].includes(getNodeFlag(node)));
                for (let fNode of filterNodes) {
                    let ele,
                        constraints;
                    let flag = getNodeFlag(fNode);
                    if (flag === fixedFlag.LABOUR) {
                        ele = new Labour();
                        constraints = curTenderEle.constraints.labourDayWorkCode;
                    } else if (flag === fixedFlag.MATERIAL) {
                        ele = new Material();
                        constraints = curTenderEle.constraints.materialDayWorkCode;
                    } else if (flag === fixedFlag.MACHINE) {
                        ele = new Machine();
                        constraints = curTenderEle.constraints.machineDayWorkCode;
                    }
                    if (fNode.children.length > 0) {
                        let isValidDepth = validDepth(1, fNode);
                        if (!isValidDepth) {
                            failList.push(`计日工${ele.name}子项超过一层`);
                        } else {
                            for (let itemNode of fNode.children) {
                                ele.children.push(loadDayWorkItem(itemNode, constraints, `${ele.name}计日工项目编号`));
                            }
                            dayWorkEle.children.push(ele);
                        }
                    }
                }
                //如果计日工下有计日工项目，则显示计日工元素
                if (dayWorkEle.children.length > 0) {
                    otherEle.children.push(dayWorkEle);
                }
            }
            //添加总承包服务费元素
            let tkcNode = detail.Bills.tree.items.find(node => getNodeFlag(node) === fixedFlag.TURN_KEY_CONTRACT);
            if (tkcNode && tkcNode.children.length > 0) {  //必须要有子项才显示总承包服务费元素
                let isValidDepth = validDepth(2, tkcNode);  //最多2层子项：总承包服务费分类-总承包服务费费用项
                if (!isValidDepth) {
                    failList.push('总承包服务费子项超过两层');
                } else {
                    let tkcEle = new TurnKeyContract({fees: tkcNode.data.fees});
                    otherEle.children.push(tkcEle);
                    loadService(tkcEle, tkcNode.children);
                }
            }
            //添加索赔计价汇总元素
            let claimNode = detail.Bills.tree.items.find(node => getNodeFlag(node) === fixedFlag.CLAIM);
            if (claimNode && claimNode.children.length > 0) {   //必须要有子项才能显示索赔计价汇总元素
                let claimEle = new element('索赔计价汇总', []);
                for (let n of claimNode.children) {
                    claimEle.children.push(new ClaimVisaFeeItem(n.data));
                }
                otherEle.children.push(claimEle);
            }
            //添加现场签证计价汇总元素
            let visaNode = detail.Bills.tree.items.find(node => getNodeFlag(node) === fixedFlag.VISA);
            if (visaNode && visaNode.children.length > 0) {     //必须要有子项才能显示现场签证计价汇总元素
                let visaEle = new element('现场签证计价汇总', []);
                for (let n of visaNode.children) {
                    visaEle.children.push(new ClaimVisaFeeItem(n.data));
                }
                otherEle.children.push(visaEle);
            }
            //添加其他元素
            let posetriy = getPosterity(otherNode);
            let subOtherEle = loadOthers(posetriy);
            if (subOtherEle) {
                otherEle.children.push(subOtherEle);
            }
            //必须有有效子项，才能显示其他项目清单元素
            return otherEle.children.length > 0 ? otherEle : null;
            //加载暂列金额
            function loadProvisional(node) {
                let provisionalEle = new Provisional({fees: node.data.fees});
                //暂列金额最多只有一层子节点
                let isValidDepth = validDepth(1, node);
                if (!isValidDepth) {
                    failList.push('暂列金额子项超过一层');
                } else {    //加载暂列金额明细
                    for (let n of node.children) {
                        let pDetailSource = {
                                code: n.data.code,
                                name: n.data.name,
                                unit: n.data.unit,
                                fees: n.data.fees,
                                remark: n.data.remark
                            },
                            pDetailEle = new ProvisionalDetail(pDetailSource);
                        //暂列金额明细编号在单位工程中唯一
                        checkUnique(curTenderEle.constraints.provisionalDetailCode, pDetailSource.code, '暂列金额明细编号');
                        provisionalEle.children.push(pDetailEle);
                    }
                }
                return provisionalEle;
            }
            //加载专业工程暂估价
            function loadEngEstimate(node) {
                let engEstimateEle = new EngEstimate({fees: node.data.fees});
                //专业工程暂估价最多只有一层子节点
                let isValidDepth = validDepth(1, node);
                if (!isValidDepth) {
                    failList.push('专业工程暂估价子项超过一层');
                } else {    //加载专业工程暂估明细
                    for (let n of node.children) {
                        let eDetailSource = {
                                code: n.data.code,
                                name: n.data.name,
                                engineeringContent: n.data.engineeringContent,
                                fees: n.data.fees,
                                remark: n.data.remark
                            },
                            eDetailEle = new EngEstimateDetail(eDetailSource);
                        //暂列金额明细编号在单位工程中唯一
                        checkUnique(curTenderEle.constraints.engEstimateDetailCode, eDetailSource.code, '专业工程暂估明细编号');
                        engEstimateEle.children.push(eDetailEle);
                    }
                }
                return engEstimateEle;
            }
            //加载计日工项目
            function loadDayWorkItem(node, constraints, hint) {
                let source = {
                    code: node.data.code,
                    name: node.data.name,
                    unit: node.data.unit,
                    quantity: node.data.quantity,
                    fees: node.data.fees,
                    remark: node.data.remark
                };
                checkUnique(constraints, source.code, hint);
                return new DayWorkItem(source);
            }
            //加载服务费项
            function loadService(parent, nodes) {
                for (let node of nodes) {
                    if (node.children.length > 0) {    //总承包服务费分类
                        let classSource = {
                            code: node.data.code,
                            name: node.data.name,
                            remark: node.data.remark
                        };
                        let tkcClass = new TurnKeyContractClass(classSource);
                        parent.children.push(tkcClass);
                        loadService(tkcClass, node.children);
                    } else {    //总承包服务费费用项
                        let source = {
                            code: node.data.code,
                            serviceContent: node.data.serviceContent,
                            feeRate: node.data.feeRate,
                            fees: node.data.fees,
                            remark: node.data.remark
                        };
                        parent.children.push(new TurnKeyContractItem(source));
                    }
                }
            }
            //加载其他列项，不符合上述情况的，其他所有清单子项
            function loadOthers(nodes) {
                //排除项
                let exclusionFlags = [
                    fixedFlag.PROVISIONAL,
                    fixedFlag.ENGINEERING_ESITIMATE,
                    fixedFlag.LABOUR,
                    fixedFlag.MATERIAL,
                    fixedFlag.MACHINE,
                    fixedFlag.TURN_KEY_CONTRACT,
                    fixedFlag.CLAIM,
                    fixedFlag.VISA
                ];
                //生成其他列项
                let otherItems = [],
                    summaryFee = 0;
                for (let node of nodes) {
                    let belongFlag = belongToFlag(node);
                    if (node.children.length > 0 || (belongFlag && exclusionFlags.includes(belongFlag))) {
                        continue;
                    }
                    //汇总其他列项金额
                    let totalFee = getFee(node.data.fees, 'common.totalFee');
                    summaryFee = scMathUtil.roundForObj(summaryFee + totalFee, curPMData.tender.property.decimal.bills.totalPrice);
                    let otherItemEle = new OtherItem({
                        code: node.data.code,
                        name: node.data.name,
                        calcBase: node.data.calcBase,
                        feeRate: node.data.feeRate,
                        commonTotalFee: totalFee,
                        remark: node.data.remark
                    });
                    otherItems.push(otherItemEle);
                    checkUnique(curTenderEle.constraints.otherItemNo, node.data.code, '其他列项编号');
                }
                let otherEle = new Other({commonTotalFee: summaryFee});
                for (let ele of otherItems) {
                    otherEle.children.push(ele);
                }
                return otherEle.children.length > 0 ? otherEle : null;  //有其他列项才能显示其他元素
            }

        }
        /*
        * 加载规费和税金清单，固定显示：规费、税金、增值税、附加税、环境保护税这几个清单
        * @param {Object}detail
        * @return {Object}
        * */
        function loadChargeTax(detail) {
            let chargeTaxEle = new ChargeTaxBills();
            let filterFlags = [
                fixedFlag.CHARGE,
                fixedFlag.TAX,
                fixedFlag.ADDED_VALUE_TAX,
                fixedFlag.ADDITIONAL_TAX,
                fixedFlag.ENVIRONMENTAL_PROTECTION_TAX
            ];
            let fitlerNodes = detail.Bills.tree.items.filter(node => filterFlags.includes(getNodeFlag(node)));
            for (let node of fitlerNodes) {
                let mainTreeNode = detail.mainTree.getNodeByID(node.data.ID),
                    serialNo = mainTreeNode ? mainTreeNode.serialNo() + 1 : 1;
                let source = {
                    code: node.data.code,
                    rowCode: `F${serialNo}`,
                    name: node.data.name,
                    calcBase: node.data.calcBase,
                    feeRate: node.data.feeRate,
                    fees: node.data.fees,
                    feeType: FEE_TYPE[getNodeFlag(node)],
                    remark: node.data.remark
                };
                //序号唯一
                checkUnique(curTenderEle.constraints.feeItemNo, source.code, '规费和税金费用项编号');
                chargeTaxEle.children.push(new FeeItem(source));
            }
            return chargeTaxEle;
        }
        /*
        * 加载主要清单明细
        * @param {Obejct}parent(设置到的父项:主要清单汇总元素) {Object}detail
        * @return {void}
        * */
        function loadMainBillsItems(parent, detail) {
            let mainBills = detail.Bills.datas.filter(data => data.mainBills);
            for (let bills of mainBills) {
                let source = {
                    code: bills.code,
                    name: bills.name,
                    unit: bills.unit,
                    quantity: bills.quantity,
                    fees: bills.fees,
                    remark: bills.remark
                };
                let mainBillsItemEle = new MainBillsItem(source);
                //主要清单明细项目编码唯一
                checkUnique(curTenderEle.constraints.mainBillsCode, source.code, '主要清单明细项目编码');
                parent.children.push(mainBillsItemEle);
            }
        }
        /*
        * 加载人材机汇总
        * @param {Object}detail
        * @return {Object}
        * */
        function loadGlj(detail) {
            let gljList = detail.projectGLJ.datas.gljList;
            if (gljList.length > 0) {
                //创建人材机汇总节点
                let gljSummary = new GljSummary();
                //人材机节点
                let allGljs = gljUtil.sortRationGLJ(gljList); //人材机汇总排序
                //计算总消耗量
                gljUtil.calcProjectGLJQuantity(detail.projectGLJ.datas,
                    detail.ration_glj.datas, detail.Ration.datas, detail.Bills.datas, curPMData.tender.property.decimal.glj.quantity, _, scMathUtil);
                for (let glj of allGljs) {
                    let price = gljUtil.getGLJPrice(glj, detail.projectGLJ.datas,
                        curPMData.tender.property.calcOptions, detail.labourCoe.datas, curPMData.tender.property.decimal, false, _, scMathUtil);
                    let gljSource = {
                        code: glj.code,
                        name: glj.name,
                        spec: glj.spec,
                        unit: glj.unit,
                        orgCode: glj.original_code,
                        is_evaluate: glj.is_evaluate,
                        basePrice: price.base,
                        marketPrice: price.marketPrice,
                        quantity: glj.quantity,
                        originPlace: glj.originPlace,
                        vender: glj.vender,
                        qualityGrace: glj.qualityGrace,
                        brand: glj.brand,
                        remark: glj.remark
                    };
                    let gljEle = new Glj(gljSource);
                    //人材机代码唯一
                    checkUnique(curTenderEle.constraints.gljCode, gljSource.code, '人材机代码');
                    //人材机配比
                    let connectKey = gljUtil.getIndex(glj, gljKeyArray),
                        ratioData = detail.projectGLJ.datas.mixRatioMap[connectKey];
                    if (ratioData && Array.isArray(ratioData)) {
                        for (let ratio of ratioData) {
                            let gljRatio = new GljRatio({code: ratio.code, quantity: ratio.consumption});
                            gljEle.children.push(gljRatio);
                        }
                    }
                    gljSummary.children.push(gljEle);
                }
                return gljSummary;
            }
        }
        //开始标签
        function startTag(ele) {
            let rst = `<${ele.name}`;
            for (let attr of ele.attrs) {
                rst += ` ${attr.name}="${attr.value}"`;
            }
            rst += ele.children.length > 0 ? '>' : '/>';
            return rst;
        }
        //结束标签
        function endTag(ele) {
            return `</${ele.name}>`;
        }
        //拼接成xml字符串
        function toXMLStr(eles) {
            let rst = '';
            for (let ele of eles) {
                rst += startTag(ele);
                if (ele.children.length > 0) {
                    rst += toXMLStr(ele.children);
                    rst += endTag(ele);
                }
            }
            return rst;
        }
        //格式化xml字符串
        function formatXml(text) {
            //去掉多余的空格
            text = '\n' + text.replace(/>\s*?</g, ">\n<");
            //调整格式
            let rgx = /\n(<(([^\?]).+?)(?:\s|\s*?>|\s*?(\/)>)(?:.*?(?:(?:(\/)>)|(?:<(\/)\2>)))?)/mg;
            let nodeStack = [];
            let output = text.replace(rgx, function($0, all, name, isBegin, isCloseFull1, isCloseFull2, isFull1, isFull2){
                let isClosed = (isCloseFull1 === '/') || (isCloseFull2 === '/' ) || (isFull1 === '/') || (isFull2 === '/');
                let prefix = '';
                if (isBegin === '!') {
                    prefix = getPrefix(nodeStack.length);
                } else {
                    if (isBegin !== '/') {
                        prefix = getPrefix(nodeStack.length);
                        if (!isClosed) {
                            nodeStack.push(name);
                        }
                    } else {
                        nodeStack.pop();
                        prefix = getPrefix(nodeStack.length);
                    }
                }
                let ret =  '\n' + prefix + all;
                return ret;
            });
            let outputText = output.substring(1);
            return outputText;
            function getPrefix(prefixIndex) {
                let span = '    ';
                let output = [];
                for (let i = 0 ; i < prefixIndex; ++i) {
                    output.push(span);
                }
                return output.join('');
            }
        }
        /*
         * 导出数据
         * @param {Number}tenderID(当前界面的单位工程ID，后台根据这个单位工程，去找其建设项目下所有数据)
         * @return {void}
         * */
        this.toXml = async function (tenderID) {
            let eleData = await loadProject(tenderID);
            if (!eleData) {
                return;
            }
            //转换成xml字符串
            let xmlStr = toXMLStr([eleData]);
            //加上xml声明
            xmlStr = `<?xml version="1.0" encoding="utf-8"?>${xmlStr}`;
            //格式化
            xmlStr = formatXml(xmlStr);
            let blob = new Blob([xmlStr], {type: 'text/plain;charset=uft-8'});
            saveAs(blob, '重庆标准交换数据.xml');
        }
    }
})();