YangHuCost/web/over_write/js/sichuan_2018.js

// 部颁2018计价标准

function overwriteRationCalcBases() {
  if (typeof rationCalcBases == "undefined") return;
  for (let key in rationCalcBases) delete rationCalcBases[key];

  rationCalcBases["人工费"] = function (node, isTender) {
    return calcTools.rationBaseFee(node, [gljType.LABOUR], priceTypes.ptMarketPrice, isTender);
  };
  rationCalcBases["材料费"] = function (node, isTender) {
    return calcTools.rationBaseFee(node, baseMaterialTypes, priceTypes.ptMarketPrice, isTender);
  };
  rationCalcBases["施工机械使用费"] = function (node, isTender) {
    return calcTools.rationBaseFee(node, baseMachineTypes, priceTypes.ptMarketPrice, isTender);
  };
  rationCalcBases["施工机械人工费"] = function (node, isTender) {
    return calcTools.machineDetailFee(node, node.data.gljList, [], gljType.MACHINE_LABOUR, isTender);
  };
  rationCalcBases["设备购置费"] = function (node, isTender) {
    return calcTools.rationBaseFee(node, [gljType.EQUIPMENT], priceTypes.ptMarketPrice, isTender);
  };

  rationCalcBases["定额人工费"] = function (node, isTender) {
    return calcTools.rationBaseFee(node, [gljType.LABOUR], priceTypes.ptBasePrice, isTender);
  };
  rationCalcBases["定额材料费"] = function (node, isTender) {
    return calcTools.rationBaseFee(node, baseMaterialTypes, priceTypes.ptBasePrice, isTender);
  };
  rationCalcBases["定额施工机械使用费"] = function (node, isTender) {
    return calcTools.rationBaseFee(node, baseMachineTypes, priceTypes.ptBasePrice, isTender);
  };
  rationCalcBases["定额商品砼费"] = function (node, isTender) {
    return calcTools.rationBaseFee(node, [gljType.COMMERCIAL_CONCRETE, gljType.COMMERCIAL_MORTAR], priceTypes.ptBasePrice, isTender);
  };
  rationCalcBases["定额设备费"] = function (node, isTender) {
    return calcTools.rationBaseFee(node, [gljType.EQUIPMENT], priceTypes.ptBasePrice, isTender);
  };
  rationCalcBases["定额外购砼构件费"] = function (node, isTender) {
    return calcTools.rationBaseFee(node, [gljType.PURCHASE_COMPONENT], priceTypes.ptBasePrice, isTender);
  };
  rationCalcBases["定额绿化苗木费"] = function (node, isTender) {
    return calcTools.rationBaseFee(node, [gljType.GREEN_SEEDLING], priceTypes.ptBasePrice, isTender);
  };
}

(function overwriteFeeTypes() {
  if (typeof cpFeeTypes == "undefined") return;
  cpFeeTypes = [
    {
      type: "marketLabour",
      name: "人工费",
    },
    {
      type: "marketMaterial",
      name: "材料费",
    },
    {
      type: "marketMachine",
      name: "施工机械使用费",
    },
    {
      type: "marketMachineLabour",
      name: "施工机械人工费",
    },
    {
      type: "marketEquipment",
      name: "设备购置费",
    },
    {
      type: "marketDirect",
      name: "直接费",
    },

    {
      type: "labour",
      name: "定额人工费",
    },
    {
      type: "material",
      name: "定额材料费",
    },
    {
      type: "machine",
      name: "定额施工机械使用费",
    },
    {
      type: "equipment",
      name: "定额设备费",
    },
    {
      type: "direct",
      name: "定额直接费",
    },

    {
      type: "measure",
      name: "措施费",
    },
    {
      type: "measure1",
      name: "措施费I",
    },
    {
      type: "measure2",
      name: "措施费II",
    },
    {
      type: "manage",
      name: "企业管理费",
    },
    {
      type: "force",
      name: "规费",
    },
    {
      type: "profit",
      name: "利润",
    },
    {
      type: "tax",
      name: "税金",
    },
    {
      type: "common",
      name: "建安费",
    },
    {
      type: "rationCommon",
      name: "定额建安费",
    },
  ];
})();

// 在新建分段的时候需要隐藏养护类别和费用标准
if (typeof $ !== "undefined") {
  // 后端也有引用这个文件，后端引用时$没有定义会报错
  $(document).ready(function () {
    $("#tender-engineering-group").hide();
    $("#tender-feeStandard-group").hide();
  });
}

//全国工地转移、综合里程费率值修改特殊处理
if (typeof feeRateObject !== "undefined") {
  feeRateObject.feeRateSpecialHandle = function (subRate, value) {
    let result = {};
    if (subRate.name == "工地转移(km)" && value && value < 50) {
      //工地转移50km以内按50km算
      result.valueKey = "50";
      result.value = scMathUtil.roundForObj(value, getDecimal("feeRate")); //设置显示的节点值
    }
    if (subRate.name == "综合里程(km)" && value && value < 3) {
      //综合里程3km以内按3km算
      result.valueKey = "3";
      result.value = scMathUtil.roundForObj(value, getDecimal("feeRate")); //设置显示的节点值
    }
    return result;
  };
}

// 清单基数
const progression = ["施工场地建设费", "养护单位(业主)管理费", "建设项目信息化费", "工程监理费", "设计文件审查费", "前期工作费", "设计文件审查费(两阶段设计)"];
const deficiency = { 设计文件审查费: 2000, "设计文件审查费(两阶段设计)": 2000, 工程勘察费: 5000, 设计费: 5000, 招标费: 5000 };
if (typeof baseFigureMap !== "undefined") {
  const { fixedFlag } = commonConstants;
  baseFigureMap.boq = {
    // 取清单固定类别是“建筑安装工程费”的定额建安费(其中定额设备费按40%计算+全额设备税金)。除清单固定类别是“建筑安装工程费”的以外部分可显示。
    定额建筑安装工程费: {
      base: "DEJZAZGCFSBSS",
      fixedFlag: fixedFlag.CONSTRUCTION_INSTALL_FEE,
      filter: [fixedFlag.CONSTRUCTION_INSTALL_FEE],
      pick: false,
    },

    // 取清单固定类别是“建筑安装工程费”的金额，扣除设备购置。仅固定类别为“保险费”可显示。
    "建筑安装工程费(不含设备费)": {
      base: "JZAZGCFBHSB",
      fixedFlag: fixedFlag.CONSTRUCTION_INSTALL_FEE,
      filter: [fixedFlag.INSURANCE_FEE],
      pick: true,
    },

    各章清单合计: {
      base: "GZQDHJ",
      fixedFlag: fixedFlag.CONSTRUCTION_INSTALL_FEE,
      filter: [fixedFlag.CONSTRUCTION_INSTALL_FEE],
      pick: false,
    },
    /*
     *  清单固定行[第100章至700章清单]下的[第100章清单]需要允许清单可使用基数{100章以外合计}
     *  因此{100章以外合计}不设置关联的清单固定行
     * */
    // 仅允许用于固定类别为“100章清单”引用
    "100章以外清单合计": {
      base: "YBZYHQDHJ",
      fixedFlag: null,
      filter: [fixedFlag.ONE_HUNDRED_BILLS],
      pick: true,
    },
    // 显示：仅清单固定类别是“工程建设其他费”部分可显示
    "养护单位(业主)管理费": {
      isProgressive: true,
      base: "JSDWYZGLF",
      fixedFlag: fixedFlag.CONSTRUCTION_INSTALL_FEE,
      filter: [fixedFlag.MAINTENANCE_EXPENSES],
      pick: true,
    },
    // 显示：仅清单固定类别是“工程建设其他费”部分可显示
    建设项目信息化费: {
      isProgressive: true,
      base: "JSXMXXHF",
      fixedFlag: fixedFlag.CONSTRUCTION_INSTALL_FEE,
      filter: [fixedFlag.MAINTENANCE_EXPENSES],
      pick: true,
    },
    // 显示：仅清单固定类别是“工程建设其他费”部分可显示
    工程监理费: {
      isProgressive: true,
      base: "GCJLF",
      fixedFlag: fixedFlag.CONSTRUCTION_INSTALL_FEE,
      filter: [fixedFlag.MAINTENANCE_EXPENSES],
      pick: true,
    },
    // 显示：仅清单固定类别是“工程建设其他费”部分可显示
    设计文件审查费: {
      isProgressive: true,
      base: "SJWJSCF",
      fixedFlag: fixedFlag.CONSTRUCTION_INSTALL_FEE,
      filter: [fixedFlag.MAINTENANCE_EXPENSES],
      pick: true,
    },
    "设计文件审查费(两阶段设计)": {
      isProgressive: true,
      base: "SJWJSCFLJDSJ",
      fixedFlag: fixedFlag.CONSTRUCTION_INSTALL_FEE,
      filter: [fixedFlag.MAINTENANCE_EXPENSES],
      pick: true,
    },
    工程勘察费: {
      isProgressive: true,
      base: "GCKCF",
      fixedFlag: fixedFlag.CONSTRUCTION_INSTALL_FEE,
      filter: [fixedFlag.MAINTENANCE_EXPENSES],
      pick: true,
    },
    设计费: {
      isProgressive: true,
      base: "SJF",
      fixedFlag: fixedFlag.CONSTRUCTION_INSTALL_FEE,
      filter: [fixedFlag.MAINTENANCE_EXPENSES],
      pick: true,
    },
    招标费: {
      isProgressive: true,
      base: "ZBF",
      fixedFlag: fixedFlag.CONSTRUCTION_INSTALL_FEE,
      filter: [fixedFlag.MAINTENANCE_EXPENSES],
      pick: true,
    },
    "设计费(两阶段)": {
      isProgressive: true,
      base: "SJFLJD",
      fixedFlag: fixedFlag.CONSTRUCTION_INSTALL_FEE,
      filter: [fixedFlag.MAINTENANCE_EXPENSES],
      pick: true,
    },
    "设计费(独立立项进行维修、加固的桥隧工程)": {
      isProgressive: true,
      base: "SJFDLLX",
      fixedFlag: fixedFlag.CONSTRUCTION_INSTALL_FEE,
      filter: [fixedFlag.MAINTENANCE_EXPENSES],
      pick: true,
    },
    "设计费(机电工程)": {
      isProgressive: true,
      base: "SJFJDGC",
      fixedFlag: fixedFlag.CONSTRUCTION_INSTALL_FEE,
      filter: [fixedFlag.MAINTENANCE_EXPENSES],
      pick: true,
    },
    "设计费(应急抢险工程)": {
      isProgressive: true,
      base: "SJFYJQXGC",
      fixedFlag: fixedFlag.CONSTRUCTION_INSTALL_FEE,
      filter: [fixedFlag.MAINTENANCE_EXPENSES],
      pick: true,
    },

    // 显示：仅清单固定类别是“工程建设其他费”部分可显示
    // 前期工作费: {
    //   isProgressive: true,
    //   base: "QQGZF",
    //   fixedFlag: fixedFlag.CONSTRUCTION_INSTALL_FEE,
    //   filter: [fixedFlag.MAINTENANCE_EXPENSES],
    //   pick: true,
    // },
  };
}

if (typeof baseFigureTemplate !== "undefined") {
  const { fixedFlag } = commonConstants;

  baseFigureTemplate.boq = {
    // 定额建筑安装工程费 算法：取“定额建筑安装工程费”的金额
    DEJZAZGCF(tender) {
      return cbTools.getBaseFee(fixedFlag.CONSTRUCTION_INSTALL_FEE, tender, "rationCommon");
    },
    DEJZAZGCFSBSS(tender) {
      let baseFee = this["DEJZAZGCF"](tender);
      const fixedNode = projectObj.project.mainTree.roots.find((node) => node.getFlag() === fixedFlag.CONSTRUCTION_INSTALL_FEE);
      const equipmentFee = cbTools.getEquipmentFee(fixedNode, tender, "equipment");
      baseFee = (baseFee - equipmentFee * 0.6).toDecimal(decimalObj.process);
      return baseFee.toDecimal(decimalObj.bills.totalPrice);
    },
    JZAZGCFBHSB(tender) {
      let baseFee = this["JZAZGCF"](tender);
      const fixedNode = projectObj.project.mainTree.roots.find((node) => node.getFlag() === fixedFlag.CONSTRUCTION_INSTALL_FEE);
      const equipmentFee = cbTools.getEquipmentFee(fixedNode, tender);
      baseFee = (baseFee - equipmentFee).toDecimal(decimalObj.process);
      return baseFee.toDecimal(decimalObj.bills.totalPrice);
    },
    //{各章清单合计}
    // 取清单固定类别是“第100章至700章清单”的金额
    GZQDHJ: function (tender) {
      return cbTools.getBaseFee(fixedFlag.CONSTRUCTION_INSTALL_FEE, tender, "common");
    },
    //{100章以外清单合计}
    // 取清单固定清单[第100章至700章清单]的金额，但扣除清单100章下的金额。
    // 如果是固定清单[第100章至700章清单]下100章以外清单引用此基数，要排除自身(目前只允许100章的清单使用，所以暂时不需要此判断)
    YBZYHQDHJ: function (tender) {
      let oneToSeven = cbTools.findNodeByFlag(fixedFlag.CONSTRUCTION_INSTALL_FEE);
      if (!oneToSeven) {
        return 0;
      }
      //100-700章固定节点的所有子节点
      let allChildren = [];
      function getChildren(nodes) {
        allChildren = allChildren.concat(nodes);
        for (let node of nodes) {
          if (node.children.length > 0) {
            getChildren(node.children);
          }
        }
      }
      getChildren(oneToSeven.children);
      //扣除的节点：100章的节点[100-200)
      let deductNodes = allChildren.filter(cbTools.withingOneHundred);
      //计算金额
      let fullFeeField = tender ? "common.tenderTotalFee" : "common.totalFee";
      return projectObj.project.calcProgram.getTotalFee([oneToSeven], deductNodes, fullFeeField).toDecimal(decimalObj.bills.totalPrice);
    },
    // 养护单位(业主)管理费 算法：按“定额建筑安装工程费”总和为基数，以累进办法计算
    // 【变更】：算法：按【固定类别是“建筑安装工程费”的“定额建安费”，扣除“设备”的“定额设备费”*60%】为基数，以累进办法计算。
    JSDWYZGLF(tender) {
      let baseFee = baseFigureTemplate.boq["DEJZAZGCF"](tender);
      const fixedNode = projectObj.project.mainTree.roots.find((node) => node.getFlag() === fixedFlag.CONSTRUCTION_INSTALL_FEE);
      const equipmentFee = cbTools.getEquipmentFee(fixedNode, tender, "equipment");
      baseFee = (baseFee - equipmentFee * 0.6).toDecimal(decimalObj.process);
      if (!tender) {
        calcBase.baseProgressiveFee = baseFee;
      }
      return calculateUtil.getProgressiveFee(
        baseFee,
        "养护单位(业主)管理费",
        projectObj.project.property.progressiveInterval,
        decimalObj.bills.totalPrice,
        deficiency
      );
    },
    // 建设项目信息化费 算法：按“定额建筑安装工程费”总和为基数，以累进办法计算
    // 【变更】：算法：按【固定类别是“建筑安装工程费”的“定额建安费”，扣除“设备”的“定额设备费”*60%】为基数，以累进办法计算。
    JSXMXXHF(tender) {
      let baseFee = baseFigureTemplate.boq["DEJZAZGCF"](tender);
      const fixedNode = projectObj.project.mainTree.roots.find((node) => node.getFlag() === fixedFlag.CONSTRUCTION_INSTALL_FEE);
      const equipmentFee = cbTools.getEquipmentFee(fixedNode, tender, "equipment");
      baseFee = (baseFee - equipmentFee * 0.6).toDecimal(decimalObj.process);
      if (!tender) {
        calcBase.baseProgressiveFee = baseFee;
      }
      return calculateUtil.getProgressiveFee(
        baseFee,
        "建设项目信息化费",
        projectObj.project.property.progressiveInterval,
        decimalObj.bills.totalPrice,
        deficiency
      );
    },
    // 工程监理费 算法：按“定额建筑安装工程费”总和为基数，以累进办法计算
    // 【变更】：算法：按【固定类别是“建筑安装工程费”的“定额建安费”，扣除“设备”的“定额设备费”*60%】为基数，以累进办法计算。
    GCJLF(tender) {
      let baseFee = baseFigureTemplate.boq["DEJZAZGCF"](tender);
      const fixedNode = projectObj.project.mainTree.roots.find((node) => node.getFlag() === fixedFlag.CONSTRUCTION_INSTALL_FEE);
      const equipmentFee = cbTools.getEquipmentFee(fixedNode, tender, "equipment");
      baseFee = (baseFee - equipmentFee * 0.6).toDecimal(decimalObj.process);
      if (!tender) {
        calcBase.baseProgressiveFee = baseFee;
      }
      return calculateUtil.getProgressiveFee(baseFee, "工程监理费", projectObj.project.property.progressiveInterval, decimalObj.bills.totalPrice, deficiency);
    },
    // 设计文件审查费 算法：按“定额建筑安装工程费”总和为基数，以累进办法计算
    // 【变更】：算法：按【固定类别是“建筑安装工程费”的“定额建安费”，扣除“设备”的“定额设备费”*60%】为基数，以累进办法计算。
    SJWJSCF(tender) {
      let baseFee = baseFigureTemplate.boq["DEJZAZGCF"](tender);
      const fixedNode = projectObj.project.mainTree.roots.find((node) => node.getFlag() === fixedFlag.CONSTRUCTION_INSTALL_FEE);
      const equipmentFee = cbTools.getEquipmentFee(fixedNode, tender, "equipment");
      baseFee = (baseFee - equipmentFee * 0.6).toDecimal(decimalObj.process);
      if (!tender) {
        calcBase.baseProgressiveFee = baseFee;
      }
      return calculateUtil.getProgressiveFee(
        baseFee,
        "设计文件审查费",
        projectObj.project.property.progressiveInterval,
        decimalObj.bills.totalPrice,
        deficiency
      );
    },
    SJWJSCFLJD(tender) {
      let baseFee = baseFigureTemplate.boq["DEJZAZGCF"](tender);
      const fixedNode = projectObj.project.mainTree.roots.find((node) => node.getFlag() === fixedFlag.CONSTRUCTION_INSTALL_FEE);
      const equipmentFee = cbTools.getEquipmentFee(fixedNode, tender, "equipment");
      baseFee = (baseFee - equipmentFee * 0.6).toDecimal(decimalObj.process);
      if (!tender) {
        calcBase.baseProgressiveFee = baseFee;
      }
      return calculateUtil.getProgressiveFee(
        baseFee,
        "设计文件审查费(两阶段设计)",
        projectObj.project.property.progressiveInterval,
        decimalObj.bills.totalPrice,
        deficiency
      );
    },
    GCKCF(tender) {
      let baseFee = baseFigureTemplate.boq["DEJZAZGCF"](tender);
      const fixedNode = projectObj.project.mainTree.roots.find((node) => node.getFlag() === fixedFlag.CONSTRUCTION_INSTALL_FEE);
      const equipmentFee = cbTools.getEquipmentFee(fixedNode, tender, "equipment");
      baseFee = (baseFee - equipmentFee * 0.6).toDecimal(decimalObj.process);
      if (!tender) {
        calcBase.baseProgressiveFee = baseFee;
      }
      return calculateUtil.getProgressiveFee(baseFee, "工程勘察费", projectObj.project.property.progressiveInterval, decimalObj.bills.totalPrice, deficiency);
    },
    SJF(tender) {
      let baseFee = baseFigureTemplate.boq["DEJZAZGCF"](tender);
      const fixedNode = projectObj.project.mainTree.roots.find((node) => node.getFlag() === fixedFlag.CONSTRUCTION_INSTALL_FEE);
      const equipmentFee = cbTools.getEquipmentFee(fixedNode, tender, "equipment");
      baseFee = (baseFee - equipmentFee * 0.6).toDecimal(decimalObj.process);
      if (!tender) {
        calcBase.baseProgressiveFee = baseFee;
      }
      return calculateUtil.getProgressiveFee(baseFee, "设计费", projectObj.project.property.progressiveInterval, decimalObj.bills.totalPrice, deficiency);
    },
    ZBF(tender) {
      let baseFee = baseFigureTemplate.boq["DEJZAZGCF"](tender);
      const fixedNode = projectObj.project.mainTree.roots.find((node) => node.getFlag() === fixedFlag.CONSTRUCTION_INSTALL_FEE);
      const equipmentFee = cbTools.getEquipmentFee(fixedNode, tender, "equipment");
      baseFee = (baseFee - equipmentFee * 0.6).toDecimal(decimalObj.process);
      if (!tender) {
        calcBase.baseProgressiveFee = baseFee;
      }
      return calculateUtil.getProgressiveFee(baseFee, "招标费", projectObj.project.property.progressiveInterval, decimalObj.bills.totalPrice, deficiency);
    },
    SJFLJD(tender) {
      let baseFee = baseFigureTemplate.boq["DEJZAZGCF"](tender);
      const fixedNode = projectObj.project.mainTree.roots.find((node) => node.getFlag() === fixedFlag.CONSTRUCTION_INSTALL_FEE);
      const equipmentFee = cbTools.getEquipmentFee(fixedNode, tender, "equipment");
      baseFee = (baseFee - equipmentFee * 0.6).toDecimal(decimalObj.process);
      if (!tender) {
        calcBase.baseProgressiveFee = baseFee;
      }
      return calculateUtil.getProgressiveFee(
        baseFee,
        "设计费(两阶段)",
        projectObj.project.property.progressiveInterval,
        decimalObj.bills.totalPrice,
        deficiency
      );
    },
    SJFDLLX(tender) {
      let baseFee = baseFigureTemplate.boq["DEJZAZGCF"](tender);
      const fixedNode = projectObj.project.mainTree.roots.find((node) => node.getFlag() === fixedFlag.CONSTRUCTION_INSTALL_FEE);
      const equipmentFee = cbTools.getEquipmentFee(fixedNode, tender, "equipment");
      baseFee = (baseFee - equipmentFee * 0.6).toDecimal(decimalObj.process);
      if (!tender) {
        calcBase.baseProgressiveFee = baseFee;
      }
      return calculateUtil.getProgressiveFee(
        baseFee,
        "设计费(独立立项进行维修、加固的桥隧工程)",
        projectObj.project.property.progressiveInterval,
        decimalObj.bills.totalPrice,
        deficiency
      );
    },
    SJFJDGC(tender) {
      let baseFee = baseFigureTemplate.boq["DEJZAZGCF"](tender);
      const fixedNode = projectObj.project.mainTree.roots.find((node) => node.getFlag() === fixedFlag.CONSTRUCTION_INSTALL_FEE);
      const equipmentFee = cbTools.getEquipmentFee(fixedNode, tender, "equipment");
      baseFee = (baseFee - equipmentFee * 0.6).toDecimal(decimalObj.process);
      if (!tender) {
        calcBase.baseProgressiveFee = baseFee;
      }
      return calculateUtil.getProgressiveFee(
        baseFee,
        "设计费(机电工程)",
        projectObj.project.property.progressiveInterval,
        decimalObj.bills.totalPrice,
        deficiency
      );
    },
    SJFYJQXGC(tender) {
      let baseFee = baseFigureTemplate.boq["DEJZAZGCF"](tender);
      const fixedNode = projectObj.project.mainTree.roots.find((node) => node.getFlag() === fixedFlag.CONSTRUCTION_INSTALL_FEE);
      const equipmentFee = cbTools.getEquipmentFee(fixedNode, tender, "equipment");
      baseFee = (baseFee - equipmentFee * 0.6).toDecimal(decimalObj.process);
      if (!tender) {
        calcBase.baseProgressiveFee = baseFee;
      }
      return calculateUtil.getProgressiveFee(
        baseFee,
        "设计费(应急抢险工程)",
        projectObj.project.property.progressiveInterval,
        decimalObj.bills.totalPrice,
        deficiency
      );
    },

    // 前期工作费 算法：按“定额建筑安装工程费”总和为基数，以累进办法计算
    // 变更：【算法】：按【固定类别是“建筑安装工程费”的“定额建安费”，扣除“设备”的“定额设备费”*60%】为基数，以累进办法计算。
    QQGZF(tender) {
      let baseFee = baseFigureTemplate.boq["DEJZAZGCF"](tender);
      const fixedNode = projectObj.project.mainTree.roots.find((node) => node.getFlag() === fixedFlag.CONSTRUCTION_INSTALL_FEE);
      const equipmentFee = cbTools.getEquipmentFee(fixedNode, tender, "equipment");
      baseFee = (baseFee - equipmentFee * 0.6).toDecimal(decimalObj.process);
      if (!tender) {
        calcBase.baseProgressiveFee = baseFee;
      }
      return calculateUtil.getProgressiveFee(baseFee, "前期工作费", projectObj.project.property.progressiveInterval, decimalObj.bills.totalPrice, deficiency);
    },
  };
}

if (typeof projectObj !== "undefined") {
  projectObj.isInsertEquipmentVisable = function (selected) {
    return true; //全国不管是预算或者工程量清单，都是显示
  };

  projectObj.getSaveProductionCostCode = function () {
    //公路云里18的清单范本安全生产费是102-3的；养护云里浙江养护的安全生产费是102-4。
    return "102-3";
  };
}
const defaultCalcMode = 1;

if (typeof module !== "undefined" && !module.nodeType) {
  module.exports = {
    progression,
    defaultCalcMode,
    deficiency,
  };
}