ngx-hana-nameserver-history-viewer 1.1.3 → 1.1.90

package/esm2020/src/nameserver-history-viewer/services/chart.service.mjs

@@ -0,0 +1,323 @@
+import { Injectable } from '@angular/core';
+import { Chart } from 'chart.js';
+import { getColorString, getNumberWithCommas, randomColor } from '../utils';
+import { UIService } from './ui.service';
+import { Item, Unit } from '../types';
+import * as i0 from "@angular/core";
+// Using dynamic flag to fix the issue of ng-packagr #696: Lambda not supported
+// @dynamic
+export class ChartService {
+    /**
+     * toggle the dataset status of the chart, synchronously
+     */
+    static _toggleDataSet(dataSetIndex, chart, hidden) {
+        // meta.hidden = false and dataset.hidden = false --> show
+        // meta.hidden = false and dataset.hidden = true --> show
+        // meta.hidden = null and dataset.hidden = false -> show
+        // meta.hidden = null and dataset.hidden = true -> hide
+        // in the first case (false, false), needs to click legend twice to
+        // hide the dataset, because the first click only set meta.hidden = null)
+        if (dataSetIndex != null && chart != null) {
+            const meta = chart.getDatasetMeta(dataSetIndex);
+            if (meta) {
+                if (!hidden) {
+                    // display the item, if dataset hidden is false, set hidden of meta to null,
+                    meta.hidden = !chart.data.datasets[dataSetIndex].hidden ? null : hidden;
+                }
+                else {
+                    meta.hidden = hidden;
+                }
+            }
+        }
+    }
+    static _restoreDataSetStatus(chart, datasetIndex, status) {
+        if (chart && chart.data && chart.data.datasets && chart.getDatasetMeta(datasetIndex) && status) {
+            chart.data.datasets[datasetIndex].hidden = status.datasetStatus;
+            chart.getDatasetMeta(datasetIndex).hidden = status.metaStatus;
+        }
+    }
+    /**
+     * initialize/clear the configuration for the chart
+     */
+    static _initConfig(chart) {
+        // init data sets
+        if (chart.data && chart.data.datasets) {
+            chart.data.datasets.length = 0;
+            chart.data.datasets = void 0;
+            chart.data = void 0;
+        }
+        // init options
+        if (chart.options && chart.options.scales && (chart.options.scales.xAxes || chart.options.scales.yAxis)) {
+            if (chart.options.scales.xAxes) {
+                chart.options.scales.xAxes.length = 0;
+                chart.options.scales.xAxes = void 0;
+            }
+            if (chart.options.scales.yAxes) {
+                chart.options.scales.yAxes.length = 0;
+                chart.options.scales.yAxes = void 0;
+            }
+            chart.options.scales = void 0;
+            chart.options = void 0;
+        }
+    }
+    /**
+     * Generate DataSets by the data and header information
+     */
+    static _generateDataSets(data, header, headerKey, defaultItems) {
+        const alpha = 0.5;
+        const colors = UIService.getColors(alpha);
+        return data.map((item, i) => {
+            const color = colors[headerKey[i]] ? getColorString(colors[headerKey[i]]) : randomColor(alpha);
+            return {
+                borderColor: color,
+                backgroundColor: color,
+                borderWidth: 1.25,
+                spanGaps: false,
+                label: header[i],
+                data: data[i],
+                fill: false,
+                yAxisID: `y-axis-${i}`,
+                hidden: !defaultItems.includes(header[i])
+            };
+        });
+    }
+    static _generateXAxes(time) {
+        const format = 'MMMDD HH:mm:ss';
+        return [
+            {
+                type: 'time',
+                time: {
+                    // unit: 'second',
+                    // stepSize: 1,
+                    displayFormats: {
+                        'millisecond': format,
+                        'second': format,
+                        'minute': format,
+                        'hour': 'MMMDD HH',
+                        'day': 'MMMDD YYYY',
+                        'week': format,
+                        'month': format,
+                        'quarter': format,
+                        'year': format,
+                    },
+                    tooltipFormat: 'll HH:mm:ss',
+                    min: time[0],
+                    max: time[time.length - 1]
+                },
+                // scaleLabel: {
+                //   display: false,
+                //   labelString: 'Date'
+                // },
+                ticks: {
+                    maxRotation: 0,
+                    reverse: true
+                }
+            }
+        ];
+    }
+    static _generateYAxes(data, yScale) {
+        return data.map((item, i) => ({
+            type: 'linear',
+            display: false,
+            position: 'left',
+            id: `y-axis-${i}`,
+            gridLines: {},
+            ticks: {
+                min: 0,
+                max: yScale[i]
+            }
+        }));
+    }
+    /**
+     * generate configuration for chart
+     */
+    static _generateChartConfig(time, data, yScale, header, headerKey, selection, tableSource, title, defaultItems, zoomCallback) {
+        return {
+            type: 'line',
+            data: {
+                datasets: ChartService._generateDataSets(data, header, headerKey, defaultItems)
+            },
+            options: {
+                elements: { point: { radius: 0, hitRadius: 5, hoverRadius: 5 } },
+                responsive: true,
+                animation: {
+                    duration: 0, // general animation time
+                },
+                hover: {
+                    animationDuration: 0,
+                    onHover: function (e) {
+                        const point = this.getElementAtEvent(e);
+                        if (point.length) {
+                            e.target.style.cursor = 'pointer';
+                        }
+                        else {
+                            e.target.style.cursor = 'default';
+                        }
+                    }
+                },
+                responsiveAnimationDuration: 0,
+                legend: {
+                    position: 'bottom',
+                    onHover: (e) => {
+                        e.target.style.cursor = 'pointer';
+                    },
+                    labels: {
+                        filter: (legendItem) => selection.isSelected(tableSource.find(row => legendItem.text === row.KPI))
+                    }
+                },
+                title: {
+                    display: true,
+                    text: title
+                },
+                responsiveDownsample: {
+                    enabled: true,
+                    desiredDataPointDistance: 2,
+                    minNumPoints: 200,
+                    maxNumPointsToDraw: 100
+                },
+                tooltips: {
+                    callbacks: {
+                        label: function (tooltipItem, chartData) {
+                            // format numbers with commas and add unit information
+                            const label = chartData.datasets[tooltipItem.datasetIndex].label || '';
+                            if (label) {
+                                // get unit (eg: MB, GB, MB/s, % and so on)
+                                const rowItem = tableSource.find(controlTableRow => label === controlTableRow.KPI) || '';
+                                const unit = rowItem[Item.unit] && rowItem[Item.unit] !== Unit.PCT ? ` ${rowItem[Item.unit]}` : rowItem[Item.unit] || '';
+                                return `${label}: ${getNumberWithCommas(tooltipItem.yLabel)}${unit}`;
+                            }
+                            else {
+                                return getNumberWithCommas(tooltipItem.yLabel);
+                            }
+                        }
+                    }
+                },
+                scales: {
+                    xAxes: ChartService._generateXAxes(time),
+                    yAxes: ChartService._generateYAxes(data, yScale)
+                },
+                zoom: {
+                    enabled: true,
+                    drag: true,
+                    mode: 'x',
+                    onZoom: zoomCallback
+                }
+            }
+        };
+    }
+    _getDataSetIndexByLabel(label, chart) {
+        if (chart.data && chart.data.datasets) {
+            return chart.data.datasets.findIndex(dataset => dataset.label === label);
+        }
+        return -1;
+    }
+    /**
+     * destroy the chart, release the resource of the chart
+     */
+    _destroyChart(chart) {
+        return new Promise((resolve) => {
+            if (chart) {
+                chart.destroy();
+            }
+            resolve();
+        });
+    }
+    /**
+     * update/refresh the chart
+     */
+    _updateChart(chart) {
+        return new Promise((resolve, reject) => {
+            if (chart) {
+                chart.update();
+                resolve();
+            }
+            else {
+                reject('Updating chart failed, error: the chart object is empty.');
+            }
+        });
+    }
+    /**
+     * reset zoom of the chart
+     */
+    _resetZoom(chart) {
+        return new Promise((resolve, reject) => {
+            if (chart) {
+                const datasetStatusBeforeReset = [];
+                if (chart.data && chart.data.datasets) {
+                    chart.data.datasets.forEach((dataset, index) => {
+                        const meta = chart.getDatasetMeta(index);
+                        if (meta) {
+                            datasetStatusBeforeReset[index] = { metaStatus: meta.hidden, datasetStatus: dataset.hidden };
+                        }
+                        else {
+                            reject(`Internal error, can not find the meta ${index}.`);
+                        }
+                    });
+                }
+                chart.resetZoom();
+                resolve(datasetStatusBeforeReset);
+            }
+            else {
+                reject('Resetting chart failed, error: the chart object is empty.');
+            }
+        });
+    }
+    /**
+     * Reset Chart to initial status
+     * If legend is already selected/unselected from the list, it wouldn't be restored.
+     * @param dataSourceData the data sets of the chart
+     * @param selection selection status list
+     */
+    resetChart(dataSourceData, selection) {
+        return this._resetZoom(this._chart).then((datasetStatusBeforeZoom) => {
+            // reset the data set by the selection status
+            dataSourceData.filter(row => !row.header).forEach(row => {
+                const index = this._getDataSetIndexByLabel(row.KPI, this._chart);
+                if (!selection.isSelected(row)) {
+                    ChartService._toggleDataSet(index, this._chart, true);
+                }
+                else {
+                    ChartService._restoreDataSetStatus(this._chart, index, datasetStatusBeforeZoom[index]);
+                }
+            });
+            return this._updateChart(this._chart);
+        });
+    }
+    /**
+     * destroy the chart and reinitialize the configuration of the chart
+     */
+    destroyChart() {
+        return this._destroyChart(this._chart).then(() => {
+            if (this._chart) {
+                ChartService._initConfig(this._chart);
+                this._chart = void 0;
+            }
+        });
+    }
+    /**
+     * generate configuration for chart and create the chart object.
+     */
+    buildChart(time, data, yScale, header, headerKey, selection, tableSource, title, defaultItems, zoomCB) {
+        return new Promise((resolve) => {
+            const ctx = document.getElementById('chartNameServerHistory').getContext('2d');
+            const cfg = ChartService._generateChartConfig(time, data, yScale, header, headerKey, selection, tableSource, title, defaultItems, zoomCB);
+            this._chart = new Chart(ctx, cfg);
+            resolve();
+        });
+    }
+    /**
+     * show/hide the relative data set
+     */
+    toggleDataInChart(label, hide) {
+        return new Promise((resolve) => {
+            ChartService._toggleDataSet(this._getDataSetIndexByLabel(label, this._chart), this._chart, hide);
+            resolve(this._updateChart(this._chart));
+        });
+    }
+}
+ChartService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: ChartService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ChartService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: ChartService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: ChartService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart.service.js","sourceRoot":"","sources":["../../../../../src/nameserver-history-viewer/services/chart.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { SelectionModel } from '@angular/cdk/collections';\r\nimport { Chart } from 'chart.js';\r\nimport { getColorString, getNumberWithCommas, randomColor } from '../utils';\r\nimport { UIService } from './ui.service';\r\nimport { ChartContentDataItem, LegendColor, Item, Unit } from '../types';\r\n\r\n// Using dynamic flag to fix the issue of ng-packagr #696: Lambda not supported\r\n// @dynamic\r\n@Injectable()\r\nexport class ChartService {\r\n  private _chart: Chart;\r\n\r\n  /**\r\n   * toggle the dataset status of the chart, synchronously\r\n   */\r\n  private static _toggleDataSet(dataSetIndex: number, chart: Chart, hidden: boolean): void {\r\n    // meta.hidden = false and dataset.hidden = false --> show\r\n    // meta.hidden = false and dataset.hidden = true --> show\r\n    // meta.hidden = null and dataset.hidden = false -> show\r\n    // meta.hidden = null and dataset.hidden = true -> hide\r\n    // in the first case (false, false), needs to click legend twice to\r\n    // hide the dataset, because the first click only set meta.hidden = null)\r\n    if (dataSetIndex != null && chart != null) {\r\n      const meta = chart.getDatasetMeta(dataSetIndex);\r\n      if (meta) {\r\n        if (!hidden) {\r\n          // display the item, if dataset hidden is false, set hidden of meta to null,\r\n          meta.hidden = !chart.data.datasets[dataSetIndex].hidden ? null : hidden;\r\n        } else {\r\n          meta.hidden = hidden;\r\n        }\r\n      }\r\n    }\r\n  }\r\n  private static _restoreDataSetStatus(chart: Chart, datasetIndex: number, status: {metaStatus: boolean, datasetStatus: boolean}): void {\r\n    if (chart && chart.data && chart.data.datasets && chart.getDatasetMeta(datasetIndex) && status) {\r\n      chart.data.datasets[datasetIndex].hidden = status.datasetStatus;\r\n      chart.getDatasetMeta(datasetIndex).hidden = status.metaStatus;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * initialize/clear the configuration for the chart\r\n   */\r\n  private static _initConfig(chart: any): void {\r\n    // init data sets\r\n    if (chart.data && chart.data.datasets) {\r\n      chart.data.datasets.length = 0;\r\n      chart.data.datasets = void 0;\r\n      chart.data = void 0;\r\n    }\r\n    // init options\r\n    if (chart.options && chart.options.scales && (chart.options.scales.xAxes || chart.options.scales.yAxis)) {\r\n      if (chart.options.scales.xAxes) {\r\n        chart.options.scales.xAxes.length = 0;\r\n        chart.options.scales.xAxes = void 0;\r\n      }\r\n      if (chart.options.scales.yAxes) {\r\n        chart.options.scales.yAxes.length = 0;\r\n        chart.options.scales.yAxes = void 0;\r\n      }\r\n      chart.options.scales = void 0;\r\n      chart.options = void 0;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Generate DataSets by the data and header information\r\n   */\r\n  private static _generateDataSets(data: ChartContentDataItem[][], header: string[], headerKey: string[], defaultItems: string[]): any {\r\n    const alpha = 0.5;\r\n    const colors: LegendColor = UIService.getColors(alpha);\r\n    return data.map((item, i) => {\r\n      const color = colors[headerKey[i]] ? getColorString(colors[headerKey[i]]) : randomColor(alpha);\r\n      return {\r\n        borderColor: color,\r\n        backgroundColor: color,\r\n        borderWidth: 1.25,\r\n        spanGaps: false,\r\n        label: header[i],\r\n        data: data[i],\r\n        fill: false,\r\n        yAxisID: `y-axis-${i}`,\r\n        hidden: !defaultItems.includes(header[i])\r\n      };\r\n    });\r\n  }\r\n  private static _generateXAxes(time: number[]): any {\r\n    const format = 'MMMDD HH:mm:ss';\r\n    return [\r\n      {\r\n        type: 'time',\r\n        time: {\r\n          // unit: 'second',\r\n          // stepSize: 1,\r\n          displayFormats: {\r\n            'millisecond': format,\r\n            'second': format,\r\n            'minute': format,\r\n            'hour': 'MMMDD HH',\r\n            'day': 'MMMDD YYYY',\r\n            'week': format,\r\n            'month': format,\r\n            'quarter': format,\r\n            'year': format,\r\n          },\r\n          tooltipFormat: 'll HH:mm:ss',\r\n          min: time[0],\r\n          max: time[time.length - 1]\r\n        },\r\n        // scaleLabel: {\r\n        //   display: false,\r\n        //   labelString: 'Date'\r\n        // },\r\n        ticks: {\r\n          maxRotation: 0,\r\n          reverse: true\r\n        }\r\n      }\r\n    ];\r\n  }\r\n  private static _generateYAxes(data: ChartContentDataItem[][], yScale: number[]): any {\r\n    return data.map((item, i) => ({\r\n      type: 'linear',\r\n      display: false,\r\n      position: 'left',\r\n      id: `y-axis-${i}`,\r\n      gridLines: {\r\n      },\r\n      ticks: {\r\n        min: 0,\r\n        max: yScale[i]\r\n      }\r\n    }));\r\n  }\r\n\r\n  /**\r\n   * generate configuration for chart\r\n   */\r\n  private static _generateChartConfig(time: number[],\r\n                                      data: ChartContentDataItem[][],\r\n                                      yScale: number[],\r\n                                      header: string[],\r\n                                      headerKey: string[],\r\n                                      selection: SelectionModel<any>,\r\n                                      tableSource: any,\r\n                                      title: string,\r\n                                      defaultItems: string[],\r\n                                      zoomCallback: any): any {\r\n    return {\r\n      type: 'line',\r\n      data: {\r\n        datasets: ChartService._generateDataSets(data, header, headerKey, defaultItems)\r\n      },\r\n      options: {\r\n        elements: {point: {radius: 0, hitRadius: 5, hoverRadius: 5}}, // set radius to 0 not to display point\r\n        responsive: true,\r\n        animation: {\r\n          duration: 0, // general animation time\r\n        },\r\n        hover: {\r\n          animationDuration: 0, // duration of animations when hovering an item\r\n          onHover: function (e) {\r\n            const point = this.getElementAtEvent(e);\r\n            if (point.length) {\r\n              e.target.style.cursor = 'pointer';\r\n            } else {\r\n              e.target.style.cursor = 'default';\r\n            }\r\n          }\r\n        },\r\n        responsiveAnimationDuration: 0, // animation duration after a resize\r\n        legend: {\r\n          position: 'bottom',\r\n          onHover: (e) => {\r\n            e.target.style.cursor = 'pointer';\r\n          },\r\n          labels: {\r\n            filter: (legendItem) => selection.isSelected(tableSource.find(row => legendItem.text === row.KPI))\r\n          }\r\n        },\r\n        title: {\r\n          display: true,\r\n          text: title\r\n        },\r\n        responsiveDownsample: {\r\n          enabled: true,\r\n          desiredDataPointDistance: 2,\r\n          minNumPoints: 200,\r\n          maxNumPointsToDraw: 100\r\n        },\r\n        tooltips: {\r\n          callbacks: {\r\n            label: function(tooltipItem, chartData) {\r\n              // format numbers with commas and add unit information\r\n              const label = chartData.datasets[tooltipItem.datasetIndex].label || '';\r\n              if (label) {\r\n                // get unit (eg: MB, GB, MB/s, % and so on)\r\n                const rowItem = tableSource.find(controlTableRow => label === controlTableRow.KPI) || '';\r\n                const unit = rowItem[Item.unit] && rowItem[Item.unit] !== Unit.PCT ? ` ${rowItem[Item.unit]}` : rowItem[Item.unit] || '';\r\n                return `${label}: ${getNumberWithCommas(tooltipItem.yLabel)}${unit}`;\r\n              } else {\r\n                return getNumberWithCommas(tooltipItem.yLabel);\r\n              }\r\n            }\r\n          }\r\n        },\r\n        scales: {\r\n          xAxes: ChartService._generateXAxes(time),\r\n          yAxes: ChartService._generateYAxes(data, yScale)\r\n        },\r\n        zoom: {\r\n          enabled: true,\r\n          drag: true,\r\n          mode: 'x',\r\n          onZoom: zoomCallback\r\n        }\r\n      }\r\n    };\r\n  }\r\n\r\n  private _getDataSetIndexByLabel(label: string, chart: Chart): number {\r\n    if (chart.data && chart.data.datasets) {\r\n      return chart.data.datasets.findIndex(dataset => dataset.label === label);\r\n    }\r\n    return -1;\r\n  }\r\n\r\n  /**\r\n   * destroy the chart, release the resource of the chart\r\n   */\r\n  private _destroyChart(chart: Chart): Promise<void> {\r\n    return new Promise((resolve) => {\r\n      if (chart) {\r\n        chart.destroy();\r\n      }\r\n      resolve();\r\n    });\r\n  }\r\n  /**\r\n   * update/refresh the chart\r\n   */\r\n  private _updateChart(chart: Chart): Promise<void> {\r\n    return new Promise((resolve, reject) => {\r\n      if (chart) {\r\n        chart.update();\r\n        resolve();\r\n      } else {\r\n        reject('Updating chart failed, error: the chart object is empty.');\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * reset zoom of the chart\r\n   */\r\n  private _resetZoom(chart: any): Promise<{metaStatus: boolean, datasetStatus: boolean}[]> {\r\n    return new Promise((resolve, reject) => {\r\n      if (chart) {\r\n        const datasetStatusBeforeReset = [];\r\n        if (chart.data && chart.data.datasets) {\r\n          chart.data.datasets.forEach((dataset, index) => {\r\n            const meta = chart.getDatasetMeta(index);\r\n            if (meta) {\r\n              datasetStatusBeforeReset[index] = {metaStatus: meta.hidden, datasetStatus: dataset.hidden};\r\n            } else {\r\n              reject(`Internal error, can not find the meta ${index}.`);\r\n            }\r\n          });\r\n        }\r\n        chart.resetZoom();\r\n        resolve(datasetStatusBeforeReset);\r\n      } else {\r\n        reject('Resetting chart failed, error: the chart object is empty.');\r\n      }\r\n    });\r\n  }\r\n  /**\r\n   * Reset Chart to initial status\r\n   * If legend is already selected/unselected from the list, it wouldn't be restored.\r\n   * @param dataSourceData the data sets of the chart\r\n   * @param selection selection status list\r\n   */\r\n  public resetChart(dataSourceData: any, selection: SelectionModel<any>): Promise <any> {\r\n    return this._resetZoom(this._chart).then((datasetStatusBeforeZoom) => {\r\n      // reset the data set by the selection status\r\n      dataSourceData.filter(row => !row.header).forEach(row => {\r\n        const index = this._getDataSetIndexByLabel(row.KPI, this._chart);\r\n        if (!selection.isSelected(row)) {\r\n          ChartService._toggleDataSet(index, this._chart, true);\r\n        } else {\r\n          ChartService._restoreDataSetStatus(this._chart, index, datasetStatusBeforeZoom[index]);\r\n        }\r\n      });\r\n      return this._updateChart(this._chart);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * destroy the chart and reinitialize the configuration of the chart\r\n   */\r\n  public destroyChart(): Promise<any> {\r\n    return this._destroyChart(this._chart).then(() => {\r\n      if (this._chart) {\r\n        ChartService._initConfig(this._chart);\r\n        this._chart = void 0;\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * generate configuration for chart and create the chart object.\r\n   */\r\n  public buildChart(time: number[],\r\n                    data: ChartContentDataItem[][],\r\n                    yScale: number[],\r\n                    header: string[],\r\n                    headerKey: string[],\r\n                    selection: SelectionModel<any>,\r\n                    tableSource: any,\r\n                    title: string,\r\n                    defaultItems: string[],\r\n                    zoomCB): Promise<void> {\r\n    return new Promise((resolve) => {\r\n      const ctx = (<HTMLCanvasElement> document.getElementById('chartNameServerHistory')).getContext('2d');\r\n      const cfg: any = ChartService._generateChartConfig(time, data, yScale, header, headerKey, selection, tableSource, title, defaultItems, zoomCB);\r\n      this._chart = new Chart(ctx, cfg);\r\n      resolve();\r\n    });\r\n  }\r\n\r\n  /**\r\n   * show/hide the relative data set\r\n   */\r\n  public toggleDataInChart(label: string, hide: boolean): Promise<any> {\r\n    return new Promise((resolve) => {\r\n      ChartService._toggleDataSet(this._getDataSetIndexByLabel(label, this._chart), this._chart, hide);\r\n      resolve(this._updateChart(this._chart));\r\n    });\r\n  }\r\n}\r\n"]}