Name

sn_sow.SOWInvestigationGridUtils

Description

No description available

Script

var SOWInvestigationGridUtils = Class.create();
SOWInvestigationGridUtils.prototype = {

  DEFAULT_CONFIG: {
      "fieldType": "string",
      "pageSize": 20,
      "pageIndex": 0,
      "enableSorting": false,
      "sortDirection": 'DESC',
      "enableFiltering": false,
      "enableRowSelection": false
  },

  SORT_FIELD: {},

  CONFIG: {},

  DATA: {
      columns: [],
      rowData: []
  },

  initialize: function() {

  },

  fetchData: function(sourceTable, sourceSysId, selectedCI, metricDefinition, metricFetchType) {
      if (!sourceTable && !sourceSysId && !selectedCI && !metricDefinition)
          return false;

      var data;
      var metricEngine = new sn_cimaf.CIMetricEngine();

      if (metricFetchType == "initial") {
          var sourceGr = this._getSourceGr(sourceTable, sourceSysId);
          if (!sourceGr) {
              return false;
          }
          data = metricEngine.getLastMetric(selectedCI, metricDefinition, this._metricWindowStartDate(sourceGr).getValue(), this._metricWindowEndDate(sourceGr).getValue());
      } else if (metricFetchType == "recent")
          data = metricEngine.getFirstMetric(selectedCI, metricDefinition);

      return data;
  },

  getConfiguration: function(definitionId, metricKey) {
      var investigationConfig = new SOWInvestigateConfig();
      var config = investigationConfig.getDefinitionConfig(definitionId);

      for (index in config.ITEMS) {
          if (config.ITEMS[index].KEY == metricKey) {
              return config.ITEMS[index];
          }
      }
  },

  compare: function(a, b) {
      var col = this.SORT_FIELD.columnName;
      var sortDirection = this.SORT_FIELD.sortDirection;

      var x = !gs.nil(a[col]) ? a[col] : "";
      var y = !gs.nil(b[col]) ? b[col] : "";

      if (x > y) {
          return sortDirection == "DESC" ? -1 : 1;
      } else if (x < y) {
          return sortDirection == "DESC" ? 1 : -1;
      }
      return 0;
  },

  getColumnDetails: function(columnName) {
      if (columnName) {
          for (index in this.DATA.columns) {
              if (this.DATA.columns[index].field == columnName) {
                  return index;
              }
          }
      }

      return -1;
  },

  sortData: function(sortField) {
      var sortDirection;
      var index = -1;

      if (sortField) {
          index = this.getColumnDetails(sortField.fieldName);
          sortDirection = sortField.sortDirection;
      } else if (this.CONFIG.DEFAULT_SORT_COLUMN) {
          index = this.getColumnDetails(this.CONFIG.DEFAULT_SORT_COLUMN);
          sortDirection = index != -1 ? this.DATA.columns[index].sortDirection : null;
      }

      if (index != -1) {
          this.SORT_FIELD = {
              columnName: this.DATA.columns[index].field,
              sortDirection: sortDirection
          };
      }

      if (index != -1 && this.SORT_FIELD) {

          this.DATA.rowData.sort(this.compare.bind(this));

          this.DATA.columns[index].isSorted = true;
          this.DATA.columns[index].isDescending = sortDirection == "DESC";
      }
  },

  paginateData: function(pageIndex, pageSize) {
      if (pageIndex == null) {
          pageIndex = this.DEFAULT_CONFIG.pageIndex;
      }

      if (pageSize == null) {
          pageSize = this.DEFAULT_CONFIG.pageSize;
      }

      var startIndex = pageIndex * pageSize;
      var endIndex = startIndex + pageSize;

      this.DATA.rowData = this.DATA.rowData.slice(startIndex, endIndex);
  },

  getColumns: function() {
      var columns = [];
      Object.keys(this.CONFIG.ATTRIBUTES).forEach(function(col) {
          var checkObject = typeof this.CONFIG.ATTRIBUTES[col] == "object";
          columns.push({
              'field': col,
              'title': checkObject && this.CONFIG.ATTRIBUTES[col].label || this.CONFIG.ATTRIBUTES[col],
              'type': checkObject && this.CONFIG.ATTRIBUTES[col].fieldType || this.DEFAULT_CONFIG.fieldType,
              'isSortable': this.CONFIG.ATTRIBUTES[col].isSortable || this.DEFAULT_CONFIG.enableSorting,
              'sortDirection': this.CONFIG.ATTRIBUTES[col].sortDirection || this.DEFAULT_CONFIG.sortDirection,
          });
      }.bind(this));

      return columns;
  },

  processRowData: function() {
      var rows = [];
      var rowLen = this.DATA.rowData.length;
      var columns = this.DATA.columns;
      var rowData = this.DATA.rowData;

      for (var i = 0; i < rowLen; i++) {
          var row = {};
          columns.forEach(function(col) {
              row[col.field] = {
                  value: !gs.nil(rowData[i][col.field]) ? rowData[i][col.field] : "",
                  displayValue: !gs.nil(rowData[i][col.field]) ? rowData[i][col.field] : gs.getMessage("(empty)")
              };
          });
          rows.push(row);
      }
      return rows;
  },

  getDataForUI: function(data, definitionId, metricKey, paginationControls, sortField) {

      var result = {
          header: {},
          body: {},
          paginationControls: {}
      };

      if (!data || !(data.payload && data.payload.length)) {
          return result;
      }

      var count = data.payload.length;
      this.CONFIG = this.getConfiguration(definitionId, metricKey);

      if (!this.CONFIG) {
          return result;
      }

      result.header = {
          title: this.CONFIG.HEADER,
          subTitle: data.timestamp.displayValue,
          count: count
      };

      result.paginationControls = {
          recordCount: count
      };

      this.DATA = {
          columns: this.getColumns(),
          rowData: data.payload
      };

      this.sortData(sortField);
      this.paginateData(paginationControls.pageIndex, paginationControls.pageSize);

      this.DATA.rowData = this.processRowData();

      result.body = this.DATA;
      return result;
  },

  _getMetricFetchWindowProp: function() {
      return gs.getProperty("sn_sow.initial_metric_fetch_window", 30);
  },

  _metricWindowEndDate: function(sourceGr) {
      var metricFetchWindow = this._getMetricFetchWindowProp();
      var incidentCreatedOn = sourceGr.getValue("sys_created_on");
      var endGdt = new GlideDateTime(incidentCreatedOn);
      endGdt.add(metricFetchWindow * 60 * 1000);
      return endGdt;
  },

  _metricWindowStartDate: function(sourceGr) {
      var metricFetchWindow = this._getMetricFetchWindowProp();
      var incidentCreatedOn = sourceGr.getValue("sys_created_on");
      var startGdt = new GlideDateTime(incidentCreatedOn);
      startGdt.add(metricFetchWindow * -1 * 60 * 1000);
      return startGdt;
  },

  _getSourceGr: function(table, sysId) {
      if (!table && !sysId)
          return null;
      var sourceGr = new GlideRecord(table);
      if (sourceGr.get(sysId))
          return sourceGr;
      return null;
  },

  type: 'SOWInvestigationGridUtils'
};

Sys ID

e0ff7be853ae11103eacddeeff7b1283

Offical Documentation

Official Docs: