dtable-statistic 4.4.24-alpha.9 → 5.0.0

package/es/calculator/workers/pivot-table-calculator-worker.js

@@ -0,0 +1,718 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = calculateStatItem;
+var _dtableUtils = require("dtable-utils");
+var _constants = require("../../constants");
+var _commonUtils = require("../../utils/common-utils");
+var _rowUtils = require("../../utils/row-utils");
+var _statUtils = _interopRequireDefault(require("../../utils/stat-utils"));
+function calculateStatItem(chart, value, _ref) {
+  let {
+    getViewRows,
+    getTableFormulaResults
+  } = _ref;
+  const {
+    groupby_column_key,
+    column_groupby_column_key
+  } = chart;
+  if (!groupby_column_key) {
+    return {};
+  }
+  if (!column_groupby_column_key) {
+    return calculateOneDimensionTable(chart, value, {
+      getViewRows,
+      getTableFormulaResults
+    });
+  }
+  return calculateTwoDimensionTable(chart, value, {
+    getViewRows,
+    getTableFormulaResults
+  });
+}
+async function calculateOneDimensionTable(chart, value, _ref2) {
+  let {
+    getViewRows,
+    getTableFormulaResults
+  } = _ref2;
+  const {
+    table_id,
+    view_id,
+    summary_type,
+    summary_method,
+    summary_column_key,
+    groupby_column_key,
+    groupby_include_empty_cells: include_empty,
+    groupby_date_granularity,
+    groupby_geolocation_granularity,
+    summary_columns_option
+  } = chart;
+  const table = (0, _dtableUtils.getTableById)(value.tables, table_id);
+  const view = table && (0, _dtableUtils.getViewById)(table.views, view_id);
+  const column = (0, _dtableUtils.getTableColumnByKey)(table, groupby_column_key);
+  if (!column) return {};
+  const isColumnDataAsAnArray = (0, _commonUtils.isArrayCellValue)(column);
+  const statRows = await getViewRows(view, table);
+  const formulaRows = await getTableFormulaResults(table, statRows);
+  let pivot_rows = [];
+  statRows.forEach(row => {
+    const {
+      _id: rowId
+    } = row;
+    const formulaRow = formulaRows[rowId];
+    if ((0, _rowUtils.isValidRow)(row, formulaRow, column, include_empty)) {
+      const name = _statUtils.default.getGroupLabel(row[column.key], formulaRow, column, groupby_date_granularity, groupby_geolocation_granularity, value);
+      let pivotRowIndex;
+      if (isColumnDataAsAnArray) {
+        if (name.length === 0 && include_empty) {
+          let pivotRowIndex = pivot_rows.findIndex(r => !r.name);
+          updateOneDimensionRows(pivot_rows, pivotRowIndex, null, row);
+        } else {
+          name.forEach(n => {
+            pivotRowIndex = pivot_rows.findIndex(r => n === r.name);
+            updateOneDimensionRows(pivot_rows, pivotRowIndex, n, row);
+          });
+        }
+      } else {
+        pivotRowIndex = pivot_rows.findIndex(pivotRow => {
+          return isSameName(pivotRow.name, name);
+        });
+        updateOneDimensionRows(pivot_rows, pivotRowIndex, name, row);
+      }
+    }
+  });
+  const summary_columns_option_keys = Array.isArray(summary_columns_option) ? summary_columns_option.map(option => option.key) : [];
+  const statisticColumnKeys = [summary_column_key, ...summary_columns_option_keys];
+  const validStatisticColumnKeys = statisticColumnKeys;
+  let statisticColumns = validStatisticColumnKeys.map(key => {
+    const column = (0, _dtableUtils.getTableColumnByKey)(table, key);
+    return column ? {
+      ...column
+    } : null;
+  }).filter(Boolean);
+  if (statisticColumns.length > 0) {
+    statisticColumns[0].method = summary_method;
+  }
+  Array.isArray(summary_columns_option) && summary_columns_option.forEach((option, index) => {
+    if (statisticColumns[index + 1]) {
+      statisticColumns[index + 1].method = option.method;
+    }
+  });
+  const {
+    pivot_columns_total
+  } = getOneDimensionTotal(statisticColumns, summary_type, formulaRows, pivot_rows);
+  _statUtils.default.sortStatistics(pivot_rows, column, 'name');
+  const pivot_columns = summary_type === _constants.SUMMARY_TYPE.COUNT ? [] : statisticColumns.map(column => {
+    return {
+      key: column.key,
+      method: column.method
+    };
+  }).filter(item => (0, _dtableUtils.getTableColumnByKey)(table, item.key));
+  pivot_rows.forEach(row => {
+    row.original_name = row.name;
+    row.name = (0, _rowUtils.getFormattedLabel)(column, row.name, value.collaborators);
+  });
+  return {
+    pivot_columns_total,
+    pivot_rows,
+    pivot_columns,
+    formulaRows
+  };
+}
+function updateOneDimensionRows(pivot_rows, index, name, row) {
+  if (index > -1) {
+    let updatedPivotRow = pivot_rows[index];
+    updatedPivotRow.rows.push(row);
+    pivot_rows[index] = updatedPivotRow;
+  } else {
+    const updatedPivotRow = {
+      name,
+      original_name: name,
+      rows: [row]
+    };
+    pivot_rows.push(updatedPivotRow);
+  }
+}
+function getOneDimensionTotal(columns, summary_type, formula_rows) {
+  let statResult = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+  let pivot_columns_total = {};
+  let dateColumnsTotalArr = {};
+  if (Array.isArray(columns) && columns.length > 0) {
+    columns.forEach(column => {
+      if (column && (0, _dtableUtils.isDateColumn)(column)) {
+        dateColumnsTotalArr[column.key] = [];
+      }
+    });
+  }
+  Array.isArray(statResult) && statResult.forEach((item, index) => {
+    const {
+      rows
+    } = item;
+    let updated = {
+      ...item
+    };
+    let totalMap = {};
+    if (summary_type === _constants.SUMMARY_TYPE.COUNT) {
+      totalMap['total'] = rows.length;
+      pivot_columns_total.total = (pivot_columns_total['total'] || 0) + rows.length;
+    } else {
+      if (Array.isArray(columns)) {
+        if (columns.length === 1) {
+          const summaryColumn = columns[0];
+          const {
+            key,
+            method
+          } = summaryColumn;
+          const total = getTotal(summaryColumn, summary_type, method, rows, formula_rows);
+          if (summaryColumn && (0, _dtableUtils.isDateColumn)(summaryColumn)) {
+            if (method === _constants.SUMMARY_METHOD_MAP.Distinct_values) {
+              totalMap['total'] = total;
+            } else {
+              totalMap['total'] = total === 0 ? 0 : total.date;
+              if (total !== 0) {
+                dateColumnsTotalArr[key].push(total);
+              }
+            }
+            if (method === _constants.SUMMARY_METHOD_MAP.Max) {
+              pivot_columns_total['total'] = dateColumnsTotalArr[key].length === 0 ? 0 : getDateMaxOrMinTotal(dateColumnsTotalArr[key], _constants.SUMMARY_METHOD_MAP.Max).date;
+            } else if (method === _constants.SUMMARY_METHOD_MAP.Min) {
+              pivot_columns_total['total'] = dateColumnsTotalArr[key].length === 0 ? 0 : getDateMaxOrMinTotal(dateColumnsTotalArr[key], _constants.SUMMARY_METHOD_MAP.Min).date;
+            } else if (method === _constants.SUMMARY_METHOD_MAP.Distinct_values) {
+              const pivotColumnTotal = (pivot_columns_total['total'] ? pivot_columns_total['total'] - 0 : 0) + total;
+              pivot_columns_total['total'] = Number.parseFloat(pivotColumnTotal.toFixed(8));
+            }
+          } else {
+            const validTotal = total ? total - 0 : 0;
+            totalMap['total'] = validTotal;
+            const pivotColumnTotal = (pivot_columns_total['total'] ? pivot_columns_total['total'] - 0 : 0) + validTotal;
+            pivot_columns_total['total'] = Number.parseFloat(pivotColumnTotal.toFixed(8));
+          }
+        } else {
+          columns.forEach(column => {
+            const {
+              key,
+              method
+            } = column;
+            const totalKey = key + method;
+            const total = getTotal(column, summary_type, method, rows, formula_rows);
+            if (column && (0, _dtableUtils.isDateColumn)(column)) {
+              if (method === _constants.SUMMARY_METHOD_MAP.Distinct_values) {
+                totalMap[totalKey] = total;
+              } else {
+                totalMap[totalKey] = total === 0 ? 0 : total.date;
+                if (total !== 0) {
+                  dateColumnsTotalArr[key].push(total);
+                }
+              }
+              if (method === _constants.SUMMARY_METHOD_MAP.Max) {
+                pivot_columns_total[totalKey] = dateColumnsTotalArr[key].length === 0 ? 0 : getDateMaxOrMinTotal(dateColumnsTotalArr[key], _constants.SUMMARY_METHOD_MAP.Max).date;
+              } else if (method === _constants.SUMMARY_METHOD_MAP.Min) {
+                pivot_columns_total[totalKey] = dateColumnsTotalArr[key].length === 0 ? 0 : getDateMaxOrMinTotal(dateColumnsTotalArr[key], _constants.SUMMARY_METHOD_MAP.Min).date;
+              } else if (method === _constants.SUMMARY_METHOD_MAP.Distinct_values) {
+                const pivotColumnTotal = (pivot_columns_total[totalKey] ? pivot_columns_total[totalKey] - 0 : 0) + total;
+                pivot_columns_total[totalKey] = Number.parseFloat(pivotColumnTotal.toFixed(8));
+              }
+            } else {
+              const validTotal = total ? total - 0 : 0;
+              totalMap[totalKey] = validTotal;
+              const pivotColumnTotal = (pivot_columns_total[totalKey] ? pivot_columns_total[totalKey] - 0 : 0) + validTotal;
+              pivot_columns_total[totalKey] = Number.parseFloat(pivotColumnTotal.toFixed(8));
+            }
+          });
+        }
+      }
+    }
+    updated.total = totalMap;
+    statResult[index] = updated;
+  });
+  return {
+    pivot_columns_total
+  };
+}
+async function calculateTwoDimensionTable(chart, value, _ref3) {
+  let {
+    getViewRows,
+    getTableFormulaResults
+  } = _ref3;
+  const {
+    table_id,
+    view_id,
+    summary_type,
+    summary_method,
+    summary_column_key,
+    groupby_column_key,
+    groupby_include_empty_cells: include_empty,
+    groupby_date_granularity,
+    groupby_geolocation_granularity,
+    column_groupby_column_key,
+    column_groupby_date_granularity,
+    column_groupby_geolocation_granularity,
+    summary_columns_option
+  } = chart;
+  const table = (0, _dtableUtils.getTableById)(value.tables, table_id);
+  const view = table && (0, _dtableUtils.getViewById)(table.views, view_id);
+  if (!view) return;
+  const groupbyColumn = (0, _dtableUtils.getTableColumnByKey)(table, groupby_column_key);
+  if (!groupbyColumn) return;
+  const isGroupbyColumnDataAsAnArray = (0, _commonUtils.isArrayCellValue)(groupbyColumn);
+  const rowGroupbyColumn = (0, _dtableUtils.getTableColumnByKey)(table, column_groupby_column_key);
+  if (!rowGroupbyColumn) {
+    return calculateOneDimensionTable(chart, value);
+  }
+  const isRowGroupbyColumnDataAsAnArray = (0, _commonUtils.isArrayCellValue)(rowGroupbyColumn);
+  const summaryColumn = (0, _dtableUtils.getTableColumnByKey)(table, summary_column_key);
+  const statRows = await getViewRows(view, table);
+  const formulaRows = await getTableFormulaResults(table, statRows);
+  const pivot_summary_multiple_columns = [];
+  summary_columns_option.forEach(item => {
+    const column = (0, _dtableUtils.getTableColumnByKey)(table, item.key);
+    if (column && (0, _dtableUtils.isNumericColumn)(column)) {
+      pivot_summary_multiple_columns.push({
+        key: item.key,
+        type: column.type,
+        data: column.data,
+        method: item.method,
+        column_name: column.name
+      });
+    }
+  });
+
+  // [{key: null}, {key: cell_value}, {key: cell_value}, ...]
+  let pivot_columns = [];
+
+  //  [
+  //    {
+  //      name: '',
+  //      cells: {
+  //        [key1]: {rows: [], total: ''},
+  //        [key2]: {rows: [], total: ''},
+  //        [key3]: {rows: [], total: ''},
+  //      }
+  //    },
+  //    ...
+  //  ]
+  let pivot_rows = [];
+  statRows.forEach(row => {
+    const {
+      _id: rowId
+    } = row;
+    const formulaRow = formulaRows[rowId];
+    const cellValueForColumn = _statUtils.default.getGroupLabel(row[rowGroupbyColumn.key], formulaRow, rowGroupbyColumn, column_groupby_date_granularity, column_groupby_geolocation_granularity, value);
+    if ((0, _rowUtils.isValidRow)(row, formulaRow, rowGroupbyColumn, include_empty)) {
+      updateTwoDimensionColumns(value, pivot_columns, rowGroupbyColumn, row, formulaRow, include_empty, column_groupby_date_granularity, column_groupby_geolocation_granularity, isRowGroupbyColumnDataAsAnArray);
+    }
+    if ((0, _rowUtils.isValidRow)(row, formulaRow, groupbyColumn, include_empty)) {
+      const name = _statUtils.default.getGroupLabel(row[groupbyColumn.key], formulaRow, groupbyColumn, groupby_date_granularity, groupby_geolocation_granularity, value);
+      let pivotRowIndex;
+      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);
+        } else {
+          name.forEach(n => {
+            pivotRowIndex = pivot_rows.findIndex(r => n === r.name);
+            updateTwoDimensionRows(pivot_rows, pivot_columns, pivotRowIndex, n, row, isRowGroupbyColumnDataAsAnArray, cellValueForColumn);
+          });
+        }
+      } else {
+        pivotRowIndex = pivot_rows.findIndex(pivotRow => {
+          return isSameName(pivotRow.name, name);
+        });
+        updateTwoDimensionRows(pivot_rows, pivot_columns, pivotRowIndex, name, row, isRowGroupbyColumnDataAsAnArray, cellValueForColumn);
+      }
+    }
+  });
+  let {
+    pivot_columns_total,
+    pivot_table_total
+  } = getTwoDimensionTotal(summaryColumn, summary_type, summary_method, formulaRows, pivot_rows, pivot_columns);
+  _statUtils.default.sortStatistics(pivot_rows, groupbyColumn, 'name');
+  _statUtils.default.sortStatistics(pivot_columns, rowGroupbyColumn, 'key');
+
+  // format shown label(name)
+  const map = {};
+  pivot_columns.forEach(column => {
+    const name = (0, _rowUtils.getFormattedLabel)(rowGroupbyColumn, column.key, value.collaborators);
+    map[column.key] = name;
+    column.key = name;
+  });
+  pivot_rows.forEach(row => {
+    row.name = (0, _rowUtils.getFormattedLabel)(groupbyColumn, row.name, value.collaborators);
+    const cells = {};
+    Object.keys(row.cells).forEach(key => {
+      cells[map[key]] = row.cells[key];
+    });
+    row.cells = cells;
+  });
+  const new_pivot_columns_total = {};
+  Object.keys(pivot_columns_total).forEach(key => {
+    new_pivot_columns_total[map[key]] = pivot_columns_total[key];
+  });
+  return {
+    pivot_rows,
+    pivot_columns,
+    pivot_columns_total: new_pivot_columns_total,
+    pivot_table_total,
+    pivot_summary_multiple_columns,
+    formulaRows
+  };
+}
+function updateTwoDimensionColumns(value, pivot_columns, column, row, formulaRow, isIncludeEmpty, dateGranularity, geolocationGranularity, isRowGroupbyColumnDataAsAnArray) {
+  let key = _statUtils.default.getGroupLabel(row[column.key], formulaRow, column, dateGranularity, geolocationGranularity, value);
+  let pivotColumnIndex;
+  if (isRowGroupbyColumnDataAsAnArray) {
+    if (key.length === 0 && isIncludeEmpty) {
+      pivotColumnIndex = pivot_columns.findIndex(r => !r.key);
+      if (pivotColumnIndex < 0) {
+        pivot_columns.unshift({
+          key: null,
+          original_key: null
+        });
+      }
+    } else {
+      key.forEach(k => {
+        pivotColumnIndex = pivot_columns.findIndex(r => r.key === k);
+        if (pivotColumnIndex < 0) {
+          pivot_columns.push({
+            key: k,
+            original_key: k
+          });
+        }
+      });
+    }
+  } else {
+    pivotColumnIndex = pivot_columns.findIndex(r => {
+      let resKey = r.key;
+      return resKey === null && key === null || resKey === undefined && key === undefined || resKey === 0 && key === 0 || resKey === key;
+    });
+    if (pivotColumnIndex < 0) {
+      pivot_columns.push({
+        key,
+        original_key: key
+      });
+    }
+  }
+}
+function updateTwoDimensionRows(pivot_rows, pivot_columns, index, name, row, isColumnDataAsAnArray, cellValue) {
+  if (index > -1) {
+    let updatedPivotRow = pivot_rows[index];
+    let {
+      cells
+    } = updatedPivotRow;
+    pivot_columns.forEach(c => {
+      let {
+        key
+      } = c;
+      if (isSameGroup(isColumnDataAsAnArray, cellValue, key)) {
+        if (cells[key]) {
+          cells[key].rows.push(row);
+        } else {
+          cells[key] = {
+            rows: [row]
+          };
+        }
+      }
+    });
+    updatedPivotRow.cells = cells;
+    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
+    });
+  }
+}
+function isSameName(prevName, currName) {
+  if ((0, _dtableUtils.isNumber)(prevName) && (0, _dtableUtils.isNumber)(currName)) {
+    return prevName === currName;
+  }
+  if (!prevName && !currName) {
+    return prevName === null && currName === null || prevName === undefined && currName === undefined || isNaN(prevName) && isNaN(currName);
+  }
+  return prevName === currName;
+}
+function isSameGroup(isColumnDataAsAnArray, source, target) {
+  if (isColumnDataAsAnArray) {
+    return (!source || source.length === 0) && !target || source && source.includes(target);
+  }
+  return source === null && target === null || source === undefined && target === undefined || source === target;
+}
+function getTwoDimensionTotal(summaryColumn, summary_type, summary_method, formula_rows) {
+  let pivot_rows = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [];
+  let pivot_columns = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : [];
+  let pivot_columns_total = {};
+  let pivot_table_total = 0;
+  let dateColumnsTotalArr = [];
+  let {
+    type: summary_column_type
+  } = summaryColumn || {};
+  const isSummaryDateColumn = summaryColumn && (0, _dtableUtils.isDateColumn)(summaryColumn);
+  let date_summary_column_format = isSummaryDateColumn ? summaryColumn.data.format : '';
+  Array.isArray(pivot_rows) && pivot_rows.forEach(pivotRow => {
+    let {
+      cells
+    } = pivotRow;
+    let total = 0;
+    Array.isArray(pivot_columns) && pivot_columns.forEach(pivotColumn => {
+      const {
+        key
+      } = pivotColumn;
+      if (cells[key]) {
+        let {
+          rows
+        } = cells[key];
+        let subTotal = getTotal(summaryColumn, summary_type, summary_method, rows, formula_rows);
+        if (isSummaryDateColumn) {
+          if (subTotal === 0) {
+            cells[key].total = 0;
+          } else {
+            subTotal.key = key;
+            subTotal.name = pivotRow.name;
+            dateColumnsTotalArr.push(subTotal);
+            cells[key].total = subTotal.date;
+          }
+        } else {
+          cells[key].total = subTotal;
+          total += subTotal ? subTotal - 0 : 0;
+          let columnTotal = pivot_columns_total[key] ? pivot_columns_total[key] : 0;
+          columnTotal += subTotal ? subTotal - 0 : 0;
+          pivot_columns_total[key] = columnTotal;
+        }
+      }
+    });
+    if (summary_column_type !== 'date') {
+      pivotRow.total = Number.parseFloat(total.toFixed(8));
+      pivot_table_total += total;
+    }
+  });
+  if (summaryColumn && (0, _dtableUtils.isDateColumn)(summaryColumn)) {
+    if (summary_method === _constants.SUMMARY_METHOD_MAP.Distinct_values) {
+      pivot_columns_total = Number.parseFloat(pivot_table_total.toFixed(8));
+    } else {
+      pivot_columns_total = showTwoDimensionDateColumnsAndRowsTotal(dateColumnsTotalArr, pivot_rows, date_summary_column_format, pivot_columns, summary_method);
+    }
+    if (summary_method === 'Max') {
+      pivot_table_total = dateColumnsTotalArr.length === 0 ? 0 : getDateMaxOrMinTotal(dateColumnsTotalArr, 'Max').date;
+    } else if (summary_method === 'Min') {
+      pivot_table_total = dateColumnsTotalArr.length === 0 ? 0 : getDateMaxOrMinTotal(dateColumnsTotalArr, 'Min').date;
+    }
+  } else {
+    pivot_table_total = Number.parseFloat(pivot_table_total.toFixed(8));
+  }
+  return {
+    pivot_columns_total,
+    pivot_table_total
+  };
+}
+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] : {};
+  const summary_column_key = summary_column ? summary_column.key : '';
+  const summary_column_type = summary_column ? summary_column.type : '';
+  const rowsLength = rows.length;
+  let total;
+  if (summary_type === _constants.SUMMARY_TYPE.COUNT) {
+    total = rowsLength;
+  } else if (summary_type === _constants.SUMMARY_TYPE.ADVANCED) {
+    if (summary_method === _constants.SUMMARY_METHOD_MAP.Distinct_values) {
+      total = 0;
+      let existMap = {};
+      rows.forEach(row => {
+        let num;
+        if (_dtableUtils.FORMULA_COLUMN_TYPES_MAP[summary_column_type]) {
+          const formulaRow = formula_rows[row._id] || {};
+          num = formulaRow[summary_column_key];
+          num = Array.isArray(num) ? num[0] : num;
+        } else {
+          num = row[summary_column_key];
+        }
+        if (!num) {
+          if (num === 0) {
+            num = '0';
+          } else {
+            num = !!num;
+          }
+        }
+        if (!existMap[num]) {
+          existMap[num] = true;
+          total++;
+        }
+      });
+      return total;
+    }
+    if (summary_column && (0, _dtableUtils.isDateColumn)(summary_column)) {
+      if (rowsLength === 0) return;
+      let dateArr = [];
+      rows.forEach(r => {
+        let formatDate = {};
+        let formatDateData;
+        let value = r[summary_column_key];
+        if (_dtableUtils.FORMULA_COLUMN_TYPES_MAP[summary_column_type]) {
+          let formulaRow = formula_rows[r._id] || {};
+          value = formulaRow[summary_column_key];
+        }
+        if (!value) return;
+        if (value.indexOf('T') != -1) {
+          const index = value.indexOf('T');
+          const targetStr = value.substring(0, index);
+          formatDateData = targetStr.replace(/-/g, '/');
+          formatDate.date = targetStr;
+        } else {
+          formatDateData = value.replace(/-/g, '/');
+          formatDate.date = value;
+        }
+        formatDate.value = Date.parse(formatDateData);
+        dateArr.push(formatDate);
+      });
+      if (summary_method === _constants.SUMMARY_METHOD_MAP.Max) {
+        total = getDateMaxOrMinTotal(dateArr, _constants.SUMMARY_METHOD_MAP.Max);
+      } else if (summary_method === _constants.SUMMARY_METHOD_MAP.Min) {
+        total = getDateMaxOrMinTotal(dateArr, _constants.SUMMARY_METHOD_MAP.Min);
+      }
+    } else {
+      switch (summary_method) {
+        case _constants.SUMMARY_METHOD_MAP.Sum:
+        case _constants.SUMMARY_METHOD_MAP.Mean:
+          {
+            let sum = 0;
+            let validNumbersCount = 0;
+            rows.forEach(r => {
+              let num;
+              if (_dtableUtils.FORMULA_COLUMN_TYPES_MAP[summary_column_type]) {
+                let formulaRow = formula_rows[r._id] || {};
+                if (formulaRow[summary_column_key] && typeof formulaRow[summary_column_key] === 'object') {
+                  num = formulaRow[summary_column_key][0];
+                } else {
+                  num = formulaRow[summary_column_key];
+                }
+              } else {
+                num = r[summary_column_key];
+              }
+              if ((0, _dtableUtils.isNumber)(num)) {
+                validNumbersCount++;
+                sum += num;
+              }
+            });
+            if (summary_method === 'Sum') {
+              total = Number.parseFloat(sum.toFixed(8));
+            } else if (summary_method === 'Mean') {
+              total = validNumbersCount === 0 ? 0 : Number.parseFloat((sum / validNumbersCount).toFixed(8));
+            }
+            break;
+          }
+        case _constants.SUMMARY_METHOD_MAP.Max:
+        case _constants.SUMMARY_METHOD_MAP.Min:
+          {
+            if (rowsLength > 0) {
+              let result = rows.reduce((current, next) => {
+                let currentValue, nextValue;
+                if (_dtableUtils.FORMULA_COLUMN_TYPES_MAP[summary_column_type]) {
+                  let currentFormulaRow = formula_rows[current._id] || {};
+                  let nextFormulaRow = formula_rows[next._id] || {};
+                  currentValue = currentFormulaRow[summary_column_key];
+                  nextValue = nextFormulaRow[summary_column_key];
+                } else {
+                  currentValue = current[summary_column_key];
+                  nextValue = next[summary_column_key];
+                }
+                if (!nextValue && nextValue !== 0) {
+                  return current;
+                }
+                let isNextGreater = currentValue < nextValue;
+                if (summary_method === 'Min') {
+                  return isNextGreater ? current : next;
+                } else {
+                  return isNextGreater ? next : current;
+                }
+              });
+              if (_dtableUtils.FORMULA_COLUMN_TYPES_MAP[summary_column_type]) {
+                let formulaRow = formula_rows[result._id];
+                if (formulaRow) {
+                  if (formulaRow[summary_column_key] && typeof formulaRow[summary_column_key] === 'object') {
+                    total = formulaRow[summary_column_key][0];
+                  } else {
+                    total = formulaRow[summary_column_key];
+                  }
+                } else {
+                  total = null;
+                }
+              } else {
+                total = result[summary_column_key];
+              }
+            }
+            break;
+          }
+        default:
+          {
+            break;
+          }
+      }
+    }
+  }
+  // formula_rows result can be '#VALUE!'
+  if (total === '#VALUE!') {
+    total = 0;
+  }
+  return total || 0;
+}
+function showTwoDimensionDateColumnsAndRowsTotal(dateArr, pivot_rows, summary_column_format, pivot_columns, summary_method) {
+  let pivot_columns_total = {};
+  Array.isArray(pivot_columns) && pivot_columns.forEach(pivotColumn => {
+    const {
+      key
+    } = pivotColumn;
+    let dateColumnTotal = [];
+    dateArr.forEach(item => {
+      if (item.key === key) {
+        dateColumnTotal.push(item);
+      }
+    });
+    if (summary_method === 'Max') {
+      pivot_columns_total[key] = dateColumnTotal.length === 0 ? 0 : getDateMaxOrMinTotal(dateColumnTotal, 'Max').date;
+    } else if (summary_method === 'Min') {
+      pivot_columns_total[key] = dateColumnTotal.length === 0 ? 0 : getDateMaxOrMinTotal(dateColumnTotal, 'Min').date;
+    }
+  });
+  Array.isArray(pivot_rows) && pivot_rows.forEach(pivotRow => {
+    let dateRowTotal = [];
+    dateArr.forEach(item => {
+      if (item.name === pivotRow.name) {
+        dateRowTotal.push(item);
+      }
+    });
+    if (summary_method === 'Max') {
+      pivotRow.total = dateRowTotal.length === 0 ? 0 : getDateMaxOrMinTotal(dateRowTotal, 'Max').date;
+    } else if (summary_method === 'Min') {
+      pivotRow.total = dateRowTotal.length === 0 ? 0 : getDateMaxOrMinTotal(dateRowTotal, 'Min').date;
+    }
+  });
+  return pivot_columns_total;
+}
+function getDateMaxOrMinTotal(dateArr, type) {
+  if (dateArr.length === 0) return;
+  const list = dateArr.map(item => item.value);
+  let dateValue = 0;
+  let dateIndex = 0;
+  if (type === 'Max') {
+    dateValue = Math.max(...list);
+  } else if (type === 'Min') {
+    dateValue = Math.min(...list);
+  }
+  dateIndex = list.indexOf(dateValue);
+  return dateArr[dateIndex];
+}