dtable-utils 0.0.3 → 4.2.0

package/lib/filter/filter-row.js

@@ -0,0 +1,239 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('./core.js');
+var checkbox = require('./filter-column/checkbox.js');
+var collaborator = require('./filter-column/collaborator.js');
+var creator = require('./filter-column/creator.js');
+var date$1 = require('./filter-column/date.js');
+var digitalSign = require('./filter-column/digital-sign.js');
+var file = require('./filter-column/file.js');
+var formula = require('./filter-column/formula.js');
+var geolocation = require('./filter-column/geolocation.js');
+var text = require('./filter-column/text.js');
+var longText = require('./filter-column/long-text.js');
+var multipleSelect = require('./filter-column/multiple-select.js');
+var number = require('./filter-column/number.js');
+var singleSelect = require('./filter-column/single-select.js');
+var link = require('./filter-column/link.js');
+var index = require('../constants/filter/index.js');
+var date = require('../date.js');
+var cellType = require('../constants/cell-type.js');
+var column = require('../constants/column.js');
+
+var getFilterResult = function getFilterResult(row, filter, _ref) {
+  var formulaRow = _ref.formulaRow,
+    username = _ref.username,
+    userId = _ref.userId;
+  var column_key = filter.column_key,
+    column$1 = filter.column;
+  var cellValue = row[column_key];
+  switch (column$1.type) {
+    case cellType.CellType.CHECKBOX:
+      {
+        return checkbox.checkboxFilter(cellValue, filter);
+      }
+    case cellType.CellType.SINGLE_SELECT:
+      {
+        return singleSelect.singleSelectFilter(cellValue, filter);
+      }
+    case cellType.CellType.MULTIPLE_SELECT:
+      {
+        return multipleSelect.multipleSelectFilter(cellValue, filter);
+      }
+    case cellType.CellType.DURATION:
+    case cellType.CellType.NUMBER:
+    case cellType.CellType.RATE:
+      {
+        return number.numberFilter(cellValue, filter);
+      }
+    case cellType.CellType.DATE:
+      {
+        return date$1.dateFilter(cellValue, filter);
+      }
+    case cellType.CellType.CTIME:
+    case cellType.CellType.MTIME:
+      {
+        cellValue = date.DateUtils.format(cellValue, column.DATE_FORMAT_MAP.YYYY_MM_DD_HH_MM_SS);
+        return date$1.dateFilter(cellValue, filter);
+      }
+    case cellType.CellType.COLLABORATOR:
+      {
+        return collaborator.collaboratorFilter(cellValue, filter, username);
+      }
+    case cellType.CellType.LONG_TEXT:
+      {
+        return longText.longTextFilter(cellValue, filter);
+      }
+    case cellType.CellType.TEXT:
+    case cellType.CellType.AUTO_NUMBER:
+    case cellType.CellType.EMAIL:
+    case cellType.CellType.URL:
+      {
+        return text.textFilter(cellValue, filter, userId);
+      }
+    case cellType.CellType.IMAGE:
+    case cellType.CellType.FILE:
+      {
+        return file.fileFilter(cellValue, filter);
+      }
+    case cellType.CellType.LAST_MODIFIER:
+    case cellType.CellType.CREATOR:
+      {
+        return creator.creatorFilter(cellValue, filter, username);
+      }
+    case cellType.CellType.GEOLOCATION:
+      {
+        return geolocation.geolocationFilter(cellValue, filter);
+      }
+    case cellType.CellType.FORMULA:
+    case cellType.CellType.LINK_FORMULA:
+      {
+        cellValue = formulaRow[column_key];
+        return formula.formulaFilter(cellValue, filter, {
+          username: username,
+          userId: userId
+        });
+      }
+    case cellType.CellType.LINK:
+      {
+        cellValue = formulaRow[column_key];
+        cellValue = Array.isArray(cellValue) ? cellValue.map(function (linked) {
+          return linked.display_value;
+        }) : null;
+        return link.linkFilter(cellValue, filter, {
+          username: username,
+          userId: userId
+        });
+      }
+    case cellType.CellType.DIGITAL_SIGN:
+      {
+        return digitalSign.digitalSignFilter(cellValue, filter);
+      }
+    default:
+      {
+        return false;
+      }
+  }
+};
+
+/**
+ * Filter row
+ * @param {object} row e.g. { _id, .... }
+ * @param {string} filterConjunction e.g. 'And' | 'Or'
+ * @param {array} filters e.g. [{ column_key, filter_predicate, ... }, ...]
+ * @param {object} formulaRow
+ * @param {string} username
+ * @param {string} userId
+ * @returns filter result, bool
+ */
+var filterRow = function filterRow(row, filterConjunction, filters) {
+  var _ref2 = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {},
+    _ref2$formulaRow = _ref2.formulaRow,
+    formulaRow = _ref2$formulaRow === void 0 ? {} : _ref2$formulaRow,
+    _ref2$username = _ref2.username,
+    username = _ref2$username === void 0 ? '' : _ref2$username,
+    userId = _ref2.userId;
+  if (filterConjunction === index.FILTER_CONJUNCTION_TYPE.AND) {
+    return filters.every(function (filter) {
+      return getFilterResult(row, filter, {
+        formulaRow: formulaRow,
+        username: username,
+        userId: userId
+      });
+    });
+  }
+  if (filterConjunction === index.FILTER_CONJUNCTION_TYPE.OR) {
+    return filters.some(function (filter) {
+      return getFilterResult(row, filter, {
+        formulaRow: formulaRow,
+        username: username,
+        userId: userId
+      });
+    });
+  }
+  return false;
+};
+
+/**
+ * Filter rows
+ * @param {string} filterConjunction e.g. 'And' | 'Or'
+ * @param {array} filters e.g. [{ column_key, filter_predicate, ... }, ...]
+ * @param {array} rows e.g. [{ _id, .... }, ...]
+ * @param {object} formulaRows
+ * @param {string} username
+ * @param {userId} username
+ * @returns filtered rows ids, array
+ */
+var filterRows = function filterRows(filterConjunction, filters, rows, _ref3) {
+  var formulaRows = _ref3.formulaRows,
+    username = _ref3.username,
+    userId = _ref3.userId;
+  var filteredRows = [];
+  var formattedFilters = core.getFormattedFilters(filters);
+  rows.forEach(function (row) {
+    var rowId = row._id;
+    var formulaRow = formulaRows && formulaRows[rowId] ? formulaRows[rowId] : {};
+    if (filterRow(row, filterConjunction, formattedFilters, {
+      formulaRow: formulaRow,
+      username: username,
+      userId: userId
+    })) {
+      filteredRows.push(rowId);
+    }
+  });
+  return filteredRows;
+};
+
+/**
+ * Filter rows without formula calculation
+ * The "formulaRows" need to be provided if you want to filter formula, link columns etc.
+ * @param {string} filterConjunction e.g. 'And' | 'Or'
+ * @param {array} filters e.g. [{ column_key, filter_predicate, ... }, ...]
+ * @param {array} rows e.g. [{ _id, .... }, ...]
+ * @param {object} table e.g. { columns, ... }
+ * @param {object} formulaRows
+ * @param {string} username
+ * @param {userId} username
+ * @returns filtered rows: row_ids and error message: error_message, object
+ */
+var getFilteredRowsWithoutFormulaCalculation = function getFilteredRowsWithoutFormulaCalculation(filterConjunction, filters, rows, table) {
+  var _ref4 = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {},
+    _ref4$formulaRows = _ref4.formulaRows,
+    formulaRows = _ref4$formulaRows === void 0 ? null : _ref4$formulaRows,
+    _ref4$username = _ref4.username,
+    username = _ref4$username === void 0 ? null : _ref4$username,
+    _ref4$userId = _ref4.userId,
+    userId = _ref4$userId === void 0 ? null : _ref4$userId;
+  var columns = table.columns;
+  var validFilters = [];
+  try {
+    validFilters = core.deleteInvalidFilter(filters, columns);
+  } catch (err) {
+    return {
+      row_ids: [],
+      error_message: err.message
+    };
+  }
+  var filteredRows = [];
+  if (validFilters.length === 0) {
+    filteredRows = rows.map(function (row) {
+      return row._id;
+    });
+  } else {
+    filteredRows = filterRows(filterConjunction, validFilters, rows, {
+      formulaRows: formulaRows,
+      username: username,
+      userId: userId
+    });
+  }
+  return {
+    row_ids: filteredRows,
+    error_message: null
+  };
+};
+
+exports.filterRow = filterRow;
+exports.filterRows = filterRows;
+exports.getFilteredRowsWithoutFormulaCalculation = getFilteredRowsWithoutFormulaCalculation;

package/lib/group/core.js

@@ -0,0 +1,126 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var date = require('../column/date.js');
+var core$1 = require('../link/core.js');
+var column = require('../table/column.js');
+var core = require('../table/core.js');
+var cellType = require('../constants/cell-type.js');
+var group = require('../constants/group.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty__default["default"](target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+/**
+ * Check is valid groupby
+ * @param {object} groupby e.g. { column_key, count_type, sort_type, ... }
+ * @param {array} columns
+ * @returns bool
+ */
+var isValidGroupby = function isValidGroupby(groupby, columns) {
+  if (!groupby || !Array.isArray(columns)) return false;
+  var column_key = groupby.column_key;
+  var groupbyColumn = columns.find(function (column) {
+    return column.key === column_key;
+  });
+  if (!groupbyColumn) {
+    return false;
+  }
+  return group.SUPPORT_GROUP_COLUMN_TYPES.includes(groupbyColumn.type);
+};
+
+/**
+ * Get valid groupbys
+ * @param {array} groupbys e.g. [{ column_key, count_type, ... }, ...]
+ * @param {array} columns
+ * @returns valid groupbys, array
+ */
+var getValidGroupbys = function getValidGroupbys(groupbys, columns) {
+  if (!Array.isArray(groupbys) || !Array.isArray(columns)) {
+    return [];
+  }
+  return groupbys.filter(function (groupby) {
+    return isValidGroupby(groupby, columns);
+  });
+};
+
+/**
+ * Get valid and formatted groupbys
+ * @param {array} groupbys e.g. [{ column_key, count_type, ... }, ...]
+ * @param {array} columns
+ * @param {object} currentTable e.g. { _id, ... }
+ * @param {object} value e.g. { tables, collaborators }
+ * @returns valid and formatted groupbys
+ */
+var deleteInvalidGroupby = function deleteInvalidGroupby(groupbys, columns, currentTable, value) {
+  var validGroupbys = getValidGroupbys(groupbys, columns);
+  var cleanGroupbys = [];
+  validGroupbys.forEach(function (groupby) {
+    var groupbyColumnKey = groupby.column_key,
+      count_type = groupby.count_type;
+    var groupbyColumn = columns.find(function (column) {
+      return groupbyColumnKey === column.key;
+    });
+    var columnType = groupbyColumn.type,
+      columnData = groupbyColumn.data;
+    var newGroupby = _objectSpread(_objectSpread({}, groupby), {}, {
+      column: groupbyColumn
+    });
+    switch (columnType) {
+      case cellType.CellType.DATE:
+      case cellType.CellType.CTIME:
+      case cellType.CellType.MTIME:
+        {
+          newGroupby.count_type = count_type || group.GROUP_DATE_GRANULARITY.MONTH;
+          break;
+        }
+      case cellType.CellType.GEOLOCATION:
+        {
+          newGroupby.count_type = count_type || group.GROUP_GEOLOCATION_GRANULARITY.PROVINCE;
+          break;
+        }
+      case cellType.CellType.COLLABORATOR:
+        {
+          var collaborator_email_map = {};
+          value.collaborators.forEach(function (collaborator) {
+            collaborator_email_map[collaborator.email] = true;
+          });
+          newGroupby.collaborator_email_map = collaborator_email_map;
+          break;
+        }
+      case cellType.CellType.LINK:
+        {
+          var table_id = columnData.table_id,
+            other_table_id = columnData.other_table_id,
+            display_column_key = columnData.display_column_key;
+          var currentTableId = currentTable ? currentTable._id : '';
+          var linkedTableID = core$1.getLinkedTableID(currentTableId, table_id, other_table_id);
+          var linkedTable = core.getTableById(value.tables, linkedTableID);
+          var displayColumn = column.getTableColumnByKey(linkedTable, display_column_key);
+          newGroupby.linked_table = linkedTable;
+          newGroupby.display_column = displayColumn;
+          break;
+        }
+      case cellType.CellType.FORMULA:
+      case cellType.CellType.LINK_FORMULA:
+        {
+          if (date.isDateColumn(groupbyColumn) && !count_type) {
+            newGroupby.count_type = group.GROUP_DATE_GRANULARITY.MONTH;
+          }
+          break;
+        }
+    }
+    cleanGroupbys.push(newGroupby);
+  });
+  return cleanGroupbys;
+};
+
+exports.deleteInvalidGroupby = deleteInvalidGroupby;
+exports.getValidGroupbys = getValidGroupbys;
+exports.isValidGroupby = isValidGroupby;