sea-chart 0.0.1 → 0.0.2

package/dist/utils/chart.js

@@ -0,0 +1,6 @@
+import { GenericModel, CHART_MAP } from '../model';
+export const generateChartConfig = (options, tables) => {
+  const genericChart = new GenericModel(options);
+  const ChartModel = CHART_MAP[genericChart.type];
+  return new ChartModel(genericChart, tables);
+};

package/dist/utils/collaborator-manager.js

@@ -0,0 +1,24 @@
+import { User } from '../model';
+class CollaboratorManager {
+  constructor(collaborators) {
+    this.collaborators = collaborators || [];
+    this.collaboratorsCache = {};
+    if (collaborators && Array.isArray(collaborators)) {
+      this.collaboratorsCache = collaborators.reduce((cache, item) => {
+        cache[item.email] = item;
+        return cache;
+      }, {});
+    }
+  }
+  getCollaboratorFromCache(email) {
+    return this.collaboratorsCache[email];
+  }
+  getCollaboratorsFromCache() {
+    const collaboratorsCache = this.collaboratorsCache;
+    return Object.values(collaboratorsCache).filter(item => item.email !== 'anonymous');
+  }
+  updateCollaboratorsCache(email, collaborator) {
+    this.collaboratorsCache[email] = collaborator instanceof User ? collaborator : new User(collaborator);
+  }
+}
+export default CollaboratorManager;

package/dist/utils/collaborator-utils.js

@@ -0,0 +1,40 @@
+import { isValidEmail } from 'dtable-utils';
+import { User } from '../model';
+import context from '../context';
+export const getKnownCollaboratorByEmail = email => {
+  const defaultUser = generateDefaultUser(email);
+  if (email === 'anonymous' || email === 'Automation Rule') {
+    const anonymous = new User({
+      ...defaultUser,
+      loaded: true
+    });
+    context.updateCollaboratorsCache(email, anonymous);
+    return anonymous;
+  }
+  let creator = context.getCollaboratorFromCache(email);
+  if (creator) return creator;
+  if (!isValidEmail(email)) {
+    creator = new User({
+      ...defaultUser,
+      loaded: true
+    });
+    context.updateCollaboratorsCache(email, creator);
+    return creator;
+  }
+  creator = context.getCollaboratorFromCache(email);
+  if (creator) return creator;
+  return null;
+};
+export const getKnownCollaboratorsByEmails = emails => {
+  if (!Array.isArray(emails) || emails.length === 0) return [];
+  return emails.map(email => getKnownCollaboratorByEmail(email));
+};
+export const generateDefaultUser = name => {
+  const mediaUrl = context.getSetting('mediaUrl');
+  const defaultAvatarUrl = "".concat(mediaUrl, "avatars/default.png");
+  return {
+    name,
+    email: name,
+    avatar_url: defaultAvatarUrl
+  };
+};

package/dist/utils/column-2-sql-column.js

@@ -0,0 +1,551 @@
+import { CellType, getTableColumnByKey } from 'dtable-utils';
+import { CHART_SUMMARY_TYPE, CHART_TYPE, DTABLE_DB_SUMMARY_METHOD } from '../constants';
+import ChartUtils from './chart-utils';
+const column2SqlColumn = function (column) {
+  let {
+    dateGranularity,
+    geolocationGranularity
+  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const {
+    name,
+    type,
+    key
+  } = column;
+  const validColumnName = "`".concat(name, "`");
+  switch (type) {
+    case CellType.DATE:
+    case CellType.MTIME:
+    case CellType.CTIME:
+      {
+        const validDateGranularity = dateGranularity && dateGranularity.toUpperCase();
+        if (validDateGranularity === 'DAY') {
+          const sqlColumnName = "ISODATE(".concat(validColumnName, ")");
+          return {
+            name: sqlColumnName,
+            key: sqlColumnName
+          };
+        }
+        if (validDateGranularity === 'WEEK') {
+          const sqlColumnName = "ISODATE(STARTOFWEEK(".concat(validColumnName, ", \"monday\"))");
+          return {
+            name: sqlColumnName,
+            key: sqlColumnName
+          };
+        }
+        if (validDateGranularity === 'MONTH') {
+          const sqlColumnName = "ISOMONTH(".concat(validColumnName, ")");
+          return {
+            name: sqlColumnName,
+            key: sqlColumnName
+          };
+        }
+        if (validDateGranularity === 'QUARTER') {
+          const sqlColumnName = "CONCATENATE(year(".concat(validColumnName, "), \"-Q\", quarter(").concat(validColumnName, "))");
+          return {
+            name: sqlColumnName,
+            key: sqlColumnName
+          };
+        }
+        if (validDateGranularity === 'YEAR') {
+          const sqlColumnName = "YEAR(".concat(validColumnName, ")");
+          return {
+            name: sqlColumnName,
+            key: sqlColumnName
+          };
+        }
+        if (validDateGranularity === 'MAX' || validDateGranularity === 'MIN') {
+          const sqlColumnName = "".concat(validDateGranularity, "(").concat(validColumnName, ")");
+          return {
+            name: sqlColumnName,
+            key: sqlColumnName
+          };
+        }
+        const sqlColumnName = "ISOMONTH(".concat(validColumnName, ")");
+        return {
+          name: sqlColumnName,
+          key: sqlColumnName
+        };
+      }
+    case CellType.GEOLOCATION:
+      {
+        const validGeolocationGranularity = geolocationGranularity && geolocationGranularity.toUpperCase();
+        if (validGeolocationGranularity === 'PROVINCE') {
+          const sqlColumnName = "PROVINCE(".concat(validColumnName, ")");
+          return {
+            name: sqlColumnName,
+            key: sqlColumnName
+          };
+        }
+        if (validGeolocationGranularity === 'CITY') {
+          const sqlColumnName = "CITY(".concat(validColumnName, ")");
+          return {
+            name: sqlColumnName,
+            key: sqlColumnName
+          };
+        }
+        if (validGeolocationGranularity === 'DISTRICT') {
+          const sqlColumnName = "DISTRICT(".concat(validColumnName, ")");
+          return {
+            name: sqlColumnName,
+            key: sqlColumnName
+          };
+        }
+        return {
+          name: validColumnName,
+          key
+        };
+      }
+    default:
+      {
+        return {
+          name: validColumnName,
+          key
+        };
+      }
+  }
+};
+export const summaryMethodColumn2SqlColumn = function (summaryMethod) {
+  let column = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const columnName = column.name || '';
+  if (summaryMethod === DTABLE_DB_SUMMARY_METHOD.DISTINCT_VALUES) {
+    return {
+      name: "".concat(DTABLE_DB_SUMMARY_METHOD.COUNT, "(DISTINCT ").concat(columnName, ")"),
+      key: "".concat(DTABLE_DB_SUMMARY_METHOD.COUNT, "(DISTINCT ").concat(columnName, ")")
+    };
+  }
+  return {
+    name: "".concat(DTABLE_DB_SUMMARY_METHOD[summaryMethod], "(`").concat(columnName, "`)"),
+    key: "".concat(DTABLE_DB_SUMMARY_METHOD[summaryMethod], "(").concat(columnName, ")")
+  };
+};
+const oneDimensionStatisticTableColumn2sqlColumn = (chart, table) => {
+  const {
+    groupby_column_key,
+    summary_type,
+    summary_column_key,
+    groupby_date_granularity,
+    groupby_geolocation_granularity,
+    summary_method,
+    summary_columns
+  } = chart;
+  if (!summary_method) return {};
+  const groupbyColumn = getTableColumnByKey(table, groupby_column_key);
+  if (!groupbyColumn) return {};
+  const {
+    key: sqlGroupbyColumnKey
+  } = column2SqlColumn(groupbyColumn, {
+    dateGranularity: groupby_date_granularity,
+    geolocationGranularity: groupby_geolocation_granularity
+  });
+  if (summary_type === CHART_SUMMARY_TYPE.COUNT) {
+    const {
+      key: sqlSummaryColumnKey
+    } = summaryMethodColumn2SqlColumn('COUNT', groupbyColumn);
+    return {
+      sqlGroupbyColumnKey,
+      sqlSummaryColumnKey
+    };
+  }
+  let summarySQLColumnName2ColumnKey = {};
+  let summaryTableColumnKey2Column = {};
+  let summaryTableColumnKey2Method = {};
+  const numericColumns = [{
+    column_key: summary_column_key,
+    summary_method: summary_method
+  }, ...summary_columns];
+  numericColumns.forEach(item => {
+    const {
+      column_key,
+      summary_method: item_summary_method
+    } = item;
+    const summaryMethod = item_summary_method.toUpperCase();
+    const column = getTableColumnByKey(table, column_key);
+    if (column && (ChartUtils.isDateSummaryColumn(column) || ChartUtils.isNumericSummaryColumn(column))) {
+      const {
+        key: sqlNumericColumnKey
+      } = summaryMethodColumn2SqlColumn(summaryMethod, column);
+      const {
+        key: summaryColumnKey
+      } = column;
+      summarySQLColumnName2ColumnKey[sqlNumericColumnKey] = summaryColumnKey;
+      summaryTableColumnKey2Column[summaryColumnKey] = column;
+      summaryTableColumnKey2Method[summaryColumnKey] = summaryMethod;
+    }
+  });
+  return {
+    sqlGroupbyColumnKey,
+    summarySQLColumnName2ColumnKey,
+    summaryTableColumnKey2Column,
+    summaryTableColumnKey2Method
+  };
+};
+const twoDimensionStatisticTableColumn2sqlColumn = (chart, table) => {
+  const {
+    groupby_column_key,
+    column_groupby_column_key,
+    summary_type,
+    summary_column_key,
+    groupby_date_granularity,
+    groupby_geolocation_granularity,
+    column_groupby_date_granularity,
+    column_groupby_geolocation_granularity,
+    summary_method
+  } = chart;
+  const columnGroupbyColumn = getTableColumnByKey(table, column_groupby_column_key);
+  if (!columnGroupbyColumn) return oneDimensionStatisticTableColumn2sqlColumn(chart, table);
+  const groupbyColumn = getTableColumnByKey(table, groupby_column_key);
+  if (!groupbyColumn) return {};
+  const {
+    key: sqlGroupbyColumnKey
+  } = column2SqlColumn(groupbyColumn, {
+    dateGranularity: groupby_date_granularity,
+    geolocationGranularity: groupby_geolocation_granularity
+  });
+  const {
+    key: sqlColumnGroupbyColumnKey
+  } = column2SqlColumn(columnGroupbyColumn, {
+    dateGranularity: column_groupby_date_granularity,
+    geolocationGranularity: column_groupby_geolocation_granularity
+  });
+  let sqlSummaryColumnKey;
+  if (summary_type === CHART_SUMMARY_TYPE.COUNT) {
+    const {
+      key
+    } = summaryMethodColumn2SqlColumn('COUNT', groupbyColumn);
+    sqlSummaryColumnKey = key;
+  } else {
+    if (!summary_method) return {};
+    const summaryMethod = (summary_method || '').toUpperCase();
+    const summaryColumn = getTableColumnByKey(table, summary_column_key) || {};
+    const {
+      key
+    } = summaryMethodColumn2SqlColumn(summaryMethod, summaryColumn);
+    sqlSummaryColumnKey = key;
+  }
+  return {
+    sqlGroupbyColumnKey,
+    sqlColumnGroupbyColumnKey,
+    sqlSummaryColumnKey
+  };
+};
+const pieChartStatisticColumn2sqlColumn = (chart, table) => {
+  const {
+    groupby_column_key,
+    summary_type,
+    summary_method,
+    summary_column_key,
+    groupby_date_granularity,
+    groupby_geolocation_granularity
+  } = chart;
+  if (!groupby_column_key) return {};
+  const groupbyColumn = getTableColumnByKey(table, groupby_column_key);
+  if (!groupbyColumn) return {};
+  const {
+    key: sqlGroupbyColumnKey
+  } = column2SqlColumn(groupbyColumn, {
+    dateGranularity: groupby_date_granularity,
+    geolocationGranularity: groupby_geolocation_granularity
+  });
+  let sqlSummaryColumnKey;
+  if (summary_type === CHART_SUMMARY_TYPE.COUNT) {
+    const {
+      key
+    } = summaryMethodColumn2SqlColumn('COUNT', groupbyColumn);
+    sqlSummaryColumnKey = key;
+  } else {
+    if (!summary_method) return {};
+    const summaryMethod = summary_method.toUpperCase();
+    const summaryColumn = getTableColumnByKey(table, summary_column_key) || {};
+    if (summaryColumn) {
+      const {
+        key
+      } = summaryMethodColumn2SqlColumn(summaryMethod, summaryColumn);
+      sqlSummaryColumnKey = key;
+    }
+  }
+  return {
+    sqlGroupbyColumnKey,
+    sqlSummaryColumnKey
+  };
+};
+const basicChartStatisticColumn2sqlColumn = (chart, table) => {
+  const {
+    x_axis_column_key,
+    y_axis_summary_type,
+    y_axis_summary_method,
+    y_axis_summary_column_key,
+    x_axis_date_granularity,
+    x_axis_geolocation_granularity
+  } = chart;
+  const groupbyColumn = getTableColumnByKey(table, x_axis_column_key);
+  if (!groupbyColumn) return {};
+  const {
+    key: sqlGroupbyColumnKey
+  } = column2SqlColumn(groupbyColumn, {
+    dateGranularity: x_axis_date_granularity,
+    geolocationGranularity: x_axis_geolocation_granularity
+  });
+  const summaryMethod = y_axis_summary_method && y_axis_summary_method.toUpperCase();
+  let sqlSummaryColumnKey;
+  if (y_axis_summary_type === CHART_SUMMARY_TYPE.COUNT) {
+    const {
+      key
+    } = summaryMethodColumn2SqlColumn('COUNT', groupbyColumn);
+    sqlSummaryColumnKey = key;
+  } else {
+    const summaryColumn = getTableColumnByKey(table, y_axis_summary_column_key);
+    if (summaryColumn) {
+      const {
+        key
+      } = summaryMethodColumn2SqlColumn(summaryMethod, summaryColumn);
+      sqlSummaryColumnKey = key;
+    }
+  }
+  return {
+    sqlGroupbyColumnKey,
+    sqlSummaryColumnKey
+  };
+};
+const combinationChartStatisticColumn2sqlColumn = (chart, table) => {
+  const {
+    x_axis_column_key,
+    x_axis_date_granularity,
+    x_axis_geolocation_granularity,
+    y_axis_left_group_by_multiple_numeric_column,
+    y_axis_left_summary_type,
+    y_axis_left_summary_column,
+    y_axis_left_summary_method,
+    y_axis_right_summary_type,
+    y_axis_right_summary_column,
+    y_axis_right_summary_method,
+    y_axis_left_group_by_numeric_columns
+  } = chart;
+  const groupbyColumn = getTableColumnByKey(table, x_axis_column_key);
+  if (!groupbyColumn) return {};
+  const {
+    key: sqlGroupbyColumnKey
+  } = column2SqlColumn(groupbyColumn, {
+    dateGranularity: x_axis_date_granularity,
+    geolocationGranularity: x_axis_geolocation_granularity
+  });
+  const summaryLeftMethod = y_axis_left_summary_method && y_axis_left_summary_method.toUpperCase();
+  const summaryRightMethod = y_axis_right_summary_method && y_axis_right_summary_method.toUpperCase();
+  let sqlLeftSummaryColumnKey, sqlRightSummaryColumnKey;
+  if (y_axis_right_summary_type === CHART_SUMMARY_TYPE.COUNT) {
+    const {
+      key
+    } = summaryMethodColumn2SqlColumn('COUNT', groupbyColumn);
+    sqlRightSummaryColumnKey = key;
+  } else {
+    const summaryColumn = getTableColumnByKey(table, y_axis_right_summary_column);
+    if (summaryColumn) {
+      const {
+        key
+      } = summaryMethodColumn2SqlColumn(summaryRightMethod, summaryColumn);
+      sqlRightSummaryColumnKey = key;
+    }
+  }
+  if (y_axis_left_summary_type === CHART_SUMMARY_TYPE.COUNT) {
+    const {
+      key
+    } = summaryMethodColumn2SqlColumn('COUNT', groupbyColumn);
+    sqlLeftSummaryColumnKey = key;
+    return {
+      sqlGroupbyColumnKey,
+      sqlRightSummaryColumnKey,
+      sqlLeftSummaryColumnKey
+    };
+  }
+  if (y_axis_left_group_by_multiple_numeric_column) {
+    const columnGroupbyNumericColumns = [{
+      column_key: y_axis_left_summary_column,
+      summary_method: y_axis_left_summary_method
+    }, ...y_axis_left_group_by_numeric_columns];
+    let summaryColumns = {};
+    columnGroupbyNumericColumns.forEach(summaryColumnOption => {
+      const {
+        column_key,
+        summary_method = 'Sum'
+      } = summaryColumnOption;
+      const column = getTableColumnByKey(table, column_key);
+      if (column) {
+        const summaryMethod = summary_method.toUpperCase();
+        const {
+          name: sqlSummaryColumnName,
+          key: sqlSummaryColumnKey
+        } = summaryMethodColumn2SqlColumn(summaryMethod, column);
+        summaryColumns[sqlSummaryColumnName] = {
+          sqlSummaryColumnKey,
+          columnName: column.name
+        };
+      }
+    });
+    return {
+      sqlGroupbyColumnKey,
+      summaryColumns,
+      sqlRightSummaryColumnKey,
+      sqlLeftSummaryColumnKey
+    };
+  }
+  const summaryLeftColumn = getTableColumnByKey(table, y_axis_left_summary_column);
+  if (summaryLeftColumn) {
+    const {
+      key
+    } = summaryMethodColumn2SqlColumn(summaryLeftMethod, summaryLeftColumn);
+    sqlLeftSummaryColumnKey = key;
+  }
+  return {
+    sqlGroupbyColumnKey,
+    sqlRightSummaryColumnKey,
+    sqlLeftSummaryColumnKey
+  };
+};
+const groupingChartStatisticColumn2sqlColumn = (chart, table) => {
+  const {
+    x_axis_column_key,
+    y_axis_summary_type,
+    y_axis_summary_method,
+    y_axis_summary_column_key,
+    x_axis_date_granularity,
+    x_axis_geolocation_granularity,
+    column_groupby_column_key,
+    column_groupby_date_granularity,
+    column_groupby_geolocation_granularity,
+    column_groupby_multiple_numeric_column,
+    summary_columns = []
+  } = chart;
+  const groupbyColumn = getTableColumnByKey(table, x_axis_column_key);
+  if (!groupbyColumn) return {};
+  const {
+    key: sqlGroupbyColumnKey
+  } = column2SqlColumn(groupbyColumn, {
+    dateGranularity: x_axis_date_granularity,
+    geolocationGranularity: x_axis_geolocation_granularity
+  });
+  if (y_axis_summary_type === CHART_SUMMARY_TYPE.COUNT) {
+    const columnGroupbyColumn = getTableColumnByKey(table, column_groupby_column_key);
+    if (!columnGroupbyColumn) return basicChartStatisticColumn2sqlColumn(chart, table);
+    const {
+      key: sqlColumnGroupbyColumnKey
+    } = column2SqlColumn(columnGroupbyColumn, {
+      dateGranularity: column_groupby_date_granularity,
+      geolocationGranularity: column_groupby_geolocation_granularity
+    });
+    const {
+      key: sqlSummaryColumnKey
+    } = summaryMethodColumn2SqlColumn('COUNT', groupbyColumn);
+    return {
+      sqlGroupbyColumnKey,
+      sqlColumnGroupbyColumnKey,
+      sqlSummaryColumnKey
+    };
+  }
+  if (column_groupby_multiple_numeric_column) {
+    const columnGroupbyNumericColumns = [{
+      column_key: y_axis_summary_column_key,
+      summary_method: y_axis_summary_method
+    }, ...summary_columns];
+    let summaryColumns = {};
+    columnGroupbyNumericColumns.forEach(summaryColumnOption => {
+      const {
+        column_key,
+        summary_method = 'Sum'
+      } = summaryColumnOption;
+      const column = getTableColumnByKey(table, column_key);
+      if (column) {
+        const summaryMethod = summary_method.toUpperCase();
+        const {
+          name: sqlSummaryColumnName,
+          key: sqlSummaryColumnKey
+        } = summaryMethodColumn2SqlColumn(summaryMethod, column);
+        summaryColumns[sqlSummaryColumnName] = {
+          sqlSummaryColumnKey,
+          columnName: column.name
+        };
+      }
+    });
+    return {
+      sqlGroupbyColumnKey,
+      summaryColumns
+    };
+  }
+  const columnGroupbyColumn = getTableColumnByKey(table, column_groupby_column_key);
+  const summaryMethod = y_axis_summary_method && y_axis_summary_method.toUpperCase();
+  const summaryColumn = getTableColumnByKey(table, y_axis_summary_column_key);
+  const {
+    key: sqlSummaryColumnKey
+  } = summaryMethodColumn2SqlColumn(summaryMethod, summaryColumn);
+  if (!columnGroupbyColumn) {
+    return {
+      sqlGroupbyColumnKey,
+      sqlSummaryColumnKey
+    };
+  }
+  const {
+    key: sqlColumnGroupbyColumnKey
+  } = column2SqlColumn(columnGroupbyColumn, {
+    dateGranularity: column_groupby_date_granularity,
+    geolocationGranularity: column_groupby_geolocation_granularity
+  });
+  return {
+    sqlGroupbyColumnKey,
+    sqlColumnGroupbyColumnKey,
+    sqlSummaryColumnKey
+  };
+};
+const chartColumn2SqlColumn = (chartElement, table) => {
+  if (!chartElement || !table) return {};
+  const {
+    config: chart
+  } = chartElement;
+  const {
+    type
+  } = chart;
+  switch (type) {
+    case CHART_TYPE.TABLE:
+      {
+        const {
+          column_groupby_column_key,
+          groupby_column_key
+        } = chart;
+        if (!groupby_column_key) return {};
+        if (!column_groupby_column_key) {
+          return oneDimensionStatisticTableColumn2sqlColumn(chart, table);
+        }
+        return twoDimensionStatisticTableColumn2sqlColumn(chart, table);
+      }
+    case CHART_TYPE.COMBINATION:
+      {
+        return combinationChartStatisticColumn2sqlColumn(chart, table);
+      }
+    case CHART_TYPE.PIE:
+    case CHART_TYPE.RING:
+    case CHART_TYPE.TREE_MAP:
+      {
+        return pieChartStatisticColumn2sqlColumn(chart, table);
+      }
+    case CHART_TYPE.BAR:
+    case CHART_TYPE.LINE:
+    case CHART_TYPE.HORIZONTAL_BAR:
+    case CHART_TYPE.AREA:
+      {
+        return basicChartStatisticColumn2sqlColumn(chart, table);
+      }
+    case CHART_TYPE.BAR_GROUP:
+    case CHART_TYPE.LINE_GROUP:
+    case CHART_TYPE.HORIZONTAL_GROUP_BAR:
+      {
+        const {
+          column_groupby_column_key,
+          column_groupby_multiple_numeric_column
+        } = chart;
+        if (!column_groupby_column_key && !column_groupby_multiple_numeric_column) {
+          return basicChartStatisticColumn2sqlColumn(chart, table);
+        }
+        return groupingChartStatisticColumn2sqlColumn(chart, table);
+      }
+    default:
+      return {};
+  }
+};
+export default chartColumn2SqlColumn;