sea-chart 0.0.69 → 0.0.70

package/dist/utils/chart-utils/original-data-utils/pivot-table-calculator.js

@@ -1,8 +1,10 @@
 import { FORMULA_COLUMN_TYPES_MAP, isNumber, isDateColumn, isNumericColumn, getTableById, getViewById, getTableColumnByKey } from 'dtable-utils';
+import { isObject } from 'lodash';
 import { CHART_SUMMARY_TYPE, TABLE_DIMENSIONS } from '../../../constants';
 import { isArrayCellValue } from '../../cell-value-utils';
 import { getFormattedLabel, isValidRow } from '../../row-utils';
 import BaseUtils from '../base-utils';
+import { summaryMethodColumn2SqlColumn } from '../../sql/column-2-sql-column';
 async function calculateOneDimensionTable(chart, value, _ref) {
   let {
     getViewRows,
@@ -167,7 +169,7 @@ function getOneDimensionTotal(columns, summary_type, formula_rows) {
               key,
               method
             } = column;
-            const totalKey = key + method;
+            const totalKey = key;
             const total = getTotal(column, summary_type, method, rows, formula_rows);
             if (column && isDateColumn(column)) {
               if (method === CHART_SUMMARY_TYPE.Distinct_values) {
@@ -281,18 +283,18 @@ async function calculateTwoDimensionTable(chart, value, _ref2) {
       if (isGroupbyColumnDataAsAnArray) {
         if (name.length === 0 && include_empty) {
           let pivotRowIndex = pivot_rows.findIndex(r => !r.name);
-          updateTwoDimensionRows(pivot_rows, pivot_columns, pivotRowIndex, null, row, isRowGroupbyColumnDataAsAnArray, cellValueForColumn);
+          updateTwoDimensionRows(pivot_rows, pivot_columns, pivotRowIndex, null, row, isRowGroupbyColumnDataAsAnArray, cellValueForColumn, chart, groupbyColumn, table);
         } else {
           name.forEach(n => {
             pivotRowIndex = pivot_rows.findIndex(r => n === r.name);
-            updateTwoDimensionRows(pivot_rows, pivot_columns, pivotRowIndex, n, row, isRowGroupbyColumnDataAsAnArray, cellValueForColumn);
+            updateTwoDimensionRows(pivot_rows, pivot_columns, pivotRowIndex, n, row, isRowGroupbyColumnDataAsAnArray, cellValueForColumn, chart, groupbyColumn, table);
           });
         }
       } else {
         pivotRowIndex = pivot_rows.findIndex(pivotRow => {
           return isSameName(pivotRow.name, name);
         });
-        updateTwoDimensionRows(pivot_rows, pivot_columns, pivotRowIndex, name, row, isRowGroupbyColumnDataAsAnArray, cellValueForColumn);
+        updateTwoDimensionRows(pivot_rows, pivot_columns, pivotRowIndex, name, row, isRowGroupbyColumnDataAsAnArray, cellValueForColumn, chart, groupbyColumn, table);
       }
     }
   });
@@ -368,7 +370,48 @@ function updateTwoDimensionColumns(value, pivot_columns, column, row, formulaRow
     }
   }
 }
-function updateTwoDimensionRows(pivot_rows, pivot_columns, index, name, row, isColumnDataAsAnArray, cellValue) {
+function updateTwoDimensionRows(pivot_rows, pivot_columns, index, name, row, isColumnDataAsAnArray, cellValue, chart, groupbyColumn, table) {
+  const {
+    summary_type,
+    summary_columns,
+    summary_column_key,
+    summary_method
+  } = chart;
+  const isCount = summary_type === CHART_SUMMARY_TYPE.COUNT;
+  let summarySQLColumnName2ColumnKey = {};
+  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 && (BaseUtils.isDateSummaryColumn(column) || BaseUtils.isNumericSummaryColumn(column))) {
+      const {
+        key: sqlNumericColumnKey
+      } = summaryMethodColumn2SqlColumn(summaryMethod, column);
+      const {
+        key: summaryColumnKey
+      } = column;
+      summarySQLColumnName2ColumnKey[sqlNumericColumnKey] = summaryColumnKey;
+    }
+  });
+  const summarySQLnames = Object.keys(summarySQLColumnName2ColumnKey);
+  const summarySQLColumnKeys = Object.values(summarySQLColumnName2ColumnKey);
+  const summaryColumn = getTableColumnByKey(table, summary_column_key) || {};
+  const singleNumeriColumnWithMethod = {
+    column: summaryColumn,
+    summary_method
+  };
+  const summaryColumnsWithMethod = BaseUtils.getSummaryColumnsWithMethod(table, {
+    config: chart
+  });
+  const multipleNumericColumnsWithMethod = summaryColumnsWithMethod;
+  const all = [singleNumeriColumnWithMethod, ...multipleNumericColumnsWithMethod];
   if (index > -1) {
     let updatedPivotRow = pivot_rows[index];
     let {
@@ -378,36 +421,110 @@ function updateTwoDimensionRows(pivot_rows, pivot_columns, index, name, row, isC
       let {
         key
       } = c;
-      if (isSameGroup(isColumnDataAsAnArray, cellValue, key)) {
+      if (BaseUtils.isSameGroup(isColumnDataAsAnArray, cellValue, key)) {
         if (cells[key]) {
           cells[key].rows.push(row);
+          if (isCount) {
+            cells[key].total = row[groupbyColumn.key];
+          } else {
+            cells[key].total = summarySQLColumnKeys.map((columnKey, i) => {
+              const current = all.find(item => item.column.key === columnKey);
+              const nextValue = row[current === null || current === void 0 ? void 0 : current.column.key];
+              const currentValue = Object.values(cells[key].total).find(item => item[2] === columnKey)[1];
+              const computedValue = BaseUtils.getSummaryValue({
+                summaryMethod: current.summary_method,
+                summaryColumn: current.column
+              }, currentValue, nextValue);
+              const columnName = current.column.name;
+              return [columnName, computedValue, columnKey];
+            });
+          }
         } else {
+          let total;
+          if (isCount) {
+            total = row[groupbyColumn.key];
+          } else {
+            total = summarySQLColumnKeys.map((columnKey, i) => {
+              var _current$column;
+              const current = all.find(item => item.column.key === columnKey);
+              const value = row[current === null || current === void 0 ? void 0 : (_current$column = current.column) === null || _current$column === void 0 ? void 0 : _current$column.key];
+              const columnName = current.column.name;
+              // keep column key to find currentValue on updating
+              return [columnName, value, columnKey];
+            });
+          }
           cells[key] = {
-            rows: [row]
+            rows: [row],
+            total
           };
         }
       }
     });
     updatedPivotRow.cells = cells;
+    // sum up
+    if (isCount) {
+      updatedPivotRow.total = Object.values(cells).reduce((acc, item) => {
+        acc += item.total;
+        return acc;
+      }, 0);
+    } else {
+      updatedPivotRow.total = Object.values(cells).reduce((acc, item) => {
+        item.total.forEach(t => {
+          isNumber(t[1]) && (acc += t[1]);
+        });
+        return acc;
+      }, 0);
+    }
     pivot_rows[index] = updatedPivotRow;
-  } else {
-    let cells = {};
-    pivot_columns.forEach(c => {
-      let {
-        key
-      } = c;
-      if (isSameGroup(isColumnDataAsAnArray, cellValue, key)) {
-        cells[key] = {
-          rows: [row]
-        };
-      }
-    });
-    pivot_rows.push({
-      name,
-      original_name: name,
-      cells
-    });
+    return;
   }
+
+  // add a new row
+  let cells = {};
+  let total = 0;
+  pivot_columns.forEach(c => {
+    let {
+      key
+    } = c;
+    if (BaseUtils.isSameGroup(isColumnDataAsAnArray, cellValue, key)) {
+      let total;
+      if (isCount) {
+        total = row[groupbyColumn.key];
+      } else {
+        total = summarySQLColumnKeys.map((columnKey, i) => {
+          var _current$column2;
+          const current = all.find(item => item.column.key === columnKey);
+          const value = row[current === null || current === void 0 ? void 0 : (_current$column2 = current.column) === null || _current$column2 === void 0 ? void 0 : _current$column2.key];
+          const columnName = current.column.name;
+          return [columnName, value, columnKey];
+        });
+      }
+      cells[key] = {
+        rows: [row],
+        total
+      };
+    }
+  });
+  const cellList = Object.values(cells);
+  total = cellList.reduce((acc, item) => {
+    let num;
+    if (isObject(item.total)) {
+      num = item.total.reduce((acc, item) => {
+        isNumber(item[1]) && (acc += item[1]);
+        return acc;
+      }, 0);
+    } else {
+      num = item.total;
+    }
+    acc += num;
+    return acc;
+  }, 0);
+  pivot_rows.push({
+    name,
+    original_name: name,
+    cells,
+    total
+  });
 }
 function isSameName(prevName, currName) {
   if (isNumber(prevName) && isNumber(currName)) {
@@ -445,10 +562,11 @@ function getTwoDimensionTotal(summaryColumn, summary_type, summary_method, formu
         key
       } = pivotColumn;
       if (cells[key]) {
+        var _cells$key;
         let {
           rows
         } = cells[key];
-        let subTotal = getTotal(summaryColumn, summary_type, summary_method, rows, formula_rows);
+        let subTotal = getTotal(summaryColumn, summary_type, summary_method, rows, formula_rows, (_cells$key = cells[key]) === null || _cells$key === void 0 ? void 0 : _cells$key.total);
         if (isSummaryDateColumn) {
           if (subTotal === 0) {
             cells[key].total = 0;
@@ -456,13 +574,13 @@ function getTwoDimensionTotal(summaryColumn, summary_type, summary_method, formu
             subTotal.key = key;
             subTotal.name = pivotRow.name;
             dateColumnsTotalArr.push(subTotal);
-            cells[key].total = subTotal.date;
+            // cells[key].total = subTotal.date;
           }
         } else {
           cells[key].total = subTotal;
-          total += subTotal ? subTotal - 0 : 0;
+          total += subTotal[0][1] ? subTotal[0][1] - 0 : 0;
           let columnTotal = pivot_columns_total[key] ? pivot_columns_total[key] : 0;
-          columnTotal += subTotal ? subTotal - 0 : 0;
+          columnTotal += subTotal[0][1] ? subTotal[0][1] - 0 : 0;
           pivot_columns_total[key] = columnTotal;
         }
       }
@@ -494,6 +612,7 @@ function getTwoDimensionTotal(summaryColumn, summary_type, summary_method, formu
 function getTotal(summary_column, summary_type, summary_method) {
   let rows = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
   let formula_rows = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+  let oldTotal = arguments.length > 5 ? arguments[5] : undefined;
   const summary_column_key = summary_column ? summary_column.key : '';
   const summary_column_type = summary_column ? summary_column.type : '';
   const rowsLength = rows.length;
@@ -536,7 +655,8 @@ function getTotal(summary_column, summary_type, summary_method) {
         let value = r[summary_column_key];
         if (FORMULA_COLUMN_TYPES_MAP[summary_column_type]) {
           let formulaRow = formula_rows[r._id] || {};
-          value = formulaRow[summary_column_key];
+          value = formulaRow[summary_column_key] || '';
+          value = Array.isArray(value) && value.length !== 0 ? value[0] : '';
         }
         if (!value) return;
         if (value.indexOf('T') !== -1) {
@@ -581,9 +701,14 @@ function getTotal(summary_column, summary_type, summary_method) {
               }
             });
             if (summary_method === 'Sum') {
-              total = Number.parseFloat(sum.toFixed(8));
+              const newTotal = JSON.parse(JSON.stringify(oldTotal));
+              newTotal[0][1] = Number.parseFloat(sum.toFixed(8));
+              total = newTotal;
             } else if (summary_method === 'Mean') {
-              total = validNumbersCount === 0 ? 0 : Number.parseFloat((sum / validNumbersCount).toFixed(8));
+              const newTotal = JSON.parse(JSON.stringify(oldTotal));
+              const val = validNumbersCount === 0 ? 0 : Number.parseFloat((sum / validNumbersCount).toFixed(8));
+              newTotal[0][1] = val;
+              total = newTotal;
             }
             break;
           }

package/dist/view/wrapper/index.js

@@ -83,6 +83,7 @@ const Wrapper = _ref => {
           if (!result) return null;
           return /*#__PURE__*/React.createElement(Table, Object.assign({}, baseProps, {
             summaryColumns: summary_columns,
+            columnGroupbyColumn: columnGroupbyColumn,
             summaryMethod: summary_method,
             chartTableColumns: chartTableColumns,
             isCalculateByView: isCalculateByView

package/dist/view/wrapper/table/index.js

@@ -10,8 +10,8 @@ class Table extends PureComponent {
     this.renderContainer = () => {
       const {
         groupbyColumn,
-        columnGroupbyColumn,
-        result
+        result,
+        columnGroupbyColumn
       } = this.props;
       const {
         pivot_columns

package/dist/view/wrapper/table/pivot-table-display-name.js

@@ -107,7 +107,10 @@ class PivotTableDisplayName extends React.Component {
         case CellType.SINGLE_SELECT:
           {
             const options = getColumnOptions(column);
-            const option = getOption(options, value) || {};
+            let option = getOption(options, value) || {};
+            if (Object.keys(option).length === 0) {
+              option = options.find(item => item.name === value) || {};
+            }
             displayName = /*#__PURE__*/React.createElement(React.Fragment, null, this.renderSelectOption(option));
             break;
           }

package/dist/view/wrapper/table/two-dimension-table.js

@@ -126,21 +126,23 @@ class TwoDimensionTable extends PureComponent {
         total
       }, selectedCell);
     };
-    this.renderByView = (total, display_empty, cellIdx, isSelectedCell, isSelectedCellTop, isSelectedCellLeft) => {
-      const isValidDisplayValue = BaseUtils.isValidValue(total, display_empty);
+    this.renderEmpty = (summaryColumns, cellIdx) => {
+      if (summaryColumns && (summaryColumns === null || summaryColumns === void 0 ? void 0 : summaryColumns.length) !== 0) {
+        return summaryColumns.map(() => {
+          return /*#__PURE__*/React.createElement("div", {
+            key: "table-cell-".concat(cellIdx),
+            className: classnames('pivot-cell', {
+              'pivot-empty-cell': true
+            })
+          }, /*#__PURE__*/React.createElement("i", null));
+        });
+      }
       return /*#__PURE__*/React.createElement("div", {
         key: "table-cell-".concat(cellIdx),
         className: classnames('pivot-cell', {
-          'pivot-empty-cell': !isValidDisplayValue,
-          'selected-pivot-cell': isSelectedCell,
-          'selected-pivot-cell-top': isSelectedCellTop,
-          'selected-pivot-cell-left': isSelectedCellLeft
-        })
-      }, isValidDisplayValue ? total : /*#__PURE__*/React.createElement("i", null), /*#__PURE__*/React.createElement("span", {
-        className: classnames({
-          'selected-pivot-cell-border': isSelectedCell
+          'pivot-empty-cell': true
         })
-      }));
+      }, /*#__PURE__*/React.createElement("i", null));
     };
     this.renderRows = () => {
       const {
@@ -250,9 +252,9 @@ class TwoDimensionTable extends PureComponent {
             key: "table-cell-".concat(cellIdx)
           }, /*#__PURE__*/React.createElement("div", {
             className: classnames('pivot-cells-container')
-          }, !isCalculateByView && total && total.map && total.map((summaryCell, idx) => {
+          }, total && total.map && total.map((summaryCell, idx) => {
             const summaryCellColumnKey = summaryCell[2];
-            const summaryCellColumn = summaryColumns.find(item => item.key === summaryCellColumnKey);
+            const summaryCellColumn = summaryColumns === null || summaryColumns === void 0 ? void 0 : summaryColumns.find(item => item.key === summaryCellColumnKey);
             const displayValue = BaseUtils.getSummaryValueDisplayString(summaryCellColumn, summaryCell[1], summaryMethod);
             const isValidDisplayValue = BaseUtils.isValidValue(displayValue, display_empty);
             return /*#__PURE__*/React.createElement("div", {
@@ -268,14 +270,7 @@ class TwoDimensionTable extends PureComponent {
                 'selected-pivot-cell-border': isSelectedCell
               })
             }));
-          }), !isCalculateByView && !total && (summaryColumns === null || summaryColumns === void 0 ? void 0 : summaryColumns.map(() => {
-            return /*#__PURE__*/React.createElement("div", {
-              key: "table-cell-".concat(cellIdx),
-              className: classnames('pivot-cell', {
-                'pivot-empty-cell': true
-              })
-            }, /*#__PURE__*/React.createElement("i", null));
-          })), isCalculateByView && this.renderByView(total, display_empty, cellIdx, isSelectedCell, isSelectedCellTop, isSelectedCellLeft)));
+          }), !total && this.renderEmpty(summaryColumns, cellIdx)));
         }), display_total && /*#__PURE__*/React.createElement("td", {
           className: classnames('pivot-cell', {
             'pivot-empty-cell': !isValidSummaryDisplayValue,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sea-chart",
-  "version": "0.0.69",
+  "version": "0.0.70",
   "main": "./dist/index.js",
   "dependencies": {
     "@antv/data-set": "0.11.8",