YangHuCost/web/building_saas/standard_interface/export/guangdong_zhongshan.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章至900章清单":"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章至900章清单" || data.name == "第100章至900章清单合计";
          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 hardID = UTIL.generateHardwareId();
      let [cpuId, diskId, macId] = hardID.split(";");
      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: "Key1",
          value: window.btoa(userID),
        },
        {
          name: "Key2",
          value: window.btoa(diskId),
        },
        {
          name: "Key3",
          value: window.btoa(macId),
        },
      ];
      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);
    }

    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],
    }, ];
  }
  return {
    entry,
  };
})();