nuxeo-development-framework 3.1.2 → 3.1.3

package/esm2015/lib/components/dynamic-chart/services/chart-data.service.js

@@ -0,0 +1,552 @@
+import { EventEmitter, Injectable } from '@angular/core';
+import moment from 'moment-es6';
+import * as _ from 'lodash';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "../../../Core/services/translation/translation.service";
+export class ChartDataService {
+    constructor(translate, translation) {
+        this.translate = translate;
+        this.translation = translation;
+        this.refreshData = new EventEmitter();
+        this.prefix = 'STATS.';
+        this.size = 8;
+        this.totalNumber = [
+            {
+                beforeDraw: (chart) => {
+                    if (chart.config.options.elements.center) {
+                        // Get ctx from string
+                        var ctx = chart.chart.ctx;
+                        // Get options from the center object in options
+                        var centerConfig = chart.config.options.elements.center;
+                        var fontStyle = centerConfig.fontStyle || 'Arial';
+                        var txt = centerConfig.text;
+                        var color = centerConfig.color || '#000';
+                        var maxFontSize = centerConfig.maxFontSize || 75;
+                        var sidePadding = centerConfig.sidePadding || 20;
+                        var sidePaddingCalculated = (sidePadding / 100) * (chart.innerRadius * 2);
+                        // Start with a base font of 30px
+                        ctx.font = '30px ' + fontStyle;
+                        // Get the width of the string and also the width of the element minus 10 to give it 5px side padding
+                        var stringWidth = ctx.measureText(txt).width;
+                        var elementWidth = chart.innerRadius * 2 - sidePaddingCalculated;
+                        // Find out how much the font can grow in width.
+                        var widthRatio = elementWidth / stringWidth;
+                        var newFontSize = Math.floor(30 * widthRatio);
+                        var elementHeight = chart.innerRadius * 2;
+                        // Pick a new font size so it will not be larger than the height of label.
+                        var fontSizeToUse = Math.min(newFontSize, elementHeight, maxFontSize);
+                        var minFontSize = centerConfig.minFontSize;
+                        var lineHeight = centerConfig.lineHeight || 25;
+                        var wrapText = false;
+                        if (minFontSize === undefined) {
+                            minFontSize = 20;
+                        }
+                        if (minFontSize && fontSizeToUse < minFontSize) {
+                            fontSizeToUse = minFontSize;
+                            wrapText = true;
+                        }
+                        // Set font settings to draw it correctly.
+                        ctx.textAlign = 'center';
+                        ctx.textBaseline = 'middle';
+                        var centerX = (chart.chartArea.left + chart.chartArea.right) / 2;
+                        var centerY = (chart.chartArea.top + chart.chartArea.bottom) / 2;
+                        ctx.font = '14' + 'px ' + fontStyle;
+                        ctx.fillStyle = color;
+                        if (!wrapText) {
+                            ctx.fillText(txt, centerX, centerY);
+                            return;
+                        }
+                        var words = txt.split(' ');
+                        var line = '';
+                        var lines = [];
+                        // Break words up into multiple lines if necessary
+                        for (var n = 0; n < words.length; n++) {
+                            var testLine = line + words[n] + ' ';
+                            var metrics = ctx.measureText(testLine);
+                            var testWidth = metrics.width;
+                            if (testWidth > elementWidth && n > 0) {
+                                lines.push(line);
+                                line = words[n] + ' ';
+                            }
+                            else {
+                                line = testLine;
+                            }
+                        }
+                        // Move the center up depending on line height and number of lines
+                        centerY -= (lines.length / 2) * lineHeight;
+                        for (var n = 0; n < lines.length; n++) {
+                            ctx.fillText(lines[n], centerX, centerY);
+                            centerY += lineHeight;
+                        }
+                        //Draw text in center
+                        ctx.fillText(line, centerX, centerY);
+                    }
+                },
+            },
+        ];
+        this.groupObjectBykey = (data) => {
+            let nameIndices = {};
+            let statusHash = {};
+            let chartData = { labels: [], datasets: [] };
+            data.forEach((item) => {
+                if (!(item.label in nameIndices)) {
+                    nameIndices[item.label] = chartData.labels.push(item.label) - 1;
+                    chartData.datasets.forEach((a) => {
+                        a.data.push(0);
+                    });
+                }
+                if (!statusHash[item.status]) {
+                    statusHash[item.status] = Object.assign(Object.assign(Object.assign({ label: `${this.translate.instant(item.status)} (${item.totalItems})` }, (item.status === 'Incoming' && {
+                        backgroundColor: '#00dca5',
+                    })), (item.status === 'Outgoing' && {
+                        backgroundColor: '#fbb62c',
+                    })), { data: chartData.labels.map(() => {
+                            return 0;
+                        }), barPercentage: 0.4, barThickness: 24, maxBarThickness: 30, minBarLength: 2 });
+                    chartData.datasets.push(statusHash[item.status]);
+                }
+                statusHash[item.status].data[nameIndices[item.label]] = item.count;
+            });
+            return chartData;
+        };
+        this.groupObjectBykeyLine = (data) => {
+            data.sort((left, right) => {
+                return moment.utc(left.id).diff(moment.utc(right.id));
+            });
+            let nameIndices = {};
+            let statusHash = {};
+            let chartData = { labels: [], datasets: [] };
+            data.forEach((item) => {
+                if (!(item.id in nameIndices)) {
+                    nameIndices[item.id] = chartData.labels.push(item.id) - 1;
+                    chartData.datasets.forEach((a) => {
+                        a.data.push(0);
+                    });
+                }
+                if (!statusHash[item.status]) {
+                    statusHash[item.status] = Object.assign(Object.assign(Object.assign({ label: `${this.translate.instant(item.status)} (${item.totalItems})` }, (item.status === 'Incoming' && {
+                        borderColor: '#00dca5',
+                    })), (item.status === 'Outgoing' && {
+                        borderColor: '#fbb62c',
+                    })), { fill: false, lineTension: 0, data: chartData.labels.map(() => {
+                            return 0;
+                        }) });
+                    chartData.datasets.push(statusHash[item.status]);
+                }
+                statusHash[item.status].data[nameIndices[item.id]] = item.count;
+            });
+            return chartData;
+        };
+        this.translation.isArabic.subscribe((arabic) => {
+            arabic ? (this.isArabic = arabic) : (this.isArabic = arabic);
+        });
+    }
+    /**
+     *
+     * @param data data fetched from back-end
+     * @param totalItems totalItems from the backedn
+     * @param prefix for Translations
+     * @returns
+     */
+    multiSeriesPieChart(data) {
+        const provideColors = data.colors;
+        const prefix = data.prefix;
+        const totalItems = data.totalItems;
+        let dataArr = [];
+        let labels = [];
+        //for aggregations
+        let itemCount = 0;
+        let otherItemsCount;
+        dataArr = data.data.slice(0, this.size).map((item, index) => {
+            const numbers = data.data.map((item1, index1) => index === index1 ? item.count : 0);
+            const colors = data.data.slice(0, this.size).map((item1, index1) => {
+                return provideColors[item1.label];
+            });
+            numbers.push(data.totalItems - item.count);
+            colors.push('#f7f8f9');
+            return {
+                data: numbers,
+                totalItems: data.totalItems,
+                backgroundColor: colors,
+            };
+        });
+        labels = data.data
+            .slice(0, this.size)
+            .map((item) => `${this.translate.instant(prefix + item.label)} (${item.count})`);
+        const chartData = {
+            datasets: dataArr,
+            labels: labels,
+        };
+        const options = {
+            type: 'doughnut',
+            data: chartData,
+            plugins: this.totalNumber,
+            showCount: true,
+            countSize: '18px',
+            options: {
+                responsive: true,
+                maintainAspectRatio: false,
+                tooltips: { enabled: false },
+                cutoutPercentage: 30,
+                legend: {
+                    labels: {
+                        usePointStyle: true,
+                        boxWidth: 8,
+                    },
+                    position: 'left',
+                    rtl: this.isArabic ? true : false,
+                },
+                elements: {
+                    center: {
+                        text: `${totalItems >= 1000
+                            ? parseFloat((totalItems / 1000).toFixed(2)) + 'K'
+                            : totalItems}`,
+                        color: '#596973',
+                        fontStyle: 'Arial',
+                        sidePadding: 20,
+                        minFontSize: 20,
+                        lineHeight: 25, // Default is 25 (in px), used for when text wraps
+                    },
+                },
+            },
+        };
+        return { options: options, chartData: chartData };
+    }
+    doughnutChart(data) {
+        const provideColors = data.colors;
+        const prefix = data.prefix;
+        const totalItems = data.data.totalItems;
+        let backgroundColor = [];
+        let dataArr = [];
+        let labels = [];
+        //for aggregations
+        let itemCount = 0;
+        let otherItemsCount;
+        data.data.data.slice(0, this.size).forEach((item, index) => {
+            backgroundColor.push(provideColors[item.label]);
+            dataArr.push(item.count);
+            itemCount = itemCount + item.count;
+        });
+        labels = data.data.data.slice(0, this.size).map((item, index) => {
+            return `${this.translate.instant(prefix + item.label)} (${item.count})`;
+        });
+        //aggregate other data
+        otherItemsCount = totalItems - itemCount;
+        if (otherItemsCount > 0) {
+            backgroundColor.push(provideColors['other']);
+            dataArr.push(otherItemsCount);
+            labels.push(`${this.translate.instant(prefix + 'other')} (${otherItemsCount})`);
+        }
+        const chartData = {
+            datasets: [
+                {
+                    backgroundColor: backgroundColor,
+                    data: dataArr,
+                },
+            ],
+            labels: labels,
+        };
+        const options = {
+            type: 'doughnut',
+            data: chartData,
+            showCount: true,
+            countSize: '18px',
+            plugins: this.totalNumber,
+            options: {
+                responsive: true,
+                maintainAspectRatio: false,
+                tooltips: { enabled: true },
+                cutoutPercentage: 30,
+                legend: {
+                    labels: {
+                        usePointStyle: true,
+                        boxWidth: 8,
+                    },
+                    display: true,
+                    position: this.isArabic ? 'right' : 'left',
+                    rtl: this.isArabic ? true : false,
+                },
+                elements: {
+                    center: {
+                        text: `${totalItems >= 1000
+                            ? parseFloat((totalItems / 1000).toFixed(2)) + 'K'
+                            : totalItems}`,
+                        color: '#596973',
+                        fontStyle: 'Arial',
+                        sidePadding: 20,
+                        minFontSize: 20,
+                        lineHeight: 25, // Default is 25 (in px), used for when text wraps
+                    },
+                },
+            },
+        };
+        return { options: options, chartData: chartData };
+    }
+    lineChart(data) {
+        data = this.groupObjectBykeyLine(data.data);
+        console.log('chart data', data);
+        this.isArabic ? moment.locale('ar-sa') : moment.locale('en-us');
+        const chartData = data;
+        const options = {
+            type: 'line',
+            data: chartData,
+            options: {
+                maintainAspectRatio: false,
+                scales: {
+                    xAxes: [
+                        {
+                            ticks: {
+                                autoSkip: true,
+                                maxTicksLimit: 12,
+                                source: 'labels',
+                            },
+                            type: 'time',
+                            time: {
+                                unit: 'week',
+                                displayFormats: {
+                                    week: 'DD-MM-yyyy',
+                                },
+                            },
+                        },
+                    ],
+                    yAxes: [
+                        {
+                            ticks: {
+                                min: 0,
+                                precision: 0,
+                            },
+                        },
+                    ],
+                },
+                title: {
+                    display: true,
+                    text: '',
+                },
+                legend: {
+                    labels: {
+                        // usePointStyle: true,
+                        boxWidth: 12,
+                    },
+                    // position: 'bottom',
+                    rtl: this.isArabic ? true : false,
+                },
+            },
+        };
+        return { options, chartData };
+    }
+    GroupedBarChart(data) {
+        data = this.groupObjectBykey(data.data);
+        this.isArabic ? moment.locale('ar-sa') : moment.locale('en-us');
+        const chartData = data;
+        const options = {
+            type: 'bar',
+            data: chartData,
+            options: {
+                plugins: {
+                    outlabels: {
+                        display: false,
+                    },
+                    labels: false,
+                },
+                barValueSpacing: 20,
+                scales: {
+                    yAxes: [
+                        {
+                            ticks: {
+                                min: 0,
+                                precision: 0,
+                            },
+                        },
+                    ],
+                },
+                legend: {
+                    // position: 'bottom',
+                    labels: {
+                        boxWidth: 12,
+                    },
+                    rtl: this.isArabic ? true : false,
+                },
+            },
+        };
+        return { options, chartData };
+    }
+    BarChart(data) {
+        const provideColors = data.colors;
+        const prefix = data.prefix;
+        const totalItems = data.totalItems;
+        let backgroundColor = [];
+        let dataArr = [];
+        let labels = [];
+        data.data.data.forEach((item, index) => {
+            backgroundColor.push('#2e62df');
+            dataArr.push(item.count);
+        });
+        labels = data.data.data.map((item, index) => {
+            return `${item.label}`;
+        });
+        const chartData = {
+            datasets: [
+                {
+                    backgroundColor: backgroundColor,
+                    data: dataArr,
+                    barPercentage: 0.4,
+                    barThickness: 24,
+                    maxBarThickness: 30,
+                    minBarLength: 2,
+                },
+            ],
+            labels: labels,
+        };
+        const options = {
+            type: 'bar',
+            data: chartData,
+            options: {
+                plugins: {
+                    outlabels: {
+                        display: false,
+                    },
+                    labels: false,
+                },
+                barValueSpacing: 20,
+                scales: {
+                    yAxes: [
+                        {
+                            ticks: {
+                                min: 0,
+                                precision: 0,
+                            },
+                        },
+                    ],
+                },
+                legend: {
+                    // position: 'bottom',
+                    display: false,
+                    // labels: {
+                    //   boxWidth: 12,
+                    // },
+                    // rtl: this.isArabic ? true : false,
+                },
+            },
+        };
+        return { options: options, chartData: chartData };
+    }
+    outlabeledPieChart(data) {
+        const provideColors = data.colors;
+        const prefix = data.prefix;
+        const totalItems = data.totalItems;
+        let backgroundColor = [];
+        let dataArr = [];
+        let labels = [];
+        data.data.data.forEach((item, index) => {
+            backgroundColor.push(provideColors[item.label]);
+            dataArr.push(item.count);
+        });
+        labels = data.data.data.map((item, index) => {
+            return `${item.label}`;
+        });
+        const chartData = {
+            datasets: [
+                {
+                    backgroundColor: backgroundColor,
+                    data: dataArr,
+                },
+            ],
+            labels: labels,
+        };
+        const options = {
+            type: 'outlabeledPie',
+            data: chartData,
+            options: {
+                layout: {
+                    padding: {
+                        top: 33,
+                    },
+                },
+                zoomOutPercentage: 55,
+                plugins: {
+                    legend: false,
+                    outlabels: {
+                        lineWidth: 0.8,
+                        lineColor: '#b4bac6',
+                        text: (context) => {
+                            let index = context.dataIndex;
+                            let label = context.labels[index];
+                            let num = context.percent * 100;
+                            let text = `${_.truncate(label, {
+                                length: 24,
+                            })} ${num.toFixed(0)}%`;
+                            return text;
+                        },
+                        color: 'white',
+                        stretch: 20,
+                        font: {
+                            resizable: true,
+                            minSize: 12,
+                            maxSize: 18,
+                        },
+                    },
+                },
+            },
+        };
+        return { options: options, chartData: chartData };
+    }
+    pieChart(data) {
+        const provideColors = data.colors;
+        const prefix = data.prefix;
+        const totalItems = data.totalItems;
+        let backgroundColor = [];
+        let dataArr = [];
+        let labels = [];
+        data.data.data.forEach((item, index) => {
+            backgroundColor.push(provideColors[item.label]);
+            dataArr.push(item.count);
+        });
+        labels = data.data.data.map((item, index) => {
+            return `${item.label}`;
+        });
+        const chartData = {
+            datasets: [
+                {
+                    backgroundColor: backgroundColor,
+                    data: dataArr,
+                },
+            ],
+            labels: labels,
+        };
+        const options = {
+            type: 'pie',
+            data: chartData,
+            options: {
+                title: {
+                    display: true,
+                    text: prefix.length > 0 ? `${this.translate.instant(prefix)}` : '',
+                },
+                zoomOutPercentage: 55,
+                legend: {
+                    labels: {
+                        usePointStyle: true,
+                        boxWidth: 8,
+                    },
+                    // position: 'left',
+                    rtl: this.isArabic ? true : false,
+                },
+                plugins: {
+                    outlabels: {
+                        display: false,
+                    },
+                },
+            },
+        };
+        return { options: options, chartData: chartData };
+    }
+}
+ChartDataService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: ChartDataService, deps: [{ token: i1.TranslateService }, { token: i2.TranslationService }], target: i0.ɵɵFactoryTarget.Injectable });
+ChartDataService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: ChartDataService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.4", ngImport: i0, type: ChartDataService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }, { type: i2.TranslationService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart-data.service.js","sourceRoot":"","sources":["../../../../../../../projects/nuxeo-development-framework/src/lib/components/dynamic-chart/services/chart-data.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter, Injectable } from '@angular/core';\r\nimport { TranslateService } from '@ngx-translate/core';\r\nimport { TranslationService } from '../../../Core/services/translation/translation.service';\r\nimport moment from 'moment-es6';\r\nimport * as _ from 'lodash';\r\n\r\ninterface ChartData {\r\n  chartData: {};\r\n  options: {};\r\n}\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class ChartDataService {\r\n  refreshData = new EventEmitter();\r\n  private prefix = 'STATS.';\r\n  private isArabic: boolean;\r\n  private size: number = 8;\r\n  \r\n  private totalNumber = [\r\n    {\r\n      beforeDraw: (chart) => {\r\n        if (chart.config.options.elements.center) {\r\n          // Get ctx from string\r\n          var ctx = chart.chart.ctx;\r\n\r\n          // Get options from the center object in options\r\n          var centerConfig = chart.config.options.elements.center;\r\n          var fontStyle = centerConfig.fontStyle || 'Arial';\r\n          var txt = centerConfig.text;\r\n          var color = centerConfig.color || '#000';\r\n          var maxFontSize = centerConfig.maxFontSize || 75;\r\n          var sidePadding = centerConfig.sidePadding || 20;\r\n          var sidePaddingCalculated =\r\n            (sidePadding / 100) * (chart.innerRadius * 2);\r\n          // Start with a base font of 30px\r\n          ctx.font = '30px ' + fontStyle;\r\n\r\n          // Get the width of the string and also the width of the element minus 10 to give it 5px side padding\r\n          var stringWidth = ctx.measureText(txt).width;\r\n          var elementWidth = chart.innerRadius * 2 - sidePaddingCalculated;\r\n\r\n          // Find out how much the font can grow in width.\r\n          var widthRatio = elementWidth / stringWidth;\r\n          var newFontSize = Math.floor(30 * widthRatio);\r\n          var elementHeight = chart.innerRadius * 2;\r\n\r\n          // Pick a new font size so it will not be larger than the height of label.\r\n          var fontSizeToUse = Math.min(newFontSize, elementHeight, maxFontSize);\r\n          var minFontSize = centerConfig.minFontSize;\r\n          var lineHeight = centerConfig.lineHeight || 25;\r\n          var wrapText = false;\r\n\r\n          if (minFontSize === undefined) {\r\n            minFontSize = 20;\r\n          }\r\n\r\n          if (minFontSize && fontSizeToUse < minFontSize) {\r\n            fontSizeToUse = minFontSize;\r\n            wrapText = true;\r\n          }\r\n\r\n          // Set font settings to draw it correctly.\r\n          ctx.textAlign = 'center';\r\n          ctx.textBaseline = 'middle';\r\n          var centerX = (chart.chartArea.left + chart.chartArea.right) / 2;\r\n          var centerY = (chart.chartArea.top + chart.chartArea.bottom) / 2;\r\n          ctx.font = '14' + 'px ' + fontStyle;\r\n          ctx.fillStyle = color;\r\n\r\n          if (!wrapText) {\r\n            ctx.fillText(txt, centerX, centerY);\r\n            return;\r\n          }\r\n\r\n          var words = txt.split(' ');\r\n          var line = '';\r\n          var lines = [];\r\n\r\n          // Break words up into multiple lines if necessary\r\n          for (var n = 0; n < words.length; n++) {\r\n            var testLine = line + words[n] + ' ';\r\n            var metrics = ctx.measureText(testLine);\r\n            var testWidth = metrics.width;\r\n            if (testWidth > elementWidth && n > 0) {\r\n              lines.push(line);\r\n              line = words[n] + ' ';\r\n            } else {\r\n              line = testLine;\r\n            }\r\n          }\r\n\r\n          // Move the center up depending on line height and number of lines\r\n          centerY -= (lines.length / 2) * lineHeight;\r\n\r\n          for (var n = 0; n < lines.length; n++) {\r\n            ctx.fillText(lines[n], centerX, centerY);\r\n            centerY += lineHeight;\r\n          }\r\n          //Draw text in center\r\n          ctx.fillText(line, centerX, centerY);\r\n        }\r\n      },\r\n    },\r\n  ];\r\n  constructor(\r\n    private translate: TranslateService,\r\n    private translation: TranslationService\r\n  ) {\r\n    this.translation.isArabic.subscribe((arabic) => {\r\n      arabic ? (this.isArabic = arabic) : (this.isArabic = arabic);\r\n    });\r\n  }\r\n  /**\r\n   *\r\n   * @param data data fetched from back-end\r\n   * @param totalItems totalItems from the backedn\r\n   * @param prefix for Translations\r\n   * @returns\r\n   */\r\n  multiSeriesPieChart(data): ChartData {\r\n    const provideColors = data.colors;\r\n    const prefix = data.prefix;\r\n    const totalItems = data.totalItems;\r\n    let dataArr = [];\r\n    let labels = [];\r\n    //for aggregations\r\n    let itemCount: number = 0;\r\n    let otherItemsCount: number;\r\n\r\n    dataArr = data.data.slice(0, this.size).map((item, index) => {\r\n      const numbers = data.data.map((item1, index1) =>\r\n        index === index1 ? item.count : 0\r\n      );\r\n      const colors = data.data.slice(0, this.size).map((item1, index1) => {\r\n        return provideColors[item1.label];\r\n      });\r\n      numbers.push(data.totalItems - item.count);\r\n\r\n      colors.push('#f7f8f9');\r\n      return {\r\n        data: numbers,\r\n        totalItems: data.totalItems,\r\n        backgroundColor: colors,\r\n      };\r\n    });\r\n    labels = data.data\r\n      .slice(0, this.size)\r\n      .map(\r\n        (item) =>\r\n        `${this.translate.instant(prefix + item.label)} (${item.count})`\r\n      );\r\n    const chartData = {\r\n      datasets: dataArr,\r\n      labels: labels,\r\n    };\r\n\r\n    const options = {\r\n      type: 'doughnut',\r\n      data: chartData,\r\n      plugins: this.totalNumber,\r\n      showCount: true,\r\n      countSize: '18px',\r\n      options: {\r\n        responsive: true,\r\n        maintainAspectRatio: false,\r\n        tooltips: { enabled: false },\r\n        cutoutPercentage: 30,\r\n        legend: {\r\n          labels: {\r\n            usePointStyle: true,\r\n            boxWidth: 8,\r\n          },\r\n          position: 'left',\r\n          rtl: this.isArabic ? true : false,\r\n        },\r\n        elements: {\r\n          center: {\r\n            text: `${\r\n              totalItems >= 1000\r\n                ? parseFloat((totalItems / 1000).toFixed(2)) + 'K'\r\n                : totalItems\r\n            }`,\r\n            color: '#596973', // Default is #000000\r\n            fontStyle: 'Arial', // Default is Arial\r\n            sidePadding: 20, // Default is 20 (as a percentage)\r\n            minFontSize: 20, // Default is 20 (in px), set to false and text will not wrap.\r\n            lineHeight: 25, // Default is 25 (in px), used for when text wraps\r\n          },\r\n        },\r\n      },\r\n    };\r\n    return { options: options, chartData: chartData };\r\n  }\r\n\r\n  doughnutChart(data): ChartData {\r\n    const provideColors = data.colors;\r\n    const prefix = data.prefix;\r\n    const totalItems = data.data.totalItems;\r\n    let backgroundColor = [];\r\n    let dataArr = [];\r\n    let labels = [];\r\n    //for aggregations\r\n    let itemCount: number = 0;\r\n    let otherItemsCount: number;\r\n    data.data.data.slice(0, this.size).forEach((item, index) => {\r\n      backgroundColor.push(provideColors[item.label]);\r\n      dataArr.push(item.count);\r\n      itemCount = itemCount + item.count;\r\n    });\r\n    labels = data.data.data.slice(0, this.size).map((item, index) => {\r\n      return `${this.translate.instant(prefix + item.label)} (${item.count})`;\r\n    });\r\n    //aggregate other data\r\n    otherItemsCount = totalItems - itemCount;\r\n    if (otherItemsCount > 0) {\r\n      backgroundColor.push(provideColors['other']);\r\n      dataArr.push(otherItemsCount);\r\n      labels.push(\r\n        `${this.translate.instant(prefix + 'other')} (${otherItemsCount})`\r\n      );\r\n    }\r\n    const chartData = {\r\n      datasets: [\r\n        {\r\n          backgroundColor: backgroundColor,\r\n          data: dataArr,\r\n        },\r\n      ],\r\n      labels: labels,\r\n    };\r\n\r\n    const options = {\r\n      type: 'doughnut',\r\n      data: chartData,\r\n      showCount: true,\r\n      countSize: '18px',\r\n      plugins: this.totalNumber,\r\n      options: {\r\n        responsive: true,\r\n        maintainAspectRatio: false,\r\n        tooltips: { enabled: true },\r\n        cutoutPercentage: 30,\r\n        legend: {\r\n          labels: {\r\n            usePointStyle: true,\r\n            boxWidth: 8,\r\n          },\r\n          display: true,\r\n          position: this.isArabic ? 'right' : 'left',\r\n          rtl: this.isArabic ? true : false,\r\n        },\r\n        elements: {\r\n          center: {\r\n            text: `${\r\n              totalItems >= 1000\r\n                ? parseFloat((totalItems / 1000).toFixed(2)) + 'K'\r\n                : totalItems\r\n            }`,\r\n            color: '#596973', // Default is #000000\r\n            fontStyle: 'Arial', // Default is Arial\r\n            sidePadding: 20, // Default is 20 (as a percentage)\r\n            minFontSize: 20, // Default is 20 (in px), set to false and text will not wrap.\r\n            lineHeight: 25, // Default is 25 (in px), used for when text wraps\r\n          },\r\n        },\r\n      },\r\n    };\r\n    return { options: options, chartData: chartData };\r\n  }\r\n\r\n  lineChart(data): ChartData {\r\n    data = this.groupObjectBykeyLine(data.data);\r\n    console.log('chart data', data);\r\n    this.isArabic ? moment.locale('ar-sa') : moment.locale('en-us');\r\n    const chartData = data;\r\n    const options = {\r\n      type: 'line',\r\n      data: chartData,\r\n      options: {\r\n        maintainAspectRatio: false,\r\n        scales: {\r\n          xAxes: [\r\n            {\r\n              ticks: {\r\n                autoSkip: true,\r\n                maxTicksLimit: 12,\r\n                source: 'labels',\r\n              },\r\n              type: 'time',\r\n              time: {\r\n                unit: 'week',\r\n                displayFormats: {\r\n                  week: 'DD-MM-yyyy',\r\n                },\r\n              },\r\n            },\r\n          ],\r\n          yAxes: [\r\n            {\r\n              ticks: {\r\n                min: 0,\r\n                precision: 0,\r\n              },\r\n            },\r\n          ],\r\n        },\r\n        title: {\r\n          display: true,\r\n          text: '',\r\n        },\r\n        legend: {\r\n          labels: {\r\n            // usePointStyle: true,\r\n            boxWidth: 12,\r\n          },\r\n          // position: 'bottom',\r\n          rtl: this.isArabic ? true : false,\r\n        },\r\n      },\r\n    };\r\n    return { options, chartData };\r\n  }\r\n\r\n  GroupedBarChart(data): ChartData {\r\n    data = this.groupObjectBykey(data.data);\r\n    this.isArabic ? moment.locale('ar-sa') : moment.locale('en-us');\r\n    const chartData = data;\r\n    const options = {\r\n      type: 'bar',\r\n      data: chartData,\r\n      options: {\r\n        plugins: {\r\n          outlabels: {\r\n            display: false,\r\n          },\r\n          labels: false,\r\n        },\r\n        barValueSpacing: 20,\r\n        scales: {\r\n          yAxes: [\r\n            {\r\n              ticks: {\r\n                min: 0,\r\n                precision: 0,\r\n              },\r\n            },\r\n          ],\r\n        },\r\n        legend: {\r\n          // position: 'bottom',\r\n          labels: {\r\n            boxWidth: 12,\r\n          },\r\n          rtl: this.isArabic ? true : false,\r\n        },\r\n      },\r\n    };\r\n    return { options, chartData };\r\n  }\r\n\r\n  BarChart(data): ChartData {\r\n    const provideColors = data.colors;\r\n    const prefix = data.prefix;\r\n    const totalItems = data.totalItems;\r\n    let backgroundColor = [];\r\n    let dataArr = [];\r\n    let labels = [];\r\n    data.data.data.forEach((item, index) => {\r\n      backgroundColor.push('#2e62df');\r\n      dataArr.push(item.count);\r\n    });\r\n    labels = data.data.data.map((item, index) => {\r\n      return `${item.label}`;\r\n    });\r\n    const chartData = {\r\n      datasets: [\r\n        {\r\n          backgroundColor: backgroundColor,\r\n          data: dataArr,\r\n          barPercentage: 0.4,\r\n          barThickness: 24,\r\n          maxBarThickness: 30,\r\n          minBarLength: 2,\r\n        },\r\n      ],\r\n      labels: labels,\r\n    };\r\n\r\n    const options = {\r\n      type: 'bar',\r\n      data: chartData,\r\n      options: {\r\n        plugins: {\r\n          outlabels: {\r\n            display: false,\r\n          },\r\n          labels: false,\r\n        },\r\n        barValueSpacing: 20,\r\n        scales: {\r\n          yAxes: [\r\n            {\r\n              ticks: {\r\n                min: 0,\r\n                precision: 0,\r\n              },\r\n            },\r\n          ],\r\n        },\r\n        legend: {\r\n          // position: 'bottom',\r\n          display: false,\r\n          // labels: {\r\n          //   boxWidth: 12,\r\n          // },\r\n          // rtl: this.isArabic ? true : false,\r\n        },\r\n      },\r\n    };\r\n    return { options: options, chartData: chartData };\r\n  }\r\n\r\n  outlabeledPieChart(data): ChartData {\r\n    const provideColors = data.colors;\r\n    const prefix = data.prefix;\r\n    const totalItems = data.totalItems;\r\n    let backgroundColor = [];\r\n    let dataArr = [];\r\n    let labels = [];\r\n    data.data.data.forEach((item, index) => {\r\n      backgroundColor.push(provideColors[item.label]);\r\n      dataArr.push(item.count);\r\n    });\r\n    labels = data.data.data.map((item, index) => {\r\n      return `${item.label}`;\r\n    });\r\n    const chartData = {\r\n      datasets: [\r\n        {\r\n          backgroundColor: backgroundColor,\r\n          data: dataArr,\r\n        },\r\n      ],\r\n      labels: labels,\r\n    };\r\n\r\n    const options = {\r\n      type: 'outlabeledPie',\r\n      data: chartData,\r\n\r\n      options: {\r\n        layout: {\r\n          padding: {\r\n            top: 33,\r\n          },\r\n        },\r\n        zoomOutPercentage: 55,\r\n        plugins: {\r\n          legend: false,\r\n          outlabels: {\r\n            lineWidth: 0.8,\r\n            lineColor: '#b4bac6',\r\n            text: (context) => {\r\n              let index = context.dataIndex;\r\n              let label = context.labels[index];\r\n              let num = context.percent * 100;\r\n              let text = `${_.truncate(label, {\r\n                length: 24,\r\n              })} ${num.toFixed(0)}%`;\r\n\r\n              return text;\r\n            },\r\n            color: 'white',\r\n            stretch: 20,\r\n            font: {\r\n              resizable: true,\r\n              minSize: 12,\r\n              maxSize: 18,\r\n            },\r\n          },\r\n        },\r\n      },\r\n    };\r\n    return { options: options, chartData: chartData };\r\n  }\r\n\r\n  pieChart(data): ChartData {\r\n    const provideColors = data.colors;\r\n    const prefix = data.prefix;\r\n    const totalItems = data.totalItems;\r\n    let backgroundColor = [];\r\n    let dataArr = [];\r\n    let labels = [];\r\n    data.data.data.forEach((item, index) => {\r\n      backgroundColor.push(provideColors[item.label]);\r\n      dataArr.push(item.count);\r\n    });\r\n    labels = data.data.data.map((item, index) => {\r\n      return `${item.label}`;\r\n    });\r\n    const chartData = {\r\n      datasets: [\r\n        {\r\n          backgroundColor: backgroundColor,\r\n          data: dataArr,\r\n        },\r\n      ],\r\n      labels: labels,\r\n    };\r\n\r\n    const options = {\r\n      type: 'pie',\r\n      data: chartData,\r\n\r\n      options: {\r\n        title: {\r\n          display: true,\r\n          text: prefix.length > 0 ? `${this.translate.instant(prefix)}` : '',\r\n        },\r\n        zoomOutPercentage: 55,\r\n        legend: {\r\n          labels: {\r\n            usePointStyle: true,\r\n            boxWidth: 8,\r\n          },\r\n          // position: 'left',\r\n          rtl: this.isArabic ? true : false,\r\n        },\r\n        plugins: {\r\n          outlabels: {\r\n            display: false,\r\n          },\r\n        },\r\n      },\r\n    };\r\n    return { options: options, chartData: chartData };\r\n  }\r\n\r\n  private groupObjectBykey = (data) => {\r\n    let nameIndices = {};\r\n    let statusHash = {};\r\n    let chartData = { labels: [], datasets: [] };\r\n    data.forEach((item) => {\r\n      if (!(item.label in nameIndices)) {\r\n        nameIndices[item.label] = chartData.labels.push(item.label) - 1;\r\n        chartData.datasets.forEach((a) => {\r\n          a.data.push(0);\r\n        });\r\n      }\r\n      if (!statusHash[item.status]) {\r\n        statusHash[item.status] = {\r\n          label: `${this.translate.instant(item.status)} (${item.totalItems})`,\r\n          ...(item.status === 'Incoming' && {\r\n            backgroundColor: '#00dca5',\r\n          }),\r\n          ...(item.status === 'Outgoing' && {\r\n            backgroundColor: '#fbb62c',\r\n          }),\r\n          data: chartData.labels.map(() => {\r\n            return 0;\r\n          }),\r\n          barPercentage: 0.4,\r\n          barThickness: 24,\r\n          maxBarThickness: 30,\r\n          minBarLength: 2,\r\n        };\r\n        chartData.datasets.push(statusHash[item.status]);\r\n      }\r\n      statusHash[item.status].data[nameIndices[item.label]] = item.count;\r\n    });\r\n\r\n    return chartData;\r\n  };\r\n\r\n  private groupObjectBykeyLine = (data) => {\r\n    data.sort((left, right) => {\r\n      return moment.utc(left.id).diff(moment.utc(right.id));\r\n    });\r\n    let nameIndices = {};\r\n    let statusHash = {};\r\n    let chartData = { labels: [], datasets: [] };\r\n    data.forEach((item) => {\r\n      if (!(item.id in nameIndices)) {\r\n        nameIndices[item.id] = chartData.labels.push(item.id) - 1;\r\n        chartData.datasets.forEach((a) => {\r\n          a.data.push(0);\r\n        });\r\n      }\r\n      if (!statusHash[item.status]) {\r\n        statusHash[item.status] = {\r\n          label: `${this.translate.instant(item.status)} (${item.totalItems})`,\r\n          ...(item.status === 'Incoming' && {\r\n            borderColor: '#00dca5',\r\n          }),\r\n          ...(item.status === 'Outgoing' && {\r\n            borderColor: '#fbb62c',\r\n          }),\r\n          fill: false,\r\n          lineTension: 0,\r\n          data: chartData.labels.map(() => {\r\n            return 0;\r\n          }),\r\n        };\r\n        chartData.datasets.push(statusHash[item.status]);\r\n      }\r\n      statusHash[item.status].data[nameIndices[item.id]] = item.count;\r\n    });\r\n\r\n    return chartData;\r\n  };\r\n  \r\n}\r\n"]}