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

/**
 *
 *
 * @author Zhong
 * @date 2019/6/24
 * @version
 */

/*
* 广东建设工程政府投资项目造价数据标准3.0
* */
const XMLStandard = (function () {
    // 广东18的导出文件中，需要把建设项目和单位工程文件分开
    // 数据类别，辨别提取的数据，哪份是以建设项目为根元素，哪份以单位工程为根元素
    const DATA_TYPE = {
        'project': 1,
        'tender': 2,
    };
    // 建设性质
    const ConstructionType = {
        '新建': '1',
        '扩建': '2',
        '改建': '3',
        '修缮': '4',
        '修复': '5',
        '维护保养': '6',
        '其他': '9',
    };
    // 造价类型
    const CostType = {
        '投资估算': '1',
        '设计概算': '2',
        '施工图预算': '3',
        '招标工程量清单': '4',
        '招标控制价（最高投标限价）': '5',
        '投标报价': '6',
        '签约合同价': '7',
        '竣工结算价': '8',
    };
    // 软件中的文件类型与造假类型映射
    const FileKind = {
        '1': '6', // 投标
        '2': '4', // 招标
        '3': '5', // 控制价
    };
    // 计价模式
    const ValuationModel = {
        'bill': '1', // 清单计价
        'ration': '2', // 定额计价
    };
    // 地区类别
    const AreaKind = {
        '一类地区': '1',
        '二类地区': '2',
        '三类地区': '3',
        '四类地区': '4',
    };
    // 专业类别
    const Specialty = {
        '房屋建筑与装饰工程': '1',
        '仿古建筑': '2',
        '通用安装工程': '3',
        '市政工程': '4',
        '园林绿化': '5',
        '矿山': '6',
        '构筑物': '7',
        '城市轨道交通工程': '8',
        '爆破': '9',
        '装饰装修': '10',
        '市政交通设施': '11',
        '市政养护': '12',
        '修缮': '13',
        '环卫': '14',
        '古建筑': '15',
        '节能': '16',
        '抗震加固': '17',
        '绿色建筑': '18',
        '工业建筑': '19',
        '地下管廊': '20',
        '装配式建筑': '21',
        '营造林': '22',
        '修复': '23',
        '其他': '99',
    };
    // 需要用到的费用字典，用固定类别来映射
    // 数据节选自标准pdf文件《《建设工程政府投资项目造价数据标准》信息公开版》，附录C-费用名称与费用代号
    // 若映射表中没有映射关系，则费用字典取名称首字母
    const FeeCodeMap = {
        // 分部分项工程，分部分项工程的子项，取项目名称的首字母拼接
        [fixedFlag.SUB_ENGINERRING]: 'QDF',
        // 措施项目
        [fixedFlag.MEASURE]: 'CSF',
        // 其他项目
        [fixedFlag.OTHER]: 'QTF',
        // 措施项目的子项
        [fixedFlag.GREEN_MEASURE_FEE]: 'AQWMSGF', // 绿色施工安全防护措施费
        [fixedFlag.OTHER_MEASURE_FEE]: 'QTCSF', // 其他措施费
        // 其他项目的子项
        [fixedFlag.PROVISIONAL]: 'ZLF', // 暂列金额
        [fixedFlag.ESTIMATE]: 'ZGJ', // 暂估价
        [fixedFlag.MATERIAL_PROVISIONAL]: 'ZGC', // 材料（工程设备）暂估价
        [fixedFlag.ENGINEERING_ESITIMATE]: 'ZGGC', // 专业工程暂估价
        [fixedFlag.DAYWORK]: 'LXF', // 计日工
        [fixedFlag.TURN_KEY_CONTRACT]: 'ZCBFWF', // 总承包服务费
        [fixedFlag.BUDGET_INCLUDE_WORK_FEE]: 'YSBGF', // 预算包干费
        [fixedFlag.PROJECT_HIGH_QUALITY_FEE]: 'GCYZF', // 工程优质费
        [fixedFlag.BUDGET_ESTIMATE_DIFF]: 'GSFDC', // 概算幅度差
        [fixedFlag.CLAIM]: 'SPFY', // 索赔费用
        [fixedFlag.VISA]: 'XCQZFY', // 现场签证
        [fixedFlag.OTHER_FEE]: 'QTFY', // 其他费用
        // 税金
        [fixedFlag.TAX]: 'SJ',
        // 工程造价
        [fixedFlag.ENGINEERINGCOST]: 'ZZJ',

    };
    // 章节类型
    const ChapterKind = {
        '章': '1',
        '节': '2',
        '细目': '3',
        '其他': '4',
    };
    // 汇总类型
    const SummrayKind = {
        'summary': '1',
        'notSummary': '2',
    };
    // 清单子目类型
    const BillsKind = {
        FBFX: '1',
        '模板及支架': '2',
        '脚手架': '3',
        '现场围挡': '4',
        '防尘降噪绿色施工防护': '5',
        OTHERS: '6',
    };
    // 取费类型
    const CalcKind = {
        '地上工程': '1',
        '地下明(盖)挖工程': '2',
        '地下暗挖工程': '3',
        '盾构工程': '4',
        '轨道工程': '5',
        '通信工程': '6',
        '信号工程': '7',
        '供电工程': '8',
        '智能与控制系统工程': '9',
        '机电工程': '10',
        '其他': '15',
    };
    // 费用归属
    const CostKind = {
        '建筑工程费': '1',
        '安装工程费': '2',
        '其他': '3',
    };
    // 计算方式
    const CalcType = {
        'quantityMulTotalUnitPrice': '1', // 工程量×综合单价
        'formulaAddFeeRate': '2', // 计算基数×费率
        'quantityMulUnitPrice': '3', // 工程量×单价
    };
    // 降效类型 建筑装饰工程定额超高降效费用计算标记
    const EfficiencyKind = {
        'baseReduction': '1', // 降效基础定额
        'notReduction': '2', // 非降效定额
        'marketPriceReduction': '3', // 按市场价计算降效费用定额
        'rationPriceReduction': '4', // 按定额价计算降效费用定额
    };
    // 子目增加费类型 安装工程定额子目增加费的费用计算标记
    const IncFeeKind = {
        'subBase': '1', // 子目增加费基础定额
        'notSubBase': '2', // 非子目增加费定额
        'subCalc': '3', // 子目增加费用计算定额
    };
    // 工料机类型
    const GLJKind = {
    };
    // 供料方式
    const Provider = {
    }

    // 通用设置和工具
    const _base = XML_EXPORT_BASE;
    const _config = _base.CONFIG;
    const _type = _config.TYPE;
    const _util = _base.UTIL;
    const _cache = _base.CACHE;

    /*
     * 提取数据入口
     * @param  {String}userID 用户ID
     *         {Number}exportKind 导出类型（投标1、招标2、控制价3
     *         {Object}projectData 项目数据（项目自身的数据、建设、单项、单位的数据(projects表的数据)，不包含详细的清单定额等数据）
     * @return {Array} [{data: Object, exportKind: Number, fileName: String}]
     * */
    async function entry(userID, exportKind, projectData) {
        // name为导出的xml节点属性名称 dName为可能需要显示给用户属性时使用的名称，比如自检提示的时候用，这里只有required为true时需要设置dName

        // 获取工程类型：枚举单位工程的工程专业+费用标准，用“；”分隔
        function getProjectType(projectData) {
            // 工程类型 工程专业+费用标准
            return projectData.children.reduce((acc, eng) => {
                const tenderProjectTypeArr = eng.children.reduce((acc, tender) => {
                    const engineeringName = tender.property.engineeringName.replace('工程', '');
                    const feeStandardName = tender.property.feeStandardName;
                    acc.push(`${engineeringName}${feeStandardName}`);
                    return acc;
                }, []);
                acc.push(...tenderProjectTypeArr);
                return acc;
            }, []).join(';');
        }

        // 获取费用字典
        function getFeeCode(data) {
            const flag = data.flagsIndex && data.flagsIndex.fixed ? data.flagsIndex.fixed.flag : null;
            const name = data.name || '';
            return FeeCodeMap[flag] || pinyinUtil.getFirstLetter(name);
        }

        // 获取定额册 取定额编号开头字母后面、-前面的数字，没有则取0
        // 如: A2-1-1 则册为2
        function getVolume(code) {
            if (!code) {
                return '0';
            }
            const reg = /^[A-Za-z](\d+)(?=-)/;
            const rst = reg.exec(code);
            return rst ? rst[1] : '0';
        }

        // 获取定额章 取定额编号第一个-和第二个-之间的数字
        // 如: A1-2-3 则章为2
        function getChapter(code) {
            if (!code) {
                return '0';
            }
            const reg = /^[A-Za-z]\d+-(\d+)(?=-)/;
            const rst = reg.exec(code);
            return rst ? rst[1] : '0';
        }

        // 建设项目
        function ConstructionProject(projectData) {
            const basicInformation = projectData.property.basicInformation;
            const attrs = [
                // 项目编号
                {
                    name: 'Number', dName: '项目编号', required: true,
                    value: ''
                },
                // 项目名称
                {
                    name: 'Name', dName: '项目名称', required: true,
                    value: projectData.name
                },
                // 工程类别
                {
                    name: 'ProjectCategory', dName: '工程类别', required: true,
                    value: _util.getValueByKey(basicInformation, 'projectCategory')
                },
                // 工程类型
                {
                    name: 'ProjectType', dName: '工程类型', required: true,
                    value: getProjectType(projectData)
                },
                // 建设性质
                {
                    name: 'ConstructionType', type: _type.INT, enumeration: Object.keys(ConstructionType),
                    value: ConstructionType[_util.getValueByKey(basicInformation, 'constructionType')]
                },
                // 文件类型
                {
                    name: 'FileKind', dName: '造价类型', type: _type.INT, required: true, enumeration: Object.keys(CostType),
                    value: FileKind[exportKind]
                },
                // 计价模式
                {
                    name: 'ValuationModel', dName: '计价模式', type: _type.INT, required: true,
                    value: ValuationModel.bill
                },
                // 计税模式
                {
                    name: 'TaxModel', dName: '计税模式', type: _type.INT, required: true,
                    value: projectData.property.taxType
                },
                // 地区类别
                {
                    name: 'AreaKind', dName: '地区类别', type: _type.INT, required: true, enumeration: Object.keys(AreaKind),
                    value: _util.getValueByKey(basicInformation, 'regionalCategories')
                },
                // 工程地点
                {
                    name: 'ProjectSite',
                    value: _util.getValueByKey(basicInformation, 'projLocation')
                },
                // 建设单位
                {
                    name: 'BuildUnit', dName: '建设单位', required: true,
                    value: _util.getValueByKey(basicInformation, 'constructingUnits')
                },
                // 建设单位法定代表人或其授权人
                {
                    name: 'BulidAuthorizer',
                    value: _util.getValueByKey(basicInformation, 'constructingUnitsPerson')
                },
                // 数据交换标准名称
                {
                    name: 'StandardName', required: true,
                    value: '建设工程政府投资项目造价数据标准'
                },
                // 数据交换标准编号
                {
                    name: 'StandardNumber', required: true,
                    value: 'DBJ/T XX-XX-2018'
                },
                // 建设（编制）范围
                {
                    name: 'RangeOfCompilation',
                    value: _util.getValueByKey(basicInformation, 'rangeOfCompilation')
                },
                // 建设规模
                {
                    name: 'Scale', dName: '工程规模', type: _type.DECIMAL, required: true,
                    value: _util.getValueByKey(basicInformation, 'projectScale')
                },
                // 建设规模单位
                {
                    name: 'Unit', dName: '建设规模单位', required: true,
                    value: _util.getValueByKey(basicInformation, 'unit')
                },
                // 技术经济指标（元） 取单方造价
                {
                    name: 'TechnicalAndEconomicIndex', type: _type.DECIMAL,
                    value: summaryInfo.perCost
                },
                // 总说明 编制说明
                {
                    name: 'Explains',
                    value: projectData.property.compilationIllustration
                }
            ];
            //唯一约束
            this.constraints = {
                billsCode: [],  //清单项目项目编码(xsd中没体现，通过跟pm沟通得知)
            };
            _base.Element.call(this, 'ConstructionProject', attrs);
        }
        // 系统信息
        function SystemInfo({ ID1, ID2, makeDate }) {
            const attrs = [
                // 编制软件信息
                { name: 'ID1', value: ID1 },
                // 编制机器硬件信息，不输出
                { name: 'ID2', value: ID2 },
                // 文件生成时间
                {
                    name: 'MakeDate', dName: '文件生成时间', type: _type.DATE_TIME, required: true,
                    value: makeDate
                }
            ];
            _base.Element.call(this, 'SystemInfo', attrs);
        }
        // 工程信息
        function ConstructionInfo() {
            _base.Element.call(this, 'ConstructionInfo', []);
        }
        // 费用精度
        function Option() {
            const attrs = [
                // 工料机消耗量、含量、用量类小数精度
                {
                    name: 'ResPrecision', type: _type.INT, required: true,
                    value: 4
                },
                // 工程量、数量类小数精度
                {
                    name: 'QuantityPrecision', type: _type.INT, required: true,
                    value: 3
                },
                // 金额、合价、费用类小数精度
                {
                    name: 'CostPrecision', type: _type.INT, required: true,
                    value: 2
                },
                // 费率、指数、比例（%）类小数精度
                {
                    name: 'RatePrecision', type: _type.INT, required: true,
                    value: 3
                }
            ];
            _base.Element.call(this, 'Option', attrs);
        }
        // 估（概、预、结）算信息
        function ProjectInfo(basicInformation, summaryInfo) {
            const attrs = [
                // 设计单位
                { name: 'Designer', value: _util.getValueByKey(basicInformation, 'designUnits') },
                // 承包单位
                { name: 'Contractor', value: _util.getValueByKey(basicInformation, 'constructionUnits') },
                // 编制单位
                {
                    name: 'CompileCompany', dName: '编制单位', required: true,
                    value: _util.getValueByKey(basicInformation, 'establishUnit') || '无'
                },
                // 编制单位法定代表人或其授权人
                { name: 'Authorizer', value: _util.getValueByKey(basicInformation, 'constructingUnitsPerson') },
                // 编制人
                { name: 'Compiler', value: _util.getValueByKey(basicInformation, 'establishUnitAuthor') },
                // 编制人资格证书编号
                { name: 'CompilerCertNo', value: _util.getValueByKey(basicInformation, 'establishDate') },
                // 编制时间
                {
                    name: 'CompileDate', dName: '编制时间', required: true,
                    value: 'todo',
                },
                // 审核人
                { name: 'Examiner', value: _util.getValueByKey(basicInformation, 'auditUnitAuditor') },
                // 审核人资格证书编号
                { name: 'ExaminerCertNo', value: _util.getValueByKey(basicInformation, 'ExaminerCertNo') },
                // 审核时间
                { name: 'ExamineDate', value: _util.getValueByKey(basicInformation, 'auditDate') },
                // 审定人
                { name: 'Approver', value: _util.getValueByKey(basicInformation, 'Approver') },
                // 审定人资格证书编号
                { name: 'ApproverCertNo', value: _util.getValueByKey(basicInformation, 'ApproverCertNo') },
                // 审定时间
                { name: 'ApproverDate', value: _util.getValueByKey(basicInformation, 'ApproverDate') },
                // 工程总价（元）
                {
                    name: 'Total', dName: '工程总价', type: _type.DECIMAL, required: true,
                    value: summaryInfo.engineeringCost || '0'
                }
            ];
            _base.Element.call(this, 'ProjectInfo', attrs);
        }
        // 招标信息 工程量清单、招标控制价时输出
        function TendereeInfo(basicInformation) {
            const attrs = [
                // 招标人
                {
                    name: 'TendereeName', dName: '招标人', required: true,
                    value: _util.getValueByKey(basicInformation, 'bidInviter')
                },
                // 招标单位法定代表人或其授权人
                {
                    name: 'TenderAuthorizer',
                    value: _util.getValueByKey(basicInformation, 'tenderRepresentative')
                },
                // 招标单位编制人
                {
                    name: 'TenderCompiler',
                    value: _util.getValueByKey(basicInformation, 'TenderCompiler')
                },
                // 招标单位编制人资格证书编号
                {
                    name: 'TenderCompilerCertNo',
                    value: _util.getValueByKey(basicInformation, 'TenderCompilerCertNo')
                },
                // 招标单位编制时间
                {
                    name: 'TenderCompileDate',
                    value: _util.getValueByKey(basicInformation, 'TenderCompileDate')
                },
                // 招标单位审核人
                {
                    name: 'TenderExaminer',
                    value: _util.getValueByKey(basicInformation, 'TenderExaminer')
                },
                // 招标单位审核人资格证书编号
                {
                    name: 'TenderExaminerCertNo',
                    value: _util.getValueByKey(basicInformation, 'TenderExaminerCertNo')
                },
                // 招标单位审核时间
                {
                    name: 'TenderExamineDate',
                    value: _util.getValueByKey(basicInformation, 'TenderExamineDate')
                },
                // 招标单位审定人
                {
                    name: 'TenderApprover',
                    value: _util.getValueByKey(basicInformation, 'TenderApprover')
                },
                // 招标单位审定人资格证书编号
                {
                    name: 'TenderApproverCertNo',
                    value: _util.getValueByKey(basicInformation, 'TenderApproverCertNo')
                },
                // 招标单位审定时间
                {
                    name: 'TenderApproveDate',
                    value: _util.getValueByKey(basicInformation, 'TenderApproveDate')
                },
                // 招标代理 不得为空，如无招标代理，则应填写“无”。
                {
                    name: 'Proxy', dName: '招标代理',
                    value: _util.getValueByKey(basicInformation, 'Proxy'), required: true
                },
                // 招标代理资质证书编号
                {
                    name: 'ProxyCertNo',
                    value: _util.getValueByKey(basicInformation, 'ProxyCertNo')
                },
                // 招标代理法定代表人或其授权人
                {
                    name: 'ProxyAuthorizer',
                    value: _util.getValueByKey(basicInformation, 'ProxyAuthorizer')
                },
                // 招标代理编制人员
                {
                    name: 'ProxyCompiler',
                    value: _util.getValueByKey(basicInformation, 'ProxyCompiler')
                },
                // 招标代理编制人员资格证书编号
                {
                    name: 'ProxyCompilerCertNo',
                    value: _util.getValueByKey(basicInformation, 'ProxyCompilerCertNo')
                },
                // 招标代理编制时间
                {
                    name: 'ProxyCompileDate',
                    value: _util.getValueByKey(basicInformation, 'ProxyCompileDate')
                },
                // 招标代理审核人
                {
                    name: 'ProxyExaminer',
                    value: _util.getValueByKey(basicInformation, 'ProxyExaminer')
                },
                // 招标代理审核人资格证书编号
                {
                    name: 'ProxyExaminerCertNo',
                    value: _util.getValueByKey(basicInformation, 'ProxyExaminerCertNo')
                },
                // 招标代理审核时间
                {
                    name: 'ProxyExamineDate',
                    value: _util.getValueByKey(basicInformation, 'ProxyExamineDate')
                },
                // 招标代理审定人
                {
                    name: 'ProxyApprover',
                    value: _util.getValueByKey(basicInformation, 'ProxyApprover')
                },
                // 招标代理审定人资格证书编号
                {
                    name: 'ProxyApproverCertNo',
                    value: _util.getValueByKey(basicInformation, 'ProxyApproverCertNo')
                },
                // 招标代理审定时间
                {
                    name: 'ProxyApproveDate',
                    value: _util.getValueByKey(basicInformation, 'ProxyApproveDate')
                },
                // 造价咨询 、Consultant（造价咨询）：不得为空，如无则应填写“无”。
                {
                    name: 'Consultant', dName: '造价咨询', required: true,
                    value: _util.getValueByKey(basicInformation, 'Consultant')
                },
                // 造价咨询资质证书编号
                {
                    name: 'ConsultantCertNo',
                    value: _util.getValueByKey(basicInformation, 'ConsultantCertNo')
                },
                // 造价咨询法定代表人或其授权人
                {
                    name: 'ConsultantAuthorizer',
                    value: _util.getValueByKey(basicInformation, 'ConsultantAuthorizer')
                },
                // 造价咨询编制人
                {
                    name: 'ConsultantCompiler',
                    value: _util.getValueByKey(basicInformation, 'ConsultantCompiler')
                },
                // 造价咨询编制人资格证书
                {
                    name: 'ConsultantCompilerCertNo',
                    value: _util.getValueByKey(basicInformation, 'ConsultantCompilerCertNo')
                },
                // 造价咨询编制时间
                {
                    name: 'ConsultantCompileDate',
                    value: _util.getValueByKey(basicInformation, 'ConsultantCompileDate')
                },
                // 造价咨询审核人
                {
                    name: 'ConsultantExaminer',
                    value: _util.getValueByKey(basicInformation, 'ConsultantExaminer')
                },
                // 造价咨询审核人资格证书编号
                {
                    name: 'ConsultantExaminerCertNo',
                    value: _util.getValueByKey(basicInformation, 'ConsultantExaminerCertNo')
                },
                // 造价咨询审核时间
                {
                    name: 'ConsultantExamineDate',
                    value: _util.getValueByKey(basicInformation, 'ConsultantExamineDate')
                },
                // 造价咨询审定人
                {
                    name: 'ConsultantApprover',
                    value: _util.getValueByKey(basicInformation, 'ConsultantApprover')
                },
                // 造价咨询审定人资格证书编号
                {
                    name: 'ConsultantApproverCertNo',
                    value: _util.getValueByKey(basicInformation, 'ConsultantApproverCertNo')
                },
                // 造价咨询审定时间
                {
                    name: 'ConsultantApproveDate',
                    value: _util.getValueByKey(basicInformation, 'ConsultantApproveDate')
                },
                // 招标控制价（元）
                {
                    name: 'TenderSumLimit', dName: '招标控制价', type: _type.DECIMAL, required: true,
                    value: 'todo'
                }
            ];
            _base.Element.call(this, 'TendereeInfo', attrs);
        }
        // 投标信息
        function BidderInfo(basicInformation, summaryInfo) {
            const attrs = [
                // 投标人
                {
                    name: 'BidName', dName: '投标人', required: true,
                    value: _util.getValueByKey(basicInformation, 'bidName')
                },
                // 投标单位法定代表人或其授权人
                {
                    name: 'BidAuthorizer',
                    value: _util.getValueByKey(basicInformation, 'bidAuthorizer')
                },
                // 投标总价（元）
                {
                    name: 'BidAuthorizer', dName: '投标总价', type: _type.DECIMAL, required: true,
                    value: summaryInfo.engineeringCost
                },
                // 投标单位编制人
                {
                    name: 'BidCompiler',
                    value: _util.getValueByKey(basicInformation, 'bidCompiler')
                },
                // 投标单位编制人资格证书编号
                {
                    name: 'BidCompilerCertNo',
                    value: _util.getValueByKey(basicInformation, 'BidCompilerCertNo')
                },
                // 投标单位编制时间
                {
                    name: 'BidCompileDate',
                    value: _util.getValueByKey(basicInformation, 'bidCompileDate')
                },
                // 投标单位审核人
                {
                    name: 'BidExaminer',
                    value: _util.getValueByKey(basicInformation, 'bidExaminer')
                },
                // 投标单位审核人资格证书编号
                {
                    name: 'BidExaminerCertNo',
                    value: _util.getValueByKey(basicInformation, 'bidExaminerCertNo')
                },
                // 投标单位审核时间
                {
                    name: 'BidExamineDate',
                    value: _util.getValueByKey(basicInformation, 'bidExamineDate')
                },
                // 投标单位审定人
                {
                    name: 'BidApprover',
                    value: _util.getValueByKey(basicInformation, 'bidApprover')
                },
                // 投标单位审定人资格证书
                {
                    name: 'BidApproverCertNo',
                    value: _util.getValueByKey(basicInformation, 'bidApproverCertNo')
                },
                // 投标单位审定时间
                {
                    name: 'BidApproveDate',
                    value: _util.getValueByKey(basicInformation, 'BidApproveDate')
                }
            ];
            _base.Element.call(this, 'BidderInfo', attrs);
        }
        // 费用汇总
        function SummaryOfCost(summaryInfo) {
            const attrs = [
                // 工程造价（元）
                {
                    name: 'Total', type: _type.DECIMAL,
                    value: summaryInfo.engineeringCost
                },
                // 建筑工程费
                {
                    name: 'Construction', type: _type.DECIMAL,
                    value: '0'
                },
                // 安装工程费
                {
                    name: 'Installation', type: _type.DECIMAL,
                    value: '0',
                },
                // 分部分项工程费
                {
                    name: 'DivisionalAndElementalWorks', type: _type.DECIMAL,
                    value: summaryInfo.subEngineering
                },
                // 措施项目费
                {
                    name: 'Preliminaries', type: _type.DECIMAL,
                    value: summaryInfo.measure
                },
                // 绿色施工安全防护措施费
                {
                    name: 'CostForHSE', type: _type.DECIMAL,
                    value: summaryInfo.safetyConstruction
                },
                // 其他措施费
                {
                    name: 'OtherPreliminaries', type: _type.DECIMAL,
                    value: 'todo'
                },
                // 其他项目费
                {
                    name: 'SundryCosts', type: _type.DECIMAL,
                    value: summaryInfo.other
                },
                // 暂列金额
                {
                    name: 'ProvisionalSums', type: _type.DECIMAL,
                    value: summaryInfo.provisional
                },
                // 暂估价材料
                {
                    name: 'ProvisionalMaterial', type: _type.DECIMAL,
                    value: summaryInfo.materialProvisional
                },
                // 专业工程暂估价
                {
                    name: 'SpecialtyProvisionalPrice', type: _type.DECIMAL,
                    value: summaryInfo.engineeringEstimate
                },
                // 计日工费用
                {
                    name: 'DayWorkRate', type: _type.DECIMAL,
                    value: summaryInfo.daywork
                },
                // 总承包服务费
                {
                    name: 'MainContractorAttendance', type: _type.DECIMAL,
                    value: summaryInfo.turnKeyContract
                },
                // 索赔费用
                {
                    name: 'ClaimForLossAndExpenses', type: _type.DECIMAL,
                    value: summaryInfo.claim
                },
                // 现场签证费用
                {
                    name: 'SiteInstruction', type: _type.DECIMAL,
                    value: summaryInfo.visa
                },
                // 规费
                {
                    name: 'StatutoryFees', type: _type.DECIMAL,
                    value: '0'
                },
                // 税金
                {
                    name: 'Tax', type: _type.DECIMAL,
                    value: summaryInfo.tax
                },
                // 人工费
                {
                    name: 'Labor', type: _type.DECIMAL,
                    value: 'todo'
                },
                // 材料费
                {
                    name: 'Material', type: _type.DECIMAL,
                    value: 'todo'
                },
                // 设备费
                {
                    name: 'Equipment', type: _type.DECIMAL,
                    value: 'todo'
                },
                // 主材设备费
                {
                    name: 'MainMaterialEquipment', type: _type.DECIMAL,
                    value: 'todo'
                },
                // 主材费
                {
                    name: 'MainMaterial', type: _type.DECIMAL,
                    value: 'todo'
                },
                // 机械费
                {
                    name: 'Machine', type: _type.DECIMAL,
                    value: 'todo'
                },
                // 管理费
                {
                    name: 'Overhead', type: _type.DECIMAL,
                    value: 'todo'
                },
                // 利润
                {
                    name: 'Profit', type: _type.DECIMAL,
                    value: 'todo'
                },
            ];
            _base.Element.call(this, 'SummaryOfCost', attrs);
        }
        // 建筑安装工程费
        function ProjectInstallationWorkCost(projectData, summaryInfo) {
            const basicInformation = projectData.property.basicInformation;
            const attrs = [
                // 工程编号
                {
                    name: 'Number',
                    value: ''
                },
                // 工程名称
                {
                    name: 'Name', required: true,
                    value: projectData.name
                },
                // 金额 (元)
                {
                    name: 'Total', type: _type.DECIMAL,
                    value: summaryInfo.engineeringCost
                },
                // 建设规模
                {
                    name: 'Scale', type: _type.DECIMAL, required: true,
                    value: _util.getValueByKey(basicInformation, 'projectScale')
                },
                // 建设规模单位
                {
                    name: 'Unit', required: true,
                    value: _util.getValueByKey(basicInformation, 'todo')
                },
                // 占总投资比例（%）
                {
                    name: 'Ratios', type: _type.DECIMAL,
                    value: '0.00'
                },
            ];
            _base.Element.call(this, 'ProjectInstallationWorkCost', attrs);
        }
        // 单项工程
        function SectionWorks({ name, total, rate }) {
            const attrs = [
                // 工程编号
                {
                    name: 'Number',
                    value: ''
                },
                // 工程名称
                {
                    name: 'Name', required: true,
                    value: name
                },
                // 金额
                {
                    name: 'Total', type: _type.DECIMAL,
                    value: total
                },
                // 建设规模 单项工程没有填写的地方，输出“0”
                {
                    name: 'Scale', dName: '建设规模', type: _type.DECIMAL, required: true,
                    value: '0'
                },
                // 建设规模单位 单项工程没有填写的地方，输出和"m2"
                {
                    name: 'Unit', dName: '建设规模单位', required: true,
                    value: 'm2'
                },
                // 占总投资比例（%）
                {
                    name: 'Ratios', type: _type.DECIMAL,
                    value: rate
                },
                // 费用代号
                {
                    name: 'Code', type: _type.DECIMAL,
                    value: ''
                },
            ];
            _base.Element.call(this, 'SectionWorks', attrs);
        }
        // 单位工程
        function UnitWorks(projectData, tenderData, summaryInfo) {
            const basicInformation = projectData.property.basicInformation;
            const projectFeature = tenderData.property.projectFeature;
            const attrs = [
                // 工程编号
                {
                    name: 'Number', required: true,
                    value: ''
                },
                // 工程名称
                {
                    name: 'Name', required: true,
                    value: tenderData.name
                },
                // 标段 取建设项目名称
                {
                    name: 'Segment',
                    value: projectData.name
                },
                // 工程类别
                {
                    name: 'ProjectCategory', required: true,
                    value: _util.getValueByKey(basicInformation, 'projectCategory')
                },
                // 工程类型
                {
                    name: 'ProjectType', required: true,
                    value: getProjectType(projectData)
                },
                // 计价模式
                {
                    name: 'ValuationModel', type: _type.INT, required: true,
                    value: VALUATION_MODEL.bill
                },
                // 计税模式
                {
                    name: 'TaxModel', type: _type.INT, required: true,
                    value: tenderData.property.taxType
                },
                // 地区类别 取建设项目-基本信息-地区类别
                {
                    name: 'AreaKind', type: _type.INT, required: true,
                    value: _util.getValueByKey(basicInformation, 'regionalCategories')
                },
                // 金额
                {
                    name: 'Total', type: _type.DECIMAL,
                    value: summaryInfo.engineeringCost
                },
                // 专业类别
                {
                    name: 'Specialty', type: _type.INT,
                    value: Specialty[tenderData.property.engineeringName]
                },
                // 工程用途
                {
                    name: 'Purposes',
                    value: ''
                },
                //建设（编制）范围
                {
                    name: 'RangeOfCompilation',
                    value: ''
                },
                // 建设规模 取单位工程-工程特征-建设规模
                {
                    name: 'Scale', type: _type.DECIMAL, required: true,
                    value: _util.getValueByKey(projectFeature, 'buildScale')
                },
                // 建设规模单位
                {
                    name: 'Unit', required: true,
                    value: 'todo'
                },
                // 占总投资比例（%）
                {
                    name: 'Ratios', type: _type.DECIMAL,
                    value: src.summaryInfo.rate
                },
                // 清单数据库，没有则填写 “无”
                {
                    name: 'BillDataBase', required: true,
                    value: '工程量清单规范(2013广东)',
                },
                // 定额数据库，没有则填写 “无”，后续获取详细数据(getTenderDetail)的时候填上
                {
                    name: 'NormDataBase', required: true,
                    value: '无'
                },
                // 人工材料设备价格文件，没有则填写 “无”
                {
                    name: 'ResInfoPricingFile', required: true,
                    value: '无'
                },
                // 总说明
                {
                    name: 'Explains',
                    value: tenderData.property.compilationIllustrationProject
                },
                // 导出XML文件名，工程编号+工程名称.xml, 暂时取“名称.xml”，用户设置完工程编号后修改此值
                {
                    name: 'FileName',
                    value: `${tenderData.name}.xml`
                },
                // 备注
                {
                    name: 'Remark',
                    value: ''
                },
            ];
            _base.Element.call(this, 'UnitWorks', attrs);
        }
        // 工程特征信息 AttrInfo， 补充信息AddiInfo
        function Info(eleName) {
            _base.Element.call(this, eleName, []);
        }
        // 工程特征信息明细 AttrInfoItem， 补充信息明细AddiInfoItem
        function InfoItem(eleName, attr) {
            const attrs = [
                {
                    name: 'Name', required: true,
                    value: attr.dispName,
                },
                { name: 'Value', value: attr.value },
            ];
            if (attr.code) {
                attrs.push({ name: 'Code', value: attr.code });
            }
            if (attr.remark) {
                attrs.push({ name: 'Remark', value: attr.remark });
            }
            _base.Element.call(this, eleName, attrs);
        }
        // 单位工程费用汇总
        function UnitWorksSummary() {
            _base.Element.call(this, 'UnitWorksSummary', []);
        }
        // 单位工程费用汇总标题
        function UnitWorksSummaryGroup(bills) {
            const attrs = [
                // 费用编号
                { name: 'Number', value: bills.code },
                // 费用名称
                {
                    name: 'Name', required: true,
                    value: bills.name
                },
                // 单位
                { name: 'Unit', value: bills.unit },
                // 工程量
                {
                    name: 'Quantity', type: _type.DECIMAL,
                    value: bills.quantity
                },
                // 金额
                {
                    name: 'Total', type: _type.DECIMAL,
                    value: _util.getFee(bills.fees, 'common.totalFee')
                },
                // 技术经济指标（元） 取综合单价
                {
                    name: 'TechnicalAndEconomicIndex', type: _type.DECIMAL,
                    value: _util.getFee(bills.fees, 'common.unitFee')
                },
                //章节类型
                {
                    name: 'ChapterKind', type: _type.INT, required: true,
                    value: '4'
                },
                // 费用代号
                {
                    name: 'Code', type: _type.INT, required: true,
                    value: getFeeCode(bills)
                },
                // 汇总类型
                {
                    name: 'Kind', type: _type.INT, required: true,
                    value: '1'
                },
                // 备注
                { name: 'Remark', value: bills.remark }
            ];
            _base.Element.call(this, 'UnitWorksSummaryGroup', attrs);
        }
        // 单位工程费汇总明细
        function UnitWorksSummaryItem(bills) {
            const attrs = [
                { name: 'Number', value: bills.code },
                {
                    name: 'Name', required: true,
                    value: bills.name
                },
                { name: 'Unit', value: bills.unit },
                {
                    name: 'Quantity', type: _type.DECIMAL,
                    value: bills.quantity
                },
                // 计算基数：可由费用代号、数字、四则运算符号、小括号组成
                {
                    name: 'QtyFormula', type: _type.DECIMAL,
                    value: 'todo'
                },
                // 费率
                {
                    name: 'Rate', type: _type.DECIMAL,
                    value: commonUtil.isDef(bills.feeRate) ? bills.feeRate : '100'
                },
                {
                    name: 'Total', type: _type.DECIMAL,
                    value: _util.getFee(bills.fees, 'common.totalFee')
                },
                // 技术经济指标（元）
                {
                    name: 'TechnicalAndEconomicIndex', type: _type.DECIMAL,
                    value: _util.getFee(bills.fees, 'common.unitFee')
                },
                //章节类型
                {
                    name: 'ChapterKind', type: _type.INT, required: true,
                    value: '4'
                },
                // 费用代号
                {
                    name: 'Code', type: _type.INT, required: true,
                    value: getFeeCode(bills)
                },
                // 汇总类型
                {
                    name: 'Kind', type: _type.INT, required: true,
                    value: '1'
                },
                // 备注
                { name: 'Remark', value: bills.remark }
            ];
            _base.Element.call(this, 'UnitWorksSummaryItem', attrs);
        }
        // 分部分项工程
        function DivisionalAndElementalWorks() {
            _base.Element.call(this, 'DivisionalAndElementalWorks', []);
        }
        // 合计费用
        function SummaryOfBasicCost(items, bills) {
            // 省略了一些
            const attrs = [
                // 人工费
                {
                    name: 'Labor', type: _type.DECIMAL,
                    value: _util.getFee(bills.fees, 'labour.totalFee')
                },
                // 材料费
                {
                    name: 'Material', type: _type.DECIMAL,
                    value: _util.getFee(bills.fees, 'material.totalFee')
                },
                // 主材费
                {
                    name: 'MainMaterial', type: _type.DECIMAL,
                    value: _util.getFee(bills.fees, 'mainMaterial.totalFee')
                },
                // 主材设备费
                {
                    name: 'MainMaterialEquipment', type: _type.DECIMAL,
                    value: 'todo'
                },
                // 暂估价
                {
                    name: 'Appraisal', type: _type.DECIMAL,
                    value: 'todo'
                },
                // 机械费
                {
                    name: 'Machine', type: _type.DECIMAL,
                    value: _util.getFee(bills.fees, 'machine.totalFee')
                },
                // 管理费
                {
                    name: 'Overhead', type: _type.DECIMAL,
                    value: _util.getFee(bills.fees, 'manage.totalFee')
                },
                // 利润
                {
                    name: 'Profit', type: _type.DECIMAL,
                    value: _util.getFee(bills.fees, 'profit.totalFee')
                },
                // 分部分项工程费
                {
                    name: 'DivisionalAndElementalWorks', type: _type.DECIMAL,
                    value: _util.getFeeByFlag(items, fixedFlag.SUB_ENGINERRING, 'mainMaterial.totalFee')
                },
                // 措施项目费
                { 
                    name: 'Preliminaries', type: _type.DECIMAL,
                    value: _util.getFeeByFlag(items, fixedFlag.MEASURE, 'mainMaterial.totalFee')
                },
                // 绿色施工安全防护措施费
                { 
                    name: 'CostForHSE',type: _type.DECIMAL, 
                    value: _util.getFeeByFlag(items, fixedFlag.GREEN_MEASURE_FEE, 'mainMaterial.totalFee')
                },
                // 其他项目费
                { 
                    name: 'SundryCosts', type: _type.DECIMAL,
                    value: _util.getFeeByFlag(items, fixedFlag.OTHER_MEASURE_FEE, 'mainMaterial.totalFee')
                },
                // 暂列金额
                { 
                    name: 'ProvisionalSums', type: _type.DECIMAL,
                    value: _util.getFeeByFlag(items, fixedFlag.PROVISIONAL, 'mainMaterial.totalFee')
                },
                // 规费
                { 
                    name: 'StatutoryFees', type: _type.DECIMAL,
                    value: '0'
                },
                // 税金
                { 
                    name: 'Tax', type: _type.DECIMAL,
                    value: _util.getFeeByFlag(items, fixedFlag.TAX, 'mainMaterial.totalFee')
                },
            ];
            _base.Element.call(this, 'SummaryOfBasicCost', attrs);
        }
        // 分部工程
        function DivisionalWorks(bills) {
            const attrs = [
                // 编码
                { name: 'Number', value: bills.code },
                // 名称
                { 
                    name: 'Name', required: true, 
                    value: bills.name 
                },
                // 特征
                { name: 'Attr', value: '' },
                // 单位
                { name: 'Unit', value: bills.unit },
                // 工程量
                { 
                    name: 'Quantity', type: _type.DECIMAL, 
                    value: bills.quantity 
                },
                // 综合合价
                { 
                    name: 'Total', type: _type.DECIMAL, 
                    value: _util.getFee(bills.fees, 'common.totalFee') 
                },
                // 综合单价
                { 
                    name: 'TechnicalAndEconomicIndex', type: _type.DECIMAL,
                    value: _util.getFee(bills.fees, 'common.unitFee') 
                },
                // 章节类型
                { 
                    name: 'ChapterKind', type: _type.INT, required: true,
                    value: '4'
                },
                // 费用字典，拼音首字母
                { name: 'Code', value: getFeeCode(bills)},
                // 备注
                { name: 'Remark', value: bills.remark }
            ];
            _base.Element.call(this, 'DivisionalWorks', attrs);
        }
        // 清单项目
        function WorkElement(bills, kind, specialty) {
            const attrs = [
                // 项目编码
                { name: 'Number', required: true, value: bills.code || ''},
                // 项目名称
                { name: 'Name', required: true, value: bills.name },
                // 项目特征
                { name: 'Attr', value: bills.itemCharacterText },
                // 工作内容
                { name: 'WorkContent', value: bills.jocContentText },
                // 计量单位
                { name: 'Unit', required: true, value: bills.unit },
                // 工程量
                { name: 'Quantity', type: _type.DECIMAL, value: bills.quantity },
                // 计算基数
                { name: 'QtyFormula', type: _type.DECIMAL, value: 'todo' },
                // 单价（元）
                { name: 'Price', type: _type.DECIMAL, value: _util.getFee(bills.fees, 'common.unitFee') },
                // 设备单价（元）指清单项目所采用设备的综合单价
                { name: 'EquipmentPrice', type: _type.DECIMAL, value: _util.getFee(bills.fees, 'equipment.unitFee') },
                // 最低限价（元）
                { name: 'PriceLow', type: _type.DECIMAL, value: 'todo' },
                // 最高限价（元）
                { name: 'PriceHigh', type: _type.DECIMAL, value: bills.maxPrice },
                // 费率（%）
                { name: 'Rate', type: _type.DECIMAL, value: bills.feeRate },
                // 合价（元）
                { name: 'Total', type: _type.DECIMAL, value: _util.getFee(bills.fees, 'common.totalFee') },
                // 主要清单
                { name: 'Total', type: _type.BOOL, value: !!bills.mainBills },
                // 子目类型
                { name: 'Kind', type: _type.INT, required: true, value: kind },
                // 取费类型
                { name: 'CalculationKind', type: _type.INT, required: true, value: '1' },
                // 费用归属
                { name: 'CostKind', type: _type.INT, required: true, value: '1' },
                // 计算方式 todo
                { name: 'CalcType', type: _type.INT, required: true, value: '1' },
                // 专业类型
                { name: 'Specialty', type: _type.INT, value: specialty },
                // 清单标识
                { name: 'ListingIdentity', value: 'GB50500-2013 1 GD' },
                // 费用代号
                { name: 'Code', value: getFeeCode(bills) },
                // 备注
                { name: 'Remark', value: bills.remark }
            ];
            _base.Element.call(this, 'WorkElement', attrs);
        }
        // 工程量计算表
        function ExpressElement(src) {
            const attrs = [
                // 序号
                { name: 'OrderNumber', value: 'todo', required: true },
                // 工程量计算式
                { name: 'Express', value: 'todo', required: true },
                // 工程量
                { name: 'Quantity', value: 'todo', required: true },
                // 汇总类型
                { name: 'Kind', value: 'todo', type: _type.INT, required: true },
                { name: 'Remark', value: src.remark }
            ];
            _base.Element.call(this, 'ExpressElement', attrs);
        }
        // 工序内容
        function WorkContent(contentText, fee) {
            const attrs = [
                // 定额工作内容
                { name: 'Name', required: true, value: contentText },
                // 取此工作内容下定额子目/量价/定额同级人材机的综合合价之和
                { name: 'Total', type: _type.DECIMAL, value: fee },
                { name: 'Remark', value: '' }
            ];
            _base.Element.call(this, 'WorkContent', attrs);
        }
        // 定额子目
        function Norm(ration, kind, specialty) {
            const attrs = [
                // 定额编码
                { name: 'Number', required: true, value: ration.code },
                { name: 'Name', required: true, value: ration.name },
                { name: 'Unit', required: true, value: ration.unit },
                { name: 'Quantity', type: _type.DECIMAL, value: ration.quantity },
                // 单价
                { name: 'Price', type: _type.DECIMAL, value: _util.getFee(ration.fees, 'common.unitFee') },
                // 合价
                { name: 'Total', type: _type.DECIMAL, value: _util.getFee(src.fees, 'common.totalFee') },
                // 是否定额
                { name: 'IsNorm', type: _type.Bool, required: true, value: 'true' },
                // 子目类型
                { name: 'Kind', type: _type.INT, required: true, value: kind },
                // 取费类型 todo
                { name: 'CalculationKind', type: _type.INT, required: true, value: '1' },
                // 费用归属
                { name: 'CostKind', type: _type.INT, required: true, value: '1' },
                // 降效类型
                { 
                    name: 'EfficiencyKind', type: _type.INT, 
                    value: ration.type === rationType.overHeight ? EfficiencyKind.baseReduction : EfficiencyKind.notReduction
                },
                // 子目增加费类型
                { name: 'IncFeeKind', type: _type.INT, value: 'todo' },
                // 换算说明
                { name: 'Conversion', value: 'todo' },
                // 专业类别
                { name: 'Specialty', type: _type.INT, value: specialty },
                //定额标识（定额库编码）
                { name: 'NormIdentity', value: 'todo' },
                // 册 定额书没有分册填写0，有分册的按册号填写
                { name: 'Volume', type: _type.INT, value: getVolume(ration.code) },
                // 章
                { name: 'Chapter', type: _type.INT, value: getChapter(ration.code)},
                { name: 'Remark', value: ration.remark }
            ];
            _base.Element.call(this, 'Norm', attrs);
        }

        // 建设项目节点
        let constructionProjectEle = null;

        /*
        * 加载数据，分两种数据类型
        * 1.建设项目
        * 2.建设项目下单位工程
        * @param  {Object}项目数据
        * @return {Array}
        * */
        async function loadData(projectData) {
            // 提取出的数据
            const extractData = [];
            // 建设项目部分
            constructionProject = await loadConstructionProject(projectData);
            extractData.push({
                data: constructionProject,
                dataType: DATA_TYPE.project,
                exportKind,
                fileName: 'Project.xml'
            });
            // 单位工程部分
            // 提取出单位工程级别的项目数据
            const tenderData = projectData.children.reduce((acc, cur) => {
                if (Array.isArray(cur.children)) {
                    acc.push(...cur.children)
                }
                return acc;
            }, []);
            // 获取单位工程详细结构
            const isPlainTender = false;
            const tenders = await loadTender(projectData.summaryInfo, tenderData, isPlainTender);
            tenders.forEach(tender => {
                // 单位工程文件名为@_单位工程编码_单位工程名称.xml
                // 因为单位工程编码后续用户可能会改变，这里暂时将fileName设置成单位工程名称.xml
                const name = tender.attrs.find(attr => attr.name === 'Name');
                extractData.push({
                    data: tender,
                    dataType: DATA_TYPE.tender,
                    exportKind,
                    fileName: `${name}.xml`
                })
            });
            return extractData;
        }

        /*
        * 加载建设项目
        * @param  {Object}项目数据
        * @return {Array}
        * */
        async function loadConstructionProject(projectData) {
            const summaryInfo = projectData.summaryInfo[projectData.ID];
            // 建设项目
            constructionProjectEle = new ConstructionProject(projectData);
            // 系统信息
            const systemInfo = new SystemInfo({
                // 软件相关信息进行base64编码
                ID1: Base64.encode(projectData.softInfo),
                ID2: _util.generateHardwareId(),
                makeDate: moment(Date.now()).format('YYYY-MM-DDTHH:mm:ss'),
            });
            // 工程信息
            const constructionInfo = loadConstructionInfo(projectData);
            // 费用汇总
            const summaryCost = new SummaryOfCost(summaryInfo);
            // 建筑安装工程费
            const projectInstall = new ProjectInstallationWorkCost(projectData, summaryInfo);
            // 单项工程
            const sectionalWorks = await loadEngineering(summaryInfo, projectData.children);
            projectInstall.children.push(...sectionalWorks);
            constructionProject.children.push(
                systemInfo,
                constructionInfo,
                summaryCost,
                projectInstall
            );
            return constructionProject;
        }

        // 加载工程信息相关元素
        function loadConstructionInfo(projectData) {
            const basicInformation = projectData.property.basicInformation;
            const summaryInfo = projectData.summaryInfo[projectData.ID];
            // 工程信息
            const constructionInfo = new ConstructionInfo();
            // 费用精度
            const option = new Option();
            // 估（概、预、结）算信息
            const projectInfo = new ProjectInfo(basicInformation, summaryInfo);
            let exportInfo;
            if (exportKind === _config.EXPORT_KIND.Bid) {
                // 招标信息
                exportInfo = new TendereeInfo(basicInformation);
            } else if (exportKind === _config.EXPORT_KIND.Tender) {
                // 投标信息
                exportInfo = new BidderInfo(basicInformation, summaryInfo);
            }
            constructionInfo.push(option, projectInfo, exportInfo);
            return constructionInfo;
        }

        /*
        * 加载所有单项工程元素
        * @param  {Object}summaryInfoMap 总的汇总价格映射表(与项目ID映射)
        *         {Array}engineeringData 所有单项工程项目数据
        * @return {Array}
        * */
        async function loadEngineering(summaryInfoMap, engineeringData) {
            const isPlainTender = true;
            const engineeringTasks = engineeringData.map(async engData => {
                const summaryInfo = summaryInfoMap[engData.ID];
                // 单项工程
                const sectionalWork = new SectionWorks({
                    name: engData.name,
                    total: summaryInfo.engineeringCost,
                    rate: summaryInfo.rate,
                });
                // 费用汇总
                const summaryCost = new SummaryOfCost(summaryInfo);
                // 简单结构的单位工程
                const tenders = await loadTender(summaryInfoMap, engData.children, isPlainTender);
                sectionalWork.push(summaryCost, ...tenders);
                return sectionalWork;
            });
            return await Promise.all(engineeringTasks);
        }

        /*
         * 加载所有单位工程元素
         * @param  {Object}summaryInfoMap 总的汇总价格映射表(与项目ID映射)
         *         {Array}tenderData 所有单项工程项目数据
         *         {Boolean}isPlain 是否简单结构(简单结构只含有UnitWorks，其下不含子元素)
         * @return {Array}
         * */
        let tenderDetail = null;
        async function loadTender(summaryInfoMap, tenderData, isPlain) {
            const basicInformation = projectData.property.basicInformation;
            const tenderTasks = tenderData.map(async tData => {
                const summaryInfo = summaryInfoMap[tData.ID];
                // 单位工程
                const unitWork = new UnitWorks(projectData, tData, summaryInfo);
                // 简单结构，不需要继续添加子元素
                if (isPlain) {
                    return unitWork;
                }
                // 不是简单结构，继续添加各种子元素
                // 工程特征信息
                const attrInfo = loadAttrInfo(tData.property.projectFeature);
                // 基本信息
                const addiInfo = loadAddiInfo(projectData.property.basicInformation);
                // 费用汇总
                const summaryOfCost = new SummaryOfCost(summaryInfo);
                // 获取单位工程详细数据
                tenderDetail = await _util.getTenderDetail(tData.ID, userID);
                // 单位工程费用汇总
            });
            return await Promise.all(tenderTasks);
        }

        // 加载工程特征信息
        // attrList 单位工程的工程特征，来自property.projectFeature
        function loadAttrInfo(attrList) {
            const attrInfo = new Info('AttrInfo');
            // 有值的才输出
            attrInfo.children = attrList
                .filter(attr => commonUtil.isDef(attr.value))
                .map(attr => new InfoItem('AttrInfoItem', attr));
            return attrInfo;
        }

        // 加载补充信息（基本信息所有条目）
        function loadAddiInfo(infoList) {
            const addiInfo = new Info('AddiInfo');
            addiInfo.children = infoList.map(rootInfoItem => {
                const rootInfo = new InfoItem('AddiInfoItem', rootInfoItem);
                rootInfo.children = rootInfoItem.items.map(infoItem => new InfoItem('AddiInfoItem', infoItem));
                return rootInfo;
            });
        }

        // 加载单位工程费用汇总
        // tenderDetail 单位工程详细数据
        function loadUnitWorksSummary(tenderDetail) {
            const unitWorksSummary = new UnitWorksSummary();
            // 读取单位工程中的固定类别为“分部分项工程”、“措施项目”、“其他项目”的大项费用
            // 分部分项
            const fbfx = tenderDetail.mainTree.roots.find(node => node.getFlag() === fixedFlag.SUB_ENGINERRING);
            const fbfxGroup = new UnitWorksSummaryGroup(fbfx.data);
            // 分部分项工程的子项，取项目名称的首字母拼接
            const fbfxChildren = fbfx.children.map(node => new UnitWorksSummaryItem(node.data));
            fbfxGroup.children.push(...fbfxChildren);
            // 措施项目
            const csxm = tenderDetail.mainTree.roots.find(node => node.getFlag() === fixedFlag.MEASURE);
            const csxmGroup = new UnitWorksSummaryGroup(csxm.data);
            // 措施项目的子项，“绿色施工安全防护措施费”、“其他措施费”
            const csxmChildren = csxm.getPosterity()
                .filter(node => [fixedFlag.GREEN_MEASURE_FEE, fixedFlag.OTHER_MEASURE_FEE].includes(node.getFlag()))
                .map(node => new UnitWorksSummaryItem(node.data));
            csxmGroup.children.push(...csxmChildren);
            // 其他项目
            const other = tenderDetail.mainTree.roots.find(node => node.getFlag() === fixedFlag.OTHER);
            const otherGroup = new UnitWorksSummaryGroup(other.data);
            // 其他项目子项，暂列金额；暂估价；材料（工程设备）暂估价；专业工程暂估价；计日工；总承包服务费；预算包干费；工程优质费；概算幅度差；索赔费用；现场签证费用；其他费用
            const otherChildrenFlags = [
                fixedFlag.PROVISIONAL,
                fixedFlag.ESTIMATE,
                fixedFlag.MATERIAL_PROVISIONAL,
                fixedFlag.ENGINEERING_ESITIMATE,
                fixedFlag.DAYWORK,
                fixedFlag.TURN_KEY_CONTRACT,
                fixedFlag.BUDGET_INCLUDE_WORK_FEE,
                fixedFlag.PROJECT_HIGH_QUALITY_FEE,
                fixedFlag.BUDGET_ESTIMATE_DIFF,
                fixedFlag.CLAIM,
                fixedFlag.VISA,
                fixedFlag.OTHER_FEE
            ];
            const otherChildren = other.getPosterity()
                .filter(node => otherChildrenFlags.includes(node.getFlag()))
                .map(node => new UnitWorksSummaryItem(node.data));
            otherGroup.chilren.push(...otherChildren);
            // 除固定类别为“分部分项工程”、“措施项目”、“其他项目”以外的大项费用，通常无子项，所以显示到Item中。（即使造价书有子项，也显示到Item中，不再列出其子项数据）
            const flags = [fixedFlag.SUB_ENGINERRING, fixedFlag.MEASURE, fixedFlag.OTEHER];
            const otherRoots = tenderDetail.mainTree.roots
                .filter(node => !flags.includes(node.getFlag()))
                .map(node => new UnitWorksSummaryItem(node.data));
            unitWorksSummary.push(fbfxGroup, csxmGroup, otherGroup, ...otherRoots);
            return unitWorksSummary;
        }

        // 加载分部分项工程
        function loadDivisionalAndElementalWorks(tenderDetail) {
            const division = new DivisionalAndElementalWorks();
            const fbfx = tenderDetail.mainTree.roots.find(node => node.getFlag === fixedFlag.SUB_ENGINERRING);
            const summaryCost = new SummaryOfBasicCost(tenderDetail.mainTree.items, fbfx.data);
        }
        
        // 加载分部分项清单，这部分是分部分项工程和措施项目共用的
        function loadFBFX(nodes, kind) {
            return nodes.map(node => {
                let ele;
                // 有子清单的是分部
                if (node.source.children.length) {
                    ele = new DivisionalWorks();
                    // 递归获取子元素
                    ele.children = loadFBFX(node.source.children);
                } else { // 无子清单的是分项
                    ele = loadBills(node.data, kind, specialty);
                }
                return ele;
            });
        }

        // 加载清单
        function loadBills(node, kind) {
            const specialty = Specialty[tenderDetail.property.engineeringName]; // 工程专业
            const workElement = new WorkElement(node.data, kind, specialty);
            const summaryCost = new SummaryOfBasicCost(tenderDetail.mainTree.items, node.data);
            // 相同工作内容的定额进行分组
            const workMap = _.groupBy(node.children, node => node.data.jobContentText || '');
            const workContents = Object.entries(workMap).map(([contentText, rationNodes]) => {
                const workContent = new WorkContent(contentText, _util.getAggregateFee(rationNodes));
                workContent.children = rationNodes.map(node => loadRation(node, kind, specialty));
            });
        }
        
        // 加载定额
        function loadRation(node, kind, specialty) {
            // 定额
            const norm = new Norm(node.data, kind, specialty);

        }
    }

    /*
     * 重置工程编号，广东18 3.0的接口，导出时的文件会用到这个编号
     * 因此重置工程编号后，还需要重置文件名数据
     * @param  {Array}codes 工程编号
     *         {Array}extractData 提取的数据
     * @return {void}
     * */
    function resetContentCode(codes, extractData) {
        // 提取到的数据分两种类型：
        // 1.根元素为建设项目：需要修改建设项目下的单位工程元素的编码和文件名
        // 2.根元素为单位工程：需要修改单位工程的编码和文件名
        // 获取建设项目数据下的单位工程元素
        const ExtractProjects = extractData.filter(data => data.dataType === DATA_TYPE.project);
        const tenders = ExtractProjects.map(extractP => {
            // 建设项目元素下建筑安装工程费元素
            const projectInstallations = _util.getElementFromSrc(extractP.data, 'ProjectInstallationWorkCost');
            // 建筑安装工程费元素下单项工程元素
            const sectionalWorks = projectInstallations.reduce((acc, cur) => {
                const sections = _util.getElementFromSrc(cur, 'SectionalWorks');
                acc.push(...sections);
            }, []);
            // 单项工程元素下单位工程元素
            return sectionalWorks.reduce((acc, cur) => {
                const tenders = _util.getElementFromSrc(cur, 'UnitWorks');
                acc.push(...tenders);
            }, []);
        });
        // 重置编号
        let idx = 0;
        for (let tender of tenders) {
            let codeItem = tender.attrs.find(attr => attr.name === '编号');
            codeItem.value = codes[idx++];
        }
    }
})();