YangHuCost/web/building_saas/main/js/views/project_view.js

/**
 * Created by Mai on 2017/6/21.
 */
var projectObj = {
  project: null,
  mainSpread: null,
  mainController: null,
  gljSpreed: null,
  beforeMainTreeSelectedChange: function (pre) {
    /*if (node) {
            subViewObj.saveComments(node);
        }*/
  },
  // CSL, 2018-02-09 用于测试显示。使用示例：projectObj.testDisplay(‘总额’, 100);
  testDisplay: function (caption, value) {
    let c = "";
    if (caption) c = caption + ": ";
    let s = `          ${c}${value}`;
    $("#testDisplay").html(s);
  },
  selectedChangeNowTime: 0,
  selectedChangeDelayTime: 20,
  treeSelectedChanged: function (node) {
    let me = this;
    let project = projectObj.project;
    let mainSheet = projectObj.mainController.sheet;
    let init = true;
    //设置选中行底色和恢复前选中行底色
    let refreshNodes = [node];
    if (!project.mainTree.preSelected) {
      refreshNodes.push(project.mainTree.items[0]);
    } else {
      refreshNodes.push(project.mainTree.preSelected);
      init = !(project.mainTree.preSelected == node);
    }
    mbzm_obj.nodeChanged = init;
    project.mainTree.preSelected = node;
    projectObj.setNodesStyle(projectObj.mainController.sheet, refreshNodes);
    function delayOpr(callback) {
      let nowTime = Date.now();
      me.selectedChangeNowTime = nowTime;
      setTimeout(function () {
        if (nowTime - me.selectedChangeNowTime == 0) {
          callback();
        }
      }, me.selectedChangeDelayTime);
    }
    delayOpr(function () {
      if ($("#linkComments").hasClass("active")) {
        subViewObj.loadComments(node);
      }
      let nodeID = node ? node.getID() : null;
      gljOprObj.mainTreeSelectedChange = gljOprObj.selectedNodeId != nodeID;
      if (init) subObj.initNavItem(node);
      /*
             2018-11-9 在NavItem里设置了默认显示的item,在里执行了click这个操作所以这两个操作不用重复执行了
             gljOprObj.showDataIfRationSelect(node);
             if (activeSubSheetIsCalcProgram())
             calcProgramObj.refreshCalcProgram(node, 3);*/
    });
  },
  refreshBaseActn: function (tree) {
    let setButtonValid = function (valid, btn) {
      if (!projectReadOnly && valid) {
        btn.removeClass("disabled");
      } else {
        btn.addClass("disabled");
      }
    };
    let selected = tree.selected,
      that = projectObj;
    const validNodes = projectObj.mainController.getValidNodesWithinSelection();
    const canUpLevel = function (nodes) {
      if (!nodes.length || projectObj.project.isBillsLocked()) {
        return false;
      }
      const firstNode = nodes[0];
      const lastNode = nodes[nodes.length - 1];
      if (firstNode.depth() <= 1) {
        // 首节点是树结构的第一/二层节点，灰显。
        return false;
      }
      if (firstNode.sourceType !== commonConstants.SourceType.BILLS) {
        // 首节点是定额/量价/工料机，灰显。
        return false;
      } else {
        if (lastNode.data.type == billType.BILL && lastNode.nextSibling) {
          // 末节点是清单有后兄弟
          if (lastNode.data.calcBase) {
            // 有基数计算
            return false;
          }
          if (lastNode.children.length > 0 && lastNode.children[0].sourceType !== commonConstants.SourceType.BILLS) {
            // 有子项,并且子项不是清单
            return false;
          }
        }
      }
      return true;
    };
    const canDownLevel = function (nodes) {
      if (!nodes.length || projectObj.project.isBillsLocked()) {
        return false;
      }
      const firstNode = nodes[0];
      if (firstNode.depth() === 0) {
        // 首节点是树结构的第一层节点，灰显。
        return false;
      }
      if (firstNode.sourceType !== commonConstants.SourceType.BILLS) {
        // 首节点是定额/量价/工料机，灰显。
        return false;
      } else {
        const preNode = firstNode.preSibling;
        if (!preNode) {
          // 首节点无前兄弟，灰显
          return false;
        } else if (preNode.data.calcBase) {
          // 首节点前兄弟有基数计算
          return false;
        }
        if (preNode.children.length > 0) {
          //前兄弟有子项，子项是分项，灰显。
          if (firstNode.data.type == billType.BILL && preNode.children[0].sourceType !== commonConstants.SourceType.BILLS) {
            // 首节点是清单，首节点前兄弟子项不是清单
            return false;
          }
        }
      }
      return true;
    };
    const canUpMove = function (nodes) {
      if (!nodes.length) {
        return false;
      }
      const firstNode = nodes[0];
      if (firstNode && firstNode.preSibling) {
        if (firstNode.sourceType == commonConstants.SourceType.BILLS) {
          if (projectObj.project.isBillsLocked()) {
            return false;
          }
          if (firstNode.data.type == billType.DXFY && firstNode.data.isAdd !== 1) {
            return false;
          }
        }
        return true;
      }
      return false;
    };
    const canDownMove = function (nodes) {
      if (!nodes.length) {
        return false;
      }
      const lastNode = nodes[nodes.length - 1];
      if (lastNode && lastNode.nextSibling) {
        if (lastNode.sourceType == commonConstants.SourceType.BILLS) {
          if (projectObj.project.isBillsLocked()) {
            return false;
          }
          if (lastNode.data.type == billType.DXFY && lastNode.data.isAdd !== 1) {
            return false;
          }
        }
        return true;
      }
      return false;
    };

    setButtonValid(projectObj.project.Ration.canAdd(selected), $("#insertRation"));
    setButtonValid(ifCanDelete(), $("#delete"));
    setButtonValid(canUpLevel(validNodes), $("#upLevel"));
    setButtonValid(canDownLevel(validNodes), $("#downLevel"));
    setButtonValid(canUpMove(validNodes), $("#upMove"));
    setButtonValid(canDownMove(validNodes), $("#downMove"));
    setButtonValid(!projectObj.project.isBillsLocked(), $("#ZLFB_btn"));
  },
  checkCommonField: function (editingText, colSetting) {
    let value;
    if (colSetting.data.decimal) {
      value = Number(editingText);
      if (number_util.isNumber(value)) {
        if (colSetting.data.decimal) {
          value = value.toDecimal(colSetting.data.decimal);
        }
      } else {
        value = null;
        alert("当前输入的数据类型不正确，请重新输入。");
      }
    } else {
      value = editingText;
    }
    return value;
  },
  checkFormulaValidField: function (editingText, colSetting) {
    let value = Number(editingText);
    if (isNaN(value)) return value;
    if (!value) {
      try {
        let exp = new Expression("");
        exp.Expression(editingText);
        value = Number(exp.Evaluate());
      } catch (error) {
        value = null;
      }
    }
    if (value != undefined || value != null) {
      if (colSetting.data.decimal) {
        value = value.toDecimal(colSetting.data.decimal);
      }
    } else if (editingText && editingText !== "") {
      value = null;
      alert("当前输入的数据类型不正确，请重新输入。");
    }
    return value;
  },
  checkSpreadEditingText: function (editingText, colSetting) {
    if (colSetting.data.field === "contain" || colSetting.data.field === "feesIndex.common.unitFee" || colSetting.data.field === "feesIndex.common.totalFee") {
      //colSetting.data.field === 'quantity'
      return this.checkFormulaValidField(editingText, colSetting);
    } else if (colSetting.data.field === "programID") {
      return this.project.calcProgram.compiledTemplateMaps[editingText];
    } else if (colSetting.data.field === "subType") {
      if (typeof editingText !== "number") return volumePriceMaps[editingText];
      else return editingText;
    } else {
      return this.checkCommonField(editingText, colSetting);
    }
  },
  getVisibleRows: function (sRow, count) {
    let rst = [];
    let nodes = projectObj.project.mainTree.items;
    for (let i = sRow, len = nodes.length; i < len; i++) {
      if (count <= 0) {
        break;
      }
      if (nodes[i].visible) {
        rst.push(i);
        count--;
      }
    }
    return rst;
  },
  //根据列标段设置焦点单元格
  setActiveCell(field, moveScroll) {
    projectObj.mainSpread.focus(true);
    let mainSheet = projectObj.mainSpread.getActiveSheet();
    TREE_SHEET_HELPER.massOperationSheet(mainSheet, function () {
      let fieldCol = colSettingObj.getColByField(field);
      if (fieldCol) {
        if (moveScroll) {
          mainSheet.showColumn(fieldCol, GC.Spread.Sheets.HorizontalPosition.center);
        }
        mainSheet.setActiveCell(projectObj.project.mainTree.selected.serialNo(), fieldCol);
      }
    });
  },
  //获取粘贴更改的单元格（粘贴时，跳过隐藏行）
  checkSpreadChangedCells: function (info) {
    let rst = { refreshRows: [], changedCells: [] };
    //获取显示行号
    let vRows = projectObj.getVisibleRows(info.row, info.rowCount);
    let vCount = vRows.length;
    let lastRow = null,
      count = 0;
    for (let cell of info.changedCells) {
      cell.text = info.sheet.getCell(cell.row, cell.col).text();
      if (cell.row !== lastRow) {
        count++;
        lastRow = cell.row;
      }
      if (count <= vCount) {
        if (vRows[count - 1] !== cell.row) {
          rst.refreshRows.push(cell.row);
        }
        rst.changedCells.push({ row: vRows[count - 1], col: cell.col, text: cell.text });
      } else {
        rst.refreshRows.push(cell.row);
      }
    }
    rst.refreshRows = Array.from(new Set(rst.refreshRows));
    return rst;
  },
  updateBillsCode: function (node, value) {
    let project = projectObj.project,
      me = this;
    let stdMatchCode, formatCode, matchs;
    let searchStdBillsAndUpdate = function (stdCode, formatCode) {
      let orgCode = node.data.code ? node.data.code.substr(0, 9) : "";
      if (projectObj.project.projectInfo.engineeringInfo.bill_lib.length === 0 || updateCodeCheck(value, stdCode === orgCode)) {
        normalUpdate(node, value, stdCode === orgCode);
      } else if (projectObj.project.projectInfo.engineeringInfo.bill_lib.length > 0) {
        let libId = projectObj.project.projectInfo.engineeringInfo.bill_lib[0].id;
        CommonAjax.post("/stdBillsEditor/getStdBillsByCode", { userId: userID, billsLibId: libId, code: stdCode }, function (data) {
          if (data) {
            function sortItems(serialItems, items) {
              for (let item of items) {
                for (let serialItem of serialItems) {
                  if (item.id === serialItem.id) {
                    item.serialNo = serialItem.serialNo;
                  }
                }
              }
              items.sort(function (a, b) {
                let rst = 0;
                if (a.serialNo > b.serialNo) {
                  rst = 1;
                } else if (a.serialNo < b.serialNo) {
                  rst = -1;
                }
                return rst;
              });
            }
            function updateBeforeInsert(node, data) {
              node.data.name = data.name;
              if (node.data.type == billType.BX) {
                //从清单库中找到标准清单的话，要把补项改成分项
                node.data.type = billType.FX;
              }
            }
            if (/\//.test(data.unit)) {
              let existB = projectObj.project.Bills.sameStdCodeBillsData(data.code);
              if (existB) {
                updateBeforeInsert(node, data);
                data.unit = existB.unit;
                project.Bills.replaceBills(node.source, data, formatCode);
                projectObj.mainController.refreshTreeNode([node], false);
              } else {
                ConfirmModal.stdBillsUnit.check(
                  data,
                  function (std) {
                    updateBeforeInsert(node, data);
                    project.Bills.replaceBills(node.source, std, formatCode);
                    projectObj.mainController.refreshTreeNode([node], false);
                  },
                  function () {
                    projectObj.mainController.refreshTreeNode([node], false);
                  }
                );
              }
            } else {
              updateBeforeInsert(node, data);
              project.Bills.replaceBills(node.source, data, formatCode);
              projectObj.mainController.refreshTreeNode([node], false);
            }
          } else {
            normalUpdate(node, value);
          }
        });
      }
    };
    //分部分项、措施项目才匹配
    let withinValidFixed = false;
    let matchFixedFlags = [fixedFlag.SUB_ENGINERRING, fixedFlag.MEASURE];
    let rootNode = getRootFixedNode(node);
    if (rootNode && rootNode.data.flagsIndex && rootNode.data.flagsIndex.fixed && matchFixedFlags.includes(rootNode.data.flagsIndex.fixed.flag)) {
      withinValidFixed = true;
    }
    if (
      withinValidFixed &&
      (node.data.type == billType.FX || node.data.type == billType.BX || (node.data.type == billType.BILL && node.source.children.length == 0))
    ) {
      //是分项、补项或者叶子清单的情况下才需要查找替换
      if (value && value.length === 9) {
        //&& /^[\d]+$/.test(value)  去掉全数字判断    07-31 zhang
        stdMatchCode = value;
        formatCode = project.Bills.newFormatCode(stdMatchCode);
        searchStdBillsAndUpdate(stdMatchCode, formatCode);
        return;
      } else if (value && value.length === 12) {
        //&& /^[\d]+$/.test(value) 去掉全数字判断    07-31 zhang
        stdMatchCode = value.substr(0, 9);
        matchs = project.Bills.sameStdCode(stdMatchCode, node.data.code);
        if (matchs.indexOf(value) === -1) {
          searchStdBillsAndUpdate(stdMatchCode, value);
          return;
        } else {
          hintBox.infoBox(
            "系统提示",
            "已存在该编码的清单，是否继续？",
            2,
            function () {
              searchStdBillsAndUpdate(stdMatchCode, value);
            },
            function () {
              me.mainController.refreshTreeNode([node], false);
            },
            ["确定", "取消"]
          );
          return;
        }
      }
    }
    normalUpdate(node, value);

    function normalUpdate(billnode, codeValue, onNeedCheck) {
      //在标准库中没有找到清单时改分项为补项再更新
      let toBX = false;
      if (onNeedCheck !== true && billnode.data.type == billType.FX) {
        billnode.data.type = billType.BX;
        toBX = true;
      }
      project.Bills.updateField(billnode.source, "code", codeValue, toBX);
      me.mainController.refreshTreeNode([billnode], false);
    }

    function updateCodeCheck(value, sameStdCode) {
      //如果前9位相同，只改前三位，则只更新编号就行了，不用做其它处理
      return sameStdCode && value && value.length == 12;
    }
  },
  updateRationCode: function (node, value) {
    if (!isDef(node.data.code) && (!isDef(value) || value.toString().trim() == "")) {
      return;
    }
    if (projectObj.project.projectInfo.engineeringInfo.ration_lib.length === 0) {
      alert("当前项目无定额库，请添加定额库。");
      this.mainController.refreshTreeNode([node], false);
    } else {
      let libId = parseInt($("#stdRationLibSelect").val());
      CommonAjax.post("/complementaryRation/api/getRationItem", { user_id: userID, rationRepId: libId, code: value }, function (data) {
        if (data) {
          projectObj.project.Ration.replaceRation(node.source, data);
          projectObj.project.ration_glj.addRationGLJ(node.source, data);
        } else {
          alert('当前库中找不到定额"' + value + '"');
        }
        projectObj.mainController.refreshTreeNode([node], false);
      });
    }
  },
  updateCode: function (node, value) {
    let project = projectObj.project;
    if (node.sourceType === project.Bills.getSourceType()) {
      this.updateBillsCode(node, value); // 新清单不适合实时计算，下面套什么还不能确定，无数量计算也无意义
    } else if (node.sourceType === project.Ration.getSourceType()) {
      if (value && typeof value == "string") {
        //小写转换成大写
        value = value.toUpperCase();
      }
      project.Ration.updateRationCodes([{ node: node, value: value }]);
      //  this.updateRationCode(node, value);  // 新套定额适合实时计算
      // 这里因异步问题暂时缺少工料机价格。该过程移到：ration_glj.js的refreshAfterSave方法中。
    }
  },
  updateNodeField: function (node, value, filedID, callback) {
    if (node.data[filedID] == value) {
      return;
    }
    let data = {
      type: node.sourceType,
      data: {
        ID: node.data.ID,
      },
    };
    data.data[filedID] = value;
    $.bootstrapLoading.start();
    projectObj.project.updateNodes([data], function () {
      node.data[filedID] = value;
      if (callback) {
        callback();
      }
      $.bootstrapLoading.end();
    });
  },
  updateCellValue: function (node, value, colSetting, editingText) {
    let project = projectObj.project,
      fieldName = colSetting.data.field;
    if (node.sourceType == ModuleNames.ration_glj) {
      project.ration_glj.updateFromMainSpread(value, node, fieldName);
    } else if (calcTools.isGljRation(node)) {
      if (fieldName === "feesIndex.common.unitFee") fieldName = "marketUnitFee";
      gljOprObj.updateRationTypeGLJ(value, node, fieldName, editingText);
    } else if (fieldName === "remark") {
      projectObj.updateNodeField(node, value, "remark");
    } else if (fieldName === "feeRate" && value == null) {
      project.FeeRate.cleanFeeRateID(node);
    } else if (value !== calcFees.getFee(node.data, fieldName) || fieldName == "quantity") {
      //工程量需要进行转换，所以做特殊处理
      if (fieldName === "code" && value != "" && !calcTools.isVolumePrice(node)) {
        projectObj.updateCode(node, value);
      } else if (fieldName === "unit" && node.sourceType == ModuleNames.bills) {
        node.updateData[fieldName] = value;
        node.changed = true;
        if (node.data.quantity) {
          node.updateData.quantity = scMathUtil.roundForObj(node.data.quantity, getDecimal("quantity", node)); //修改清单单位的时候清单工程量要重新4舍5入;
        }
        project.calcProgram.calcAndSave(node);
      } else if (fieldName === "feeRate") {
        project.FeeRate.updateFeeRateFromBills(value, node, fieldName);
      } else if (fieldName === "contain") {
        //编辑含量
        project.Ration.updateContain(value, node);
      } else if (
        fieldName === "quantity" ||
        fieldName === "marketUnitFee" ||
        fieldName === "feesIndex.common.unitFee" ||
        fieldName === "feesIndex.common.totalFee" ||
        fieldName === "calcBase" ||
        fieldName === "programID" ||
        fieldName === "subType" ||
        fieldName === "isSubcontract"
      ) {
        if (fieldName === "quantity") {
          quantityEditObj.checkingAndUpdate(editingText, node);
          return;
        } else if (fieldName === "marketUnitFee" || fieldName === "feesIndex.common.unitFee" || fieldName === "feesIndex.common.totalFee") {
          if (isNaN(value)) {
            // 输入的是无效的字符
            alert("当前输入的数据类型不正确，请重新输入。");
            projectObj.mainController.refreshTreeNode([node]);
            return;
          }

          // if (value) {
          if (fieldName === "feesIndex.common.unitFee") {
            value = parseFloat(value).toDecimal(decimalObj.decimal("unitPrice", node));

            //当前是量价/人材机，综合单价可输入，输入的值读取到市场单价，重算综合单价。
            if (node.sourceType == ModuleNames.ration && node.data.type != rationType.ration) {
              fieldName = "marketUnitFee";
            } else if (node.sourceType == ModuleNames.bills) {
              node.updateData.calcFlag = treeNodeCalcFlag.customUnitPrice;
            }
          } else if (fieldName === "feesIndex.common.totalFee") {
            value = scMathUtil.roundForObj(value, getDecimal("totalPrice", node));
            node.updateData.calcFlag = treeNodeCalcFlag.customTotalPrice;
          }
          // }
        } else if (fieldName === "calcBase") {
          //zhong
          if (value === undefined || value === null || value.toString().trim() === "") {
            value = "";
          }
          if (value === node.data.calcBase) {
            return;
          }
          node.data.userCalcBase = value;
          project.calcBase.calculate(node);
          if (!project.calcBase.success) {
            let activeCell = projectObj.mainSpread.getActiveSheet().getSelections()[0];
            projectObj.mainController.refreshTreeNode([node]);
            return;
          } else if (value === "") {
            //删除清单基数，要清空费用
            calcTools.clearFees(node);
          }
          // if (value) {value = parseFloat(value).toDecimal(decimalObj.decimal("totalPrice", node))};
        }

        //计算基数赋值要经过解析和标准化，已在calculate里赋值
        if (fieldName !== "calcBase") {
          calcTools.setFieldValue(node, fieldName, value);
          projectObj.mainController.refreshTreeNode([node]); // 量价，输入单价x，反算单价x1，第二次输入单价x，单价不再反算。（实际反算了，没刷新）
        }

        project.calcProgram.calcAndSave(node);
        gljOprObj.showRationGLJSheetData();
      } else {
        //不涉及计算的，只改updateData的值就好了
        if (node.sourceType === project.Bills.getSourceType()) {
          if (fieldName === "maxPrice" || fieldName === "minPrice") {
            if (value == null) {
              value = "";
            } else {
              value = scMathUtil.roundToString(value, getDecimal("unitPrice", node));
            }
          }
          project.Bills.updateField(node.source, fieldName, value, false);
        }
        node.updateData[fieldName] = value;
        node.changed = true;
        if (colSetting.data.wordWrap) {
          this.mainSpread.getActiveSheet().autoFitRow(node.serialNo());
        }
        project.calcProgram.calcAndSave(node);
        // projectObj.mainController.refreshTreeNode([node]);
      }
    } else {
      projectObj.mainController.refreshTreeNode([node], false);
    }
  },
  mainSpreadLeaveCell: function (sender, info) {
    let colSetting = projectObj.mainController.setting.cols[info.col];
    projectObj.lastCol = colSetting;
    projectObj.lastCell = { row: info.row, col: info.col };
    if (colSetting.data.field === "quantity") {
      SheetDataHelper.hideMoreButton();
    }
  },
  //repaint 动态下拉框
  mainSpreadEnterCell: function (sender, info) {
    let colSetting = projectObj.mainController.setting.cols[info.col];
    if (
      colSetting.data.field === "unit" ||
      (projectObj.lastCol && projectObj.lastCol.data.field === "unit") ||
      colSetting.data.field === "subType" ||
      (projectObj.lastCol && projectObj.lastCol.data.field === "subType") ||
      colSetting.data.field === "programID" ||
      (projectObj.lastCol && projectObj.lastCol.data.field === "programID")
    ) {
      let rects = [];
      rects.push(info.sheet.getCellRect(info.row, info.col));
      if (projectObj.lastCell) {
        rects.push(info.sheet.getCellRect(projectObj.lastCell.row, projectObj.lastCell.col));
      }
      for (let rect of rects) {
        info.sheet.repaint(rect);
      }
    }
  },
  //滚动造价书鼠标时，工程量的更多按钮跟着移动
  TopRowChanged: function (type, info) {
    let colSetting = projectObj.mainController.setting.cols[info.sheet.getActiveColumnIndex()];
    if (colSetting.data.field === "quantity") {
      SheetDataHelper.moveMoreButton(info.sheet);
    }
  },
  mainSpreadEditStarting: function (sender, info) {
    let project = projectObj.project;
    let node = project.mainTree.items[info.row];
    let fieldName = projectObj.mainController.setting.cols[info.col].data.field;
    let value = info.sheet.getValue(info.row, info.col);
    if (fieldName === "code" && node && calcTools.isRationItem(node) && isDef(node.data.code) && isDef(value)) {
      if (isDef(node.data.prefix) && node.data.prefix !== rationPrefix.none) {
        value = value.replace(new RegExp(node.data.prefix), "");
      }
      value = value.replace(new RegExp(rationPrefix.replace), "");
      info.sheet.setValue(info.row, info.col, value);
    }
    if (node && fieldName == "quantity" && (node.data.quantityEXP !== null || node.data.quantityEXP !== undefined)) {
      info.sheet.setValue(info.row, info.col, node.data.quantityEXP);
    }
  },
  onCellDoubleClick: function (sender, info) {
    let project = projectObj.project;
    if (info.row && info.col) {
      let node = project.mainTree.items[info.row];
      let fieldName = projectObj.mainController.setting.cols[info.col].data.field;
      if (fieldName == "marketUnitFee") {
        if (gljOprObj.hasComposition(node.data, true)) {
          alert("当前人材机的市场价由组成物计算得出，不可直接修改。");
          return;
        }
      }
      if (fieldName == "code" && node) {
        projectObj.showBillOrRationLib(node);
      }
    }
  },
  showBillOrRationLib(node) {
    let BILLS = projectObj.project.Bills;
    let code = node.data.code ? node.data.code : "";
    if (node.sourceType == ModuleNames.bills) {
      //当清单是“分部分项工程”、“措施项目工程”时，要展开清单规则节点
      if (BILLS.isFXorBX(node) || (node.data.type == billType.BILL && BILLS.isMeasure(node))) {
        //是分项或补项，是清单并且属于措施项目节点
        if (!billsGuidance.bills.tree) {
          doAfterLoadGuidance = function () {
            billsGuidance.locateAtBills(code);
            doAfterLoadGuidance = null;
          };
        } else {
          billsGuidance.locateAtBills(code);
        }
        if (!$("#zy").is(":visible")) {
          $("#stdBillsGuidanceTab").click();
        }
      }
    }
    if (node.sourceType == ModuleNames.ration) {
      //在定额编码中双击，如果右侧定额库没有展开，则自动展开。
      if (node.data.type != rationType.ration) return; //只有定额类型才需要自动展开，其它都不用
      let libID = node.data.libID;
      if (node.data.from === "cpt") {
        libID = node.data.fromUser ? `${rationLibObj.compleRationLibId}*${node.data.fromUser}` : rationLibObj.compleRationLibId;
      }
      if (!rationLibObj.tree) {
        if (isDef(libID)) sessionStorage.setItem("stdRationLib", libID);
        rationLibObj.doAfterGetRationTree = function () {
          this.locateAtRation(libID, code);
          this.doAfterGetRationTree = null;
        };
      } else {
        if ($("#stdRationLibSelect").select().val() != libID) {
          let libOpts = $("#stdRationLibSelect").find("option");
          for (let libOpt of libOpts) {
            if ($(libOpt).val() == libID) {
              $(libOpt).prop("selected", "selected");
              break;
            }
          }
          $("#stdRationLibSelect").change();
          rationLibObj.doAfterGetRationTree = function () {
            this.locateAtRation(libID, code);
            this.doAfterGetRationTree = null;
          };
        } else {
          rationLibObj.locateAtRation(node.data.libID, code);
        }
      }
      if (!$("#de").is(":visible")) $("#stdRationTab").click();
    }
  },
  onColumnWidthChanged: function (sender, info) {
    // CSL,2018.07.25
    if (info.colList.includes(4) || info.colList.includes(5)) {
      let items = projectObj.project.mainTree.items;
      let sheet = projectObj.mainSpread.getActiveSheet();
      for (let i = 0; i < items.length; i++) {
        let need = false;
        if (items[i].data.itemCharacterText) {
          sheet.getCell(i, 4).wordWrap(true);
          need = true;
        }
        if (items[i].data.jobContentText) {
          sheet.getCell(i, 5).wordWrap(true);
          need = true;
        }
        if (need) sheet.autoFitRow(i);
      }
    }
  },
  onClipboardPasting: function (sender, info) {
    let rIdx = info.sheet.getActiveRowIndex();
    let node = projectObj.project.mainTree.items[rIdx];
    if (!node.parent) {
      info.cancel = true;
      hintBox.infoBox("系统提示", "大项费用不允许粘贴！", 1);
      return false;
    }

    let colName = projectObj.project.projSetting.main_tree_col.cols[info.cellRange.col].data.field;
    if (node.sourceType === projectObj.project.Ration.getSourceType() && colName == "code") {
      info.cancel = true;

      function getNodeType(node) {
        let t = null;
        if (calcTools.isRationItem(node)) t = 1;
        else if (calcTools.isBill(node)) {
          if (calcTools.isBill_FB(node)) t = 2;
          else if (calcTools.isBill_FX(node) || calcTools.isBill_BX(node)) t = 3;
          else if (calcTools.isBill_BILL(node)) t = 4;
        }
        return t;
      }
      function getPasteTextArr(info) {
        let copyText = info.pasteData.text.trim();
        if (!copyText) return null;
        let spliter = "";
        if (copyText.includes("\r\n")) {
          spliter = "\r\n";
        } else if (copyText.includes("\n")) {
          // 兼容Unix、Mac 等系统回车换行符
          spliter = "\n";
        } else {
          spliter = "\r";
        }
        let rows = copyText.split(spliter);
        let rstArr = [];
        for (let row of rows) {
          row = row.trim();
          row = row.split("\t");
          rstArr.push(row);
        }
        return rstArr;
      }
      function getPasteNodes(node, nodeType, count) {
        let nodesArr = [];
        let curNode = null;
        for (let i = rIdx; i < rIdx + count; i++) {
          curNode = projectObj.project.mainTree.items[i];
          if (curNode && calcTools.isSameTypeNode(curNode, node)) {
            nodesArr.push(curNode);
          } else {
            curNode = projectObj.project.mainTree.items[i - 1];
            break;
          }
        }

        if (nodesArr.length < count) {
          if (projectObj.project.mainTree.selected != curNode) projectObj.project.mainTree.selected = curNode;

          let add = count - nodesArr.length;
          for (let i = 0; i < add; i++) {
            switch (nodeType) {
              case 1:
                curNode = projectObj.project.Ration.addNewRationFast(rationType.ration);
                break;
              case 2:
                curNode = ProjectController.addFB(projectObj.project, projectObj.mainController);
                break;
              case 3:
                curNode = ProjectController.addFX(projectObj.project, projectObj.mainController);
                break;
              case 4:
                curNode = ProjectController.addBills(projectObj.project, projectObj.mainController);
                break;
            }

            if (!curNode) {
              hintBox.infoBox("系统提示", "插入新结点出错，粘贴失败！", 1);
              return nodesArr;
            } else {
              nodesArr.push(curNode);
              if (projectObj.project.mainTree.selected != curNode) projectObj.project.mainTree.selected = curNode;
            }
          }
        }

        return nodesArr;
      }
      function doPaste(nodes, nodeType, datas) {
        if (nodeType == 1) {
          // 批量粘贴定额有严重的异步问题，这里要和清单分开处理
          let updateRationCodes = [];
          for (let i = 0; i < datas.length; i++) {
            let ptNode = nodes[i];
            let code = datas[i][0];
            // 编号去掉“换、借、补”等多余的字
            code = code.replace(new RegExp(rationPrefix.complementary), "");
            code = code.replace(new RegExp(rationPrefix.borrow), "");
            code = code.replace(new RegExp(rationPrefix.replace), "");
            updateRationCodes.push({ node: ptNode, value: code });
          }
          projectObj.project.Ration.updateRationCodes(updateRationCodes);
        } else {
          for (let i = 0; i < datas.length; i++) {
            let ptNode = nodes[i];
            let code = datas[i][0];
            if (!(ptNode.data && ptNode.data.code && ptNode.data.code.sameText(code))) {
              projectObj.updateCode(ptNode, code);
            }
          }
        }
        projectObj.mainController.refreshTreeNode(nodes);
      }

      let tagType = getNodeType(node);
      if (!tagType) {
        hintBox.infoBox("系统提示", "该树结点类型不支持从项目编码列粘贴！", 1);
        return false;
      }
      let datas = getPasteTextArr(info);
      if (!datas) return;
      let pasteNodes = getPasteNodes(node, tagType, datas.length);
      doPaste(pasteNodes, tagType, datas);
    }
  },
  mainSpreadEditEnded: function (sender, info) {
    let project = projectObj.project;
    let node = project.mainTree.items[info.row];
    project.withinBillsLocked(node);
    let colSetting = projectObj.mainController.setting.cols[info.col];
    let fieldName = projectObj.mainController.setting.cols[info.col].data.field;
    //提前处理
    if (fieldName === "code" || fieldName === "name" || fieldName === "unit") {
      info.editingText = info.editingText ? info.editingText.toString().replace(new RegExp(/[\r,\n]/g), "") : info.editingText;
    }
    // 检查输入类型等
    let value = projectObj.checkSpreadEditingText(info.editingText, colSetting);
    projectObj.updateCellValue(node, value, colSetting, info.editingText);

    // 自动行高
    const autoHeight = project.property.displaySetting.autoHeight;
    if (autoHeight) {
      projectObj.mainSpread.getActiveSheet().autoFitRow(info.row);
    }
  },
  msClipboardChanged: function (sender, info) {
    let colSettings = projectObj.mainController.setting.cols;
    let cDatas = sheetCommonObj.getTableData(info.sheet, colSettings);
    sheetCommonObj.copyTextToClipboard(cDatas);
    return;
  },
  mainSpreadRangeChanged: function (sender, info) {
    let project = projectObj.project,
      setting = projectObj.mainController.setting;
    let changedObj = projectObj.checkSpreadChangedCells(info);
    let refreshNodes = [];
    for (let row of changedObj.refreshRows) {
      refreshNodes.push(project.mainTree.items[row]);
    }
    let updateRationCodes = []; //更新定额编码时要用同步的方式
    if (changedObj.changedCells.length > 0) {
      for (let changedCell of changedObj.changedCells) {
        let node = project.mainTree.items[changedCell.row];
        let colSetting = setting.cols[changedCell.col];
        let value = projectObj.checkSpreadEditingText(changedCell.text, colSetting);
        if (colSetting.data.field == "code" && node.sourceType == project.Ration.getSourceType() && node.data.type == rationType.ration) {
          //如果是更新定额的编码
          updateRationCodes.push({ node: node, value: value });
        } else {
          projectObj.updateCellValue(node, value, colSetting, changedCell.text);
        }
      }
    }
    if (updateRationCodes.length > 0) {
      project.Ration.updateRationCodes(updateRationCodes);
    }
    if (refreshNodes.length > 0) {
      projectObj.mainController.refreshTreeNode(refreshNodes);
    }
  },
  checkMainSpread: function () {
    if (!this.mainSpread) {
      this.mainSpread = SheetDataHelper.createNewSpread($("#billsSpread")[0]);
      sheetCommonObj.spreadDefaultStyle(this.mainSpread);
      this.mainSpread.getActiveSheet().selectionPolicy(GC.Spread.Sheets.SelectionPolicy.muliRange);
      this.mainSpread.getActiveSheet().name("mainSheet");
      this.mainSpread.getActiveSheet().options.isProtected = true;
      this.mainSpread.getActiveSheet().options.frozenlineColor = "#ababab";
    }
  },
  refreshMainSpread: function () {
    if (this.mainSpread) {
      this.mainSpread.refresh();
    }
  },
  loadProjectData: function () {
    var that = this;
    this.project = PROJECT.createNew(scUrlUtil.GetQueryString("project"), userID);
    let startTime = +new Date();
    $.bootstrapLoading.start();
    this.project.loadDatas(function (err) {
      projectInfoObj.refreshTotalPriceSpan(); // 工具栏中的总造价信息
      let mTime = +new Date();
      //projectInfoObj.showProjectInfo(that.project.projectInfo);
      //快速列设置
      if (!colSettingObj.getVisible("itemCharacterText")) {
        switchTznrHtml(true);
      }
      if (colSettingObj.getVisible("itemCharacterText")) {
        switchTznrHtml(false);
      }
      if (!err) {
        that.project.projectGLJ.calcQuantity(true); //计算分部分项和技术措施项目消耗量;

        let quantityTime = +new Date();
        // that.project.property = projectObj.project.projectInfo.property;
        if (typeof overwriteRationCalcBases === "function") overwriteRationCalcBases(that.project.property.taxType);
        if (typeof overwriteFeeTypesWhenHasProperty === "function") {
          overwriteFeeTypesWhenHasProperty(that.project.property.engineeringName);
          that.project.calcProgram.compileAllTemps();
        }
        //that.project.calcProgram.compileAllTemps();
        that.project.calcBase.init(that.project);
        // that.project.calcFields = JSON.parse(JSON.stringify(cpFeeTypes));
        // that.project.initCalcFields();
        let str = JSON.stringify(that.project.projSetting.main_tree_col);
        that.project.projSetting.mainGridSetting = JSON.parse(str);
        that.project.projSetting.mainGridSetting.frozenCols = 4;
        TREE_SHEET_HELPER.initSetting($("#billsSpread")[0], that.project.projSetting.mainGridSetting);
        that.project.projSetting.mainGridSetting.setAutoFitRow = MainTreeCol.getEvent("setAutoFitRow");
        that.project.projSetting.mainGridSetting.cols.forEach(function (col) {
          col.data.splitFields = col.data.field.split(".");
          if (col.data.getText && Object.prototype.toString.apply(col.data.getText) === "[object String]") {
            col.data.getText = MainTreeCol.getEvent(col.data.getText);
          }
          if (col.readOnly && Object.prototype.toString.apply(col.readOnly) === "[object String]") {
            col.readOnly = MainTreeCol.getEvent(col.readOnly);
          }
          if (col.data.cellType && Object.prototype.toString.apply(col.data.cellType) === "[object String]") {
            let getCellType = MainTreeCol.getEvent(col.data.cellType);
            col.data.cellType = getCellType;
          }
          // if (col.data.digit && Object.prototype.toString.apply(col.data.digit) === "[object String]") {
          //     col.data.decimal = that.project.getDecimal(col.data.digit);
          //     col.data.formatter = MainTreeCol.getNumberFormatter(col.data.decimal);
          // }
          if (col.data.field === "code") {
            col.data.formatter = "@";
          }
          col.setAutoHeight = MainTreeCol.getEvent("setAutoHeight");
          col.editChecking = MainTreeCol.getEvent("editChecking");
          // 根据配置设置自动行高,在这里先做个标记，然后对每个单元格单独配置
          if (col.data.field === "name" || col.data.field === "itemCharacterText" || col.data.field === "jobContentText" || col.data.field === "adjustState") {
            col.data.autoHeight = true;
            col.showHint = true;
          }
          if (col.data.field === "quantity" || col.data.field === "remark") {
            col.showHint = true;
          }

          // 综合单价、综合合价，小数部分应补0对齐。  CSL
          // if (col.data.field.hasSubStr("common")){
          if (col.data.field.hasSubStr(".totalFee")) col.data.formatter = MainTreeCol.getNumberFormatter(decimalObj.ration.totalPrice, true);
          else if (col.data.field.hasSubStr(".unitFee")) col.data.formatter = MainTreeCol.getNumberFormatter(decimalObj.ration.unitPrice, true);
          // }
        });
        that.mainController = TREE_SHEET_CONTROLLER.createNew(
          that.project.mainTree,
          that.mainSpread.getActiveSheet(),
          that.project.projSetting.mainGridSetting
        );
        that.mainController.bind("refreshBaseActn", that.refreshBaseActn);
        that.mainController.bind(TREE_SHEET_CONTROLLER.eventName.beforeTreeSelectedChange, that.beforeMainTreeSelectedChange);
        that.mainController.bind(TREE_SHEET_CONTROLLER.eventName.treeSelectedChanged, that.treeSelectedChanged);
        gljCol.initGljCol(
          that.project.projSetting.glj_col ? that.project.projSetting.glj_col.showAdjustPrice : false,
          that.project.property.tenderSetting.showTenderFields ? that.project.property.tenderSetting.showTenderFields : false,
          true
        );
        that.mainController.showTreeData();
        subObj.initSubSpread(); //初始化主界面下方的表格
        if (!projectReadOnly) {
          that.mainSpreadEscKey(that.mainSpread, that.mainSpreadEditStarting, that.mainSpreadEditEnded);
          sheetCommonObj.bindEnterKey(that.mainSpread, that.mainSpreadEnterKey);
        }
        setTimeout(function () {
          that.mainSpread.getActiveSheet().startEdit(); //这两句需要挺多时间,而又需要在editend 事件前触发，而这些又不影响计算，所以这里用异步的方法
          that.mainSpread.getActiveSheet().endEdit();

          that.mainSpread.bind(GC.Spread.Sheets.Events.EditEnded, that.mainSpreadEditEnded);
          that.mainSpread.bind(GC.Spread.Sheets.Events.EditStarting, that.mainSpreadEditStarting);
        }, 100);
        that.mainSpread.bind(GC.Spread.Sheets.Events.SelectionChanged, that.amountAreaNumber); //选中统计专用，节点相关操作在treeSelectedChanged里些
        that.mainSpread.bind(GC.Spread.Sheets.Events.LeaveCell, that.mainSpreadLeaveCell);
        that.mainSpread.bind(GC.Spread.Sheets.Events.EnterCell, that.mainSpreadEnterCell);

        that.mainSpread.bind(GC.Spread.Sheets.Events.RangeChanged, that.mainSpreadRangeChanged);
        that.mainSpread.bind(GC.Spread.Sheets.Events.ClipboardChanged, that.msClipboardChanged);
        that.mainSpread.bind(GC.Spread.Sheets.Events.ButtonClicked, that.onButtonClick);
        that.mainSpread.bind(GC.Spread.Sheets.Events.CellDoubleClick, that.onCellDoubleClick);
        that.mainSpread.bind(GC.Spread.Sheets.Events.ColumnWidthChanged, that.onColumnWidthChanged);
        that.mainSpread.bind(GC.Spread.Sheets.Events.ClipboardPasting, that.onClipboardPasting);

        //工程量悬浮窗移动事件
        that.mainSpread.bind(GC.Spread.Sheets.Events.TopRowChanged, that.TopRowChanged);
        //let loadOtherStartTime = +new Date();
        //if(!projectReadOnly){
        that.loadMainSpreadContextMenu();
        //}
        socketObject.connect("main", { projectReadOnly: !!projectReadOnly, user: { ...projectObj.project.projectInfo.opener } }); //连接socket服务器
        let endTime = +new Date();
        console.log(`时间——${endTime - startTime}`);
        that.project.projectMarkChecking(); //是否需要重新进行造价计算
        autoFlashHeight();
        that.loadFocusLocation();
        projectObj.refreshMainSpread();
        //定位到会话中的选项
        let mainTabFocus = sessionStorage.getItem("mainTab") ? sessionStorage.getItem("mainTab") : "#tab_zaojiashu";
        $(mainTabFocus).click();
        if (projectReadOnly) {
          sheetCommonObj.disableSpread(that.mainSpread);
        }
        if (projectObj.project.projectInfo.lastFileVer != VERSION) projectObj.project.calcProgram.doTenderCalc(); // 打开标段后，进行一次全部计算，包括调价计算。
        $.bootstrapLoading.end();
      } else {
      }
      const onceAlert = getLocalCache(commonConstants.StorageKey.ONCE_MAIN_LOADED);
      if (onceAlert) {
        alert(onceAlert);
        removeLocalCache(commonConstants.StorageKey.ONCE_MAIN_LOADED);
      }
    });
  },
  //mainSpread有一些单元格进入编辑状态后，会动态改变值，公用的bindEscKey方法不适用
  mainSpreadEscKey: function (workBook, editStarting = null, editEnded = null) {
    workBook.commandManager().register("myEsc", function () {
      let sheet = workBook.getActiveSheet();
      if (editStarting) {
        sheet.unbind(GC.Spread.Sheets.Events.EditStarting);
      }
      if (editEnded) {
        sheet.unbind(GC.Spread.Sheets.Events.EditEnded);
      }
      let row = sheet.getActiveRowIndex();
      let col = sheet.getActiveColumnIndex();
      let orgV = sheet.getValue(row, col);
      let node = projectObj.project.mainTree.items[row];
      let field = colSettingObj.getFieldByCol(col);
      //进入编辑状态后改变了单元格值的时候特殊处理
      if (isDef(field) && field === "code") {
        if (
          node &&
          node.sourceType === projectObj.project.Ration.getSourceType() &&
          node.data.type === rationType.ration &&
          isDef(node.data.code) &&
          isDef(node.data.prefix) &&
          node.data.prefix !== rationPrefix.none
        ) {
          orgV = node.data.prefix + orgV;
        }
      } else if (isDef(field) && field === "quantity") {
        orgV = isDef(node) && isDef(node.data.quantity) ? node.data.quantity : "";
      }
      if (!isDef(orgV)) {
        orgV = "";
      }
      if (sheet.isEditing()) {
        sheet.endEdit();
        sheet.setValue(row, col, orgV);
      }
      if (editStarting) {
        sheet.bind(GC.Spread.Sheets.Events.EditStarting, editStarting);
      }
      if (editEnded) {
        sheet.bind(GC.Spread.Sheets.Events.EditEnded, editEnded);
      }
    });
    workBook.commandManager().setShortcutKey(null, GC.Spread.Commands.Key.esc, false, false, false, false);
    workBook.commandManager().setShortcutKey("myEsc", GC.Spread.Commands.Key.esc, false, false, false, false);
  },
  mainSpreadEnterKey: function () {
    let me = projectObj;
    let sheet = me.mainSpread.getActiveSheet();
    let orgRow = sheet.getActiveRowIndex();
    let orgCol = sheet.getActiveColumnIndex();
    let orgField = colSettingObj.getFieldByCol(orgCol);
    let selected = me.project.mainTree.items[orgRow];
    if (sheet.isEditing()) {
      sheet.endEdit();
    }
    //正常情况，焦点应该是在下一行的同一列
    let newRow = orgRow + 1,
      newCol = orgCol;
    //getColByField getVisible都不提出来，减少调用次数
    if (selected) {
      //在分项/补项的编码单元格回车，焦点应跳动至本行的工程量单元格
      if (
        orgField &&
        orgField === "code" &&
        selected.sourceType === me.project.Bills.getSourceType() &&
        [billType.FX, billType.BX].includes(selected.data.type)
      ) {
        let quantityCol = colSettingObj.getColByField("quantity");
        let quantityVisible = colSettingObj.getVisible("quantity");
        if (quantityCol !== null && quantityVisible !== false) {
          newRow = orgRow;
          newCol = quantityCol;
        }
      } else if (
        orgField &&
        orgField === "quantity" &&
        selected.sourceType === me.project.Bills.getSourceType() &&
        [billType.FX, billType.BX].includes(selected.data.type)
      ) {
        //在分项/补项的工程量单元格回车，如果其下有定额/量价/人材机，焦点应跳动至其下第一条定额/量价/人材机的工程量，如果是空行，则跳到至第一条定额xx的编码；
        if (selected.children.length !== 0 && !(isDef(selected.children[0].data.code) && selected.children[0].data.code.toString().trim() !== "")) {
          let codeCol = colSettingObj.getColByField("code");
          let codeVisible = colSettingObj.getVisible("code");
          newRow = orgRow + 1;
          if (codeCol !== null && codeVisible !== false) {
            newCol = codeCol;
          }
        }
        //如果其下没有定额/量价/人材机，则自动在其下插入一条定额空行，在其后自动插入一条分项空行，焦点跳动至定额空行的编码单元格。
        else if (selected.children.length === 0) {
          //分项没有后兄弟，且没有锁定清单时在其后插入分项
          if (
            !selected.nextSibling &&
            !(projectObj.project.projectInfo.property.lockBills && projectObj.project.withinBillsLocked(projectObj.project.mainTree.selected))
          ) {
            ProjectController.addFX(me.project, me.mainController);
            //将焦点行设置成原本的行，以插入定额
            me.mainController.setTreeSelected(me.project.mainTree.items[orgRow]);
          }
          /* 
                    2021-04-26 只插入清单不插入定额  
                    //插入定额
                    me.project.Ration.addNewRation(null, rationType.ration, function () {
                        newRow = sheet.getActiveRowIndex();
                        let codeCol = colSettingObj.getColByField('code');
                        let codeVisible = colSettingObj.getVisible('code');
                        if(codeCol !== null && codeVisible !== false){
                            newCol = codeCol;
                        }
                        sheet.setActiveCell(newRow, newCol);
                    },true,null,false); */
        }
      }
      //在定额/量价/人材机的编码单元格回车，焦点应跳动至本行的工程量单元格
      else if (orgField && orgField === "code" && selected.sourceType === me.project.Ration.getSourceType()) {
        let quantityCol = colSettingObj.getColByField("quantity");
        let quantityVisible = colSettingObj.getVisible("quantity");
        if (quantityCol !== null && quantityVisible !== false) {
          newRow = orgRow;
          newCol = quantityCol;
        }
      }
      //在定额/量价/人材机的工程量单元格回车
      else if (orgField && orgField === "quantity" && selected.sourceType === me.project.Ration.getSourceType()) {
        let nextSibling = selected.nextSibling;
        //如果其后有定额/量价/人材机(空行:编码为空不算)，焦点应跳动至下一行定额/量价/人材机的工程量，不需处理

        //如果其后没有定额/量价/人材机(空行也没有)，则自动在其后插入一行定额空行，焦点跳动至定额空行的编码单元格
        /*   if(!nextSibling){
                    let codeCol = colSettingObj.getColByField('code');
                    let codeVisible = colSettingObj.getVisible('code');
                    me.project.Ration.addNewRation(null, rationType.ration, function () {
                        newRow = sheet.getActiveRowIndex();
                        if(codeCol !== null && codeVisible !== false){
                            newCol = codeCol;
                        }
                        sheet.setActiveCell(newRow, newCol);
                    }, true,null,false);
                } */
        //如果其后有定额空行，焦点跳动至定额空行的编码单元格
        if (nextSibling && !(isDef(nextSibling.data.code) && nextSibling.data.code.toString().trim() !== "")) {
          let codeCol = colSettingObj.getColByField("code");
          let codeVisible = colSettingObj.getVisible("code");
          if (codeCol !== null && codeVisible !== false) {
            newRow = orgRow + 1;
            newCol = codeCol;
          }
        }
      }
      //在清单的编码单元格回车，如果清单是叶子节点，焦点跳动至本行的工程量单元格
      else if (
        orgField &&
        orgField === "code" &&
        selected.sourceType === me.project.Bills.getSourceType() &&
        selected.data.type === billType.BILL &&
        selected.source.children.length === 0
      ) {
        let quantityCol = colSettingObj.getColByField("quantity");
        let quantityVisible = colSettingObj.getVisible("quantity");
        if (quantityCol && quantityVisible) {
          newRow = orgRow;
          newCol = quantityCol;
        }
      }
    }
    //设置焦点
    sheet.setActiveCell(newRow, newCol);
    //触发表格事件
    me.mainController.setTreeSelected(me.project.mainTree.items[newRow]); //SelectionChanged
    me.mainSpreadLeaveCell({ type: "LeaveCell" }, { sheet: sheet, sheetName: sheet.name(), cancel: false, row: orgRow, col: orgCol });
    me.mainSpreadEnterCell({ type: "EnterCell" }, { sheet: sheet, sheetName: sheet.name(), cancel: false, row: newRow, col: newCol });
  },
  isInsertEquipmentVisable: function (selected) {
    //浙江不管是预算或者工程量清单，都是隐藏，overwrite文件重写
    if (this.project.property.valuationType !== "ration") {
      //属于预算项目的情况下，在固定清单可见
      //属于的固定清单
      let belongFlag = cbTools.getBelongFlag(selected);
      if (belongFlag && belongFlag === fixedFlag.EQUIPMENT_ACQUISITION_FEE) {
        return true;
      }
      return false;
    }
    return true;
  },
  //取安全生产费
  getSaveProductionCostCode: function () {
    //公路云里18的清单范本安全生产费是102-3的；养护云里浙江养护的安全生产费是102-4。
    return "102-4";
  },

  // 注册自定义插入清单数量
  registerFlexibleInsertBillMenu: function (name) {
    const project = projectObj.project;
    const insertBillsHtml = `<span>${name}&nbsp;&nbsp;<input id='insert-bills-number' class="menu-input" type="text" value="1" onfocus="this.select()">&nbsp;&nbsp;行</span>`;
    return sheetCommonObj.registerInputContextMenuItem("insertBills", insertBillsHtml, "fa-sign-in", async function () {
      if (project.mainTree.selected.data.type == billType.DXFY) {
        if (project.mainTree.selected.data.calcBase && project.mainTree.selected.data.calcBase != "") {
          alert("当前有基数计算,不能插入子项。");
          return;
        }
      }
      try {
        const number = +$("#insert-bills-number").val();
        if (!number) {
          return;
        }
        $.bootstrapLoading.start();
        const postData = ProjectController.getBillsPostData(number);
        const newNodes = await ProjectController.addBillsByData(postData, true);
        projectObj.mainController.setTreeSelected(newNodes[0]);
        projectObj.selectColAndFocus(project.mainTree.selected);
        projectObj.refreshBaseActn(project.mainTree);
      } catch (err) {
        console.log(err);
        if (!$("hintBox_form").is(":visible")) {
          alert(err);
        }
      } finally {
        $.bootstrapLoading.end();
      }
    });
  },
  // 注册自定义插入定额数量
  registerFlexibleInsertRatoinMenu: function () {
    const project = projectObj.project;
    const insertRationHtml = `<span>插入定额&nbsp;&nbsp;<input id='insert-ration-number' class="menu-input" type="text" value="1" onfocus="this.select()">&nbsp;&nbsp;行</span>`;
    return sheetCommonObj.registerInputContextMenuItem("insertRation", insertRationHtml, "fa-sign-in", async function () {
      try {
        const number = +$("#insert-ration-number").val();
        if (!number) {
          return;
        }
        $.bootstrapLoading.start();
        const newData = [];
        for (let i = 0; i < number; i++) {
          newData.push({ itemQuery: null, rationType: rationType.ration });
        }
        await project.Ration.addMultiRation(newData);
        projectObj.setActiveCell("code", true);
        projectObj.refreshBaseActn(project.mainTree);
      } catch (err) {
        console.log(err);
        if (!$("hintBox_form").is(":visible")) {
          alert(err);
        }
      } finally {
        $.bootstrapLoading.end();
      }
    });
  },
  loadMainSpreadContextMenu: function () {
    var project = this.project,
      spread = this.mainSpread,
      controller = this.mainController;
    let insertBillsName =
      project.projectInfo.property && project.projectInfo.property.valuationType == commonConstants.ValuationType.BOQ ? "插入清单" : "插入项目节"; //右键“插入清单”改文字为“插入项目节”，工程量清单中保持不变。
    $.contextMenu({
      selector: "#billsSpread",
      selectableSubMenu: true,
      build: function ($trigger, e) {
        projectObj.cusRationCombCheck(spread.getActiveSheet());
        var target = SheetDataHelper.safeRightClickSelection($trigger, e, spread);
        controller.setTreeSelected(controller.tree.items[target.row]);
        return target.hitTestType === GC.Spread.Sheets.SheetArea.viewport || target.hitTestType === GC.Spread.Sheets.SheetArea.rowHeader;
      },
      items: {
        insertRootBill: {
          name: "插入大项费用",
          icon: "fa-sign-in",
          disabled: function () {
            return projectReadOnly || (projectObj.project.isBillsLocked() && project.withinBillsLocked(project.mainTree.selected));
            //return project.mainTree.selected ? project.mainTree.selected.sourceType !== project.Bills.getSourceType() : false;
          },
          callback: function (key, opt) {
            ProjectController.addRootBill(project, controller);
          },
          visible: function (key, opt) {
            return project.mainTree.selected && project.mainTree.selected.parent == null;
          },
        },
        insertFB: {
          name: "插入分部",
          icon: "fa-sign-in",
          disabled: function () {
            if (projectReadOnly) {
              return true;
            }
            let selected = project.mainTree.selected;
            if (projectObj.project.isBillsLocked() == false && selected && selected.sourceType == project.Bills.getSourceType()) {
              if (selected.data.type == billType.FB) {
                return false;
              }
              if (isFlag(selected.data) && selected.data.flagsIndex.fixed.flag == fixedFlag.SUB_ENGINERRING) {
                //焦点行是分部分项工程
                if (selected.children.length > 0) {
                  return selected.children[0].data.type == billType.FX || selected.children[0].data.type == billType.BX; //焦点行是分部分项工程，且子项是分项或补项
                } else {
                  return false;
                }
              }
            }
            return true; //除了清单，其它类型都只读
          },
          callback: function (key, opt) {
            ProjectController.addFB(project, controller);
            projectObj.selectColAndFocus(project.mainTree.selected);
          },
          visible: function (key, opt) {
            if (project.mainTree.selected) {
              return project.Bills.isFBFX(project.mainTree.selected); //不属于分部分项的话隐藏
            } else {
              return false;
            }
          },
        },
        insertFX: {
          name: "插入分项",
          icon: "fa-sign-in",
          disabled: function () {
            if (projectReadOnly) {
              return true;
            }
            let selected = project.mainTree.selected;
            if (projectObj.project.isBillsLocked() == false && selected && selected.sourceType == project.Bills.getSourceType()) {
              if (selected.data.type == billType.FX || selected.data.type == billType.BX) {
                //焦点行是分项，有效显示
                return false;
              }
              if (selected.data.type == billType.FB) {
                //点行是分部，
                if (selected.children.length > 0) {
                  //且有子项，子项是分部，灰显。
                  return selected.children[0].data.type == billType.FB;
                } else {
                  return false;
                }
              }
              if (isFlag(selected.data) && selected.data.flagsIndex.fixed.flag == fixedFlag.SUB_ENGINERRING) {
                //焦点行是分部分项工程
                if (selected.children.length > 0) {
                  return selected.children[0].data.type == billType.FB; //焦点行是分部分项工程，且子项是分部时灰显
                } else {
                  return false;
                }
              }
            }
            return true; //除了清单，其它类型都只读
          },
          callback: function (key, opt) {
            ProjectController.addFX(project, controller);
            projectObj.selectColAndFocus(project.mainTree.selected);
          },
          visible: function (key, opt) {
            if (project.mainTree.selected) {
              return project.Bills.isFBFX(project.mainTree.selected); //不属于分部分项的话隐藏
            } else {
              return false;
            }
          },
        },
        insertBills: {
          type: projectObj.registerFlexibleInsertBillMenu(insertBillsName),
          disabled: function () {
            if (projectReadOnly) {
              return true;
            }
            let selected = project.mainTree.selected;
            if (
              !(projectObj.project.isBillsLocked() == true && project.withinBillsLocked(selected)) &&
              selected &&
              selected.sourceType === project.Bills.getSourceType()
            ) {
              return false;
            }
            return true;
          },
          visible: function (key, opt) {
            if (project.mainTree.selected) {
              return project.Bills.isFBFX(project.mainTree.selected) == true ? false : true;
            } else {
              return false;
            }
          },
        },
        spr1: "--------",
        insertRation: {
          type: projectObj.registerFlexibleInsertRatoinMenu(),
          disabled: function () {
            if (projectReadOnly) {
              return true;
            }
            // var selected = project.mainTree.selected;
            // return project.Ration.addRationChecking(selected);  // Vincent, 2018-01-02
            // 工具栏要加按钮，且不能隐藏。菜单可以隐藏，两者又必须统一，所以启用新规则。怕以后又要改回来，所以保留。 CSL, 2018-01-02
            return !project.Ration.canAdd(project.mainTree.selected);
          },
          visible: function (key, opt) {
            let rst = true;
            if (compilationName === "内蒙古高速公路日常养护估算(2021)") return false;
            return rst;
          },
        },
        insertGLJ: {
          name: "插入工料机",
          icon: "fa-sign-in",
          disabled: function () {
            if (projectReadOnly) {
              return true;
            }
            // var selected = project.mainTree.selected;
            // return project.Ration.addRationChecking(selected);  // Vincent, 2018-01-02
            return !project.Ration.canAdd(project.mainTree.selected);
          },
          callback: function (key, opt) {
            let selected = project.mainTree.selected;
            if (selected.data.calcBase && selected.data.calcBase != "") {
              alert("当前有基数计算，不能插入定额/量价/工料机。");
              return;
            }
            getGLJData("insert"); // ProjectController.addRation(project, controller, rationType.volumePrice);
          },
          visible: function (key, opt) {
            let rst = true;
            if (compilationName === "内蒙古高速公路日常养护估算(2021)") return false;
            return rst;
          },
        },

        insertLJ: {
          name: "插入量价", //插入量价不需要自动定位到编号列
          icon: "fa-sign-in",
          disabled: function () {
            if (projectReadOnly) {
              return true;
            }
            return !project.Ration.canAdd(project.mainTree.selected);
          },
          visible: function (key, opt) {
            let rst = true;
            if (compilationName === "内蒙古高速公路日常养护估算(2021)") rst = false;
            return rst;
          },
          callback: function (key, opt) {
            /* project.Ration.addNewRation(null,rationType.volumePrice,function (newNode) {
                             projectObj.selectColAndFocus(newNode,null);
                         },true);*/
          },
          items: {
            insertLabour: {
              name: "人工",
              icon: "fa-sign-in",
              callback: function (key) {
                project.Ration.insertVolumePrice(gljType.LABOUR);
              },
            },
            insertMaterial: {
              name: "材料",
              icon: "fa-sign-in",
              callback: function (key) {
                project.Ration.insertVolumePrice(gljType.GENERAL_MATERIAL);
              },
            },
            insertMachine: {
              name: "机械",
              icon: "fa-sign-in",
              callback: function (key) {
                project.Ration.insertVolumePrice(gljType.GENERAL_MACHINE);
              },
            },
          },
        },
        insertMaterial: {
          name: "按清单名称插入材料", //插入量价不需要自动定位到编号列
          icon: "fa-sign-in",
          disabled: function () {
            if (projectReadOnly) {
              return true;
            }
            return !project.Ration.canAdd(project.mainTree.selected);
          },
          visible: function (key, opt) {
            let rst = true;
            if (compilationName === "内蒙古高速公路日常养护估算(2021)") return false;
            return rst;
          },
          callback: function (key, opt) {
            //名称取清单名称，单位取清单单位
            let selected = project.mainTree.selected;
            let billNode = selected;
            if (selected.sourceType == project.Ration.getSourceType()) billNode = selected.parent;
            let ext = { name: billNode.data.name, unit: billNode.data.unit };
            project.Ration.insertVolumePrice(gljType.GENERAL_MATERIAL, ext);
          },
        },
        insertEquipment: {
          name: "插入设备",
          icon: "fa-sign-in",
          disabled: function () {
            if (projectReadOnly) {
              return true;
            }
            return !project.Ration.canAdd(project.mainTree.selected);
          },
          callback: function (key, opt) {
            let selected = project.mainTree.selected;
            if (selected.data.calcBase && selected.data.calcBase != "") {
              alert("当前有基数计算，不能插入定额/量价/工料机。");
              return;
            }
            getGLJData("insertEquipment"); // ProjectController.addRation(project, controller, rationType.volumePrice);
          },
          visible: function (key, opt) {
            //2018-11-08  新需求，这个按钮先隐藏，有需要再放开
            let selected = project.mainTree.selected;
            return projectObj.isInsertEquipmentVisable(selected);
          },
        },
        spr2: "--------",
        calc_installation_fee: {
          name: "计取安装费用",
          icon: "fa-sign-in",
          disabled: function () {
            if (projectReadOnly) {
              return true;
            }
            return false;
          },
          callback: function (key, opt) {
            installationFeeObj.showCalcInstallSettingDiv();
          },
          visible: function (key, opt) {
            return projectObj.project.isInstall();
          },
        },
        cleanzmhs: {
          name: "清空定额调整",
          icon: "fa-remove",
          callback: function (key, opt) {
            let selected = project.mainTree.selected;
            projectObj.project.Ration.updateRationCodes([{ node: selected, value: selected.data.code }], true);
          },
          visible: function (key, opt) {
            let selected = project.mainTree.selected;
            if (selected && selected.sourceType == ModuleNames.ration) {
              return true;
            }
            return false;
          },
          disabled: function () {
            let selected = project.mainTree.selected;
            if (projectReadOnly) {
              return true;
            }
            if (selected && selected.data.type != rationType.ration) {
              return true;
            }
            return false;
          },
        },
        setBookMark: {
          name: "设置书签批注",
          icon: "fa-flag",
          disabled: function () {
            if (projectReadOnly || !project.mainTree.selected || project.mainTree.selected.sourceType == ModuleNames.ration_glj) {
              return true;
            }
            return false;
          },
          items: {
            cancelMark: {
              name: "取消书签批注",
              icon: "fa-remove",
              disabled: function () {
                const selected = project.mainTree.selected;
                return !(selected && selected.data.bookmarkBackground);
              },
              callback: function () {
                locateObject.setOrCancelBookmark(project.mainTree.selected, null);
              },
            },
            markE2F2C5: {
              name: function () {
                return locateObject.getDescribeByColor("E2F2C5");
              },
              icon: "fa-square annotate-color-1",
              callback: function () {
                locateObject.setOrCancelBookmark(project.mainTree.selected, "E2F2C5");
              },
            },
            markF9E2CF: {
              name: function () {
                return locateObject.getDescribeByColor("F9E2CF");
              },
              icon: "fa-square annotate-color-2",
              callback: function () {
                locateObject.setOrCancelBookmark(project.mainTree.selected, "F9E2CF");
              },
            },
            markF2EFD9: {
              name: function () {
                return locateObject.getDescribeByColor("F2EFD9");
              },
              icon: "fa-square annotate-color-3",
              callback: function () {
                locateObject.setOrCancelBookmark(project.mainTree.selected, "F2EFD9");
              },
            },
            markF5D1DA: {
              name: function () {
                return locateObject.getDescribeByColor("F5D1DA");
              },
              icon: "fa-square annotate-color-4",
              callback: function () {
                locateObject.setOrCancelBookmark(project.mainTree.selected, "F5D1DA");
              },
            },
            markE3E3E3: {
              name: function () {
                return locateObject.getDescribeByColor("E3E3E3");
              },
              icon: "fa-square annotate-color-5",
              callback: function () {
                locateObject.setOrCancelBookmark(project.mainTree.selected, "E3E3E3");
              },
            },
            markB6F3F2: {
              name: function () {
                return locateObject.getDescribeByColor("B6F3F2");
              },
              icon: "fa-square annotate-color-6",
              callback: function () {
                locateObject.setOrCancelBookmark(project.mainTree.selected, "B6F3F2");
              },
            },
            markECE0F5: {
              name: function () {
                return locateObject.getDescribeByColor("ECE0F5");
              },
              icon: "fa-square annotate-color-7",
              callback: function () {
                locateObject.setOrCancelBookmark(project.mainTree.selected, "ECE0F5");
              },
            },
          },
        },
        delete: {
          name: "删除",
          icon: "fa-remove",
          disabled: function () {
            return !ifCanDelete();
          },
          callback: function () {
            var selected = project.mainTree.selected;
            if (selected.sourceType == project.Bills.getSourceType() && selected.data.type == billType.FB && selected.children.length <= 0) {
              //选中的是分部，并且没有子项，直接删除
              project.Bills.deleteSelectedNodes(); //project.Bills.deleteSelectedNode();
            } else {
              $("#delete_row").modal({ show: true }); //弹出删除提示框;
            }
          },
        },
        calculateAll_RationContent: {
          name: "造价计算",
          icon: "fa-calculator",
          callback: function () {
            $.bootstrapLoading.start();
            setTimeout(function () {
              project.calcProgram.calcAllNodesAndSave();
              $.bootstrapLoading.end();
            }, 100);
          },
          disabled: function () {
            if (projectReadOnly) {
              return true;
            }
          },
          visible: function (key, opt) {
            //2019-11-11 新需求重新开放右键“造价计算”。
            return true;
          },
        },
        spr4: "--------",
        copyBlock: {
          name: "复制整块",
          icon: "fa-copy",
          disabled: function () {
            if (projectReadOnly) {
              return true;
            }
            let selection = projectObj.mainSpread.getActiveSheet().getSelections()[0];
            let firstNode = projectObj.project.mainTree.items[selection.row]; //当多选的情况，用mainTree.selected判断不正确,要用第一个选中的节点
            for (let i = 0; i < selection.rowCount; i++) {
              //多选的时候判断所有与第一个节点同级的节点
              let temNode = projectObj.project.mainTree.items[selection.row + i];
              if (firstNode.getParentID() == temNode.getParentID()) {
                if (BlockController.copyBtnDisable(temNode) == true) {
                  return true;
                }
              }
            }
            return false;
          },
          callback: function () {
            $.bootstrapLoading.start();
            //let selected = project.mainTree.selected;
            let selections = projectObj.mainSpread.getActiveSheet().getSelections();
            setTimeout(function () {
              BlockController.copyBlock(selections[0]);
              $.bootstrapLoading.end();
            }, 100);
          },
        },
        pasteBlock: {
          name: "粘贴整块",
          icon: "fa-paste",
          disabled: function () {
            if (projectReadOnly) {
              return true;
            }
            return BlockController.pasteBtnDisable(project.mainTree.selected);
          },
          callback: function () {
            BlockController.pasteBlock(project.mainTree.selected);
          },
        },
        recoverDeletedNodes: {
          name: "恢复删除节点",
          icon: "fa-undo",
          disabled: function () {
            return BlockController.recoverBlockDisabled();
          },
          callback: function () {
            BlockController.recoverBlock();
          },
        },
        editEngineer: {
          name: "编辑工程内容",
          icon: "fa-edit",
          disabled: function () {
            return projectReadOnly;
          },
          visible: function (key, opt) {
            let selected = project.mainTree.selected;
            return selected.sourceType == ModuleNames.bills && project.Bills.isEngineerEst(selected); //当焦点行是“专业工程暂估价”时，右键可见并有效。
          },
          callback: function () {
            let node = project.mainTree.selected; //project.Bills.getNodeByFlag(project.mainTree.selected,fixedFlag.ENGINEERING_ESITIMATE);
            if (node) {
              projectObj.editContent(node, "engineeringContent");
            }
          },
        },
        editService: {
          name: "编辑服务内容",
          icon: "fa-edit",
          disabled: function () {
            return projectReadOnly;
          },
          visible: function (key, opt) {
            let selected = project.mainTree.selected;
            return selected.sourceType == ModuleNames.bills && project.Bills.isTotalService(selected); //当焦点行是“总承包服务费”时，右键可见并有效。
          },
          callback: function () {
            let node = project.mainTree.selected; //project.Bills.getNodeByFlag(project.mainTree.selected,fixedFlag.TURN_KEY_CONTRACT);
            if (node) {
              projectObj.editContent(node, "serviceContent");
            }
          },
        },
        editAccording: {
          name: "编辑签证及索赔依据",
          icon: "fa-edit",
          disabled: function () {
            return projectReadOnly;
          },
          visible: function (key, opt) {
            let selected = project.mainTree.selected;
            return selected.sourceType == ModuleNames.bills && project.Bills.isClaimVisa(selected); //当焦点行是“签证及索赔计价”时，右键可见并有效。
          },
          callback: function () {
            let node = project.mainTree.selected; //project.Bills.getNodeByFlag(project.mainTree.selected,fixedFlag.CLAIM_VISA);
            if (node) {
              projectObj.editContent(node, "claimVisa");
            }
          },
        },
        replaceMaterial: {
          name: "智能材料替换",
          icon: "fa-edit",
          disabled: function (key, opt) {
            if (projectReadOnly) {
              return true;
            }
            let selected = project.mainTree.selected;
            return selected.sourceType == ModuleNames.bills ? !(project.Bills.isFXorBX(selected) || selected.source.children.length == 0) : true; //是分项、补项或叶子清单才有效;
          },
          callback: function () {
            MaterialController.replaceMaterial([project.mainTree.selected]);
          },
          visible: function (key, opt) {
            //2018-11-15 暂时隐藏
            return false;
          },
        },
        createBlocks: {
          name: "生成组价模板",
          icon: "fa-puzzle-piece",
          disabled: function (key, opt) {
            if (projectReadOnly) {
              return true;
            }
            let selected = project.mainTree.selected;
            return selected.sourceType != ModuleNames.bills;
          },
          callback: function () {
            blockLibObj.checkShow();
          },
          visible: function (key, opt) {
            let rst = G_SHOW_BLOCK_LIB;
            if (compilationName === "内蒙古高速公路日常养护估算(2021)") rst = false;
            return rst;
            // return G_SHOW_BLOCK_LIB;
          },
        },
      },
    });
  },
  // 计算node及node的所有父项
  converseCalculateBills: function (node) {
    projectObj.project.calcProgram.calcAndSave(node);
  },

  // 获取上次退出时的焦点位置
  loadFocusLocation: function (orow, ocol) {
    const projectId = scUrlUtil.GetQueryString("project");
    let row = gljUtil.isDef(orow) ? orow : getLocalCache("lastRow:" + projectId);
    let col = gljUtil.isDef(ocol) ? ocol : getLocalCache("lastCol:" + projectId);
    if (row == null || col == null) {
      //默认焦点定位到造价书的第一行“分项”。
      col = 1;
      row = 0;
      for (let i = 0; i < this.mainController.tree.items.length; i++) {
        let node = this.mainController.tree.items[i];
        if (node && node.sourceType == ModuleNames.bills && (node.data.type === billType.FX || node.data.type === billType.BX)) {
          //默认字位到第一条分项或补项
          row = i;
          break;
        }
      }
    }
    row = parseInt(row);
    col = parseInt(col);
    const sheet = this.mainSpread.getActiveSheet();
    sheet.setSelection(row, col, 1, 1);
    row = row < this.mainController.tree.items.length ? row : 0;
    this.mainController.setTreeSelected(this.mainController.tree.items[row]); //触发树节点选中事件
    sheet.showRow(row, GC.Spread.Sheets.VerticalPosition.center);
  },
  // 选中区域合计数字
  amountAreaNumber: function (e, info) {
    if (info.newSelections === undefined || info.newSelections.length <= 0) {
      return false;
    }
    const selectedArea = info.newSelections[0];
    const sheet = info.sheet;
    if (selectedArea.colCount <= 1 && selectedArea.rowCount <= 1) {
      return false;
    }
    //获取最左最右坐标
    let maxCell = { row: selectedArea.row, col: selectedArea.col + selectedArea.colCount };
    let maxCellX = sheet.getCellRect(maxCell.row, maxCell.col).x
      ? sheet.getCellRect(maxCell.row, maxCell.col).x
      : sheet.getCellRect(maxCell.row, maxCell.col - 1).x;
    let minCell = { row: selectedArea.row, col: selectedArea.col };
    let minCellX = sheet.getCellRect(minCell.row, minCell.col).x
      ? sheet.getCellRect(minCell.row, minCell.col).x
      : sheet.getCellRect(minCell.row, minCell.col + 1).x;
    // 获取鼠标位置
    let x = window.event.clientX;
    let y = window.event.clientY;

    // 匹配数字或小数
    const regular = /^([0-9]+[.]{1}[0-9]+)$|^([1-9]{1}\d*)$/;
    // 小数点最高位数
    let max = 0;
    let total = 0;
    let counter = 0;
    let notNumber = false; //如果有非数字，则不显示
    for (let col = selectedArea.col; col < selectedArea.colCount + selectedArea.col; col++) {
      for (let row = selectedArea.row; row < selectedArea.rowCount + selectedArea.row; row++) {
        const value = sheet.getCell(row, col).text();
        if (!regular.test(value)) {
          if (value) notNumber = true;
          continue;
        }
        counter++;
        // 获取当前数据小数位数
        let pointPosition = value.toString().indexOf(".");
        pointPosition = pointPosition < 0 ? pointPosition : pointPosition + 1;
        const current = pointPosition > 0 ? value.toString().substring(pointPosition, value.toString().length).length : 0;
        max = current > max ? current : max;
        total += parseFloat(value);
      }
    }
    // 如果不为0则悬浮显示
    if (notNumber === false && total > 0 && counter > 1) {
      const div = $(
        '<div id="total-tips"><p>合计: <input type="text" id="total" readonly="readonly" style="border: none;"/></p><p><a href="javascript:void(0);">复制</a></p></div>'
      );
      div.css({
        position: "absolute",
        border: "1px #C0C0C0 solid",
        background: "#fff",
        boxShadow: "1px 2px 5px rgba(0,0,0,0.4)",
      });
      div.children("p").css({
        textAlign: "center",
        padding: 8,
        marginBottom: 2,
      });
      div.children("p").first().css({
        borderBottom: "1px #C0C0C0 solid",
      });
      const totalString = total.toFixed(max);
      // input长度
      const inputWidth = totalString.length * 8;
      // 计算是否会超出显示范围
      const baseWidth = 48;
      const baseHeight = 81;
      const canvasWidth = $("#billsSpreadvp_vp").width();
      const canvasHeight = $("#billsSpreadvp_vp").height();
      //x = x + baseWidth + inputWidth > canvasWidth ? x - baseWidth - inputWidth : x;
      x = maxCellX + baseWidth + inputWidth > canvasWidth ? minCellX - baseWidth - inputWidth : maxCellX + baseWidth;
      y = y + baseHeight > canvasHeight ? y - baseHeight : y;
      //test
      let testT = sheet.getParent().hitTest(x, y);
      //test
      div.css({
        left: x,
        top: y,
      });

      div.children().children("#total").width(inputWidth).val(totalString);
      $("body").append(div);
      // 用于判断是否要关闭窗体
      setTimeout(function () {
        isTotalShowing = true;
      }, 200);
    }
  },

  onButtonClick: function (e, info) {
    let colSetting = projectObj.mainController.setting.cols[info.col];
    let node = projectObj.project.mainTree.items[info.row];
    let fieldName = colSetting.data.field;
    if (fieldName == "isSubcontract") {
      projectObj.onSubcontractClick(node);
    } else if (fieldName == "isEstimate") {
      projectObj.onIsEstimateClick(node, info);
    } else if (fieldName == "evaluationProject") {
      projectObj.onEvaluationProjectClic(node, info);
    } else if (fieldName == "unitPriceAnalysis") {
      projectObj.onUnitPriceAnalysisClick(node, info);
    } else if (fieldName == "appraisalBills" || fieldName == "lockUnitPrice" || fieldName == "outPutMaxPrice" || fieldName == "outPutLimitPrice") {
      projectObj.onCasCadeButtonClick(node, info, fieldName);
    }
  },
  onEvaluationProjectClic: function (node, info) {
    let checkboxValue = info.sheet.getCell(info.row, info.col).value();
    let newval = checkboxValue ? 0 : 1;
    projectObj.project.updateEvalproject(newval, node.data, function (programID) {
      node.updateData.evaluationProject = newval;
      node.updateData.programID = programID;
      node.changed = true;
      projectObj.project.calcProgram.calcAndSave(node);
    });
  },
  setAndGetCheckBoxVal: function (info) {
    let checkboxValue = info.sheet.getCell(info.row, info.col).value();
    let cell = info.sheet.getCell(info.row, info.col),
      newval = 0;
    if (checkboxValue) {
      newval = 0;
      cell.value(newval);
    } else {
      newval = 1;
      cell.value(newval);
    }
    return newval;
  },
  onIsEstimateClick: function (node, info) {
    let newval = projectObj.setAndGetCheckBoxVal(info);
    if (MainTreeCol.readOnly.bills(node)) {
      projectObj.updateNodeField(node, newval, "isEstimate");
    } else if (node.data.projectGLJID) {
      //更新的是定额类型的工料机或者是显示在造价书页面的主材、设备
      console.log(node);
      let updateData = { id: node.data.projectGLJID, field: "is_evaluate", value: newval };
      projectObj.project.projectGLJ.pGljUpdate(updateData);
    }
  },
  onUnitPriceAnalysisClick: function (unode, info) {
    let updateDatas = [],
      nodes = [];
    let newval = projectObj.setAndGetCheckBoxVal(info);
    //仅对大项费用、清单有效，修改父项清单，子项清单跟随修改。
    if (unode.sourceType == ModuleNames.bills) unitPriceAnalysisUpdate(unode, newval);
    if (updateDatas.length > 0) {
      $.bootstrapLoading.start();
      projectObj.project.updateNodes(updateDatas, function () {
        for (let n of nodes) {
          n.data.unitPriceAnalysis = newval;
        }
        projectObj.mainController.refreshTreeNode(nodes);
        $.bootstrapLoading.end();
      });
    }

    function unitPriceAnalysisUpdate(node, val) {
      updateDatas.push(getUnitPriceUpdataData(node, val));
      nodes.push(node);
      if (node.children.length > 0 && node.children[0].sourceType == ModuleNames.bills) {
        //仅对大项费用、清单有效
        for (let i = 0; i < node.children.length; i++) {
          unitPriceAnalysisUpdate(node.children[i], val);
        }
      }
    }

    function getUnitPriceUpdataData(node, val) {
      let data = {
        type: node.sourceType,
        data: {
          ID: node.data.ID,
          unitPriceAnalysis: val,
        },
      };
      return data;
    }
  },
  onCasCadeButtonClick: function (node, info, fieldName) {
    let checkboxValue = info.sheet.getCell(info.row, info.col).value();
    let cell = info.sheet.getCell(info.row, info.col),
      newval = true;
    if (checkboxValue == true) {
      newval = false;
    } else {
      newval = true;
    }
    projectObj.project.updateCasCadeBills(node, newval, fieldName, fieldName != "lockUnitPrice");
  },
  onSubcontractClick: function (node) {
    //点击分包费checkbox
    if (node.updateData.isSubcontract) node.updateData.isSubcontract = false;
    else node.updateData.isSubcontract = true;
    node.changed = true;
    projectObj.project.calcProgram.calcAndSave(node);
  },
  //根据节点获取行style(颜色、字体加粗)
  getNodeColorStyle: function (sheet, node, tree) {
    let colorSetting = optionsOprObj.getOption(optionsOprObj.optionsTypes.COLOROPTS);
    let mapping = {
      DEFAULT: "DEFAULT",
      SELECTED: "SELECTED",
      DXFY: "DXFY",
      FB: "FB",
      UNLEAFBILL: "UNLEAFBILL",
      FX: "FX",
      BX: "BX",
      UNCBBILL: "UNCBBILL",
      CBBILL: "CBBILL",
      ZCSB: "ZCSB",
    };
    let styleMap = null;
    tree ? "" : (tree = this.project.mainTree);
    //中文字段名，由于同一节点中，中文字体大小和数字字体大小不同
    if (colorSetting == null) {
      return null;
    }
    let stringFields = ["code", "subType", "name", "unit", "itemCharacterText", "jobContentText", "adjustState", "calcBase", "programID", "ruleText"];
    if (!isDef(node)) {
      return null;
    }
    //清单大类
    if (node.sourceType === this.project.Bills.getSourceType()) {
      //大项费用
      if (node.data.type === billType.DXFY) {
        styleMap = mapping.DXFY;
      }
      //分部
      if (node.data.type === billType.FB) {
        styleMap = mapping.FB;
      }
      //分项
      else if (node.data.type === billType.FX) {
        styleMap = mapping.FX;
      }
      //补项
      else if (node.data.type === billType.BX) {
        styleMap = mapping.BX;
      }
      //清单
      else if (node.data.type === billType.BILL) {
        //非叶子节点的清单
        if (node.source.children.length > 0) {
          styleMap = mapping.UNLEAFBILL;
        }
        //未使用基数计算的叶子节点的清单
        else if (node.source.children.length === 0 && (!isDef(node.data.calcBase) || node.data.calcBase === "")) {
          styleMap = mapping.UNCBBILL;
        }
        //使用基数计算的叶子节点的清单
        else if (node.source.children.length === 0 && isDef(node.data.calcBase && node.data.calcBaseValue !== "")) {
          styleMap = mapping.CBBILL;
        }
      }
    }
    //定额下的主材、设备
    else if (node.sourceType === this.project.ration_glj.getSourceType()) {
      styleMap = mapping.ZCSB;
    } else {
      styleMap = mapping.DEFAULT;
    }
    let styleSetting = colorSetting[styleMap];
    let defaultSetting = colorSetting[mapping.DEFAULT];
    if (!isDef(styleSetting)) {
      return null;
    }
    let style = new GC.Spread.Sheets.Style();
    //设置style属性
    for (let attr in styleSetting) {
      if (attr !== "stringFont" && attr !== "numFont") {
        style[attr] = styleSetting[attr] === "default" || !isDef(styleSetting[attr]) ? defaultSetting[attr] : styleSetting[attr];
      }
      //暂时不开放字体设置，开放的话只能每个单元格进入此方法
      /* else {
                if(stringFields.indexOf(colSetting.data.field) > 0){
                    style.font = styleSetting.stringFont === 'default' || !isDef(styleSetting.stringFont) ? defaultSetting.stringFont : styleSetting.stringFont;
                }
                else {
                    style.font = styleSetting.numFont === 'default' || !isDef(styleSetting.numFont) ? defaultSetting.numFont : styleSetting.numFont;
                }
            }*/
    }
    //选中行-替换底色
    if (node === tree.selected) {
      style.backColor = colorSetting[mapping.SELECTED]["backColor"];
    }
    if (_ && !_.isEmpty(node.data.bookmarkBackground)) style.backColor = "#" + node.data.bookmarkBackground; //设置书签和批注背景色
    //大项费用加粗（数字与中文字符大小不一问题由字体造成，暂时不考虑分别设置大小）
    /* if(node.sourceType === this.project.Bills.getSourceType() && node.data.type === billType.DXFY){
            style.font = 'bold 14px Arial';
        }*/
    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;
  },
  //大项费用则字体加粗，String 15px, Number 13px
  getBoldFontStyle: function (node, colSetting) {
    let style = new GC.Spread.Sheets.Style();
    if (node.sourceType !== this.project.Bills.getSourceType() || node.data.type !== billType.DXFY) {
      return null;
    }

    //备注暂无字段
    let stringFields = ["code", "subType", "name", "unit", "itemCharacterText", "jobContentText", "adjustState", "calcBase", "programID", "ruleText"];
    style.font = "bold 14px Arial";
    return style;
  },
  //设置节点style
  setNodesStyle: function (sheet, nodes, tree) {
    let me = this;
    TREE_SHEET_HELPER.massOperationSheet(sheet, function () {
      for (let node of nodes) {
        if (node && node.serialNo() != -1) {
          sheet.getRange(node.serialNo(), -1, 1, -1).backColor(me.getNodeColorStyle(sheet, node, tree).backColor);
        }
      }
    });
  },
  loadLockBillsButton: function () {
    if (projectObj.project.projectInfo.property.lockBills == true) {
      //$("a[name='lockBills']").attr("data-original-title","解锁清单");
      $("a[name='lockBills']").html('<i class="fa fa-unlock-alt" aria-hidden="true"></i> 解锁清单');
    } else {
      //$("a[name='lockBills']").attr("data-original-title","锁定清单");
      $("a[name='lockBills']").html('<i class="fa fa-lock" aria-hidden="true"></i> 锁定清单');
    }
  },
  editContent: function (node, fieldID) {
    //右键编辑工程内容、服务内容、签证及索赔依据
    let infoText = "请输入";
    switch (fieldID) {
      case "engineeringContent":
        infoText += "工程内容:";
        break;
      case "serviceContent":
        infoText += "服务内容:";
        break;
      case "claimVisa":
        infoText += "签证及索赔依据:";
        break;
    }

    hintBox.valueBox(infoText, node.data[fieldID], function () {
      let newValue = hintBox.value;
      projectObj.updateNodeField(node, newValue, fieldID);
    });
  },
  ifItemCharHiden: function (setting) {
    //项目特征及内容列是否隐藏
    if (this.itemCol == null || this.itemCol == undefined) {
      this.itemCol = _.find(setting.cols, function (item) {
        return item.data.field == "itemCharacterText";
      });
    }
    return this.itemCol ? !this.itemCol.visible : true;
  },
  onCommonTotalFeeButtonClick: function (hitinfo) {
    let me = calcBaseView;
    let node = projectObj.project.mainTree.items[hitinfo.row] ? projectObj.project.mainTree.items[hitinfo.row] : null;
    if (hitinfo.sheet.getParent() === projectObj.mainSpread) {
      projectObj.mainController.setTreeSelected(node);
    }
    hitinfo.sheet.setActiveCell(hitinfo.row, hitinfo.col);
    calcBaseView.confirmBtn.attr("toggle", "commonTotalFee");
    //changeCalcBaseFeeRate('commonTotalFee');//公路上不需要费率选项页
    changeCalcBaseFeeRate("calcBase");
    $("#tabCalcBase").tab("show");
    calcBaseView.initCalctor("bills");
    //feeRateObject.showSelectModal(hitinfo);
  },
  selectColAndFocus: function (newNode, field = "code") {
    //选中单元格并设置焦点
    if (newNode) {
      if (field != null) projectObj.mainController.sheet.setSelection(newNode.serialNo(), colSettingObj.getColByField(field), 1, 1); //自动定位到编号单元格
      projectObj.mainSpread.focus();
    }
  },
  cusRationCombCheck: function (sheet) {
    //检查自定义定额编号下拉框，右键的时候不自动消失，现手动结束编辑，并删除元素
    if (sheet.isEditing()) {
      sheet.endEdit();
    }
    if ($("#rationCheckBox").is(":visible")) $("#rationCheckBox").parent().parent().remove();
  },
};

// 点击合计框中的复制
$("body").on("click", "#total-tips a", function () {
  const totalElement = $(this).parent().siblings("p").find("#total");
  totalElement.select();
  document.execCommand("Copy");
  $(this).text("已复制");
});
// 合计框点击其他位置关闭
let isTotalShowing = false;
$("body").on("click", function (e) {
  if (isTotalShowing && !$(e.target).is("#total-tips") && !$(e.target).is("#total-tips p") && !$(e.target).is("#total-tips p a")) {
    $("#total-tips").remove();
    isTotalShowing = false;
  }
});

/*$('#insert').click(function () {
    var controller = projectObj.mainController, project = projectObj.project;
    var selected = controller.tree.selected;

    if (!selected || selected.sourceType === project.Bills.getSourceType()) {
        ProjectController.addBills(project, controller);
    } else if (selected.sourceType === project.Ration.getSourceType()) {
        ProjectController.addRation(project, controller, selected.data.type);
    };
});*/

$("#delete").click(function () {
  let project = projectObj.project;
  let selected = project.mainTree.selected;
  if (isSingleSelect() && selected.sourceType == project.Bills.getSourceType() && selected.data.type == billType.FB && selected.children.length <= 0) {
    //选中的是分部，并且没有子项，直接删除
    project.Bills.deleteSelectedNode();
  } else {
    $("#delete_row").modal({ show: true }); //弹出删除提示框;
  }
});

// TODO 造价书节点的升降级、上下移都是异步的，不等服务器响应直接进行前端更新的。有风险，后续可能需要改。
// 节流，防止快速触发
const throttleTime = 400;
const throttleUpLevel = _.throttle(() => {
  const controller = projectObj.mainController;
  const project = projectObj.project;
  const mainTreeNodes = controller.getValidNodesWithinSelection();
  const billsNodes = mainTreeNodes.map((node) => node.source);
  const orgParent = mainTreeNodes[0].parent;
  project.Bills.multiUpLevelBills(project.Bills.tree, billsNodes);
  controller.multiUpLevel(mainTreeNodes);
  const refreshNodes = [orgParent, ...mainTreeNodes];
  controller.refreshTreeNode(refreshNodes);
  projectObj.project.calcProgram.calcNodesAndSave(refreshNodes);
}, throttleTime);
$("#upLevel").click(throttleUpLevel);
const throttleDownLevel = _.throttle(() => {
  const controller = projectObj.mainController;
  const project = projectObj.project;
  const mainTreeNodes = controller.getValidNodesWithinSelection();
  const billsNodes = mainTreeNodes.map((node) => node.source);
  const orgParent = mainTreeNodes[0].parent;
  const preNode = mainTreeNodes[0].preSibling; //降级前的前一节点变成降级后新的父节点，要重新计算
  project.Bills.multiDownLevelBills(project.Bills.tree, billsNodes);
  controller.multiDownLevel(mainTreeNodes);
  controller.refreshTreeNode([orgParent, ...mainTreeNodes]);
  projectObj.converseCalculateBills(preNode);
}, throttleTime);
$("#downLevel").click(throttleDownLevel);
$("#insertRation").click(function () {
  // projectObj.project.Ration.addNewRation(null,rationType.ration);
  // 连续点工具栏的插入定额按钮，显示树结构画线有问题。
  // projectObj.project.Ration.addNewRationFast(rationType.ration,projectObj.selectColAndFocus);
  //2020-01-08  要限制定额数量，所以还是要用等回传信息的方式插入定额
  projectObj.project.Ration.addNewRation(null, rationType.ration, projectObj.selectColAndFocus, false);
});
const throttleUpMove = _.throttle(() => {
  const controller = projectObj.mainController;
  const project = projectObj.project;
  const mainTreeNodes = controller.getValidNodesWithinSelection();
  const sourceNodes = mainTreeNodes.map((node) => node.source);
  const firstNode = mainTreeNodes[0];
  if (firstNode.sourceType === commonConstants.SourceType.BILLS) {
    project.Bills.multiUpMoveBills(project.Bills.tree, sourceNodes);
    controller.multiUpMove(mainTreeNodes);
  } else if (firstNode.sourceType === commonConstants.SourceType.RATION) {
    project.Ration.changeMultiPos(mainTreeNodes[0].preSibling.source, sourceNodes);
    controller.multiUpMove(mainTreeNodes);
  }
}, throttleTime);
$("#upMove").click(throttleUpMove);
const throttleDownMove = _.throttle(() => {
  const controller = projectObj.mainController;
  const project = projectObj.project;
  const mainTreeNodes = controller.getValidNodesWithinSelection();
  const sourceNodes = mainTreeNodes.map((node) => node.source);
  const firstNode = mainTreeNodes[0];
  if (firstNode.sourceType === commonConstants.SourceType.BILLS) {
    project.Bills.multiDownMoveBills(project.Bills.tree, sourceNodes);
    controller.multiDownMove(mainTreeNodes);
  } else if (firstNode.sourceType === commonConstants.SourceType.RATION) {
    const nextSource = mainTreeNodes[mainTreeNodes.length - 1].nextSibling.source;
    const reverseSource = [...sourceNodes].reverse();
    project.Ration.changeMultiPos(nextSource, reverseSource);
    controller.multiDownMove(mainTreeNodes);
  }
}, throttleTime);
$("#downMove").click(throttleDownMove);
$("a[name='lockBills']").click(function () {
  //点击锁定/解锁清单
  let lockBills = projectObj.project.projectInfo.property.lockBills;
  lockBills = !lockBills;
  projectObj.project.updateLockBills(lockBills, function () {
    var controller = projectObj.mainController,
      project = projectObj.project;
    var selected = controller.tree.selected;
    let nodes = _.filter(project.mainTree.items, { sourceType: ModuleNames.bills });
    controller.refreshTreeNode(nodes);
    projectObj.mainController.setTreeSelected(selected); //触发树节点选中事件
    projectObj.loadLockBillsButton();
  });
});
$("#ZLFB_btn").click(function () {
  zlfb_object.getSectionInfo();
});

//显示至..
let displayLevel = function (nodes, depth, type) {
  let refreshNodes = [];
  function getExpandedController() {
    if (["X", "M", "J", "XM"].includes(type)) {
      //项、目、节、细目
      return function expandedControl(nodes, depth) {
        for (let node of nodes) {
          let nodeDepth = node.depth();
          if (nodeDepth <= depth) {
            let expanded =
              (nodeDepth === depth && !node.children[0]) || (nodeDepth < depth && node.children[0] && node.children[0].data.type === billType.BILL)
                ? true
                : false;
            node.setExpanded(expanded);
            refreshNodes.push(node);
            if (nodeDepth < depth) {
              expandedControl(node.children, depth);
            }
          }
        }
      };
    } else {
      return function expandedControl(nodes) {
        for (let node of nodes) {
          if (node.sourceType === projectObj.project.Bills.getSourceType()) {
            let expanded = true;
            if (type === "ZDCXM") {
              expanded = !node.children[0] || (node.children[0] && node.children[0].sourceType !== projectObj.project.Ration.getSourceType()) ? true : false;
            }
            node.setExpanded(expanded);
            refreshNodes.push(node);
            expandedControl(node.children);
          }
        }
      };
    }
  }
  getExpandedController()(nodes, depth);
  let sheet = projectObj.mainSpread.getActiveSheet();
  TREE_SHEET_HELPER.massOperationSheet(sheet, function () {
    TREE_SHEET_HELPER.refreshNodesVisible(refreshNodes, projectObj.mainSpread.getActiveSheet(), true);
  });
};

// 数据接口
$("#open-export-modal").click(() => {
  CommonHeader.doAfterValidateVersion(
    () => $("#interface-export-modal").modal("show"),
    () => alert(`${commonUtil.getVersionText()}不提供此功能。`)
    // () => $('#interface-export-modal').modal('show'), // 暂时
  );
});

//导入下拉
$("#importSpan").click(function () {
  $('[data-toggle="tooltip"]').tooltip("hide");
  $("#import").modal("show");
});
$("#importDropDown").click(function () {
  $('[data-toggle="tooltip"]').tooltip("hide");
});
$("body").click(function () {
  //点击完后隐藏子菜单
  if ($("#subDisplay").is(":visible")) {
    $("#subDisplay").removeClass("show");
  }
});
let enterDisplayA = false;
//鼠标移到显示至，自动弹出子菜单
$("#displayA").mouseenter(function (e) {
  enterDisplayA = true;
  $("#subDisplay").addClass("show");
});
$("#displayA").mouseleave(function () {
  enterDisplayA = false;
});
$("#moreMenu > a").mouseenter(function () {
  if (!enterDisplayA) {
    $("#subDisplay").removeClass("show");
  }
});

//项
$("#displayX").click(function () {
  displayLevel(projectObj.project.mainTree.items, 1, "X");
});
//目
$("#displayM").click(function () {
  displayLevel(projectObj.project.mainTree.items, 2, "M");
});
//节
$("#displayJ").click(function () {
  displayLevel(projectObj.project.mainTree.items, 3, "J");
});
//细目
$("#displayXM").click(function () {
  displayLevel(projectObj.project.mainTree.items, 4, "XM");
});
//最底层细目
$("#displayZDCXM").click(function () {
  displayLevel(projectObj.project.mainTree.items, null, "ZDCXM");
});
//定额
$("#displayDE").click(function () {
  displayLevel(projectObj.project.mainTree.items, null, "DE");
});

$("#poj-set").on("show.bs.modal", function () {
  let setCalcFlag = function (obj, val, curFlag) {
    obj.val(val);
    if (val === curFlag) {
      obj.prop("checked", true);
    } else {
      obj.prop("checked", false);
    }
  };
  if (projectObj.project) {
    //江西重定义了leafBillGetFeeType的内容
    // 预算：bill, 正算，rationPrice: 2,
    // 清单：ration, 反算，rationPriceConverse: 1,
    let defaultCalcMode = projectObj.project.property.valuationType !== "ration" ? leafBillGetFeeType.rationPrice : leafBillGetFeeType.rationPriceConverse;
    let ft =
      projectObj.project.property.billsCalcMode !== undefined && projectObj.project.property.billsCalcMode !== null
        ? projectObj.project.property.billsCalcMode
        : defaultCalcMode;

    let zg =
      projectObj.project.property.zanguCalcMode !== undefined && projectObj.project.property.zanguCalcMode !== null
        ? projectObj.project.property.zanguCalcMode
        : zanguCalcType.common;
    setCalcFlag($("#rationContent"), leafBillGetFeeType.rationContent, ft);
    setCalcFlag($("#rationPriceConverse"), leafBillGetFeeType.rationPriceConverse, ft);
    setCalcFlag($("#rationPrice"), leafBillGetFeeType.rationPrice, ft);
    setCalcFlag($("#billsPrice"), leafBillGetFeeType.billsPrice, ft);
    setCalcFlag($("#zangu_common"), zanguCalcType.common, zg);
    setCalcFlag($("#zangu_gatherMaterial"), zanguCalcType.gatherMaterial, zg);

    let showAdjustPrice = projectObj.project.projSetting.glj_col ? projectObj.project.projSetting.glj_col.showAdjustPrice : false;
    showAdjustPrice === true ? $("#tab_poj-settings-6").show() : $("#tab_poj-settings-6").hide();
    projDisplayView.init();
    calcOptions.init();
  }
  let propertyInfo = projectObj.project.projectInfo.property;
  //关于计算-价差预备费//预算项目才有
  if (propertyInfo.valuationType !== "ration") {
    $("#jcybf").show();
    //年造价增涨率,单位为%
    $("#costGrowthRate").val(propertyInfo.costGrowthRate ? propertyInfo.costGrowthRate * 100 : 0);
    //增涨计费年限
    $("#growthPeriod").val(propertyInfo.growthPeriod ? propertyInfo.growthPeriod : 0);
  }
});

function isKeyNumber(keyCode) {
  // 数字
  if (keyCode >= 48 && keyCode <= 57) {
    return true;
  } else if (keyCode >= 96 && keyCode <= 105) {
    //小键盘数字
    return true;
  } else if (keyCode == 8 || keyCode == 46 || keyCode == 37 || keyCode == 39 || keyCode == 108 || keyCode == 110) {
    // Backspace, del, 左右方向键
    return true;
  } else if (keyCode >= 112 && keyCode <= 123) {
    //F1 -F12
    return true;
  }
  return false;
}

//年造价增涨率
$("#costGrowthRate").keydown(function (e) {
  return isKeyNumber(e.keyCode);
});
//计费年限
$("#growthPeriod").keydown(function (e) {
  return isKeyNumber(e.keyCode);
});

//恢复默认列设置
$("#recColSetting").click(function () {
  let libID = projectObj.project.property.colLibID ? projectObj.project.property.colLibID : null;
  if (!libID) {
    alert("项目没有绑定标准列设置");
    return;
  }
  $(this).addClass("disabled");
  CommonAjax.post(
    "/project/getDefaultColSetting",
    { libID: libID },
    function (rstData) {
      if (!rstData || rstData.length === 0) {
        alert("标准列设置没有数据");
        $("#recColSetting").removeClass("disabled");
        return;
      }
      let sheet = colSettingObj.settingSpread.getActiveSheet();
      SheetDataHelper.massOperationSheet(sheet, function () {
        for (let row = 0; row < sheet.getRowCount(); row++) {
          sheet.setValue(row, 0, rstData.main_tree_col.cols[row].visible);
        }
      });
      $("#recColSetting").removeClass("disabled");
    },
    function () {
      $("#recColSetting").removeClass("disabled");
    }
  );
});
//恢复默认系统设置
$("#property_default").click(function () {
  let project = projectObj.project,
    projectID = project.ID();
  /*
   * 清除窗口比例缓存
   * */
  //清单精灵/指引窗口比例
  removeLocalCache("stdBillsGuidanceTabmainWidth");
  removeLocalCache("stdBillsGuidanceTabmainSideWidth");
  // 清单展开状态
  window.sessionStorage.removeItem("stdBillsGuidanceExpState");
  //定额库窗口比例
  removeLocalCache("stdRationTabmainWidth");
  removeLocalCache("stdRationTabmainSideWidth");
  removeLocalCache("dedeTopDivHeight");
  removeLocalCache("dedeBottomDivHeight");
  //查找定位窗口比例
  removeLocalCache("locateTabmainWidth");
  removeLocalCache("locateTabmainSideWidth");
  removeLocalCache("locatelocateTopDivHeight");
  removeLocalCache("locatelocateBottomDivHeight");
  //块模板库窗口比例
  removeLocalCache("kmbkkmbkTopDivHeight");
  removeLocalCache("kmbkkmbkMidDivHeight");
  removeLocalCache("kmbkkmbkBottomDivHeight");
  //主界面窗口比例
  removeLocalCache("mainVerticaltop_divHeight");
  removeLocalCache("mainVerticalbottom_divHeight");
  //造价书下方-人材机和项目特征文本
  removeLocalCache("subRcjsubSpreadWidth");
  removeLocalCache("subRcjitemTextDivWidth");
  //造价书下方-子目换算下调整状态和辅助值
  removeLocalCache("subRcjitemTextDivWidth");
  removeLocalCache("subRcjitemTextDivWidth");
  //造价书下方-特征及内容窗口比例
  removeLocalCache("subZmhscoeSpreadWidth");
  removeLocalCache("subZmhsassDivWidth");
  //人材机汇总窗口比例
  removeLocalCache("projectGljprojectGljTopHeight");
  removeLocalCache("projectGljprojectGljBottomHeight");
  //补充人材机库
  removeLocalCache("compleGLjleftContentWidth");
  removeLocalCache("compleGLjmidContentWidth");
  removeLocalCache("compleGLjrightContentWidth");
  //补充定额库
  removeLocalCache("compleRationleftContentWidth");
  removeLocalCache("compleRationmainContentWidth");
  removeLocalCache("compleRationzmhsContentWidth");
  removeLocalCache("compleRationrationItemsSheetHeight");
  removeLocalCache("compleRationsubContentHeight");
  removeLocalCache("compleRationmainSpreadHeight");
  removeLocalCache("compleRationcontentSpreadHeight");

  //在后台恢复一些设置
  CommonAjax.post("/pm/api/defaultSettings", { user_id: userID, projectID: projectID }, function (rstData) {
    window.location.href = `/main?project=${projectID}`;
  });
});
$("#property_ok").click(function () {
  let project = projectObj.project,
    projectID = project.ID(),
    properties = {},
    options = {},
    labourCoes = {},
    rations = [],
    bills = [],
    mixDatas = {
      projectID: projectID,
      updateType: "update",
      properties: properties,
      options: options,
      labourCoes: labourCoes,
      rations: rations,
      bills: bills,
    },
    reCalcBills = false,
    reCalcRations = false;

  let b = parseInt($("input[name='calcFlag']:checked").val());
  if (b !== project.property.billsCalcMode) {
    properties["property.billsCalcMode"] = b;
    project.property.billsCalcMode = b;
    reCalcBills = true;
  }

  let zg = parseInt($("input[name='zangu']:checked").val());
  if (zg !== project.property.zanguCalcMode) {
    properties["property.zanguCalcMode"] = zg;
    project.property.zanguCalcMode = zg;
    reCalcRations = true;
  }

  //价差预备费,预算项目才有
  if (project.property.valuationType !== "ration") {
    let costGrowthRateV = $("#costGrowthRate").val(),
      costGrowthRate = costGrowthRateV ? parseFloat(costGrowthRateV / 100) : 0,
      growthPeriodV = $("#growthPeriod").val(),
      growthPeriod = growthPeriodV ? parseFloat(growthPeriodV) : 0;
    if (project.property.costGrowthRate !== costGrowthRate) {
      properties["property.costGrowthRate"] = costGrowthRate;
      project.property.costGrowthRate = costGrowthRate;
      reCalcBills = true;
    }
    if (project.property.growthPeriod !== growthPeriod) {
      properties["property.growthPeriod"] = growthPeriod;
      project.property.growthPeriod = growthPeriod;
      reCalcBills = true;
    }
  }

  //基本信息
  if (basicInfoView.toUpdate(basicInfoView.orgDatas, basicInfoView.datas)) {
    let saveData = basicInfoView.toSaveDatas(basicInfoView.datas);
    projectObj.project.property.basicInformation = saveData;
    properties["property.basicInformation"] = saveData;
  }
  //工程特征
  let diffBillsPriceFeatureDatas = [];
  if (projFeatureView.toUpdate(projFeatureView.orgDatas, projFeatureView.datas)) {
    let saveData = projFeatureView.toSaveDatas(projFeatureView.datas);
    projectObj.project.property.projectFeature = saveData;
    properties["property.projectFeature"] = saveData;
    //内蒙古养估、广东农村等有些特征修改后，需要刷新指标基价(清单单价)
    //*
    if (billsUnitPriceFeature) {
      for (let idx = 0; idx < projFeatureView.orgDatas.length; idx++) {
        if (projFeatureView.orgDatas[idx].value !== projFeatureView.datas[idx].value) {
          diffBillsPriceFeatureDatas.push(projFeatureView.datas[idx]);
        }
      }
    }
    //*/
  }
  // 清单限价
  const maxPriceRate = $("#max-price-rate") && +$("#max-price-rate").val();
  if (commonUtil.isNumber(maxPriceRate) && maxPriceRate !== projectObj.project.property.maxPriceRate) {
    properties["property.maxPriceRate"] = maxPriceRate;
  }
  const minPriceRate = $("#min-price-rate") && +$("#min-price-rate").val();
  if (commonUtil.isNumber(minPriceRate) && minPriceRate !== projectObj.project.property.minPriceRate) {
    properties["property.minPriceRate"] = minPriceRate;
  }
  //清单工程量精度
  let newBillsDecimalDatas = billsDecimalView.toBillsDecimalDatas(billsDecimalView.cache);
  if (billsDecimalView.toUpdate(billsQuanDecimal.datas, newBillsDecimalDatas)) {
    billsQuanDecimal.datas = newBillsDecimalDatas;
    reCalcBills = true;
    properties["property.billsQuantityDecimal"] = newBillsDecimalDatas;
  }
  //小数位数
  let updateDecimal = m_getDecimalData($("input", "#poj-settings-decimal"));
  if (toUpdateDecimal(decimalObj, updateDecimal)) {
    let frChanged = decimalObj.feeRate != updateDecimal.feeRate;
    setDecimal(decimalObj, updateDecimal);
    if (frChanged) {
      project.calcProgram.compileAllTemps();
    }
    reCalcRations = true;
    reCalcBills = true;
    properties["property.decimal"] = updateDecimal;
  }
  // 呈现选项
  projDisplayView.updateChecking(properties);
  //列设置（独立逻辑，只是通过项目属性确定按钮触发）
  if (colSettingObj.dataChanged()) {
    colSettingObj.updateColSetting();
  }
  //系统选项
  if (optionsOprObj.needToSaveGeneralOpts()) {
    let v1 = optionsOprObj.rationQuanACToBillsQuan.prop("checked"),
      v2 = optionsOprObj.rationQuanACToRationUnit.prop("checked"),
      progressiveType = parseInt($("input[name='progressiveType']:checked").val());
    options.updateData = {
      rationQuanACToBillsQuan: v1,
      rationQuanACToRationUnit: v2,
      progressiveType: progressiveType,
    };
    optionsOprObj.options[optionsOprObj.optionsTypes.GENERALOPTS].progressiveType = progressiveType;
  }

  if (calcOptions.updateChecking(properties)) {
    reCalcRations = true;
  }

  // 人工系数
  if (labourCoeView.needSave()) {
    let libID = $("#std_labour_coe_files").children("option:selected").val();
    let libName = $("#std_labour_coe_files").children("option:selected").text();

    labourCoes.updateData = { libID: libID, libName: libName, newItemArr: labourCoeView.needUpdateDatas };
    project.labourCoe.refreshData(labourCoes.updateData); // 全编译所用到的人工系数来自project.labourCoe，所以必须先刷新project.labourCoe
    project.calcProgram.compileAllTemps();
    reCalcRations = true;
    reCalcBills = true;
  }
  // 重新计算树节点
  let changedNodes = [];
  if (reCalcRations)
    // 定额动，全部计算。算完先不存储，和后面的数据一起提交，一次通讯。
    changedNodes = project.calcProgram.calcAllNodes(calcAllType.catAll);
  else if (reCalcBills)
    // 清单动，可以只计算清单。
    changedNodes = project.calcProgram.calcAllNodes(calcAllType.catBills);
  if (changedNodes.length > 0) {
    for (let node of changedNodes) {
      let data = calcTools.cutNodeForSave(node);
      if (node.sourceType == "ration") rations.push(data);
      else if (node.sourceType == "bills") bills.push(data);
    }
  }

  function hasMixData() {
    return (
      Object.keys(mixDatas.properties).length > 0 ||
      mixDatas.options.updateData ||
      mixDatas.labourCoes.updateData ||
      mixDatas.rations.length > 0 ||
      mixDatas.bills.length > 0
    );
  }

  function needToReload(mixDatas) {
    if (Object.keys(mixDatas.labourCoes).length > 0) {
      return true;
    }
    if (Object.keys(mixDatas.properties).length > 0) {
      if (
        mixDatas.properties.hasOwnProperty("property.billsCalcMode") ||
        mixDatas.properties.hasOwnProperty("property.zanguCalcMode") ||
        mixDatas.properties.hasOwnProperty("property.calcOptions") ||
        mixDatas.properties.hasOwnProperty("property.costGrowthRate") ||
        mixDatas.properties.hasOwnProperty("property.growthPeriod") ||
        mixDatas.properties.hasOwnProperty("property.billsQuantityDecimal") ||
        mixDatas.properties.hasOwnProperty("property.decimal") ||
        mixDatas.properties.hasOwnProperty("property.displaySetting")
      ) {
        return true;
      }
    }
    return false;
  }

  if (hasMixData()) {
    CommonAjax.post("/pm/api/updateMixDatas", { user_id: userID, mixDataArr: mixDatas }, function (rstData) {
      const doAferSuccess = () => {
        $.bootstrapLoading.end();
        //需要重载页面
        if (needToReload(mixDatas)) {
          window.location.href = "/main?project=" + projectID;
        } else {
          if (mixDatas.properties.hasOwnProperty("property.maxPriceRate")) {
            projectObj.project.property.maxPriceRate = maxPriceRate;
          }
          if (mixDatas.properties.hasOwnProperty("property.minPriceRate")) {
            projectObj.project.property.minPriceRate = minPriceRate;
          }
          if (mixDatas.properties.hasOwnProperty("property.basicInformation")) {
            basicInfoView.orgDatas = basicInfoView.toViewDatas(mixDatas.properties["property.basicInformation"]);
          }
          if (mixDatas.properties.hasOwnProperty("property.projectFeature")) {
            projFeatureView.orgDatas = projFeatureView.toViewDatas(mixDatas.properties["property.projectFeature"]);
          }
          if (mixDatas.options && mixDatas.options.updateData) {
            let v1 = mixDatas.options.updateData["rationQuanACToBillsQuan"],
              v2 = mixDatas.options.updateData["rationQuanACToRationUnit"],
              progressiveType = mixDatas.options.updateData["progressiveType"];
            optionsOprObj.updateOptions(optionsOprObj.options, { type: optionsOprObj.optionsTypes.GENERALOPTS, opt: "rationQuanACToBillsQuan", value: v1 });
            optionsOprObj.updateOptions(optionsOprObj.options, { type: option - sOprObj.optionsTypes.GENERALOPTS, opt: "rationQuanACToRationUnit", value: v2 });
            optionsOprObj.updateOptions(optionsOprObj.options, {
              type: optionsOprObj.optionsTypes.GENERALOPTS,
              opt: "progressiveType",
              value: progressiveType,
            });
          }
        }
      };
      // 改变清单库
      if (rstData && rstData.billLibs) {
        projectObj.project.projectInfo.engineeringInfo.bill_lib = rstData.billLibs;
        $("#stdBillsGuidanceLibSelect").empty();
        if ($("#zy").is(":visible")) {
          billsGuidance.initLibs(rstData.billLibs);
        }
      }
      // 需要改变费率
      if (rstData && rstData.newFeeLibID) {
        $.bootstrapLoading.start();
        feeRateObject.feeRateSTDLoaded = false;
        feeRateObject.feeRateSTDList = [];
        projectObj.project.FeeRate.changeFeeRateStandard(rstData.newFeeLibID, doAferSuccess);
      } else {
        doAferSuccess();
      }
    });
  }

  if (diffBillsPriceFeatureDatas.length > 0) {
    //刷新指标基价
    if (billsGuidance.bills.tree) {
      chkAndResetBills(billsGuidance.bills.workBook.getActiveSheet(), billsGuidance.bills.tree.items);
      billsGuidance.bills.workBook.refresh();
    } else {
      chkAndResetBills(null);
    }
  }
});

function testShow() {
  var controller = projectObj.mainController,
    project = projectObj.project;
  var selected = controller.tree.selected,
    parent = selected.parent;
  var showinfo = "<label>确认要删除当前选中行吗？</label>";
  var showN = false;
  var cancelText = "否";
  if (selected.sourceType == project.Bills.getSourceType() && selected.data.type == billType.FB && selected.children.length > 0) {
    //选中的是分部，并且有子项
    if (isSingleSelect() || selectionChecking()) {
      showinfo =
        "<label>是否删除其下的子项？</label><br><label>【是】则删除分部行及其下的所有子项，</label><br><label>【否】则仅删除当前分部行，子项保留，</label><br><label>【取消】则取消删除</label>";
      showN = true;
      cancelText = "取消";
    }
  }
  $("#delete_showinfo").html(showinfo);
  showN == true ? $("#deleteN").show() : $("#deleteN").hide();
  $("#deleteCancel").text(cancelText);

  function selectionChecking() {
    let selection = projectObj.mainSpread.getActiveSheet().getSelections()[0];
    let mainTreeMap = {};
    for (let i = 0; i < selection.rowCount; i++) {
      let tem_node = controller.tree.items[selection.row + i];
      if (i == 0) {
        //第一个直接添加;
        mainTreeMap[tem_node.getID()] = tem_node;
      } else {
        project.Bills.setNodeToMap(tem_node, mainTreeMap);
      }
    }
    let nodes = changeMapToArray(mainTreeMap);
    if (nodes.length == 1) {
      return true;
    }
    return false;
  }
}

$("#delete_row").on("show.bs.modal", function (e) {
  //这里用show,在shown之前调用，页面不会出现按钮闪现的情况
  var controller = projectObj.mainController,
    project = projectObj.project;
  var selected = controller.tree.selected,
    parent = selected.parent;
  var showinfo = "<label>确认要删除当前选中行吗？</label>";
  var showN = false;
  var cancelText = "否";
  if (selected.sourceType == project.Bills.getSourceType() && selected.data.type == billType.FB && selected.children.length > 0) {
    //选中的是分部，并且有子项
    if (isSingleSelect() || selectionChecking()) {
      showinfo =
        "<label>是否删除其下的子项？</label><br><label>【是】则删除分部行及其下的所有子项，</label><br><label>【否】则仅删除当前分部行，子项保留，</label><br><label>【取消】则取消删除</label>";
      showN = true;
      cancelText = "取消";
    }
  } else if (isSingleSelect() && mbzm_obj.hasReferenceRation(selected)) {
    //“有模板关联的定额”右键点击删除，弹窗提示“删除主子目时将删除对应的关联子目，是否继续？  是 否” (只有单选中一条定额并且是有模板关联的定额)
    showinfo = "<label>删除主子目时将删除对应的关联子目，是否继续？</label>";
  }
  $("#delete_showinfo").html(showinfo);
  showN == true ? $("#deleteN").show() : $("#deleteN").hide();
  $("#deleteCancel").text(cancelText);

  function selectionChecking() {
    let selection = projectObj.mainSpread.getActiveSheet().getSelections()[0];
    let mainTreeMap = {},
      nodes = [];
    for (let i = 0; i < selection.rowCount; i++) {
      let tem_node = controller.tree.items[selection.row + i];
      if (i == 0) {
        //第一个直接添加;
        mainTreeMap[tem_node.getID()] = tem_node;
      } else {
        project.Bills.setNodeToMapAndArray(tem_node, mainTreeMap, nodes);
      }
    }
    if (nodes.length == 1) {
      return true;
    }
    return false;
  }
});

function changeMapToArray(map) {
  let newArray = [];
  for (let key in map) {
    newArray.push(map[key]);
  }
  return newArray;
}

$("#deleteY").click(function () {
  //正常删除，级联删除子项
  let project = projectObj.project;
  project.Bills.deleteSelectedNodes();
});

$("#deleteN").click(function () {
  //不删除子项
  let controller = projectObj.mainController,
    project = projectObj.project;
  let selected = controller.tree.selected,
    parent = selected.parent;
  if (selected) {
    let preNode = selected.preSibling;
    let nextNode = selected.nextSibling;
    if (preNode) {
      //有前兄弟
      if (preNode.children.length > 0 && preNode.children[0].data.type != selected.children[0].data.type) {
        //并且前兄弟子项和焦点行子项类别不同。
        alert("删除分部会导致分部和分项同级，不允许该操作！");
        return;
      }
    } else if (nextNode) {
      if (nextNode.data.type != selected.children[0].data.type) {
        alert("删除分部会导致分部和分项同级，不允许该操作！ ");
        return;
      }
    }
    project.Bills.singleDeleteBills(selected, controller);
  }
});

function isSingleSelect() {
  //是否选中造价书中的单行
  let selections = projectObj.mainSpread.getActiveSheet().getSelections();
  if (selections[0].rowCount == 1) {
    return true;
  }
  return false;
}
function ifCanDelete() {
  if (projectReadOnly) {
    return false;
  }
  let selections = projectObj.mainSpread.getActiveSheet().getSelections();
  let tree = projectObj.project.mainTree;
  let selected = projectObj.project.mainTree.selected;
  if (selections[0].rowCount == 1) {
    //选中单行
    return canDelete(selected);
  } else {
    return canDelete_m(selections[0]);
  }

  function canDelete(node, m_selection) {
    if (node) {
      if (node.sourceType === projectObj.project.Bills.getSourceType()) {
        if (node.data.type == billType.DXFY && node.data.isAdd != 1) {
          return false;
        }
        if (projectObj.project.isBillsLocked() == true && projectObj.project.withinBillsLocked(node)) {
          return false;
        }
        if (projectObj.project.Bills.hasFlags(node)) {
          return false;
        }
      }
      if (m_selection != true && node.sourceType === projectObj.project.ration_glj.getSourceType()) {
        //多选的时候不做这一项判断
        return false;
      }
      return true;
    } else {
      return false;
    }
  }

  function canDelete_m(selection) {
    for (let i = 0; i < selection.rowCount; i++) {
      if (tree.items[selection.row + i] == undefined || tree.items[selection.row + i] == null) {
        return false;
      }
      if (i == 0 && tree.items[selection.row].sourceType === projectObj.project.ration_glj.getSourceType()) {
        return false;
      }
      if (canDelete(tree.items[selection.row + i], true) == false) {
        return false;
      }
    }
    return true;
  }
}

function canInsertRationNode(selected) {
  //判断是否能插入定额、量价、定额类型工料机, false 不能，true能
  if (!selected) return false;
  let project = projectObj.project;
  if (selected.sourceType == ModuleNames.bills && selected.data.type == billType.DXFY) {
    return false;
  } else if (!(project.Bills.isMeasure(selected) || project.Bills.isFBFX(selected))) {
    return false;
  } else if (selected.sourceType == ModuleNames.bills && selected.source.children.length > 0) {
    return false;
  } else {
    return true;
  }
}

let importJson = null;
//选择导入的excel文件
$("#customFile").change(function () {
  let file = $(this)[0];
  let excelFile = file.files[0];
  $("#uploadAlert").hide();
  if (excelFile) {
    let xlsReg = /xls$/g;
    if (excelFile.name && xlsReg.test(excelFile.name)) {
      showUploadAlert(false, "请选择xlsx文件");
      $(this).val("");
      return;
    }
    $(".custom-file-label").text(`${file.files[0].name}`);
    $("#uploadAlert").hide();
    $.bootstrapLoading.start();
    $("#loadingPage").css("z-index", "2000");
    //前端解析excel数据
    if (importJson) {
      importJson = null;
    }
    let excelIo = new GC.Spread.Excel.IO();
    let sDate = +new Date();
    excelIo.open(
      excelFile,
      function (json) {
        importJson = json;
        console.log(json);
        console.log(`解析Excel文件时间：${+new Date() - sDate}`);
        $.bootstrapLoading.end();
      },
      function (e) {
        $.bootstrapLoading.end();
        alert(e.errorMessage);
      }
    );
  }
});

//线上nginx请求体最大设置为100m
//从excel导入清单
$("#importConfirm").click(function () {
  let me = this;
  $(me).addClass("disabled");
  try {
    $.bootstrapLoading.start();
    $("#loadingPage").css("z-index", "2000");
    let formData = new FormData();
    let file = $("#customFile")[0];
    if (file.files.length <= 0) {
      throw "未选择文件";
    }
    let projectID = scUrlUtil.GetQueryString("project");
    if (!projectID || projectID <= 0) {
      throw "项目数据出错";
    }
    let sDate = +new Date();
    formData.append("projectID", projectID);
    let importBillsData = importBills.extactDatas(importJson.sheets);
    if (importBillsData.length === 0) {
      throw "excel无有效数据";
    }
    let compressData = LZString.compressToUTF16(JSON.stringify(importBillsData));
    formData.append("compressData", compressData);
    let eDate = +new Date();
    console.log(`解析excel数据时间：${eDate - sDate}`);
    $.ajax({
      url: "/bills/import",
      type: "POST",
      data: formData,
      cache: false,
      contentType: false,
      processData: false,
      success: function (response) {
        if (response.err === 0) {
          // 成功则关闭窗体
          $("#import").modal("hide");
          //更新前端
          doAfterImport(response.data);
          if ($.bootstrapLoading.isLoading()) {
            $.bootstrapLoading.end();
          }
        } else {
          const message = response.msg !== undefined ? response.msg : "上传失败!";
          $.bootstrapLoading.end();
          alert(message);
        }
        $(me).removeClass("disabled");
      },
      error: function (jqXHR) {
        alert(`与服务器通信发生错误${jqXHR.status} ${jqXHR.statusText}`);
        $.bootstrapLoading.end();
        $(me).removeClass("disabled");
      },
    });
  } catch (err) {
    console.log(err);
    showUploadAlert(false, err);
    $(me).removeClass("disabled");
    if ($.bootstrapLoading.isLoading()) {
      $.bootstrapLoading.end();
    }
  }
});

function showUploadAlert(success, msg) {
  if (!success) {
    $("#uploadAlert").removeClass("alert-success");
    $("#uploadAlert").addClass("alert-danger");
  } else {
    $("#uploadAlert").removeClass("alert-danger");
    $("#uploadAlert").addClass("alert-success");
  }
  $("#uploadAlert").text(msg);
  $("#uploadAlert").show();
}
//导入清单到一个固定行位置后，更新数据
function doAfterImportPosition(positionData) {
  let nodes = projectObj.project.mainTree.nodes;
  let bills_datas = projectObj.project.Bills.datas;
  let ration_datas = projectObj.project.Ration.datas;
  let quantity_detail_datas = projectObj.project.quantity_detail.datas;
  let ration_glj_datas = projectObj.project.ration_glj.datas;
  let ration_coe_datas = projectObj.project.ration_coe.datas;
  let ration_install_datas = projectObj.project.ration_installation.datas;
  let delNodes = [];
  for (let billID of positionData.remove.bill) {
    if (nodes["id_" + billID]) {
      delNodes.push(nodes["id_" + billID]);
    }
    //清除清单数据
    _.remove(bills_datas, { ID: billID });
    //清除清单工程量明细数据
    _.remove(quantity_detail_datas, { billID: billID });
  }
  for (let rationID of positionData.remove.ration) {
    //清除定额数据
    _.remove(ration_datas, { ID: rationID });
    //清除定额下的相关数据
    _.remove(ration_glj_datas, { rationID: rationID });
    _.remove(ration_coe_datas, { rationID: rationID });
    _.remove(ration_install_datas, { rationID: rationID });
    _.remove(quantity_detail_datas, { rationID: rationID });
  }
  //删除节点
  if (delNodes.length > 0) {
    //通过固定清单获得删除节点的起始行索引
    let beginRow = null;
    if (positionData.fixedBill) {
      let fixedNode = nodes["id_" + positionData.fixedBill.ID];
      if (fixedNode) {
        beginRow = projectObj.project.mainTree.items.indexOf(fixedNode) + 1;
      }
    }
    //删除主树节点
    projectObj.mainController.m_delete(delNodes, beginRow);
    //删除清单树节点
    let delIdNodes = [];
    for (let delNode of delNodes) {
      delIdNodes.push(delNode.source);
    }
    projectObj.project.Bills.tree.m_delete(delIdNodes);
  }
  if (positionData.insert.bill.length > 0) {
    //设置flagsIndex
    for (let insertBill of positionData.insert.bill) {
      insertBill.flagsIndex = {};
      if (insertBill.flags) {
        insertBill.flags.forEach(function (flag) {
          insertBill.flagsIndex[flag.fieldName] = flag;
        });
      }
    }
    //插入清单节点
    projectObj.project.Bills.tree.insertByDatas(positionData.insert.bill);
    projectObj.project.Bills.datas = projectObj.project.Bills.datas.concat(positionData.insert.bill);
    //插入主树节点
    let newNodes = projectObj.project.mainTree.insertByDatas(positionData.insert.bill);
    for (let node of newNodes) {
      node.source = projectObj.project.Bills.tree.nodes["id_" + node.getID()];
      node.data = node.source.data;
      node.sourceType = projectObj.project.Bills.getSourceType();
      if (node.data.fees) {
        node.data.feesIndex = getFeeIndex(node.data.fees);
      }
    }
    ProjectController.syncDisplayNewNodes(projectObj.mainController, newNodes);
  }
}
//导入后更新操作
function doAfterImport(resData) {
  if (resData && resData.length > 0) {
    for (let data of resData) {
      doAfterImportPosition(data);
    }
    //如果清单未锁定，导入后锁定清单
    if (!projectObj.project.projectInfo.property.lockBills) {
      $("a[name='lockBills']").click();
    }
    $.bootstrapLoading.end();
    //重算
    projectObj.project.calcProgram.calcAllNodesAndSave(calcAllType.catAll, function () {
      projectObj.project.projectGLJ.loadData(function () {
        $.bootstrapLoading.end();
      });
    });
  }
}
//下载导入清单示例文件
$("#uploadExample").click(function () {
  window.location.href = "/bills/downloadExamp";
});

$(function () {
  //清空导入清单选择文件
  $("#import").on("show.bs.modal", function () {
    $("#customFile").val("");
    $("#uploadAlert").hide();
    $(".custom-file-label").text(`请选择上传文件`);
  });

  $("#import").on("hidden.bs.modal", function () {
    //恢复选择表高度
    $("#uploadSheets").height("");
    $("#uploadSheets").hide();
    $("#uploadSheetsHead").hide();
  });

  /* $("#billsSpread").mouseover(function(){
        spreadAutoFocus(projectObj.mainSpread,subSpread);
    });

    $("#subSpread").mouseover(function(){
        spreadAutoFocus(subSpread,projectObj.mainSpread);
    });
*/

  $("#paste_confirm").click(function () {
    let selected = projectObj.project.mainTree.selected;
    let blockData = BlockController.getBlockData();
    let position = $("input[name='pastePositionRadio']:checked").val();
    BlockController.confirmPaste(blockData, selected, position);
    $("#pastePosition").modal("hide");
  });

  $("#div_createBlocks").on("show.bs.modal", function () {
    function getBlockCategoriesHtml(Categories) {
      let result = "";
      if (Categories.length <= 0) return result;

      for (let c of Categories) {
        result += '<option value="' + c.data.ID + '">' + c.data.nodeName + "</option>";
      }
      return result;
    }

    let sHtml = getBlockCategoriesHtml(blockLibObj.getCategories());
    $("#select_block_category").html(sHtml);
    $("#select_block_category")[0].selectedIndex = 0;
    $("#ckb_block_exist_cover").prop("checked", false);
  });

  $("#div_cloneOptions").on("show.bs.modal", function () {
    let s = "";
    switch (blockLibObj.cloneType) {
      case 1:
        s = "一对一克隆";
        break;
      case 2:
        s = "一对多克隆";
        break;
      case 3:
        s = "多对多克隆";
        break;
    }
    s = `<span style='color:red;'>${s}</span>`;
    $("#clone_option_title").html(`快速组价 (${s})`);

    if (calcTools.isBudgetProject()) {
      $("#clone_option_code").prop("checked", false);
      $("#clone_option_name").prop("checked", true);
    } else {
      $("#clone_option_code").prop("checked", true);
      $("#clone_option_name").prop("checked", false);
    }

    $("#clone_option_unit").prop("checked", true);
    $("#clone_option_quantity").prop("checked", true);
    $("#clone_option_cover").prop("checked", true);
  });

  $("#btn_block_createBlocks").click(async function () {
    if ($("#select_block_category")[0].options.length < 1) return;
    let cID = $("#select_block_category").val();
    let selected = projectObj.project.mainTree.selected;
    let cover = $("#ckb_block_exist_cover").prop("checked");
    async function createBlocks(aNode, categoryID) {
      async function createBlock(node) {
        if (node.data.name == undefined || node.data.name == "") return; // 清单名称为空，不生成块模板文件
        if (node.children.length == 0) return;
        // 封装成伟城的块文件格式，直接调用伟城接口（定额这里的业务太多太庞杂，不要再重做一遍，尽量共用，维护代价小）
        // 块文件要构建自己的树结构，所以也有自己的一部分数据。两种结构揉合在一起，显得有点杂乱，但利大于弊。
        let vBlock_WC = {
          compilationID: projectObj.project.projectInfo.compilation,
          firstNodeType: node.data.type,
          isFBFX: projectObj.project.Bills.isFBFX(node),
          copyTime: +new Date(),
          datas: [],
        };
        let ration_glj_Map = _.groupBy(projectObj.project.ration_glj.datas, "rationID");
        vBlock_WC.datas.push(BlockController.getNodeDatas(node, ration_glj_Map));
        vBlock_WC = JSON.parse(JSON.stringify(vBlock_WC));
        // 块文件名称：编号要根据实际情况对父清单的编号进行拼装。
        //  let newCode = divideObj.getExeBillCode(vBlock_WC.datas[0].ID);
        let code = calcTools.getCodeForBlock(node);
        let unit = node.data.unit ? node.data.unit : "";
        let fileName = code + " " + node.data.name + " " + unit;
        fileName = fileName.replace(/^\s+|\s+$/g, ""); // 只去两头空格

        let extN = blockLibObj.getSameNameNode(fileName, categoryID);
        if (extN) {
          if (cover) blockLibObj.assignData(extN, vBlock_WC);
        } else await blockLibObj.newNode(2, fileName, categoryID, vBlock_WC);
      }

      async function createRecursion(node) {
        if (!node) return;

        if (calcTools.isLeafBill(node)) await createBlock(node);

        if (node.firstChild()) await createRecursion(node.firstChild());
        if (node.nextSibling) await createRecursion(node.nextSibling);
      }

      if (calcTools.isLeafBill(aNode)) await createBlock(aNode);
      else await createRecursion(aNode.firstChild());
    }

    await createBlocks(selected, cID);
    blockLibObj.loadDetailDatas(blockLibObj.mainTree.selected);
    $("#div_createBlocks").modal("hide");
  });

  $("#btn_block_clone_ok").click(async function () {
    let projectNode = projectObj.project.mainTree.selected;
    let block = blockLibObj.mainTree.selected;
    let options = {};
    if ($("#clone_option_code").prop("checked")) options.checkCode = true;
    if ($("#clone_option_name").prop("checked")) options.checkName = true;
    if ($("#clone_option_unit").prop("checked")) options.checkUnit = true;
    if ($("#clone_option_zeroQuantity").prop("checked")) options.zeroQuantity = true;
    if ($("#clone_option_cover").prop("checked")) options.overwriteRations = true;
    let calcNodes = [];
    switch (blockLibObj.cloneType) {
      case 1:
        let nodes = await blockLibObj.oneToOneClone(projectNode, block, options);
        calcNodes = calcNodes.concat(nodes);
        break;
      case 2:
        let bills = calcTools.getLeafBills(projectNode);
        for (let bill of bills) {
          calcTools.forceSelect(bill);
          let nodes = await blockLibObj.oneToOneClone(bill, block, options);
          calcNodes = calcNodes.concat(nodes);
        }
        break;
      case 3:
        let mtmBills = calcTools.getLeafBills(projectNode);
        let mtmBlocks = blockLibObj.mainTree.selected.children;
        for (let mtmBill of mtmBills) {
          for (let mtmBlock of mtmBlocks) {
            calcTools.forceSelect(mtmBill);
            let nodes = await blockLibObj.oneToOneClone(mtmBill, mtmBlock, options);
            calcNodes = calcNodes.concat(nodes);
          }
        }
        break;
    }
    if (calcNodes.length > 0) {
      projectObj.project.calcProgram.calcNodesAndSave(calcNodes, function () {
        installationFeeObj.calcInstallationFee();
      });
    }
  });

  function spreadAutoFocus(spread, relateSpread) {
    if (relateSpread && relateSpread.getActiveSheet().isEditing()) {
      //关联的spread不在编辑状态的情况下，才自动获得焦点;
      return;
    } else {
      spread ? spread.focus() : "";
    }
  }
  //项目为只读
  if (projectReadOnly) {
    disableTools();
  }
});

//项目只读，处理不可操作的工具栏
function disableTools() {
  //造价书按钮
  $("#insertRation").addClass("disabled");
  $("#delete").addClass("disabled");
  $("#upLevel").addClass("disabled");
  $("#downLevel").addClass("disabled");
  $("#upMove").addClass("disabled");
  $("#downMove").addClass("disabled");
  $("#ZLFB_btn").addClass("disabled");
  //$('#switchTznr').addClass('disabled');
  $("#uploadLj").addClass("disabled");
  $("#uploadGld").addClass("disabled");
  $('a[name="lockBills"]').addClass("disabled");
  //关于计算
  $("#poj-settings-4").find("input").prop("disabled", "disabled");
  //小数位数
  $("#poj-settings-decimal").find("input").prop("disabled", "disabled");
  // 清单限价
  $(".limit-price-input").prop("disabled", "disabled");
  //人工单价调整
  $("#std_labour_coe_files").prop("disabled", "disabled");
  //呈现选项
  $("#display-setting").find("input").prop("disabled", "disabled");
  $("#recColSetting").remove();
  //项目属性恢复默认系统设置
  $("#property_default").addClass("disabled");
  //项目属性确定
  $("#property_ok").addClass("disabled");
  //清单精灵
  $("#elfInsertRation").addClass("disabled");
  $("#elfInsertSingle").addClass("disabled");
  //模板子目：应用、下一条
  $("#apply_mbzm").addClass("disabled");
  $("#next_mbzm").addClass("disabled");
  //特征及内容
  $("#add-rule").find("select").prop("disabled", "disabled");
  $("#use-to-current").addClass("disabled");
  $("#use-to-all").addClass("disabled");
  $(".bottom-tools").remove();
  //导入
  $("#importConfirm").addClass("disabled");
  //选项
  $("#generalOpts1").prop("disabled", "disabled");
  $("#generalOpts2").prop("disabled", "disabled");
  //补充库编辑器
  $(".compleRationLib").addClass("disabled");
  $(".compleGljLib").addClass("disabled");
  //库
  //$('#stdBillsGuidanceTab').addClass('disabled');
  $("#stdBillsTab").addClass("disabled");
  //$('#stdRationTab').addClass('disabled');
  $("#blockLibTab").addClass("disabled");
  //人材机汇总,选择其他、另存使用
  $('a[data-target="#change-unitFile"]').remove();
  $('a[data-target="#unitFile-save-as"]').remove();
  //费率,选择其他、另存使用、重选标准、统一设置相同参数
  $('a[data-target="#change-lv"]').remove();
  $('a[data-target="#copy-lv"]').remove();
  $("#standardSelect").prop("disabled", "disabled");
  $("#cascadeSet").prop("disabled", "disabled");
  $("#changeConfirm").prop("disabled", "disabled");
  //计算程序标准
  $("#calcProgramFileSelect").prop("disabled", "disabled");
  //调价
  $("#calcPriceOption").prop("disabled", "disabled");
  $("#gljPriceTenderCoe").prop("readOnly", true);
  $("#tenderGLJQuantity").prop("disabled", "disabled");
  $("#tenderRationQuantity").prop("disabled", "disabled");
  $("#tenderPrice").prop("disabled", "disabled");
  $("#cleanTender").prop("disabled", "disabled");
  $("#calcTender").prop("disabled", "disabled");
  //分摊
  $("#exec_divide_btn").prop("disabled", "disabled");
  $("#cancel_divide_btn").prop("disabled", "disabled");
  $("#cancel_all_divide_btn").prop("disabled", "disabled");
}
//根据触发改变计算基数、费率弹出框
function changeCalcBaseFeeRate(toggle) {
  if (toggle === "calcBase") {
    $("#mixedHeader").hide();
    $("#normalHeader").show();
    $("#calcBaseFeeRate").find(".modal-title").text("计算基数选择").show();
    $("#calcBaseExp").remove();
    let $textarea = $("<textarea>").attr("id", "calcBaseExp").prop("rows", 2).addClass("form-control").css("resize", "none");
    $("#expArea").prepend($textarea);
  } else if (toggle === "feeRate") {
    $("#mixedHeader").hide();
    $("#normalHeader").show();
    $("#calcBaseFeeRate").find(".modal-title").text("费率选择").show();
    $("#calcBaseFeeRate").find(".modal-body").find("button:first").hide();
    $("#calcBaseFeeRate").find(".modal-body").find("ul:first").hide();
  } else if (toggle === "commonTotalFee") {
    $("#normalHeader").hide();
    $("#mixedHeader").show();
    $("#calcBaseFeeRate").find(".modal-body").find("button:first").show();
    $("#calcBaseFeeRate").find(".modal-body").find("ul:first").show();
    $("#calcBaseExp").remove();
    let $textarea = $("<textarea>").attr("id", "calcBaseExp").prop("rows", 2).addClass("form-control").css("resize", "none");
    $("#expArea").prepend($textarea);
  }
}
//综合合价弹出计算基数费率确认
$("#calcBaseFeeRateConf").click(function () {
  let toggle = $(this).attr("toggle");
  if (!toggle || toggle !== "commonTotalFee") {
    return;
  }
  let calcBaseValue = calcBaseView.getInputExpr() ? calcBaseView.getInputExpr() : "";
  let selected = projectObj.project.mainTree.selected;
  let needToSave = false,
    validateFeeRate = false,
    cusFeeRate = false;
  if ($("input[name='editFeeRateOptions']:checked").val() == "0") {
    //等于”0“ 是自定义输入,删除费率关联ID，直接取值
    let newVal = null;
    if ($("#customFeeRate").val() != "") {
      newVal = number_util.checkNumberValue($("#customFeeRate").val(), getDecimal("feeRate"));
      if (newVal == null) return;
    }
    selected.updateData.feeRateID = null;
    selected.updateData.feeRate = newVal;
    selected.changed = true;
    needToSave = true;
    cusFeeRate = true;
  } else {
    validateFeeRate = feeRateObject.checkSelectedFeeRate();
  }
  if (calcBaseValue !== selected.data.calcBase) {
    needToSave = true;
    selected.data.userCalcBase = calcBaseValue;
    selected.updateData.lockUnitPrice = null;
    projectObj.project.calcBase.calculate(selected);
  }
  if (validateFeeRate) {
    feeRateObject.submitFeeRateFromBill();
  } else {
    if (calcBaseValue === calcBaseValue) {
      $("#calcBaseFeeRate").modal("hide");
    }
  }
  //删除清单基数，要清空费用
  if (projectObj.project.calcBase.success && calcBaseValue === "") {
    calcTools.clearFees(selected);
  }
  if (!projectObj.project.calcBase.success && cusFeeRate == false) {
    return;
  } else if ((!validateFeeRate || selected.data.feeRateID === parseInt(feeRateObject.feeRateSelection.ID)) && needToSave) {
    projectObj.project.calcProgram.calcAndSave(selected);
    $("#calcBaseFeeRate").modal("hide");
  }
});

$("#menu_calc_program_manage").click(function () {
  $("#tab_calc_program_manage").click();
});

$("#mainNav").on("click", " li a", function (e) {
  projectObj.project.projectMarkChecking();
});

// 清单限价
$(".limit-price-input").bind("input", function () {
  const limitType = $(this).data("limit");
  const orgVal = limitType === "max" ? projectObj.project.property.maxPriceRate || 0 : projectObj.project.property.minPriceRate || 0;
  try {
    const val = $(this).val();
    if (isNaN(val)) {
      throw "只能输入两位小数数值！";
    }
    const splits = val.split(".");
    const decimalDigits = (splits[1] && splits[1].length) || 0;
    if (decimalDigits > 2) {
      const roundVal = scMathUtil.roundForObj(val, 2);
      $(this).val(roundVal);
    }
  } catch (err) {
    alert(err);
    $(this).val(orgVal);
  }
});