dtable-statistic 4.0.2-test-2

package/es/calculator/mirror-calculator.js

@@ -0,0 +1,217 @@
+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 { formatNumericValue, getSummaryColumnMethod } from '../utils/common-utils';
+import StatUtils from '../utils/stat-utils';
+import { DTABLE_DB_SUMMARY_METHOD } from '../constants';
+var MirrorCalculator = /*#__PURE__*/function (_BaseCalculator) {
+  _inherits(MirrorCalculator, _BaseCalculator);
+  var _super = _createSuper(MirrorCalculator);
+  function MirrorCalculator(_ref) {
+    var value = _ref.value,
+      statisticThreadManager = _ref.statisticThreadManager,
+      username = _ref.username,
+      userId = _ref.userId;
+    _classCallCheck(this, MirrorCalculator);
+    return _super.call(this, {
+      value: value,
+      statisticThreadManager: statisticThreadManager,
+      username: username,
+      userId: userId
+    });
+  }
+  _createClass(MirrorCalculator, [{
+    key: "isValidChart",
+    value: function isValidChart(chart) {
+      if (!this.validateBaseConfigs(chart)) {
+        return false;
+      }
+      var table_id = chart.table_id,
+        column = chart.column,
+        summary_column = chart.summary_column,
+        group_column = chart.group_column;
+      var table = this.getTableById(table_id);
+      if (!TableUtils.getTableColumnByKey(table, column)) {
+        return false;
+      }
+      if (summary_column && !TableUtils.getTableColumnByKey(table, summary_column)) {
+        return false;
+      }
+      var selectedGroupColumn = TableUtils.getTableColumnByKey(table, group_column);
+      if (!selectedGroupColumn) return false;
+      var data = selectedGroupColumn.data || {};
+      var options = data.options || [];
+      if (options.length < 2) 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 column, table_id, view_id, summary_type, summary_method, summary_column, group_column, selectedTable, selectedView, sqlString, selectedColumn, columnName, selectedGroupColumn, groupColumnName, isAdvanced, method, sqlCondition, summaryColumnName, summaryColumn, summaryColumnMethod, result, data, newResult, _summaryColumnMethod, valueKey, groupData, groupData0, groupData1;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                column = chart.column, table_id = chart.table_id, view_id = chart.view_id, summary_type = chart.summary_type, summary_method = chart.summary_method, summary_column = chart.summary_column, group_column = chart.group_column;
+                selectedTable = this.getTableById(table_id);
+                selectedView = this.getViewById(view_id, selectedTable);
+                sqlString = '';
+                selectedColumn = TableUtils.getTableColumnByKey(selectedTable, column);
+                columnName = selectedColumn.name;
+                selectedGroupColumn = TableUtils.getTableColumnByKey(selectedTable, group_column);
+                groupColumnName = selectedGroupColumn.name;
+                isAdvanced = summary_type === 'advanced';
+                method = isAdvanced ? DTABLE_DB_SUMMARY_METHOD[summary_method] : 'COUNT';
+                sqlCondition = filter2SqlCondition(selectedTable, selectedView);
+                summaryColumnName = '';
+                if (isAdvanced) {
+                  summaryColumn = TableUtils.getTableColumnByKey(selectedTable, summary_column);
+                  summaryColumnName = summaryColumn.name;
+                  summaryColumnMethod = getSummaryColumnMethod(method, summaryColumnName);
+                  sqlString = "select `".concat(columnName, "`, `").concat(groupColumnName, "`, ").concat(summaryColumnMethod, " from `").concat(selectedTable.name, "` ").concat(sqlCondition, " group by `").concat(columnName, "`, `").concat(groupColumnName, "` limit 5000");
+                } else {
+                  sqlString = "select `".concat(columnName, "`, `").concat(groupColumnName, "`, ").concat(method, "(").concat(columnName, ") from `").concat(selectedTable.name, "` ").concat(sqlCondition, " group by `").concat(columnName, "`, `").concat(groupColumnName, "` limit 5000");
+                }
+                _context2.next = 15;
+                return this.sqlQuery(sqlString);
+              case 15:
+                result = _context2.sent;
+                if (!(result.status === 200 && result.data.success)) {
+                  _context2.next = 26;
+                  break;
+                }
+                data = result.data;
+                if (data.results) {
+                  _context2.next = 20;
+                  break;
+                }
+                return _context2.abrupt("return", []);
+              case 20:
+                newResult = [];
+                _summaryColumnMethod = getSummaryColumnMethod(method, summaryColumnName);
+                valueKey = isAdvanced ? "".concat(_summaryColumnMethod) : "".concat(method, "(").concat(columnName, ")");
+                groupData = this.getGroupData(data.results, selectedGroupColumn);
+                if (groupData.length > 0) {
+                  groupData0 = groupData[0] || {};
+                  groupData1 = groupData[1] || {};
+                  data.results.forEach(function (item) {
+                    var label = StatUtils.getGroupLabel(item[column], {}, selectedColumn, '', '', _this.value);
+                    var groupValue = item[group_column];
+                    var equal2GroupData0 = groupData0.id === groupValue;
+                    var equal2GroupData1 = groupData1.id === groupValue;
+                    if (equal2GroupData0 || equal2GroupData1) {
+                      var value = item[valueKey];
+                      if (isAdvanced) {
+                        value = formatNumericValue(value, summaryColumn);
+                      }
+                      newResult.push({
+                        name: label,
+                        original_name: item[column],
+                        value: equal2GroupData0 ? value : 0,
+                        group_name: groupData[0].name,
+                        color: groupData[0].color
+                      }, {
+                        name: label,
+                        original_name: item[column],
+                        value: equal2GroupData1 ? value : 0,
+                        group_name: groupData[1].name,
+                        color: groupData[1].color
+                      });
+                    }
+                  });
+                }
+                return _context2.abrupt("return", {
+                  data: newResult,
+                  colorSet: [groupData[0] && groupData[0].color, groupData[1] && groupData[1].color]
+                });
+              case 26:
+                return _context2.abrupt("return", []);
+              case 27:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+      function queryDb(_x2) {
+        return _queryDb.apply(this, arguments);
+      }
+      return queryDb;
+    }()
+  }, {
+    key: "getGroupData",
+    value: function getGroupData(result, groupColumn) {
+      var _ref2 = groupColumn.data || {},
+        _ref2$options = _ref2.options,
+        options = _ref2$options === void 0 ? {} : _ref2$options;
+      var groupCount = 0;
+      var groupList = [];
+      var cache = {};
+      var _loop = function _loop(i) {
+        var groupValue = result[i][groupColumn.key];
+        var item = options.find(function (optionItem) {
+          return optionItem.id === groupValue;
+        });
+        if (!cache[groupValue] && groupValue) {
+          groupList.push(item);
+          cache[groupValue] = true;
+          groupCount++;
+        }
+        if (groupCount === 2) return "break";
+      };
+      for (var i = 0; i < result.length; i++) {
+        var _ret = _loop(i);
+        if (_ret === "break") break;
+      }
+      return groupList;
+    }
+  }]);
+  return MirrorCalculator;
+}(BaseCalculator);
+export default MirrorCalculator;

package/es/calculator/number-card-calculator.js

@@ -0,0 +1,135 @@
+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 NumberCardCalculator = /*#__PURE__*/function (_BaseCalculator) {
+  _inherits(NumberCardCalculator, _BaseCalculator);
+  var _super = _createSuper(NumberCardCalculator);
+  function NumberCardCalculator(_ref) {
+    var value = _ref.value,
+      statisticThreadManager = _ref.statisticThreadManager,
+      username = _ref.username,
+      userId = _ref.userId;
+    _classCallCheck(this, NumberCardCalculator);
+    return _super.call(this, {
+      value: value,
+      statisticThreadManager: statisticThreadManager,
+      username: username,
+      userId: userId
+    });
+  }
+  _createClass(NumberCardCalculator, [{
+    key: "isValidChart",
+    value: function isValidChart(chart) {
+      if (!this.validateBaseConfigs(chart)) {
+        return false;
+      }
+      var table_id = chart.table_id,
+        numeric_column = chart.numeric_column;
+      var table = this.getTableById(table_id);
+      if (!TableUtils.getTableColumnByKey(table, numeric_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", 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, numeric_column, summary_method, selectedTable, selectedView, selectedColumn, sqlCondition, summaryColumnMethod, sqlString, result, data, summaryResult, key;
+        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, numeric_column = chart.numeric_column, summary_method = chart.summary_method;
+                selectedTable = this.getTableById(table_id);
+                selectedView = this.getViewById(view_id, selectedTable);
+                selectedColumn = TableUtils.getTableColumnByKey(selectedTable, numeric_column);
+                sqlCondition = filter2SqlCondition(selectedTable, selectedView);
+                summaryColumnMethod = getSummaryColumnMethod(DTABLE_DB_SUMMARY_METHOD[summary_method], selectedColumn.name);
+                sqlString = "select ".concat(summaryColumnMethod, " from `").concat(selectedTable.name, "` ").concat(sqlCondition, " limit 5000");
+                _context2.next = 9;
+                return this.sqlQuery(sqlString);
+              case 9:
+                result = _context2.sent;
+                if (!(result.status === 200 && result.data.success)) {
+                  _context2.next = 18;
+                  break;
+                }
+                data = result.data.results;
+                if (data) {
+                  _context2.next = 14;
+                  break;
+                }
+                return _context2.abrupt("return", 0);
+              case 14:
+                if (!(data.length > 0)) {
+                  _context2.next = 18;
+                  break;
+                }
+                summaryResult = data[0];
+                key = Object.keys(summaryResult)[0];
+                return _context2.abrupt("return", summaryResult[key]);
+              case 18:
+                return _context2.abrupt("return", 0);
+              case 19:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+      function queryDb(_x2) {
+        return _queryDb.apply(this, arguments);
+      }
+      return queryDb;
+    }()
+  }]);
+  return NumberCardCalculator;
+}(BaseCalculator);
+export default NumberCardCalculator;