dtable-statistic 4.0.2-test-2

package/es/calculator/completeness-calculator.js

@@ -0,0 +1,307 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import { filter2SqlCondition, TableUtils } from 'dtable-store';
+import BaseCalculator from './base-calculator';
+import { getSqlGroup, getSqlOrder } from '../utils/sql-utils';
+import { PIE_CHART_COLORS, STAT_TYPE, TIME_COLUMN_LIST } from '../constants';
+import { isArrayCellValue } from '../utils/common-utils';
+import StatUtils from '../utils/stat-utils';
+import { getFormattedLabel } from '../utils/row-utils';
+var CompletenessCalculator = /*#__PURE__*/function (_BaseCalculator) {
+  _inherits(CompletenessCalculator, _BaseCalculator);
+  var _super = _createSuper(CompletenessCalculator);
+  function CompletenessCalculator(_ref) {
+    var value = _ref.value,
+      statisticThreadManager = _ref.statisticThreadManager,
+      username = _ref.username,
+      userId = _ref.userId;
+    _classCallCheck(this, CompletenessCalculator);
+    return _super.call(this, {
+      value: value,
+      statisticThreadManager: statisticThreadManager,
+      username: username,
+      userId: userId
+    });
+  }
+  _createClass(CompletenessCalculator, [{
+    key: "isValidChart",
+    value: function isValidChart(chart) {
+      if (!this.validateBaseConfigs(chart)) {
+        return false;
+      }
+      var type = chart.type,
+        table_id = chart.table_id,
+        name_column = chart.name_column,
+        completed_column = chart.completed_column,
+        target_column = chart.target_column,
+        group_column = chart.group_column;
+      var table = this.getTableById(table_id);
+      if (!TableUtils.getTableColumnByKey(table, name_column)) {
+        return false;
+      }
+      if (!TableUtils.getTableColumnByKey(table, completed_column)) {
+        return false;
+      }
+      if (!TableUtils.getTableColumnByKey(table, target_column)) {
+        return false;
+      }
+      if (type === STAT_TYPE.GROUP_COMPLETENESS_CHART && (!group_column || !TableUtils.getTableColumnByKey(table, group_column))) {
+        return false;
+      }
+      return true;
+    }
+  }, {
+    key: "calculate",
+    value: function () {
+      var _calculate = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(chart) {
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if (this.isValidChart(chart)) {
+                  _context.next = 2;
+                  break;
+                }
+                return _context.abrupt("return", []);
+              case 2:
+                if (!this.isCalcByQueryDB(chart)) {
+                  _context.next = 6;
+                  break;
+                }
+                _context.next = 5;
+                return this.queryDb(chart);
+              case 5:
+                return _context.abrupt("return", _context.sent);
+              case 6:
+                _context.next = 8;
+                return this.calculateWithWorker(chart);
+              case 8:
+                return _context.abrupt("return", _context.sent);
+              case 9:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+      function calculate(_x) {
+        return _calculate.apply(this, arguments);
+      }
+      return calculate;
+    }()
+  }, {
+    key: "queryDb",
+    value: function () {
+      var _queryDb = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(chart) {
+        var _this = this;
+        var table_id, view_id, name_column, completed_column, target_column, group_column, date_granularity, selectedTable, selectedView, selectedColumn, groupName, sqlCondition, completedColumn, targetColumn, groupColumn, sqlOrder, isColumnDataAsAnArray, memo, resultList, completedColumnName, targetColumnName, sqlString, result, data, isTimeGroupColumn, isGroupColumnDataAsAnArray, _completedColumnName, _targetColumnName, groupColumnName, _sqlString, _result, colorMap, _data, colorIndex;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                table_id = chart.table_id, view_id = chart.view_id, name_column = chart.name_column, completed_column = chart.completed_column, target_column = chart.target_column, group_column = chart.group_column, date_granularity = chart.date_granularity;
+                selectedTable = this.getTableById(table_id);
+                selectedView = this.getViewById(view_id, selectedTable);
+                if (selectedView) {
+                  _context2.next = 5;
+                  break;
+                }
+                return _context2.abrupt("return", []);
+              case 5:
+                selectedColumn = TableUtils.getTableColumnByKey(selectedTable, name_column);
+                groupName = "`".concat(selectedColumn.name, "`");
+                sqlCondition = filter2SqlCondition(selectedTable, selectedView);
+                completedColumn = TableUtils.getTableColumnByKey(selectedTable, completed_column);
+                targetColumn = TableUtils.getTableColumnByKey(selectedTable, target_column);
+                groupColumn = TableUtils.getTableColumnByKey(selectedTable, group_column);
+                sqlOrder = getSqlOrder(null, groupName);
+                isColumnDataAsAnArray = isArrayCellValue(selectedColumn);
+                memo = new Map();
+                resultList = [];
+                if (groupColumn) {
+                  _context2.next = 29;
+                  break;
+                }
+                completedColumnName = "`".concat(completedColumn.name, "`"), targetColumnName = "`".concat(targetColumn.name, "`");
+                sqlString = "select ".concat(groupName, ", ").concat(completedColumnName, ", ").concat(targetColumnName, " from `").concat(selectedTable.name, "` ").concat(sqlCondition, " group by ").concat(groupName, ", ").concat(completedColumnName, ", ").concat(targetColumnName, " ").concat(sqlOrder, " desc limit 5000");
+                _context2.next = 20;
+                return this.sqlQuery(sqlString);
+              case 20:
+                result = _context2.sent;
+                if (!(!result.status === 200 || !result.data.success)) {
+                  _context2.next = 23;
+                  break;
+                }
+                return _context2.abrupt("return", []);
+              case 23:
+                data = result.data;
+                if (data.results) {
+                  _context2.next = 26;
+                  break;
+                }
+                return _context2.abrupt("return", []);
+              case 26:
+                data.results.forEach(function (item) {
+                  var name = item[selectedColumn.key];
+                  var label;
+                  if (name || Number.isFinite(name)) {
+                    label = StatUtils.getGroupLabel(name, {}, selectedColumn, '', '', _this.value);
+                    if (isColumnDataAsAnArray) {
+                      label = label[0];
+                    }
+                    label = getFormattedLabel(selectedColumn, label, _this.value.collaborators);
+                    if (!memo.get(label)) {
+                      var completedValue = item[completedColumn.key] || 0;
+                      var targetValue = item[targetColumn.key] || 0;
+                      if (completedValue >= targetValue) {
+                        resultList.push({
+                          name: label,
+                          original_name: name,
+                          value: completedValue,
+                          type: 'completed',
+                          current_value: completedValue,
+                          target_value: targetValue
+                        });
+                      } else {
+                        resultList.push({
+                          name: label,
+                          original_name: name,
+                          value: completedValue,
+                          type: 'completed',
+                          current_value: completedValue,
+                          target_value: targetValue
+                        }, {
+                          name: label,
+                          original_name: name,
+                          value: targetValue - completedValue,
+                          type: 'uncompleted',
+                          current_value: completedValue,
+                          target_value: targetValue
+                        });
+                      }
+                      memo.set(label, 1);
+                    }
+                  }
+                });
+                _context2.next = 48;
+                break;
+              case 29:
+                isTimeGroupColumn = TIME_COLUMN_LIST.includes(groupColumn.type);
+                isGroupColumnDataAsAnArray = isArrayCellValue(groupColumn);
+                _completedColumnName = "`".concat(completedColumn.name, "`");
+                _targetColumnName = "`".concat(targetColumn.name, "`");
+                groupColumnName = "`".concat(groupColumn.name, "`");
+                if (isTimeGroupColumn) {
+                  groupColumnName = getSqlGroup(date_granularity, groupColumn);
+                }
+                _sqlString = "select ".concat(groupName, ", ").concat(_completedColumnName, ", ").concat(_targetColumnName, ", ").concat(groupColumnName, " from `").concat(selectedTable.name, "` ").concat(sqlCondition, " group by ").concat(groupName, ", ").concat(_completedColumnName, ", ").concat(_targetColumnName, ", ").concat(groupColumnName, " ").concat(sqlOrder, " desc limit 5000");
+                _context2.next = 38;
+                return this.sqlQuery(_sqlString);
+              case 38:
+                _result = _context2.sent;
+                colorMap = {};
+                if (!(!_result.status === 200 || !_result.data.success)) {
+                  _context2.next = 42;
+                  break;
+                }
+                return _context2.abrupt("return", []);
+              case 42:
+                _data = _result.data;
+                if (_data.results) {
+                  _context2.next = 45;
+                  break;
+                }
+                return _context2.abrupt("return", []);
+              case 45:
+                colorIndex = 0;
+                _data.results.forEach(function (item) {
+                  var name = item[selectedColumn.key];
+                  var label;
+                  var groupLabel;
+
+                  // get and format name
+                  if (name || Number.isFinite(name)) {
+                    label = StatUtils.getGroupLabel(name, {}, selectedColumn, '', '', _this.value);
+                    if (isColumnDataAsAnArray) {
+                      label = label[0];
+                    }
+                    label = getFormattedLabel(selectedColumn, label, _this.value.collaborators);
+                  }
+
+                  // get and format group name
+                  if (!isTimeGroupColumn) {
+                    groupLabel = item[groupColumn.key];
+                    groupLabel = StatUtils.getGroupLabel(groupLabel, {}, groupColumn, '', '', _this.value);
+                    if (groupLabel && isGroupColumnDataAsAnArray) {
+                      groupLabel = groupLabel[0];
+                    }
+                    groupLabel = getFormattedLabel(groupColumn, groupLabel, _this.value.collaborators);
+                  } else {
+                    groupLabel = item[groupColumnName] + '';
+                  }
+
+                  // get group color
+                  var color = colorMap[groupLabel];
+                  if (!color) {
+                    color = PIE_CHART_COLORS[colorIndex % 12];
+                    colorMap[groupLabel] = color;
+                    colorIndex++;
+                  }
+                  var cache = memo.get(label);
+                  if (!cache || !cache[groupLabel]) {
+                    var completedValue = item[completedColumn.key] || 0;
+                    var targetValue = item[targetColumn.key] || 0;
+                    if (label && groupLabel) {
+                      resultList.push({
+                        name: label,
+                        original_name: name,
+                        group_label: groupLabel,
+                        value: completedValue,
+                        type: 'completed',
+                        current_value: completedValue,
+                        target_value: targetValue
+                      });
+                      if (completedValue < targetValue) {
+                        resultList.push({
+                          name: label,
+                          original_name: name,
+                          group_label: groupLabel,
+                          value: targetValue - completedValue,
+                          type: 'uncompleted',
+                          current_value: completedValue,
+                          target_value: targetValue
+                        });
+                      }
+                      if (cache) {
+                        cache[groupLabel] = 1;
+                        memo.set(label, cache);
+                      } else {
+                        memo.set(label, _defineProperty({}, groupLabel, 1));
+                      }
+                    }
+                  }
+                });
+                resultList.colorMap = colorMap;
+              case 48:
+                return _context2.abrupt("return", resultList);
+              case 49:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+      function queryDb(_x2) {
+        return _queryDb.apply(this, arguments);
+      }
+      return queryDb;
+    }()
+  }]);
+  return CompletenessCalculator;
+}(BaseCalculator);
+export default CompletenessCalculator;

package/es/calculator/copy-value.js

@@ -0,0 +1,47 @@
+var IGNORE_KEYS = ['description', 'format_version', 'plugin_settings', 'plugins', 'statistics', 'version', 'scripts', 'settings'];
+var TABLE_IGNORE_KEYS = ['summary_configs', 'is_header_locked'];
+var copyValue = function copyValue(value) {
+  var newValue = {};
+  Object.keys(value).forEach(function (key) {
+    if (key !== 'tables' && !IGNORE_KEYS.includes(key)) {
+      newValue[key] = value[key];
+    }
+  });
+  var tables = value.tables;
+  var newTables = [];
+  tables.forEach(function (table) {
+    var newTable = {};
+    Object.keys(table).forEach(function (key) {
+      if (key === 'columns') {
+        var columns = table.columns;
+        var newColumns = [];
+        columns.forEach(function (column) {
+          var newColumn = Object.assign({}, column, {
+            editor: null,
+            formatter: null
+          });
+          newColumns.push(newColumn);
+        });
+        newTable.columns = newColumns;
+      } else if (key === 'views') {
+        var views = table['views'];
+        var newViews = [];
+        views.forEach(function (view) {
+          var newView = Object.assign({}, view, {
+            colorbys: null,
+            archived_columns: null,
+            archived_rows: null
+          });
+          newViews.push(newView);
+        });
+        newTable[key] = newViews;
+      } else if (!TABLE_IGNORE_KEYS.includes(key)) {
+        newTable[key] = table[key];
+      }
+    });
+    newTables.push(newTable);
+  });
+  newValue.tables = newTables;
+  return newValue;
+};
+export default copyValue;

package/es/calculator/dashboard-calculator.js

@@ -0,0 +1,146 @@
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import { filter2SqlCondition, TableUtils } from 'dtable-store';
+import { DTABLE_DB_SUMMARY_METHOD } from '../constants';
+import { getSummaryColumnMethod } from '../utils/common-utils';
+import BaseCalculator from './base-calculator';
+var DashboardCalculator = /*#__PURE__*/function (_BaseCalculator) {
+  _inherits(DashboardCalculator, _BaseCalculator);
+  var _super = _createSuper(DashboardCalculator);
+  function DashboardCalculator(_ref) {
+    var value = _ref.value,
+      statisticThreadManager = _ref.statisticThreadManager,
+      username = _ref.username,
+      userId = _ref.userId;
+    _classCallCheck(this, DashboardCalculator);
+    return _super.call(this, {
+      value: value,
+      statisticThreadManager: statisticThreadManager,
+      username: username,
+      userId: userId
+    });
+  }
+  _createClass(DashboardCalculator, [{
+    key: "isValidChart",
+    value: function isValidChart(chart) {
+      if (!this.validateBaseConfigs(chart)) {
+        return false;
+      }
+      var table_id = chart.table_id,
+        target_value_column = chart.target_value_column,
+        total_value_column = chart.total_value_column;
+      var table = this.getTableById(table_id);
+      var selectedColumn1 = TableUtils.getTableColumnByKey(table, target_value_column);
+      var selectedColumn2 = TableUtils.getTableColumnByKey(table, total_value_column);
+      if (!selectedColumn1 || !selectedColumn2) {
+        return false;
+      }
+      return true;
+    }
+  }, {
+    key: "calculate",
+    value: function () {
+      var _calculate = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(chart) {
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if (this.isValidChart(chart)) {
+                  _context.next = 2;
+                  break;
+                }
+                return _context.abrupt("return", 0);
+              case 2:
+                if (!this.isCalcByQueryDB(chart)) {
+                  _context.next = 6;
+                  break;
+                }
+                _context.next = 5;
+                return this.queryDb(chart);
+              case 5:
+                return _context.abrupt("return", _context.sent);
+              case 6:
+                _context.next = 8;
+                return this.calculateWithWorker(chart);
+              case 8:
+                return _context.abrupt("return", _context.sent);
+              case 9:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+      function calculate(_x) {
+        return _calculate.apply(this, arguments);
+      }
+      return calculate;
+    }()
+  }, {
+    key: "queryDb",
+    value: function () {
+      var _queryDb = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(chart) {
+        var table_id, view_id, target_value_column, target_value_column_summary_method, total_value_column, total_value_column_summary_method, selectedTable, selectedView, selectedColumn1, selectedColumn2, sqlCondition, key1, key2, sqlString, result, data, result1, result2;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                table_id = chart.table_id, view_id = chart.view_id, target_value_column = chart.target_value_column, target_value_column_summary_method = chart.target_value_column_summary_method, total_value_column = chart.total_value_column, total_value_column_summary_method = chart.total_value_column_summary_method;
+                selectedTable = this.getTableById(table_id);
+                selectedView = this.getViewById(view_id, selectedTable);
+                selectedColumn1 = TableUtils.getTableColumnByKey(selectedTable, target_value_column);
+                selectedColumn2 = TableUtils.getTableColumnByKey(selectedTable, total_value_column);
+                sqlCondition = filter2SqlCondition(selectedTable, selectedView);
+                key1 = getSummaryColumnMethod(DTABLE_DB_SUMMARY_METHOD[target_value_column_summary_method], selectedColumn1.name);
+                key2 = getSummaryColumnMethod(DTABLE_DB_SUMMARY_METHOD[total_value_column_summary_method], selectedColumn2.name);
+                sqlString = "select ".concat(key1, ", ").concat(key2, " from `").concat(selectedTable.name, "` ").concat(sqlCondition, " limit 5000");
+                _context2.next = 11;
+                return this.sqlQuery(sqlString);
+              case 11:
+                result = _context2.sent;
+                if (!(result.status === 200 && result.data.success)) {
+                  _context2.next = 22;
+                  break;
+                }
+                data = result.data.results;
+                if (data) {
+                  _context2.next = 16;
+                  break;
+                }
+                return _context2.abrupt("return", 0);
+              case 16:
+                if (!(data.length > 0)) {
+                  _context2.next = 22;
+                  break;
+                }
+                result1 = data[0][key1];
+                result2 = data[0][key2];
+                if (!(result2 === 0)) {
+                  _context2.next = 21;
+                  break;
+                }
+                return _context2.abrupt("return", 0);
+              case 21:
+                return _context2.abrupt("return", result1 / result2);
+              case 22:
+                return _context2.abrupt("return", 0);
+              case 23:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+      function queryDb(_x2) {
+        return _queryDb.apply(this, arguments);
+      }
+      return queryDb;
+    }()
+  }]);
+  return DashboardCalculator;
+}(BaseCalculator);
+export default DashboardCalculator;