YangHuCost/web/building_saas/pm/js/pm_newMain.js

/**
 * 项目管理相关js
 *
 * @author CaiAoLin
 * @date 2017/8/22
 * @version
 */
let Tree = null; //
let movetoZTree = null;
let copytoZTree = null;
let engineering = [];
let feeRateData = [];
let isSaving = false;
let projectProperty = [];
let fileDelObj = null;
let projectType = {
  folder: "Folder",
  tender: "Tender",
  project: "Project",
  engineering: "Engineering",
};
let fileType = {
  unitPriceFile: "UnitPriceFile",
  feeRateFile: "FeeRateFile",
};

let taxTypeMap = {
  1: "一般计税",
  2: "简易计税",
};

/*
 * 地区，同一费用定额下不同地区有不同单价，则新建单位工程时需要选择地区项
 * 地区项为空的时候，前端不显示该下拉项，地区的赋值覆盖在over_write相关文件中
 * */
let regions = [];

const {
  ValuationType: {
    SUGGESTION,
    FEASIBILITY,
    ROUGH,
    BUDGET,
    BILL_BUDGET,
    BOQ,
    ESTIMATION,
  },
  ValuationText,
  BOQType: { BID_INVITATION, BID_SUBMISSION },
} = window.commonConstants;
const { similarEqual, isDef } = window.commonUtil;

function isStopCreate() {
  const names = ['重庆养护(2018)', '内蒙古养护(2019)', '甘肃养护(2021)', '内蒙古高速公路养护(2022)', '内蒙古高速公路养护(2022)'];
  return !!(compilationData && names.includes(compilationData.name));
}

//操作状态
const STATE = {
  addingTender: false,
  addingProject: false,
  addingFolder: false,
  deleting: false,
  importing: false,
  moving: false,
};
const projTreeObj = {
  tree: null,
  workBook: null,
  copyToWorkBook: null,
  replaceWorkBook: null,
  copySelected: null,
  preSelection: null,
  changeInfo: null,
  setting: {
    tree: {
      id: "ID",
      pid: "ParentID",
      nid: "NextSiblingID",
      rootId: -1,
      autoUpdate: false,
    },
    //0.48 0.13 0.15 0.15 0.09
    header: [
      {
        name: "工程列表",
        dataCode: "name",
        width: 300,
        vAlign: "center",
        hAlign: "left",
      },
      {
        name: "总造价",
        dataCode: "totalCost",
        width: 100,
        vAlign: "center",
        hAlign: "right",
        formatter: "0.00",
      },
      {
        name: "项目类别",
        dataCode: "valuationType",
        width: 100,
        vAlign: "center",
        hAlign: "left",
      },
      {
        name: "单价文件",
        dataCode: "unitPriceFile",
        width: 140,
        vAlign: "center",
        hAlign: "left",
      },
      {
        name: "费率文件",
        dataCode: "feeRateFile",
        width: 140,
        vAlign: "center",
        hAlign: "left",
      },
      {
        name: "创建日期",
        dataCode: "createDateTime",
        width: 100,
        vAlign: "center",
        hAlign: "center",
      },
    ],
    //选中行颜色
    style: {
      defalutBackColor: "White",
      selectedColor: "#BBFFFF",
    },
    options: {
      tabStripVisible: false,
      allowContextMenu: false,
      allowCopyPasteExcelStyle: false,
      allowExtendPasteRange: false,
      allowUserDragDrop: false,
      allowUserDragFill: false,
      scrollbarMaxAlign: true,
      showDragDropTip: false,
    },
  },
  copyToSetting: {
    header: [
      {
        name: "工程列表",
        dataCode: "name",
        width: 550,
        vAlign: "center",
        hAlign: "left",
      },
    ],
    //选中行颜色
    style: {
      defalutBackColor: "White",
      selectedColor: "#BBFFFF",
    },
    options: {
      tabStripVisible: false,
      allowCopyPasteExcelStyle: false,
      allowExtendPasteRange: false,
      allowUserDragDrop: false,
      allowUserDragFill: false,
      scrollbarMaxAlign: true,
      showDragDropTip: false,
      allowContextMenu: false,
    },
  },
  replaceSetting: {
    header: [
      {
        name: "工程列表",
        dataCode: "name",
        width: 250,
        vAlign: "center",
        hAlign: "left",
      },
      {
        name: "选择",
        dataCode: "selected",
        width: 50,
        vAlign: "center",
        cellType: "checkBox",
      },
    ],
    //选中行颜色
    style: {
      defalutBackColor: "White",
      selectedColor: "#BBFFFF",
    },
    options: {
      tabStripVisible: false,
      allowCopyPasteExcelStyle: false,
      allowExtendPasteRange: false,
      allowUserDragDrop: false,
      allowUserDragFill: false,
      scrollbarMaxAlign: true,
      showDragDropTip: false,
      allowContextMenu: false,
    },
  },
  renderSheetFuc: function (sheet, fuc) {
    sheet.suspendPaint();
    sheet.suspendEvent();
    fuc();
    sheet.resumePaint();
    sheet.resumeEvent();
  },
  setOptions: function (workbook, opts) {
    for (let opt in opts) {
      workbook.options[opt] = opts[opt];
    }
  },
  bindEvent: function (workBook) {
    const _events = GC.Spread.Sheets.Events;
    let sheet = workBook.getActiveSheet();
    //改变选中节点set selected
    sheet.bind(_events.SelectionChanging, this.onSelectionChanging);
    sheet.bind(_events.EditStarting, this.onCellEditing);
    sheet.bind(_events.ClipboardPasting, this.onCellEditing);
    workBook.bind(_events.DragDropBlock, this.onDragDropBlock);
    workBook.bind(GC.Spread.Sheets.Events.ButtonClicked, this.changeFileClick);
  },
  buildHeader: function (sheet, headers) {
    let me = this;
    let fuc = function () {
      //sheet.options.isProtected = true;  //为了拖动功能，这里不设置protect,输入限制在editstarting控制
      sheet.options.protectionOptions = {
        allowResizeRows: true,
        allowResizeColumns: true,
      };
      sheet.setColumnCount(headers.length);
      sheet.setRowHeight(0, 40, GC.Spread.Sheets.SheetArea.colHeader);
      let workBookWidth = getWorkBookWidth();
      for (let i = 0, len = headers.length; i < len; i++) {
        sheet.setValue(
          0,
          i,
          headers[i].name,
          GC.Spread.Sheets.SheetArea.colHeader
        );
        let width = headers[i].width;
        sheet.setColumnWidth(i, width, GC.Spread.Sheets.SheetArea.colHeader);
        if (headers[i].formatter) {
          sheet.setFormatter(
            -1,
            i,
            headers[i].formatter,
            GC.Spread.Sheets.SheetArea.viewport
          );
        }
      }
    };
    me.renderSheetFuc(sheet, fuc);
  },
  buildSheet: function (workBook, spreadID, setting) {
    //改成和复制项目spread共用
    let newWorkBook = workBook;
    if (!workBook) {
      newWorkBook = new GC.Spread.Sheets.Workbook($("#" + spreadID)[0], {
        sheetCount: 1,
      });
      this.setOptions(newWorkBook, setting.options);
      this.buildHeader(newWorkBook.getActiveSheet(), setting.header);
      this.bindEvent(newWorkBook);
      this.loadContextMenu();
      this.loadStartMenu();
    } else {
      workBook.refresh();
    }
    return newWorkBook;
  },
  // 获取新建按钮是否是disabled
  getAddBtnDisabled: function (action) {
    switch (action) {
      case projectType.folder:
      case projectType.project:
      case projectType.tender:
        return false;
      default:
        return true;
    }
  },
  refreshAddMenuItems: function () {
    const items = [
      {
        el: $("#addFolderSub"),
        action: projectType.folder,
      },
      {
        el: $("#addProjectSub"),
        action: projectType.project,
      },
      {
        el: $("#addTenderSub"),
        action: projectType.tender,
      },
    ];
    items.forEach((item) => {
      const disabled = this.getAddBtnDisabled(item.action);
      if (disabled) {
        item.el.addClass("disabled");
      } else {
        item.el.removeClass("disabled");
      }
    });
  },
  //右键菜单项
  contextMenuItems: {
    addFolder: {
      name: "新建文件夹",
      icon: "fa-folder-o",
      disabled: function () {
        return projTreeObj.getAddBtnDisabled(projectType.folder);
      },
      callback: function (key, opt) {
        $("#add-folder-dialog").modal("show");
      },
    },
    addProject: {
      name: "新建建设项目",
      icon: "fa-cubes",
      disabled: function () {
        return projTreeObj.getAddBtnDisabled(projectType.project);
      },
      callback: function (key, opt) {
        if (isStopCreate()) {
          $('#stop-create-dialog').modal('show');
        } else {
          $('#add-project-dialog').modal('show');
        }
      },
    },
    addTender: {
      name: "新建分段",
      icon: "fa-sticky-note-o",
      disabled: function () {
        return projTreeObj.getAddBtnDisabled(projectType.tender);
      },
      callback: function (key, opt) {
        if (isStopCreate()) {
          $('#stop-create-dialog').modal('show');
          return;
        }
        //弹出新建单位工程之前，判断当前使用版本，且当前使用单位工程数是否已到最大值
        let selectedItem = projTreeObj.tree.selected;
        $("#add-tender-dialog").modal("show");
      },
    },
    rename: {
      name: "重命名",
      icon: "fa-edit",
      disabled: function () {
        return !projTreeObj.tree.selected;
      },
      callback: function (key, opt) {
        $("#rename-name").val(
          projTreeObj.tree.selected.data.name
            ? projTreeObj.tree.selected.data.name
            : ""
        );
        $("#rename-dialog").modal("show");
        setTimeout(function () {
          $("#rename-name")[0].focus();
        }, 300);
      },
    },
    delete: {
      name: "删除",
      icon: "fa-remove",
      disabled: function () {
        let node = projTreeObj.tree.selected;
        return (
          !node ||
          (node.data.projType === projectType.folder &&
            node.children.length > 0)
        );
      },
      callback: function (key, opt) {
        if (projTreeObj.tree && projTreeObj.tree.selected) {
          $("#del").modal("show");
        }
      },
    },
    copyTo: {
      name: "复制到",
      icon: "fa-copy",
      disabled: function () {
        let node = projTreeObj.tree.selected;
        return !(node && node.data.projType === projectType.tender);
      },
      callback: function (key, opt) {
        if (isStopCreate()) {
          $('#stop-create-dialog').modal('show');
          return;
        }
        let selectedItem = projTreeObj.tree.selected;
        try {
          let selectedType =
            selectedItem !== null && selectedItem.data !== undefined
              ? selectedItem.data.projType
              : "";
          if (selectedType !== projectType.tender) {
            throw "请选择单位工程进行复制";
          }
        } catch (error) {
          alert(error);
          return false;
        }
        //更新选中项目缓存
        $("#copy-to-dialog").modal("show");
      },
    },
    saveAs: {
      name: "另存为",
      icon: "fa-paste",
      disabled: function () {
        const node = projTreeObj.tree.selected;
        return !(node && node.data.projType === projectType.tender);
      },
      callback: function (key, opt) {
        if (isStopCreate()) {
          $('#stop-create-dialog').modal('show');
          return;
        }
        $("#save-as-dialog").modal("show");
      },
    },
    share: {
      name: "分享",
      icon: "fa-share",
      disabled: function () {
        let selectedItem = projTreeObj.tree.selected;
        return !selectedItem;
      },
      callback: function (key, opt) {
        const selected = projTreeObj.tree.selected;
        if (selected && selected.data.ID) {
          SHARE_TO.initModal(SHARE_TO.Mode.PROJECT, selected.data.ID);
        }
      },
    },
    importInterface: {
      name: "导入接口文件",
      icon: "fa-cloud-upload",
      visible: function () {
        const names = [
          "公路造价(2018)",
          "安徽养护(2018)",
          "广东公路造价(2018)",
          "浙江养护(2005)",
          "山东养护(2016/2024)",
          "广西养护(2020)",
        ];
        return compilationData && names.includes(compilationData.name);
      },
      callback: function () {
        CommonHeader.doAfterValidateVersion(
          () => $("#interface-import-modal").modal("show"),
          () => alert(`${commonUtil.getVersionText()}不提供此功能。`)
          // () => $('#interface-import-modal').modal('show') //临时
        );
        // $('#interface-import-modal').modal('show');
      },
    },
    manageFiles: {
      name: "管理相关文件",
      icon: "fa-list",
      disabled: function () {
        let selectedItem = projTreeObj.tree.selected;
        return !(
          selectedItem && selectedItem.data.projType !== projectType.folder
        );
      },
      callback: function (key, opt) {
        setDataToSideBar();
        $(".slide-sidebar").animate({ width: "440" }).addClass("open");
        setTimeout(function () {
          $("body").bind("click", function (event) {
            var e = event || window.event; //浏览器兼容性
            if (!$(event.target).is("a")) {
              var elem = event.target || e.srcElement;
              while (elem) {
                //循环判断至跟节点，防止点击的是div子元素
                if (
                  elem.className == "open-sidebar" ||
                  elem.className == "slide-sidebar open"
                ) {
                  return false;
                }
                if ($(elem).attr("id") && $(elem).attr("id") === "del-wj") {
                  return false;
                }
                elem = elem.parentNode;
              }
              $(".slide-sidebar").animate({ width: "0" }).removeClass("open"); // 关闭处理
              $("body").unbind("click");
            }
          });
        }, 500);
      },
    },
    refreshSummary: {
      name: "刷新项目造价",
      icon: "fa-refresh",
      disabled: function () {
        let selectedItem = projTreeObj.tree.selected;
        return !(
          selectedItem && selectedItem.data.projType !== projectType.folder
        );
      },
      callback: function (key, opt) {
        //获取当前节点的建设项目ID
        projTreeObj.refreshProjectData();
      },
    },
    exportProject: {
      name: "导出建设项目",
      icon: "fa-cloud-download",
      disabled: function () {
        let selectedItem = projTreeObj.tree.selected;
        if (selectedItem)
          return selectedItem.data.projType === projectType.folder;
        return true;
      },
      callback: function (key, opt) {
        //获取当前节点的建设项目ID
        let selectedItem = projTreeObj.tree.selected;
        let projectNode = selectedItem; //取建设项目节点
        if (selectedItem.data.projType === projectType.tender) {
          projectNode = selectedItem.parent;
        }
        projTreeObj.exportProject(projectNode.data.ID, projectNode.data.name);
      },
    },
    importProject: {
      name: "导入建设项目",
      icon: "fa-upload",
      disabled: function () {
        let selectedItem = projTreeObj.tree.selected;
        if (selectedItem) {
          //if(selectedItem.data.projType === projectType.project) return false;//如果是建设项目，可用
          if (selectedItem.data.projType === projectType.folder) {
            //如果是文件夹
            if (selectedItem.children) {
              if (selectedItem.children.length == 0) return false; //如果文件夹没有子项，可用
              if (selectedItem.children[0].projType === projectType.project)
                return false; //如果文件夹有子项，并且是建设项目，可用
            }
          } else {
            //除了文件夹，都可用
            return false;
          }
        } else {
          //列表为空时可导入
          return false;
        }
        return true;
      },
      callback: function (key, opt) {
        if (isStopCreate()) {
          $('#stop-create-dialog').modal('show');
          return;
        }
        $("#confirm-import").hide();
        $("#import").modal("show");
        projTreeObj.getUploadToken();
      },
    },
  },
  //全部-开始（新建）按钮弹出菜单（新建单位工程）
  loadStartMenu: function () {
    let me = this;
    $("#startA").click(me.contextMenuItems.addTender.callback);
  },
  //spread中鼠标右键弹出菜单
  loadContextMenu: function () {
    let me = this;
    $.contextMenu({
      selector: "#projSpread",
      build: function ($trigger, e) {
        let target = SheetDataHelper.safeRightClickSelection(
          $trigger,
          e,
          me.workBook
        );
        me.initSelection(
          { row: target.row, rowCount: 1 },
          me.preSelection ? me.preSelection : null,
          me.workBook.getActiveSheet()
        );
        return (
          target.hitTestType === GC.Spread.Sheets.SheetArea.viewport ||
          target.hitTestType === GC.Spread.Sheets.SheetArea.rowHeader
        );
      },
      items: {
        addFolder: me.contextMenuItems.addFolder,
        addProject: me.contextMenuItems.addProject,
        addTender: me.contextMenuItems.addTender,
        spr1: "--------",
        rename: me.contextMenuItems.rename,
        delete: me.contextMenuItems.delete,
        copyTo: me.contextMenuItems.copyTo,
        saveAs: me.contextMenuItems.saveAs,
        spr2: "--------",
        share: me.contextMenuItems.share,
        importInterface: me.contextMenuItems.importInterface,
        spr3: "--------",
        manageFiles: me.contextMenuItems.manageFiles,
        refreshSummary: me.contextMenuItems.refreshSummary,
        exportProject: me.contextMenuItems.exportProject,
        importProject: me.contextMenuItems.importProject,
      },
    });
  },
  //刷新按钮有效性（升降级、上下移）
  refreshBtn: function (selected) {
    const upLevel = $("#upLevel");
    const downLevel = $("#downLevel");
    const upMove = $("#upMove");
    const downMove = $("#downMove");
    if (!selected) {
      upLevel.addClass("disabled");
      downLevel.addClass("disabled");
      upMove.addClass("disabled");
      downMove.addClass("disabled");
      return;
    }
    /* 升级有效
     * 当前选中文件夹，且文件夹有父项，且父项是文件夹
     * 当前选中建设项目，且建设项目有父项，且父项是文件夹
     */
    if (
      [projectType.project, projectType.folder].includes(
        selected.data.projType
      ) &&
      selected.parent &&
      selected.parent.data &&
      selected.parent.data.projType === projectType.folder
    ) {
      upLevel.removeClass("disabled");
    } else {
      upLevel.addClass("disabled");
    }
    /*
     * 降级有效
     * 当前选中文件夹，且文件夹有前兄弟，且前兄弟是文件夹
     * 当前选中建设项目，且建设项目有前兄弟，且前兄弟是文件夹
     * */
    if (
      [projectType.project, projectType.folder].includes(
        selected.data.projType
      ) &&
      selected.preSibling() &&
      selected.preSibling().data.projType === projectType.folder
    ) {
      downLevel.removeClass("disabled");
    } else {
      downLevel.addClass("disabled");
    }
    /*
     * 上移有效
     * 当前选中行有前兄弟，不论前兄弟类型
     * */
    selected.preSibling()
      ? upMove.removeClass("disabled")
      : upMove.addClass("disabled");
    /*
     * 后移有效
     * 当前选中行有后兄弟，不论后兄弟类型
     * */
    selected.nextSibling
      ? downMove.removeClass("disabled")
      : downMove.addClass("disabled");
  },
  doAfterTreeOpr: function ({ selected, parent, next, projectMap }, action) {
    $.bootstrapLoading.start();
    moveProjects(
      {
        user_id: userID,
        rootProjectID: null,
        projectMap: projectMap,
        feeRateMap: {},
        unitPriceMap: {},
      },
      function (result) {
        for (let key in result) {
          //更新前端节点数据
          let updateData = result[key].update;
          let node = projTreeObj.tree.findNode(result[key].query.ID);
          if (node) {
            for (let ukey in updateData) {
              _.set(node.data, ukey, updateData[ukey]);
            }
          }
        }
        projTreeObj.moveTo(selected, null, parent, next, null, action);
        $.bootstrapLoading.end();
        STATE.moving = false;
        projTreeObj.emitTreeChange();
      }
    );
  },
  //升级后选中节点的后兄弟节点不成为其子节点，因为有层级类型限制(相当于选中节点移动到父项后成为其后兄弟)
  upLevel: function () {
    if (STATE.moving) {
      return;
    }
    STATE.moving = true;
    let selected = projTreeObj.tree.selected,
      parent = selected.parent.parent,
      next = selected.parent.nextSibling,
      projectMap = {};
    //更新父节点
    projectMap[selected.pid()] = {
      query: { ID: selected.pid() },
      update: { NextSiblingID: selected.id() },
    };
    //更新选中节点前兄弟节点
    let orgPre = selected.preSibling();
    if (orgPre) {
      projectMap[orgPre.id()] = {
        query: { ID: orgPre.id() },
        update: { NextSiblingID: selected.nid() },
      };
    }
    //更新选中节点
    projectMap[selected.id()] = {
      query: { ID: selected.id() },
      update: {
        ParentID: selected.parent.pid(),
        NextSiblingID: selected.parent.nid(),
      },
    };
    this.doAfterTreeOpr({ selected, parent, next, projectMap });
  },
  downLevel: function () {
    if (STATE.moving) {
      return;
    }
    STATE.moving = true;
    let selected = projTreeObj.tree.selected,
      parent = null,
      next = null,
      projectMap = {};
    const maxFolderLevel = getMaxFolderLevel(selected);
    if (maxFolderLevel === 3) {
      return alert("文件夹不能超过3层");
    }
    //更新前兄弟节点
    let orgPre = selected.preSibling();
    parent = orgPre;
    projectMap[orgPre.id()] = {
      query: { ID: orgPre.id() },
      update: { NextSiblingID: selected.nid() },
    };
    //更新前兄弟最后子节点
    if (orgPre.children.length > 0) {
      let lastChild = orgPre.lastChild();
      projectMap[lastChild.id()] = {
        query: { ID: lastChild.id() },
        update: { NextSiblingID: selected.id() },
      };
    }
    //更新选中节点
    projectMap[selected.id()] = {
      query: { ID: selected.id() },
      update: { ParentID: orgPre.id(), NextSiblingID: -1 },
    };
    this.doAfterTreeOpr({ selected, parent, next, projectMap }, "downLevel");
  },
  upMove: function () {
    if (STATE.moving) {
      return;
    }
    STATE.moving = true;
    let selected = projTreeObj.tree.selected,
      parent = selected.parent,
      next = selected.preSibling(),
      projectMap = {};
    //$('#upMove').addClass('disabled');
    //更新前前兄弟
    let prepre = selected.preSibling().preSibling();
    if (prepre) {
      projectMap[prepre.id()] = {
        query: { ID: prepre.id() },
        update: { NextSiblingID: selected.id() },
      };
    }
    //更新前兄弟
    let pre = selected.preSibling();
    projectMap[pre.id()] = {
      query: { ID: pre.id() },
      update: { NextSiblingID: selected.nid() },
    };
    //更新选中节点
    projectMap[selected.id()] = {
      query: { ID: selected.id() },
      update: { NextSiblingID: pre.id() },
    };
    this.doAfterTreeOpr({ selected, parent, next, projectMap });
  },
  downMove: function () {
    if (STATE.moving) {
      return;
    }
    STATE.moving = true;
    let selected = projTreeObj.tree.selected,
      parent = selected.parent,
      next = selected.nextSibling.nextSibling,
      projectMap = {};
    //$('#downMove').addClass('disabled');
    //更新前兄弟
    let pre = selected.preSibling();
    if (pre) {
      projectMap[pre.id()] = {
        query: { ID: pre.id() },
        update: { NextSiblingID: selected.nid() },
      };
    }
    //更新后兄弟
    projectMap[selected.nid()] = {
      query: { ID: selected.nid() },
      update: { NextSiblingID: selected.id() },
    };
    //更新选中节点
    projectMap[selected.id()] = {
      query: { ID: selected.id() },
      update: { NextSiblingID: selected.nextSibling.nid() },
    };
    this.doAfterTreeOpr({ selected, parent, next, projectMap });
  },
  loadBtn: function () {
    $("#upLevel").click(this.upLevel.bind(this));
    $("#downLevel").click(this.downLevel.bind(this));
    $("#upMove").click(this.upMove.bind(this));
    $("#downMove").click(this.downMove.bind(this));
  },
  getSelStyle: function (backColor) {
    let style = new GC.Spread.Sheets.Style();
    style.backColor = backColor;
    style.borderLeft = new GC.Spread.Sheets.LineBorder(
      "#D4D4D4",
      GC.Spread.Sheets.LineStyle.thin
    );
    style.borderTop = new GC.Spread.Sheets.LineBorder(
      "#D4D4D4",
      GC.Spread.Sheets.LineStyle.thin
    );
    style.borderRight = new GC.Spread.Sheets.LineBorder(
      "#D4D4D4",
      GC.Spread.Sheets.LineStyle.thin
    );
    style.borderBottom = new GC.Spread.Sheets.LineBorder(
      "#D4D4D4",
      GC.Spread.Sheets.LineStyle.thin
    );
    return style;
  },
  //设置选中行底色
  setSelStyle: function (sel, backColor, sheet) {
    let me = this;
    //let sheet = me.workBook.getSheet(0);
    sel.row = sel.row === -1 ? 0 : sel.row;
    me.renderSheetFuc(sheet, function () {
      let style = me.getSelStyle(backColor);
      for (let i = 0; i < sel.rowCount; i++) {
        let row = i + sel.row;
        sheet.setStyle(row, -1, style);
      }
    });
  },
  initSelection: function (newSel, oldSel = null, sheet) {
    let me = this;
    let node = me.tree.items[newSel.row];
    node = node ? node : null;
    me.refreshBtn(node);
    //恢复底色
    if (oldSel) {
      me.setSelStyle(oldSel, me.setting.style.defalutBackColor, sheet);
    }
    //设置选中行底色
    if (newSel) {
      me.setSelStyle(newSel, me.setting.style.selectedColor, sheet);
    }
    if (sheet.name() == "copyToSheet") {
      //复制到
      me.copySelected = node;
      let canCopy = false;
      if (node) {
        canCopy =
          node.data.projType == projectType.tender ||
          node.data.projType == projectType.project;
      }
      canCopy == true
        ? $("#copy-to-confirm").removeClass("disabled")
        : $("#copy-to-confirm").addClass("disabled");
      return; //如果是复制到表，不用做后面的操作
    } else if (sheet.name() == "replaceSheet") {
      //如果是替换文件，不用做后面的操作
      return;
    }
    me.tree.selected = node;
    me.preSelection = newSel;
  },
  onSelectionChanging: function (sender, args) {
    let me = projTreeObj;
    me.initSelection(args.newSelections[0], args.oldSelections[0], args.sheet);
  },
  changeFileClick: async function (sender, args) {
    if (args.sheet.name() == "projectSheet") {
      await projTreeObj.initFileChangePage(
        projTreeObj.setting.header[args.col].dataCode
      );
      $("#mr_from").val(projTreeObj.setting.header[args.col].dataCode);
      $("#m_replace_file").modal("show");
    } else if (args.sheet.name() == "replaceSheet") {
      let cellType = args.sheet.getCellType(args.row, args.col);
      if (cellType instanceof GC.Spread.Sheets.CellTypes.CheckBox) {
        projTreeObj.onReplaceNodeCheck(sender, args);
      }
    }
  },
  cusButtonClick: async function (info) {
    projTreeObj.changeFileClick(null, info);
  },
  onDragDropBlock: function (sender, args) {
    //拖动移动项目位置
    let selected = projTreeObj.tree.selected;
    let targetNode = projTreeObj.tree.items[args.toRow];
    let projectMap = {},
      feeRateMap = {},
      unitPriceMap = {},
      parent = null,
      next = null,
      oldProject = null;
    let rootProjectID = null; //记录建设项目ID
    //let updateObj = {project:[],feeRateFile:[],unitPriceFile:[]};
    args.cancel = true; //首先取消填充的动作
    if (args.sheet.name() == "copyToSheet") {
      //如果是复制到表，不用做后面的操作
      return;
    }
    if (
      selected.preSibling() != null &&
      selected.preSibling() == targetNode &&
      selected.data.projType == targetNode.data.projType
    ) {
      //如果目标节点与选中节点的前一节点一样，并且选中节点与目标节点项目类型也一样的话，不用移动
      return;
    }
    if (selected == targetNode) {
      return;
    }
    if (selected.data.projType == "Tender") {
      //移动单位工程
      oldProject = selected.parent; //记录原来的建设项目
      if (
        targetNode.data.projType == projectType.tender ||
        targetNode.data.projType == projectType.project
      ) {
        //只能移动到这两个地方
        if (targetNode.data.projType == projectType.tender) {
          //移动到单位工程后面
          [parent, next] = getMoveUpdateData(
            selected,
            targetNode,
            projectMap,
            true
          );
          rootProjectID = targetNode.pid();
        } else {
          //移动后成为建设项目的子项
          [parent, next] = getMoveUpdateData(
            selected,
            targetNode,
            projectMap,
            false
          );
          rootProjectID = targetNode.id();
        }
        if (selected.data.property.rootProjectID != rootProjectID) {
          //如果不属于同一个建设项目，要检查是否移动或复制单价文件和费率文件
          projectMap[selected.id()].update["property.rootProjectID"] =
            rootProjectID; //要改变根项目ID
          //检查费率文件和单价文件
          moveOrCopy(selected, rootProjectID, feeRateMap, unitPriceMap, false);
        }
      }
    }
    if (selected.data.projType == "Project") {
      //移动的是建设项目
      if (
        targetNode.data.projType == "Project" ||
        targetNode.data.projType == "Folder"
      ) {
        //目标位置是建设项目和文件夹
        if (targetNode.data.projType == "Project") {
          [parent, next] = getMoveUpdateData(
            selected,
            targetNode,
            projectMap,
            true
          );
        } else {
          [parent, next] = getMoveUpdateData(
            selected,
            targetNode,
            projectMap,
            false
          );
        }
      }
    }
    if (
      selected.data.projType == "Folder" &&
      targetNode.data.projType == "Folder"
    ) {
      //文件夹只能移动到文件夹下
      [parent, next] = getMoveUpdateData(
        selected,
        targetNode,
        projectMap,
        false
      ); //成为子项
    }
    if (_.isEmpty(projectMap)) {
      //项目数据为空
      return;
    }
    $.bootstrapLoading.start();
    moveProjects(
      {
        user_id: userID,
        rootProjectID: rootProjectID,
        projectMap: projectMap,
        feeRateMap: feeRateMap,
        unitPriceMap: unitPriceMap,
      },
      function (result) {
        for (let key in result) {
          //更新前端节点数据
          let updateData = result[key].update;
          let node = projTreeObj.tree.findNode(result[key].query.ID);
          if (node) {
            for (let ukey in updateData) {
              _.set(node.data, ukey, updateData[ukey]);
            }
          }
        }
        projTreeObj.moveTo(selected, targetNode, parent, next, oldProject);
        $.bootstrapLoading.end();
      }
    );
    function getMoveUpdateData(sel, target, projectMap, sameLevel) {
      let tem_parent = null,
        tem_next = null;
      if (sameLevel == true) {
        //移动后的位置的级别相同
        tem_parent = target.parent;
        tem_next = target.nextSibling;
        //移动到target的后面
        projectMap[target.id()] = {
          query: { ID: target.id() },
          update: { NextSiblingID: sel.id() },
        };
      } else {
        //移动后变成子项
        tem_parent = target;
        tem_next = target.firstChild();
      }
      let nextID = tem_next ? tem_next.id() : -1;
      if (sel.preSibling() != null) {
        //如果原来有前项，更新下一节点
        projectMap[sel.preSibling().id()] = {
          query: { ID: sel.preSibling().id() },
          update: { NextSiblingID: sel.data.NextSiblingID },
        };
      }
      if (sel.parent.id() == tem_parent.id()) {
        //移动前移动后的父项相同，只改变next
        if (selected.id() != nextID) {
          //父项相同的情况下， 下一节点ID如果等于选中的ID即项目没有移动，不用做处理
          projectMap[selected.id()] = {
            query: { ID: selected.id() },
            update: { NextSiblingID: nextID },
          };
        }
      } else {
        //
        let temData = {
          query: { ID: selected.id() },
          update: { ParentID: tem_parent.id(), NextSiblingID: nextID },
        };
        let reName = projTreeObj.projectNameChecking(tem_parent, selected); //重名检查
        if (reName) {
          temData.update["name"] = reName;
        }
        projectMap[selected.id()] = temData;
      }
      return [tem_parent, tem_next];
    }

    function moveOrCopy(
      sel,
      rootProjectID,
      feeRateMap,
      unitPriceMap,
      sameCheck
    ) {
      //检查选中的项目使用的费率文件和单价文件是要移动还是复制一份
      let project = sel.parent; //取建设项目
      let sameParent_f = true;
      let sameParent_u = true;
      let useFeeRateProject = getTendersByFile(
        fileType.feeRateFile,
        sel.data.property.feeFile.id,
        project
      );
      let useUnitPriceProject = getTendersByFile(
        fileType.unitPriceFile,
        sel.data.property.unitPriceFile.id,
        project
      );
      let tem_feeRate = {
        action: "copy",
        rootProjectID: rootProjectID,
        name: sel.data.property.feeFile.name,
        query: { ID: sel.data.property.feeFile.id },
      };
      let tem_unitPrice = {
        action: "copy",
        rootProjectID: rootProjectID,
        name: sel.data.property.unitPriceFile.name,
        query: { id: sel.data.property.unitPriceFile.id },
      };
      if (useFeeRateProject.length == 1) {
        //如果没有其它项目使用同一个费率文件，则移动
        tem_feeRate.action = "move";
        tem_feeRate.update = { rootProjectID: rootProjectID };
      }
      if (useUnitPriceProject.length == 1) {
        //如果没有其它项目使用同一个单价文件，则移动
        tem_unitPrice.action = "move";
        tem_unitPrice.update = { root_project_id: rootProjectID };
      }
      feeRateMap[sel.id()] = tem_feeRate;
      unitPriceMap[sel.id()] = tem_unitPrice;
      if (sameCheck == true) {
        //需要检查是否属于同一个单项工程，移动单项工程的时候用
        if (useUnitPriceProject.length > 1) {
          for (let f of useFeeRateProject) {
            if (f.pid() != sel.pid()) {
              //父节点不同
              sameParent_f = false;
              break;
            }
          }
          if (sameParent_f == true) {
            //如果使用的都是同属于一个单项工程，在移动单项工程的时候，移动费率文件和单价文件就可以了
            feeRateMap[sel.id()].action = "move";
            feeRateMap[sel.id()].update = { rootProjectID: rootProjectID };
          }
        }
        if (useUnitPriceProject.length > 1) {
          for (let u of useUnitPriceProject) {
            if (u.pid() != sel.pid()) {
              //父节点不同
              sameParent_u = false;
              break;
            }
          }
          if (sameParent_u == true) {
            unitPriceMap[sel.id()].action = "move";
            unitPriceMap[sel.id()].update = { root_project_id: rootProjectID };
          }
        }
      }
    }
  },
  projectNameChecking: function (parent, node, type) {
    //decDate = '（' + new Date().Format('MM-dd hh:mm:ss') + '恢复）';
    type = type ? type : "移动";
    for (let c of parent.children) {
      if (c.data.name == node.data.name) {
        //如果存在同名的项目
        return (
          node.data.name +
          "（" +
          new Date().Format("MM-dd hh:mm:ss") +
          type +
          "）"
        );
      }
    }
    return null;
  },
  onCellEditing: function (sender, args) {
    args.cancel = true;
  },
  getShowData: function (datas) {
    for (let data of datas) {
      data.name = data.name ? data.name : "";
      if (data.projType !== projectType.tender) {
        data.engineeringCost = "";
        data.unitPriceFile = "";
        data.feeRateFile = "";
        data.createDateTime = "";
      } else {
        data.engineeringCost = data.engineeringCost ? data.engineeringCost : 0;
        data.unitPriceFile =
          data.property &&
            data.property.unitPriceFile &&
            data.property.unitPriceFile.name
            ? data.property.unitPriceFile.name
            : "";
        data.feeRateFile =
          data.property && data.property.feeFile && data.property.feeFile.name
            ? data.property.feeFile.name
            : "";
        data.createDateTime = data.createDateTime
          ? new Date(data.createDateTime).Format("yyyy-MM-dd")
          : "";
      }
    }
  },
  openTender: function (ID, parent, timeoutTime) {
    setTimeout(function () {
      let newTab = window.open("about:blank");
      BeforeOpenProject(ID, { fullFolder: GetFullFolder(parent) }, function () {
        let mainUrl = `/main?project=${ID}`;
        newTab.location.replace(mainUrl); //不能后退
      });
    }, timeoutTime);
  },
  getTreeNodeCell: function (tree) {
    let me = projTreeObj;
    let indent = 20;
    let levelIndent = -5;
    let halfBoxLength = 5;
    let halfExpandLength = 3;
    let imgWidth = 18;
    let imgHeight = 14;
    let shareImg = document.getElementById("share_pic"),
      shareImgWidth = 13,
      shareImgHeight = 13;
    let defaultHeight = 18; // 单元格默认高度
    let TreeNodeCellType = function () { };
    TreeNodeCellType.prototype = new GC.Spread.Sheets.CellTypes.Text();
    // 自动行高处理 此函数在每次调用autoFitRow后调用，返回的值作为新的单元格高度
    // 在单元格设置为自动行高后，单元格的内容有空格时，spreadjs会将空格认为是换行，会导致高度计算不正确，因此在setCellValue中处理空格
    TreeNodeCellType.prototype.getAutoFitHeight = function (
      value,
      text,
      cellStyle,
      zoomFactor,
      context
    ) {
      if (!defaultHeight) {
        defaultHeight = context.sheet.getCell(context.row, -1).height();
      }
      const node = me.tree.items[context.row];
      const nodeIndent = node
        ? (node.depth() + 1) * indent +
        node.depth() * levelIndent +
        imgWidth +
        5
        : 0;
      const cellWidth = context.sheet.getCell(-1, context.col).width();
      const textLength = this.getAutoFitWidth(...arguments);
      const tempNum = textLength / (cellWidth - nodeIndent);
      const lineNum =
        tempNum % 1 > 0.92 ? Math.ceil(tempNum + 1) : Math.ceil(tempNum); // 不这么处理的话有些行高算出来不对
      //const lineNum = Math.ceil(textLength / (cellWidth - nodeIndent));
      return lineNum * defaultHeight;
    };
    TreeNodeCellType.prototype.paint = function (
      ctx,
      value,
      x,
      y,
      w,
      h,
      style,
      options
    ) {
      if (style.backColor == undefined) style.backColor = "white";
      if (style.backColor) {
        ctx.save();
        ctx.fillStyle = style.backColor;
        ctx.fillRect(x, y, w, h);
        ctx.restore();
      } else {
        ctx.clearRect(x, y, w, h);
      }
      let drawLine = function (canvas, x1, y1, x2, y2, color) {
        ctx.save();
        ctx.translate(0.5, 0.5);
        ctx.beginPath();
        ctx.moveTo(x1, y1);
        ctx.lineTo(x2, y2);
        ctx.strokeStyle = color;
        ctx.stroke();
        ctx.restore();
      };
      let drawExpandBox = function (
        ctx,
        x,
        y,
        w,
        h,
        centerX,
        centerY,
        expanded
      ) {
        let rect = {},
          h1,
          h2,
          offset = 1;
        rect.top = centerY - halfBoxLength;
        rect.bottom = centerY + halfBoxLength;
        rect.left = centerX - halfBoxLength;
        rect.right = centerX + halfBoxLength;

        if (rect.left < x + w) {
          rect.right = Math.min(rect.right, x + w);

          ctx.save();
          ctx.translate(0.5, 0.5);
          ctx.strokeStyle = "black";
          ctx.beginPath();
          ctx.moveTo(rect.left, rect.top);
          ctx.lineTo(rect.left, rect.bottom);
          ctx.lineTo(rect.right, rect.bottom);
          ctx.lineTo(rect.right, rect.top);
          ctx.lineTo(rect.left, rect.top);
          ctx.stroke();
          ctx.fillStyle = "white";
          ctx.fill();
          ctx.restore();

          // Draw Horizontal Line
          h1 = centerX - halfExpandLength;
          h2 = Math.min(centerX + halfExpandLength, x + w);
          if (h2 > h1) {
            drawLine(ctx, h1, centerY, h2, centerY, "black");
          }
          // Draw Vertical Line
          if (!expanded && centerX < x + w) {
            drawLine(
              ctx,
              centerX,
              centerY - halfExpandLength,
              centerX,
              centerY + halfExpandLength,
              "black"
            );
          }
        }
      };
      let node = tree.items[options.row];
      let showTreeLine = true;
      if (!node) {
        return;
      }

      let centerX =
        Math.floor(x) +
        node.depth() * indent +
        node.depth() * levelIndent +
        indent / 2;
      let x1 = centerX + indent / 2;
      let centerY = Math.floor((y + (y + h)) / 2);
      let y1;
      const lineColor = "#ababab";
      // Draw Sibling Line
      if (showTreeLine) {
        // Draw Horizontal Line
        if (centerX < x + w) {
          drawLine(
            ctx,
            centerX,
            centerY,
            Math.min(x1, x + w),
            centerY,
            lineColor
          );
          let img;
          if (node.data.projType === projectType.folder) {
            img = document.getElementById("folder_open_pic");
            imgWidth = 15;
          } else if (node.data.projType === projectType.project) {
            img = document.getElementById("proj_pic");
            imgWidth = 18;
          } else if (node.data.projType === projectType.engineering) {
            img = document.getElementById("eng_pic");
            imgWidth = 14;
          } else if (node.data.projType === projectType.tender) {
            //如果单位工程不是实时计算结果，则显示刷新标记
            img =
              node.data.changeMark && node.data.changeMark != ""
                ? document.getElementById("refresh_pic")
                : document.getElementById("tender_pic");
            imgWidth = 14;
          }
          ctx.drawImage(
            img,
            centerX + indent / 2 + 3,
            centerY - 7,
            imgWidth,
            imgHeight
          );
        }
        // Draw Vertical Line
        if (centerX < x + w) {
          y1 = node.isLast() ? centerY : y + h;
          if (node.isFirst() && !node.parent.parent) {
            drawLine(ctx, centerX, centerY, centerX, y1, lineColor);
          } else {
            drawLine(ctx, centerX, y, centerX, y1, lineColor);
          }
        }
      }
      // Draw Expand Box
      if (node.children.length > 0) {
        drawExpandBox(ctx, x, y, w, h, centerX, centerY, node.expanded);
      }
      // Draw Parent Line
      if (showTreeLine) {
        var parent = node.parent,
          parentCenterX = centerX - indent - levelIndent;
        while (parent.parent) {
          if (!parent.isLast()) {
            if (parentCenterX < x + w) {
              drawLine(ctx, parentCenterX, y, parentCenterX, y + h, lineColor);
            }
          }
          parent = parent.parent;
          parentCenterX -= indent + levelIndent;
        }
      }
      //分享标记在开头
      if (node.data.shareInfo && node.data.shareInfo.length > 0) {
        let nowY = Math.floor((y + (y + h)) / 2);
        ctx.drawImage(shareImg, x + 3, nowY - 7, shareImgWidth, shareImgHeight);
      }
      // Draw Text
      //x = x + (node.depth() + 1) * indent +  node.depth() * levelIndent;
      x =
        x +
        (node.depth() + 1) * indent +
        node.depth() * levelIndent +
        imgWidth +
        3;
      w =
        w -
        (node.depth() + 1) * indent -
        node.depth() * levelIndent -
        imgWidth -
        3;
      GC.Spread.Sheets.CellTypes.Text.prototype.paint.apply(this, arguments);
      /*  if (node.data.shareInfo && node.data.shareInfo.length > 0) {//分享标记在文本后
                let nowX = Math.floor(x) + w - 20;
                let nowY = Math.floor((y + (y + h)) / 2);
                ctx.drawImage(shareImg, nowX + 3, nowY - 7, shareImgWidth,shareImgHeight);
            }*/
    };
    TreeNodeCellType.prototype.getHitInfo = function (
      x,
      y,
      cellStyle,
      cellRect,
      context
    ) {
      let info = {
        x: x,
        y: y,
        row: context.row,
        col: context.col,
        cellStyle: cellStyle,
        cellRect: cellRect,
        sheetArea: context.sheetArea,
      };
      let node = tree.items[info.row];
      if (node && node.data.projType === projectType.tender) {
        info.isReservedLocation = true;
      }
      return info;
    };
    TreeNodeCellType.prototype.processMouseDown = function (hitinfo) {
      let offset = -1;
      let node = tree.items[hitinfo.row];
      let centerX =
        hitinfo.cellRect.x +
        offset +
        node.depth() * indent +
        node.depth() * levelIndent +
        indent / 2;
      let centerY =
        (hitinfo.cellRect.y +
          offset +
          (hitinfo.cellRect.y + offset + hitinfo.cellRect.height)) /
        2;
      let text = hitinfo.sheet.getText(hitinfo.row, hitinfo.col);
      let value = hitinfo.sheet.getValue(hitinfo.row, hitinfo.col);
      let acStyle = hitinfo.sheet.getActualStyle(hitinfo.row, hitinfo.col),
        zoom = hitinfo.sheet.zoom();
      let textLength = this.getAutoFitWidth(value, text, acStyle, zoom, {
        sheet: hitinfo.sheet,
        row: hitinfo.row,
        col: hitinfo.col,
        sheetArea: GC.Spread.Sheets.SheetArea.viewport,
      });
      //(图标+名字)区域
      function withingClickArea() {
        return (
          hitinfo.x > centerX + halfBoxLength &&
          hitinfo.x <
          centerX + halfBoxLength + imgWidth + indent / 2 + 3 + textLength
        );
      }
      if (hitinfo.sheet.name() === "projectSheet") {
        //只有项目管理界面才执行
        //单项文件，进入造价书界面
        if (node.data.projType === projectType.tender) {
          let thisClick = Date.now(),
            open = false;
          if (
            this.preNode === node &&
            this.preClick &&
            thisClick - this.preClick <= 300
          ) {
            open = true;
            let timeoutTime = 200;
            if ($(".slide-sidebar").hasClass("open")) {
              timeoutTime = 500;
            }
            projTreeObj.openTender(node.data.ID, node.parent, timeoutTime);
          }
          this.preClick = open ? null : thisClick;
          this.preNode = open ? null : node;
        }
        if (!node || node.children.length === 0) {
          return;
        }
      }
      //统一改成方框外1像素内都有效
      if (
        hitinfo.x >= centerX - halfBoxLength - 2 &&
        hitinfo.x <= centerX + halfBoxLength + 2 &&
        hitinfo.y >= centerY - halfBoxLength - 2 &&
        hitinfo.y <= centerY + halfBoxLength + 2
      ) {
        node.setExpanded(!node.expanded);
        TREE_SHEET_HELPER.massOperationSheet(hitinfo.sheet, function () {
          let iCount = node.posterityCount(),
            i,
            child;
          for (i = 0; i < iCount; i++) {
            child = tree.items[hitinfo.row + i + 1];
            hitinfo.sheet.setRowVisible(
              hitinfo.row + i + 1,
              child.visible,
              hitinfo.sheetArea
            );
          }
          hitinfo.sheet.invalidateLayout();
        });
        hitinfo.sheet.repaint();
      }
    };
    /*TreeNodeCellType.prototype.processMouseMove = function (hitInfo) {
            let sheet = hitInfo.sheet;

            let div = sheet.getParent().getHost();
            let canvasId = div.id + "vp_vp";
            let canvas = $(`#${canvasId}`)[0];
            //改变鼠标图案
            if (sheet && hitInfo.isReservedLocation) {
                canvas.style.cursor='pointer';
                return true;
            }else{
                canvas.style.cursor='default';
            }
            return false;
        };*/
    TreeNodeCellType.prototype.processMouseEnter = function (hitinfo) {
      let text = hitinfo.sheet.getText(hitinfo.row, hitinfo.col);
      let value = hitinfo.sheet.getValue(hitinfo.row, hitinfo.col);
      let tag = hitinfo.sheet.getTag(hitinfo.row, hitinfo.col);
      let acStyle = hitinfo.sheet.getActualStyle(hitinfo.row, hitinfo.col),
        zoom = hitinfo.sheet.zoom();
      let node = me.tree.items[hitinfo.row];
      let nodeIndent = node
        ? (node.depth() + 1) * indent +
        node.depth() * levelIndent +
        imgWidth +
        3
        : 0;
      let textLength = this.getAutoFitWidth(value, text, acStyle, zoom, {
        sheet: hitinfo.sheet,
        row: hitinfo.row,
        col: hitinfo.col,
        sheetArea: GC.Spread.Sheets.SheetArea.viewport,
      });
      let cellWidth = hitinfo.sheet.getCell(-1, hitinfo.col).width();
      if (textLength > cellWidth - nodeIndent) {
        TREE_SHEET_HELPER.showTipsDiv(text, { pos: {} }, hitinfo);
      }
    };
    TreeNodeCellType.prototype.processMouseLeave = function (hitinfo) {
      let me = this;
      TREE_SHEET_HELPER.tipDiv = "hide";
      if (TREE_SHEET_HELPER._toolTipElement) {
        $(TREE_SHEET_HELPER._toolTipElement).hide();
        TREE_SHEET_HELPER._toolTipElement = null;
      }
      TREE_SHEET_HELPER.tipDivCheck(); //延时检查：当tips正在show的时候，就调用了hide方法，会导致tips一直存在，所以设置一个超时处理
    };
    return new TreeNodeCellType();
  },
  setFileSelectButton: function (row, col, node, sheet, setting) {
    if (!setting) setting = this.setting;
    let dataCode = setting.header[col]["dataCode"];
    if (
      node.data.projType == "Tender" &&
      (dataCode == "feeRateFile" || dataCode == "unitPriceFile")
    ) {
      sheet.setCellType(
        row,
        col,
        sheetCommonObj.getCusButtonCellType(projTreeObj.cusButtonClick, false),
        GC.Spread.Sheets.SheetArea.viewport
      );
    }
  },
  setCellValue: function (cell, node, sheet, setting) {
    //const sheet = this.workBook.getActiveSheet();
    if (!setting) setting = this.setting;
    const { row, col } = cell;
    let dataCode = setting.header[col]["dataCode"];
    let value = "";
    if (dataCode === "name") {
      // 在单元格设置为自动行高后，单元格的内容有空格时，spreadjs会将空格认为是换行，因此需要处理空格
      value =
        (node.data.name &&
          node.data.name.replace(new RegExp(" ", "g"), "\t")) ||
        "";
    } else if (dataCode === "unitPriceFile") {
      if (node.data.projType === projectType.tender) {
        value =
          node.data.property &&
            node.data.property.unitPriceFile &&
            node.data.property.unitPriceFile.name
            ? node.data.property.unitPriceFile.name
            : "";
      }
    } else if (dataCode === "feeRateFile") {
      if (node.data.projType === projectType.tender) {
        value =
          node.data.property &&
            node.data.property.feeFile &&
            node.data.property.feeFile.name
            ? node.data.property.feeFile.name
            : "";
      }
    } else if (dataCode === "createDateTime") {
      value = node.data.createDateTime
        ? new Date(node.data.createDateTime).Format("yyyy-MM-dd")
        : "";
    } else {
      value = isDef(node.data[dataCode]) ? node.data[dataCode] : "";
    }
    sheet.setValue(row, col, value);
  },
  showTreeData: function (nodes, setting, sheet) {
    let headers = setting.header;
    let me = this;
    let tree = nodes.length > 0 ? nodes[0].tree : me.tree; //sheet.name() == "copyToSheet"?me.copyTree:me.tree;
    let fuc = function () {
      sheet.setRowCount(0);
      sheet.setRowCount(nodes.length);
      let treeNodeCell = me.getTreeNodeCell(tree);
      sheet.getRange(-1, 0, -1, 1).cellType(treeNodeCell);
      const rows = [];
      for (let i = 0; i < nodes.length; i++) {
        rows.push(i);
        for (let j = 0; j < headers.length; j++) {
          sheet
            .getRange(-1, j, -1, 1)
            .hAlign(GC.Spread.Sheets.HorizontalAlign[headers[j]["hAlign"]]);
          sheet
            .getRange(-1, j, -1, 1)
            .vAlign(GC.Spread.Sheets.VerticalAlign[headers[j]["vAlign"]]);
          if (
            headers[j].cellType == "checkBox" &&
            nodes[i].data.canSelect === true
          ) {
            sheet.setCellType(
              i,
              j,
              new GC.Spread.Sheets.CellTypes.CheckBox(),
              GC.Spread.Sheets.SheetArea.viewport
            );
            sheet.getCell(i, j).hAlign(GC.Spread.Sheets.HorizontalAlign.center);
          }
          me.setCellValue({ row: i, col: j }, nodes[i], sheet, setting);
          me.setFileSelectButton(i, j, nodes[i], sheet, setting);
        }
        sheet.getCell(i, 1, GC.Spread.Sheets.SheetArea.viewport).locked(true);
        if (typeof nodes[i].visible !== "undefined") {
          sheet.setRowVisible(nodes[i].serialNo(), nodes[i].visible);
        }
      }
      sheetCommonObj.setRowsAutoFit(sheet, rows, 0, true);
    };
    me.renderSheetFuc(sheet, fuc);
  },
  refreshNodeData: function (nodes) {
    let me = this;
    let sheet = me.workBook.getActiveSheet();
    let header = me.setting.header;
    me.renderSheetFuc(sheet, function () {
      if (_.isArray(nodes)) {
        for (let t of nodes) {
          setSheetCellData(t, sheet);
        }
      } else {
        setSheetCellData(nodes, sheet);
      }
    });
    function setSheetCellData(n, sheet) {
      let rIdx = me.tree.items.indexOf(n);
      for (let i = 0; i < header.length; i++) {
        me.setCellValue({ row: rIdx, col: i }, n, sheet);
        me.setFileSelectButton(rIdx, i, n, sheet);
      }
    }
  },
  sumEngineeringCost: function () {
    let projectNodes = _.filter(projTreeObj.tree.items, function (item) {
      return item.data.projType == projectType.project;
    });
    for (let p of projectNodes) {
      this.calEngineeringCost(p);
    }
  },
  calEngineeringCost: function (node) {
    let projectNode = null; //建设项目节点
    let refreshNodes = [];
    if (node.data.projType == projectType.folder) {
      //如果是文件夹时不用计算
      return;
    }
    if (node.data.projType == projectType.project) {
      projectNode = node;
    }
    if (node.data.projType == projectType.tender) {
      projectNode = node.parent;
    }
    if (projectNode) {
      calNode(projectNode);
    }
    let children = projectNode.children;
    refreshNodes.push(projectNode);
    return refreshNodes.concat(children);
    function calNode(node) {
      let tem_sum = 0;
      if (node.data.projType == projectType.tender) {
        return;
      }
      for (let t of node.children) {
        calNode(t);
        let temP = scMathUtil.roundForObj(t.data.totalCost, 2);
        tem_sum = scMathUtil.roundForObj(temP + tem_sum, 2);
      }
      node.data.totalCost = scMathUtil.roundToString(tem_sum, 2);
    }
  },
  initFileChangePage: async function (from) {
    let title =
      from == "unitPriceFile" ? "批量替换单价文件" : "批量替换费率文件";
    $("#mr_title").text(title);
    this.initHtmlByFromRadio();
    let result =
      from == "unitPriceFile"
        ? await this.setUnitFileChangeFileData()
        : await this.setFeeRateChangeFileData();
    this.changeInfo = result;
    this.loadFileOptions(this.changeInfo, from);
  },
  setFeeRateChangeFileData: async function () {
    //userID
    let node = projTreeObj.tree.selected;
    let data = {
      user_id: userID,
      projectID: node.data.ID,
      rootProjectID: node.data.property.rootProjectID,
    };
    let result = await ajaxPost("/feeRates/getChangeInfo", data);
    this.getFileListWithPath(result.others);
    return result;
  },
  setUnitFileChangeFileData: async function () {
    let node = projTreeObj.tree.selected;
    let data = {
      project_id: node.data.ID,
      rootProjectID: node.data.property.rootProjectID,
    };
    let result = await ajaxPost("/glj/get-project-info", data);
    this.getFileListWithPath(result.other);
    //数据结构不一样，这里做一下转换
    let t_result = {
      currentProject: {
        ID: node.data.ID,
        currentOptions: result.self,
      },
      others: result.other,
    };
    return t_result;
  },

  getFileListWithPath: function (list) {
    for (let n of list) {
      let node = projTreeObj.tree.findNode(n.ID);
      if (node) {
        n.name = getPathName(node);
      }
      n.serialNo = (node && node.serialNo()) || 1;
    }
    // 按照正确的树结构排序
    list.sort((a, b) => a.serialNo - b.serialNo);

    function getPathName(node) {
      if (node.parent && node.parent.data) {
        return getPathName(node.parent) + "\\" + node.data.name;
      } else {
        return node.data ? node.data.name : "";
      }
    }
  },
  loadFileOptions: function (data, from) {
    let idField = "ID",
      optionField = "optionList";
    if (from == "unitPriceFile") {
      idField = "id";
      optionField = "unitPriceList";
    }
    $("#currentOptions").empty();
    for (let c of data.currentProject.currentOptions) {
      var option = $("<option>").val(c[idField]).text(c.name);
      $("#currentOptions").append(option);
    }
    $("#otherProject").empty();
    for (let p of data.others) {
      var option = $("<option>").val(p.ID).text(p.name);
      $("#otherProject").append(option);
    }
    $("#otherFileOptions").empty();
    if (data.others.length > 0) {
      for (let f of data.others[0][optionField]) {
        var option = $("<option>").val(f[idField]).text(f.name);
        $("#otherFileOptions").append(option);
      }
    }
  },
  initHtmlByFromRadio: function () {
    var radioV = $("input[name='select_from']:checked").val();
    if (radioV == "0") {
      $("#fromProject").show();
      $("#fromOther").hide();
    } else {
      $("#fromProject").hide();
      $("#fromOther").show();
    }
  },
  initCopyToSpread: function () {
    let me = this;
    me.copyToWorkBook = projTreeObj.buildSheet(
      me.copyToWorkBook,
      "copyToSpread",
      me.copyToSetting
    );
    let sheet = me.copyToWorkBook.getActiveSheet();
    sheet.options.isProtected = true;
    sheet.name("copyToSheet");
    let datas = [];
    for (let i of me.tree.items) {
      datas.push(i.data);
    }
    me.copyTree = pmTree.createNew(projTreeObj.setting, datas);
    initNodesVisibility(me.copyTree.items, false);
    me.showTreeData(me.copyTree.items, me.copyToSetting, sheet);
    me.copySelected = null;
    let initSel = sheet.getSelections()[0]
      ? sheet.getSelections()[0]
      : { row: 0, rowCount: 1 };
    projTreeObj.initSelection(initSel, null, sheet);
  },
  initReplaceSpread: function () {
    let me = this;
    me.replaceWorkBook = projTreeObj.buildSheet(
      me.replaceWorkBook,
      "replaceSpread",
      me.replaceSetting
    );
    let sheet = me.replaceWorkBook.getActiveSheet();
    sheet.options.isProtected = true;
    sheet.name("replaceSheet");
    let datas = [];
    for (let i of me.tree.items) {
      //要挑出同个建设项目的节点
      if (me.isReplaceNode(i) == true) {
        let tem = _.cloneDeep(i.data);
        if (tem.projType == "Tender") tem.canSelect = true;
        if (i == me.tree.selected) tem.selected = 1;
        datas.push(tem);
      }
    }
    me.replaceTree = pmTree.createNew(projTreeObj.setting, datas);
    me.showTreeData(me.replaceTree.items, me.replaceSetting, sheet);
  },
  isReplaceNode: function (node) {
    //只加载本建设项目的节点
    let isReplaceNode = false;
    let selected = this.tree.selected;
    let rootProjectID = selected.data.property.rootProjectID;
    let rootNode = this.tree.findNode(rootProjectID);
    if (rootNode) {
      let IDMap = this.getAllParentNodeID(selected);
      isReplaceNode =
        IDMap[node.data.ID] !== undefined ||
        node.data.ID == rootProjectID ||
        node.data.ParentID == rootProjectID ||
        (node.data.property &&
          node.data.property.rootProjectID == rootProjectID);
    }
    return isReplaceNode;
  },
  getAllParentNodeID: function (node) {
    let IDMap = {};
    getPID(node, IDMap);
    return IDMap;
    function getPID(node, map) {
      if (node.parent && node.data.ParentID != -1) {
        map[node.data.ParentID] = true;
        getPID(node.parent, map);
      }
    }
  },
  onReplaceNodeCheck: function (sender, args) {
    let checkboxValue = args.sheet.getCell(args.row, args.col).value();
    let newval = checkboxValue ? 0 : 1;
    let node = projTreeObj.replaceTree.items[args.row];
    if (node.data.ID === projTreeObj.tree.selected.data.ID) return; //如果是项目管理界面选中的节点，不给取消
    projTreeObj.setReplaceSelection(
      node,
      newval,
      args.row,
      args.col,
      args.sheet
    );
  },
  setReplaceSelection: function (node, value, row, col, sheet) {
    sheet.getCell(row, col).value(value);
    node.data.selected = value;
  },
  selectSameTypeProject: function (value) {
    let node = this.tree.selected;
    let engineering_id = node.data.property.engineering_id;
    for (let i = 0; i < this.replaceTree.items.length; i++) {
      let tnode = this.replaceTree.items[i];
      if (tnode.data.ID == node.data.ID) continue;
      if (
        tnode &&
        tnode.data.property &&
        tnode.data.property.engineering_id == engineering_id
      ) {
        this.setReplaceSelection(
          tnode,
          value,
          i,
          1,
          this.replaceWorkBook.getActiveSheet()
        );
      }
    }
  },
  confirmFileChange: async function () {
    let selectProjects = [],
      fileID = null,
      from = $("#mr_from").val(),
      name = "",
      oldFileIDs = [],
      validate = true;
    for (let i of this.replaceTree.items) {
      if (i.data.selected === 1) {
        selectProjects.push({
          projectID: i.data.ID,
          rootProjectID: i.data["property"]["rootProjectID"],
        });
        let fileField = from == "feeRateFile" ? "feeFile" : "unitPriceFile";
        oldFileIDs.push(i.data["property"][fileField]["id"]);
      }
    }
    if (selectProjects.length > 0) {
      let type = parseInt($("input[name='select_from']:checked").val()); //0 从当前建设项目，1从其它建设项目中复制
      if (type == 0) {
        fileID = $("#currentOptions").val();
        name = $("#currentOptions").find("option:selected").text();
      } else {
        fileID = $("#otherFileOptions").val();
        name = $("#otherFileOptions").find("option:selected").text();
      }
      if (fileID == null || fileID == undefined || fileID == "") {
        alert("请选择替换文件");
      }
      //从其它项目复制才要做重名检查
      if (type == 1)
        validate = await projTreeObj.fileNameChecking(
          { name: name, rootProjectID: selectProjects[0].rootProjectID },
          from
        );
      if (validate == true) {
        $("#m_replace_file").modal("hide");
        await projTreeObj.postChangeFile(
          {
            projects: selectProjects,
            fileID: fileID,
            name: name,
            type: type,
            from: from,
          },
          oldFileIDs
        );
      } else {
        alert(
          `当前的建设项目中已经有相同名字的${from == "feeRateFile" ? "费率" : "单价"
          }文件！`
        );
      }
    }
  },
  fileNameChecking: async function (data, from) {
    let url =
      from == "feeRateFile"
        ? "/feeRates/checkFeeRateName"
        : "/glj/checkUnitFileName";
    let reuslt = await ajaxPost(url, data);
    return reuslt == false; //result 为true 则有重名的文件
  },

  postChangeFile: async function (data, oldFileIDs) {
    data.user_id = userID;
    $.bootstrapLoading.start();
    let result = await ajaxPost("/pm/api/changeFile", data);
    $.bootstrapLoading.end();
    projTreeObj.refreshWhenFileDateChange(data.projects[0].projectID);
    //发送文件改变消息
    data.oldFileIDs = _.uniq(oldFileIDs);
    socket.emit("multiFileChangeNotify", data);
  },
  checkFileName: async function (fileID, name, type) {
    let node = this.tree.selected;
  },

  insert: function (data, parent, next) {
    let preNode = this.tree.items[this.preSelection.row];
    let node = this.tree.addNodeData(data, parent, next);
    this.addRow(node);
    let newSel = this.workBook.getSheet(0).getSelections()[0];
    this.initSelection(
      newSel,
      preNode ? { row: preNode.serialNo(), rowCount: 1 } : null,
      this.workBook.getActiveSheet()
    ); //这里不能直接用this.preSelection，因为如果插入的记录在preSelection的前面时，之前old选中行已经变了，改不了old行的颜色
    return node;
  },
  addRow: function (node) {
    const me = this;
    const sheet = this.workBook.getActiveSheet();
    me.renderSheetFuc(sheet, function () {
      const items = me.tree.items;
      const rIdx = items.indexOf(node);
      const cIdx = sheet.getActiveColumnIndex();
      sheet.addRows(rIdx, 1);
      //set selection selected
      sheet.setSelection(rIdx, cIdx, 1, 1);
      me.tree.selected = node;
      //父节点收起时添加子节点,子节点添加完后隐藏
      /*if(node.parent && !node.parent.expanded){
                sheet.setRowVisible(rIdx, false);
            }*/
      // 添加节点自动展开相关的隐藏节点
      me.tree.setNodesExpanded(node.getCollapseParents(), sheet);
      sheet.getCell(rIdx, 0).cellType(me.getTreeNodeCell(me.tree));
      me.refreshNodeData(node);
    });
  },
  remove: function (sheet, rIdx, count) {
    let me = this;
    me.renderSheetFuc(sheet, function () {
      sheet.deleteRows(rIdx, count);
      sheet.setRowCount(me.tree.items.length);
      me.initSelection(
        { row: sheet.getActiveRowIndex(), rowCount: 1 },
        null,
        sheet
      );
    });
  },
  move: function (orgRow, newRow) {
    this.workBook.getActiveSheet().deleteRows(orgRow, 1);
    this.addRow(this.tree.items[newRow]);
  },
  moveTo: function (select, target, parent, next, oldProject, action) {
    let me = this;
    let fromRow = select.serialNo();
    let rCout = select.posterityCount() + 1; //删除的行数
    let sheet = me.workBook.getActiveSheet();
    let refreshNodes = [];
    me.tree.removeNode(select); //删除旧节点
    let newNode = addNewNodes(select, parent, next);
    if (oldProject) {
      refreshNodes = refreshNodes.concat(me.calEngineeringCost(oldProject));
      refreshNodes = refreshNodes.concat(me.calEngineeringCost(parent));
    }
    me.renderSheetFuc(sheet, function () {
      sheet.deleteRows(fromRow, rCout);
      sheet.addRows(newNode.serialNo(), rCout);
      let oldSelection = sheet.getSelections()[0];
      me.initSelection(
        { row: newNode.serialNo(), rowCount: oldSelection.rowCount },
        oldSelection,
        sheet
      );
      sheet.setSelection(
        newNode.serialNo(),
        oldSelection.col,
        oldSelection.rowCount,
        oldSelection.colCount
      );
      const newNodes = [newNode];
      const children = newNode.getAllChildren();
      newNodes.push(...children);
      for (let node of newNodes) {
        const row = node.serialNo();
        sheet.getCell(row, 0).cellType(me.getTreeNodeCell(me.tree));
        const visible = node.visible;
        sheet.setRowVisible(row, visible);
      }
      refreshNodes = refreshNodes.concat(newNodes);
      me.refreshNodeData(refreshNodes);
    });
    if (action === "downLevel") {
      me.tree.setNodesExpanded([parent], sheet);
    }

    function addNewNodes(node, parent, next) {
      const nodeState = {};
      if (typeof node.expanded !== "undefined") {
        nodeState.expanded = node.expanded;
      }
      if (typeof node.visible !== "undefined") {
        nodeState.visible = node.visible;
      }
      let newNode = me.tree.addNodeData(node.data, parent, next, nodeState);
      for (let c of node.children) {
        addNewNodes(c, newNode, null);
      }
      return newNode;
    }
  },
  refreshProjectData: function (projectID) {
    //projTreeObj.tree.findNode(4578)
    //获取当前节点的建设项目ID
    let project = projectID
      ? projTreeObj.tree.findNode(projectID)
      : projTreeObj.tree.selected;
    while (project.data.projType !== projectType.project && project.parent) {
      project = project.parent;
    }
    if (project && project.data.ID) {
      $.bootstrapLoading.start();
      CommonAjax.post(
        "/pm/api/getSummaryInfo",
        { user_id: userID, projectIDs: [project.data.ID] },
        function (summaryInfo) {
          //11-06 zhang 这个接口返回值增加了项目需重新计算标记，项目图标刷新
          refreshProjSummary(project, summaryInfo);
          $.bootstrapLoading.end();
        },
        function () {
          $.bootstrapLoading.start();
        }
      );
    }
  },
  refreshProjectIcon: function (projectID) {
    let node = projTreeObj.tree.findNode(projectID);
    if (node && node.data.changeMark && node.data.changeMark != "")
      this.refreshProjectData(projectID);
  },
  refreshWhenFileDateChange: function (projectID) {
    //当单价文件、费率文件被修改后，刷新页面，共用的项目提示刷新图标
    //在一次的修改中，同一个建设下，单价文件、费率文件才有共用的情况，而refreshProjectData是传入单位工程ID,刷新整个建设项目，所以，只要传入修改的单位工程ID，刷新建设项目即可
    this.refreshProjectData(projectID);
  },
  exportProject: async function (projectID, projectName) {
    $.bootstrapLoading.progressStart();
    let spString = "|----|";
    try {
      let sumString = "";
      $("#progress_modal_bar").css("width", "5%");
      let result = await getProjectInfo({
        projectID: projectID,
        type: "main",
        user_id: userID,
      });
      $("#progress_modal_bar").css("width", "10%");
      let result_arr = result.split(spString);
      sumString = result_arr[0];
      if (result_arr.length == 2) {
        let tenders = JSON.parse(result_arr[1]);
        let each = 100;
        let width = 10;
        if (tenders.length > 0) each = 90 / tenders.length;
        for (let t of tenders) {
          let tenderString = await getProjectInfo({
            projectID: t,
            rootProjectID: projectID,
            type: "sub",
            user_id: userID,
          });
          width += each;
          $("#progress_modal_bar").css("width", width + "%");
          await setTimeoutSync(null, 500); //设置间隔
          sumString = sumString + spString + tenderString;
        }
      }
      //  console.log(JSON.parse(sumString));
      saveProjectFile(sumString);
    } catch (e) {
      alert("导出失败！请查看log.");
      console.log(e);
    } finally {
      await setTimeoutSync(null, 500); //设置间隔
      $.bootstrapLoading.progressEnd();
    }

    async function getProjectInfo(data) {
      let result = await ajaxPost("/pm/api/exportProject", data);
      return result;
    }

    function saveProjectFile(data) {
      let blob = new Blob([data], { type: "text/plain;charset=utf-8" });
      saveAs(blob, projectName + ".ybp");
    }
  },
  getImportProjectDate: function () {
    //导入建设项目时，需要在现有的树节点中插入新的节点，这里是取插入所需的项目数据
    let selectNode = projTreeObj.tree.selected;
    let parent = null,
      next = null;
    let updateData = {};
    if (selectNode && selectNode.data.projType == projectType.folder) {
      parent = selectNode;
      next = selectNode.firstChild();
    } else if (selectNode) {
      let projectNode = null;
      if (selectNode.data.projType == projectType.project)
        projectNode = selectNode;
      if (selectNode.data.projType == projectType.tender)
        projectNode = selectNode.parent;
      parent = projectNode.parent;
      next = projectNode.nextSibling;
      updateData["update"] = { query: { ID: projectNode.id() } };
    } else if (!selectNode) {
      // 默认在第一位
      parent = selectNode ? selectNode.parent : projTreeObj.tree._root;
      next = selectNode ? selectNode.nextSibling : projTreeObj.tree.firstNode();
    }
    updateData["self"] = {
      ParentID: parent.id(),
      NextSiblingID: next ? next.id() : -1,
    };
    return updateData;
  },
  // 创建建设项目的时候，根据选中位置获取所要创建建设项目的父ID、上兄弟节点ID、后兄弟节点ID
  getRelProjectID: function (selected) {
    let parent, pre, next;
    if (!selected || selected.data.projType === projectType.project) {
      parent = selected ? selected.parent : projTreeObj.tree._root;
      pre = selected;
      next = selected ? selected.nextSibling : projTreeObj.tree.firstNode();
    } else if (selected.data.projType === projectType.folder) {
      parent = selected;
      pre = selected.lastChild();
      next = null;
    } else if (selected.data.projType === projectType.tender) {
      const selectedProj = selected.parent;
      parent = selectedProj ? selectedProj.parent : projTreeObj.tree._root;
      pre = selectedProj;
      next = selectedProj
        ? selectedProj.nextSibling
        : projTreeObj.tree.firstNode();
    }
    return {
      parentProjectID: parent && parent.data ? parent.data.ID : -1,
      preProjectID: pre && pre.data ? pre.data.ID : -1,
      nextProjectID: next && next.data ? next.data.ID : -1,
    };
  },
  getUploadToken: async function () {
    let result = await ajaxGet("/pm/api/getUploadToken");
    $("#confirm-import").show();
    projTreeObj.uptoken = result.uptoken;
  },
  // 树数据发生变化，触发推送
  emitTreeChange: function () {
    const compilationID = compilationData._id;
    // 获取当前树节点展开状态和焦点行
    const isActive = $("#tab_pm_all").hasClass("active");
    const expandState = isActive
      ? this.tree.getExpState(this.tree.items)
      : null;
    const selection =
      isActive && this.tree.selected
        ? { row: this.tree.selected.serialNo(), rowCount: 1 }
        : null;
    socket.emit("pmTreeChange", {
      userID,
      compilationID,
      expandState,
      selection,
    });
  },
  initTree: function (refresh = false, callback, expandCallback) {
    if (gcTreeObj.workBook) {
      gcTreeObj.workBook.destroy();
      gcTreeObj.workBook = null;
    }
    gcTreeObj.tree = null;
    init(refresh, callback, expandCallback);
  },
  handleNotifyClick: function (expandState, selection) {
    $("#empty-modal").modal("hide");
    $("#notify").hide();
    const callback = () => {
      const sheet = this.workBook.getSheet(0);
      if (selection && this.tree.items[selection.row]) {
        this.initSelection(selection, { row: 0, rowCount: 1 }, sheet);
        const col = sheet.getActiveColumnIndex();
        sheet.setSelection(selection.row, col, 1, 1);
      }
    };
    const expandCallback = () => {
      if (expandState) {
        this.tree.setExpandedByState(this.tree.items, expandState);
      }
    };
    this.initTree(true, callback, expandCallback);
  },
};

function changeValuationType(type) {
  $('input[name="valuation_type"]:checked').prop("checked", false);
  $(`input[name="valuation_type"][value="${type}"]`).prop("checked", true);
  // let targetData = type === 'bill' ? JSON.parse(billValuation) : JSON.parse(rationValuation);
  let targetData = getValuationData(type);
  let html = "";
  for (let i = targetData.length - 1; i >= 0; i--) {
    let valuation = targetData[i];
    if (valuation === null) {
      continue;
    }
    html += `<option ${i === targetData.length - 1 ? "selected" : ""} value="${valuation.id
      }">${valuation.name}</option>`;
  }
  $("#valuation").html(html);
  let engineeringList = getEngineeringList();
  let engineeringHtml = getEngineeringHtml(engineeringList);
  $("#tender-engineering").html(engineeringHtml);
  changeEngineering();
  $("#engineering-info").hide();
}

function changeEngineering() {
  $("#engineering-info").hide();
  initFeeStandardSel();
}

function changeFeeRate(engLib) {
  if (engLib) {
    /*
         if (engLib.fee_lib !== undefined && engLib.fee_lib.length > 0) {
            $("#tender-fee-rate").children("option").first().val("newFeeRate-"+engLib.fee_lib[0].id);
        }*/
    //2018-08-29  费率改为和计税方式绑定在一起 所以在这里还不能确定标准费率库ID
    $("#tender-fee-rate").children("option").first().val("newFeeRate@@");
    $("#tender-engineering")
      .parent()
      .siblings(".hidden-area")
      .slideDown("fast");
  } else {
    $("#tender-fee-rate")
      .children("option")
      .first()
      .val($("#tender-name").val());
  }
}

function initFeeStandardSel() {
  $("#tender-feeStandard").empty();
  let feeStandards = [];
  let engineeringList = getEngineeringList();
  let currentEngName = $("#tender-engineering").val();
  for (let eng of engineeringList) {
    if (
      eng.lib.name &&
      eng.lib.name === currentEngName &&
      eng.lib.feeName &&
      eng.lib.feeName !== ""
    ) {
      feeStandards.push(eng.lib.feeName);
    }
  }
  for (let feeName of feeStandards) {
    let $opt = $(`<option value="${feeName}">${feeName}</option>`);
    $("#tender-feeStandard").append($opt);
  }
  if (feeStandards.length > 0) {
    if ($("#feeStandard-info").is(":visible")) {
      $("#feeStandard-info").hide();
    }
  }
  let currentEngLib = getEngineeringLib(
    currentEngName + $("#tender-feeStandard").val(),
    engineeringList
  );
  changeFeeRate(currentEngLib);
  setTaxGroupHtml();
  getStdCalcProgramFiles();
}

function _iniAdminLevel() {
  //初始化行政等级（广东农村公路用）
  $("#tender-adminLevel").empty();
  let adminLevels = [];
  adminLevels.push(adminLevelType.CITY_LEVEL);
  adminLevels.push(adminLevelType.COUNTRY_SIDE_LEVEL);
  adminLevels.push(adminLevelType.VLLAGE_LEVEL);
  for (let feeName of adminLevels) {
    let $opt = $(`<option value="${feeName}">${feeName}</option>`);
    $("#tender-adminLevel").append($opt);
  }
  $("#tender-adminLevel")[0].selectedIndex = 0;
  // changeFeeRate(currentEngLib);
  // setTaxGroupHtml();
  // getStdCalcProgramFiles();
}

function changeFeeStandard() {
  let currentEngLib = getEngineeringLib(
    $("#tender-engineering").val() + $("#tender-feeStandard").val(),
    getEngineeringList()
  );
  changeFeeRate(currentEngLib);
  setTaxGroupHtml();
  getStdCalcProgramFiles();
}

function setTaxGroupHtml() {
  let groups = getTaxGroupList();
  let taxTypeArray = [];
  let htmlString = "";
  if (groups && groups.length > 0) {
    taxTypeArray = _.uniq(_.map(groups, "taxType"));
  }
  for (let t of taxTypeArray) {
    htmlString += "<option value='" + t + "'>" + taxTypeMap[t] + "</option>";
  }
  $("#taxType").html(htmlString);
  if (taxTypeArray.length < 2) {
    $("#taxType_div").hide();
  } else {
    $("#taxType_div").show();
  }
}

function getStdCalcProgramFiles() {
  function getStdCPFilesHtml(taxGroups) {
    let result = "";
    if (taxGroups.length <= 0) {
      return result;
    }

    for (let group of taxGroups) {
      let groupString = ""; //把计算程序、清单模板、列设置的ID生成一个组合的值
      let p_id = group.program_lib ? group.program_lib.id : "";
      let t_id = group.template_lib ? group.template_lib.id : "";
      let c_id = group.col_lib ? group.col_lib.id : "";
      let f_id = group.fee_lib ? group.fee_lib.id : "";
      groupString = p_id + "|-|" + t_id + "|-|" + c_id + "|-|" + f_id;
      result +=
        "<option value=" +
        groupString +
        ">" +
        group.program_lib.name +
        "</option>";
    }
    return result;
  }
  let taxType = $("#taxType").val();
  let stdCPHtml = getStdCPFilesHtml(getTaxGroupList(taxType));
  $("#tender-calcProgram").html(stdCPHtml);
  if ($("#tender-calcProgram")[0].options.length > 1)
    $("#tender-calcProgram")[0].selectedIndex = 0;
}

$(document).ready(function () {
  // 分享给的一些事件监听
  SHARE_TO.handleEventListener();

  // 单位工程超限提示后，弹出客服列表
  $("#hintBox_form").on("hide.bs.modal", function () {
    const text = $("#hintBox_caption").text();
    if (
      text ===
      "您创建的项目个数超限，请联系我们的客服人员，或者导出建设项目保存到本地备份，删除云上数据。"
    ) {
      $("#customerService").click();
    }
  });
  //绑定项目管理的升降级、上下移按钮事件
  projTreeObj.loadBtn();
  $("#sideTab")
    .find("li")
    .click(function () {
      //消除tooltip
      $('[data-toggle="tooltip"]').tooltip("hide");
    });
  //列宽随着屏幕改变
  $(window).resize(function () {
    sheetCommonObj.setColumnWidthByRate(
      getWorkBookWidth(),
      gcTreeObj.workBook,
      gcTreeObj.setting.header
    );
    //sheetCommonObj.setColumnWidthByRate(getWorkBookWidth(), pmShare.spreadObj.workBook, pmShare.headers);
  });

  projTreeObj.initTree();
  $("#tab_pm_all").on("show.bs.tab", () => projTreeObj.initTree(true));

  // 侧滑数据
  /* $(".poj-list").on('click', ".open-sidebar", function() {
        setDataToSideBar();
        $(".slide-sidebar").animate({width:"800"}).addClass("open");
    });*/

  //单价、费率文件删除确认
  $("#fileDelConfirm").click(function () {
    if (fileDelObj && fileDelObj.id) {
      let updateObj = Object.create(null);
      updateObj.updateType = "delete";
      updateObj.updateData = Object.create(null);
      if (fileDelObj.fileType === fileType.unitPriceFile) {
        updateObj.updateData.id = fileDelObj.id;
      } else if (fileDelObj.fileType === fileType.feeRateFile) {
        updateObj.updateData.ID = fileDelObj.id;
      }
      updateObj.fileType = fileDelObj.fileType;
      a_updateFiles([updateObj], function () {
        fileDelObj = null;
        $("#fileDelCancel").click();
        setDataToSideBar();
        //refresh front?
      });
    }
  });
  //绑定新建建设项目、新建文件夹、重命名Enter键事件
  bindInputs($("#project-name"), $("#folder-name"), $("#rename-name"));
  //绑定新建窗口显示事件
  bindModalShown(
    $("#add-folder-dialog"),
    $("#add-project-dialog"),
    $("#add-tender-dialog")
  );
  //绑定新建建设项目、新建单位工程、新建文件夹、重命名弹窗隐藏事件
  bindModalsHidden(
    $("#add-project-dialog"),
    $("#add-tender-dialog"),
    $("#add-folder-dialog"),
    $("#rename-dialog")
  );

  // 新建子菜单有效性刷新
  $("#addMenuBtn").click(function () {
    if (isStopCreate()) {
      $('#stop-create-dialog').modal('show');
      return false;
    }
    const menuDisplay = !$("#addMenu").is(":visible");
    if (!menuDisplay) {
      return;
    }
    projTreeObj.refreshAddMenuItems();
  });

  // 新增建设项目操作
  $("#addProjOk").click(function () {
    if (STATE.addingProject) {
      return;
    }
    STATE.addingProject = true;
    let suc = AddProject();
    if (suc === false) {
      STATE.addingProject = false;
    }
  });

  // 选择计价方式
  $("input[name='valuation_type']").click(function () {
    let type = $(this).val();
    changeValuationType(type);
  });

  //选择计价规则
  $("#valuation").change(function () {
    let engineeringList = getEngineeringList();
    let engineeringHtml = getEngineeringHtml(engineeringList);
    $("#tender-engineering").html(engineeringHtml);
    $("#valuation-info").hide();
    changeEngineering();
  });

  //选择计税方式
  $("#taxType").change(function () {
    $("#valuation-info").hide();
    getStdCalcProgramFiles();
  });

  //新建单位工程-建设项目提示
  $("#poj-name").keyup(function () {
    let pojName = $("#poj-name").val().trim();
    let nameList = getNameList($("#poj-name-list").children());
    let isExist = hasListName(nameList, pojName);
    if (!isExist) {
      //ESTIMATION
      if (compilationData.name === "内蒙古高速公路日常养护估算(2021)") {
        changeValuationType(ESTIMATION);
      } else if (
        compilationData.name === "四川养护(2013)" ||
        compilationData.name === "部颁2018计价标准"
      ) {
        changeValuationType(BILL_BUDGET);
      } else {
        changeValuationType(BUDGET);
      }
      if (pojName !== "") {
        replaceClass($("#poj-name-info"), "text-danger", "text-info");
        setDangerInfo($("#poj-name-info"), `新建“${pojName}”`);
        if (!$("#tender-reserve").children().length) {
          initProjectOptSet($("#tender-reserve"));
        }
        // 新建项目，需要选择项目类型了，单位工程就不需要选择项目类别
        $("#val-type-group").hide();
      } else {
        $("#tender-reserve").empty();
        $("#poj-name-info").hide();
      }
      //清空文件下拉
      setFileOptions(null);
    } else {
      $("#val-type-group").show();
      $("#tender-reserve").empty();
      //触发选项
      let curName = $(this).val().trim();
      function getProjOpt(opts) {
        for (let opt of opts) {
          if ($(opt).text().trim() === curName) {
            return $(opt);
          }
        }
        return null;
      }
      let matchOpt = getProjOpt($("#poj-name-list").find("a"));
      const projectID = matchOpt.data("id");
      handleTenderValuationTypeViewState(projectID);
      if (matchOpt) {
        matchOpt.click();
      }
      $("#poj-name-info").hide();
    }
  });

  //新建单位工程-单位工程提示
  $("#tender-name").keyup(function () {
    let selected = projTreeObj.tree.selected;
    let pojName = $("#poj-name").val().trim();
    let tenderName = $("#tender-name").val().trim();
    let isExist = hasTender(selected, pojName, tenderName);
    $("#unit-price").find("option:first-child").text(tenderName);
    $("#tender-fee-rate").find("option:first-child").text(tenderName);
    if (isExist) {
      if (tenderName !== "")
        setDangerInfo($("#tender-name-info"), `已存在“${tenderName}”`);
    } else {
      $("#tender-name-info").hide();
    }
  });

  //下拉是否含有输入的名字
  function hasListName(nameList, name) {
    for (let i = 0, len = nameList.length; i < len; i++) {
      if (nameList[i] === name) {
        return true;
      }
    }
    return false;
  }

  function getNameList(list) {
    let rst = [];
    for (let i = 0, len = list.length; i < len; i++) {
      rst.push($(list[i]).text());
    }
    return rst;
  }

  //设置地区选项
  function setRegionOpts(regions) {
    $("#regionDiv").find("select").empty();
    for (let region of regions) {
      let $opt = $(`<option value = "${region}">${region}</option>`);
      $("#regionDiv").find("select").append($opt);
    }
  }
  // 某些费用定额不显示费用标准
  const compilationWithoutFeeStandard = [
    // 内蒙2019
    "5d776dad620cc0000dab6b2a",
  ];
  // 新增单位工程弹层改变
  $("#add-tender-dialog").on("show.bs.modal", function () {
    if (compilationWithoutFeeStandard.includes(compilationData._id)) {
      $("#tender-feeStandard-group").hide();
    }
    //clear info
    $("#poj-name-info").hide();
    $("#tender-name-info").hide();
    $("#tender-name").val("");
    $("#valuation-info").hide();
    $("#engineering-info").hide();
    $("#unit-price").find("option:first-child").text("新建单价文件");
    $("#tender-fee-rate").find("option:first-child").text("新建费率文件");
    //获取建设项目
    let selected = projTreeObj.tree.selected;
    let projs = getProjs(selected);
    setProjOptions(projs, selected);
    if (selected.data.valuationType === "工程量清单") {
      $("#val-type-group").hide();
    } else {
      if (selected.data.property.hasOwnProperty("valuationType")) {
        $("#val-type-group").hide();
      } else {
        $("#val-type-group").show();
      }
    }
    const firstProj =
      selected && selected.data.projType === projectType.project
        ? selected
        : projs[0];
    const firstProjID = (firstProj && firstProj.data.ID) || null;
    handleTenderValuationTypeViewState(firstProjID);
    //设置地区选项
    if (regions.length > 0) {
      setRegionOpts(regions);
      $("#regionDiv").show();
    }
  });

  // 新增单位工程
  $("#add-tender-confirm").click(function () {
    if (STATE.addingTender) {
      return;
    }
    STATE.addingTender = true;
    let suc = AddTender();
    if (suc === false) {
      STATE.addingTender = false;
    }
  });

  // 新增文件夹操作
  $("#add-folder-confirm").click(function () {
    if (STATE.addingFolder) {
      return;
    }
    STATE.addingFolder = true;
    let suc = AddFolder();
    if (suc === false) {
      STATE.addingFolder = false;
    }
  });

  // 删除时文字替换
  $("#del").on("show.bs.modal", function () {
    let hasTenderChild = function (children) {
      for (let i = 0; i < children.length; i++) {
        if (children[i].children.length === 0) {
          if (children[i].data.projType === "Tender") {
            return true;
          }
        } else if (hasTenderChild(children[i].children)) {
          return true;
        }
      }
      return false;
    };
    // 显示内容
    let tenderHintElement = $("#tenderHint");
    let folderHintElement = $("#folderHint");
    if (projTreeObj.tree.selected.children.length === 0) {
      tenderHintElement.show();
      tenderHintElement.text(
        '删除 "' + projTreeObj.tree.selected.data.name + '" ？'
      );
      folderHintElement.hide();
    } else {
      tenderHintElement.hide();
      folderHintElement.show();
      folderHintElement.text(
        '删除 "' + projTreeObj.tree.selected.data.name + '" 以及它包含的子项？'
      );
    }
    // 显示是否可以找回
    if (hasTenderChild([projTreeObj.tree.selected])) {
      $("#restoreHint").show();
    } else {
      $("#restoreHint").hide();
    }
  });

  // 删除操作
  $("#delete-confirm").click(function () {
    if (STATE.deleting) {
      return;
    }
    STATE.deleting = true;
    let updateData = null;
    let dialog = $("#del");
    if (projTreeObj.tree) {
      $.bootstrapLoading.start();
      updateData = GetDeleteUpdateData(projTreeObj.tree.selected);
      UpdateProjectData(
        updateData,
        function () {
          dialog.modal("hide");
          let selected = projTreeObj.tree.selected;
          //删除行号
          let rIdx = projTreeObj.tree.items.indexOf(selected);
          //删除行数
          let rCout = selected.posterityCount() + 1;
          projTreeObj.tree.removeNode(selected);
          let refreshNodes = projTreeObj.calEngineeringCost(selected);
          //delete view
          let sheet = projTreeObj.workBook.getActiveSheet();
          projTreeObj.remove(sheet, rIdx, rCout);
          if (
            selected.data.projType == projectType.tender ||
            selected.data.projType == projectType.engineering
          ) {
            projTreeObj.refreshNodeData(refreshNodes); //刷新工程造价信息
          }
          $.bootstrapLoading.end();
          //快速点击时，第一个项目删除成功了，可能会删除多项目
          setTimeout(function () {
            STATE.deleting = false;
          }, 500);
          projTreeObj.emitTreeChange();
        },
        function () {
          $.bootstrapLoading.end();
          setTimeout(function () {
            STATE.deleting = false;
          }, 500);
        }
      );
    }
  });

  // 重命名操作
  $("#rename-confirm").click(function () {
    let select = projTreeObj.tree.selected;
    let parent = select ? select.parent : Tree._root;
    let newName = $("#rename-name").val().trim();
    let dialog = $("#rename-dialog");
    if (newName === "") {
      setDangerInfo($("#rename-name-info"), "请输入重命名");
      return false;
    }

    if (newName === select.data.name) {
      dialog.modal("hide");
      return false;
    }
    if (existName(newName, parent.children, select.data.projType)) {
      setDangerInfo($("#rename-name-info"), `已存在“${newName}”`);
      return;
    }
    RenameProject(select.id(), newName, select.data.ParentID, function () {
      setDangerInfo($("#rename-name-info"), "", false);
      dialog.modal("hide");
      select.data.name = newName;
      let sheet = projTreeObj.workBook.getActiveSheet();
      projTreeObj.setCellValue(
        { row: sheet.getActiveRowIndex(), col: 0 },
        select,
        sheet,
        projTreeObj.setting
      );
      projTreeObj.emitTreeChange();
    });
  });

  // 复制到按钮点击
  /*$('#copy-to-btn').click(function () {
        let selectedItem = projTreeObj.tree.selected;
        try {
            let selectedType = selectedItem !== null && selectedItem.data !== undefined ?
                selectedItem.data.projType : '';
            if (selectedType !== projectType.tender) {
                throw '请选择单位工程进行复制';
            }
        } catch (error) {
            alert(error);
            return false;
        }
        $('#copy-to-dialog').modal('show');
    });*/
  // 复制到弹层替换
  /*  $('#copy-to-dialog').on('show.bs.modal', function () {
        copytoZTree = ConvertTreeToZtree(projTreeObj.tree, $('#treeDemo2'), null);
    });*/

  $("#copy-to-dialog").on("shown.bs.modal", function () {
    projTreeObj.initCopyToSpread();
    // copytoZTree = ConvertTreeToZtree(projTreeObj.tree, $('#treeDemo2'), null);
  });

  $("#m_replace_file").on("shown.bs.modal", function () {
    // projTreeObj.tree.selected
    projTreeObj.initReplaceSpread();
  });
  $("input[name='select_from']").each(function () {
    $(this).click(function () {
      projTreeObj.initHtmlByFromRadio();
    });
  });
  // 复制到操作
  $("#copy-to-confirm").click(async function () {
    try {
      let originalNode = projTreeObj.tree.selected;
      let toNode = projTreeObj.copySelected;
      let parent = null,
        next = null,
        projectMap = {};
      if (toNode.data.projType == projectType.project) {
        //复制为目标的子节点
        parent = toNode;
        next = toNode.firstChild();
      } else if (toNode.data.projType == projectType.tender) {
        //复制为目标的后兄弟
        parent = toNode.parent;
        next = toNode.nextSibling;
        projectMap["update"] = { query: { ID: toNode.id() } }; //前一节点的下一个节点更新;
      }
      // 复制到的目标建设项目项目类型与当前文件项目类型相同才可复制（目标建设项目为空也能复制到，兼容旧项目）
      const targetValuationType = parent.data.property.valuationType || null;
      const curValuationType = originalNode.data.property.valuationType || null;
      if (targetValuationType && targetValuationType !== curValuationType) {
        return alert(
          "当前分段与目标建设项目的项目类型不同，请选择其他建设项目进行复制。"
        );
      }
      let nextID = next ? next.id() : -1;
      let projectData = _.cloneDeep(originalNode.data);
      projectData["ParentID"] = parent.id();
      projectData["NextSiblingID"] = nextID;
      projectData["property"] = {};
      projectData["property"]["rootProjectID"] = parent.id();
      projectData["shareInfo"] = [];
      let rename = projTreeObj.projectNameChecking(
        parent,
        originalNode,
        "复制"
      ); //重名检查
      rename ? (projectData["name"] = rename) : "";
      projectMap["copy"] = { document: projectData };
      $("#copy-to-dialog").modal("hide");
      const copyRst = await ajaxPost("/pm/api/copyProjects", {
        projectMap: projectMap,
        user_id: userID,
        tenderCount: 1,
      });
      if (!copyRst.error) {
        $.bootstrapLoading.progressStart("拷贝项目", true);
        $("#progress_modal_body").text("正在拷贝项目，请稍候……");
        await importProcessChecking(null, null, (newProjectData) =>
          handleTenderAfterChecking(newProjectData, projectData)
        );
      }
    } catch (err) {
      alert(err);
    }
  });

  // 另存为操作
  $("#save-as-dialog").on("show.bs.modal", function () {
    const selected = projTreeObj.tree.selected;
    const name = selected.data.name;
    $("#save-file").prop("checked", true);
    $("#save-as-name").val(name);
    setTimeout(() => $("#save-as-name")[0].focus(), 300);
  });
  $("#save-as-confirm").click(
    _.throttle(async function () {
      try {
        const name = $("#save-as-name").val().trim();
        if (!name) {
          throw new Error("名称不可为空。");
        }
        const saveAsFile = $("#save-file").prop("checked");
        const originalNode = projTreeObj.tree.selected;
        const projectMap = {
          isSaveAs: true,
          saveAsFile,
        };
        const parent = originalNode.parent;
        const next = parent.firstChild();
        const nextID = next ? next.id() : -1;
        const projectData = _.cloneDeep(originalNode.data);
        projectData["ParentID"] = parent.id();
        projectData["NextSiblingID"] = nextID;
        projectData["property"] = {};
        projectData["property"]["rootProjectID"] = parent.id();
        projectData["shareInfo"] = [];
        projectData["name"] = name;
        projectMap["copy"] = { document: projectData };
        //$("#save-as-dialog").modal('hide');
        const copyRst = await ajaxPost("/pm/api/copyProjects", {
          projectMap: projectMap,
          user_id: userID,
          tenderCount: 1,
        });
        if (!copyRst.error) {
          $.bootstrapLoading.progressStart("拷贝项目", true);
          $("#progress_modal_body").text("正在拷贝项目，请稍候……");
          await importProcessChecking(null, null, (newProjectData) => {
            handleTenderAfterChecking(newProjectData, projectData);
            if (newProjectData) {
              $("#save-as-dialog").modal("hide");
            }
          });
        }
      } catch (err) {
        alert(err);
      }
    }, 2000)
  );

  $("#selectSameTypeProject").click(function () {
    let value = $(this).prop("checked") == true ? 1 : 0;
    projTreeObj.selectSameTypeProject(value);
  });

  $("#changeFileConfirm").click(function () {
    projTreeObj.confirmFileChange();
  });

  // 选择工程专业后动态更改费率文件等数据
  $("#tender-engineering").change(function () {
    changeEngineering();
  });
  $("#tender-feeStandard").change(function () {
    changeFeeStandard();
  });
});

//获取工作表总宽度
function getWorkBookWidth() {
  return (workBookWidth = $(window).width() - $(".pm-side").width() - 90);
}

function prepareInitialTimer() {
  $("#progressBar").css("width", `0%`);
  let outer = setInterval(function () {
    let curWidth = parseInt($("#progressBar")[0].style.width.replace("%", ""));
    curWidth = parseInt(curWidth + 2);
    $("#progressBar").css("width", `${curWidth}%`);
    if (curWidth >= 80) {
      clearInterval(outer);
    }
  }, 100);
  let inner = setInterval(function () {
    let curWidth = parseFloat(
      $("#progressBar")[0].style.width.replace("%", "")
    );
    if (curWidth >= 80) {
      curWidth = parseFloat(curWidth + 0.1);
      $("#progressBar").css("width", `${curWidth}%`);
      if (curWidth >= 95) {
        clearInterval(inner);
      }
    }
  }, 500);
  return { outer, inner };
}

// 初始化节点可见性，默认收起至建设项目层
function initNodesVisibility(nodes, visible) {
  function recurSetVisible(nodes, visible) {
    nodes.forEach((node) => {
      node.visible = visible;
      if (node.children) {
        recurSetVisible(node.children, visible);
      }
    });
  }
  nodes.forEach((node) => {
    const isProject = node.data.projType === projectType.project;
    if (isProject) {
      node.expanded = visible;
      recurSetVisible(node.children, visible);
    }
  });
}

function initProjects(callback, expandCallback) {
  GetAllProjectData(function (datas) {
    //设置项目类别
    for (let data of datas) {
      if (data.projType === projectType.tender && data.property.valuationType) {
        data.valuationType = ValuationText[data.property.valuationType] || "";
      }
    }
    CommonAjax.post(
      "/options/getOptions",
      [],
      function (rstData) {
        projTreeObj.setting.style.selectedColor =
          rstData.COLOROPTS.SELECTED.backColor;
        projTreeObj.tree = pmTree.createNew(projTreeObj.setting, datas);
        projTreeObj.tree.selected = projTreeObj.tree.items[0];
        projTreeObj.workBook = projTreeObj.buildSheet(
          projTreeObj.workBook,
          "projSpread",
          projTreeObj.setting
        );
        const sheet = projTreeObj.workBook.getSheet(0);
        sheet.options.frozenlineColor = "#ababab";
        sheet.frozenColumnCount(2);
        sheet.name("projectSheet");
        sheetCommonObj.spreadDefaultStyle(projTreeObj.workBook);
        projTreeObj.sumEngineeringCost();
        if (expandCallback) {
          expandCallback();
        } else {
          initNodesVisibility(projTreeObj.tree.items, false);
        }
        projTreeObj.showTreeData(
          projTreeObj.tree.items,
          projTreeObj.setting,
          sheet
        );
        //初始选择
        const initSel = sheet.getSelections()[0]
          ? sheet.getSelections()[0]
          : { row: 0, rowCount: 1 };
        projTreeObj.initSelection(initSel, null, sheet);
        autoFlashHeight();
        projTreeObj.workBook.refresh();
        if (callback) {
          callback();
        }
      },
      function () {
        $.bootstrapLoading.end();
      }
    );
  });
}

/**
 * 初始化数据
 * @return {void} */
async function init(refresh = false, callback, expandCallback) {
  //refresh是刷新页面时才使用的
  try {
    billValuation = billValuation.replace(/\n/g, "\\n");
    rationValuation = rationValuation.replace(/\n/g, "\\n");
    //init spread and pmTree
    if (refresh == false) socketObject.connect("pm"); //socket 连接;
    if (isFirst) {
      isFirst = false;
      $.bootstrapLoading.progressStart(
        "欢迎使用" + $("#projectTitle").val(),
        true
      );
      $("#progress_modal_body").text("首次加载例题，请稍候……");
      await ajaxPost("/pm/api/prepareInitialData", { user_id: userID });
      await importProcessChecking(
        null,
        null,
        () => {
          initProjects(() => {
            $.bootstrapLoading.progressEnd();
            if (callback) {
              callback();
            }
          }, expandCallback);
        },
        true
      );
    } else {
      await importProcessChecking(
        null,
        ({ content }) => {
          $.bootstrapLoading.progressStart(
            "欢迎使用" + $("#projectTitle").val(),
            true
          );
          $("#progress_modal_body").text(content);
        },
        () => {
          $.bootstrapLoading.start();
          initProjects(() => {
            $.bootstrapLoading.end();
            if (callback) {
              callback();
            }
          }, expandCallback);
        },
        true
      );
    }
    engineering =
      engineeringList !== null && engineeringList !== undefined
        ? JSON.parse(engineeringList)
        : [];
  } catch (err) {
    alert(err);
  }
}

function refreshAllPage() {
  if (gcTreeObj.workBook) {
    gcTreeObj.workBook.destroy();
    gcTreeObj.workBook = null;
  }
  gcTreeObj.tree = null;
  init(true);
}

/**
 * 新增建设项目
 *
 * @return {boolean}
 */
function AddProject() {
  let name = $("#project-name").val().trim();
  if (name === "") {
    setDangerInfo($("#project-name-info"), "请填写建设项目名称");
    return false;
  }
  $.bootstrapLoading.start();
  let existCallback = function () {
    setDangerInfo(
      $("#project-name-info"),
      `已存在“${$("#project-name").val()}”`
    );
    STATE.addingProject = false;
    $.bootstrapLoading.end();
  };
  let sucCallback = function () {
    $("#add-project-dialog").modal("hide");
    $("#project-name").val("");
    setDangerInfo($("#project-name-info"), "", false);
    $.bootstrapLoading.end();
    setTimeout(function () {
      STATE.addingProject = false;
    }, 500);
    projTreeObj.emitTreeChange();
  };
  let errCB = function () {
    $.bootstrapLoading.end();
    setTimeout(function () {
      STATE.addingProject = false;
    }, 500);
  };
  let selectedItem = projTreeObj.tree.selected;
  const property = {
    valuationType: $('input[name="valuation-type"]:checked').val(),
  };
  if (property.valuationType === BOQ) {
    property.boqType = +$('input[name="boq-type-input"]:checked').val();
  }
  /*
     * （1）、当前没有焦点行，新建建设项目为第一个节点。
     （2）、当前定位在文件夹，新建建设项目为文件夹的最后一个子节点。
     （3）、当前定位在建设项目，新建建设项目为其后兄弟。
     （4）、当前定位在单项工程或单位工程，新建项目为当前所属建设项目的后兄弟。
     * */
  if (!selectedItem) {
    AddSiblingsItem(
      selectedItem,
      name,
      property,
      projectType.project,
      existCallback,
      sucCallback,
      errCB
    );
  } else {
    if (selectedItem.data.projType === projectType.project) {
      AddSiblingsItem(
        selectedItem,
        name,
        property,
        projectType.project,
        existCallback,
        sucCallback,
        errCB
      );
    } else if (selectedItem.data.projType === projectType.tender) {
      let proj = selectedItem.parent;
      AddSiblingsItem(
        proj,
        name,
        property,
        projectType.project,
        existCallback,
        sucCallback,
        errCB
      );
    } else if (selectedItem.data.projType === projectType.folder) {
      AddChildrenItem(
        selectedItem,
        name,
        property,
        projectType.project,
        existCallback,
        sucCallback,
        errCB
      );
    }
  }
}

function _getOptionDivDomStr(value, rdName, labelName, id, isChecked) {
  return `
        <div class="custom-control custom-radio custom-control-inline">
            <input type="radio" value="${value}" name="${rdName}" ${isChecked ? "checked" : ""
    } id="${id}" class="custom-control-input">
            <label class="custom-control-label" for="${id}">${labelName}</label>
        </div>
    `;
}

// 创建建设项目可选项
function initProjectOptSet($target) {
  const html = `<div class="form-group row">
                        <label for="staticEmail" class="col-auto col-form-label col-form-label-sm">项目类型</label>
                        <div class="col">
                            ${COMPILATION_NAME.includes("公路造价")
      ? ` 
                                ${_getOptionDivDomStr(
        SUGGESTION,
        "valuation-type",
        "建议估算",
        "type-suggestion",
        true
      )}
                                ${_getOptionDivDomStr(
        FEASIBILITY,
        "valuation-type",
        "可行性估算",
        "type-feasibility",
        false
      )}
                                ${_getOptionDivDomStr(
        ROUGH,
        "valuation-type",
        "概算",
        "type-rough",
        false
      )}
                            `
      : ""
    }
                            ${COMPILATION_NAME.includes(
      "内蒙古高速公路日常养护估算(2021)"
    )
      ? `
                                ${_getOptionDivDomStr(
        ESTIMATION,
        "valuation-type",
        "估算",
        "type-suggestion",
        true
      )}
                                `
      : ``
    }
                            ${COMPILATION_NAME.includes("四川养护(2013)") ||
      COMPILATION_NAME.includes("部颁2018计价标准")
      ? `
                                ${_getOptionDivDomStr(
        BILL_BUDGET,
        "valuation-type",
        "清单预算",
        "type-bill_budget",
        true
      )}
                                `
      : ``
    }
                            ${COMPILATION_NAME !==
      "内蒙古高速公路日常养护估算(2021)" &&
      COMPILATION_NAME !== "四川养护(2013)" &&
      COMPILATION_NAME !== "部颁2018计价标准"
      ? `
                                ${!COMPILATION_NAME.includes("部颁2018计价标准")
        ? _getOptionDivDomStr(
          BUDGET,
          "valuation-type",
          "预算",
          "type-budget",
          !COMPILATION_NAME.includes("公路造价")
        )
        : ""
      }
                                ${_getOptionDivDomStr(
        BOQ,
        "valuation-type",
        "工程量清单",
        "type-boq",
        COMPILATION_NAME.includes("部颁2018计价标准")
      )}
                                `
      : ``
    }
                        </div>
                    </div>
                    <div class="form-group row hide-area" id="boq-type">
                        <label for="staticEmail" class="col-auto col-form-label col-form-label-sm">清单类型</label>
                        <div class="col">
                            ${_getOptionDivDomStr(
      BID_INVITATION,
      "boq-type-input",
      "招标",
      "boq-type-tender",
      false
    )}
                            ${_getOptionDivDomStr(
      BID_SUBMISSION,
      "boq-type-input",
      "投标",
      "boq-type-bidder",
      true
    )}
                        </div>
                    </div>`;
  //const $children = $(html);
  $target.empty();
  $target.append($(html));
  $('input[name="valuation-type"]').on("change", function () {
    const valuationType = $(this).val();
    onChangeValuationType(valuationType);
  });
  if (COMPILATION_NAME.includes("部颁2018计价标准")) {
    onChangeValuationType($('input[name="valuation-type"]').val());
  }
}

function onChangeValuationType(valuationType) {
  // 当项目类型是“工程量清单”时，清单类型可见可选
  changeValuationType(valuationType);
  valuationType === BOQ
    ? $("#boq-type").removeClass("hide-area")
    : $("#boq-type").addClass("hide-area");
}

function bindModalShown(folderDialog, projDialog, tenderDialog) {
  folderDialog.on("shown.bs.modal", function () {
    $("#folder-name").focus();
  });
  projDialog.on("shown.bs.modal", function () {
    $("#project-name").focus();
    initProjectOptSet($("#project-reserve"));
  });
  tenderDialog.on("shown.bs.modal", function () {
    $("#tender-name").focus();
  });
}

//新建建设项目、新建单项工程、新建文件夹、重命名弹窗隐藏事件
function bindModalsHidden(
  projDialog,
  tenderDialog,
  folderDialog,
  renameDialog
) {
  projDialog.on("hidden.bs.modal", function () {
    setDangerInfo($("#project-name-info"), "", false);
    $("#project-name").val("");
    $("#project-reserve").empty();
  });
  tenderDialog.on("hidden.bs.modal", function () {
    $("#tender-reserve").empty();
  });
  folderDialog.on("hidden.bs.modal", function () {
    setDangerInfo($("#folder-name-info"), "", false);
    $("#folder-name").val("");
  });
  renameDialog.on("hidden.bs.modal", function () {
    setDangerInfo($("#rename-name-info"), "", false);
    $("#rename-name").val("");
  });
}

//绑定新建建设项目、新建文件夹、重命名回车键功能
function bindInputs(projInput, foldInput, renameInput) {
  projInput.bind("keypress", function (event) {
    if (event.keyCode === 13) {
      $("#addProjOk").click();
      return false;
    }
  });
  foldInput.bind("keypress", function (event) {
    if (event.keyCode === 13) {
      $("#add-folder-confirm").click();
      return false;
    }
  });
  renameInput.bind("keypress", function (event) {
    if (event.keyCode === 13) {
      $("#rename-confirm").click();
      return false;
    }
  });
}
//新建建设项目、单项工程、文件夹、重命名提示(文本改变，暂时不需要)
function getChangedFunc(input, nameInfo) {
  return function () {
    let selected = Tree.selected();
    let parent = selected ? selected.parent : Tree._root;
    let name = input.val();
    if (existName(name, parent.children)) {
      nameInfo.text(`已存在“${name}”`);
      nameInfo.show();
    } else {
      nameInfo.text("");
      nameInfo.hide();
    }
  };
}

//新增节点，初始化汇总数值
function setInitSummaryData(data) {
  if (data.projType === projectType.folder) {
    return;
  }
  //just for View
  data.totalCost = 0;
}

function AddTenderItems(
  selected,
  projName,
  tenderName,
  projectProperty,
  property,
  callback,
  errCB
) {
  const addPath = { p_t: "p_t", t: "t" };
  let path,
    updateDatas = [];
  let tempProjs = getProjs(selected);
  let tempProj = getNodeByName(projName, tempProjs);
  if (tempProj) {
    path = addPath.t;
  } else {
    path = addPath.p_t;
  }
  if (path === addPath.p_t) {
    let parent, pre, next;
    GetNewProjectId(
      2,
      function (IDs) {
        let projID = IDs.lowID,
          tenderID = IDs.lowID + 1;
        if (!selected || selected.data.projType === projectType.project) {
          parent = selected ? selected.parent : projTreeObj.tree._root;
          pre = selected;
          next = selected ? selected.nextSibling : projTreeObj.tree.firstNode();
        } else if (selected.data.projType === projectType.folder) {
          parent = selected ? selected : projTreeObj.tree._root;
          pre = selected ? selected.lastChild() : projTreeObj.tree.firstNode();
          next = null;
        } else if (selected.data.projType === projectType.tender) {
          let selectedProj = selected.parent;
          parent = selectedProj ? selectedProj.parent : projTreeObj.tree._root;
          pre = selectedProj;
          next = selectedProj
            ? selectedProj.nextSibling
            : projTreeObj.tree.firstNode();
        }
        let updateProjs = GetUpdateData(
          pre,
          parent,
          next,
          projName,
          projectProperty,
          projID,
          { updateType: "new", projectType: projectType.project }
        );
        property.rootProjectID = projID;
        let updateTender = {
          updateType: "new",
          updateData: {
            ID: tenderID,
            ParentID: projID,
            NextSiblingID: -1,
            name: tenderName,
            projType: projectType.tender,
            property: property,
          },
        };
        updateDatas = updateDatas.concat(updateProjs);
        updateDatas.push(updateTender);
        UpdateProjectData(
          updateDatas,
          function (datas) {
            let projData, tenderData;
            datas.forEach(function (data) {
              if (data.updateType === "new") {
                data.updateData.shareInfo = [];
                setInitSummaryData(data.updateData);
                if (data.updateData.projType === projectType.project) {
                  projData = data.updateData;
                } else if (data.updateData.projType === projectType.tender) {
                  tenderData = data.updateData;
                  tenderData.feeStandardName =
                    tenderData.property.feeStandardName || "";
                  tenderData.valuationType =
                    ValuationText[tenderData.property.valuationType] || "";
                }
              }
            });
            let pojNode = projTreeObj.insert(projData, parent, next);
            let tenderNode = projTreeObj.insert(tenderData, pojNode, null);
            const rows = [pojNode.serialNo(), tenderNode.serialNo()];
            sheetCommonObj.setRowsAutoFit(
              projTreeObj.workBook.getSheet(0),
              rows,
              0,
              true
            );
            callback();
          },
          errCB
        );
      },
      errCB
    );
  } else if (path === addPath.t) {
    GetNewProjectId(
      1,
      function (IDs) {
        let tenderID = IDs.lowID;
        let pre = tempProj.lastChild();
        property.rootProjectID = tempProj.data.ID;
        let updateTender = {
          updateType: "new",
          updateData: {
            ID: tenderID,
            ParentID: tempProj.id(),
            NextSiblingID: -1,
            name: tenderName,
            projType: projectType.tender,
            property: property,
          },
        };
        updateDatas.push(updateTender);
        if (pre) {
          updateDatas.push({
            updateType: "update",
            updateData: { ID: pre.id(), NextSiblingID: tenderID },
          });
        }
        UpdateProjectData(
          updateDatas,
          function (datas) {
            datas.forEach(function (data) {
              if (data.updateType === "new") {
                data.updateData.shareInfo = [];
                setInitSummaryData(data.updateData);
                data.updateData.feeStandardName =
                  data.updateData.property.feeStandardName || "";
                data.updateData.valuationType =
                  ValuationText[data.updateData.property.valuationType] || "";
                const tenderNode = projTreeObj.insert(
                  data.updateData,
                  tempProj,
                  null
                );
                const rows = [tenderNode.serialNo()];
                sheetCommonObj.setRowsAutoFit(
                  projTreeObj.workBook.getSheet(0),
                  rows,
                  0,
                  true
                );
              }
            });
            callback();
          },
          errCB
        );
      },
      errCB
    );
  }
}

/**
 * 新增子元素
 *
 * @param {String} name
 * @param {String} type
 * @param {function} callback
 * @return {void}
 */
function AddChildrenItem(
  selected,
  name,
  property,
  type,
  existCallback,
  sucCallback,
  errCB
) {
  if (!selected) {
    selected = projTreeObj.tree.selected;
  }
  let parent = selected ? selected : projTreeObj.tree._root;
  let pre = selected ? selected.lastChild() : projTreeObj.tree.firstNode();
  if (existName(name, parent.children)) {
    //alert('同级目录已存在相同名称数据.');
    existCallback();
  } else {
    GetNewProjectId(
      1,
      function (IDs) {
        let typeInfo = {
          updateType: "new",
          projectType: type,
        };
        let updateData = GetUpdateData(
          pre,
          parent,
          null,
          name,
          property,
          IDs.lowID,
          typeInfo
        );
        projTreeObj.tree.maxNodeId(IDs.lowID - 1);
        UpdateProjectData(
          updateData,
          function (datas) {
            datas.forEach(function (data) {
              if (data.updateType === "new") {
                data.updateData.shareInfo = [];
                setInitSummaryData(data.updateData);
                const node = projTreeObj.insert(data.updateData, parent, null);
                sheetCommonObj.setRowsAutoFit(
                  projTreeObj.workBook.getSheet(0),
                  [node.serialNo()],
                  0,
                  true
                );
              }
            });
            sucCallback();
          },
          errCB
        );
      },
      errCB
    );
  }
}

/**
 * 新增同级元素
 *
 * @param {String} name
 * @param {String} type
 * @param {function} callback
 * @return {void}
 */
function AddSiblingsItem(
  selected,
  name,
  property,
  type,
  existCallback,
  sucCallback,
  errCB
) {
  if (!selected) {
    selected = projTreeObj.tree.selected;
  }
  let parent = selected ? selected.parent : projTreeObj.tree._root;
  let next = selected ? selected.nextSibling : projTreeObj.tree.firstNode();
  if (existName(name, parent.children, type)) {
    //alert('同级目录已存在相同名称数据.');
    existCallback();
  } else {
    GetNewProjectId(
      1,
      function (IDs) {
        let typeInfo = {
          updateType: "new",
          projectType: type,
        };
        let updateData = GetUpdateData(
          selected,
          parent,
          next,
          name,
          property,
          IDs.lowID,
          typeInfo
        );
        projTreeObj.tree.maxNodeId(IDs.lowID - 1);
        UpdateProjectData(
          updateData,
          function (datas) {
            datas.forEach(function (data) {
              if (data.updateType === "new") {
                data.updateData.shareInfo = [];
                setInitSummaryData(data.updateData);
                const node = projTreeObj.insert(data.updateData, parent, next);
                sheetCommonObj.setRowsAutoFit(
                  projTreeObj.workBook.getSheet(0),
                  [node.serialNo()],
                  0,
                  true
                );
              }
            });
            sucCallback();
          },
          errCB
        );
      },
      errCB
    );
  }
}

//根据工程专业名称+费用标准名称获取工程专业库
function getEngineeringLib(cascadeName, engineeringList) {
  for (let eng of engineeringList) {
    let engName = eng.lib.name ? eng.lib.name : "";
    let engFeeName = eng.lib.feeName ? eng.lib.feeName : "";
    if (cascadeName === engName + engFeeName) {
      return eng.lib;
    }
  }
  return null;
}

function getValuationData(type) {
  let valuationData = [];
  if (type === SUGGESTION) {
    valuationData = JSON.parse(suggestionValuation);
  } else if (type === FEASIBILITY) {
    valuationData = JSON.parse(feasibilityValuation);
  } else if (type === ROUGH) {
    valuationData = JSON.parse(roughValuation);
  } else if (type === BUDGET) {
    valuationData = JSON.parse(billValuation);
  } else if (type === BILL_BUDGET) {
    valuationData = JSON.parse(rationValuation);
  } else if (type === ESTIMATION) {
    valuationData = JSON.parse(estimationData);
  } else {
    valuationData = JSON.parse(rationValuation);
  }
  return valuationData;
}

function getEngineeringList() {
  let valuation = $("#valuation").val();
  let valuationType = $("input[name='valuation_type']:checked").val();
  let valuationData = getValuationData(valuationType);
  let engineeringList = [];
  for (let tmp of valuationData) {
    if (tmp.id === valuation) {
      engineeringList = tmp.engineering_list;
      break;
    }
  }
  return engineeringList;
}

function getTaxGroupList(type) {
  //getcalcProgramList
  let egrs = getEngineeringList();
  let groupList = [];
  //let egrID = $("#tender-engineering").val();
  let engLib = getEngineeringLib(
    $("#tender-engineering").val() + $("#tender-feeStandard").val(),
    egrs
  );
  if (engLib) {
    if (type) {
      //是否要过滤，如果这个参数不传，则返回整个数组;
      for (let group of engLib.tax_group) {
        if (group.taxType == type && group.program_lib) {
          groupList.push(group);
        }
      }
    } else {
      groupList = engLib.tax_group;
    }
  }
  return groupList;
}

function getNodeByName(name, nodes) {
  for (let i = 0, len = nodes.length; i < len; i++) {
    if (name === nodes[i].data.name) {
      return nodes[i];
    }
  }
  return null;
}

//同级是否重名,文件夹与建设项目可以同名
function existName(name, nodes, projType = null) {
  for (let i = 0, len = nodes.length; i < len; i++) {
    if (name === nodes[i].data.name) {
      if (
        projType &&
        projType === projectType.folder &&
        nodes[i].data.projType === projectType.project
      ) {
        continue;
      }
      return true;
    }
  }
  return false;
}

//获取新建单位工程时的建设项目数据
function getProjs(selected) {
  let rst = [];
  let temp;
  let firstNode;
  if (!selected) {
    temp = projTreeObj.tree._root;
    firstNode = temp.children[0];
  } else if (selected.data.projType === projectType.folder) {
    temp = selected;
    firstNode = temp.children[0];
  } else if (selected.data.projType === projectType.project) {
    temp = selected.parent;
    firstNode = temp.children[0];
  } else if (selected.data.projType === projectType.tender) {
    let proj = selected.parent;
    temp = proj.parent;
    firstNode = proj;
  }
  for (let childNode of temp.children) {
    if (childNode.data.projType === projectType.project) {
      rst.push(childNode);
    }
  }
  if (firstNode) {
    //firstNode to first place
    let index = null;
    for (let i = 0, len = rst.length; i < len; i++) {
      if (rst[i].data.ID === firstNode.data.ID) {
        index = i;
        break;
      }
    }
    if (index) {
      rst.splice(index, 1);
      rst.splice(0, 0, firstNode);
    }
  }
  return rst;
}

function setFileOptions(projID) {
  // 获取单价文件数据
  if (!projID) {
    $("#unit-price").children("option:not(':first')").remove();
    let first = $("#tender-fee-rate").children("option").first();
    $("#tender-fee-rate").empty();
    $("#tender-fee-rate").append(first);
  } else {
    getUnitFile(projID, function (response) {
      $("#unit-price").children("option:not(':first')").remove();
      if (response.data.length <= 0) {
        return false;
      }
      let unitFileHtml = "";
      for (let tmp of response.data) {
        unitFileHtml +=
          '<option value="' + tmp.id + '">' + tmp.name + "</option>";
      }
      $("#unit-price").children("option").first().after(unitFileHtml);
    });
    // 获取费率文件数据
    getFeeRateFile(projID, function (response) {
      let first = $("#tender-fee-rate").children("option").first();
      $("#tender-fee-rate").empty();
      $("#tender-fee-rate").append(first);
      if (response.data.length <= 0) {
        return false;
      }
      for (let tmp of response.data) {
        let option = $("<option>").val(tmp.ID).text(tmp.name);
        $("#tender-fee-rate").append(option);
      }
    });
  }
}

// 根据建设项目是否有项目类型属性，控制新建单位时，单位工程项目类别选项的可见性和只读性
// 主要是兼容性处理：新建分段时，如果建设项目已有项目类型，则分段的项目类型、清单类型同建设项目的，窗口中只读；如果建设项目中没有，则可选择（是为了兼容养护的旧项目）
function handleTenderValuationTypeViewState(projectID) {
  if (!projectID) {
    return changeValuationType(BUDGET);
  }
  const projectNode = projTreeObj.tree.findNode(projectID); // 建设项目节点
  if (!projectNode) {
    return changeValuationType(BUDGET);
  }
  const projectValuationType = projectNode.data.property.valuationType;
  if (projectValuationType) {
    changeValuationType(projectValuationType);
    $('input[name="valuation_type"]').attr("disabled", "disabled");
  } else {
    //恢复成默认选中预算项目类别。
    changeValuationType(BUDGET);
    $('input[name="valuation_type"]').removeAttr("disabled");
  }
}

//建设项目下拉框
function setProjOptions(projs, selected) {
  $("#poj-name-list").empty();
  $("#poj-name").val("");
  if (projs.length > 0) {
    let firstProj =
      selected && selected.data.projType === projectType.project
        ? selected
        : projs[0];
    $("#poj-name").val(firstProj.data.name);
    setFileOptions(firstProj.data.ID);
    for (let i = 0, len = projs.length; i < len; i++) {
      let $proj = $(
        `<a class='text-ellipsis' title="${projs[i].data.name}" data-id="${projs[i].data.ID}">`
      )
        .val(projs[i].data.ID)
        .text(projs[i].data.name);
      $proj.addClass("dropdown-item");
      $proj.attr("href", "javascript:void(0);");
      $proj.click(function () {
        $("#poj-name").val(projs[i].data.name);
        setFileOptions(projs[i].data.ID);
        $("#poj-name-info").hide();
        $("#tender-reserve").empty();
        $("#val-type-group").show();
        handleTenderValuationTypeViewState(projs[i].data.ID);
      });
      $("#poj-name-list").append($proj);
    }
  } else {
    setFileOptions(null);
  }
}

function hasTender(selected, pojName, tenderName) {
  let isExist = false;
  let tempProjs = getProjs(selected);
  if (pojName !== "") {
    let tempProj = getNodeByName(pojName, tempProjs);
    if (tempProj) {
      let tempTender = getNodeByName(tenderName, tempProj.children);
      if (tempTender) {
        isExist = true;
      }
    }
  }
  return isExist;
}

//替换class
function replaceClass(selector, orgClass, newClass) {
  selector.removeClass(orgClass);
  selector.addClass(newClass);
}
//设置提示信息
function setDangerInfo(area, info, show = true) {
  area.text(info);
  if (show) area.show();
  else area.hide();
}

/**
 * 新增分段
 *
 * @return {boolean}
 */
function AddTender() {
  try {
    let projName = $("#poj-name").val().trim();
    if (projName === "") {
      replaceClass($("#poj-name-info"), "text-info", "text-danger");
      setDangerInfo($("#poj-name-info"), "请填写建设项目名称");
      return false;
    }

    let tenderName = $("#tender-name").val();
    if (tenderName === "") {
      setDangerInfo($("#tender-name-info"), "请填写单位工程名称");
      return false;
    }

    if (hasTender(projTreeObj.tree.selected, projName, tenderName)) {
      return false;
    }
    let unitPriceFileObj = getAddTenderFile(
      tenderName,
      $("#unit-price"),
      $("#unit-price").children()
    );
    let feeFileObj = getAddTenderFile(
      tenderName,
      $("#tender-fee-rate"),
      $("#tender-fee-rate").children()
    );
    let valuation = $("#valuation").val();
    /*
     * 计价规则只是隐藏显示了，工程专业id还是要通过养护类别、费用标准确定，因为后台结构没有变化
     * */
    let engineeringName = $("#tender-engineering").val();
    if (!engineeringName || engineeringName === "") {
      setDangerInfo($("#engineering-info"), "请选择养护类别");
      return false;
    }
    // 费用标准只是隐藏显示了（某些费用定额下）
    let feeName = $("#tender-feeStandard").val();
    if (!feeName || feeName === "") {
      setDangerInfo($("#feeStandard-info"), "请选择费用标准");
      return false;
    }

    let taxType = $("#taxType").val();
    /*if(!taxType || taxType ===""){
            return false;
        }*/

    let IDGroup = $("#tender-calcProgram").val();
    // 如果compilationData有估算(estimation_valuation)的话，可以不要计算程序吧
    if (
      (!IDGroup || IDGroup === "") &&
      compilationData.estimation_valuation.length === 0
    ) {
      setDangerInfo($("#calcProgram-info"), "请选择计算程序");
      return false;
    }
    IDGroup = IDGroup.split("|-|");

    let calcProgram = isNaN(parseInt(IDGroup[0]))
      ? IDGroup[0]
      : parseInt(IDGroup[0]); //转换成整数
    let templateLibID = IDGroup[1];
    let colLibID = IDGroup[2];
    let feeLibID = IDGroup[3];
    if (templateLibID == "" || colLibID == "" || feeLibID == "") {
      alert("工程专业配置有误！");
      return false;
    }
    //如果是新建费率的情况
    if (feeFileObj.id.indexOf("newFeeRate") != -1) feeFileObj.id += feeLibID;
    let valuationName = $("#valuation").children("option:selected").text();
    const projectInfo = {};
    // 单位工程项目类型、清单类型则跟着建设项目可选项走
    const selectedItem = projTreeObj.tree.selected;
    const tempProjs = getProjs(selectedItem);
    const matchedProject = getNodeByName(projName, tempProjs);
    let valuationType;
    let boqType;
    if (matchedProject) {
      valuationType =
        matchedProject.data.property.valuationType ||
        $("input[name='valuation_type']:checked").val();
      boqType = matchedProject.data.property.boqType || null;
    } else {
      valuationType = $("input[name='valuation-type']:checked").val(); // 建设项目选项
      projectInfo.valuationType = valuationType;
      if (valuationType === BOQ) {
        boqType = +$("input[name='boq-type-input']:checked").val(); // 建设项目选项
        projectInfo.boqType = boqType;
      }
    }

    let engineering = undefined;
    let valuationData = getValuationData(valuationType);
    let engineeringList = [];
    for (let tmp of valuationData) {
      if (tmp.id === valuation) {
        engineeringList = tmp.engineering_list;
        break;
      }
    }
    let libs = getEngineeringLib(engineeringName + feeName, engineeringList);
    if (!libs) {
      alert("数据错误，无法确定工程专业库!");
      return false;
    }
    // 一个项目里面，这两个文件必须得有，而界面又没有像费率、单价文件那样给出可选项。所以这里给出提示。
    if (!libs.artificial_lib) throw "编办没有绑定人工系数标准文件";

    let featureLibID = "",
      progressiveLibID = "";
    if (libs.feature_lib && libs.feature_lib.length > 0) {
      featureLibID = libs.feature_lib[0].id;
    }
    if (libs.progressive_lib && libs.progressive_lib.length > 0) {
      progressiveLibID = libs.progressive_lib[0].id;
    }

    let calcProgramName = $("#tender-calcProgram")
      .children("option:selected")
      .text();
    //let newTab = window.open('about:blank');
    let tempProj = getNodeByName(projName, tempProjs);
    if (!tempProj) {
      if (isStopCreate()) {
        $('#stop-create-dialog').modal('show');
        return;
      }
    }
    $.bootstrapLoading.start();
    let callback = function (tenderNode) {
      $("#add-tender-dialog").modal("hide");
      $("#tender-name").val("");
      $("#tender-fee-rate").children("option").removeAttr("selected");
      $("#tender-engineering").children("option").removeAttr("selected");
      $("#tender-calcProgram").children("option").removeAttr("selected");
      $("#poj-name").val("");
      $("#poj-name-info").hide();
      $.bootstrapLoading.end();
      setTimeout(function () {
        STATE.addingTender = false;
      }, 500);
      projTreeObj.emitTreeChange();
    };
    let errCB = function () {
      $.bootstrapLoading.end();
      setTimeout(function () {
        STATE.addingTender = false;
      }, 500);
    };
    //地区
    let region = $("#regionDiv").find("select").val() || "全省";
    let tenderInfo = {
      valuation: valuation,
      valuationType: valuationType,
      valuationName: valuationName,
      isInstall: libs.isInstall !== undefined ? libs.isInstall : false,
      engineering: libs.engineering, //定额默认取费专业
      projectEngineering: libs.projectEngineering, //单位工程默认取费专业（造价书中插入量价、工料机时用）
      engineering_id: libs._id,
      engineeringName: engineeringName,
      feeStandardName: feeName,
      unitPriceFile: { name: unitPriceFileObj.name, id: unitPriceFileObj.id },
      feeFile: { name: feeFileObj.name, id: feeFileObj.id },
      calcProgram: { name: calcProgramName, id: calcProgram },
      taxType: taxType,
      templateLibID: templateLibID,
      colLibID: colLibID,
      featureLibID: featureLibID,
      progressiveLibID: progressiveLibID,
      region: region,
    };
    if (boqType) {
      tenderInfo.boqType = boqType;
    }
    AddTenderItems(
      selectedItem,
      projName,
      tenderName,
      projectInfo,
      tenderInfo,
      callback,
      errCB
    );
  } catch (error) {
    alert(error);
  }
}
/*
 * 新增单位工程时选择的文件
 * @tenderName {String}
 * @selValue {String}
 * @options {Array}
 * */
function getAddTenderFile(tenderName, selected, options) {
  let rst = { name: "", id: "" };
  let selValue = selected.val();
  //选择的是新建单价/费率文件
  if (selValue === "") {
    //若新建的单位工程名称与建设项目下文件重名，则引用该文件
    for (let i = 0; i < options.length; i++) {
      if (i === 0) {
        continue;
      }
      let option = options[i];
      if ($(option).text() === tenderName) {
        rst.id = $(option).val();
        break;
      }
    }
    rst.name = tenderName;
  }
  //非新建
  else {
    rst.id = selected.val();
    rst.name = selected.children("option:selected").text();
  }
  return rst;
}

/**
 * 新增文件夹
 *
 * @return {boolean}
 */
function AddFolder() {
  let name = $("#folder-name").val().trim();
  if (name === "") {
    setDangerInfo($("#folder-name-info"), "请填写文件夹名称");
    return false;
  }

  let selectedItem = projTreeObj.tree.selected;
  $.bootstrapLoading.start();
  let existCallback = function () {
    setDangerInfo($("#folder-name-info"), `已存在“${$("#folder-name").val()}”`);
    STATE.addingFolder = false;
    $.bootstrapLoading.end();
  };
  let sucCallback = function () {
    $("#add-folder-dialog").modal("hide");
    $("#folder-name").val("");
    setDangerInfo($("#folder-name-info"), "", false);
    $.bootstrapLoading.end();
    setTimeout(function () {
      STATE.addingFolder = false;
    }, 500);
    projTreeObj.emitTreeChange();
  };
  let errCB = function () {
    $.bootstrapLoading.end();
    setTimeout(function () {
      STATE.addingFolder = false;
    }, 500);
  };
  if (selectedItem) {
    // 判断是否超过3层
    if (!withinTreble(selectedItem)) {
      alert("文件夹不能超过3层");
      return false;
    }
    if (
      selectedItem.data.projType === projectType.folder ||
      selectedItem.data.projType === projectType.project
    ) {
      AddSiblingsItem(
        null,
        name,
        null,
        projectType.folder,
        existCallback,
        sucCallback,
        errCB
      );
    } else if (selectedItem.data.projType === projectType.tender) {
      let proj = selectedItem.parent;
      AddSiblingsItem(
        proj,
        name,
        null,
        projectType.folder,
        existCallback,
        sucCallback,
        errCB
      );
    }
  } else {
    AddSiblingsItem(
      null,
      name,
      null,
      projectType.folder,
      existCallback,
      sucCallback,
      errCB
    );
  }
}

function getFolderLevel(selected) {
  let level = 0;
  while (selected && selected.data) {
    if (selected.data.projType === projectType.folder) {
      level++;
    }
    selected = selected.parent;
  }
  return level;
}

// 选中节点及其子项最大文件夹层数
function getMaxFolderLevel(selected) {
  const nodes = [selected, ...selected.getAllChildren()];
  const levels = nodes.map((node) => getFolderLevel(node));
  return Math.max(...levels);
}

//判断是否是三层文件夹以内
function withinTreble(selectedItem) {
  if (selectedItem.data.projType === projectType.tender) {
    selectedItem = selectedItem.parent;
  }
  if (
    selectedItem.parent.parent &&
    hasFolder(selectedItem.parent.parent.children) &&
    selectedItem.parent.parent.parent &&
    hasFolder(selectedItem.parent.parent.parent.children) &&
    selectedItem.parent.parent.parent.parent &&
    hasFolder(selectedItem.parent.parent.parent.parent.children)
  ) {
    return false;
  }
  return true;
  function hasFolder(items) {
    for (let i = 0, len = items.length; i < len; i++) {
      if (items[i].data.projType === projectType.folder) {
        return true;
      }
    }
    return false;
  }
}

/**
 * 组织更新数据
 *
 * @param {Object} parent
 * @param {Object} next
 * @param {String} name
 * @param {Object} type
 * @return {Object}
 */
function GetUpdateData(pre, parent, next, name, property, newId, type) {
  let data = [];
  let updateData = {};

  let rootProjectID = -1;
  if (type.projectType === projectType.tender) {
    let rootProject = parent ? parent.parent : projTreeObj.tree._root;
    rootProjectID = rootProject ? rootProject.id() : -1;
    if (property) {
      property.rootProjectID = rootProjectID;
    }
  }

  updateData["updateType"] =
    type.updateType === undefined ? "new" : type.updateType;
  updateData["updateData"] = {};
  if (newId !== "") {
    updateData["updateData"][projTreeObj.tree.setting.tree.id] = newId;
  }
  updateData["updateData"][projTreeObj.tree.setting.tree.pid] = parent
    ? parent.id()
    : -1;
  updateData["updateData"][projTreeObj.tree.setting.tree.nid] = next
    ? next.id()
    : -1;
  if (name !== "") {
    updateData["updateData"]["name"] = name;
  }
  if (property !== null && property !== undefined) {
    updateData["updateData"]["property"] = property;
  }
  if (type !== null && type.projectType !== null) {
    updateData["updateData"]["projType"] =
      type.projectType !== undefined ? type.projectType : "Tender";
  }
  if (pre) {
    //维护preNode
    let updateObj = Object.create(null);
    updateObj.updateData = Object.create(null);
    updateObj.updateType = "update";
    updateObj.updateData.ID = pre.id();
    updateObj.updateData.NextSiblingID = newId;
    data.push(updateObj);
  }
  data.push(updateData);
  return data;
}

/**
 * 获取删除数据
 *
 * @return {Object} node
 * @return {Object}
 */
function GetDeleteUpdateData(node) {
  let datas = [],
    updateData,
    pre = node.preSibling(),
    deleteNodeData = function (node) {
      var data = Object.create(null);
      data["updateType"] = "delete";
      //data['NextSiblingID'] = node.data.NextSiblingID;
      data["updateData"] = Object.create(null);
      data["updateData"][projTreeObj.tree.setting.tree.id] = node.id();
      data["updateData"]["projType"] = node.data.projType;
      if (node.data.projType === "Tender") {
        data["updateData"]["FullFolder"] = GetFullFolder(node.parent);
      }
      return data;
    },
    addDeleteChildren = function (children) {
      children.forEach(function (child) {
        datas.push(deleteNodeData(child));
        addDeleteChildren(child.children);
      });
    };
  if (pre && pre.id() !== -1) {
    updateData = {};
    updateData["updateType"] = "update";
    updateData["updateData"] = {};
    updateData["updateData"][projTreeObj.tree.setting.tree.id] = pre.id();
    updateData["updateData"][projTreeObj.tree.setting.tree.nid] = node
      ? node.nid()
      : -1;
    datas.push(updateData);
  }
  datas.push(deleteNodeData(node));
  addDeleteChildren(node.children);
  return datas;
}

/**
 * 获取父级所有名称
 *
 * @return {Array}
 */
function GetFullFolder(node) {
  let fullFolder = [];
  let cur = node;
  while (cur && cur.data) {
    fullFolder.unshift(cur.data.name);
    cur = cur.parent;
  }
  return fullFolder;
}

/**
 * 获取需要更新的前节点
 *
 * @param {Object} parent
 * @param {Object} next
 * @return {Object}
 */
function GetNeedUpdatePreNode(parent, next) {
  if (next) {
    return next.preSibling();
  } else if (parent) {
    return parent.firstChild();
  } else {
    return null;
  }
}

/**
 * 获取最新id
 *
 * @param {function} callback
 * @return {void}
 */
function GetNewProjectId(count, callback, errCB) {
  CommonAjax.post(
    "/pm/api/getNewProjectID",
    { count: count },
    function (data) {
      callback(data);
    },
    errCB
  );
}

/**
 * 重命名项目
 *
 * @param {Number} projectId
 * @param {String} newName
 * @param {Number} parentID
 * @param {function} callback
 * @return {void}
 */
function RenameProject(projectId, newName, parentID, callback) {
  $.ajax({
    type: "POST",
    url: "/pm/api/renameProject",
    data: {
      data: JSON.stringify({
        user_id: userID,
        id: projectId,
        newName: newName,
        parentID: parentID,
      }),
    },
    dataType: "json",
    cache: false,
    timeout: 5000,
    success: function (result) {
      if (result.error === 0) {
        callback();
      } else {
        if (result.message === "同级目录已存在相同名称数据") {
          setDangerInfo($("#rename-name-info"), `已存在“${newName}”`);
        }
      }
    },
    error: function (iqXHR, textStatus, errorThrown) {
      alert("error " + textStatus + " " + errorThrown);
    },
  });
}

/**
 * 转换当前树结构为zTree结构
 *
 * @param {Object} Tree
 * @param {Object} zTreeObj
 * @param {Object} filterNode
 * @return {Mixed}
 */
function ConvertTreeToZtree(Tree, zTreeObj, filterNode) {
  let setting = {
    data: {
      simpleData: {
        enable: true,
        idKey: "id",
        pIdKey: "pId",
        rootPId: "-1",
      },
    },
  };
  let zTreeData = [],
    exportNodesData = function (nodes) {
      nodes.forEach(function (node) {
        if (node !== filterNode) {
          var data = {};
          data["id"] = node.data[Tree.setting.tree.id];
          data["pId"] = node.pid();
          data["name"] = node.data["name"];
          data["isParent"] = node.data.projType === "Folder"; //(node.data.projType === 'Folder' && node.children.length === 0);
          data["open"] = node.data.projType === "Folder"; //node.children.length !== 0;
          zTreeData.push(data);
          exportNodesData(node.children);
        }
      });
    };
  exportNodesData(Tree._root.children);
  return $.fn.zTree.init(zTreeObj, setting, zTreeData);
}

/**
 * 获取指定zTree节点
 *
 * @param {Object} zTreeObj
 * @return {object}
 */
function GetTargetTreeNode(zTreeObj) {
  if (!zTreeObj || !projTreeObj.tree) {
    return null;
  }

  let ztree_selected =
    zTreeObj.getSelectedNodes().length === 0
      ? null
      : zTreeObj.getSelectedNodes()[0];
  return ztree_selected ? projTreeObj.tree.findNode(ztree_selected.id) : null;
}

/**
 * 根据指定id获取对应的工程专业
 *
 * @param {Array} engineeringList
 * @return {String}
 */
function getEngineeringHtml(engineeringList) {
  //
  let result = "";
  if (engineeringList.length <= 0) {
    return result;
  }
  let engineeringObject = {};
  for (let tmp of engineering) {
    engineeringObject[tmp.value] = tmp.name;
  }
  let engLibNames = [];
  for (let i = 0; i < engineeringList.length; i++) {
    let tmp = engineeringList[i];
    if (engLibNames.includes(tmp.lib.name)) {
      continue;
    }
    result += `<option ${i === 0 ? "selected" : ""} value="${tmp.lib.name}">${tmp.lib.name
      }</option>`;
    engLibNames.push(tmp.lib.name);
  }
  return result;
}

/**
 * 远程获取项目属性数据
 *
 * @param {Object} projectInfo
 * @return {void}
 */
function getProperty(projectInfo) {
  if (projectInfo.property === undefined) {
    return;
  }
  projectProperty = projectInfo.property;
  // 写入专业工程相关
  let engineeringHtml = getEngineeringHtml(projectProperty.engineeringList);
  $("#tender-engineering").html(engineeringHtml);

  // 填入计价规则
  let valuationHtml =
    '<option value="' +
    projectProperty.valuation +
    '">' +
    projectProperty.valuationName +
    "</option>";
  $("#tender-valuation").html(valuationHtml);

  // 选中计价方式
  $("input[name='tender_valuation_type']")
    .attr("disabled", "disabled")
    .removeAttr("checked", "checked");
  $(
    "input[name='tender_valuation_type'][value='" +
    projectProperty.valuationType +
    "']"
  )
    .attr("checked", "checked")
    .removeAttr("disabled", "disabled");
}

/**
 * 获取单价文件
 *
 * @param {Number} parentID
 * @return {void}
 */
function getUnitFile(parentID, callback) {
  parentID = parseInt(parentID);
  if (isNaN(parentID) && parentID <= 0) {
    return;
  }

  $.ajax({
    url: "/pm/api/getUnitFile",
    type: "post",
    data: { data: JSON.stringify({ user_id: userID, parentID: parentID }) },
    dataType: "json",
    error: function () {
      alert("数据传输错误!");
    },
    beforeSend: function () { },
    success: function (response) {
      if (response.error === 1) {
        alert("获取失败!");
      } else {
        if (callback) {
          callback(response);
        }
      }
    },
  });
}

/**
 * 获取费率文件
 *
 * @param {Number} parentID
 * @return {void}
 */
function getFeeRateFile(parentID, callback) {
  parentID = parseInt(parentID);
  if (isNaN(parentID) && parentID <= 0) {
    return;
  }

  $.ajax({
    url: "/pm/api/getFeeRateFile",
    type: "post",
    data: { data: JSON.stringify({ user_id: userID, parentID: parentID }) },
    dataType: "json",
    error: function () {
      alert("数据传输错误!");
    },
    beforeSend: function () { },
    success: function (response) {
      if (response.error === 1) {
        alert("获取失败!");
      } else {
        if (callback) {
          callback(response);
        }
      }
    },
  });
}

/**
 * 加载单价、费率文件数据到侧边栏
 *
 * @return {void}
 */
function setDataToSideBar() {
  // 获取当前点击的数据
  let that = projTreeObj;
  let selectedItem = that.tree.selected;
  while (
    [projectType.tender, projectType.engineering].includes(
      selectedItem.data.projType
    ) &&
    selectedItem.parent
  ) {
    selectedItem = selectedItem.parent;
  }
  let name = selectedItem.data.name;
  let target =
    selectedItem.data.projType === projectType.project
      ? "#summary-project"
      : "#summary-engineering";
  $(".side-content .p-3").hide();
  $(target).show();

  // 加载单价文件与费率文件
  if (selectedItem.data.projType === projectType.project) {
    let engineeringData =
      selectedItem.children !== null && selectedItem.children.children !== null
        ? selectedItem.children
        : [];
    let unitPriceFileList = [];
    let feeFileList = [];
    let poj_tenders = getProjTenders(selectedItem);
    getUnitFile(selectedItem.data.ID, function (response) {
      unitPriceFileList = unitPriceFileList.concat(response.data);
      $(target + "-unit-price-table tbody").empty();
      set_file_table(
        target,
        poj_tenders,
        unitPriceFileList,
        fileType.unitPriceFile
      );
    });
    getFeeRateFile(selectedItem.data.ID, function (response) {
      feeFileList = feeFileList.concat(response.data);
      $(target + "-fee-table tbody").empty();
      set_file_table(target, poj_tenders, feeFileList, fileType.feeRateFile);
    });
  }
}

//获取建设项目的全部单位工程
function getProjTenders(proj) {
  if (proj.data.projType === projectType.tender) {
    proj = proj.parent;
  }
  return proj.children;
}
//单价、费率文件汇总信息的使用次数、使用该文件的单位工程
function getUsedObj(tenders, fileId, type) {
  let rst = Object.create(null),
    usedCount = 0,
    usedInfo = "";
  rst.usedCount = 0;
  rst.usedInfo = null;
  for (let i = 0, len = tenders.length; i < len; i++) {
    if (tenders[i].data.property) {
      let theFile =
        type === fileType.unitPriceFile
          ? tenders[i].data.property.unitPriceFile || null
          : tenders[i].data.property.feeFile || null;
      if (theFile && theFile.id == fileId) {
        usedCount++;
        usedInfo += tenders[i].data.name + "<br>";
      }
    }
  }
  if (usedCount > 0) {
    usedInfo = usedInfo.slice(0, usedInfo.length - 4);
    rst.usedCount = usedCount;
    rst.usedInfo = usedInfo;
  }
  return rst;
}

//单价、费率文件汇总界面交互
function bindEvents_file_table(jqS, usedObj, targetBody, type) {
  //悬浮显示删除和重命名按钮
  $(jqS).hover(
    function () {
      $("p", this).show();
    },
    function () {
      $("p", this).hide();
    }
  );
  //删除
  if (usedObj.usedCount > 0) {
    //不可删除
    $(jqS + " p a:eq(0)").addClass("disabled");
    $(jqS + " p a:eq(0)").removeAttr("data-target");
  } else {
    $(jqS + " p a:eq(0)").on("click", function () {
      let dispName = $(jqS + " div:eq(0)")[0].childNodes[0].textContent;
      //刷新删除弹出框内容
      let delData = '删除"' + dispName + '"？';
      $("#del-wj .modal-body h5").text(delData);
      let attrId = $(jqS).attr("id");
      let id = attrId.slice(5, attrId.length);
      if (type === fileType.unitPriceFile) {
        id = parseInt(id);
      }
      let obj = Object.create(null);
      obj.fileType = type;
      obj.id = id;
      fileDelObj = obj;
    });
  }
  //重命名
  let fileObjs = getFileObj(targetBody, type),
    fileDiv = $(jqS + " div:eq(0)"),
    renameDiv = $(jqS + " div:eq(1)"),
    hintText = $(jqS).find("span"),
    postFix = "";
  $(jqS + " p a:eq(1)").on("click", function () {
    let orgDispName = $(jqS + " div:eq(0)")[0].childNodes[0].textContent;
    let orgName = orgDispName;
    $(jqS + " input").val(orgName);
    fileDiv.hide();
    renameDiv.show();
    $(jqS).find("input:eq(0)").focus();
    $(jqS)
      .find("input:eq(0)")
      .blur(function () {
        fileDiv.show();
        renameDiv.hide();
        hintText.hide();
      });
  });
  //回车键确认重命名
  $(jqS)
    .find("input:eq(0)")
    .keypress(function (e) {
      if (e.keyCode === 13) {
        let orgName = $(jqS + " div:eq(0)")[0].childNodes[0].textContent;
        let attrId = $(jqS).attr("id");
        let id = attrId.slice(5, attrId.length);
        let newName = $(jqS + " input")
          .val()
          .trim();
        if (newName !== orgName) {
          if (hasThisFileName(fileObjs, newName)) {
            hintText.show();
            return;
          }
          if (newName.trim().length === 0) {
            alert("文件名不可为空！");
            $(jqS + " input").val(orgName);
            return;
          }
          //ajax
          let updateObj = Object.create(null);
          updateObj.fileType = type;
          updateObj.updateType = "update";
          updateObj.updateData = Object.create(null);
          if (type === fileType.unitPriceFile) {
            updateObj.updateData.id = parseInt(id);
          } else if (type === fileType.feeRateFile) {
            updateObj.updateData.ID = id;
          }
          updateObj.updateData.name = newName;
          a_updateFiles([updateObj], function () {
            let newDispName = newName + postFix;
            fileDiv[0].childNodes[0].textContent = newDispName;
            fileDiv.show();
            renameDiv.hide();
            //refresh tender
            refreshTenderFile(
              getTendersByFile(type, id, projTreeObj.tree.selected),
              type,
              newName
            );
          });
        }
        let newDispName = newName + postFix;
        fileDiv[0].childNodes[0].textContent = newDispName;
        fileDiv.show();
        renameDiv.hide();
        hintText.hide();
      }
    });
  //悬浮框显示使用该文件的单位工程
  $($(jqS)[0].nextSibling).popover({
    placement: "bottom",
    html: true,
    trigger: "hover", //| focus.
    content: usedObj.usedInfo ? usedObj.usedInfo : "",
  });
}

//更新单价、费率文件（删除、重命名）
function a_updateFiles(updateDatas, callback) {
  $.ajax({
    type: "post",
    url: "/pm/api/updateFiles",
    data: {
      data: JSON.stringify({ user_id: userID, updateDatas: updateDatas }),
    },
    dataType: "json",
    success: function (result) {
      if (!result.error && callback) {
        callback();
      }
    },
  });
}

function set_file_table(target, poj_tenders, fileList, type) {
  let fileCounter = 1;
  for (let i = 0, len = fileList.length; i < len; i++) {
    let fileId =
      type === fileType.unitPriceFile ? fileList[i].id : fileList[i].ID;
    let usedObj = getUsedObj(poj_tenders, fileId, type);
    let usedHtml =
      usedObj.usedCount > 0
        ? '<td class="text-center"><a href="javascript:void(0);">' +
        usedObj.usedCount +
        "</a></td>"
        : '<td class="text-center">' + usedObj.usedCount + "</td>";
    let unitPriceEditHtml =
      type === fileType.unitPriceFile
        ? `<a class="btn btn-sm" href="/unitPrice/index/${fileId}" target="_">编辑</a>`
        : "";
    let hoverHtml = `<p style="display: none; height: 14px;"><a class="btn btn-sm" href="javascript:void(0);" data-toggle="modal" data-target="#del-wj">删除</a><a class="btn btn-sm" href="javascript:void(0);">重命名</a>${unitPriceEditHtml}</p></div>`;

    let renHtml =
      '<div class="input-group" style="display: none;">' +
      '<input class="form-control form-control-sm" value="">' +
      "</div>" +
      '<span class="form-text text-danger" style="display: none">本建设项目已存在该文件名，请重新输入！' +
      "</span></td>";
    let fileTypeStr = type === fileType.unitPriceFile ? "单价文件" : "费率文件";
    let fileHtml =
      '<tr><td class="text-center">' +
      fileCounter +
      '</td><td id="file_' +
      fileId +
      '"><div>' +
      fileList[i].name +
      hoverHtml +
      renHtml +
      usedHtml +
      "</tr>";
    fileCounter++;
    let targetBody =
      type === fileType.unitPriceFile
        ? target + "-unit-price-table tbody"
        : target + "-fee-table tbody";
    $(targetBody).append(fileHtml);
    let jqS = "#file_" + fileId;
    bindEvents_file_table(jqS, usedObj, targetBody, type);
  }
}

function getFileObj(jqS, type) {
  let rst = [];
  let trs = $("tr", jqS);
  for (let i = 0, len = trs.length; i < len; i++) {
    let td = $("td:eq(1)", trs[i])[0];
    let name = td.childNodes[0].childNodes[0].textContent;
    let attrId = $(td).attr("id");
    let id = attrId.slice(5, attrId.length);
    if (type === fileType.unitPriceFile) {
      id = parseInt(id);
    }
    let obj = Object.create(null);
    obj.id = id;
    obj.name = name;
    rst.push(obj);
  }
  return rst;
  //let orgDispName = $(jqS + ' div:eq(0)')[0].childNodes[0].textContent;
}

function hasThisFileName(fileObjs, name) {
  for (let i = 0, len = fileObjs.length; i < len; i++) {
    if (fileObjs[i].name === name) {
      return true;
    }
  }
  return false;
}

//获得使用此单价、费率文件的项目节点
function getTendersByFile(type, fileId, project) {
  let rst = [];
  let tenders = getProjTenders(project);
  for (let tender of tenders) {
    if (
      type === fileType.unitPriceFile &&
      tender.data.property &&
      tender.data.property.unitPriceFile
    ) {
      if (fileId == tender.data.property.unitPriceFile.id) {
        rst.push(tender);
      }
    } else if (
      type === fileType.feeRateFile &&
      tender.data.property &&
      tender.data.property.feeFile
    ) {
      if (fileId == tender.data.property.feeFile.id) {
        rst.push(tender);
      }
    }
  }
  return rst;
}

//重命名单价、费率文件后，刷新使用此文件的节点
function refreshTenderFile(tenders, type, newName) {
  projTreeObj.renderSheetFuc(
    projTreeObj.workBook.getActiveSheet(),
    function () {
      for (let tender of tenders) {
        if (type === fileType.unitPriceFile) {
          tender.data.property.unitPriceFile.name = newName;
        } else if (type === fileType.feeRateFile) {
          tender.data.property.feeFile.name = newName;
        }
        projTreeObj.refreshNodeData(tender);
      }
    }
  );
}

//批量替换文件，切换建设项目
$("#otherProject").change(function () {
  let optionList = [],
    idField = "ID";
  var newVal = $(this).val();
  var projects = projTreeObj.changeInfo.others;
  var selected = _.find(projects, { ID: parseInt(newVal) });
  if ($("#mr_from").val() == "unitPriceFile") {
    idField = "id";
    optionList = selected.unitPriceList;
  } else {
    optionList = selected.optionList;
  }
  $("#otherFileOptions").empty();
  for (let f of optionList) {
    let option = $("<option>").val(f[idField]).text(f.name);
    $("#otherFileOptions").append(option);
  }
});

$("#confirm-import").click(function () {
  //$.bootstrapLoading.start();
  if (STATE.importing) {
    return;
  }
  STATE.importing = true;

  let input = $("input[name='import_project_data']")[0];
  if (input.files.length <= 0) {
    throw "请选择文件!";
  }
  let token = projTreeObj.uptoken;
  $("#import").modal("hide");
  $.bootstrapLoading.progressStart("上传文件中", true);
  let file = input.files[0];
  let key = uuid.v1() + ".ybp"; //file.name;
  if (file) {
    let config = {
      useCdnDomain: true,
      disableStatisticsReport: false,
      retryCount: 6,
      region: qiniu.region.z2,
    };
    let putExtra = {
      fname: "",
      params: { "x:name": key.split(".")[0] },
      mimeType: null,
    };
    // 添加上传dom面板
    let observable = qiniu.upload(file, key, token, putExtra, config);
    observable.subscribe({
      next: function (reponse) {
        console.log(reponse);
      },
      error: function (err) {
        console.log(err);
      },
      complete: function (res) {
        console.log("complete");
        $("#progress_modal_body").text("正在导入建设项目");
        startImportProject(key);
        projTreeObj.uptoken = null;
      },
    });
  }
});

async function startImportProject(key) {
  try {
    console.log("start Import");
    let result = await ajaxPost("/pm/api/importProject", {
      key: key,
      updateData: projTreeObj.getImportProjectDate(),
    });
    importProcessChecking(key, null, (projectData) =>
      handleProjectAfterChecking(projectData)
    );
  } catch (error) {
    alert(error);
    $.bootstrapLoading.end();
  } finally {
    STATE.importing = false;
  }
}

// 导入检查完成时，对新增建设项目的处理
function handleProjectAfterChecking(projectData) {
  if (!projectData) {
    return;
  }
  const rootData = projectData.find(
    (item) => item.projType === projectType.project
  );
  const sorted = commonUtil.getSortedTreeData(rootData.ParentID, projectData);
  doAfterImport(sorted);
  projTreeObj.emitTreeChange();
}
// 导入检查完成时，对新增单位工程的处理
function handleTenderAfterChecking(projectData, orgTender) {
  if (!projectData) {
    return;
  }
  const tenderData = { ...orgTender, ...projectData[0] };
  const parent = projTreeObj.tree.findNode(tenderData.ParentID);
  const next = projTreeObj.tree.findNode(tenderData.NextSiblingID);
  const newNode = projTreeObj.insert(tenderData, parent, next);
  const refreshNodes = projTreeObj.calEngineeringCost(newNode);
  projTreeObj.refreshNodeData(refreshNodes);
  projTreeObj.emitTreeChange();
}

async function importProcessChecking(
  key,
  processingFunc = null,
  completeFunc = null,
  immediately = false
) {
  let count = 0;
  immediately ? checking() : setTimeout(checking, 2000);
  async function checking() {
    let result = await ajaxPost("/pm/api/importProcessChecking", {
      key: key,
      user_id: userID,
    });
    if (result.error == 1) {
      let message = result.msg ? result.msg : result.message;
      setTimeout(function () {
        $.bootstrapLoading.progressEnd(); //不做这个的话太快，页面不会自动关闭
      }, 500);
      alert(message);
      if (completeFunc) {
        completeFunc(result.data);
      }
    } else if (result.error == 0) {
      if (result.status == "processing") {
        // 只调用一次
        if (processingFunc && count === 0) {
          processingFunc(result);
        }
        count++;
        setTimeout(checking, 2000);
      } else if (result.status == "complete") {
        if (completeFunc) {
          completeFunc(result.data);
        }
        $.bootstrapLoading.progressEnd();
        //refreshAllPage();
      }
    }
  }
}

$("#import_project_data").change(function () {
  let file = $(this)[0];
  let projectFile = file.files[0];
  if (projectFile) {
    let ybpReg = /ybp$/g;
    if (projectFile.name && ybpReg.test(projectFile.name)) {
      $("#import_project_label").text(`${projectFile.name}`);
      $("#confirm-import").removeAttr("disabled");
    } else {
      alert("请选择ybp项目文件");
      $(this).val("");
      $("#confirm-import").attr("disabled", "disabled");
    }
  }
});

//清空导入清单选择文件
$("#import").on("show.bs.modal", function () {
  $("#import_project_data").val("");
  $(".custom-file-label").text(`请选择建设项目文件`);
});

//刷新建设项目汇总金额信息
function refreshProjSummary(project, summaryInfo) {
  let refreshNodes = [];
  refreshNodes.push(project);
  getNodes(project);
  function getNodes(node) {
    if (node.children.length > 0) {
      refreshNodes = refreshNodes.concat(node.children);
      for (let cNode of node.children) {
        getNodes(cNode);
      }
    }
  }
  for (let node of refreshNodes) {
    let nodeInfo = summaryInfo[node.data.ID];
    if (nodeInfo) {
      node.data.totalCost = nodeInfo.totalCost;
      node.data.changeMark = nodeInfo.changeMark;
      if (nodeInfo.property) node.data.property = nodeInfo.property;
    }
  }
  projTreeObj.refreshNodeData(refreshNodes);
}

//projectDatas在后端已经按照顺序排过了： project eng1 tender1-1 tender1-2 eng2 tender2-1 tender2-2
function doAfterImport(projectDatas) {
  //插入节点
  let lastNode;
  for (let data of projectDatas) {
    data.feeStandardName =
      (data.property && data.property.feeStandardName) || ""; //工程专业列显示用
    let parent = projTreeObj.tree.items.find(
      (node) => node.data.ID === data.ParentID
    ),
      next = projTreeObj.tree.items.find(
        (node) => node.data.ID === data.NextSiblingID
      );
    lastNode = projTreeObj.insert(data, parent, next);
  }
  if (lastNode) {
    projTreeObj.workBook
      .getSheet(0)
      .showRow(lastNode.serialNo(), GC.Spread.Sheets.VerticalPosition.center);
  }
}

if (isShow) {
  let showTime = parseInt($("#showTime").val());
  if (showTime > 0) {
    $("#welcomeCloseBtn").hide();
    function countdown() {
      if (showTime > 0) {
        showTime--;
        $("#countdown").text(showTime);
      } else {
        $("#countdown").text("");
        $("#welcomeCloseBtn").show();
        clearInterval(welcomeTimer);
      }
    }
    countdown();
    let welcomeTimer = setInterval("countdown()", 1000);
  }
  $("#welcomePage").modal("show"); //是否显示欢迎页
} else if (isFree) {
  _showFreeUserInfo();
}