YangHuCost/web/building_saas/standard_interface/export/shandong_common.js

// INTERFACE_EXPORT =，必须这么写，这样才能在导出时动态加载脚本后，覆盖前端代码
// 参考广东中山导出接口
INTERFACE_EXPORT = (() => {
    "use strict";
    const feeRateMap = {
      冬季施工增加费: "DJSGZJFFL",
      冬季施工: "DJSGZJFFL",
      雨季施工增加费: "YUJSGZJFFL",
      雨季施工: "YUJSGZJFFL",
      夜间施工增加费: "YEJSGZJFFL",
      夜间施工: "YEJSGZJFFL",
      高原地区施工增加费: "GYDQSGZJFFL",
      高原施工: "GYDQSGZJFFL",
      风沙地区施工增加费: "FSDQSGZJFFL",
      风沙施工: "FSDQSGZJFFL",
      沿海地区施工增加费: "YHDQSGZJFFL",
      沿海施工: "YHDQSGZJFFL",
      行车干扰施工增加费: "XCGRGCSGZJFFL",
      行车干扰: "XCGRGCSGZJFFL",
      工地转移费: "GDZYFFL",
      '工地转移(km)': "GDZYFFL",
      施工辅助费: "SGFZFFL",
      施工辅助: "SGFZFFL",
      基本费用: "JBFYFL",
      主副食运费补贴: "ZFSYFBTFL",
      '综合里程(km)': "ZFSYFBTFL",
      职工探亲路费: "ZGTQLFFL",
      职工探亲: "ZGTQLFFL",
      职工取暖补贴: "ZGQNBTFL",
      职工取暖: "ZGQNBTFL",
      财务费用: "CWFYFL",
      养老保险费: "YANGLBXFFL",
      失业保险费: "SYBXFFL",
      医疗保险费: "YILBXFFL",
      工伤保险费: "GSBXFL",
      养老保险: "YANGLBXFFL",
      失业保险: "SYBXFFL",
      医疗保险: "YILBXFFL",
      工伤保险: "GSBXFL",
      住房公积金: "ZFGJJFL",
      规费: "GFZHFL",
      利润: "LRL",
      税金: "SL",
      土方: "TF",
      石方: "SF",
      运输: "YS",
      路面: "LM",
      "路面(不计雨)": "LM",
      隧道: "SD",
      构造物I: "GZW1",
      "构造物I(不计冬)": "GZW1",
      "构造物I(不计雨)": "GZW1",
      构造物II: "GZW2",
      "构造物III(桥梁)": "GZW3",
      "构造物III(除桥以外)": "GZW3",
      "构造物III(除桥以外不计雨夜)": "GZW3",
      技术复杂大桥: "JSFZDQ",
      "钢材及钢结构(桥梁)": "GJG",
      "钢材及钢结构(除桥以外)": "GJG",
      "钢材及钢结构(除桥以外不计夜)": "GJG",
    };
  
    //计算程序有，这里没有:施工机械使用费\施工机械人工费\定额人工费\定额材料费\定额施工机械使用费
    const itemFeeMap = {
      'marketLabour': 'RGF',
      'marketMaterial': 'CLF',
      'marketMachine':'JXSYF',
      'marketEquipment': 'SBGZF',
      'direct': 'DEZJF',
      'equipment': 'DESBF',
      'marketDirect': 'ZJF',
      'measure': 'CSF',
      'measure1': 'CSF1',
      'measure2': 'CSF2',
      'manage': 'QYGLF',
      'force': 'GF',
      'profit': 'LR',
      'tax': 'SJ',
      'common': 'JAF',
      'rationCommon': 'DEJAF'
    };
  
    const feeLibNoMap = {
      'eba0e7c0-cfe6-11ea-ba15-739be477d1fe': 'GYSFL-000000-2018-86',
      '451d3180-e02e-11ea-8056-1514dfc2f39e': 'GYSFL-340000-2019-210',
      '32923ff0-e912-11ea-8b20-d93bc370e960': 'GYSFL-440000-2019-544'
    };
  
    const FixedCostMap = {
      //折旧费、检修费、维护费、安拆辅助费
      '折旧费': 1,
      '检修费': 1,
      '维护费': 1,
      '安拆辅助费':1
    }
  
    const RoadGradeMap = {
      "高速公路": "0",
      "一级公路": "1",
      "二级公路": "2",
      "三级公路": "3",
      "四级公路": "4",
      "等外公路": "5",
      "独立桥梁": "6",
      "独立隧道": "7"
    }
  
    const sectionNameMap = {
      "清单 第100章 总则": true,
      "清单 第200章 路基": true,
      "清单 第300章 路面": true,
      "清单 第400章 桥梁、涵洞": true,
      "清单 第500章 隧道": true,
      "清单 第600章 安全设施及预埋管线": true,
      "清单 第700章 绿化及环境保护设施": true,
      // "清单 第800章 机电工程": true,
      // "清单 第900章 附属区房建工程":true
    }
  
    const ListCodeMap = {
      "第100章至700章清单":"1",
      "清单 第100章 总则": "一",
      "清单 第200章 路基": "二",
      "清单 第300章 路面": "三",
      "清单 第400章 桥梁、涵洞": "四",
      "清单 第500章 隧道": "五",
      "清单 第600章 安全设施及预埋管线": "六",
      "清单 第700章 绿化及环境保护设施": "七",
      // "清单 第800章 机电工程": "八",
      // "清单 第900章 附属区房建工程": "九",
      "已包含在清单合计中的材料、工程设备、专业工程暂估价合计": "10",
      "清单合计减去材料、工程设备、专业工程暂估价合计": "11",
      "计日工合计": "12",
      "劳务": "12.1",
      "材料": "12.2",
      "机械": "12.3",
      "暂列金额(不含计日工总额)": "13",
      "投标报价": "14"
    } 
  
  
    const ratioCodeMap = { 
      "01ZJF":"0",
      "02JXF":"1",
      "03WHF":"2",
      "04ACFZF":"3"
    }
  
    function getBasePrice(projectGLJID, tenderProject) {
      let glj = _.find(tenderProject.projectGLJ.datas.gljList, {
        id: projectGLJID
      })
      return glj ? gljUtil.getBasePrice(glj, null, null, null, decimalObj, false, _, scMathUtil) : 0;
    }
  
  
  
    function getFeeRate(programID, fieldName, tenderProject) {
      let rate = 0;
      let template = tenderProject.calcProgram.compiledTemplates;
      if (template[programID]) {
        let item = _.find(template[programID].calcItems, {
          fieldName: fieldName
        })
        if (item) rate = item.feeRate;
      }
      return rate
    }
  
    function billNameChecking(bNode,projectName,fixedFlag) { 
      let data = bNode.data;
      let fail = null;
      let pass = true;
      if (data.flagsIndex && data.flagsIndex.fixed) {
        let flag = data.flagsIndex.fixed.flag;
        switch (flag) {
          case fixedFlag.ONE_SEVEN_BILLS:
            pass = data.name == "第100章至700章清单" || data.name == "第100章至700章清单合计";
            break;
          case fixedFlag.PROVISIONAL_TOTAL:
            pass = data.name == "已包含在清单合计中的材料、工程设备、专业工程暂估价合计";
            break;
          case fixedFlag.BILLS_TOTAL_WT_PROV:
            pass = data.name == "清单合计减去材料、工程设备、专业工程暂估价合计";
            break;
          case fixedFlag.DAYWORK_LABOR:
            pass = data.name == "计日工合计";
            break;
  /*         case fixedFlag.LABOUR_SERVICE:
            pass = data.name == "劳务";
            break;
          case fixedFlag.MATERIAL:
            pass = data.name == "材料";
            break;
          case fixedFlag.CONSTRUCTION_MACHINE:
            pass = data.name == "机械";
            break; */
          case fixedFlag.PROVISIONAL:
            pass = data.name == "暂列金额(不含计日工总额)";
            break;
          case fixedFlag.TOTAL_COST:
            pass = data.name == "投标报价";
            break;
          case fixedFlag.ONE_HUNDRED_BILLS:
            pass = data.name == "清单 第100章 总则";
            break;
        }
      } else { 
        if (bNode.parent) { 
          const pdata = bNode.parent.data;
          if (pdata.flagsIndex && pdata.flagsIndex.fixed && pdata.flagsIndex.fixed.flag == fixedFlag.ONE_SEVEN_BILLS) { 
            if (!sectionNameMap[data.name]) pass = false
          }
        }
      }
      if(pass == false)fail = { hint: `清单:"${data.name?data.name:""}",名字不符合规范！`, type: projectName }
  
      return fail;
    }
  
    /**
     *
     * @param {String} areaKey - 地区标识，如：'安徽@马鞍山'，有些地区的接口只是取值上有不同，共有一个接口脚本， 需要通过地区标识确定一些特殊处理
     * @param {Number} exportKind - 导出类型，招标、投标、控制价
     * @param {Object} projectData - 项目表数据：{ 建设项目Data, children: [单位工程...] }
     * @param {Object} tenderDetailMap - 单位工程ID与getData接口数据(projectObj.project的结构)的映射。
     * @return {Promise<Array>} - 返回的数据结构必须按照规定：[{ data, exportKind, fileName }]，参考web\building_saas\standard_interface\index.js中的注释说明
     */
    async function entry(areaKey, exportKind, projectData, tenderDetailMap) {
      const {
        CONFIG: {
          TYPE
        },
        UTIL,
        Element
      } = INTERFACE_EXPORT_BASE;
  
      const {
        EXPORT_KIND: {
          BID_INVITATION,
          BID_SUBMISSION,
          CONTROL
        },
        fixedFlag,
      } = window.commonConstants;
      let cprjType = {
        1: "GCLQD", // 招标
        2: "TBBJ", // 投标
        3: "ZBKZJ", // 控制价
      };
      const isBidInvitation = exportKind === BID_INVITATION; // 是否是招标
      const isBidSubmission = exportKind === BID_SUBMISSION; // 是否是投标
      const isControl = exportKind === CONTROL; // 是否是控制价
  
      function emptyElement(name) {
        this.name = name;
        this.attrs = [];
        this.children = [];
      }
  
      // 建设项目根节点信息
      function CprjInfo(projectName) {
        const attrs = [{
            name: "CprjName",
            value: projectName,
          },
          {
            name: "CprjType",
            value: cprjType[exportKind],
          },
        ];
        Element.call(this, "CprjInfo", attrs);
      }
      // 项目基本信息
      function SystemInfo(projectData) {
        let baseInfo = _.find(projectData.property.basicInformation, {
          dispName: "基本信息",
        });
         //“招标工程量清单”、“招标控制价”时，输出该字段，为导出该文件的当前时间
        let makeData = {
          value : UTIL.getNowFormatTime(true)
        }
  
        //投标的时候取基本信息的makeData字段
        if(isBidSubmission) makeData = _.find(baseInfo.items, { "key": "makeDate" });
        // 取编制软件序列号所属单位。读取项目属性-建设项目基本信息的“投标单位”字段。该字段需要模板中新增。等确定后再修改
        let softwareNumHolder = _.find(baseInfo.items, { "key": "???" });
        let hardID = UTIL.generateHardwareId();
        let [cpuId, diskId, macId] = hardID.split(";");
        const orgScretInfoStr = `SoftwareName=纵横公路工程造价管理软件,SoftwareVer=V${VERSION},SoftwareCompany=珠海纵横创新软件有限公,SoftwareNumber=${userID},HardNumber=${diskId},MacAddress=${macId},SoftwareNumberHolder=${softwareNumHolder}`
        let scretInfo = sm3Digest(orgScretInfoStr);
        const attrs = [{
            name: "Name",
            value: "公路工程造价数据标准",
          },
          {
            name: "Version",
            value: "1.0",
          },
          {
            name: "SoftwareName",
            value: "纵横公路工程造价管理软件",
          },
          {
            name: "SoftwareVer",
            value: "V" + VERSION,
          },
          {
            name: "SoftwareCompany",
            value: "珠海纵横创新软件有限公司",
          },
          {
            name: "MakeDate",
            value: makeData?makeData.value:"",
          },
          {
            name: "SoftwareNumber",
            value: window.btoa(userID),
          },
          {
            name: "HardNumber",
            value: window.btoa(diskId),
          },
          {
            name: "MacAddress",
            value: window.btoa(macId),
          },
          {
            name: "SoftwareNumberHolder",
            value: softwareNumHolder,
          },
          {
            name: "SecretInfo",
            value: scretInfo,
          },
        ];
        if (isBidSubmission)
          attrs.splice(6, 0, {
            name: "BidderVer",
            value: UTIL.getNowFormatTime(true),
          });
        Element.call(this, "SystemInfo", attrs);
      }
  
      //造价依据
      function CostBasis() {
        // ItemStandardNo="GYSFX-000000-2018-86"
        const attrs = [{
            name: "MakeRuleNo",
            value: "GYSBB-000000-2018-86",
          },
          {
            name: "MakeRuleName",
            value: "公路工程建设项目概算预算编制办法",
          },
          {
            name: "ItemStandardNo",
            value: "GYSFX-000000-2018-86",
          },
        ];
        Element.call(this, "CostBasis", attrs);
  
        //定额库信息
  
        //to do 改成实际的值
        function NormLib() {
          const attrs = [{
              name: "NormLibNo",
              value: "YSDE-000000-2018-86",
            },
            {
              name: "NormLibName",
              value: "部颁公路工程预算定额(2018)",
            },
            {
              name: "Type",
              value: "ZDEK",
            },
          ];
          Element.call(this, "NormLib", attrs);
        }
        this.children.push(new NormLib());
      }
  
      function Rate(tenderProject, feeRateInfo, seirNo) {
        //RateNo="1" Name="纵横软件测试版本" RateLibNo="GYSFL-000000-2018-86"
        const attrs = [{
            name: "RateNo",
            value: seirNo,
          },
          {
            name: "Name",
            value: feeRateInfo.name,
          },
          {
            name: "RateLibNo",
            value: feeLibNoMap[feeRateInfo.libID],
          },
        ];
        Element.call(this, "Rate", attrs);
  
        let RateParams = new emptyElement("RateParams");
        let subRates = projectObj.project.FeeRate.getAllSubRates(feeRateInfo.rates);
        for (let s of subRates) {
          let sname = s.name.replace("(％)", "");
          sname = sname.replace("(%)", "");
          if (feeRateMap[sname]) {
            let value = "";
            if (s.editable) {
              let sel = _.find(s.optionList, {
                selected: true,
              });
              if (sel) {
                value = sel.name;
              } else if (gljUtil.isDef(s.value)) {
                value = s.value;
              }
            } else {
              value = _.findIndex(s.optionList, {
                selected: true,
              });
              if (value == -1) value = 0;
            }
            /*     if (sname == '利润') tenderProject.ProfitRate = value;
                if (sname == '税金') tenderProject.TaxRate = value; */
            RateParams.children.push(new RateParam(feeRateMap[sname], value));
          }
        }
  
        this.children.push(RateParams);
  
        function RateParam(RateTypeNo, RateParamNo) {
          //<RateParam RateTypeNo="DJSGZJFFL" RateParamNo="0" Ratio="100"/>
          const attrs = [{
              name: "RateTypeNo",
              value: RateTypeNo,
            },
            {
              name: "RateParamNo",
              value: RateParamNo,
            },
            {
              name: "Ratio",
              value: "100",
            },
          ];
          Element.call(this, "RateParam", attrs);
        }
  
        let RateValues = new emptyElement("RateValues");
  
        function RateValue(CostTypeNo, RateTypeNo, value) {
          const attrs = [{
              name: "CostTypeNo",
              value: CostTypeNo,
            },
            {
              name: "RateTypeNo",
              value: RateTypeNo,
            },
            {
              name: "RateValue",
              value: value,
            },
          ];
          Element.call(this, "RateValue", attrs);
        }
  
        let prefix = "";
        for (let r of feeRateInfo.rates) {
          if (!r.ParentID && feeRateMap[r.name]) prefix = feeRateMap[r.name];
          if (feeRateMap[r.name] && r.ParentID) {
            RateValues.children.push(new RateValue(prefix, feeRateMap[r.name], r.rate));
          }
        }
  
        this.children.push(RateValues);
      }
  
      function Pract(tpdata, seriNo) {
        let pgljData = tpdata.projectGLJ.datas;
        let decimalObj = tpdata.property.decimal;
        const attrs = [{
            name: "PractNo",
            value: seriNo,
          },
          {
            name: "Name",
            value: pgljData.constData.usedUnitPriceInfo.name,
          },
        ];
        Element.call(this, "Pract", attrs);
  
        let Param = {
          name: "Param",
          attrs: [{
              name: "TaxLibNo",
              value: "CCSBZ-440000-2019-544",
            },
            {
              name: "AuxRate",
              value: pgljData.constData.assistProductionFeeRate,
            },
          ],
          children: [],
        };
        if (isBidSubmission || isControl) { //导出到招标文件中，不输出这一部分。
          let elecDatas = electrovalenceObj.getElectrovalenceDatas(null, pgljData.com_electrovalence, pgljData.gljList);
          electrovalenceObj.calcPertElectrovalenceMarketPrice(elecDatas);
          for (let e of elecDatas) {
            let Electro = {
              name: "Electro",
              attrs: [{
                  name: "Code",
                  value: e.code,
                },
                {
                  name: "Price",
                  value: e.electPrice,
                },
                {
                  name: "Ratio",
                  value: e.coe,
                },
              ],
              children: [],
            };
            Param.children.push(Electro);
          }
        }
  
  
        this.children.push(Param);
  
        function Mp(g) {
          const attrs = [{
              name: "Code",
              value: g.code,
            },
            {
              name: "PractName",
              value: g.name,
            },
            {
              name: "Spec",
              value: g.specs,
            },
            {
              name: "Unit",
              value: g.unit,
            },
            {
              name: "BudgetPrice",
              value: g.priceInfo.tenderPrice,
            },
            {
              name: "NormPrice",
              value: g.priceInfo.basePrice,
            },
            {
              name: "IsAdd",
              value: g.unit_price.is_add,
            },
          ];
          Element.call(this, "Mp", attrs);
        }
  
        function Material(g) {
          const attrs = [{
              name: "Code",
              value: g.code,
            },
            {
              name: "PractName",
              value: g.name,
            },
            {
              name: "Spec",
              value: g.specs,
            },
            {
              name: "Unit",
              value: g.unit,
            },
            {
              name: "BudgetPrice",
              value: g.priceInfo.tenderPrice,
            },
            {
              name: "NormPrice",
              value: g.priceInfo.basePrice,
            },
            {
              name: "IsAdd",
              value: g.unit_price.is_add,
            },
            {
              name: "OrgPrice",
              value: g.unit_price.originalPrice ? g.unit_price.originalPrice : 0,
            },
            {
              name: "TransFee",
              value: g.unit_price.unitFreight ? g.unit_price.unitFreight : 0,
            },
            {
              name: "GwRate",
              value: g.unit_price.grossWeightCoe_n ? g.unit_price.grossWeightCoe_n : 0,
            },
            {
              name: "OffSiteLf",
              value: g.unit_price.offSiteTransportLossRate_n ? g.unit_price.offSiteTransportLossRate_n : 0,
            },
            {
              name: "OnSiteLf",
              value: 0,
            },
            {
              name: "LoadLf",
              value: g.unit_price.handlingLossRate_n ? g.unit_price.handlingLossRate_n : 0,
            },
            {
              name: "StoreRate",
              value: g.unit_price.purchaseStorageRate_n ? g.unit_price.purchaseStorageRate_n : 0,
            },
            {
              name: "PackageRecycleFee",
              value: g.unit_price.packageRecoverValue ? g.unit_price.packageRecoverValue : 0,
            },
          ];
          Element.call(this, "Material", attrs);
          // if (g.unit_price.calcMaterial == 1) { //有材料计算
          //   let index = gljUtil.getIndex(g);
          //   let orList = [];
          //   for (let o of pgljData.originalList) {
          //     if (o.connect_key == index) orList.push(new OrgPrices(o));
          //   }
          //   if (orList.length > 0) this.children = orList;
          // }
  
          function CostStructure(r) {
            //待获取
            this.name = "CostStructure";
            this.attrs = [];
            this.children = [];
          }
  
          function Consume(r, o) {
            this.name = "Consume";
            this.attrs = [];
            this.children = [];
            for (let g of o.ration_gljs) {
              if (g.rationID == r.ID) {
                let r_quantity = scMathUtil.roundForObj(r.quantity, tpdata.property.decimal.ration.quantity);
                this.children.push(new ConsumeItem(g, r_quantity));
              }
            }
          }
  
          function ConsumeItem(g, ration_quantity) {
            const attrs = [{
                name: "Code", //待获取
                value: g.code,
              },
              {
                name: "Consumption",
                value: scMathUtil.roundForObj(ration_quantity * parseFloat(g.quantity), tpdata.property.decimal.glj.quantity),
              },
            ];
            Element.call(this, "ConsumeItem", attrs);
          }
  
          function Norm(r, o) {
            const attrs = [{
                name: "NormLibNo", //待获取
                value: "",
              },
              {
                name: "DisplayCode",
                value: r.code,
              },
              {
                name: "Name",
                value: r.name,
              },
              {
                name: "Unit",
                value: r.unit,
              },
              {
                name: "Num",
                value: r.quantity,
              },
              {
                name: "CostTypeNo",
                value: "", //待获取
              },
              {
                name: "FabricationCost", //待获取
                value: "",
              },
              {
                name: "AdjustStatus",
                value: "",
              },
            ];
            Element.call(this, "Norm", attrs);
            this.children.push(new CostStructure(r));
            this.children.push(new Consume(r, o));
          }
  
          function SelfCollect(o) {
            const attrs = [{
              name: "OtherCost",
              value: 0,
            }, ];
            Element.call(this, "SelfCollect", attrs);
            for (let r of o.rations) {
              this.children.push(new Norm(r, o));
            }
          }
  
          function OrgPrices(o) {
            const attrs = [{
                name: "OrgPricevalue",
                value: o.supplyPrice,
              },
              {
                name: "Ratio",
                value: o.coe,
              },
            ];
  
            Element.call(this, "OrgPrices", attrs);
            if (!o.rations) return;
            this.children.push(new SelfCollect(o));
          }
        }
  
        function Mech(g,gljKeyMap) {
          const attrs = [{
              name: "Code",
              value: g.code,
            },
            {
              name: "PractName",
              value: g.name,
            },
            {
              name: "Spec",
              value: g.specs,
            },
            {
              name: "Unit",
              value: g.unit,
            },
            {
              name: "BudgetPrice",
              value: g.priceInfo.tenderPrice,
            },
            {
              name: "NormPrice",
              value: g.priceInfo.basePrice,
            },
            {
              name: "IsAdd",
              value: g.unit_price.is_add,
            },
          ];
          Element.call(this, "Mech", attrs);
          let FixedCostItems = [];
          let fcsum = 0;
          let VariableCostItems = [];
          let vcsum = 0;
          if (g.ratio_data && g.ratio_data.length > 0) { 
            for (let ratio of g.ratio_data) { 
              let rIndex = gljUtil.getIndex(ratio);
              let rglj = gljKeyMap[rIndex];
              let ts = scMathUtil.roundForObj(parseFloat(ratio.consumption) * rglj.priceInfo.tenderPrice, decimalObj.glj.unitPrice);
              if (FixedCostMap[ratio.name]) {
                FixedCostItems.push(new FixedCostItem(ratio));
                fcsum = scMathUtil.roundForObj(fcsum + ts, decimalObj.glj.unitPrice);
              } else { 
                VariableCostItems.push(new VariableCostItem(ratio));
                vcsum = scMathUtil.roundForObj(vcsum + ts, decimalObj.glj.unitPrice);
              } 
            }
          }
  
  
          if (FixedCostItems.length > 0) {
            let fc = new FixedCost(fcsum);
            fc.children = FixedCostItems;
            this.children.push(fc);
          }
            
          if (VariableCostItems.length > 0) {
            let vc = new VariableCost(vcsum);
            vc.children = VariableCostItems;
            this.children.push(vc);
          }
  
          function VariableCost(sum) { 
            const attrs = [{
              name: "VariableCostSum",
              value: sum,
            }];
            Element.call(this, "VariableCost", attrs);
          }
          
          function VariableCostItem(item) { 
            const attrs = [{
              name: "VariableCostNo",
              value: item.code,
            },{
              name: "Consumption",
              value: item.consumption,
            }]
            Element.call(this, "VariableCostItem", attrs);
          }
  
          function FixedCost(sum) { 
            const attrs = [{
              name: "FixedCostSum",
              value: sum,
            }, {
              name: "FixedRate",
              value: 1,
            }];
            Element.call(this, "FixedCost", attrs);
          }
  
          function FixedCostItem(item) { 
            const attrs = [{
              name: "FixedCostNo",
              value: ratioCodeMap[item.code],
            },{
              name: "Sum",
              value: item.consumption,
            }]
            Element.call(this, "FixedCostItem", attrs);
  
          }
        }
  
        let Mps = new emptyElement("Mps");
        let Materials = new emptyElement("Materials");
        let Mechs = new emptyElement("Mechs");
        let gljKeyMap = {};
        let temMechs = [];
        if (isBidSubmission || isControl) { //导出到招标文件中，不输出这一部分。
          for (let g of pgljData.gljList) {
            if (!g.quantity) {
              continue;
            }
            let type = g.type + "";
            gljKeyMap[gljUtil.getIndex(g)] = g;
            type = type.charAt(0);
            if (type == "1") {
              Mps.children.push(new Mp(g));
            } else if (type == "2" || type == 5) {
              Materials.children.push(new Material(g));
            } else if (type == "3") {
              temMechs.push(g);
            }
          }
          for (let t of temMechs) { 
            Mechs.children.push(new Mech(t,gljKeyMap));
          }
        }
        this.children.push(Mps);
        this.children.push(Materials);
        this.children.push(Mechs);
      }
  
      function EprjInfo(tenderProject) {
        let bills = tenderProject.Bills.datas;
        let feature = tenderProject.property.projectFeature ? tenderProject.property.projectFeature : [];
        let totalItem = null;
        let proItem = null; //暂列金额项
        let safeItem = null;
        let oneToSevenItem = null;
        for (let b of bills) {
          if (b.flagsIndex && b.flagsIndex.fixed && b.flagsIndex.fixed.flag == fixedFlag.TOTAL_COST) totalItem = b;
          if (b.flagsIndex && b.flagsIndex.fixed && b.flagsIndex.fixed.flag == fixedFlag.PROVISIONAL) proItem = b;
          if (b.flagsIndex && b.flagsIndex.fixed && b.flagsIndex.fixed.flag == fixedFlag.ONE_SEVEN_BILLS) oneToSevenItem = b;
          if(b.code == "102-3" && b.name=="安全生产费") safeItem = b;
        }
  
        const attrs = [{
            name: "Name",
            value: tenderProject.projectInfo.name,
          },
          {
            name: "Sums",
            value: totalItem.feesIndex && totalItem.feesIndex.common && totalItem.feesIndex.common.tenderTotalFee ? totalItem.feesIndex.common.tenderTotalFee : 0,
          },
        ];
        //输出控制价、投标文件时，取调价后的标段总造价。
        //输出招标文件时，取0
        if (isBidInvitation) attrs[1].value = 0;
        Element.call(this, "EprjInfo", attrs);
        this.children.push(new SummaryOfCost(totalItem, proItem,safeItem,oneToSevenItem,feature));
        this.children.push(new MakeInfo(tenderProject));
        this.children.push(new Params(tenderProject));
        this.children.push(new getBillsItems(tenderProject));
        this.children.push(new getIndexs(tenderProject));
        let bidEvaluationMainMaterials = getBidEvaluationMainMaterial(tenderProject);
        if(bidEvaluationMainMaterials.length > 0) this.children.push(...bidEvaluationMainMaterials);
        
        //山东接口还需要增加几个表的数据（就是把原报表的显示数据转到投标文件里）
        // 1. 投标报价汇总表
        this.children.push(new quoteSummary(tenderProject));
        // 2. 计日工表
        let spdw = sporadicWork(tenderProject);
        if (spdw) {
          this.children.push(spdw);
        }
        // 3. 材料暂估价表
        let estMaterialRpt = materialEstimate(tenderProject);
        if (estMaterialRpt) {
          this.children.push(estMaterialRpt);
        }
        // 4. 工程设备暂估价表
        let estMachineRpt = getMachineTempEst(tenderProject);
        if (estMachineRpt) {
          this.children.push(estMachineRpt);
        }
        // 5. 专业工程暂估价表
        let estSpecPrjRpt = getSpecPrjEst(tenderProject);
        if (estSpecPrjRpt) {
          this.children.push(estSpecPrjRpt);
        }
        // 6. 工程量清单单价分析表
    }
  
      function _getBidGljCode(tenderProject, orgGlj) {
        let rst = orgGlj.code;
        if (tenderProject.bid_evaluation_list && tenderProject.bid_evaluation_list.datas) {
          for (let bGlj of tenderProject.bid_evaluation_list.datas) {
            if (bGlj.projectGLJID === orgGlj.id) {
              rst = bGlj.seq;
              break;
            }
          }
        }
        return rst;
      }

      function _getFee(bill, key = 'common', valueKey = 'tenderTotalFee') {
        let rstSum = 0;
        if (bill) {
          let dtlB = (bill.data) ? bill.data : bill;
          if (dtlB.fees) {
            for (let fee of dtlB.fees) {
              if (fee.fieldName === key) {
                rstSum = fee[valueKey];
                break;
              }
            }
          }
        }
        return rstSum;
      };
      function quoteSummary(tenderProject) {
        let quoteSummaryItem = new emptyElement('QuoteSummary');
        // let attrs = [];
        //1. 取固定清单，
        // 1.1 100~700章总清单(flags有属性为19的那个) -> topNode100To700
        // 1.2 已包含在清单合计中的材料、工程设备、专业工程暂估价合计 标记：20
        // 1.3 清单合计减去材料、工程设备、专业工程暂估价|合计 标记：21
        // 1.4 计日工合计 标记：22
        // 1.5 暂列金额(不含计日工总额) 标记：26
        // 1.6 投标报价 标记：9
        let topNode100To700, nodeZXZDJ, nodeQDKCZXZDJ, nodeJRG, nodeZLJE, nodeTBBJ;
        let chapterNodes = [];
        tenderProject.Bills.datas.forEach((bill)=> {
            if (bill.flags && bill.flags.length > 0) {
                for (let flag of bill.flags) {
                    switch(flag.flag) {
                        case 19 :
                            topNode100To700 = bill;
                        break;
                        case 20 :
                            nodeZXZDJ = bill;
                        break;
                        case 21 :
                            nodeQDKCZXZDJ = bill;
                        break;
                        case 22 :
                            nodeJRG = bill;
                        break;
                        case 26 :
                            nodeZLJE = bill;
                        break;
                        case 9 :
                            nodeTBBJ = bill;
                        break;
                        default :
                        break;
                    }
                }
            }
        });

        //2. 然后获取topNode100To700下的所有次一级清单(100章...700章)
        if (topNode100To700) {
          for (let rootBill of tenderProject.Bills.tree.roots) {
            // 100~700章总清单在top级别（山东养护）
            if (rootBill.data.ID === topNode100To700.ID) {
              rootBill.children.forEach((subBill)=> {
                if (subBill.data.name.includes('00章')) {
                  chapterNodes.push(subBill);
                }
              });
              break;
            }
          }
        }
        //3. 拼凑数据
        let nodeAttrs = [];
        if (topNode100To700) {
          let order = 1;
          //读取投标报价汇总表信息。1.ItemNo 序号。2.ChapterNo 章次。 3.Name 科目名称。 4.Sum 金额。
          chapterNodes.forEach((cnode)=> {
            let chapterIdx = cnode.data.name.indexOf("00章");
            nodeAttrs.push({ItemNo: order, ChapterNo: cnode.data.name.substr(chapterIdx - 1, 3), Name: cnode.data.name, Sum: _getFee(cnode)});
            order++;
          });
          nodeAttrs.push({ItemNo: order, ChapterNo: '', Name: '第100章至700章清单合计', Sum: _getFee(topNode100To700)});
          order++;
          if (nodeZXZDJ) {
            nodeAttrs.push({ItemNo: order, ChapterNo: '', Name: '已包含在清单合计中的材料、工程设备、专业工程暂估价合计', Sum: _getFee(nodeZXZDJ)});
            order++;
          }
          if (nodeQDKCZXZDJ) {
            nodeAttrs.push({ItemNo: order, ChapterNo: '', Name: `清单合计减去材料、工程设备、专业工程暂估价合计(即${order - 2}-${order - 1})=${order}`, Sum: _getFee(nodeQDKCZXZDJ)});
            order++;
          }
          if (nodeJRG) {
            nodeAttrs.push({ItemNo: order, ChapterNo: '', Name: `计日工合计`, Sum: _getFee(nodeJRG)});
            order++;
          }
          if (nodeZLJE) {
            nodeAttrs.push({ItemNo: order, ChapterNo: '', Name: `暂列金额(不含计日工总额)`, Sum: _getFee(nodeZLJE)});
            order++;
          }
          if (nodeTBBJ) {
            nodeAttrs.push({ItemNo: order, ChapterNo: '', Name: `投标报价(${chapterNodes.length + 1} + ${order - 2}+${order - 1})=${order}`, Sum: _getFee(nodeZLJE)});
            order++;
          }
        }
        function _Item(item) {
          const attrs = [
            { name: 'ItemNo',
              value: item.ItemNo
            },
            { name: 'ChapterNo',
              value: item.ChapterNo
            },
            { name: 'Name',
              value: item.Name
            },
            { name: 'Sum',
              value: item.Sum
            }
          ];
          let rst = new emptyElement('Item');
          rst.attrs.push(...attrs);
          return rst;
        }
        for (let attr of nodeAttrs) {
          quoteSummaryItem.children.push(_Item(attr));
        }
        return quoteSummaryItem;
      }

      function sporadicWork(tenderProject) {
        //计日工表，含：劳务、材料、施工机械、计日工汇总
        let hasSporadicWork = false;
        let sporadicWorkItem = new Element('SporadicWork');
        let nodeLabour, nodeMaterial, nodeMachine;
        //首先收集过滤计日工相关清单
        tenderProject.Bills.datas.forEach((bill)=> {
          if (bill.flags && bill.flags.length > 0) {
              for (let flag of bill.flags) {
                  switch(flag.flag) {
                      case 23 :
                        nodeLabour = bill;
                      break;
                      case 24 :
                        nodeMaterial = bill;
                      break;
                      case 25 :
                        nodeMachine = bill;
                      break;
                      default :
                      break;
                  }
              }
          }
        });
        const _buildWorkNodeItem = function(orgNode, subNodes, parentKey, childKey) {
          let parentNode = new Element(parentKey);
          sporadicWorkItem.children.push(parentNode);
          const pSumAttrs = [
            {
              name: 'Sum',
              value: _getFee(orgNode)
            }
          ];
          // Element.call(this, parentKey, pSumAttrs);
          parentNode.attrs.push(...pSumAttrs);
          subNodes.forEach((node)=> {
              let childNode = new Element(childKey);
              parentNode.children.push(childNode);
              const attrs = [
                { name: 'ItemNo',
                  value: node.code
                }, {
                  name: 'Name',
                  value: node.name
                }, {
                  name: 'Unit',
                  value: node.unit
                }, {
                  name: 'Num',
                  value: node.quantity
                }, {
                  name: 'Price',
                  value: _getFee(node, 'common', 'tenderUnitFee')
                }, {
                  name: 'Sum',
                  value: _getFee(node)
                }
              ];
              childNode.attrs.push(...attrs);
          });
        };
        //1. 判断劳务
        if (nodeLabour) {
          let subNodes = [];
          tenderProject.Bills.datas.forEach((bill)=> {
            if (bill.ParentID === nodeLabour.ID) {
              subNodes.push(bill);
            }
          });
          if (subNodes.length > 0) {
            hasSporadicWork = true;
            //创建劳务Mps节点及劳务Mps下Mp子节点
            _buildWorkNodeItem(nodeLabour, subNodes, 'Mps', 'Mp');
          }
        }
        //2. 判断材料
        if (nodeMaterial) {
          let subNodes = [];
          tenderProject.Bills.datas.forEach((bill)=> {
            if (bill.ParentID === nodeMaterial.ID) {
              subNodes.push(bill);
            }
          });
          if (subNodes.length > 0) {
            hasSporadicWork = true;
            //创建材料Materials节点及劳务Materials下Material子节点
            _buildWorkNodeItem(nodeMaterial, subNodes, 'Materials', 'Material');
          }
        }
        //3. 判断施工机械
        if (nodeMachine) {
          let subNodes = [];
          tenderProject.Bills.datas.forEach((bill)=> {
            if (bill.ParentID === nodeMachine.ID) {
              subNodes.push(bill);
            }
          });
          if (subNodes.length > 0) {
            hasSporadicWork = true;
            //创建施工机械Meehs节点及劳务Meehs下Meeh子节点
            _buildWorkNodeItem(nodeMachine, subNodes, 'Meehs', 'Meeh');
          }
        }
        //4. 判断计日工汇总
        if (hasSporadicWork) {
          let summaryNode = new Element('Summary');
          sporadicWorkItem.children.push(summaryNode);
          const pSumAttrs = [
            {
              name: 'Sum',
              value: _getFee(nodeLabour) + _getFee(nodeMaterial) + _getFee(nodeMachine)
            }
          ];
          summaryNode.attrs = pSumAttrs;
          //把劳务、材料、施工机械
          function _workItem(node, name, remark='') {
            let childNode = new Element('Item');
            summaryNode.children.push(childNode);
            const attrs = [
              {
                name: "Name",
                value: name,
              },
              {
                name: "Sum",
                value: _getFee(node),
              },
              {
                name: "Remark",
                value: remark,
              }
            ]
            childNode.attrs.push(...attrs);
          }
          _workItem(nodeLabour, '劳务');
          _workItem(nodeMaterial, '材料');
          _workItem(nodeMachine, '机械');
        }
        //返回
        if (hasSporadicWork) {
          return sporadicWorkItem;
        } else {
          return null;
        }
      }

      function materialEstimate(tenderProject) {
        let mEstNode = new emptyElement('MaterialEstimate');
        let items = [];
        //材料暂估价明细
        tenderProject.projectGLJ.datas.gljList.forEach((glj)=> {
          if (glj.is_evaluate && glj.type !== 5 && glj.type !== 301) {
            items.push(glj);
          }
        });
        if (items.length > 0) {
          items.forEach((glj, sno)=> {
            let mEstItemNode = new emptyElement('Item');
            mEstNode.children.push(mEstItemNode);
            let attrs = [
              {name: 'ItemNo', value: sno + 1},
              {name: 'Code', value: _getBidGljCode(tenderProject, glj)},
              {name: 'Number', value: glj.code},
              {name: 'Name', value: glj.name},
              {name: 'Unit', value: glj.unit},
              {name: 'Num', value: glj.tenderQuantity},
              {name: 'Price', value: glj.unit_price.market_price},
              {name: 'Sum', value: glj.tenderQuantity * glj.unit_price.market_price, type:TYPE.DECIMAL},
              {name: 'Remark', value: (glj.remark) ? glj.remark : ''}
            ];
            mEstItemNode.attrs.push(...attrs);
          });
          return mEstNode;
        } else {
          return null;
        }
      }

      function getMachineTempEst(tenderProject) {
        let mEstNode = new emptyElement('PrjDeviceEstimate');
        let items = [];
        //工程设备明细
        tenderProject.projectGLJ.datas.gljList.forEach((glj)=> {
          if (glj.is_evaluate && glj.type === 5) {
            items.push(glj);
          }
        });
        if (items.length > 0) {
          items.forEach((glj, sno)=> {
            let mEstItemNode = new emptyElement('Item');
            mEstNode.children.push(mEstItemNode);
            let attrs = [
              {name: 'ItemNo', value: sno + 1},
              {name: 'Code', value: _getBidGljCode(tenderProject, glj)},
              {name: 'Number', value: glj.code},
              {name: 'Name', value: glj.name},
              {name: 'Unit', value: glj.unit},
              {name: 'Num', value: glj.tenderQuantity},
              {name: 'Price', value: glj.unit_price.market_price},
              {name: 'Sum', value: glj.tenderQuantity * glj.unit_price.market_price, type:TYPE.DECIMAL},
              {name: 'Remark', value: (glj.remark) ? glj.remark : ''}
            ];
            mEstItemNode.attrs.push(...attrs);
          });
          return mEstNode;
        } else {
          return null;
        }
      }

      function getSpecPrjEst(tenderProject) {
        let mEstNode = new emptyElement('SpecPrjEstimate');
        let sum = 0;
        let items = [];
        //专业工程暂估明细
        tenderProject.Bills.datas.forEach((bill)=> {
          if (bill.specialProvisional === '专业工程') {
            items.push(bill);
          }
        });
        if (items.length > 0) {
          items.forEach((bill, sno)=> {
            let mEstItemNode = new emptyElement('Item');
            mEstNode.children.push(mEstItemNode);
            let ttl = _getFee(bill);
            sum += ttl;
            let attrs = [
              {name: 'ItemNo', value: sno + 1},
              {name: 'Name', value: bill.name},
              {name: 'Content', value: bill.jobContent.toString()},
              {name: 'Sum', value: ttl, type:TYPE.DECIMAL},
            ];
            mEstItemNode.attrs.push(...attrs);
          });
          mEstNode.attrs.push({name: 'Sum', value: sum});
          return mEstNode;
        } else {
          return null;
        }
      }

      function getBillsAnalyze(tenderProject) {
        // 本函数是尽量复刻【5.5表】工程量清单单价分析表的‘综合’计算式脚本的相关逻辑，具体细节根据实际环境有所调整（前端环境已有不少现成的结构及数据，能少跑不少逻辑）
        let djfxbNode = new emptyElement('ListUnitPriceAnalysis');
        // 工程量清单单价分析(100~700章 清单下所有定额工料机的综合)
        let topNode100To700;
        let sno = 1;
        const prefix = '_';
        let filterMtlTypes = [202, 203, 204, 301];
        for (let bill of tenderProject.Bills.datas) {
          if (bill.flags && bill.flags.length > 0) {
              for (let flag of bill.flags) {
                if (flag.flag === 19) {
                  for (let rootBill of tenderProject.Bills.tree.roots) {
                    if (rootBill.ID === bill.ID) {
                      topNode100To700 = rootBill;
                      break;
                    }
                  }
                  break;
                }
              }
          }
        }
        const cacheObj = {};
        const proKeysArr = [];
        const addedGljCodeCache = {};
        //说明：根据实际情况，用户会直接在清单下加工料机，此工料机属于定额层次，那么算工程量的时候要加上这个（沟通后这种几率很小，暂时返回0，如有再补上）
        const _getAdhocGljQty = function(billsId, rationCode, rstType = 1) {
          let rst = 0;
          // for (let nbidx = 0; nbidx < newRBillsIdArr.length; nbidx++) {
          //   if (newRBillsIdArr[nbidx] === billsId && newRCodeArr[nbidx] === rationCode) {
          //     rst = (rstType === 1) ? newRQtyArr[nbidx] : newTtlArr[nbidx];
          //     break;
          //   }
          // }
          return rst;
        };

        const _getCacheObjInitialedItem = function(bill = null, glj = null) {
          return {
            code: (bill) ? bill.code : ((glj) ? glj.code : ''),
            name: (bill) ? bill.name : ((glj) ? glj.name : ''),
            quantity: 0,
            labourConsume: 0,
            labourUnitPrice: 0,
            labourTotalPrice: 0,
            mainMaterialFee: 0,
            auxiliaryMaterialFee: 0,
            materialUnitFee: (bill) ? _getFee(bill, 'marketMaterial', 'unitFee') : 0,
            machineFee: (bill) ? _getFee(bill, 'marketMachine') : 0,
            otherFee: (bill) ? _getFee(bill, 'measure') : 0, //措施费
            managementFee: (bill) ? (_getFee(bill, 'manage') + _getFee(bill, 'force')) : 0, //管理+规费
            taxFee: (bill) ? _getFee(bill, 'tax') : 0,
            profitFee: (bill) ? _getFee(bill, 'profit') : 0,
            unitPrice: (bill) ? _getFee(bill, 'common', 'unitFee') : 0
          };
        };
        const _getPrjGLJ = function(gljID) {
          let rst = null;
          for (let glj of tenderProject.projectGLJ.datas.gljList) {
            if (glj.id === gljID) {
              rst = glj;
              break;
            }
          }
        };
        const _createNode = function(billIdKey, bill) {
          if (cacheObj[billIdKey]) {
            //1. 叶子清单，先创建清单Item
            let bQtn = 1;
            if (bill.hasOwnProperty('quantity')) {
              bQtn = parseFloat(bill.quantity);
              if (isNaN(bQtn)) bQtn = 1;
            }
            let billMainMaterialTtl = cacheObj[billIdKey].mainMaterialFee/bQtn;
            let billAuxiliaryMaterialTtl = cacheObj[billIdKey].auxiliaryMaterialFee/bQtn;
            let leafBillAttrs = [
              {name: 'ItemNo', vlaue: sno},
              {name: 'Code', vlaue: cacheObj[billIdKey].code},
              {name: 'Name', vlaue: cacheObj[billIdKey].name},
              {name: 'LaborWorkDays', vlaue: cacheObj[billIdKey].labourConsume / bQtn},
              {name: 'LaborUnitPrice', vlaue: cacheObj[billIdKey].labourUnitPrice},
              {name: 'LaborUnitTotal', vlaue: cacheObj[billIdKey].labourTotalPrice / bQtn},
              {name: 'MainMaterialConsume', vlaue: 0},
              {name: 'MainMaterialUnit', vlaue: ''},
              {name: 'MainMaterialUnitPrice', vlaue: 0},
              {name: 'MainMaterialTotal', vlaue: billMainMaterialTtl},
              {name: 'AuxiliaryMaterialFee', vlaue: billAuxiliaryMaterialTtl},
              {name: 'MaterialSum', vlaue: billMainMaterialTtl + billAuxiliaryMaterialTtl},
              {name: 'MachUsageFee', vlaue: cacheObj[billIdKey].machineFee/bQtn},
              {name: 'OtherFee', vlaue: cacheObj[billIdKey].otherFee/bQtn},
              {name: 'ManageFee', vlaue: cacheObj[billIdKey].managementFee/bQtn},
              {name: 'Tax', vlaue: cacheObj[billIdKey].taxFee/bQtn},
              {name: 'Profit', vlaue: cacheObj[billIdKey].profitFee/bQtn},
              {name: 'Price', vlaue: _getFee(bill)},
            ];
            sno++;
            let itemNode = new emptyElement('Item');
            itemNode.attrs.push(...leafBillAttrs);
            djfxbNode.children.push(itemNode);
            //2. 清单下工料机
            cacheObj[billIdKey].items.forEach((gljItem)=> {
              let showQty = gljItem.mainMaterialConsume/cacheObj[billIdKey].quantity;
              showQty = Math.round(showQty * 1000000) / 1000000;
              let gljAttrs = [
                {name: 'ItemNo', vlaue: sno},
                {name: 'Code', vlaue: gljItem.code},
                {name: 'Name', vlaue: gljItem.name},
                {name: 'LaborWorkDays', vlaue: 0},
                {name: 'LaborUnitPrice', vlaue: 0},
                {name: 'LaborUnitTotal', vlaue: 0},
                {name: 'MainMaterialConsume', vlaue: showQty},
                {name: 'MainMaterialUnit', vlaue: gljItem.mainMaterialUnit},
                {name: 'MainMaterialUnitPrice', vlaue: gljItem.mainMaterialUnitPrice},
                {name: 'MainMaterialTotal', vlaue: showQty * gljItem.mainMaterialUnitPrice},
                {name: 'AuxiliaryMaterialFee', vlaue: 0},
                {name: 'MaterialSum', vlaue: 0},
                {name: 'MachUsageFee', vlaue: 0},
                {name: 'OtherFee', vlaue: 0},
                {name: 'ManageFee', vlaue: 0},
                {name: 'Tax', vlaue: 0},
                {name: 'Profit', vlaue: 0},
                {name: 'Price', vlaue: _getFee(bill)},
              ];
              sno++;
            });
          }
        };
        const _getAllGlj = function(parentBill) {
          if (parentBill.children.length > 0) {
            parentBill.children.forEach((subBill)=> {
              _getAllGlj(subBill);
            });
          } else {
            let billIdKey = prefix + parentBill.ID;
            if (!cacheObj.hasOwnProperty(billIdKey)) {
              cacheObj[billIdKey] = _getCacheObjInitialedItem(parentBill);
              addedGljCodeCache[billIdKey] = [];
              proKeysArr.push(billIdKey);
            }
            tenderProject.ration_glj.forEach((rglj)=> {
              if (rglj.billsItemID === parentBill.ID) {
                let gljQty = parseFloat(rglj.quantity);
                if (isNaN(gljQty)) gljQty = 0;
                let gljRationQty = parseFloat(rglj.rationItemQuantity);
                if (isNaN(gljRationQty)) gljRationQty = 0;
                let gljCns = gljQty * gljRationQty;
                let prjGlj = _getPrjGLJ(rglj.projectGLJID);
                let gljUnitPrice = parseFloat(prjGlj.unit_price.market_price);
                let gljTotalPrice = gljCns * gljUnitPrice;
                let gljCode = rglj.code;

                if (rglj.type === 1) {
                  //人工
                  cacheObj[billIdKey].labourConsume = cacheObj[billIdKey].labourConsume + gljCns;
                  cacheObj[billIdKey].labourUnitPrice = gljUnitPrice;
                  cacheObj[billIdKey].labourTotalPrice = cacheObj[billIdKey].labourTotalPrice + gljTotalPrice;
                } else if (filterMtlTypes.indexOf(dtlType) < 0) {
                  if (!addedGljCodeCache[billIdKey].includes(gljCode)) {
                    addedGljCodeCache[billIdKey].push(gljCode);
                  }
                  if (prjGlj.is_main_material) {
                    let dtlObj = {};
                    dtlObj.code = gljCode;
                    dtlObj.name = rglj.name;
                    dtlObj.specs = rglj.specs;
                    //
                    let adhocGljQty = _getAdhocGljQty(parentBill.ID, dtlObj.code);
                    let adhocGljTtl = adhocGljQty * gljUnitPrice;
                    dtlObj.mainMaterialConsume = gljCns + adhocGljQty; //考虑清单单独加工料机的情况，需要补上消耗量
                    dtlObj.mainMaterialUnitPrice = gljUnitPrice;
                    dtlObj.mainMaterialTotalPrice = gljTotalPrice;
                    dtlObj.mainMaterialUnit = rglj.unit;
                    let isAdd = 0;
                    for (let i = 0; i < cacheObj[billIdKey].items.length; i++) {
                      //先比较对象中是否已存在同一条工料机，存在，则累加汇总消耗量和金额；否则添加。
                      if (dtlObj.code === cacheObj[billIdKey].items[i].code && dtlObj.name === cacheObj[billIdKey].items[i].name && dtlObj.mainMaterialUnit === cacheObj[billIdKey].items[i].mainMaterialUnit && dtlObj.specs === cacheObj[billIdKey].items[i].specs) {
                          cacheObj[billIdKey].items[i].mainMaterialConsume = cacheObj[billIdKey].items[i].mainMaterialConsume + gljCns;
                        cacheObj[billIdKey].items[i].mainMaterialTotalPrice = cacheObj[billIdKey].items[i].mainMaterialTotalPrice + gljTotalPrice;
                        isAdd = 1;
                        break;
                      }
                    }
                    if (isAdd === 0) {
                        cacheObj[billIdKey].items.push(dtlObj);
                    }
                    cacheObj[billIdKey].mainMaterialFee = cacheObj[billIdKey].mainMaterialFee + gljTotalPrice + adhocGljTtl;          
                  } else {
                    cacheObj[billIdKey].auxiliaryMaterialFee = cacheObj[billIdKey].auxiliaryMaterialFee + gljTotalPrice;
                  }
                }
              }
            });
            // 整理完后，开始创建XML节点(这里与参考脚本逻辑不一样了，直接开始创建)
            _createNode(billIdKey, parentBill);
          }
        };
        if (topNode100To700) {
          topNode100To700.children.forEach((topChapterBill)=> {
            _getAllGlj(topChapterBill);
          });
        }
        //...
        return djfxbNode;
      }

      function getBidEvaluationMainMaterial(tenderProject) { 
        let bidMaterials = [];
        let i = 1;
        for (let b of  tenderProject.bidMaterialData) { 
          bidMaterials.push(new BidEvaluationMainMaterial(b, i));
          i++
        }
        return bidMaterials;
        function BidEvaluationMainMaterial(b, index) {
          const attrs = [{
              name: "Code",
              value: b.seq,
            },
            {
              name: "Number",
              value: b.code
            },
            {
              name: "Name",
              value: b.name
            },
            {
              name: "Specification",
              value: b.specs
            },
            {
              name: "Unit",
              value: b.unit
            },
            {
              name: "Price",
              value: b.marketPrice || '0',
              type: TYPE.DECIMAL
            },
            {
              name: "LimitedPrice",
              value: b.marketPrice || '0',
              type: TYPE.DECIMAL
            },
            {
              name: "Quantity",
              value: 0,//b.quantity
              type: TYPE.DECIMAL
            },
            {
              name: "Total",
              value: 0//b.totalPrice
            },
            {
              name: "Remark",
              value: b.remark
            }
          ];
          if (isBidSubmission || isControl) { 
            attrs[7].value = b.quantity;
            attrs[8].value = b.totalPrice;
          }
          Element.call(this, "BidEvaluationMainMaterial", attrs);
        }
  
      }
  
  
      function getIndexs(tenderProject) {
        let Indexs = new emptyElement('Indexs');
        let feature = tenderProject.property.projectFeature ? tenderProject.property.projectFeature : [];
        for (let f of feature) {
          if (f.code) Indexs.children.push(new IndexItem(f))
        }
        return Indexs;
  
        function IndexItem(fea) {
          const attrs = [{
              name: "Code",
              value: fea.code,
            },
            {
              name: "Name",
              value: fea.dispName,
            },
            {
              name: "Unit",
              value: fea.unit,
            },
            {
              name: "Value",
              value: fea.value,
            },
            {
              name: "Remark",
              value: fea.remark,
            }
          ]
          Element.call(this, "IndexItem", attrs);
        }
  
  
      }
  
  
      function getBillsItems(tenderProject) {
        let items = new emptyElement("Items");
        let rootNodes = tenderProject.mainTree.roots;
        for (let r of rootNodes) {
          
          setItem(r, -1, items.children);
        }
        return items;
  
        function setItem(bNode, level, list) {
          if (bNode.sourceType == ModuleNames.ration) return;
          let item = new bill(bNode, level);
          if (bNode.children && bNode.children.length > 0) {
            level += 1;
            for (let c of bNode.children) {
              setItem(c, level, item.children);
            }
          }
          list.push(item);
  
          function getCalcType(node) {
            /*           
            判断是否父项：
             是父项，则取1；
            是叶子项，则判断其下有无套定额/量价/工料机：
                  有则取1；
                  无则判断有无基数计算：
                 有则取2；
                 无则取3 */
            if (node.children && node.children.length > 0) {
              return 1; //是父项，则取1, 有套定额/量价/工料机，也取1
            } else {
              return node.data.calcBase && node.data.calcBase != "" ? 2 : 3
            }
          }
  
          function getItemType(node) {
            let Bills = projectObj.project.Bills;
            //是100~900章部分、或是计日工部分，叶子清单输出1，父项输出0；
            if (Bills.isBelongOneToSeven(node)||Bills.isBelongDayWork(node)) {
              if (node.children && node.children.length > 0) {
                return node.children[0].sourceType == ModuleNames.ration ? 1 : 0
              }
              return 1 //叶子清单输出1
            } else {
              return 0;
              /* //非100~900章部分，
              //  是暂列金额，判断暂列金额的金额等于0，则输出为0；暂列金额的金额不等于0，则输出为1；
              if (node.data.name && node.data.name.indexOf("暂列金额") != -1) {
                let sum = node.data.feesIndex && node.data.feesIndex.common ? node.data.feesIndex.common.tenderTotalFee : "";
                return gljUtil.isNotEmpty(sum) ? 1 : 0
              } else { //非暂列金额,则判断清单的工程量是否等于0，等于0，则输出0；不等于0，则输出1
                return gljUtil.isNotEmpty(node.data.quantity) ? 1 : 0
              } */
            }
  
          }
  
          function bill(bNode, level) {
            let data = bNode.data;
            let CostKind = 3;
            if (data.name && data.name.indexOf("安全生产费") != -1) CostKind = 1;
            if (data.name && data.name.indexOf("暂列金额") != -1) CostKind = 2;
            //1 = 工程量×综合单价；2 = 计算基数×费率；3 = 工程量×单价。
            let CalcType = getCalcType(bNode);
            //取暂估价类型。读取造价书界面的专项暂定列。0=材料暂估价，1=工程设备暂估价,2=专业工程暂估价，没有选的输出为空。
            let ProvisionalType = "";
            if (data.specialProvisional == "材料") ProvisionalType = 0;
            if (data.specialProvisional == "工程设备") ProvisionalType = 1;
            if (data.specialProvisional == "专业工程") ProvisionalType = 2;
  
            //MpRatio
            let MpRatio = "";
            let MaterialRatio = "";
            let MechRatio = "";
            if (data.quantityCoe) {
              if (data.quantityCoe["labour"]) MpRatio = data.quantityCoe["labour"];
              if (data.quantityCoe["material"]) MaterialRatio = data.quantityCoe["material"];
              if (data.quantityCoe["machine"]) MechRatio = data.quantityCoe["machine"];
            }
            let fail = billNameChecking(bNode,tenderProject.projectInfo.name,fixedFlag)
            //fail: { hint: '错误提示', type: '提示所属（基本就是单位工程名称）' }
            let ListCode = "";
            if (ListCodeMap[data.name]) ListCode = ListCodeMap[data.name];
            if (data.code && data.code != "") ListCode = data.code;
  
            const attrs = [{
                name: "ListCode",
                value: ListCode,
              },
              {
                name: "ListName",
                value: data.name,
                fail:fail
              },
              {
                name: "Unit",
                value: data.unit,
              },
              {
                name: "Num",
                value: data.quantity,
                type: TYPE.DECIMAL,
                toFix:3
              },
              {
                name: "QtyFormula",
                value: data.feesIndex && data.feesIndex.common ? data.feesIndex.common.tenderTotalFee : "",//data.calcBase //data.calcBase ? cbParser.toFExpr(data.calcBase, tenderProject.mainTree.items) : "",
                type: TYPE.DECIMAL,
                toFix:2
              },
              {
                name: "Price",
                value: 0,//data.feesIndex && data.feesIndex.common ? data.feesIndex.common.tenderUnitFee : "",
                type: TYPE.DECIMAL,
                toFix:2
              },
              {
                name: "Rate",
                value: 100,
              },
              {
                name: "Sum",
                value: 0,//data.feesIndex && data.feesIndex.common ? data.feesIndex.common.tenderTotalFee : "",
                type: TYPE.DECIMAL,
                toFix:2
              },
              {
                name: "ChapterKind",
                value: level > 3 ? 3 : level,
              },
              {
                name: "CostKind",
                value: CostKind,
              },
              {
                name: "CalcType",
                value: CalcType,
              },
              {
                name: "ProvisionalType",
                value: ProvisionalType,
                mustHasValue:true
              },
              {
                name: "MeterRules",
                value: "",
              },
              {
                name: "Content",
                value: data.jobContentText,
              },
              {
                name: "Remarks",
                value: data.remark,
              },
             /*  {
                name: "MpRatio",
                value: MpRatio,
              },
              {
                name: "MaterialRatio",
                value: MaterialRatio,
              },
              {
                name: "MechRatio",
                value: MechRatio,
              },
              {
                name: "AdjustedPrice",
                value: data.feesIndex && data.feesIndex.common ? data.feesIndex.common.tenderUnitFee : "",
              },
              {
                name: "AdjustedSums",
                value: data.feesIndex && data.feesIndex.common ? data.feesIndex.common.tenderTotalFee : "",
              }, */
              {
                name: "ItemType",
                value: getItemType(bNode),
              },
              /* {
                name: "FomulaCode",
                value: ""
              }, */
            ];
            //投标、招标控制价时。取单价。
            //招标时，如果是“安全生产费”或“暂列金额”，取单价，否则取0。
            if (isBidSubmission || isControl || CostKind==1 ||CostKind==2) { 
              attrs[5].value = data.feesIndex && data.feesIndex.common ? data.feesIndex.common.tenderUnitFee : "";
              attrs[7].value = data.feesIndex && data.feesIndex.common ? data.feesIndex.common.tenderTotalFee : "";
              //暂列金额 数量为0的时候，单价输出0
              if( CostKind==2 && !gljUtil.isNotEmpty(data.quantity)) attrs[5].value  = 0
            }
  
            Element.call(this, "Item", attrs);
            let cc = CostComposition(bNode);
            if (cc) this.children.push(cc);
            this.children.push(CostStructure(data))
  
            function CostComposition(bNode) {
              if (isBidInvitation) return null;
              let CostComposition = new emptyElement('CostComposition');
              let Norms = [];
              let Costs = [];
              if (bNode.children && bNode.children.length > 0 && bNode.children[0].sourceType == ModuleNames.ration) {
                for (let r of bNode.children) {
                  if (r.data.type == rationType.ration) {
                    if(isEmptyRation(r.data)) continue;//定额空行不输出到接口文件中。
                    Norms.push(new Ration(r.data));
                  } else {
                    Costs.push(new Cost(r.data));
                  }
                }
              }
              if (Norms.length > 0) CostComposition.children.push(...Norms);
              if (Costs.length > 0) CostComposition.children.push(...Costs);
              if (bNode.data.calcBase) CostComposition.children.push(new Formula(bNode.data));
              return CostComposition.children.length > 0 ? CostComposition : null;
  
            //定额空行不输出到接口文件中。 //定额空行的判断是：定额编码、定额名称、定额单位、定额单位、定额工程量为零或为空时
            function isEmptyRation(ration){
              return !gljUtil.isNotEmpty(ration.code)&&!gljUtil.isNotEmpty(ration.name)&&!gljUtil.isNotEmpty(ration.unit)&&(!gljUtil.isNotEmpty(ration.quantity)||ration.quantity == 0)
            }
              
  
              function Formula(bills) {
                const attrs = [{
                    name: "Name",
                    value: bills.name
                  },
                  {
                    name: "Formulas",
                    value: bills.calcBase
                  },
                  {
                    name: "Ratio",
                    value: 1
                  },
                  {
                    name: "Sum",
                    value: bills.feesIndex && bills.feesIndex.common ? bills.feesIndex.common.tenderTotalFee : "",
                    type:TYPE.DECIMAL
                  },
                  {
                    name: "Remarks",
                    value: bills.remark
                  }
                ]
                Element.call(this, "Formula", attrs);
  
                //               1.Name
                // 名称/描述。取清单的名称。
                // 2.Formulas
                // 计算式。读取计算基数的文本。
                // 取基数计算窗口内容，基数直接转换为金额？参考标准文档的 7.11 及 7.12 节。
                // 7.11是定额的费用，7.12是清单累进基数，主要是估概预算中用到，清单里的不同，所以中山的接口直接输出基数文本。
                // 3.Ratio
                // 系数。输出为1，非必填。
                // 4.Sum
                // 取金额。
                // 5.Remarks
              }
  
              function Cost(item) {
                let BasePrice = 0;
                if (item.type == rationType.volumePrice) { // 当插入的是量价时，基价读取单价列。
                  BasePrice = item.feesIndex && item.feesIndex.common ? item.feesIndex.common.tenderUnitFee : 0
                } else {
                  BasePrice = getBasePrice(item.projectGLJID, tenderProject)
                }
                let calcMap = tenderProject.calcProgram.compiledTemplateMaps
                let CostTypeNo = '';
                if (feeRateMap[calcMap[item.programID]]) CostTypeNo = feeRateMap[calcMap[item.programID]];
                const attrs = [{
                    name: "Code",
                    value: item.code,
                  }, {
                    name: 'Name',
                    value: item.name
                  }, {
                    name: 'Spec',
                    value: item.specs
                  }, {
                    name: 'Unit',
                    value: item.unit
                  }, {
                    name: 'Num',
                    value: item.tenderQuantity
                  }, {
                    name: 'BasePrice',
                    value: BasePrice
                  }, {
                    name: 'Price',
                    value: item.feesIndex && item.feesIndex.common ? item.feesIndex.common.tenderUnitFee : 0
                  }, {
                    name: 'IsEquipment',
                    value: item.subType == gljType.EQUIPMENT ? 1 : 0
                  }, {
                    name: 'CostTypeNo',
                    value: CostTypeNo
                  }, {
                    name: 'ProfitRate',
                    value: getFeeRate(item.programID, 'profit', tenderProject)
  
                  },
                  {
                    name: 'TaxRate',
                    value: getFeeRate(item.programID, 'tax', tenderProject)
                  },
                  {
                    name: 'MpRatio',
                    value: item.subType == gljType.LABOUR ? 100 : 0
                  },
                  {
                    name: 'MaterialRatio',
                    value: item.subType == gljType.GENERAL_MATERIAL ? 100 : 0
                  },
                  {
                    name: 'MechRatio',
                    value: item.subType == gljType.GENERAL_MACHINE ? 100 : 0
                  }
                ]
                Element.call(this, "Cost", attrs);
                this.children.push(CostStructure(item));
              }
  
  
              function Ration(ration) {
                let calcMap = tenderProject.calcProgram.compiledTemplateMaps
                let CostTypeNo = '';
                if (feeRateMap[calcMap[ration.programID]]) CostTypeNo = feeRateMap[calcMap[ration.programID]];
                const attrs = [{
                    name: "NormLibNo",
                    value: 'YSDE-000000-2018-86',
                  }, {
                    name: 'DisplayCode',
                    value: ration.code
                  }, {
                    name: 'Name',
                    value: ration.name
                  }, {
                    name: 'Unit',
                    value: ration.unit
                  }, {
                    name: 'Num',
                    value: ration.tenderQuantity
                  },
                  {
                    name: 'CostTypeNo',
                    value: CostTypeNo
                  },
                  {
                    name: 'ProfitRate',
                    value: getFeeRate(ration.programID, 'profit', tenderProject) //tenderProject.ProfitRate
                  },
                  {
                    name: 'TaxRate',
                    value: getFeeRate(ration.programID, 'tax', tenderProject) //tenderProject.TaxRate
                  },
                  {
                    name: 'FabricationCost',
                    value: ration.feesIndex && ration.feesIndex.common ? ration.feesIndex.common.tenderTotalFee : 0
                  },
                  {
                    name: 'AdjustStatus',
                    value: ration.adjustState
                  }
                ]
                Element.call(this, "Norm", attrs);
                this.children.push(CostStructure(ration));
                this.children.push(Consume(ration));
              }
            }
  
            function Consume(ration) {
              let consume = new emptyElement('Consume');
              for (let rg of ration.rationGLJList) {
                consume.children.push(new ConsumeItem(rg));
              }
              return consume;
  
              function ConsumeItem(rg) {
                const attrs = [{
                  name: "Code",
                  value: rg.code,
                }, {
                  name: "Consumption",
                  value: rg.tenderQuantity
                }];
                Element.call(this, "ConsumeItem", attrs);
  
              }
  
            }
  
  
            function CostStructure(item) {
              let CostStructure = new emptyElement('CostStructure');
              for (let f of cpFeeTypes) {
                if(itemFeeMap[f.type]) CostStructure.children.push(new CostItem(item,f.type))
              }
              if (CostStructure.children.length == 0) CostStructure.children.push(new CostItem({},""))
              function CostItem(item,type) {
                const attrs = [{
                  name: "ItemNo",
                  value: itemFeeMap[type],
                }, {
                  name: 'Sum',
                  value: 0 //fee.tenderTotalFee
                }]
                if ((isBidSubmission || isControl) && item.feesIndex && item.feesIndex[type]) attrs[1].value = item.feesIndex[type].tenderTotalFee;
                Element.call(this, "CostItem", attrs);
              }
              return CostStructure;
            }
  
  
          }
        }
      }
  
      function Params(tenderProject) {
        let feature = tenderProject.property.projectFeature ? tenderProject.property.projectFeature : [];
        let featrueMap = {};
        let baseMap = {};
        for (let f of feature) {
          featrueMap[f.key] = f;
        }
        let baseInfo = _.find(tenderProject.property.basicInformation, {
          dispName: "基本信息",
        });
        for (let i of baseInfo.items) {
          let key = i.key;
          //if (i.dispName == "编制日期") key = "编制时间";
          baseMap[key] = i;
        }
  
  
        let BuildType = "";
        if (baseMap["natureConstruction"].value == "新建") BuildType = 0;
        if (baseMap["natureConstruction"].value == "改扩建") BuildType = 1;
        let Terrain = "";
        if (baseMap["terrainCategory"].value == "平原微丘") Terrain = 0;
        if (baseMap["terrainCategory"].value == "山岭重丘") Terrain = 1;
        let DesignSpeed = featrueMap["designSpeed"].value;
        let Structure = "";
        if (featrueMap["pavementStructure"].value == "沥青路面") Structure = 0;
        if (featrueMap["pavementStructure"].value == "水泥混凝土路面") Structure = 1;
        if (featrueMap["pavementStructure"].value == "其他类型路面") Structure = 2;
        let RoadGrade = "";
        if (RoadGradeMap[baseMap["roadGrade"].value]) RoadGrade = RoadGradeMap[baseMap["roadGrade"].value];
  
        const attrs = [{
            name: "PrjArea",
            value: baseMap["location"] ? baseMap["location"].value : ""
          },
          {
            name: "StartPileNo",
            value: baseMap["startChainages"] ? baseMap["startChainages"].value : "",
            mustHasValue: true
          },
          {
            name: "EndPileNo",
            value: baseMap["endChainages"] ? baseMap["endChainages"].value : "",
            mustHasValue: true
          },
          {
            name: "BuildType",
            value: BuildType,
          },
          {
            name: "Terrain",
            value: Terrain,
            mustHasValue: true
          },
          {
            name: "RoadGrade",
            value: RoadGrade,
            mustHasValue: true
          },
          {
            name: "DesignSpeed",
            value: DesignSpeed,
            mustHasValue: true
          },
          {
            name: "Structure",
            value: Structure,
            mustHasValue: true
          },
          {
            name: "SubgradeWidth",
            value: featrueMap["subgradeWidth"] ? featrueMap["subgradeWidth"].value : "",
            mustHasValue: true
          },
          {
            name: "RoadLength",
            value: featrueMap["roadLength"] ? featrueMap["roadLength"].value : "",
            mustHasValue: true
          },
          {
            name: "BridgeLength",
            value: featrueMap["bridgeLength"] ? featrueMap["bridgeLength"].value : "",
            mustHasValue: true
          },
          {
            name: "TunnelLength",
            value: featrueMap["tunnelLength"] ? featrueMap["tunnelLength"].value : "",
            mustHasValue: true
          },
          {
            name: "BriTunRate",
            value: featrueMap["briTunRate"] ? featrueMap["briTunRate"].value : "",
            mustHasValue: true
          },
          {
            name: "InterchangeNum",
            value: featrueMap["interchangeNum"] ? featrueMap["interchangeNum"].value : "",
            mustHasValue: true
          },
          {
            name: "StubLengths",
            value: featrueMap["stubLengths"] ? featrueMap["stubLengths"].value : "",
            mustHasValue: true
          },
          {
            name: "LaneLength",
            value: featrueMap["laneLength"] ? featrueMap["laneLength"].value : "",
            mustHasValue: true
          },
        ];
        Element.call(this, "Params", attrs);
      }
  
      function SummaryOfCost(totalItem, proItem,safeItem,oneToSevenItem,feature) {
        let attrs = [{
            name: "TenderSumLimit",
            value: totalItem.feesIndex && totalItem.feesIndex.common && totalItem.feesIndex.common.tenderTotalFee ? totalItem.feesIndex.common.tenderTotalFee : 0,
            type: TYPE.DECIMAL,
            toFix:2,
          },
          {
            name: "BidTotal",
            value: totalItem.feesIndex && totalItem.feesIndex.common && totalItem.feesIndex.common.tenderTotalFee ? totalItem.feesIndex.common.tenderTotalFee : 0,
            type: TYPE.DECIMAL,
            toFix:2,
          },
          {
            name: "BillTotal",
            value: oneToSevenItem.feesIndex && oneToSevenItem.feesIndex.common && oneToSevenItem.feesIndex.common.tenderTotalFee ? oneToSevenItem.feesIndex.common.tenderTotalFee : 0,
            type: TYPE.DECIMAL,
            toFix:2,
          },
          {
            name: "CostForHSE",
            value: safeItem && safeItem.feesIndex && safeItem.feesIndex.common && safeItem.feesIndex.common.tenderTotalFee ? safeItem.feesIndex.common.tenderTotalFee : 0,
            type: TYPE.DECIMAL,
            toFix:2,
          },
          {
            name: "ProvisionalSums",
            value: proItem.feesIndex && proItem.feesIndex.common && proItem.feesIndex.common.tenderTotalFee ? proItem.feesIndex.common.tenderTotalFee : 0,
            type: TYPE.DECIMAL,
            toFix:2,
          },
          {
            name: "Appraisal",
            value: totalItem.feesIndex && totalItem.feesIndex.estimate && totalItem.feesIndex.estimate.tenderTotalFee ? totalItem.feesIndex.estimate.tenderTotalFee : 0,
            type: TYPE.DECIMAL,
            toFix:2,
          },
        ];
        if (isBidInvitation) { 
          attrs.splice(0, 3) //招标
        } 
        //if (isControl) attrs.splice(1, 5); //控制价
        if (isBidSubmission) { //投标文件时，读工程特征中的 招标控制价 值
          let tenderSumLimit = _.find(feature, { "key": "tenderSumLimit" }); 
          if(tenderSumLimit) attrs[0].value = tenderSumLimit.value
        } 
        Element.call(this, "SummaryOfCost", attrs);
      }
  
      function MakeInfo(tenderProject) {
        let property = tenderProject.property;
        let baseMap = {};
        let baseInfo = _.find(property.basicInformation, {
          dispName: "基本信息",
        });
        for (let i of baseInfo.items) {
          let key = i.key;
          //if (i.dispName == "编制日期") key = "编制时间";
          baseMap[key] = i;
        }
        //mustHasValue  
        const attrs = [{
            name: "ValuationModel",
            value: property.taxType,
          },
          {
            name: "Manage",
            value: baseMap["constructingUnit"] ? baseMap["constructingUnit"].value : "",
          },
          {
            name: "Designer",
            value: baseMap["designUnit"] ? baseMap["designUnit"].value : "",
            mustHasValue:true
          },
          {
            name: "Compile",
            value: baseMap["compileUnit"] ? baseMap["compileUnit"].value : "",
          },
          {
            name: "CompileApprover",
            value: baseMap["compileApprover"] ? baseMap["compileApprover"].value : "",
          },
          {
            name: "CompileCertNo",
            value: baseMap["compileCertNo"] ? baseMap["compileCertNo"].value : "",
            mustHasValue:true
          },
          {
            name: "CompileDate",
            value: baseMap["compileDate"] && baseMap["compileDate"].value != "" ? baseMap["compileDate"].value + "T00:00:00" : "",
            mustHasValue:true
          },
          {
            name: "Review",
            value: baseMap["reviewUnit"] ? baseMap["reviewUnit"].value : "",
            mustHasValue:true
          },
          {
            name: "ReviewApprover",
            value: baseMap["reviewApprover"] ? baseMap["reviewApprover"].value : "",
            mustHasValue:true
          },
          {
            name: "ReviewCertNo",
            value: baseMap["reviewCertNo"] ? baseMap["reviewCertNo"].value : "",
            mustHasValue:true
          },
          {
            name: "ReviewDate",
            value: baseMap["reviewDate"] && baseMap["reviewDate"].value != "" ? baseMap["reviewDate"].value + "T00:00:00" : "",
            mustHasValue:true
          },
          {
            name: "Examine",
            value: baseMap["examineUnit"] ? baseMap["examineUnit"].value : "",
            mustHasValue:true
          },
          {
            name: "ExamineApprover",
            value: baseMap["examineApprover"] ? baseMap["examineApprover"].value : "",
            mustHasValue:true
          },
          {
            name: "ExamineCertNo",
            value: baseMap["examineCertNo"] ? baseMap["examineCertNo"].value : "",
            mustHasValue:true
          },
          {
            name: "ExamineDate",
            value: baseMap["examineDate"] && baseMap["examineDate"].value != "" ? baseMap["examineDate"].value + "T00:00:00" : "",
            mustHasValue:true
          },
          {
            name: "CompileExplain",
            value: baseMap["compileExplain"] ? baseMap["compileExplain"].value : "",
            mustHasValue:true
          },
          {
            name: "ExamineExplain",
            value: baseMap["examineExplain"] ? baseMap["examineExplain"].value : "",
            mustHasValue:true
          },
          {
            name: "ProjectExplain",
            value: baseMap["projectExplain"] ? baseMap["projectExplain"].value : "",
            mustHasValue:true
          },
        ];
        if (isBidInvitation) { //招标文件，则以下的8、12~18则不输出
          attrs.splice(11, 7);
          attrs.splice(7, 1);
        }
        Element.call(this, "MakeInfo", attrs);
      }
  
      let data = new CprjInfo(projectData.name); 
      data.children.push(new SystemInfo(projectData));
      data.children.push(new CostBasis());
      let seriNo = 1;
      let Rates = [];
      let Practs = [];
      let EprjInfos = [];
      for (let c of projectData.children) {
        let tenderProject = tenderDetailMap[c.ID];
        let feeRataDatas = tenderProject.FeeRate.datas;
        Rates.push(new Rate(tenderProject, feeRataDatas, seriNo));
        Practs.push(new Pract(tenderProject, seriNo));
        EprjInfos.push(new EprjInfo(tenderProject));
        seriNo++;
      }
      data.children.push(...Rates,...Practs,...EprjInfos);
      return [{
        data: data,
        exportKind: exportKind,
        fileName: projectData.name + INTERFACE_CONFIG[areaKey]["fileSuffix"][exportKind],
      }, ];
    }

    // 山东需求，要有密文校验信息(SM3算法)
    function SM3() {
        if (!(this instanceof SM3)) {
            return new SM3();
        }
     
        this.reg = new Array(8);
        this.chunk = [];
        this.size = 0;
     
        this.reset();
    }
     
    SM3.prototype.reset = function() {
        this.reg[0] = 0x7380166f;
        this.reg[1] = 0x4914b2b9;
        this.reg[2] = 0x172442d7;
        this.reg[3] = 0xda8a0600;
        this.reg[4] = 0xa96f30bc;
        this.reg[5] = 0x163138aa;
        this.reg[6] = 0xe38dee4d;
        this.reg[7] = 0xb0fb0e4e;
        this.chunk = [];
        this.size = 0;
    };
     
    /**
     * 字符串转byte数组
     */
    SM3.prototype.strToBytes= function (s) {
      var ch, st, re = [];
      for (var i = 0; i < s.length; i++ ) {
        ch = s.charCodeAt(i);  
        st = [];                 
        do {
          st.push( ch & 0xFF );  
          ch = ch >> 8;          
        }
        while ( ch );
        re = re.concat( st.reverse() );
      }
      return re;
    };
     
    SM3.prototype.write = function(msg) {
        var m = (typeof msg === 'string') ? this.strToBytes(msg) : msg;
        this.size += m.length;
        var i = 64 - this.chunk.length;
        if (m.length < i) {
            this.chunk = this.chunk.concat(m);
            return;
        }
     
        this.chunk = this.chunk.concat(m.slice(0, i));
        while (this.chunk.length >= 64) {
            this._compress(this.chunk);
            if (i < m.length) {
                this.chunk = m.slice(i, Math.min(i + 64, m.length));
            } else {
                this.chunk = [];
            }
            i += 64;
        }
    };
     
    /**
     * 计算hash值
     */
    SM3.prototype.sum = function(msg, enc) {
        if (msg) {
            this.reset();
            this.write(msg);
        }
     
        this._fill();
        for (var i = 0; i < this.chunk.length; i += 64) {
            this._compress(this.chunk.slice(i, i + 64));
        }
     
        var digest = null;
        if (enc == 'hex') {
            digest = "";
            for (var i = 0; i < 8; i++) {
                digest += this.reg[i].toString(16);
            }
        } else {
            var digest = new Array(32);
            for (var i = 0; i < 8; i++) {
                var h;
                h = this.reg[i];
                digest[i * 4 + 3] = (h & 0xff) >>> 0;
                h >>>= 8;
                digest[i * 4 + 2] = (h & 0xff) >>> 0;
                h >>>= 8;
                digest[i * 4 + 1] = (h & 0xff) >>> 0;
                h >>>= 8;
                digest[i * 4] = (h & 0xff) >>> 0;
            }
        }
     
        this.reset();
        return digest;
    };
     
    SM3.prototype._compress = function(m) {
        if (m < 64) {
            console.error("compress error: not enough data");
            return;
        }
        var w = this._expand(m);
        var r = this.reg.slice(0);
        for (var j = 0; j < 64; j++) {
            var ss1 = this._rotl(r[0], 12) + r[4] + this._rotl(this._t(j), j)
            ss1 = (ss1 & 0xffffffff) >>> 0;
            ss1 = this._rotl(ss1, 7);
     
            var ss2 = (ss1 ^ this._rotl(r[0], 12)) >>> 0;
     
            var tt1 = this._ff(j, r[0], r[1], r[2]);
            tt1 = tt1 + r[3] + ss2 + w[j + 68];
            tt1 = (tt1 & 0xffffffff) >>> 0;
     
            var tt2 = this._gg(j, r[4], r[5], r[6]);
            tt2 = tt2 + r[7] + ss1 + w[j];
            tt2 = (tt2 & 0xffffffff) >>> 0;
     
            r[3] = r[2];
            r[2] = this._rotl(r[1], 9);
            r[1] = r[0];
            r[0] = tt1;
            r[7] = r[6]
            r[6] = this._rotl(r[5], 19);
            r[5] = r[4];
            r[4] = (tt2 ^ this._rotl(tt2, 9) ^ this._rotl(tt2, 17)) >>> 0;
        }
     
        for (var i = 0; i < 8; i++) {
            this.reg[i] = (this.reg[i] ^ r[i]) >>> 0;
        }
    };
     
    SM3.prototype._fill = function() {
        var l = this.size * 8;
        var len = this.chunk.push(0x80) % 64;
        if (64 - len < 8) {
            len -= 64;
        }
        for (; len < 56; len++) {
            this.chunk.push(0x00);
        }
     
        for (var i = 0; i < 4; i++) {
            var hi = Math.floor(l / 0x100000000);
            this.chunk.push((hi >>> ((3 - i) * 8)) & 0xff);
        }
        for (var i = 0; i < 4; i++) {
            this.chunk.push((l >>> ((3 - i) * 8)) & 0xff);
        }
    };
     
    SM3.prototype._expand = function(b) {
        var w = new Array(132);
        for (var i = 0; i < 16; i++) {
            w[i] = b[i * 4] << 24;
            w[i] |= b[i * 4 + 1] << 16;
            w[i] |= b[i * 4 + 2] << 8;
            w[i] |= b[i * 4 + 3];
            w[i] >>>= 0;
        }
     
        for (var j = 16; j < 68; j++) {
            var x;
            x = w[j - 16] ^ w[j - 9] ^ this._rotl(w[j - 3], 15);
            x = x ^ this._rotl(x, 15) ^ this._rotl(x, 23);
            w[j] = (x ^ this._rotl(w[j - 13], 7) ^ w[j - 6]) >>> 0;
        }
     
        for (var j = 0; j < 64; j++) {
            w[j + 68] = (w[j] ^ w[j + 4]) >>> 0;
        }
     
        return w;
    };
     
    SM3.prototype._rotl = function(x, n) {
        n %= 32;
        return ((x << n) | (x >>> (32 - n))) >>> 0;
    };
     
    SM3.prototype._t = function(j) {
        if (0 <= j && j < 16) {
            return 0x79cc4519;
        } else if (16 <= j && j < 64) {
            return 0x7a879d8a;
        } else {
            console.error("invalid j for constant Tj");
        }
    };
     
    SM3.prototype._ff = function(j, x, y, z) {
        if (0 <= j && j < 16) {
            return (x ^ y ^ z) >>> 0;
        } else if (16 <= j && j < 64) {
            return ((x & y) | (x & z) | (y & z)) >>> 0;
        } else {
            console.error("invalid j for bool function FF");
            return 0;
        }
    };
     
    SM3.prototype._gg = function(j, x, y, z) {
        if (0 <= j && j < 16) {
            return (x ^ y ^ z) >>> 0;
        } else if (16 <= j && j < 64) {
            return ((x & y) | (~x & z)) >>> 0;
        } else {
            console.error("invalid j for bool function GG");
            return 0;
        }
    };
     
    /**
     * 等效于Array.from目的是做浏览器兼容处理 Array.from IE浏览器不支持
     */
    SM3.prototype.toArray = function(s, f){
        var a = [];
        for(var i=0; i<s.length; i++){
            var t  = s[i];
            if(f){
                t = f(t);
            }
            a.push(t);
        }
        return a;
    };

    /**
     * SM3加密主函数
     * @param msg
     * @returns
     */
    function sm3Digest(msg){
        var _sm3 = new SM3();
        var digest = _sm3.sum(msg);
        var hashHex = _sm3.toArray(digest, function(byte) {return ('0' + (byte & 0xFF).toString(16)).slice(-2);}).join('');
        return hashHex;
    }
    
    return {
      entry,
    };
  })();