dtable-statistic 4.2.1 → 4.3.0

package/es/service/dashboard-service.js

@@ -1,468 +1,470 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
-import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime/helpers/esm/createClass";
 import StatisticDashBoard from '../model/statistic-dashboard';
 import { hasOwnProperty } from '../utils';
 import { generatorUniqueId } from '../utils/common-utils';
 import { DASHBOARD_ACTION_TYPE, STAT_TYPE, SUMMARY_TYPE } from '../constants';
-var ADVANCED_STATISTICS_NAME = 'advanced-statistics';
-var DashBoardService = /*#__PURE__*/function () {
-  function DashBoardService(_ref) {
-    var value = _ref.value,
-      defaultDashboardName = _ref.defaultDashboardName,
-      chartCalculator = _ref.chartCalculator,
-      chartService = _ref.chartService,
-      updateStatistics = _ref.updateStatistics,
-      deletePluginSettings = _ref.deletePluginSettings;
-    _classCallCheck(this, DashBoardService);
+const ADVANCED_STATISTICS_NAME = 'advanced-statistics';
+class DashBoardService {
+  constructor(_ref) {
+    let {
+      value,
+      defaultDashboardName,
+      chartCalculator,
+      chartService,
+      updateStatistics,
+      deletePluginSettings
+    } = _ref;
     this.defaultDashboardName = defaultDashboardName;
     this.chartCalculator = chartCalculator;
     this.chartService = chartService;
     this.initStatistics(value, updateStatistics, deletePluginSettings);
   }
-  _createClass(DashBoardService, [{
-    key: "initStatistics",
-    value: function initStatistics(value, updateStatistics, deletePluginSettings) {
-      var baseStatistics = value && value.statistics || [];
-      var advancedStatistics = this.getAdvancedStatistics(value);
-      var hasBaseStatistics = baseStatistics.length > 0;
-      var hasAdvancedStatistics = advancedStatistics.length > 0;
-      this.statistics = baseStatistics;
+  initStatistics(value, updateStatistics, deletePluginSettings) {
+    const baseStatistics = value && value.statistics || [];
+    const advancedStatistics = this.getAdvancedStatistics(value);
+    const hasBaseStatistics = baseStatistics.length > 0;
+    const hasAdvancedStatistics = advancedStatistics.length > 0;
+    this.statistics = baseStatistics;
 
-      // init default dashboard if neither base-statistics nor advanced-statistics
-      if (!hasBaseStatistics && !hasAdvancedStatistics) {
-        this.statistics = [new StatisticDashBoard({
-          _id: generatorUniqueId([]),
-          stat_items: [],
-          name: this.defaultDashboardName
-        })];
-        return;
-      }
-      this.needSave = false;
-
-      // convert to advance-statistic
-      if (hasBaseStatistics && !hasOwnProperty(this.statistics[0], 'stat_items')) {
-        this.needSave = true;
-        this.convert2AdvanceStatistic();
-      }
-
-      // merge advanced statistics
-      if (hasAdvancedStatistics) {
-        this.mergeAdvancedStatistics(advancedStatistics, deletePluginSettings);
-      }
-      if (this.needSave) {
-        this.needSave = false;
-        updateStatistics(this.statistics);
-      }
-    }
-  }, {
-    key: "convert2AdvanceStatistic",
-    value: function convert2AdvanceStatistic() {
-      var _this = this;
-      var statItems = this.statistics.map(function (chart) {
-        var type = chart.type;
-        switch (type) {
-          case STAT_TYPE.PIVOT_TABLE:
-            {
-              return _this.convertPivotTable(chart);
-            }
-          case STAT_TYPE.BAR:
-            {
-              return _this.convertChartBar(chart);
-            }
-          case STAT_TYPE.LINE:
-            {
-              return _this.convertChartLine(chart);
-            }
-          case STAT_TYPE.PIE:
-            {
-              return _this.chartService.generatorChart(_objectSpread(_objectSpread({}, chart), {}, {
-                type: STAT_TYPE.RING
-              }));
-            }
-          default:
-            {
-              return null;
-            }
-        }
-      }).filter(Boolean);
+    // init default dashboard if neither base-statistics nor advanced-statistics
+    if (!hasBaseStatistics && !hasAdvancedStatistics) {
       this.statistics = [new StatisticDashBoard({
         _id: generatorUniqueId([]),
-        stat_items: statItems,
+        stat_items: [],
         name: this.defaultDashboardName
       })];
+      return;
     }
-  }, {
-    key: "convertPivotTable",
-    value: function convertPivotTable(chart) {
-      var summary_type = chart.summary_type,
-        summary_columns_option = chart.summary_columns_option;
-      var convertedChart = _objectSpread({}, chart);
-      if (summary_type === SUMMARY_TYPE.ADVANCED && summary_columns_option && summary_columns_option.length > 0) {
-        convertedChart.column_groupby_multiple_numeric_column = true;
-      }
-      return this.chartService.generatorChart(convertedChart);
-    }
-  }, {
-    key: "convertChartBar",
-    value: function convertChartBar(chart) {
-      var column_groupby_column_key = chart.column_groupby_column_key,
-        y_axis_use_stack = chart.y_axis_use_stack,
-        y_axis_summary_method = chart.y_axis_summary_method,
-        column_groupby_multiple_numeric_column = chart.column_groupby_multiple_numeric_column,
-        column_groupby_numeric_column_keys = chart.column_groupby_numeric_column_keys;
-      var convertedChart = _objectSpread({}, chart);
-      var isGroupbyMultipleNumericColumns = column_groupby_multiple_numeric_column && column_groupby_numeric_column_keys && column_groupby_numeric_column_keys.length > 0;
-      if (column_groupby_column_key || isGroupbyMultipleNumericColumns) {
-        convertedChart.type = STAT_TYPE.BAR_GROUP;
-        if (y_axis_use_stack) {
-          convertedChart.type = STAT_TYPE.BAR_STACK;
-        }
-        if (isGroupbyMultipleNumericColumns) {
-          convertedChart.column_groupby_multiple_numeric_column = column_groupby_multiple_numeric_column;
-          convertedChart.column_groupby_numeric_columns = column_groupby_numeric_column_keys.map(function (key) {
-            if (!key) return null;
-            return {
-              column_key: key,
-              summary_method: y_axis_summary_method
-            };
-          }).filter(Boolean);
-        }
-      }
-      return this.chartService.generatorChart(convertedChart);
+    this.needSave = false;
+
+    // convert to advance-statistic
+    if (hasBaseStatistics && !hasOwnProperty(this.statistics[0], 'stat_items')) {
+      this.needSave = true;
+      this.convert2AdvanceStatistic();
     }
-  }, {
-    key: "convertChartLine",
-    value: function convertChartLine(chart) {
-      var column_groupby_column_key = chart.column_groupby_column_key,
-        column_groupby_multiple_numeric_column = chart.column_groupby_multiple_numeric_column,
-        column_groupby_numeric_column_keys = chart.column_groupby_numeric_column_keys,
-        y_axis_summary_method = chart.y_axis_summary_method;
-      var isGroupbyMultipleNumericColumns = column_groupby_multiple_numeric_column && column_groupby_numeric_column_keys && column_groupby_numeric_column_keys.length > 0;
-      var convertedChart = _objectSpread({}, chart);
-      if (column_groupby_column_key) {
-        convertedChart.type = STAT_TYPE.GROUP_LINE;
-        if (isGroupbyMultipleNumericColumns) {
-          convertedChart.column_groupby_multiple_numeric_column = column_groupby_multiple_numeric_column;
-          convertedChart.column_groupby_numeric_columns = column_groupby_numeric_column_keys.map(function (key) {
-            if (!key) return null;
-            return {
-              column_key: key,
-              summary_method: y_axis_summary_method
-            };
-          }).filter(Boolean);
-        }
-      }
-      return this.chartService.generatorChart(convertedChart);
+
+    // merge advanced statistics
+    if (hasAdvancedStatistics) {
+      this.mergeAdvancedStatistics(advancedStatistics, deletePluginSettings);
     }
-  }, {
-    key: "getAdvancedStatistics",
-    value: function getAdvancedStatistics(value) {
-      if (!value || !hasOwnProperty(value, 'plugin_settings') || !hasOwnProperty(value.plugin_settings, ADVANCED_STATISTICS_NAME)) {
-        return [];
-      }
-      return value.plugin_settings[ADVANCED_STATISTICS_NAME] || [];
+    if (this.needSave) {
+      this.needSave = false;
+      updateStatistics(this.statistics);
     }
-  }, {
-    key: "mergeAdvancedStatistics",
-    value: function mergeAdvancedStatistics(advancedStatistics, deletePluginSettings) {
-      if (!Array.isArray(advancedStatistics) || advancedStatistics.length === 0 || this.statistics.some(function (dashboard) {
-        return dashboard.from_advanced;
-      }) // already merged from advanced
-      ) {
-        return;
-      }
-      var mergedStatistics = _toConsumableArray(this.statistics);
-      advancedStatistics.forEach(function (dashboard) {
-        var convertedDashboard = _objectSpread(_objectSpread({}, dashboard), {}, {
-          _id: generatorUniqueId(mergedStatistics),
-          from_advanced: true
-        });
-        var convertedCharts = Array.isArray(dashboard.stat_items) ? dashboard.stat_items.map(function (chart) {
-          if (!chart) return null;
-          var convertedChart = _objectSpread({}, chart);
-
-          // fix code spell from advanced
-          if (hasOwnProperty(chart, 'column_groupby_mutiple_numeric_column')) {
-            convertedChart.column_groupby_multiple_numeric_column = chart.column_groupby_mutiple_numeric_column;
+  }
+  convert2AdvanceStatistic() {
+    const statItems = this.statistics.map(chart => {
+      const {
+        type
+      } = chart;
+      switch (type) {
+        case STAT_TYPE.PIVOT_TABLE:
+          {
+            return this.convertPivotTable(chart);
           }
-          if (hasOwnProperty(chart, 'y_axis_left_group_by_mutiple_numeric_column')) {
-            convertedChart.y_axis_left_group_by_multiple_numeric_column = chart.y_axis_left_group_by_mutiple_numeric_column;
+        case STAT_TYPE.BAR:
+          {
+            return this.convertChartBar(chart);
           }
-          return convertedChart;
-        }).filter(Boolean) : [];
-        convertedDashboard.stat_items = convertedCharts;
-        mergedStatistics.push(convertedDashboard);
-      });
-      this.needSave = true;
-      this.statistics = mergedStatistics;
-      deletePluginSettings(ADVANCED_STATISTICS_NAME);
-    }
-  }, {
-    key: "getValidStatistics",
-    value: function getValidStatistics(statistics) {
-      var _this2 = this;
-      return statistics.map(function (dashboard) {
-        var charts = dashboard.stat_items || dashboard.statItems;
-        if (!Array.isArray(charts) || charts.length === 0) {
-          return dashboard;
-        }
-        charts = charts.filter(function (chart) {
-          return _this2.chartCalculator.isValidChart(chart);
-        });
-        charts = charts.map(function (chart, index) {
-          if (!chart.layout) {
-            return _objectSpread(_objectSpread({}, chart), {}, {
-              layout: {
-                i: chart._id,
-                x: index % 2 * 2,
-                y: Infinity,
-                w: 2,
-                h: 7
-              }
-            });
+        case STAT_TYPE.LINE:
+          {
+            return this.convertChartLine(chart);
           }
-          return chart;
-        });
-        return _objectSpread(_objectSpread({}, dashboard), {}, {
-          stat_items: charts
-        });
-      });
-    }
-  }, {
-    key: "getStatistics",
-    value: function getStatistics() {
-      return this.statistics;
-    }
-  }, {
-    key: "getStatisticById",
-    value: function getStatisticById(id) {
-      return this.statistics.find(function (statistic) {
-        return statistic._id === id;
-      });
-    }
-  }, {
-    key: "getColorThemeName",
-    value: function getColorThemeName() {
-      return this.statistics[0].chart_color_theme || 'theme0';
-    }
-  }, {
-    key: "update",
-    value: function update(_ref2) {
-      var action = _ref2.action,
-        payload = _ref2.payload;
-      switch (action) {
-        case DASHBOARD_ACTION_TYPE.MODIFY_COLOR_THEME:
+        case STAT_TYPE.PIE:
           {
-            var colorThemeName = payload.colorThemeName;
-            this.statistics = this.statistics.map(function (statistic) {
-              return _objectSpread(_objectSpread({}, statistic), {}, {
-                chart_color_theme: colorThemeName
-              });
+            return this.chartService.generatorChart({
+              ...chart,
+              type: STAT_TYPE.RING
             });
-            break;
           }
-        case DASHBOARD_ACTION_TYPE.ADD_DASHBOARD:
+        default:
           {
-            var dashboard = payload.dashboard;
-            this.statistics = [].concat(_toConsumableArray(this.statistics), [dashboard]);
-            break;
+            return null;
           }
-        case DASHBOARD_ACTION_TYPE.RENAME_DASHBOARD:
-          {
-            var index = payload.index,
-              name = payload.name;
-            if (!this.statistics[index]) {
-              break;
+      }
+    }).filter(Boolean);
+    this.statistics = [new StatisticDashBoard({
+      _id: generatorUniqueId([]),
+      stat_items: statItems,
+      name: this.defaultDashboardName
+    })];
+  }
+  convertPivotTable(chart) {
+    const {
+      summary_type,
+      summary_columns_option
+    } = chart;
+    let convertedChart = {
+      ...chart
+    };
+    if (summary_type === SUMMARY_TYPE.ADVANCED && summary_columns_option && summary_columns_option.length > 0) {
+      convertedChart.column_groupby_multiple_numeric_column = true;
+    }
+    return this.chartService.generatorChart(convertedChart);
+  }
+  convertChartBar(chart) {
+    const {
+      column_groupby_column_key,
+      y_axis_use_stack,
+      y_axis_summary_method,
+      column_groupby_multiple_numeric_column,
+      column_groupby_numeric_column_keys
+    } = chart;
+    let convertedChart = {
+      ...chart
+    };
+    const isGroupbyMultipleNumericColumns = column_groupby_multiple_numeric_column && column_groupby_numeric_column_keys && column_groupby_numeric_column_keys.length > 0;
+    if (column_groupby_column_key || isGroupbyMultipleNumericColumns) {
+      convertedChart.type = STAT_TYPE.BAR_GROUP;
+      if (y_axis_use_stack) {
+        convertedChart.type = STAT_TYPE.BAR_STACK;
+      }
+      if (isGroupbyMultipleNumericColumns) {
+        convertedChart.column_groupby_multiple_numeric_column = column_groupby_multiple_numeric_column;
+        convertedChart.column_groupby_numeric_columns = column_groupby_numeric_column_keys.map(key => {
+          if (!key) return null;
+          return {
+            column_key: key,
+            summary_method: y_axis_summary_method
+          };
+        }).filter(Boolean);
+      }
+    }
+    return this.chartService.generatorChart(convertedChart);
+  }
+  convertChartLine(chart) {
+    const {
+      column_groupby_column_key,
+      column_groupby_multiple_numeric_column,
+      column_groupby_numeric_column_keys,
+      y_axis_summary_method
+    } = chart;
+    const isGroupbyMultipleNumericColumns = column_groupby_multiple_numeric_column && column_groupby_numeric_column_keys && column_groupby_numeric_column_keys.length > 0;
+    let convertedChart = {
+      ...chart
+    };
+    if (column_groupby_column_key) {
+      convertedChart.type = STAT_TYPE.GROUP_LINE;
+      if (isGroupbyMultipleNumericColumns) {
+        convertedChart.column_groupby_multiple_numeric_column = column_groupby_multiple_numeric_column;
+        convertedChart.column_groupby_numeric_columns = column_groupby_numeric_column_keys.map(key => {
+          if (!key) return null;
+          return {
+            column_key: key,
+            summary_method: y_axis_summary_method
+          };
+        }).filter(Boolean);
+      }
+    }
+    return this.chartService.generatorChart(convertedChart);
+  }
+  getAdvancedStatistics(value) {
+    if (!value || !hasOwnProperty(value, 'plugin_settings') || !hasOwnProperty(value.plugin_settings, ADVANCED_STATISTICS_NAME)) {
+      return [];
+    }
+    return value.plugin_settings[ADVANCED_STATISTICS_NAME] || [];
+  }
+  mergeAdvancedStatistics(advancedStatistics, deletePluginSettings) {
+    if (!Array.isArray(advancedStatistics) || advancedStatistics.length === 0 || this.statistics.some(dashboard => dashboard.from_advanced) // already merged from advanced
+    ) {
+      return;
+    }
+    let mergedStatistics = [...this.statistics];
+    advancedStatistics.forEach(dashboard => {
+      let convertedDashboard = {
+        ...dashboard,
+        _id: generatorUniqueId(mergedStatistics),
+        from_advanced: true
+      };
+      let convertedCharts = Array.isArray(dashboard.stat_items) ? dashboard.stat_items.map(chart => {
+        if (!chart) return null;
+        let convertedChart = {
+          ...chart
+        };
+
+        // fix code spell from advanced
+        if (hasOwnProperty(chart, 'column_groupby_mutiple_numeric_column')) {
+          convertedChart.column_groupby_multiple_numeric_column = chart.column_groupby_mutiple_numeric_column;
+        }
+        if (hasOwnProperty(chart, 'y_axis_left_group_by_mutiple_numeric_column')) {
+          convertedChart.y_axis_left_group_by_multiple_numeric_column = chart.y_axis_left_group_by_mutiple_numeric_column;
+        }
+        return convertedChart;
+      }).filter(Boolean) : [];
+      convertedDashboard.stat_items = convertedCharts;
+      mergedStatistics.push(convertedDashboard);
+    });
+    this.needSave = true;
+    this.statistics = mergedStatistics;
+    deletePluginSettings(ADVANCED_STATISTICS_NAME);
+  }
+  getValidStatistics(statistics) {
+    return statistics.map(dashboard => {
+      let charts = dashboard.stat_items || dashboard.statItems;
+      if (!Array.isArray(charts) || charts.length === 0) {
+        return dashboard;
+      }
+      charts = charts.filter(chart => this.chartCalculator.isValidChart(chart));
+      charts = charts.map((chart, index) => {
+        if (!chart.layout) {
+          return {
+            ...chart,
+            layout: {
+              i: chart._id,
+              x: index % 2 * 2,
+              y: Infinity,
+              w: 2,
+              h: 7
             }
-            var updatedStatistics = _toConsumableArray(this.statistics);
-            updatedStatistics[index].name = name;
-            this.statistics = updatedStatistics;
+          };
+        }
+        return chart;
+      });
+      return {
+        ...dashboard,
+        stat_items: charts
+      };
+    });
+  }
+  getStatistics() {
+    return this.statistics;
+  }
+  getStatisticById(id) {
+    return this.statistics.find(statistic => statistic._id === id);
+  }
+  getColorThemeName() {
+    return this.statistics[0].chart_color_theme || 'theme0';
+  }
+  update(_ref2) {
+    let {
+      action,
+      payload
+    } = _ref2;
+    switch (action) {
+      case DASHBOARD_ACTION_TYPE.MODIFY_COLOR_THEME:
+        {
+          const {
+            colorThemeName
+          } = payload;
+          this.statistics = this.statistics.map(statistic => {
+            return {
+              ...statistic,
+              chart_color_theme: colorThemeName
+            };
+          });
+          break;
+        }
+      case DASHBOARD_ACTION_TYPE.ADD_DASHBOARD:
+        {
+          const {
+            dashboard
+          } = payload;
+          this.statistics = [...this.statistics, dashboard];
+          break;
+        }
+      case DASHBOARD_ACTION_TYPE.RENAME_DASHBOARD:
+        {
+          const {
+            index,
+            name
+          } = payload;
+          if (!this.statistics[index]) {
             break;
           }
-        case DASHBOARD_ACTION_TYPE.DELETE_DASHBOARD:
-          {
-            var _index = payload.index;
-            if (!this.statistics[_index]) {
-              break;
-            }
-            var _updatedStatistics = _toConsumableArray(this.statistics);
-            _updatedStatistics.splice(_index, 1);
-            this.statistics = _updatedStatistics;
+          let updatedStatistics = [...this.statistics];
+          updatedStatistics[index].name = name;
+          this.statistics = updatedStatistics;
+          break;
+        }
+      case DASHBOARD_ACTION_TYPE.DELETE_DASHBOARD:
+        {
+          const {
+            index
+          } = payload;
+          if (!this.statistics[index]) {
             break;
           }
-        case DASHBOARD_ACTION_TYPE.MOVE_DASHBOARD:
-          {
-            var draggedDashboardId = payload.draggedDashboardId,
-              targetBoardId = payload.targetBoardId,
-              relativePosition = payload.relativePosition;
-            var draggedDashboard = this.getStatisticById(draggedDashboardId);
-            var targetDashboard = this.getStatisticById(targetBoardId);
-            var draggedDashboardIndex = this.statistics.indexOf(draggedDashboard);
-            var targetDashboardIndex = this.statistics.indexOf(targetDashboard);
-            targetDashboardIndex += relativePosition == 'before' ? 0 : 1;
-            var _updatedStatistics2 = _toConsumableArray(this.statistics);
-            if (draggedDashboardIndex < targetDashboardIndex) {
-              if (targetDashboardIndex < _updatedStatistics2.length) {
-                _updatedStatistics2.splice(targetDashboardIndex, 0, draggedDashboard);
-              } else {
-                // drag it to the end
-                _updatedStatistics2.push(draggedDashboard);
-              }
-              _updatedStatistics2.splice(draggedDashboardIndex, 1);
+          let updatedStatistics = [...this.statistics];
+          updatedStatistics.splice(index, 1);
+          this.statistics = updatedStatistics;
+          break;
+        }
+      case DASHBOARD_ACTION_TYPE.MOVE_DASHBOARD:
+        {
+          const {
+            draggedDashboardId,
+            targetBoardId,
+            relativePosition
+          } = payload;
+          const draggedDashboard = this.getStatisticById(draggedDashboardId);
+          const targetDashboard = this.getStatisticById(targetBoardId);
+          const draggedDashboardIndex = this.statistics.indexOf(draggedDashboard);
+          let targetDashboardIndex = this.statistics.indexOf(targetDashboard);
+          targetDashboardIndex += relativePosition == 'before' ? 0 : 1;
+          let updatedStatistics = [...this.statistics];
+          if (draggedDashboardIndex < targetDashboardIndex) {
+            if (targetDashboardIndex < updatedStatistics.length) {
+              updatedStatistics.splice(targetDashboardIndex, 0, draggedDashboard);
             } else {
-              _updatedStatistics2.splice(draggedDashboardIndex, 1);
-              _updatedStatistics2.splice(targetDashboardIndex, 0, draggedDashboard);
+              // drag it to the end
+              updatedStatistics.push(draggedDashboard);
             }
-            this.statistics = _updatedStatistics2;
+            updatedStatistics.splice(draggedDashboardIndex, 1);
+          } else {
+            updatedStatistics.splice(draggedDashboardIndex, 1);
+            updatedStatistics.splice(targetDashboardIndex, 0, draggedDashboard);
+          }
+          this.statistics = updatedStatistics;
+          break;
+        }
+      case DASHBOARD_ACTION_TYPE.MODIFY_DASHBOARD_LAYOUT:
+        {
+          const {
+            index,
+            layout
+          } = payload;
+          let idChartLayoutMap = {};
+          layout && layout.forEach(chartLayout => {
+            idChartLayoutMap[chartLayout.i] = chartLayout;
+          });
+          let updatedStatistics = [...this.statistics];
+          let updatedDashboard = updatedStatistics[index];
+          if (!updatedDashboard) {
             break;
           }
-        case DASHBOARD_ACTION_TYPE.MODIFY_DASHBOARD_LAYOUT:
-          {
-            var _index2 = payload.index,
-              layout = payload.layout;
-            var idChartLayoutMap = {};
-            layout && layout.forEach(function (chartLayout) {
-              idChartLayoutMap[chartLayout.i] = chartLayout;
-            });
-            var _updatedStatistics3 = _toConsumableArray(this.statistics);
-            var updatedDashboard = _updatedStatistics3[_index2];
-            if (!updatedDashboard) {
-              break;
-            }
-            var stat_items = updatedDashboard.stat_items;
-            updatedDashboard.stat_items = stat_items.map(function (chart) {
-              var chartLayout = idChartLayoutMap[chart._id];
-              if (!chartLayout) return chart;
-              var x = chartLayout.x,
-                y = chartLayout.y,
-                w = chartLayout.w,
-                h = chartLayout.h,
-                i = chartLayout.i;
-              return Object.assign({}, chart, {
-                layout: {
-                  x: x,
-                  y: y,
-                  w: w,
-                  h: h,
-                  i: i
-                }
-              });
+          const {
+            stat_items
+          } = updatedDashboard;
+          updatedDashboard.stat_items = stat_items.map(chart => {
+            const chartLayout = idChartLayoutMap[chart._id];
+            if (!chartLayout) return chart;
+            const {
+              x,
+              y,
+              w,
+              h,
+              i
+            } = chartLayout;
+            return Object.assign({}, chart, {
+              layout: {
+                x,
+                y,
+                w,
+                h,
+                i
+              }
             });
-            _updatedStatistics3[_index2] = updatedDashboard;
-            this.statistics = _updatedStatistics3;
+          });
+          updatedStatistics[index] = updatedDashboard;
+          this.statistics = updatedStatistics;
+          break;
+        }
+      case DASHBOARD_ACTION_TYPE.ADD_CHART:
+        {
+          const {
+            index,
+            chart
+          } = payload;
+          const updatedStatistics = [...this.statistics];
+          let updatedDashboard = updatedStatistics[index];
+          if (!updatedDashboard) {
             break;
           }
-        case DASHBOARD_ACTION_TYPE.ADD_CHART:
-          {
-            var _index3 = payload.index,
-              chart = payload.chart;
-            var _updatedStatistics4 = _toConsumableArray(this.statistics);
-            var _updatedDashboard = _updatedStatistics4[_index3];
-            if (!_updatedDashboard) {
-              break;
-            }
-            var statItemsLen = _updatedDashboard.stat_items.length;
-            if (!chart.layout) {
-              chart.layout = {
-                i: chart._id,
-                x: statItemsLen % 2 * 2,
-                y: Infinity,
-                w: 2,
-                h: 7
-              };
-            }
-            _updatedDashboard.stat_items.push(chart);
-            this.statistics = _updatedStatistics4;
-            break;
+          const statItemsLen = updatedDashboard.stat_items.length;
+          if (!chart.layout) {
+            chart.layout = {
+              i: chart._id,
+              x: statItemsLen % 2 * 2,
+              y: Infinity,
+              w: 2,
+              h: 7
+            };
           }
-        case DASHBOARD_ACTION_TYPE.DELETE_CHART:
-          {
-            var _index4 = payload.index,
-              chart_id = payload.chart_id;
-            var _updatedStatistics5 = _toConsumableArray(this.statistics);
-            var _updatedDashboard2 = _updatedStatistics5[_index4];
-            if (!_updatedDashboard2) {
-              break;
-            }
-            var deleteIndex = _updatedDashboard2.stat_items.findIndex(function (chart) {
-              return chart._id === chart_id;
-            });
-            if (deleteIndex < 0) {
-              break;
-            }
-            _updatedDashboard2.stat_items.splice(deleteIndex, 1);
-            this.statistics = _updatedStatistics5;
+          updatedDashboard.stat_items.push(chart);
+          this.statistics = updatedStatistics;
+          break;
+        }
+      case DASHBOARD_ACTION_TYPE.DELETE_CHART:
+        {
+          const {
+            index,
+            chart_id
+          } = payload;
+          const updatedStatistics = [...this.statistics];
+          let updatedDashboard = updatedStatistics[index];
+          if (!updatedDashboard) {
             break;
           }
-        case DASHBOARD_ACTION_TYPE.MODIFY_CHART:
-          {
-            var _index5 = payload.index,
-              _chart = payload.chart;
-            var charId = _chart._id;
-            var _updatedStatistics6 = _toConsumableArray(this.statistics);
-            var _updatedDashboard3 = _updatedStatistics6[_index5];
-            if (!_updatedDashboard3) {
-              break;
-            }
-            var updateIndex = _updatedDashboard3.stat_items.findIndex(function (chart) {
-              return chart._id === charId;
-            });
-            if (updateIndex < 0) {
-              break;
-            }
-            _updatedDashboard3.stat_items[updateIndex] = _chart;
-            this.statistics = _updatedStatistics6;
+          let deleteIndex = updatedDashboard.stat_items.findIndex(chart => chart._id === chart_id);
+          if (deleteIndex < 0) {
             break;
           }
-        case DASHBOARD_ACTION_TYPE.MOVE_CHART_TO_VIEW:
-          {
-            var _index6 = payload.index,
-              _chart_id = payload.chart_id,
-              target_view_id = payload.target_view_id;
-            var _updatedStatistics7 = _toConsumableArray(this.statistics);
-            var currentDashboard = _updatedStatistics7[_index6];
-            if (!currentDashboard || !Array.isArray(currentDashboard.stat_items)) break;
-            var movedChartIndex = currentDashboard.stat_items.findIndex(function (chart) {
-              return chart._id === _chart_id;
-            });
-            if (movedChartIndex < 0) break;
-            var _targetDashboard = target_view_id && _updatedStatistics7.find(function (view) {
-              return view._id === target_view_id;
-            });
-            if (!_targetDashboard) break;
-            var movedCharts = currentDashboard.stat_items.splice(movedChartIndex, 1);
-            var movedChart = movedCharts && movedCharts[0];
-            if (!movedChart) break;
-            var newChartId = movedChart._id;
-            if (!Array.isArray(_targetDashboard.stat_items)) {
-              _targetDashboard.stat_items = [];
-            } else {
-              newChartId = generatorUniqueId(_targetDashboard.statItems);
-            }
-            movedChart = Object.assign(movedChart, {
-              _id: newChartId,
-              layout: {
-                i: newChartId,
-                x: _targetDashboard.stat_items.length % 2 * 2,
-                y: Infinity,
-                w: 2,
-                h: 7
-              }
-            });
-            _targetDashboard.stat_items.push(movedChart);
-            this.statistics = _updatedStatistics7;
+          updatedDashboard.stat_items.splice(deleteIndex, 1);
+          this.statistics = updatedStatistics;
+          break;
+        }
+      case DASHBOARD_ACTION_TYPE.MODIFY_CHART:
+        {
+          const {
+            index,
+            chart
+          } = payload;
+          const charId = chart._id;
+          const updatedStatistics = [...this.statistics];
+          let updatedDashboard = updatedStatistics[index];
+          if (!updatedDashboard) {
             break;
           }
-        default:
-          {
+          let updateIndex = updatedDashboard.stat_items.findIndex(chart => chart._id === charId);
+          if (updateIndex < 0) {
             break;
           }
-      }
-      return this.getStatistics();
+          updatedDashboard.stat_items[updateIndex] = chart;
+          this.statistics = updatedStatistics;
+          break;
+        }
+      case DASHBOARD_ACTION_TYPE.MOVE_CHART_TO_VIEW:
+        {
+          const {
+            index,
+            chart_id,
+            target_view_id
+          } = payload;
+          const updatedStatistics = [...this.statistics];
+          let currentDashboard = updatedStatistics[index];
+          if (!currentDashboard || !Array.isArray(currentDashboard.stat_items)) break;
+          let movedChartIndex = currentDashboard.stat_items.findIndex(chart => chart._id === chart_id);
+          if (movedChartIndex < 0) break;
+          let targetDashboard = target_view_id && updatedStatistics.find(view => view._id === target_view_id);
+          if (!targetDashboard) break;
+          const movedCharts = currentDashboard.stat_items.splice(movedChartIndex, 1);
+          let movedChart = movedCharts && movedCharts[0];
+          if (!movedChart) break;
+          let newChartId = movedChart._id;
+          if (!Array.isArray(targetDashboard.stat_items)) {
+            targetDashboard.stat_items = [];
+          } else {
+            newChartId = generatorUniqueId(targetDashboard.statItems);
+          }
+          movedChart = Object.assign(movedChart, {
+            _id: newChartId,
+            layout: {
+              i: newChartId,
+              x: targetDashboard.stat_items.length % 2 * 2,
+              y: Infinity,
+              w: 2,
+              h: 7
+            }
+          });
+          targetDashboard.stat_items.push(movedChart);
+          this.statistics = updatedStatistics;
+          break;
+        }
+      default:
+        {
+          break;
+        }
     }
-  }]);
-  return DashBoardService;
-}();
+    return this.getStatistics();
+  }
+}
 export default DashBoardService;