dtable-utils 0.0.3 → 4.2.0

package/es/filter/filter-column/text.js

@@ -0,0 +1,60 @@
+import { FILTER_PREDICATE_TYPE } from '../../constants/filter/filter-predicate.js';
+
+/**
+ * Filter text
+ * @param {string} text
+ * @param {string} filter_predicate
+ * @param {string} filter_term
+ * @param {string} userId
+ * @returns bool
+ */
+var textFilter = function textFilter(text, _ref, userId) {
+  var filter_predicate = _ref.filter_predicate,
+    filter_term = _ref.filter_term;
+  switch (filter_predicate) {
+    case FILTER_PREDICATE_TYPE.CONTAINS:
+      {
+        if (!filter_term) {
+          return true;
+        }
+        if (!text) {
+          return false;
+        }
+        return text.toString().toLowerCase().indexOf(filter_term.toLowerCase()) > -1;
+      }
+    case FILTER_PREDICATE_TYPE.NOT_CONTAIN:
+      {
+        if (!filter_term || !text) {
+          return true;
+        }
+        return text.toString().toLowerCase().indexOf(filter_term.toLowerCase()) < 0;
+      }
+    case FILTER_PREDICATE_TYPE.IS:
+      {
+        return !filter_term || text === filter_term;
+      }
+    case FILTER_PREDICATE_TYPE.IS_NOT:
+      {
+        return !filter_term || text !== filter_term;
+      }
+    case FILTER_PREDICATE_TYPE.EMPTY:
+      {
+        return !text;
+      }
+    case FILTER_PREDICATE_TYPE.NOT_EMPTY:
+      {
+        return !!text;
+      }
+    case FILTER_PREDICATE_TYPE.IS_CURRENT_USER_ID:
+      {
+        if (!userId) return false;
+        return text === userId;
+      }
+    default:
+      {
+        return false;
+      }
+  }
+};
+
+export { textFilter };

package/es/filter/filter-row.js

@@ -0,0 +1,233 @@
+import { getFormattedFilters, deleteInvalidFilter } from './core.js';
+import { checkboxFilter } from './filter-column/checkbox.js';
+import { collaboratorFilter } from './filter-column/collaborator.js';
+import { creatorFilter } from './filter-column/creator.js';
+import { dateFilter } from './filter-column/date.js';
+import { digitalSignFilter } from './filter-column/digital-sign.js';
+import { fileFilter } from './filter-column/file.js';
+import { formulaFilter } from './filter-column/formula.js';
+import { geolocationFilter } from './filter-column/geolocation.js';
+import { textFilter } from './filter-column/text.js';
+import { longTextFilter } from './filter-column/long-text.js';
+import { multipleSelectFilter } from './filter-column/multiple-select.js';
+import { numberFilter } from './filter-column/number.js';
+import { singleSelectFilter } from './filter-column/single-select.js';
+import { linkFilter } from './filter-column/link.js';
+import { FILTER_CONJUNCTION_TYPE } from '../constants/filter/index.js';
+import { DateUtils } from '../date.js';
+import { CellType } from '../constants/cell-type.js';
+import { DATE_FORMAT_MAP } from '../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 = filter.column;
+  var cellValue = row[column_key];
+  switch (column.type) {
+    case CellType.CHECKBOX:
+      {
+        return checkboxFilter(cellValue, filter);
+      }
+    case CellType.SINGLE_SELECT:
+      {
+        return singleSelectFilter(cellValue, filter);
+      }
+    case CellType.MULTIPLE_SELECT:
+      {
+        return multipleSelectFilter(cellValue, filter);
+      }
+    case CellType.DURATION:
+    case CellType.NUMBER:
+    case CellType.RATE:
+      {
+        return numberFilter(cellValue, filter);
+      }
+    case CellType.DATE:
+      {
+        return dateFilter(cellValue, filter);
+      }
+    case CellType.CTIME:
+    case CellType.MTIME:
+      {
+        cellValue = DateUtils.format(cellValue, DATE_FORMAT_MAP.YYYY_MM_DD_HH_MM_SS);
+        return dateFilter(cellValue, filter);
+      }
+    case CellType.COLLABORATOR:
+      {
+        return collaboratorFilter(cellValue, filter, username);
+      }
+    case CellType.LONG_TEXT:
+      {
+        return longTextFilter(cellValue, filter);
+      }
+    case CellType.TEXT:
+    case CellType.AUTO_NUMBER:
+    case CellType.EMAIL:
+    case CellType.URL:
+      {
+        return textFilter(cellValue, filter, userId);
+      }
+    case CellType.IMAGE:
+    case CellType.FILE:
+      {
+        return fileFilter(cellValue, filter);
+      }
+    case CellType.LAST_MODIFIER:
+    case CellType.CREATOR:
+      {
+        return creatorFilter(cellValue, filter, username);
+      }
+    case CellType.GEOLOCATION:
+      {
+        return geolocationFilter(cellValue, filter);
+      }
+    case CellType.FORMULA:
+    case CellType.LINK_FORMULA:
+      {
+        cellValue = formulaRow[column_key];
+        return formulaFilter(cellValue, filter, {
+          username: username,
+          userId: userId
+        });
+      }
+    case CellType.LINK:
+      {
+        cellValue = formulaRow[column_key];
+        cellValue = Array.isArray(cellValue) ? cellValue.map(function (linked) {
+          return linked.display_value;
+        }) : null;
+        return linkFilter(cellValue, filter, {
+          username: username,
+          userId: userId
+        });
+      }
+    case CellType.DIGITAL_SIGN:
+      {
+        return 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 === FILTER_CONJUNCTION_TYPE.AND) {
+    return filters.every(function (filter) {
+      return getFilterResult(row, filter, {
+        formulaRow: formulaRow,
+        username: username,
+        userId: userId
+      });
+    });
+  }
+  if (filterConjunction === 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 = 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 = 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
+  };
+};
+
+export { filterRow, filterRows, getFilteredRowsWithoutFormulaCalculation };

package/es/group/core.js

@@ -0,0 +1,116 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { isDateColumn } from '../column/date.js';
+import { getLinkedTableID } from '../link/core.js';
+import { getTableColumnByKey } from '../table/column.js';
+import { getTableById } from '../table/core.js';
+import { CellType } from '../constants/cell-type.js';
+import { SUPPORT_GROUP_COLUMN_TYPES, GROUP_DATE_GRANULARITY, GROUP_GEOLOCATION_GRANULARITY } from '../constants/group.js';
+
+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(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 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.DATE:
+      case CellType.CTIME:
+      case CellType.MTIME:
+        {
+          newGroupby.count_type = count_type || GROUP_DATE_GRANULARITY.MONTH;
+          break;
+        }
+      case CellType.GEOLOCATION:
+        {
+          newGroupby.count_type = count_type || GROUP_GEOLOCATION_GRANULARITY.PROVINCE;
+          break;
+        }
+      case 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.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 = getLinkedTableID(currentTableId, table_id, other_table_id);
+          var linkedTable = getTableById(value.tables, linkedTableID);
+          var displayColumn = getTableColumnByKey(linkedTable, display_column_key);
+          newGroupby.linked_table = linkedTable;
+          newGroupby.display_column = displayColumn;
+          break;
+        }
+      case CellType.FORMULA:
+      case CellType.LINK_FORMULA:
+        {
+          if (isDateColumn(groupbyColumn) && !count_type) {
+            newGroupby.count_type = GROUP_DATE_GRANULARITY.MONTH;
+          }
+          break;
+        }
+    }
+    cleanGroupbys.push(newGroupby);
+  });
+  return cleanGroupbys;
+};
+
+export { deleteInvalidGroupby, getValidGroupbys, isValidGroupby };