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

/**
 * Created by CSL on 2017-05-12.
 */

var gljOprObj = {
  sheet: null,
  libID: null,
  ration: null,
  sheetData: [],
  checkb: null,
  rationGljEditObj: null, //编辑定额工料机还没提交的缓存数据
  cancelUpdate: true,
  mainTreeSelectedChange: false,
  detailSheet: null,
  detailData: [],
  GLJSelection: [],
  selectedGLJClass: null,
  parentNodeIds: {},
  preActiveTab: "", //提升焦点变换性能 2019年4月15日
  activeTab: "#linkGLJ",
  rationTab: "#linkGLJ",
  billsTab: "#linkGCLMX",
  setting: {},
  detailSetting: {
    header: [
      {
        headerName: "名称",
        headerWidth: 100,
        dataCode: "name",
        dataType: "String",
      },
      {
        headerName: "计算式",
        headerWidth: 120,
        dataCode: "regex",
        dataType: "String",
      },
      {
        headerName: "结果（C）",
        headerWidth: 120,
        dataCode: "result",
        dataType: "Number",
        decimalField: "quantity_detail",
      },
      {
        headerName: "累加",
        headerWidth: 120,
        dataCode: "isSummation",
        dataType: "String",
        cellType: "checkBox",
      },
      {
        headerName: "图号及备注",
        headerWidth: 120,
        dataCode: "memo",
        dataType: "String",
      },
    ],
    view: {
      lockColumns: [2, 3],
      rowHeaderWidth: 25,
    },
  },
  gljTreeSetting: {
    view: {
      expandSpeed: "",
      selectedMulti: false,
    },
    edit: {
      enable: false,
      editNameSelectAll: true,
      showRemoveBtn: true,
      showRenameBtn: true,
      removeTitle: "删除节点",
      renameTitle: "更改名称",
    },
    data: {
      keep: {
        parent: true,
        leaf: true,
      },
      key: {
        children: "items",
        name: "Name",
      },
      simpleData: {
        enable: false,
        idKey: "ID",
        pIdKey: "ParentID",
        rootPId: -1,
      },
    },
    callback: {
      onClick: function (event, treeId, treeNode) {
        if (treeId == "gljTree") {
          let me = gljOprObj,
            gljTypeId = treeNode.ID;
          if (treeNode.ID) {
            me.gljCurTypeId = treeNode.ID;
            me.filterLibGLJSheetData();
            me.showLibGLJSheetData();
            gljOprObj.initSelection({
              row: me.gljLibSheet.getActiveRowIndex(),
            });
          }
        } else {
          if (treeNode.isParent) {
            $("#class_selected_conf").attr("disabled", "disabled");
            $("#selected_class").val("");
          } else {
            $("#class_selected_conf").removeAttr("disabled");
            $("#selected_class").val(treeNode.ID);
          }
        }
      },
    },
  },
  gljLibSheetSetting: {
    owner: "gljTree",
    header: [
      {
        headerName: "选择",
        headerWidth: 40,
        dataCode: "select",
        hAlign: "center",
        vAlign: "center",
        cellType: "checkBox",
      },
      {
        headerName: "编码",
        headerWidth: 80,
        dataCode: "code",
        dataType: "String",
        formatter: "@",
        hAlign: "left",
        vAlign: "center",
      },
      {
        headerName: "名称",
        headerWidth: 160,
        dataCode: "name",
        dataType: "String",
        hAlign: "left",
        vAlign: "center",
      },
      {
        headerName: "规格型号",
        headerWidth: 160,
        dataCode: "specs",
        dataType: "String",
        hAlign: "left",
        vAlign: "center",
      },
      {
        headerName: "单位",
        headerWidth: 40,
        dataCode: "unit",
        dataType: "String",
        hAlign: "center",
        vAlign: "center",
      },
      {
        headerName: "单价",
        headerWidth: 55,
        dataCode: "basePrice",
        dataType: "Number",
        formatter: "0.00",
        hAlign: "right",
        vAlign: "center",
      },
      {
        headerName: "类型",
        headerWidth: 60,
        dataCode: "gljType",
        dataType: "String",
        hAlign: "center",
        vAlign: "center",
      },
      {
        headerName: "新增",
        headerWidth: 40,
        dataCode: "isComplementary",
        dataType: "String",
        hAlign: "center",
        vAlign: "center",
        cellType: "checkBox",
      },
    ],
    view: {
      lockColumns: [0, 1, 2, 3, 4, 5, 6],
    },
  },
  gljLibSheet: null,
  scopeSetting: {},
  scopeSpread: null,
  scopeSheet: null,
  scopeDatas: [],
  scopeSelectedIDMap: {},
  initSheet: function (sheet, name = "ration_glj") {
    var me = this;
    me.sheet = sheet;
    sheetCommonObj.initSheet(me.sheet, me.setting, 30);
    sheet.name(name);
    me.bindSheetEvent(sheet);
    sheet.bind(GC.Spread.Sheets.Events.CellDoubleClick, me.onCellDoubleClick);
    sheet.bind(GC.Spread.Sheets.Events.ClipboardChanged, me.onClipboardChanged);
    subSpread.bind(GC.Spread.Sheets.Events.ButtonClicked, me.onButtonClick);
    if (!projectReadOnly) {
      gljContextMenu.loadGLJSpreadContextMenu();
      me.bindGLJEnterKey(subSpread, sheet);
    }
    sheet.bind(
      GC.Spread.Sheets.Events.SelectionChanged,
      me.onRationGLJSelectionChange
    );
    sheet.bind(GC.Spread.Sheets.Events.CellClick, function () {
      //这里主要记录是否点击了sheet以外的地方，如果点击了sheet里的单元格，则将cancelUpdate设置为true不触发提交更新操作
      me.cancelUpdate = true; //取消延时任务由selection change 事件处理
    });
  },
  onRationGLJSelectionChange: function (sender, args) {
    let me = gljOprObj;
    let selected = args.newSelections[0]
      ? args.newSelections[0]
      : { row: 0, col: 0 };
    //这主要记录是否点击了sheet以外的地方，如果点击了sheet里的单元格，则将cancelUpdate设置为true不触发提交更新操作
    me.cancelUpdate = true; //取消延时任务由这里进行判断处理
    me.sheetInitSelection(selected);
    if (me.rationGljEditObj) {
      if (ifNeedUpdate(selected)) {
        me.updateGljFromCache();
      }
    }

    function ifNeedUpdate(selected) {
      let navigationRightCol = me.setting.navigationRightCol,
        fieldID = me.setting.header[selected.col].dataCode;
      if (
        me.rationGljEditObj.row == selected.row &&
        navigationRightCol.indexOf(fieldID) != -1
      ) {
        //如果换行或者超出了三个编辑列，则提交更新
        return false;
      }
      return true;
    }
  },
  updateGljFromCache: function () {
    let me = this;
    if (me.rationGljEditObj) {
      projectObj.project.ration_glj.submitChange(
        me.rationGljEditObj.recode,
        me.rationGljEditObj.doc
      );
    }
    me.rationGljEditObj = null;
  },
  bindGLJEnterKey: function (spread, sheet) {
    let me = this;
    subSpread.commandManager().register("myEnter", enterKeyAction);
    subSpread
      .commandManager()
      .setShortcutKey(
        null,
        GC.Spread.Commands.Key.enter,
        false,
        false,
        false,
        false
      );
    subSpread
      .commandManager()
      .setShortcutKey(
        "myEnter",
        GC.Spread.Commands.Key.enter,
        false,
        false,
        false,
        false
      );

    function enterKeyAction(spd, sheeName) {
      let editRow = sheet.getActiveRowIndex(),
        orgCol = sheet.getActiveColumnIndex();
      let fieldID = me.setting.header[orgCol].dataCode;
      if (
        sheeName == "ration_glj" &&
        me.setting.navigationRightCol.indexOf(fieldID) != -1
      ) {
        if (sheet.isEditing()) sheet.endEdit();
        GC.Spread.Sheets.Commands.navigationRight.execute(spd, sheeName);
      } else {
        GC.Spread.Sheets.Commands.commitInputNavigationDown.execute(
          spd,
          sheeName
        );
      }
    }
  },
  sheetInitSelection: function (selected) {
    let me = gljOprObj;
    let style = {};
    if (selected.row < me.sheetData.length) {
      if (me.setting.getStyle)
        style = me.setting.getStyle(me.sheetData[selected.row]);
      me.sheet.setStyle(selected.row, -1, me.getSelStyle(true, style));
    }
    me.sheet.repaint();
    if (me.preGljSelection && me.preGljSelection.row !== selected.row) {
      if (me.setting.getStyle && me.preGljSelection.row < me.sheetData.length)
        style = me.setting.getStyle(me.sheetData[me.preGljSelection.row]);
      me.sheet.setStyle(
        me.preGljSelection.row,
        -1,
        me.getSelStyle(false, style)
      );
    }
    me.preGljSelection = selected;
  },
  initDetailSheet: function (sheet) {
    var me = this;
    me.detailSheet = sheet;
    sheetCommonObj.initSheet(me.detailSheet, me.detailSetting, 30);
    // me.detailSheet.selectionUnit(0);//0 cell,1 row,2 col;
    sheet.name("quantity_detail");
    me.bindSheetEvent(sheet);
  },
  detailSheetReadonly: function () {
    let selected = projectObj.project.mainTree.selected;
    let Bills = projectObj.project.Bills;
    if (selected) {
      //清单锁定时只读
      if (
        selected.sourceType == ModuleNames.bills &&
        projectObj.project.isBillsLocked() &&
        projectObj.project.withinBillsLocked(selected)
      ) {
        return true;
      }
      //大项费用、分部节点层次时，工程量明细只读。
      if (
        indicativeInfoObj.isDXFY(selected) ||
        indicativeInfoObj.isFB(selected)
      ) {
        return true;
      }
      //是主材或者是设备时只读
      if (selected.sourceType == ModuleNames.ration_glj) {
        return true;
      } else if (gljOprObj.isInstallationNode(selected)) {
        //是补项或者是安装类型的定额时只读
        return true;
      }
      return false;
    }
    return true;
  },
  bindSheetEvent: function (sheet) {
    var me = this;
    sheet.bind(GC.Spread.Sheets.Events.ClipboardPasting, me.onClipboardPasting);
    sheet.bind(GC.Spread.Sheets.Events.ClipboardPasted, me.onClipboardPasted);
    sheet.bind(GC.Spread.Sheets.Events.EditEnded, me.onEditEnded);
    sheet.bind(GC.Spread.Sheets.Events.RangeChanged, me.onRangeChanged);
    sheet.bind(GC.Spread.Sheets.Events.EditStarting, me.startEditChecking);
    // sheet.bind(GC.Spread.Sheets.Events.CellClick, me.onCellClick);
  },
  onClipboardPasting: function (sender, args) {
    var me = gljOprObj;
    if (
      args.sheetName != "quantity_detail" &&
      (args.cellRange.rowCount != 1 || args.cellRange.colCount != 1)
    ) {
      //工程量明细做特殊处理
      args.cancel = true;
    }
  },
  onClipboardPasted: function (e, info) {
    var me = gljOprObj;
    console.log("past");
    //  if (!me.ration) {return;};
    // your code...
  },
  startEditChecking: function (sender, args) {
    let me = gljOprObj;
    let selected = projectObj.project.mainTree.selected;
    if ($.bootstrapLoading.isLoading()) args.cancel = true;
    if (selected) {
      if (me.isInstallationNode(selected) == true) {
        args.cancel = true;
      } else {
        if (args.sheetName == "quantity_detail") {
          //工程量明细表
          if (me.detailSheetReadonly()) {
            args.cancel = true;
          } else {
            if (args.sheet.getValue(args.row, args.col) == null) {
              //这里是为了解决当单元格里的值是null的时候，在单元格里输入数据，按键盘箭头移动光标的时候，会直接结束编辑，跳到另外的单元格。
              args.sheet.setValue(args.row, args.col, "");
            }
          }
        }
        if (args.sheetName == "ration_glj") {
          //定额工料机表
          if (!me.rationGLJEditCheck(args)) args.cancel = true;
        }
      }
    } else {
      args.cancel = true;
    }
  },
  isInstallationNode: function (node) {
    if (
      node.sourceType == ModuleNames.ration &&
      node.data.type == rationType.install
    ) {
      //是定额安装费类型时只读，原先是补项的时候也是控制只读的||(node.sourceType == ModuleNames.bills&&node.data.type==billType.BX)){//是定额安装费类型或者补项
      return true;
    }
    return false;
  },
  onEditEnded: function (sender, args) {
    var me = gljOprObj;
    if (args.sheetName == "ration_glj") {
      me.onEditGLJSheet(args);
    }
    if (args.sheetName == "quantity_detail") {
      me.onEditDetailSheet(args);
    }
  },
  onEditDetailSheet: function (args, callback) {
    var me = gljOprObj;
    if (args.row > me.detailData.length) {
      return;
    }
    if (args.row == me.detailData.length && args.editingText == null) {
      return;
    }
    var selected = projectObj.project.mainTree.selected; //因为使用了延时方法，所以要先取得选中行;
    var detailList = me.detailData;
    if (args.editingText) {
      args.editingText = args.editingText.replace(/（/g, "("); //替换中文左右括号;
      args.editingText = args.editingText.replace(/）/g, ")");
    }
    if (args.row == detailList.length) {
      projectObj.project.quantity_detail.saveQuantityDetail(
        args,
        me.detailSetting.header[args.col].dataCode,
        selected,
        callback
      );
    }
    if (args.row < detailList.length) {
      projectObj.project.quantity_detail.updateQuantityDetail(
        args,
        me.detailSetting.header[args.col].dataCode,
        detailList[args.row],
        selected,
        callback
      );
    }
  },
  onEditGLJSheet: function (args) {
    var me = gljOprObj;
    if (args.row >= me.sheetData.length) {
      me.sheet.getCell(args.row, args.col).value(null);
      return;
    }
    me.updateRationGLJ(args);
  },
  onSelectionChanged: function (sender, args) {
    let me = gljOprObj;
    me.initSelection(
      args.newSelections.length > 0
        ? { row: args.newSelections[0].row }
        : { row: 0 }
    );
  },
  getSelStyle: function (selected, settingStyle, rcolor) {
    let style = new GC.Spread.Sheets.Style();
    if (settingStyle) {
      for (let key in settingStyle) {
        style[key] = settingStyle[key];
      }
    }
    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
    );
    let colorOpts = optionsOprObj.getOption(
      optionsOprObj.optionsTypes.COLOROPTS
    );
    if (!colorOpts) colorOpts = { SELECTED: { backColor: "#FFFACD" } };
    let selectedColor = colorOpts.SELECTED.backColor,
      recColor = rcolor ? rcolor : "White";
    style.backColor = selected ? selectedColor : recColor;
    return style;
  },
  initSelection: function (sel) {
    let me = gljOprObj;
    if (sel) {
      sel.row = !sel.row || sel.row == -1 ? 0 : sel.row;
      me.gljLibSheet.setStyle(sel.row, -1, me.getSelStyle(true));
    }
    if (me.preGljLibSelection && me.preGljLibSelection.row !== sel.row) {
      me.gljLibSheet.setStyle(
        me.preGljLibSelection.row,
        -1,
        me.getSelStyle(false)
      );
    }
    me.preGljLibSelection = sel;
  },
  onButtonClick: function (sender, args) {
    if (args.sheet.isEditing()) {
      args.sheet.endEdit();
    }
    var me = gljOprObj;
    var sheet = args.sheet,
      row = args.row,
      col = args.col;
    var cellType = sheet.getCellType(row, col);
    if (cellType instanceof GC.Spread.Sheets.CellTypes.Button) {
      if (args.sheetName == "rationInstallSheet") {
        installationFeeObj.onPositionButtonClick(sender, args);
      }
    } else {
      me.onCheckBoxClick(sender, args);
    }
  },
  onCheckBoxClick: function (sender, args) {
    if (typeof projectObj != "undefined") {
      let selected = projectObj.project.mainTree.selected;
      if (selected.sourceType == ModuleNames.ration_glj) {
        //选中的是工料机时不可编辑
        return;
      }
      if (gljOprObj.isInstallationNode(selected) == true) {
        return;
      }
    }
    let checkboxValue = args.sheet.getCell(args.row, args.col).value();
    if (args.sheetName == "rationInstallSheet" && checkboxValue) {
      return;
    }
    let newval = checkboxValue ? 0 : 1;
    args.sheet.getCell(args.row, args.col).value(newval);
    if (args.sheetName == "ration_glj") {
      gljOprObj.updateIsEstimate(args, newval);
    } else if (args.sheetName == "quantity_detail") {
      projectObj.project.quantity_detail.isSummationUpdate(
        args,
        gljOprObj.detailData,
        newval
      );
    } else if (args.sheetName == "glj_lib") {
      if (gljOprObj.gljLibSheetSetting.header[args.col].dataCode === "select") {
        gljOprObj.setGLJSelection(args, newval);
      }
    } else if (args.sheetName == "rationInstallSheet") {
      args.newValue = newval;
      installationFeeObj.onRationInstallValueChange(sender, args);
    }
  },
  onCellDoubleClick: function (sender, args) {
    // 含组成物的材料市场价改为只读,改为双击无反应不提示
    /*  var me = gljOprObj;
         var header = me.setting.header;
         if (args.row >= me.sheetData.length) {
         return;
         }
         if (header[args.col] && header[args.col].dataCode == 'marketPrice') {
         if(me.hasComposition(me.sheetData[args.row])){
         alert("当前工料机的市场价由组成物计算得出，不可直接修改。");
         }
         }
         if (header[args.col] && header[args.col].dataCode == 'basePrice') {
         var isAdd = me.sheetData[args.row].isAdd;
         if(isAdd==1){//是新增但没有组成物时允许修改定额价
         if(me.hasComposition(me.sheetData[args.row])){//如果有组成物，不可修改
         alert("当前工料机的定额价由组成物计算得出，不可直接修改。");
         }
         }
         }*/
  },
  onClipboardChanged: function (sender, info) {
    let cDatas = sheetCommonObj.getTableData(info.sheet, null);
    sheetCommonObj.copyTextToClipboard(cDatas);
    return;
  },
  rationGLJEditCheck: function (args) {
    //true 可以编辑，false 不能编辑
    let me = gljOprObj,
      header = me.setting.header;
    let dataCode =
        header[args.col] && header[args.col].dataCode
          ? header[args.col].dataCode
          : null,
      recode = me.sheetData[args.row];
    if (me.sheet.getTag(args.row, args.col) == "locked") return false; //如果是双击树节点编号里设置了锁定标记，不能编辑
    if (_.includes(me.setting.view.lockColumns, args.col)) return false; //如果是锁定的列，不能编辑
    if (recode != undefined) {
      if (recode.isMixRatio) {
        //对于组成物列
        return dataCode == "marketPrice"; //允许修改组成物市单价,其它的不可以
      } else {
        if (dataCode && dataCode == "marketPrice") {
          return !me.marketPriceReadOnly({ data: me.sheetData[args.row] });
        }
        if (dataCode && dataCode == "basePrice") {
          var isAdd = recode.isAdd;
          if (isAdd == 1) {
            //是新增但没有组成物时允许修改定额价
            return !me.marketPriceReadOnly({ data: recode }); //如果有组成物，不可修改
          } else {
            return false;
          }
        }
        if (
          me.isExtraType(recode.type) &&
          (dataCode == "name" || dataCode == "specs" || dataCode == "unit")
        ) {
          //人材机窗口中的“企业管理费”“利润”“一般风险费”的名称、规格、单位改为只读。
          return false;
        }
        return true;
      }
    } else {
      return false;
    }
  },
  hasComposition: function (ration_glj, isRationType) {
    //判断是否有组成物，有则返回true   现在主材类型的工料机也有可能有组成物。
    return gljUtil.hasComposition(ration_glj, isRationType);
  },
  onRangeChanged: function (sender, args) {
    var me = gljOprObj;
    if (args.sheetName == "quantity_detail") {
      me.batchUpdateQuantityDetail(args);
    } else {
      if (args.action == GC.Spread.Sheets.RangeChangedAction.clear) {
        args.editingText = null;
      } else if (args.action == GC.Spread.Sheets.RangeChangedAction.paste) {
        args.editingText = args.sheet.getCell(args.row, args.col).value();
      } else {
        return;
      }
      if (args.sheetName == "ration_glj") {
        me.onEditGLJSheet(args);
      }
    }
  },
  batchUpdateQuantityDetail: function (args) {
    let me = gljOprObj;
    let updateArray = [];
    for (let i = 0; i < args.changedCells.length; i++) {
      let c = args.changedCells[i];
      let tem = {
        row: c.row,
        col: c.col,
        editingText: args.sheet.getCell(c.row, c.col).text(),
        sheet: args.sheet,
        sheetName: args.sheetName,
        index: i,
      };
      updateArray.push(tem);
    }
    if (updateArray.length > 0) {
      updateArray.length == 1
        ? me.onEditDetailSheet(updateArray[0])
        : me.onEditDetailSheet(updateArray[0], updateCallback);
    }

    function updateCallback(i_args) {
      let index = i_args.index;
      if (index < updateArray.length - 1) {
        let nextIndex = index + 1;
        updateArray[nextIndex].replace = i_args.replace;
        if (nextIndex == updateArray.length - 1) {
          //是最后一个，则不用调callback了
          me.onEditDetailSheet(updateArray[nextIndex]);
        } else {
          me.onEditDetailSheet(updateArray[nextIndex], updateCallback);
        }
      }
    }
  },
  showDataIfRationSelect: function (node, selectedNodeId) {
    this.sheet.suspendPaint();
    this.sheet.suspendEvent();
    var isShow = false;
    if (projectReadOnly && this.setting.view.lockColumns) {
      this.setting.view.lockColumns = null;
    }
    if (selectedNodeId) {
      this.selectedNodeId = selectedNodeId;
    }
    if (node) {
      if (this.selectedNodeId && this.selectedNodeId == node.getID()) {
        return;
      } else {
        //恢复底色
        this.sheet.setStyle(
          this.sheet.getActiveRowIndex(),
          -1,
          this.getSelStyle(false, this.setting.style)
        );
        this.selectedNodeId = node.getID();
      }
      if (node.sourceType == "ration") {
        if (node.data.type == rationType.gljRation) {
          if ($("#linkGLJ").hasClass("active")) this.showMixRatio(node);
          subObj.showGljSubTabData();
        } else {
          if ($("#linkGLJ").hasClass("active")) {
            this.showRationGLJData(node);
            subObj.showGljSubTabData();
            // MaterialController.showReplaceDiv(node);
          }
          if ($("#linkAZZJF").hasClass("active"))
            installationFeeObj.showRationInstallationData(node);
          if ($("#linkMBZM").hasClass("active")) mbzm_obj.showMBZMData(node);
        }
        isShow = true;
      }
      if (node.sourceType == ModuleNames.ration_glj) {
        if ($("#linkGLJ").hasClass("active")) this.showMixRatio(node);
        MaterialController.hideReplaceDiv();
        isShow = true;
      }
      if ($("#linkGCLMX").hasClass("active")) this.showQuantityDetailData(node);
    } else {
      this.selectedNodeId = null;
    }
    if (!isShow) {
      this.clearSheetData();
      MaterialController.hideReplaceDiv();
    }
    this.sheet.resumeEvent();
    this.sheet.resumePaint();
  },
  showMixRatio: function (node) {
    //显示组成物到定额工料机
    let mixRatioMap = projectObj.project.projectGLJ.datas.mixRatioMap;
    let projectGljs = projectObj.project.projectGLJ.datas.gljList;
    let indexArray =
      node.sourceType == ModuleNames.ration ? rationKeyArray : gljKeyArray;
    let connect_index = this.getIndex(node.data, indexArray);
    let gljList = [];
    if (mixRatioMap[connect_index]) {
      //说明是有组成物的类型
      gljList = this.getMixRationShowDatas(
        mixRatioMap[connect_index],
        projectGljs
      );
    }
    if (gljList.length > 0) {
      //计算总消耗量
      if (node.sourceType == ModuleNames.ration) {
        this.calcMixRationTotalQuantity(gljList, node.data.quantity);
      } else {
        let totalQuantity = this.getTotalQuantity(node.data);
        this.calcMixRationTotalQuantity(gljList, totalQuantity);
      }
    }
    this.sheetData = gljList;
    this.sheet.setRowCount(0);
    this.sheetData = gljUtil.sortRationGLJ(this.sheetData);
    this.sheet.getRange(-1, 0, -1, 1).cellType(this.getTreeNodeCellType([]));
    sheetCommonObj.showData(this.sheet, this.setting, this.sheetData);
    //初始选择
    this.preGljSelection = null;
    this.sheetInitSelection({ row: this.sheet.getActiveRowIndex(), col: 0 });
    this.sheet.getRange(-1, 0, -1, this.setting.header.length).locked(true); //锁住定额工料机的所有列
    this.detailSheet
      .getRange(-1, 0, -1, this.detailSetting.header.length)
      .locked(true); //锁住工程量明细的所有列
  },
  showRationGLJData: function (node) {
    let gljList = [];
    let ration_glj = projectObj.project.ration_glj;
    node = node ? node : projectObj.project.mainTree.selected;
    if (node.sourceType == ModuleNames.ration) {
      if (node.data.type == rationType.gljRation) {
        this.showMixRatio(node);
      } else {
        let ration = node.data;
        gljList = this.filterGljByRation(ration, ration_glj.datas);
        this.showInSheet(gljList);
      }
    } else if (node.sourceType == ModuleNames.ration_glj) {
      this.showMixRatio(node);
    }
  },
  showRationGLJSheetData: function (init) {
    let me = this;
    let selected = this.sheet.getSelections();
    this.combineWithProjectGlj(this.sheetData);
    this.sheet.setRowCount(0);
    this.sheetData = gljUtil.sortRationGLJ(this.sheetData);
    this.sumQuantity(); //计算总消耗量
    this.addMixRatioToShow(); //显示组成物信息
    this.initRationTree(init, this.getUnitPriceCodeMap());
    sheetCommonObj.showData(
      this.sheet,
      this.setting,
      this.sheetData,
      null,
      function () {
        if (me.mainTreeSelectedChange == true) {
          me.sheet.setSelection(0, 1, 1, 1); //默认选中第一行，第二列（名称列）
          me.mainTreeSelectedChange = false;
        } else if (selected) {
          //定位光标到之前的位置
          me.sheet.setSelection(
            selected[0].row,
            selected[0].col,
            selected[0].rowCount,
            selected[0].colCount
          );
        }
        //初始选择
        me.preGljSelection = null;
        me.sheetInitSelection({
          row: me.sheet.getActiveRowIndex(),
          col: me.sheet.getActiveColumnIndex(),
        });
      }
    );
  },
  getSelectedRationGlj: function () {
    let selected = this.sheet.getSelections()[0];
    let ration_glj = this.sheetData[selected.row];
    return ration_glj;
  },
  getUnitPriceCodeMap: function () {
    //取单价文件中，编码前缀一样的映射表
    let codeMap = {};
    let priceMap = projectObj.project.projectGLJ.datas.unitPriceMap;
    if (priceMap) {
      for (let connectKey in priceMap) {
        let code = priceMap[connectKey].code;
        let name = priceMap[connectKey].name;
        let specs = priceMap[connectKey].specs;
        if (code) {
          let displayText = code + " " + name + " " + specs;
          let preCode = code.split("-")[0];
          if (codeMap[preCode]) {
            codeMap[preCode].push({ text: displayText, value: connectKey });
          } else {
            codeMap[preCode] = [{ text: displayText, value: connectKey }];
          }
        }
      }
    }
    return codeMap;
  },
  initRationTree: function (init, codeMap) {
    this.sheet.suspendPaint();
    this.sheet.suspendEvent();
    this.sheet.setRowCount(
      this.sheetData.length > 30 ? this.sheetData.length : 30
    );
    for (var i = 0; i < this.sheetData.length; i++) {
      let options = this.getCodeOptions(this.sheetData[i], codeMap);
      this.sheet.setCellType(
        i,
        0,
        this.getTreeNodeCellType(this.sheetData, options),
        GC.Spread.Sheets.SheetArea.viewport
      );
      if (this.sheetData[i].hasOwnProperty("subList")) {
        var collapsed =
          this.sheetData[i].collapsed == undefined
            ? true
            : this.sheetData[i].collapsed;
        if (collapsed == true) {
          this.sheet
            .getRange(i + 1, -1, this.sheetData[i].subList.length, -1)
            .visible(false);
        }
      }
    }
    this.sheet.resumeEvent();
    this.sheet.resumePaint();
  },
  getCodeOptions: function (recode, codeMap) {
    let options = [];
    if (recode.isMixRatio === true) {
      return null;
    }
    let code = recode.code;
    if (code) {
      let preCode = code.split("-")[0];
      if (codeMap[preCode]) options = codeMap[preCode];
      if (options.length > 0)
        _.remove(options, { value: gljOprObj.getIndex(recode, gljKeyArray) }); //去掉本身
    }
    return _.sortBy(options, "text");
  },
  filterGljByRation: function (ration, datas) {
    var gljList = [];
    if (datas && datas.length > 0) {
      gljList = _.filter(datas, { rationID: ration.ID });
    }
    return gljList;
  },
  showInSheet: function (gljList) {
    this.sheetData = gljList;
    this.showRationGLJSheetData(true);
  },
  sumQuantity: function (node) {
    if (this.sheetData.length > 0) {
      node = node ? node : projectObj.project.mainTree.selected;
      let ration = node.data;
      for (let glj of this.sheetData) {
        glj.totalQuantity = this.getTotalQuantity(glj, ration);
      }
    }
  },
  getTotalQuantity: function (glj, ration) {
    if (glj.isMixRatio == true) return; //如果是用于显示的组成物，则不用计算，跳过
    ration = ration
      ? ration
      : _.find(projectObj.project.Ration.datas, { ID: glj.rationID });
    glj.totalQuantity = gljUtil.getTotalQuantity(
      glj,
      ration,
      getDecimal("ration.quantity"),
      getDecimal("glj.quantity")
    );
    if (glj.hasOwnProperty("subList")) {
      //需要计算glj下挂的组成物的总消耗量
      this.calcMixRationTotalQuantity(glj.subList, glj.totalQuantity);
    }
    return glj.totalQuantity;
  },
  calcMixRationTotalQuantity(mList, pTotal) {
    //计算组成物的总消耗量
    for (let subG of mList) {
      subG.rationItemQuantity = scMathUtil.roundForObj(
        subG.rationItemQuantity,
        getDecimal("glj.quantity")
      );
      subG.totalQuantity =
        scMathUtil.roundForObj(
          subG.rationItemQuantity * pTotal,
          getDecimal("glj.quantity")
        ) + "";
    }
  },
  addMixRatioToShow: function () {
    var newList = [];
    _.remove(this.sheetData, { isMixRatio: true });
    for (var i = 0; i < this.sheetData.length; i++) {
      newList.push(this.sheetData[i]);
      if (this.sheetData[i].hasOwnProperty("subList")) {
        newList = newList.concat(this.sheetData[i].subList);
      }
    }
    this.sheetData = newList;
  },
  combineWithProjectGlj: function (
    ration_gljs,
    needRatio = true,
    ration,
    p_gljMap
  ) {
    let projectGLJData = projectObj.project.projectGLJ.datas;
    let projectGljs = projectGLJData.gljList;
    let mixRatioMap = projectGLJData.mixRatioMap;
    if (
      ration_gljs &&
      ration_gljs.length > 0 &&
      projectGljs &&
      projectGljs.length > 0
    ) {
      let pgljMap = p_gljMap ? p_gljMap : _.indexBy(projectGljs, "id");
      for (let i = 0; i < ration_gljs.length; i++) {
        let glj = pgljMap[ration_gljs[i].projectGLJID];
        if (glj) {
          if (
            projectObj.project.projectGLJ.isEstimateType(ration_gljs[i].type)
          ) {
            ration_gljs[i].isEstimate = glj.is_evaluate;
          }
          ration_gljs[i].shortName =
            projectObj.project.projectGLJ.getShortNameByID(ration_gljs[i].type);
          ration_gljs[i].isAdd = glj.unit_price.is_add;
          ration_gljs[i] = this.setGLJPrice(ration_gljs[i], glj, false); //设置工料机价格
          let connect_index = this.getIndex(glj, gljKeyArray);
          if (needRatio == true && mixRatioMap.hasOwnProperty(connect_index)) {
            let mixRatios = this.getMixRationShowDatas(
              mixRatioMap[connect_index],
              projectGljs
            );
            ration_gljs[i].subList = mixRatios;
          }
          if (needRatio == false) {
            //不需要组成物的情况，目前应该是复制整块那里用到，这里加上毛重系数等信息，一起复制
            ration_gljs[i].grossWeightCoe = glj.unit_price.grossWeightCoe;
            ration_gljs[i].purchaseStorageRate =
              glj.unit_price.purchaseStorageRate;
            ration_gljs[i].offSiteTransportLossRate =
              glj.unit_price.offSiteTransportLossRate;
            ration_gljs[i].handlingLossRate = glj.unit_price.handlingLossRate;
          }

          if (ration) gljOprObj.getTotalQuantity(ration_gljs[i], ration);
        } else {
          //计算程序中量价也会放到这里进来，量价是没有对应的项目工料机的
          //if(ration_gljs[i].type != rationType.volumePrice) console.log("没有找到工料机："+ration_gljs[i].name)
        }
      }
    }
    return ration_gljs;
  },
  setGLJPrice: function (data, glj, isRadio = false, ext) {
    //isRadio 标记是否算组成物的价格
    let proGLJ = projectObj.project.projectGLJ;
    let calcOptions = projectObj.project.projectInfo.property.calcOptions;
    let decimalObj = projectObj.project.projectInfo.property.decimal;
    let labourCoeDatas = projectObj.project.labourCoe.datas;
    glj = glj ? glj : _.find(proGLJ.datas.gljList, { id: data.projectGLJID });
    if (glj) {
      let tenderCoe = projectObj.project.projectGLJ.getTenderPriceCoe(glj);
      let result = gljUtil.getGLJPrice(
        glj,
        proGLJ.datas,
        calcOptions,
        labourCoeDatas,
        decimalObj,
        isRadio,
        _,
        scMathUtil,
        ext,
        tenderCoe
      );
      data.marketPrice = result.marketPrice;
      data.basePrice = result.basePrice;
      data.adjustPrice = result.adjustPrice;
      data.marketUnitFee = data.marketPrice; //更新树节点市场单价列的值
      data.tenderPrice = result.tenderPrice;
    }
    return data;
  },

  getBasePrice: function (treeNode) {
    //造价书中的工料机修改的节点要用到
    let proGLJ = projectObj.project.projectGLJ;
    let glj = _.find(proGLJ.datas.gljList, { id: treeNode.data.projectGLJID });
    if (this.calcPriceDiff(glj) == true) {
      return proGLJ.getBasePrice(glj);
    } else {
      return scMathUtil.roundForObj(
        treeNode.data.marketUnitFee,
        getDecimal("glj.unitPrice")
      );
    }
  },
  getMarketPrice: function (treeNode) {
    //造价书中的工料机修改的节点要用到
    let proGLJ = projectObj.project.projectGLJ;
    let glj = _.find(proGLJ.datas.gljList, { id: treeNode.data.projectGLJID });
    return proGLJ.getMarketPrice(glj);
  },
  calcPriceDiff: function (glj) {
    let calcOptions = projectObj.project.projectInfo.property.calcOptions;
    return gljUtil.calcPriceDiff(glj, calcOptions);
  },
  getIndex(obj, pops) {
    return gljUtil.getIndex(obj, pops);
  },
  getConditionByKey(conKey) {
    //将连接字符串转换成对象
    let valueArray = conKey.split("|-|");
    let obj = {};
    for (let i = 0; i < valueArray.length; i++) {
      if (valueArray[i] != "null") {
        if (gljKeyArray[i] == "type") {
          valueArray[i] = parseInt(valueArray[i]);
        }
        obj[gljKeyArray[i]] = valueArray[i];
      }
    }
    return obj;
  },
  getMixRationShowDatas: function (mixRatioList, projectGljs) {
    var temRationGLJs = [];
    for (var i = 0; i < mixRatioList.length; i++) {
      let mIndex = gljOprObj.getIndex(mixRatioList[i], gljKeyArray);
      let pgljMap = projectObj.project.projectGLJ.datas.gljMap;
      let pg = null;
      if (pgljMap) {
        pg = pgljMap[mIndex];
      }
      if (!pg) {
        pg = _.find(projectGljs, function (item) {
          return gljOprObj.getIndex(item, gljKeyArray) == mIndex;
        }); //改关联关系
      }
      if (pg) {
        let tem = {
          projectGLJID: pg.id,
          code: pg.code,
          name: pg.name,
          specs: pg.specs,
          unit: pg.unit,
          type: mixRatioList[i].type,
          shortName: projectObj.project.projectGLJ.getShortNameByID(
            mixRatioList[i].type
          ),
          consumption: mixRatioList[i].consumption,
          rationItemQuantity: mixRatioList[i].consumption,
          // quantity:mixRatioList[i].consumption,
          /*  basePrice: pg.unit_price.base_price,
                     marketPrice: pg.unit_price.market_price,
                     adjustPrice: pg.adjust_price,*/
          //isEstimate: pg.is_evaluate,
          isMixRatio: true,
          isAdd: pg.unit_price.is_add,
          GLJID: pg.glj_id,
        };
        if (projectObj.project.projectGLJ.isEstimateType(pg.type)) {
          tem.isEstimate = pg.is_evaluate;
        }
        this.setGLJPrice(tem, pg);
        temRationGLJs.push(tem);
      } else {
        console.log("没有找到工料机：" + mIndex);
      }
    }
    temRationGLJs = gljUtil.sortMixRatio(temRationGLJs);
    return temRationGLJs;
  },
  showQuantityDetailData: function (node) {
    node = node ? node : projectObj.project.mainTree.selected;
    var quantity_detail = projectObj.project.quantity_detail;
    let field = node.sourceType == ModuleNames.ration ? "rationID" : "billID";
    let details = quantity_detail.getListByID(node.data.ID, field);
    sheetCommonObj.showData(this.detailSheet, this.detailSetting, details);
    this.detailData = details;
    if (MainTreeCol.readOnly.forQuantifyDetail(node)) {
      this.detailSheet
        .getRange(-1, 0, -1, this.detailSetting.header.length)
        .locked(true);
    }
  },
  clearSheetData: function () {
    if ($("#linkGLJ").hasClass("active")) {
      sheetCommonObj.showData(this.sheet, this.setting, []);
    }
    if ($("#linkAZZJF").hasClass("active")) {
      installationFeeObj.rationInstallSheet.setRowCount(0); //清除combobox cell
      sheetCommonObj.showData(
        installationFeeObj.rationInstallSheet,
        installationFeeObj.rationInstallSetting,
        []
      );
    }
    //  sheetCommonObj.showData(this.detailSheet,this.detailSetting,[]);
    this.sheetData = [];
    installationFeeObj.rationInstallData = [];
    //this.detailData=[];
  },
  updateRationGLJ: function (args) {
    var me = this;
    var updateField = me.setting.header[args.col].dataCode;
    var recode = me.sheetData[args.row];
    var newval;
    if (!me.rationGLJEditCheck(args)) {
      recode
        ? me.sheet.getCell(args.row, args.col).value(recode[updateField])
        : me.sheet.getCell(args.row, args.col).value(null);
      return;
    }
    if (args.editingText) {
      args.editingText = args.editingText.replace(/[\r\n]/g, ""); //去掉回车换行等字符;
      me.sheet.getCell(args.row, args.col).value(args.editingText);
    }
    if (
      updateField == "marketPrice" ||
      updateField == "customQuantity" ||
      updateField == "basePrice"
    ) {
      if (args.editingText == null) {
        updateField == "marketPrice" ? (newval = 0) : (newval = "");
      } else {
        var decimal =
          updateField == "customQuantity" ? getDecimal("glj.quantity") : 6; //对于市场价和定额价，这里只是中间的小数位数，后面更新前会根据有没有组成物再取值
        newval = number_util.checkNumberValue(args.editingText, decimal);
        if (newval == null) {
          me.sheet.getCell(args.row, args.col).value(recode[updateField]);
          return;
        }
      }
    } else {
      if (updateField == "name" || updateField == "unit") {
        if (args.editingText === null) {
          alert(me.setting.header[args.col].headerName + "不能为空!");
          me.sheet.getCell(args.row, args.col).value(recode[updateField]);
          return;
        }
      }
      if (updateField == "code") {
        if (
          !gljUtil.isDef(args.editingText) ||
          args.editingText == "" ||
          args.editingText.indexOf("|-|") === -1 ||
          this.isRationGLJExit(args.editingText)
        ) {
          //说明是选中自已，或者是已存在的工料机
          me.sheet.getCell(args.row, args.col).value(recode[updateField]);
          return;
        }
      }
      newval = args.editingText == null ? "" : args.editingText;
    }
    if (newval === recode[updateField]) {
      //如果值完全相等，则不需要更新
      return;
    }
    if (updateField == "marketPrice" || updateField == "basePrice") {
      projectObj.project.projectGLJ.updatePriceFromRG(
        recode,
        updateField,
        newval
      );
    } else if (updateField == "code") {
      //替换单价文件中已经有的工料机
      projectObj.project.ration_glj.updateRationGLJByChangeCode(
        recode,
        updateField,
        newval
      );
    } else if (me.setting.navigationRightCol.indexOf(updateField) != -1) {
      //对于名称、规格、单位先跳到下一列，保存至缓存
      me.setToEditCache(recode, updateField, newval, args);
    } else {
      projectObj.project.ration_glj.updateRationGLJByEdit(
        recode,
        updateField,
        newval
      );
    }
  },
  setToEditCache: function (recode, updateField, value, args) {
    let me = this;
    if (me.rationGljEditObj == null) {
      me.rationGljEditObj = {
        recode: recode,
        doc: {},
        row: args.row,
      };
      me.rationGljEditObj.doc[updateField] = value;
    } else {
      if (me.rationGljEditObj.recode.ID == recode.ID) {
        //确保编辑的是同一条数据
        me.rationGljEditObj.doc[updateField] = value;
      }
    }
  },
  isRationGLJExit: function (connectKey) {
    for (let rg of gljOprObj.sheetData) {
      if (rg.isMixRatio == true) {
        continue;
      }
      if (gljOprObj.getIndex(rg, gljKeyArray) == connectKey) {
        //存在一样的工料机
        return true;
      }
    }
    return false;
  },
  updateRationTypeGLJ: function (value, node, fieldName, editingText) {
    let newval;
    let updatePrice = false;
    if (
      fieldName == "marketUnitFee" ||
      fieldName == "feesIndex.common.unitFee"
    ) {
      updatePrice = true;
      if (value == null) {
        newval = 0;
      } else {
        var decimal = getDecimal("glj.unitPrice");
        newval = number_util.checkNumberValue(value, decimal);
      }
    } else {
      if (value != null) {
        projectObj.project.projectGLJ.updatePropertyFromMainSpread(
          node,
          fieldName,
          value,
          editingText
        );
        return;
      }
    }
    if (newval && updatePrice == true) {
      projectObj.project.projectGLJ.updatePriceFromRG(
        node.data,
        "marketPrice",
        newval
      );
      return;
    }
    projectObj.mainController.refreshTreeNode([node]);
  },
  updateIsEstimate: function (args, newval) {
    var me = gljOprObj;
    if (me.setting.header[args.col].dataCode == "isEstimate") {
      var pspread = new ProjectGLJSpread();
      var recode = me.sheetData[args.row];
      let projectGljs = projectObj.project.projectGLJ.datas.gljList;
      let glj = _.find(projectGljs, { id: recode.projectGLJID });
      if (glj) {
        glj["is_evaluate"] = newval;
        args.fromRG = true;
        pspread.postUpdate(
          recode.projectGLJID,
          "is_evaluate",
          newval,
          args,
          null,
          successTrigger
        );
      }
    }
  },
  showLibGLJSheetData: function () {
    //this.gljLibSheetData = _.sortBy(this.gljLibSheetData, 'code');
    sheetCommonObj.showData(
      this.gljLibSheet,
      this.gljLibSheetSetting,
      this.gljLibSheetData,
      gljOprObj.distTypeTree
    );
    this.gljLibSheet.setRowCount(this.gljLibSheetData.length);
  },
  filterLibGLJSheetData: function () {
    let me = this;
    const selectLibID = $("#glj-lib-select").val();
    const cptLibReg = new RegExp(commonConstants.COMPLEMENTARY_LIB);
    me.gljLibSheetData = cptLibReg.test(selectLibID)
      ? me.complementaryGLJs
      : me.stdGLJ;
    if (
      $("#actionType").val() == "replace" ||
      $("#actionType").val() == "m_replace"
    ) {
      me.filterLibGLJByType();
    } else if (
      $("#actionType").val() == "addMix" ||
      $("#actionType").val() == "unitPriceAddMix"
    ) {
      projectGljObject.filterLibGLJForMixRatio();
    }
    //文本筛选
    let searchStr = $("#gljSearchKeyword").val();
    if (searchStr && searchStr.trim() != "") {
      let reg = new RegExp(searchStr);
      me.gljLibSheetData = _.filter(me.gljLibSheetData, function (data) {
        return reg.test(data.code) || reg.test(data.name);
      });
    }
    if (me.gljCurTypeId == undefined) {
      return;
    }
    if (me.parentNodeIds["_pNodeId_" + me.gljCurTypeId]) {
      me.gljLibSheetData = _.filter(me.gljLibSheetData, function (n) {
        return _.includes(
          me.parentNodeIds["_pNodeId_" + me.gljCurTypeId],
          n.gljClass
        );
      });
    } else {
      me.gljLibSheetData = _.filter(me.gljLibSheetData, {
        gljClass: me.gljCurTypeId,
      });
    }
  },
  setGLJSelection: function (args, newVal) {
    if (
      $("#actionType").val() == "add" ||
      $("#actionType").val() == "insert" ||
      $("#actionType").val() == "insertEquipment" ||
      $("#actionType").val() == "addMix" ||
      $("#actionType").val() == "unitPriceAddMix"
    ) {
      this.addGLJsSelection(args, newVal);
    } else {
      this.replaceGLJSelection(args, newVal);
    }
  },
  addGLJsSelection: function (args, newVal) {
    var con_key = this.getIndex(this.gljLibSheetData[args.row], gljLibKeyArray);
    if (newVal == 1) {
      this.GLJSelection.push(con_key);
      this.gljLibSheetData[args.row].select = 1;
    } else if (newVal == 0) {
      _.pull(this.GLJSelection, con_key);
      this.gljLibSheetData[args.row].select = 0;
    }
  },
  replaceGLJSelection: function (args, newVal) {
    var me = this;
    var oldSelection = this.GLJSelection[0];
    if (newVal == 0) {
      args.sheet.getCell(args.row, args.col).value(1);
      return;
    }
    this.GLJSelection = [
      me.getIndex(this.gljLibSheetData[args.row], gljLibKeyArray),
    ];
    this.gljLibSheetData[args.row].select = 1;
    var oindex = _.findIndex(this.gljLibSheetData, function (item) {
      var i_key = me.getIndex(item, gljLibKeyArray);
      return oldSelection == i_key;
    });
    if (oindex != -1) {
      args.sheet.getCell(oindex, args.col).value(0);
      this.gljLibSheetData[oindex].select = 0;
    } else {
      var oldData = _.find(gljOprObj.AllRecode, function (item) {
        var i_key = me.getIndex(item, gljLibKeyArray);
        return oldSelection == i_key;
      });
      oldData ? (oldData.select = 0) : "";
    }
  },
  filterLibGLJByType: function () {
    var me = this;
    var selected = me.sheetData[gljContextMenu.selectedRow];
    let materialTypes = [
      gljType.CONCRETE,
      gljType.MORTAR,
      gljType.MIX_RATIO,
      gljType.COMMERCIAL_CONCRETE,
      gljType.COMMERCIAL_MORTAR,
    ]; //混凝土、砂浆、配合比、商品混凝土、商品砂浆
    let normalTypes = [
      gljType.GENERAL_MATERIAL,
      gljType.PURCHASE_COMPONENT,
      gljType.GREEN_SEEDLING,
    ]; //普通材料、外购砼构件、绿化苗木;
    let filterTypes = [selected.type];
    //当前人材机类型是“混凝土、砂浆、配合比、商品混凝土、商品砂浆”时，筛选的可替换的人材机类型应是“混凝土、或砂浆、或配合比、或商品混凝土、或商品砂浆”。
    if (materialTypes.includes(selected.type)) filterTypes = materialTypes;
    //当前人材机类型是普通材料、外购砼构件、绿化苗木
    if (normalTypes.includes(selected.type)) filterTypes = normalTypes;
    me.gljLibSheetData = _.filter(me.gljLibSheetData, function (data) {
      return filterTypes.includes(data.gljType);
    });
  },
  getComboData: function (gljDistType) {
    let me = this;
    let distType;
    let distTypeTree = {
      prefix: "gljType",
      distTypes: {},
      comboDatas: [],
      distTypesArr: [],
    };
    gljDistType.forEach(function (typeData) {
      let typeObj = {
        data: typeData,
        children: [],
        parent: null,
      };
      distTypeTree.distTypes[distTypeTree.prefix + typeData.ID] = typeObj;
      distTypeTree.distTypesArr.push(typeObj);
    });
    gljDistType.forEach(function (typeData) {
      distType = distTypeTree.distTypes[distTypeTree.prefix + typeData.ID];
      let parent =
        distTypeTree.distTypes[distTypeTree.prefix + typeData.ParentID];
      if (parent) {
        distType.parent = parent;
        parent.children.push(distType);
      }
    });
    distTypeTree.distTypesArr.forEach(function (distTypeObj) {
      if (
        distTypeObj.data.fullName !== "材料" &&
        distTypeObj.data.fullName !== "机械"
      ) {
        distTypeTree.comboDatas.push({
          text: distTypeObj.data.fullName,
          value: distTypeObj.data.ID,
        });
      }
    });
    return distTypeTree;
  },
  doInsertGLJ: function (insertType) {
    var me = this;
    var selected = projectObj.project.mainTree.selected;
    var project = projectObj.project;
    if (me.GLJSelection.length <= 0) {
      return;
    }
    $.bootstrapLoading.start();
    project.ration_glj.insertGLJAsRation(
      me.GLJSelection,
      selected,
      insertType,
      function (parentNodeID, nextNodeID, data) {
        let newNode = null;
        for (let r_glj of data) {
          r_glj.quantity = r_glj.quantity + "";
          project.Ration.datas.push(r_glj);
        } //要先更新树节点工程量，加载项目工料机并计算消耗量才有值
        project.projectGLJ.loadData(function () {
          for (let r_glj of data) {
            r_glj = me.setGLJPrice(r_glj); //设置工料机价格
            newNode = project.mainTree.insert(
              parentNodeID,
              nextNodeID,
              r_glj.ID
            );
            newNode.source = r_glj;
            newNode.sourceType = project.Ration.getSourceType();
            newNode.data = r_glj;
            ProjectController.syncDisplayNewNode(
              projectObj.mainController,
              newNode
            );
          }
          project.calcProgram.calcLeafAndSave(newNode.parent); //计算父级清单的所有子节点
          projectObj.mainController.refreshTreeNode([newNode]);
          if (me.hasComposition(newNode.data, true)) {
            me.showMixRatio(newNode);
          } else {
            me.showRationGLJSheetData();
          }
          projectObj.refreshBaseActn(project.mainTree);
          $.bootstrapLoading.end();
        });
      }
    );
  },
  doAddGLJ: function () {
    var selected = projectObj.project.mainTree.selected;
    var project = projectObj.project;
    gljOprObj.GLJSelection = _.filter(gljOprObj.GLJSelection, function (n) {
      var rg = _.find(gljOprObj.sheetData, function (item) {
        if (item.isMixRatio == true) {
          return false;
        }
        var i_key = gljOprObj.getIndex(item, gljKeyArray);
        return n == i_key;
      });
      return rg ? false : true;
    });
    if (
      gljOprObj.GLJSelection.length > 0 &&
      selected &&
      selected.sourceType == ModuleNames.ration
    ) {
      project.ration_glj.addGLJByLib(
        gljOprObj.GLJSelection,
        selected.data,
        function (result) {
          if (result) {
            selected.data.adjustState = result.adjustState;
            project.ration_glj.datas = project.ration_glj.datas.concat(
              result.newRecodes
            ); //显示和缓存统一，这样的话就不用更新两个位置了
            //project.ration_glj.datas = project.ration_glj.datas.concat(result.showData);
            //gljOprObj.sheetData = gljOprObj.sheetData.concat(result.showData);
            project.projectGLJ.loadNewProjectGLJToCaches(
              result.projectGLJList,
              true
            );
            project.ration_glj.addToMainTree(result.showData); //组成物不会显示到造价书页面
            project.calcProgram.calcAndSave(selected);
            projectObj.mainController.refreshTreeNode([selected]);
            gljOprObj.refreshView();
            $.bootstrapLoading.end();
          }
        }
      ); //doc.rationID=selected.data.ID;
    }
  },
  concreteTypeReplaceChecking: function (selectCode, oldData, selected) {
    //selected为空，表示批量替换   混凝土替换前的检查，是否给出确认提示
    let allGLJ = gljOprObj.AllRecode;
    let glj = _.find(allGLJ, function (item) {
      let i_key = gljOprObj.getIndex(item, gljLibKeyArray);
      return i_key == selectCode;
    });
    if (!glj) return false;
    if (gljUtil.isConcreteToCommercialConcrete(oldData.type, glj.gljType)) {
      //被替换的是混凝土，替换成商品砼或商品砂浆
      if (selected) {
        //如果有选中的，说明是替换，还要判断是否有辅助定额， 批量替换不用判断
        return selected.data.rationAssList &&
          selected.data.rationAssList.length > 0
          ? true
          : false;
      }
      return true;
    }
    return false;
  },
  replaceGLJConfirm: function (mreplace = false) {
    let me = this;
    let oldData = me.sheetData[gljContextMenu.selectedRow];
    let selectCode = gljOprObj.GLJSelection[0];
    let selected =
      mreplace == true ? null : projectObj.project.mainTree.selected;
    if (me.concreteTypeReplaceChecking(selectCode, oldData, selected)) {
      hintBox.infoBox(
        "操作确认",
        "请先调整厚度，再替换商品砼。确定要继续吗？",
        2,
        function () {
          mreplace == true
            ? $("#mreplace_next_div").modal("show")
            : me.doReplaceGLJ(selectCode, oldData, selected);
        },
        null,
        ["确定", "取消"],
        false
      );
    } else {
      mreplace == true
        ? $("#mreplace_next_div").modal("show")
        : me.doReplaceGLJ(selectCode, oldData, selected);
    }
  },
  doReplaceGLJ: function (selectCode, oldData, selected, is) {
    let me = this;
    let project = projectObj.project;
    let oldType = oldData.type;
    project.ration_glj.replaceGLJ(selectCode, oldData, function (result) {
      if (result) {
        //result.adjustState;
        project.ration_glj.setDatasAfterReplace(result);
        let data = result.data;
        let nodes = [selected];
        let node = project.ration_glj.updateGLJNodeAfterReplace(data);
        if (node) nodes.push(node);
        /*if (project.ration_glj.needShowToTree(data)) {//当替换的是主材或设备时，刷新对应的树节点
                 var node = project.ration_glj.findGLJNodeByID(data.ID);
                 if (node) {
                 project.ration_glj.transferToNodeData(data);
                 node.source = data;
                 node.data = data;
                 }
                 node ? nodes.push(node) : "";
                 }*/
        //project.ration_glj.addToMainTree(data);
        selected.data.adjustState = result.adjustState;
        selected.data.name = result.name;
        projectObj.mainController.refreshTreeNode(nodes);
        project.calcProgram.calcAndSave(selected, function () {
          me.replaceProgramInfo(oldType, result.projectGLJ.type);
        });
        gljOprObj.refreshView();
        $.bootstrapLoading.end();
      }
    });
  },

  replaceProgramInfo: function (oldType, newType) {
    //检查是否由混凝土替换为商品砼或者商品砂浆
    if (gljUtil.isConcreteToCommercialConcrete(oldType, newType)) {
      const showCompilations1 = [
        "浙江养护(2005)",
        "内蒙古养护(2019)",
        "内蒙古高速公路养护(2022)",
        "安徽养护(2018)",
        "山东养护(2016/2024)",
      ];
      const showMsg1 = "请手动修改取费类别为构造物III";
      const showCompilations2 = ["广西养护(2020)", "广西日常养护(2020)"];
      const showMsg2 = "请手动修改取费类别为商混及外构件";
      const showCompilations3 = ["河南养护(2022)", "河南日常养护(2022)"];
      const showMsg3 = "请手动修改取费类别为商品混凝土及外构件";

      if (showCompilations1.includes(compilationName)) {
        // 隐藏，不显示
      } else if (showCompilations2.includes(compilationName)) {
        setTimeout(() => {
          alert(showMsg2);
        }, 300);
      } else if (showCompilations3.includes(compilationName)) {
        setTimeout(() => {
          alert(showMsg3);
        }, 300);
      } else {
        setTimeout(() => {
          alert(showMsg1);
        }, 300);
      }
    }
  },

  doMReplaceGLJ: function () {
    let me = this;
    let project = projectObj.project;
    let oldData = me.sheetData[gljContextMenu.selectedRow];
    let selectCode = gljOprObj.GLJSelection[0];
    let oldType = oldData.type;
    project.ration_glj.mReplaceGLJ(
      selectCode,
      oldData,
      function (result, updateMap) {
        if (result == null) {
          return;
        }
        let data = result.data;
        let stateList = result.stateList;
        //let n_index = me.getIndex(data.query, gljKeyArray);
        let nodes = [];
        let quantityMap = {};
        for (let gr of result.glj_result) {
          quantityMap[gr.query.ID] = gr.doc;
        }
        //添加\删除混凝土组成物定额工料机
        project.ration_glj.addAndDeleteDatas(
          result.newRecodes,
          result.deleteList
        );
        _.forEach(project.ration_glj.datas, function (t) {
          //     let t_index = me.getIndex(t, gljKeyArray);
          if (updateMap[t.ID]) {
            if (updateMap[t.ID].code) me.updateProperty(t, data.doc); //说明这条不是只更新自定义消耗量的，才要更新项目工料机
            me.updateProperty(t, updateMap[t.ID]);
            if (project.ration_glj.needShowToTree(t)) {
              //如果是造价书中的树节点，则也须刷新
              project.ration_glj.transferToNodeData(t);
              var node = project.ration_glj.findGLJNodeByID(t.ID);
              node ? nodes.push(node) : "";
            }
          }
          if (quantityMap[t.ID]) {
            //更新消耗量
            me.updateProperty(t, quantityMap[t.ID]);
          }
        });
        project.projectGLJ.loadNewProjectGLJToCaches([result.projectGLJ], true);
        var rationNodes = me.refreshStateAfterMreplace(stateList, nodes);
        project.calcProgram.calcNodesAndSave(rationNodes, function () {
          me.replaceProgramInfo(oldType, result.projectGLJ.type);
        });
        me.refreshView();
        $.bootstrapLoading.end();
      }
    );
  },
  updateProperty: function (obj, doc) {
    gljUtil.updateProperty(obj, doc);
  },
  refreshStateAfterMreplace: function (stateList, gljNodes) {
    let nodes = [];
    let rationNodes = [];
    _.forEach(stateList, function (s) {
      let node = _.find(projectObj.project.mainTree.items, function (n) {
        return n.sourceType == ModuleNames.ration && n.data.ID == s.rationID;
      });
      if (node) {
        node.data.adjustState = s.adjustState;
        node.data.name = s.name;
        nodes.push(node);
        rationNodes.push(node);
      }
    });
    gljNodes.length > 0 ? (nodes = nodes.concat(gljNodes)) : "";
    projectObj.mainController.refreshTreeNode(nodes);
    return rationNodes;
  },
  refreshView: function () {
    let node = projectObj.project.mainTree.selected;
    this.showDataIfRationSelect(node, "111111");
  },
  refreshTreeNode: function (obj) {
    if (!obj) {
      return;
    }
    let objectArray = [];
    let nodes = [];
    if (obj instanceof Array) {
      objectArray.concat(obj);
    } else {
      objectArray.push(obj);
    }
    for (let o of objectArray) {
      let node = this.updateDataNodeProperty(o.ID, o.data);
      if (node) {
        nodes.push(node);
      }
    }
    projectObj.mainController.refreshTreeNode(nodes);
    return nodes;
  },
  updateDataNodeProperty: function (nodeID, data) {
    let node = projectObj.project.mainTree.findNode(nodeID);
    if (node) {
      for (let k in data) {
        node.data[k] = data[k];
      }
    }
    return node;
  },
  getTreeNodeCellType: function (data, comboboxOptions) {
    let ns = GC.Spread.Sheets;
    let rectW = 10;
    let rectH = 10;
    let margin = 3;

    function TreeNodeCellType() {
      this.ctx = null;
    }
    TreeNodeCellType.prototype = comboboxOptions
      ? sheetCommonObj.getDynamicCombo()
      : new ns.CellTypes.Text();
    TreeNodeCellType.prototype.paint = function (
      ctx,
      value,
      x,
      y,
      w,
      h,
      style,
      options
    ) {
      this.ctx = ctx;
      if (style.backColor) {
        //先画背景色
        ctx.save();
        ctx.fillStyle = style.backColor;
        ctx.fillRect(x, y, w, h);
        ctx.restore();
      } else {
        ctx.clearRect(x, y, w, h);
      }
      if (value != null) {
        let offset = margin + rectW + 6;
        let recode = data[options.row];
        if (recode && recode.hasOwnProperty("subList")) {
          sheetCommonObj.drowRect(ctx, x, y, w, h, rectW, rectH, margin);
          let collapsed =
            recode.collapsed == undefined ? true : recode.collapsed; //options.sheet.getTag(options.row,options.col);
          sheetCommonObj.drowSymbol(
            ctx,
            x,
            y,
            w,
            h,
            rectW,
            rectH,
            margin,
            collapsed
          );
        } else if (recode && recode.isMixRatio) {
          let hasNext =
            data[options.row + 1] && data[options.row + 1].isMixRatio;
          offset = sheetCommonObj.drowSubItem(ctx, x, y, w, h, offset, hasNext);
          offset += 1;
        }
        arguments[2] = x + offset;
        arguments[4] = w - offset;
        //x = x + offset;
        //w = w - offset;
        GC.Spread.Sheets.CellTypes.Text.prototype.paint.apply(this, arguments);
      }
    };
    TreeNodeCellType.prototype.getHitInfo = function (
      x,
      y,
      cellStyle,
      cellRect,
      context
    ) {
      if (x < cellRect.x + cellRect.width - 15) {
        //这里要判断点击的位置来决定return的内容，不能直接用combobox的方法
        return {
          x: x,
          y: y,
          row: context.row,
          col: context.col,
          cellStyle: cellStyle,
          cellRect: cellRect,
          sheetArea: context.sheetArea,
        };
      } else {
        return GC.Spread.Sheets.CellTypes.ComboBox.prototype.getHitInfo.apply(
          this,
          arguments
        );
      }
    };
    TreeNodeCellType.prototype.processMouseDown = function (hitinfo) {
      let recode = data[hitinfo.row];
      if (hitinfo.x < hitinfo.cellRect.x + hitinfo.cellRect.width - 15) {
        hitinfo.sheet.setTag(hitinfo.row, hitinfo.col, "locked"); //通过这个来控制除了点击下拉框的三角形，点击其它地方不充许进入编辑状态，不然不好控制下拉框超出页面后调整滚动条
      }
      if (recode && recode.hasOwnProperty("subList")) {
        let hoffset = hitinfo.cellRect.x + 3;
        if (hitinfo.x > hoffset && hitinfo.x < hoffset + 10) {
          let collapsed =
            recode.collapsed == undefined ? true : recode.collapsed;
          collapsed = !collapsed;
          recode.collapsed = collapsed;
          //hitinfo.sheet.setTag(hitinfo.row,hitinfo.col,collapsed);
          hitinfo.sheet
            .getRange(hitinfo.row + 1, -1, recode.subList.length, -1)
            .visible(!collapsed);
          hitinfo.sheet.invalidateLayout();
          hitinfo.sheet.repaint();
          return;
        }
      }
      if (
        comboboxOptions &&
        hitinfo.x > hitinfo.cellRect.x + hitinfo.cellRect.width - 15
      ) {
        //点击了下拉框按钮，这里要判断下拉框是否会被挡住，从而决定是否自动调整滚动条
        hitinfo.sheet.setTag(hitinfo.row, hitinfo.col, "");
        sheetCommonObj.scrollSheetForOption(
          hitinfo.sheet,
          this.ctx,
          hitinfo.cellRect,
          hitinfo.row,
          comboboxOptions
        ); //下拉框超出显示后自动调整滚动条
        GC.Spread.Sheets.CellTypes.ComboBox.prototype.processMouseDown.apply(
          this,
          arguments
        );
      }
    };
    let cellType = new TreeNodeCellType();
    if (comboboxOptions) {
      cellType.editorValueType(
        GC.Spread.Sheets.CellTypes.EditorValueType.value
      );
      cellType.itemHeight(comboboxOptions.length).items(comboboxOptions);
    }
    return cellType;
  },
  marketPriceReadOnly: function (node) {
    let isRationType =
      node.sourceType == ModuleNames.ration &&
      node.data.type == rationType.gljRation;
    let type = isRationType == true ? node.data.subType : node.data.type;
    if (gljUtil.isConcreteType(type)) return true;
    return this.hasComposition(node.data, isRationType); //2018-9-14 需求变更暂估工料机也能修改市场价原语句：return hasCom|| node.data.isEstimate == 1
  },
  locateZTree: function (ID) {
    let zTree = $.fn.zTree.getZTreeObj("gljTree");
    let node = null;
    if (ID) node = zTree.getNodesByParam("ID", ID, null)[0];
    if (!node) {
      node = zTree.getNodeByTId("gljTree_1");
      ID = node.ID;
    }
    zTree.selectNode(node);
    gljOprObj.gljCurTypeId = ID;
    gljOprObj.filterLibGLJSheetData();
    gljOprObj.showLibGLJSheetData();
  },
  isExtraType: function (type) {
    return _.includes(gljUtil.extraType, type);
  },
  setNodeShowTab: function () {
    let node = projectObj.project.mainTree.selected;
    if (node && node.sourceType == ModuleNames.ration) {
      gljOprObj.rationTab = gljOprObj.activeTab;
    } else {
      gljOprObj.billsTab = gljOprObj.activeTab;
    }
  },
  //初始化分类树
  //@param {String}type(标准或补充) {Array}treeData(树数据)
  initClassTree: function (type, treeData, initSel = false) {
    let me = this;
    if (me.treeObj) {
      me.treeObj.destroy();
      me.parentNodeIds = {};
    }
    zTreeHelper.createTree(treeData, me.gljTreeSetting, "gljTree", me);
    if (initSel) {
      let rootNode = me.treeObj.getNodes()[0];
      if (rootNode && rootNode.isParent && rootNode.isFirstNode) {
        me.rootNode = rootNode;
      }
      if (me.rootNode) {
        me.treeObj.selectNode(me.rootNode);
        me.gljTreeSetting.callback.onClick(null, "gljTree", me.rootNode);
      }
    }
  },
  initScopeSpread: function () {
    if (this.scopeSpread) return this.scopeSpread.repaint();
    this.scopeSpread = SheetDataHelper.createNewSpread($("#scopeSpread")[0]);
    sheetCommonObj.spreadDefaultStyle(this.scopeSpread);
    this.scopeTree = idTree.createNew({
      id: "ID",
      pid: "ParentID",
      nid: "NextSiblingID",
      rootId: -1,
      autoUpdate: false,
    });
    this.scopeTreeController = TREE_SHEET_CONTROLLER.createNew(
      this.scopeTree,
      this.scopeSpread.getActiveSheet(),
      this.scopeSetting
    );
    this.scopeSheet = this.scopeSpread.getActiveSheet();
    this.scopeSpread.bind(
      GC.Spread.Sheets.Events.ButtonClicked,
      this.onScopeChecked
    );
  },
  showScopeDatas: function () {
    this.initScopeSpread();
    this.scopeDatas = this.getScopeDatas();
    this.scopeTree.loadDatas(this.scopeDatas);
    this.scopeTreeController.showTreeData();
  },
  getScopeDatas: function () {
    let controller = projectObj.mainController,
      project = projectObj.project;
    let allNodes = [],
      datas = [];
    for (let rootNode of controller.tree.roots) {
      allNodes.push(rootNode);
      controller.tree.getAllSubNode(rootNode.source, allNodes);
    }
    for (let n of allNodes) {
      let temData = {
        ID: n.data.ID,
        NextSiblingID: n.data.NextSiblingID,
        ParentID: n.data.ParentID,
        unit: n.data.unit,
        code: n.data.code,
        selected: 0,
        name: n.data.name,
        quantity: calcTools.uiNodeQty(n) ? calcTools.uiNodeQty(n) : "",
      };
      if (n.data.feesIndex && n.data.feesIndex.common) {
        temData.unitPrice = n.data.feesIndex.common.unitFee;
        temData.totalPrice = n.data.feesIndex.common.totalFee;
      }
      datas.push(temData);
    }
    return datas;
  },
  onScopeChecked: function (e, args) {
    let me = gljOprObj,
      nodes = [];
    var checkboxValue = args.sheet.getCell(args.row, args.col).value();
    var newval = checkboxValue ? 0 : 1;
    let node = me.scopeTree.items[args.row];
    setNodeAndChildreSelected(node, newval, nodes);
    me.scopeTreeController.refreshTreeNode(nodes);

    function setNodeAndChildreSelected(n, val, arr) {
      n.data.selected = val;
      nodes.push(n);
      for (let c of n.children) {
        setNodeAndChildreSelected(c, val, arr);
      }
    }
  },
  setScopeSelection: function () {
    for (let node of this.scopeTree.items) {
      //挑出选中数，过滤父节点
      if (node.data.selected == 1 && node.children.length == 0)
        this.scopeSelectedIDMap[node.data.ID] = true;
    }
  },
};

$(function () {
  $("#glj_tree_div").on("shown.bs.modal", function (e) {
    gljContextMenu.initGLJSelectView();
  });

  $("#mreplace_next_div").on("shown.bs.modal", function (e) {
    gljOprObj.scopeSelectedIDMap = {};
    gljOprObj.showScopeDatas();
  });

  $("#glj_tree_div").on("hidden.bs.modal", function () {
    $("#gljSearchKeyword").val("");
  });

  $(".glj-radio").change(function () {
    let val = $("input[name='glj']:checked").val();
    if (val == "allGljs") {
      gljOprObj.gljLibSheetData = gljOprObj.AllRecode;
      gljOprObj.filterLibGLJSheetData();
      gljOprObj.showLibGLJSheetData();
    } else {
      if (val === "stdGLJ") {
        gljOprObj.initClassTree("std", gljOprObj.treeData.std, true);
      } else {
        gljOprObj.initClassTree("comple", gljOprObj.treeData.comple, true);
      }
      gljOprObj.initSelection({ row: 0 });
    }
  });
  // 更改选择库
  $("#glj-lib-select").change(function () {
    let getLibFun = null;
    if (typeof unitPriceObj != "undefined")
      getLibFun = unitPriceObj.getGLJLibData;
    getGLJData("change", false, getLibFun);
  });
  /*    //工料机搜索
     $('#gljSearchKeyword').change(function () {
     gljOprObj.filterLibGLJSheetData();
     gljOprObj.showLibGLJSheetData();
     });
     $('#gljSearchKeyword').bind('keypress', function (e) {
     if(e.keyCode === 13){
     alert('2');
     $(this).blur();
     return false;
     }
     });*/
  $("#gljSearchKeyword").bind("keyup", function (e) {
    gljOprObj.filterLibGLJSheetData();
    gljOprObj.showLibGLJSheetData();
    gljOprObj.initSelection({ row: 0 });
  });

  $("#glj_selected_conf").click(function () {
    if (gljOprObj.GLJSelection.length < 1) {
      return;
    }
    if (["insert", "insertEquipment"].includes($("#actionType").val())) {
      //造价书页面中插入定额类型的工料机
      gljOprObj.doInsertGLJ($("#actionType").val());
    } else if ($("#actionType").val() == "add") {
      //添加工料机
      gljOprObj.doAddGLJ();
    } else if ($("#actionType").val() == "replace") {
      //替换工料机
      gljOprObj.replaceGLJConfirm(false);
    } else if ($("#actionType").val() == "m_replace") {
      //批量替换工料机
      gljOprObj.replaceGLJConfirm(true);
    } else if ($("#actionType").val() == "addMix") {
      projectGljObject.addMixRatio();
    } else if ($("#actionType").val() == "unitPriceAddMix") {
      unitPriceObj.addMixRatio();
    }
    $("#glj_tree_div").modal("hide");
  });
  $("#scope_position_confirm").click(function () {
    gljOprObj.setScopeSelection();
    gljOprObj.doMReplaceGLJ();
  });
  $("#replace_next_btn").click(function () {
    $("#glj_tree_div").modal("hide");
    gljOprObj.replaceGLJConfirm(true);
  });
  $("#class_selected_conf").click(function () {
    var gljClass = $("#selected_class").val();
    var glj = gljOprObj.selectedGLJClass;
    if (glj && gljClass && gljClass != "") {
      //保存到我的工料机库
      /*1 检查是否有组成物
       * 2 如果有，则检查组成物中是否有新增的记录，如果有，查看是否已经保存了，没有的话，要先添加组成物到补充工料机库
       * 3 保存
       * */
      var newItem = {
        code: glj.code,
        name: glj.name,
        specs: glj.specs,
        unit: glj.unit,
        basePrice: glj.basePrice,
        gljType: glj.type,
        shortName: glj.shortName,
        component: [],
        gljClass: gljClass,
      };
      if (glj.hasOwnProperty("subList") && glj.subList.length > 0) {
        //有组成物，检查组成物信息，目前组成物不允许修改，所以暂时不用考虑组成物是新增的情况
        for (var i = 0; i < glj.subList.length; i++) {
          let tem = {
            ID: glj.subList[i].GLJID,
            consumeAmt: glj.rationItemQuantity,
            isStd: true,
          };
          newItem.component.push(tem);
        }
      }
      var data = getcmpUpdateData([newItem]);
      $.bootstrapLoading.start();
      var callback = function (data) {
        $("#glj_class_div").modal("hide");
        $.bootstrapLoading.end();
      };
      CommonAjax.post(
        "complementartGlj/api/mixUpdateGljItems",
        data,
        callback,
        function () {
          $.bootstrapLoading.end();
        }
      );
    }
  });

  $("#glj_class_div").on("hidden.bs.modal", function (e) {
    gljOprObj.selectedGLJClass = null;
    $("#class_selected_conf").attr("disabled", "disabled");
    $("#selected_class").val("");
  });

  $("#subSpread").focusout(function (e) {
    //当本身或子元素失去焦点时这个事件都会发生，而且不好判断点击的是哪里。
    if (gljOprObj.rationGljEditObj) {
      gljOprObj.cancelUpdate = false;
      gljOprObj.timeStamp = e.timeStamp; //设置时间戳，有可能用户在表格上乱点，这个事件被触发多次
      setTimeout(function () {
        //延时执行提交操作，如果点击的是spread里的地方，会把cancelUpdate改成true,这样的话就不执行提交操作
        if (
          gljOprObj.timeStamp == e.timeStamp &&
          gljOprObj.cancelUpdate !== true
        ) {
          //时间戳要相同
          gljOprObj.updateGljFromCache();
        }
      }, 200);
    }
  });
  function getcmpUpdateData(items) {
    var data = {
      updateItems: [],
      removeIds: [],
    };
    data.addItems = items;
    return data;
  }
});

function operationWithRound(value1, value2, field, symble) {
  let decimal = getDecimal(field);
  value1 = scMathUtil.roundForObj(value1, decimal);
  value2 = scMathUtil.roundForObj(value2, decimal);
  let result;
  switch (symble) {
    case "+":
      result = scMathUtil.roundForObj(value1 + value2, decimal);
      break;
    case "-":
      result = scMathUtil.roundForObj(value1 - value2, decimal);
      break;
    case "*":
      result = scMathUtil.roundForObj(value1 * value2, decimal);
      break;
    case "/":
      result = scMathUtil.roundForObj(value1 / value2, decimal);
      break;
  }
  return result;
}

function getDecimal(fieldID, node) {
  if (node) {
    return decimalObj.decimal(fieldID, node);
  } else if (fieldID.indexOf(".") != -1) {
    var keyArray = fieldID.split(".");
    return decimalObj[keyArray[0]][keyArray[1]];
  } else {
    return decimalObj.decimal(fieldID);
  }
}

function compareRationGLJ(a, b) {
  if (a.type + "" < b.type + "") {
    return true;
  }
  if (a.type + "" == b.type + "") {
    if (a.code < b.code) {
      return true;
    }
  }
  return false;
}