nuxeo-development-framework 5.2.9 → 5.3.1

package/esm2015/lib/components/reports/ndf-reports/services/chart-manager.service.js

@@ -0,0 +1,131 @@
+import { __awaiter } from "tslib";
+import { DOCUMENT } from '@angular/common';
+import { Inject, Injectable } from '@angular/core';
+import { Chart } from 'chart.js/auto';
+import * as moment from 'moment';
+import { ChartPlugins } from '../../charts';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class ChartManagerService {
+    constructor(_translateService, _document) {
+        this._translateService = _translateService;
+        this._document = _document;
+        this._charts = new Map();
+    }
+    setChart(chart) {
+        this._charts.set(chart.id, chart);
+    }
+    getChart(id) {
+        return this._charts.get(id);
+    }
+    resizeCharts() {
+        this._charts.forEach((chart) => {
+            if (chart.canvas && chart.canvas.ownerDocument) {
+                chart.resize();
+            }
+        });
+    }
+    destroy(id) {
+        const _chart = this._charts.get(id);
+        if (_chart) {
+            _chart.destroy();
+            this._charts.delete(id);
+        }
+    }
+    destroyAll() {
+        this._charts.forEach((chart) => {
+            chart.destroy();
+        });
+        this._charts.clear();
+    }
+    printChart(id, label) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _chart = this._charts.get(id);
+            if (!_chart) {
+                return;
+            }
+            const { chart, destroy: destroyTempChart } = yield this._createHiddenCanvasForExport(_chart, label);
+            if (!chart) {
+                return;
+            }
+            const imageLink = this._document.createElement('a');
+            const date = moment().format('YYYY-MM-DD_HH-mm-ss');
+            imageLink.href = chart.canvas.toDataURL('image/jpeg', 0.9);
+            imageLink.download = `${label}-${date}.jpg`;
+            imageLink.click();
+            destroyTempChart();
+        });
+    }
+    _createHiddenCanvasForExport(chart, label) {
+        const currentLang = this._translateService.currentLang;
+        return new Promise((resolve) => {
+            var _a;
+            const padding = 40;
+            const hiddenCanvas = this._document.createElement('canvas');
+            const [width, height] = [1024, 600];
+            hiddenCanvas.style.width = `${width}px`;
+            hiddenCanvas.style.height = `${height}px`;
+            hiddenCanvas.width = width;
+            hiddenCanvas.height = height;
+            hiddenCanvas.id = 'hiddenCanvas';
+            this._document.body.appendChild(hiddenCanvas);
+            const hiddenChart = new Chart(hiddenCanvas, {
+                type: (_a = chart.config) === null || _a === void 0 ? void 0 : _a.type,
+                data: chart.config.data,
+                options: Object.assign(Object.assign({}, chart.config.options), { animation: false, responsive: false, layout: {
+                        padding: padding
+                    }, plugins: Object.assign(Object.assign({}, chart.config.options.plugins), { title: {
+                            display: true,
+                            text: label,
+                            padding: {
+                                top: 0,
+                                bottom: 30
+                            }
+                        }, legend: {
+                            display: true,
+                            rtl: currentLang == 'ar',
+                            position: currentLang == 'ar' ? 'right' : 'left'
+                        } }) }),
+                plugins: [
+                    ChartPlugins.chartDataLabels,
+                    {
+                        id: 'canvasBackgroundColor',
+                        beforeDraw: (chart, args, options) => {
+                            const { ctx } = chart;
+                            ctx.save();
+                            ctx.globalCompositeOperation = 'destination-over';
+                            ctx.fillStyle = 'white';
+                            ctx.fillRect(0, 0, chart.width, chart.height);
+                            ctx.restore();
+                        }
+                    },
+                    {
+                        id: 'onReady',
+                        afterRender: function (chart, options) {
+                            resolve({
+                                chart: chart,
+                                destroy: () => {
+                                    chart.destroy();
+                                    document.body.removeChild(hiddenCanvas);
+                                }
+                            });
+                        }
+                    }
+                ]
+            });
+            hiddenChart.render();
+        });
+    }
+}
+ChartManagerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ChartManagerService, deps: [{ token: i1.TranslateService }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+ChartManagerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ChartManagerService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ChartManagerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart-manager.service.js","sourceRoot":"","sources":["../../../../../../../../projects/nuxeo-development-framework/src/lib/components/reports/ndf-reports/services/chart-manager.service.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEjC,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;;;AAK5C,MAAM,OAAO,mBAAmB;IAG/B,YACS,iBAAmC,EACjB,SAAmB;QADrC,sBAAiB,GAAjB,iBAAiB,CAAkB;QACjB,cAAS,GAAT,SAAS,CAAU;QAJtC,YAAO,GAAG,IAAI,GAAG,EAA0B,CAAC;IAKjD,CAAC;IAEJ,QAAQ,CAAC,KAAY;QACpB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;IACnC,CAAC;IAED,QAAQ,CAAC,EAAmB;QAC3B,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC7B,CAAC;IAED,YAAY;QACX,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;YAC9B,IAAI,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC,aAAa,EAAE;gBAC/C,KAAK,CAAC,MAAM,EAAE,CAAC;aACf;QACF,CAAC,CAAC,CAAC;IACJ,CAAC;IAED,OAAO,CAAC,EAAmB;QAC1B,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACpC,IAAI,MAAM,EAAE;YACX,MAAM,CAAC,OAAO,EAAE,CAAC;YACjB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;SACxB;IACF,CAAC;IAED,UAAU;QACT,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;YAC9B,KAAK,CAAC,OAAO,EAAE,CAAC;QACjB,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;IACtB,CAAC;IAEK,UAAU,CAAC,EAAmB,EAAE,KAAa;;YAClD,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YACpC,IAAI,CAAC,MAAM,EAAE;gBACZ,OAAO;aACP;YAED,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,gBAAgB,EAAE,GAAG,MAAM,IAAI,CAAC,4BAA4B,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;YACpG,IAAI,CAAC,KAAK,EAAE;gBACX,OAAO;aACP;YAED,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;YACpD,MAAM,IAAI,GAAG,MAAM,EAAE,CAAC,MAAM,CAAC,qBAAqB,CAAC,CAAC;YACpD,SAAS,CAAC,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,YAAY,EAAE,GAAG,CAAC,CAAC;YAC3D,SAAS,CAAC,QAAQ,GAAG,GAAG,KAAK,IAAI,IAAI,MAAM,CAAC;YAC5C,SAAS,CAAC,KAAK,EAAE,CAAC;YAClB,gBAAgB,EAAE,CAAC;QACpB,CAAC;KAAA;IAEO,4BAA4B,CAAC,KAAY,EAAE,KAAa;QAC/D,MAAM,WAAW,GAAG,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC;QAEvD,OAAO,IAAI,OAAO,CAAwC,CAAC,OAAO,EAAE,EAAE;;YACrE,MAAM,OAAO,GAAG,EAAE,CAAC;YAEnB,MAAM,YAAY,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;YAC5D,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;YAEpC,YAAY,CAAC,KAAK,CAAC,KAAK,GAAG,GAAG,KAAK,IAAI,CAAC;YACxC,YAAY,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC;YAC1C,YAAY,CAAC,KAAK,GAAG,KAAK,CAAC;YAC3B,YAAY,CAAC,MAAM,GAAG,MAAM,CAAC;YAC7B,YAAY,CAAC,EAAE,GAAG,cAAc,CAAC;YAEjC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC;YAE9C,MAAM,WAAW,GAAG,IAAI,KAAK,CAAC,YAAY,EAAE;gBAC3C,IAAI,EAAE,MAAC,KAAK,CAAC,MAA6B,0CAAE,IAAI;gBAChD,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,IAAI;gBACvB,OAAO,kCACH,KAAK,CAAC,MAAM,CAAC,OAAO,KACvB,SAAS,EAAE,KAAK,EAChB,UAAU,EAAE,KAAK,EACjB,MAAM,EAAE;wBACP,OAAO,EAAE,OAAO;qBAChB,EACD,OAAO,kCACH,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,KAC/B,KAAK,EAAE;4BACN,OAAO,EAAE,IAAI;4BACb,IAAI,EAAE,KAAK;4BACX,OAAO,EAAE;gCACR,GAAG,EAAE,CAAC;gCACN,MAAM,EAAE,EAAE;6BACV;yBACD,EACD,MAAM,EAAE;4BACP,OAAO,EAAE,IAAI;4BACb,GAAG,EAAE,WAAW,IAAI,IAAI;4BACxB,QAAQ,EAAE,WAAW,IAAI,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM;yBAChD,MAEF;gBACD,OAAO,EAAE;oBACR,YAAY,CAAC,eAAe;oBAC5B;wBACC,EAAE,EAAE,uBAAuB;wBAC3B,UAAU,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE;4BACpC,MAAM,EAAE,GAAG,EAAE,GAAG,KAAK,CAAC;4BACtB,GAAG,CAAC,IAAI,EAAE,CAAC;4BACX,GAAG,CAAC,wBAAwB,GAAG,kBAAkB,CAAC;4BAClD,GAAG,CAAC,SAAS,GAAG,OAAO,CAAC;4BACxB,GAAG,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;4BAC9C,GAAG,CAAC,OAAO,EAAE,CAAC;wBACf,CAAC;qBACD;oBACD;wBACC,EAAE,EAAE,SAAS;wBACb,WAAW,EAAE,UAAU,KAAK,EAAE,OAAO;4BACpC,OAAO,CAAC;gCACP,KAAK,EAAE,KAAK;gCACZ,OAAO,EAAE,GAAG,EAAE;oCACb,KAAK,CAAC,OAAO,EAAE,CAAC;oCAChB,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC;gCACzC,CAAC;6BACD,CAAC,CAAC;wBACJ,CAAC;qBACD;iBACD;aACD,CAAC,CAAC;YACH,WAAW,CAAC,MAAM,EAAE,CAAC;QACtB,CAAC,CAAC,CAAC;IACJ,CAAC;;iHAnIW,mBAAmB,kDAKtB,QAAQ;qHALL,mBAAmB,cAFnB,MAAM;4FAEN,mBAAmB;kBAH/B,UAAU;mBAAC;oBACX,UAAU,EAAE,MAAM;iBAClB;yFAMsC,QAAQ;0BAA5C,MAAM;2BAAC,QAAQ","sourcesContent":["import { DOCUMENT } from '@angular/common';\r\nimport { Inject, Injectable } from '@angular/core';\r\nimport { TranslateService } from '@ngx-translate/core';\r\nimport { Chart } from 'chart.js/auto';\r\nimport * as moment from 'moment';\r\nimport { ChartConfiguration } from 'chart.js/dist/types';\r\nimport { ChartPlugins } from '../../charts';\r\n\r\n@Injectable({\r\n\tprovidedIn: 'root'\r\n})\r\nexport class ChartManagerService {\r\n\tprivate _charts = new Map<string | number, Chart>();\r\n\r\n\tconstructor(\r\n\t\tprivate _translateService: TranslateService,\r\n\t\t@Inject(DOCUMENT) private _document: Document\r\n\t) {}\r\n\r\n\tsetChart(chart: Chart) {\r\n\t\tthis._charts.set(chart.id, chart);\r\n\t}\r\n\r\n\tgetChart(id: string | number): Chart {\r\n\t\treturn this._charts.get(id);\r\n\t}\r\n\r\n\tresizeCharts() {\r\n\t\tthis._charts.forEach((chart) => {\r\n\t\t\tif (chart.canvas && chart.canvas.ownerDocument) {\r\n\t\t\t\tchart.resize();\r\n\t\t\t}\r\n\t\t});\r\n\t}\r\n\r\n\tdestroy(id: string | number) {\r\n\t\tconst _chart = this._charts.get(id);\r\n\t\tif (_chart) {\r\n\t\t\t_chart.destroy();\r\n\t\t\tthis._charts.delete(id);\r\n\t\t}\r\n\t}\r\n\r\n\tdestroyAll() {\r\n\t\tthis._charts.forEach((chart) => {\r\n\t\t\tchart.destroy();\r\n\t\t});\r\n\t\tthis._charts.clear();\r\n\t}\r\n\r\n\tasync printChart(id: string | number, label: string) {\r\n\t\tconst _chart = this._charts.get(id);\r\n\t\tif (!_chart) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tconst { chart, destroy: destroyTempChart } = await this._createHiddenCanvasForExport(_chart, label);\r\n\t\tif (!chart) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tconst imageLink = this._document.createElement('a');\r\n\t\tconst date = moment().format('YYYY-MM-DD_HH-mm-ss');\r\n\t\timageLink.href = chart.canvas.toDataURL('image/jpeg', 0.9);\r\n\t\timageLink.download = `${label}-${date}.jpg`;\r\n\t\timageLink.click();\r\n\t\tdestroyTempChart();\r\n\t}\r\n\r\n\tprivate _createHiddenCanvasForExport(chart: Chart, label: string) {\r\n\t\tconst currentLang = this._translateService.currentLang;\r\n\r\n\t\treturn new Promise<{ chart: Chart; destroy: () => void }>((resolve) => {\r\n\t\t\tconst padding = 40;\r\n\r\n\t\t\tconst hiddenCanvas = this._document.createElement('canvas');\r\n\t\t\tconst [width, height] = [1024, 600];\r\n\r\n\t\t\thiddenCanvas.style.width = `${width}px`;\r\n\t\t\thiddenCanvas.style.height = `${height}px`;\r\n\t\t\thiddenCanvas.width = width;\r\n\t\t\thiddenCanvas.height = height;\r\n\t\t\thiddenCanvas.id = 'hiddenCanvas';\r\n\r\n\t\t\tthis._document.body.appendChild(hiddenCanvas);\r\n\r\n\t\t\tconst hiddenChart = new Chart(hiddenCanvas, {\r\n\t\t\t\ttype: (chart.config as ChartConfiguration)?.type,\r\n\t\t\t\tdata: chart.config.data,\r\n\t\t\t\toptions: {\r\n\t\t\t\t\t...chart.config.options,\r\n\t\t\t\t\tanimation: false,\r\n\t\t\t\t\tresponsive: false,\r\n\t\t\t\t\tlayout: {\r\n\t\t\t\t\t\tpadding: padding\r\n\t\t\t\t\t},\r\n\t\t\t\t\tplugins: {\r\n\t\t\t\t\t\t...chart.config.options.plugins,\r\n\t\t\t\t\t\ttitle: {\r\n\t\t\t\t\t\t\tdisplay: true,\r\n\t\t\t\t\t\t\ttext: label,\r\n\t\t\t\t\t\t\tpadding: {\r\n\t\t\t\t\t\t\t\ttop: 0,\r\n\t\t\t\t\t\t\t\tbottom: 30\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t},\r\n\t\t\t\t\t\tlegend: {\r\n\t\t\t\t\t\t\tdisplay: true,\r\n\t\t\t\t\t\t\trtl: currentLang == 'ar',\r\n\t\t\t\t\t\t\tposition: currentLang == 'ar' ? 'right' : 'left'\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t},\r\n\t\t\t\tplugins: [\r\n\t\t\t\t\tChartPlugins.chartDataLabels,\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tid: 'canvasBackgroundColor',\r\n\t\t\t\t\t\tbeforeDraw: (chart, args, options) => {\r\n\t\t\t\t\t\t\tconst { ctx } = chart;\r\n\t\t\t\t\t\t\tctx.save();\r\n\t\t\t\t\t\t\tctx.globalCompositeOperation = 'destination-over';\r\n\t\t\t\t\t\t\tctx.fillStyle = 'white';\r\n\t\t\t\t\t\t\tctx.fillRect(0, 0, chart.width, chart.height);\r\n\t\t\t\t\t\t\tctx.restore();\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t},\r\n\t\t\t\t\t{\r\n\t\t\t\t\t\tid: 'onReady',\r\n\t\t\t\t\t\tafterRender: function (chart, options) {\r\n\t\t\t\t\t\t\tresolve({\r\n\t\t\t\t\t\t\t\tchart: chart,\r\n\t\t\t\t\t\t\t\tdestroy: () => {\r\n\t\t\t\t\t\t\t\t\tchart.destroy();\r\n\t\t\t\t\t\t\t\t\tdocument.body.removeChild(hiddenCanvas);\r\n\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t});\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t]\r\n\t\t\t});\r\n\t\t\thiddenChart.render();\r\n\t\t});\r\n\t}\r\n}\r\n"]}

package/esm2015/lib/components/reports/ndf-reports/services/chart-plugins-registry.service.js

@@ -0,0 +1,49 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ChartPluginsRegistry {
+    constructor() {
+        this._plugins = new Map();
+    }
+    register(key, plugin) {
+        if (typeof key === 'object') {
+            Object.entries(key).forEach(([key, fn]) => this._plugins.set(key, fn));
+            return;
+        }
+        if (typeof key === 'string' && plugin) {
+            this._plugins.set(key, plugin);
+        }
+    }
+    /**
+     * Check if a plugin exists with the given key
+     * @param key The plugin key to check
+     * @returns True if the plugin exists, false otherwise
+     */
+    has(key) {
+        return this._plugins.has(key);
+    }
+    /**
+     * Get a plugin by its key
+     * @param key The key of the plugin to retrieve
+     * @returns The plugin instance or undefined if not found
+     */
+    get(key) {
+        return this._plugins.get(key);
+    }
+    /**
+     * Remove a plugin by its key
+     * @param key The key of the plugin to remove
+     * @returns True if the plugin was removed, false if it didn't exist
+     */
+    delete(key) {
+        return this._plugins.delete(key);
+    }
+}
+ChartPluginsRegistry.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ChartPluginsRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ChartPluginsRegistry.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ChartPluginsRegistry, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ChartPluginsRegistry, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhcnQtcGx1Z2lucy1yZWdpc3RyeS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbnV4ZW8tZGV2ZWxvcG1lbnQtZnJhbWV3b3JrL3NyYy9saWIvY29tcG9uZW50cy9yZXBvcnRzL25kZi1yZXBvcnRzL3NlcnZpY2VzL2NoYXJ0LXBsdWdpbnMtcmVnaXN0cnkuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQU0zQyxNQUFNLE9BQU8sb0JBQW9CO0lBSGpDO1FBSWtCLGFBQVEsR0FBbUMsSUFBSSxHQUFHLEVBQUUsQ0FBQztLQWdEdEU7SUFyQ0EsUUFBUSxDQUFDLEdBQStDLEVBQUUsTUFBMEI7UUFDbkYsSUFBSSxPQUFPLEdBQUcsS0FBSyxRQUFRLEVBQUU7WUFDNUIsTUFBTSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLEdBQUcsRUFBRSxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUM7WUFDdkUsT0FBTztTQUNQO1FBRUQsSUFBSSxPQUFPLEdBQUcsS0FBSyxRQUFRLElBQUksTUFBTSxFQUFFO1lBQ3RDLElBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxNQUFNLENBQUMsQ0FBQztTQUMvQjtJQUNGLENBQUM7SUFFRDs7OztPQUlHO0lBQ0ksR0FBRyxDQUFDLEdBQVc7UUFDckIsT0FBTyxJQUFJLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUMvQixDQUFDO0lBRUQ7Ozs7T0FJRztJQUNJLEdBQUcsQ0FBQyxHQUFXO1FBQ3JCLE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDL0IsQ0FBQztJQUVEOzs7O09BSUc7SUFDSSxNQUFNLENBQUMsR0FBVztRQUN4QixPQUFPLElBQUksQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ2xDLENBQUM7O2tIQWhEVyxvQkFBb0I7c0hBQXBCLG9CQUFvQixjQUZwQixNQUFNOzRGQUVOLG9CQUFvQjtrQkFIaEMsVUFBVTttQkFBQztvQkFDWCxVQUFVLEVBQUUsTUFBTTtpQkFDbEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IENoYXJ0VHlwZSwgUGx1Z2luIH0gZnJvbSAnY2hhcnQuanMnO1xyXG5cclxuQEluamVjdGFibGUoe1xyXG5cdHByb3ZpZGVkSW46ICdyb290J1xyXG59KVxyXG5leHBvcnQgY2xhc3MgQ2hhcnRQbHVnaW5zUmVnaXN0cnkge1xyXG5cdHByaXZhdGUgcmVhZG9ubHkgX3BsdWdpbnM6IE1hcDxzdHJpbmcsIFBsdWdpbjxDaGFydFR5cGU+PiA9IG5ldyBNYXAoKTtcclxuXHJcblx0LyoqXHJcblx0ICogUmVnaXN0ZXIgYSBwbHVnaW4gb3IgbXVsdGlwbGUgcGx1Z2lucy5cclxuXHQgKlxyXG5cdCAqIEBwYXJhbSB7c3RyaW5nIHwgUmVjb3JkPHN0cmluZywgUGx1Z2luPENoYXJ0VHlwZT4+fSBrZXkgLSBUaGUga2V5IG9mIHRoZSBwbHVnaW4gdG8gcmVnaXN0ZXIgb3IgYW4gb2JqZWN0IGNvbnRhaW5pbmcgbXVsdGlwbGUgcGx1Z2lucy5cclxuXHQgKiBAcGFyYW0ge1BsdWdpbjxDaGFydFR5cGU+fSBbcGx1Z2luXSAtIFRoZSBwbHVnaW4gaW5zdGFuY2UgdG8gcmVnaXN0ZXIgKGlmIGBrZXlgIGlzIGEgc3RyaW5nKS5cclxuXHQgKiBAcmV0dXJucyB7dm9pZH1cclxuXHQgKi9cclxuXHRyZWdpc3RlcihrZXk6IHN0cmluZywgcGx1Z2luOiBQbHVnaW48Q2hhcnRUeXBlPik6IHZvaWQ7XHJcblx0cmVnaXN0ZXIocGx1Z2luczogUmVjb3JkPHN0cmluZywgUGx1Z2luPENoYXJ0VHlwZT4+KTogdm9pZDtcclxuXHRyZWdpc3RlcihrZXk6IHN0cmluZyB8IFJlY29yZDxzdHJpbmcsIFBsdWdpbjxDaGFydFR5cGU+PiwgcGx1Z2luPzogUGx1Z2luPENoYXJ0VHlwZT4pOiB2b2lkIHtcclxuXHRcdGlmICh0eXBlb2Yga2V5ID09PSAnb2JqZWN0Jykge1xyXG5cdFx0XHRPYmplY3QuZW50cmllcyhrZXkpLmZvckVhY2goKFtrZXksIGZuXSkgPT4gdGhpcy5fcGx1Z2lucy5zZXQoa2V5LCBmbikpO1xyXG5cdFx0XHRyZXR1cm47XHJcblx0XHR9XHJcblxyXG5cdFx0aWYgKHR5cGVvZiBrZXkgPT09ICdzdHJpbmcnICYmIHBsdWdpbikge1xyXG5cdFx0XHR0aGlzLl9wbHVnaW5zLnNldChrZXksIHBsdWdpbik7XHJcblx0XHR9XHJcblx0fVxyXG5cclxuXHQvKipcclxuXHQgKiBDaGVjayBpZiBhIHBsdWdpbiBleGlzdHMgd2l0aCB0aGUgZ2l2ZW4ga2V5XHJcblx0ICogQHBhcmFtIGtleSBUaGUgcGx1Z2luIGtleSB0byBjaGVja1xyXG5cdCAqIEByZXR1cm5zIFRydWUgaWYgdGhlIHBsdWdpbiBleGlzdHMsIGZhbHNlIG90aGVyd2lzZVxyXG5cdCAqL1xyXG5cdHB1YmxpYyBoYXMoa2V5OiBzdHJpbmcpOiBib29sZWFuIHtcclxuXHRcdHJldHVybiB0aGlzLl9wbHVnaW5zLmhhcyhrZXkpO1xyXG5cdH1cclxuXHJcblx0LyoqXHJcblx0ICogR2V0IGEgcGx1Z2luIGJ5IGl0cyBrZXlcclxuXHQgKiBAcGFyYW0ga2V5IFRoZSBrZXkgb2YgdGhlIHBsdWdpbiB0byByZXRyaWV2ZVxyXG5cdCAqIEByZXR1cm5zIFRoZSBwbHVnaW4gaW5zdGFuY2Ugb3IgdW5kZWZpbmVkIGlmIG5vdCBmb3VuZFxyXG5cdCAqL1xyXG5cdHB1YmxpYyBnZXQoa2V5OiBzdHJpbmcpOiBQbHVnaW48Q2hhcnRUeXBlPiB8IHVuZGVmaW5lZCB7XHJcblx0XHRyZXR1cm4gdGhpcy5fcGx1Z2lucy5nZXQoa2V5KTtcclxuXHR9XHJcblxyXG5cdC8qKlxyXG5cdCAqIFJlbW92ZSBhIHBsdWdpbiBieSBpdHMga2V5XHJcblx0ICogQHBhcmFtIGtleSBUaGUga2V5IG9mIHRoZSBwbHVnaW4gdG8gcmVtb3ZlXHJcblx0ICogQHJldHVybnMgVHJ1ZSBpZiB0aGUgcGx1Z2luIHdhcyByZW1vdmVkLCBmYWxzZSBpZiBpdCBkaWRuJ3QgZXhpc3RcclxuXHQgKi9cclxuXHRwdWJsaWMgZGVsZXRlKGtleTogc3RyaW5nKTogYm9vbGVhbiB7XHJcblx0XHRyZXR1cm4gdGhpcy5fcGx1Z2lucy5kZWxldGUoa2V5KTtcclxuXHR9XHJcbn1cclxuIl19

package/esm2015/lib/components/reports/ndf-reports/services/digit-chart.service.js

@@ -0,0 +1,42 @@
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import _ from 'lodash';
+import * as i0 from "@angular/core";
+import * as i1 from "./chart-data-transformers.service";
+export class DigitChartService {
+    constructor(_dataTransformers) {
+        this._dataTransformers = _dataTransformers;
+    }
+    prepareChart(response, config) {
+        if (!config.datasource) {
+            console.warn('No datasource provided for chart configuration');
+            return of(null);
+        }
+        return of(config.datasource).pipe(map((sourceConfig) => {
+            const rawData = _.get(response, sourceConfig.propertyPath);
+            if (this._dataTransformers.hasDigitsTransformer(sourceConfig === null || sourceConfig === void 0 ? void 0 : sourceConfig.transformer)) {
+                const adapter = this._dataTransformers.getDigitsTransformer(sourceConfig === null || sourceConfig === void 0 ? void 0 : sourceConfig.transformer);
+                return adapter(rawData, response);
+            }
+            if (_.isObject(rawData)) {
+                return _.get(rawData, sourceConfig === null || sourceConfig === void 0 ? void 0 : sourceConfig.bindValue, rawData);
+            }
+            if (Array.isArray(rawData)) {
+                return rawData.reduce((acc, item) => {
+                    acc += Number(_.get(item, sourceConfig === null || sourceConfig === void 0 ? void 0 : sourceConfig.bindValue, item.docCount));
+                }, 0);
+            }
+            return rawData;
+        }));
+    }
+}
+DigitChartService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DigitChartService, deps: [{ token: i1.ChartDataTransformers }], target: i0.ɵɵFactoryTarget.Injectable });
+DigitChartService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DigitChartService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DigitChartService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ChartDataTransformers }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/reports/ndf-reports/services/dynamic-timeline-report.service.js

@@ -0,0 +1,72 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, forkJoin, of, pipe, ReplaySubject } from 'rxjs';
+import { catchError, finalize, switchMap } from 'rxjs/operators';
+import _ from 'lodash';
+import * as i0 from "@angular/core";
+import * as i1 from "./index";
+export class DynamicTimelineReportService {
+    constructor(_ndfReportsService) {
+        this._ndfReportsService = _ndfReportsService;
+        this._rebuildTriggerSub = new BehaviorSubject(false);
+        this.rebuild$ = this._rebuildTriggerSub.asObservable();
+        this._isInitialized = false;
+        this.isLoadingResult = false;
+        this._selectedGroupSub = new ReplaySubject();
+        this.selectedGroup$ = this._selectedGroupSub.asObservable();
+    }
+    updateSelectedGroup(selected) {
+        if (!this._selectedGroup) {
+            this._selectedGroup = selected || 'week';
+        }
+        this._selectedGroupSub.next(this._selectedGroup);
+    }
+    changeGroup(group) {
+        this._selectedGroup = group;
+        this._rebuildTriggerSub.next(true);
+    }
+    rebuild() {
+        this._rebuildTriggerSub.next(true);
+    }
+    prepareData() {
+        return pipe(switchMap(([config, criteria]) => {
+            var _a;
+            const request = config === null || config === void 0 ? void 0 : config.request;
+            if (!request) {
+                return of(null);
+            }
+            this.updateSelectedGroup((_a = config === null || config === void 0 ? void 0 : config.group) === null || _a === void 0 ? void 0 : _a.selected);
+            this.payload = _.merge(criteria || {}, this._prepareSelectedGroups(config));
+            const data$ = this._ndfReportsService.getData(request, this.payload).pipe(catchError((error) => {
+                console.error(error);
+                return of(null);
+            }), finalize(() => {
+                this.isLoadingResult = false;
+            }));
+            return forkJoin({
+                config: of(config),
+                data: data$
+            });
+        }));
+    }
+    _prepareSelectedGroups(config) {
+        const data = config.datasource.map((source) => {
+            var _a;
+            return ({
+                name: source.aggregation,
+                interval: this._selectedGroup || ((_a = config === null || config === void 0 ? void 0 : config.group) === null || _a === void 0 ? void 0 : _a.selected) || 'week'
+            });
+        });
+        return {
+            payload: {
+                aggregationNames: data
+            }
+        };
+    }
+}
+DynamicTimelineReportService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DynamicTimelineReportService, deps: [{ token: i1.NdfReportsService }], target: i0.ɵɵFactoryTarget.Injectable });
+DynamicTimelineReportService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DynamicTimelineReportService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DynamicTimelineReportService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.NdfReportsService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/reports/ndf-reports/services/index.js

@@ -0,0 +1,11 @@
+export * from './ndf-reports.service';
+export * from './chart-manager.service';
+export * from './report-transform.service';
+export * from './dynamic-timeline-report.service';
+export * from './reports-state.service';
+export * from './digit-chart.service';
+export * from './base-chart-builder.service';
+export * from './chart-data-transformers.service';
+export * from './chart-plugins-registry.service';
+export * from './report-config-mapper.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9udXhlby1kZXZlbG9wbWVudC1mcmFtZXdvcmsvc3JjL2xpYi9jb21wb25lbnRzL3JlcG9ydHMvbmRmLXJlcG9ydHMvc2VydmljZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyxnQ0FBZ0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbmRmLXJlcG9ydHMuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vY2hhcnQtbWFuYWdlci5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9yZXBvcnQtdHJhbnNmb3JtLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2R5bmFtaWMtdGltZWxpbmUtcmVwb3J0LnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL3JlcG9ydHMtc3RhdGUuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZGlnaXQtY2hhcnQuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vYmFzZS1jaGFydC1idWlsZGVyLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2NoYXJ0LWRhdGEtdHJhbnNmb3JtZXJzLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2NoYXJ0LXBsdWdpbnMtcmVnaXN0cnkuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vcmVwb3J0LWNvbmZpZy1tYXBwZXIuc2VydmljZSc7XHJcbiJdfQ==

package/esm2015/lib/components/reports/ndf-reports/services/ndf-reports.service.js

@@ -0,0 +1,49 @@
+import { Injectable } from '@angular/core';
+import _ from 'lodash';
+import { BaseService } from '../../../../shared/services';
+import * as i0 from "@angular/core";
+export class NdfReportsService extends BaseService {
+    getData(request, criteria = {}) {
+        return (request === null || request === void 0 ? void 0 : request.customUrl) ? this._customQuery(request, criteria) : this._query(request, criteria);
+    }
+    _query(request, criteria) {
+        const { params } = this._prepareRequest(request, criteria);
+        return this.query({
+            pageProvider: request.pageProvider,
+            headers: request === null || request === void 0 ? void 0 : request.headers,
+            params: params
+        });
+    }
+    _customQuery(request, criteria) {
+        var _a;
+        const { params, payload } = this._prepareRequest(request, criteria);
+        return this.request({
+            type: ((_a = request.customUrl) === null || _a === void 0 ? void 0 : _a.method) || 'get',
+            endpoint: request.customUrl.url,
+            headers: request === null || request === void 0 ? void 0 : request.headers,
+            queryParams: params,
+            payload: payload
+        });
+    }
+    _prepareRequest(request, criteria) {
+        const params = Object.assign(Object.assign({ pageSize: 1 }, ((request === null || request === void 0 ? void 0 : request.params) || {})), ((criteria === null || criteria === void 0 ? void 0 : criteria.params) || {}));
+        const payload = _.mergeWith(request.payload || {}, (criteria === null || criteria === void 0 ? void 0 : criteria.payload) || {}, (objValue, srcValue, key) => {
+            if (Array.isArray(objValue) && key === 'predicateList') {
+                return objValue.concat(srcValue);
+            }
+        });
+        return {
+            params,
+            payload
+        };
+    }
+}
+NdfReportsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NdfReportsService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+NdfReportsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NdfReportsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NdfReportsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/reports/ndf-reports/services/report-config-mapper.service.js

@@ -0,0 +1,82 @@
+import { __rest } from "tslib";
+import { Injectable } from '@angular/core';
+import { ChartUtils } from '../../charts';
+import { getChartsOptions, getDoughnutOptions, getHorizontalBarOptions, getLineOptions, getPieOptions, getVerticalBarOptions } from '../options';
+import * as i0 from "@angular/core";
+import * as i1 from "./chart-plugins-registry.service";
+export class ReportConfigMapperService {
+    constructor(_chartPluginsRegistry) {
+        this._chartPluginsRegistry = _chartPluginsRegistry;
+    }
+    /**
+     * Prepares a graph chart configuration by converting plugin names to actual plugin objects
+     * @param config The graph chart definition
+     * @returns The prepared graph chart with plugin objects
+     */
+    prepareGraphConfig(config) {
+        const _a = config.chart, { plugins, colors, options, direction, overrides } = _a, rest = __rest(_a, ["plugins", "colors", "options", "direction", "overrides"]);
+        const chart = Object.assign(Object.assign({}, rest), { overrides: getChartsOptions(overrides), options: this._getChartOptions(config.chart.type, options, direction) });
+        if (Array.isArray(plugins) && plugins.length > 0) {
+            chart.plugins = this._preparePlugins(plugins);
+        }
+        chart.colors = [...(colors || []), ...ChartUtils.getColors()];
+        return Object.assign(Object.assign({}, config), { chart: chart });
+    }
+    /**
+     * Prepares a dynamic line chart configuration by converting plugin names to actual plugin objects
+     * @param config The dynamic line chart definition
+     * @returns The prepared dynamic line chart with plugin objects
+     */
+    prepareGraphLineConfig(config) {
+        const _a = config.chart, { plugins, options } = _a, rest = __rest(_a, ["plugins", "options"]);
+        const chart = Object.assign(Object.assign({}, rest), { options: getLineOptions(options) });
+        if (Array.isArray(plugins) && plugins.length > 0) {
+            chart.plugins = this._preparePlugins(plugins);
+        }
+        const _colors = [...((config === null || config === void 0 ? void 0 : config.colors) || []), ...ChartUtils.getColors()];
+        return Object.assign(Object.assign({}, config), { colors: _colors, chart: chart });
+    }
+    /**
+     * Prepares a digit chart configuration
+     * @param config The digit chart definition
+     * @returns The prepared digit chart (currently just returns the input as is)
+     */
+    prepareDigitConfig(config) {
+        return config;
+    }
+    /**
+     * Converts an array of plugin names to an array of plugin objects
+     * @param plugins Array of plugin names
+     * @returns Array of plugin objects or undefined if no plugins
+     */
+    _preparePlugins(plugins) {
+        return plugins.reduce((acc, plgName) => {
+            const plugin = this._chartPluginsRegistry.get(plgName);
+            if (plugin) {
+                return [...acc, plugin];
+            }
+            return acc;
+        }, []);
+    }
+    _getChartOptions(type, options, direction = 'horizontal') {
+        var _a;
+        const _optionsMap = {
+            verticalBar: getVerticalBarOptions,
+            horizontalBar: getHorizontalBarOptions,
+            doughnut: getDoughnutOptions,
+            line: getLineOptions,
+            pie: getPieOptions
+        };
+        const key = type === 'bar' ? `${direction}Bar` : type;
+        return ((_a = _optionsMap[key]) === null || _a === void 0 ? void 0 : _a.call(_optionsMap, options)) || {};
+    }
+}
+ReportConfigMapperService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ReportConfigMapperService, deps: [{ token: i1.ChartPluginsRegistry }], target: i0.ɵɵFactoryTarget.Injectable });
+ReportConfigMapperService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ReportConfigMapperService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ReportConfigMapperService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ChartPluginsRegistry }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-config-mapper.service.js","sourceRoot":"","sources":["../../../../../../../../projects/nuxeo-development-framework/src/lib/components/reports/ndf-reports/services/report-config-mapper.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport {\r\n\tDigitChart,\r\n\tDigitChartDefinition,\r\n\tDynamicLineChart,\r\n\tDynamicLineChartDefinition,\r\n\tDynamicLineChartOptions,\r\n\tGraphChart,\r\n\tGraphChartDefinition,\r\n\tGraphChartOptions\r\n} from '../models';\r\nimport { ChartPluginsRegistry } from './chart-plugins-registry.service';\r\nimport { ChartOptions, ChartType, Plugin } from 'chart.js';\r\nimport { ChartUtils, CustomPluginChartOptions } from '../../charts';\r\nimport _ from 'lodash';\r\nimport {\r\n\tgetChartsOptions,\r\n\tgetDoughnutOptions,\r\n\tgetHorizontalBarOptions,\r\n\tgetLineOptions,\r\n\tgetPieOptions,\r\n\tgetVerticalBarOptions\r\n} from '../options';\r\n\r\n@Injectable({\r\n\tprovidedIn: 'root'\r\n})\r\nexport class ReportConfigMapperService {\r\n\tconstructor(private readonly _chartPluginsRegistry: ChartPluginsRegistry) {}\r\n\r\n\t/**\r\n\t * Prepares a graph chart configuration by converting plugin names to actual plugin objects\r\n\t * @param config The graph chart definition\r\n\t * @returns The prepared graph chart with plugin objects\r\n\t */\r\n\tprepareGraphConfig(config: GraphChartDefinition): GraphChart {\r\n\t\tconst { plugins, colors, options, direction, overrides, ...rest } = config.chart;\r\n\r\n\t\tconst chart: GraphChartOptions = {\r\n\t\t\t...rest,\r\n\t\t\toverrides: getChartsOptions(overrides),\r\n\t\t\toptions: this._getChartOptions(config.chart.type, options, direction)\r\n\t\t};\r\n\r\n\t\tif (Array.isArray(plugins) && plugins.length > 0) {\r\n\t\t\tchart.plugins = this._preparePlugins(plugins);\r\n\t\t}\r\n\r\n\t\tchart.colors = [...(colors || []), ...ChartUtils.getColors()];\r\n\r\n\t\treturn {\r\n\t\t\t...config,\r\n\t\t\tchart: chart\r\n\t\t} as GraphChart;\r\n\t}\r\n\r\n\t/**\r\n\t * Prepares a dynamic line chart configuration by converting plugin names to actual plugin objects\r\n\t * @param config The dynamic line chart definition\r\n\t * @returns The prepared dynamic line chart with plugin objects\r\n\t */\r\n\tprepareGraphLineConfig(config: DynamicLineChartDefinition): DynamicLineChart {\r\n\t\tconst { plugins, options, ...rest } = config.chart;\r\n\r\n\t\tconst chart: DynamicLineChartOptions = {\r\n\t\t\t...rest,\r\n\t\t\toptions: getLineOptions(options)\r\n\t\t};\r\n\t\tif (Array.isArray(plugins) && plugins.length > 0) {\r\n\t\t\tchart.plugins = this._preparePlugins(plugins);\r\n\t\t}\r\n\t\tconst _colors = [...(config?.colors || []), ...ChartUtils.getColors()];\r\n\r\n\t\treturn {\r\n\t\t\t...config,\r\n\t\t\tcolors: _colors,\r\n\t\t\tchart: chart\r\n\t\t} as DynamicLineChart;\r\n\t}\r\n\r\n\t/**\r\n\t * Prepares a digit chart configuration\r\n\t * @param config The digit chart definition\r\n\t * @returns The prepared digit chart (currently just returns the input as is)\r\n\t */\r\n\tprepareDigitConfig(config: DigitChartDefinition): DigitChart {\r\n\t\treturn config as DigitChart;\r\n\t}\r\n\r\n\t/**\r\n\t * Converts an array of plugin names to an array of plugin objects\r\n\t * @param plugins Array of plugin names\r\n\t * @returns Array of plugin objects or undefined if no plugins\r\n\t */\r\n\tprivate _preparePlugins(plugins: string[]): undefined | Plugin<ChartType>[] {\r\n\t\treturn plugins.reduce((acc, plgName) => {\r\n\t\t\tconst plugin = this._chartPluginsRegistry.get(plgName);\r\n\t\t\tif (plugin) {\r\n\t\t\t\treturn [...acc, plugin];\r\n\t\t\t}\r\n\t\t\treturn acc;\r\n\t\t}, []);\r\n\t}\r\n\r\n\tprivate _getChartOptions(\r\n\t\ttype: ChartType,\r\n\t\toptions: ChartOptions,\r\n\t\tdirection: 'horizontal' | 'vertical' = 'horizontal'\r\n\t) {\r\n\t\tconst _optionsMap = {\r\n\t\t\tverticalBar: getVerticalBarOptions,\r\n\t\t\thorizontalBar: getHorizontalBarOptions,\r\n\t\t\tdoughnut: getDoughnutOptions,\r\n\t\t\tline: getLineOptions,\r\n\t\t\tpie: getPieOptions\r\n\t\t};\r\n\r\n\t\tconst key = type === 'bar' ? `${direction}Bar` : type;\r\n\t\treturn _optionsMap[key]?.(options) || {};\r\n\t}\r\n}\r\n"]}

package/esm2015/lib/components/reports/ndf-reports/services/report-transform.service.js

@@ -0,0 +1,98 @@
+import { Injectable } from '@angular/core';
+import _ from 'lodash';
+import { forkJoin, of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../core/services";
+export class ReportTransformService {
+    constructor(_ndfTransformService) {
+        this._ndfTransformService = _ndfTransformService;
+    }
+    _extractDataFormats(data) {
+        const extractedData = _.flatMap(data, (item) => {
+            if (Array.isArray(item === null || item === void 0 ? void 0 : item.datasource)) {
+                return _.filter(item.datasource, (source) => source.dataFormat);
+            }
+            return [];
+        });
+        return _.groupBy(extractedData, 'dataFormat');
+    }
+    prepareData(reportData, config) {
+        var _a;
+        const fields = this._extractDataFormats(config.reports.items);
+        if (!((_a = Object.values(fields)) === null || _a === void 0 ? void 0 : _a.length)) {
+            return of(reportData);
+        }
+        const observables$ = Object.entries(fields).map(([key, value]) => {
+            return this._transformDataFormat(key, value, reportData);
+        });
+        return forkJoin(observables$).pipe(map((data) => {
+            return this._updateBuckets(data, reportData);
+        }));
+    }
+    _updateBuckets(data, reportData) {
+        if (!(data === null || data === void 0 ? void 0 : data.length)) {
+            return reportData;
+        }
+        data.forEach((localizedBuckets) => {
+            localizedBuckets.forEach((item) => {
+                _.set(reportData, item.propertyPath, item.buckets);
+            });
+        });
+        return reportData;
+    }
+    _key(k) {
+        return `${k}`.split('/').pop();
+    }
+    _transformDataFormat(dataFormat, values, reportData) {
+        if (!this._ndfTransformService.has(dataFormat)) {
+            throw new Error(`No transformer defined for type: ${dataFormat}`);
+        }
+        const formats = this._extractBuckets(values, reportData);
+        const keys = this._getUniqueKeysFromFormats(formats);
+        if (keys.length) {
+            return this._ndfTransformService
+                .transform(dataFormat, keys)
+                .pipe(map((response) => this._applyLocalization(formats, response)));
+        }
+        return of([]);
+    }
+    _getUniqueKeysFromFormats(formats) {
+        return _.uniq(_.flatMap(formats, (item) => _.map(item.buckets, (bk) => this._key(bk.key))));
+    }
+    _extractBuckets(values, reportData) {
+        return values
+            .map((value) => {
+            const buckets = _.get(reportData, value.propertyPath);
+            if (buckets === null || buckets === void 0 ? void 0 : buckets.length) {
+                return Object.assign(Object.assign({}, value), { buckets: buckets });
+            }
+        })
+            .filter(Boolean);
+    }
+    _applyLocalization(formats, response) {
+        return !!(response === null || response === void 0 ? void 0 : response.length)
+            ? formats.map((format) => {
+                format.buckets.forEach((bucket) => {
+                    const cacheItem = _.find(response, { code: this._key(bucket.key) });
+                    if (cacheItem) {
+                        bucket.localized = {
+                            ar: cacheItem.arabicTitle,
+                            en: cacheItem.englishTitle
+                        };
+                    }
+                });
+                return format;
+            })
+            : [];
+    }
+}
+ReportTransformService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ReportTransformService, deps: [{ token: i1.NdfTransformService }], target: i0.ɵɵFactoryTarget.Injectable });
+ReportTransformService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ReportTransformService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ReportTransformService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NdfTransformService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-transform.service.js","sourceRoot":"","sources":["../../../../../../../../projects/nuxeo-development-framework/src/lib/components/reports/ndf-reports/services/report-transform.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\n\r\nimport _ from 'lodash';\r\nimport { forkJoin, of } from 'rxjs';\r\nimport { map } from 'rxjs/operators';\r\nimport { ApiResponseModel, EntryModel } from '../../../../core/models';\r\nimport { NdfTransformService } from '../../../../core/services';\r\nimport { StatisticBucket } from '../../charts';\r\nimport { NdfReportsConfig, ReportDefinitionModel, ReportDataSource } from '../models';\r\n\r\ntype LocalizeStatisticBucket = StatisticBucket & { en: string; ar: string };\r\n\r\n@Injectable({\r\n\tprovidedIn: 'root'\r\n})\r\nexport class ReportTransformService {\r\n\tconstructor(private readonly _ndfTransformService: NdfTransformService) {}\r\n\r\n\tprivate _extractDataFormats(data: ReportDefinitionModel[]) {\r\n\t\tconst extractedData = _.flatMap(data, (item) => {\r\n\t\t\tif (Array.isArray(item?.datasource)) {\r\n\t\t\t\treturn _.filter(item.datasource, (source) => source.dataFormat);\r\n\t\t\t}\r\n\t\t\treturn [];\r\n\t\t});\r\n\t\treturn _.groupBy(extractedData, 'dataFormat');\r\n\t}\r\n\r\n\tprepareData(reportData: ApiResponseModel, config: NdfReportsConfig) {\r\n\t\tconst fields = this._extractDataFormats(config.reports.items);\r\n\r\n\t\tif (!Object.values(fields)?.length) {\r\n\t\t\treturn of(reportData);\r\n\t\t}\r\n\r\n\t\tconst observables$ = Object.entries(fields).map(([key, value]) => {\r\n\t\t\treturn this._transformDataFormat(key, value as any, reportData);\r\n\t\t});\r\n\r\n\t\treturn forkJoin(observables$).pipe(\r\n\t\t\tmap((data) => {\r\n\t\t\t\treturn this._updateBuckets(data, reportData);\r\n\t\t\t})\r\n\t\t);\r\n\t}\r\n\r\n\tprivate _updateBuckets(data: LocalizeStatisticBucket[][], reportData: ApiResponseModel<EntryModel>): any {\r\n\t\tif (!data?.length) {\r\n\t\t\treturn reportData;\r\n\t\t}\r\n\r\n\t\tdata.forEach((localizedBuckets) => {\r\n\t\t\tlocalizedBuckets.forEach((item) => {\r\n\t\t\t\t_.set(reportData, item.propertyPath, item.buckets);\r\n\t\t\t});\r\n\t\t});\r\n\r\n\t\treturn reportData;\r\n\t}\r\n\r\n\tprivate _key(k: string) {\r\n\t\treturn `${k}`.split('/').pop();\r\n\t}\r\n\r\n\tprivate _transformDataFormat(\r\n\t\tdataFormat: string,\r\n\t\tvalues: Pick<ReportDataSource, 'propertyPath' | 'dataFormat'>[],\r\n\t\treportData: ApiResponseModel\r\n\t) {\r\n\t\tif (!this._ndfTransformService.has(dataFormat)) {\r\n\t\t\tthrow new Error(`No transformer defined for type: ${dataFormat}`);\r\n\t\t}\r\n\r\n\t\tconst formats = this._extractBuckets(values, reportData);\r\n\r\n\t\tconst keys = this._getUniqueKeysFromFormats(formats);\r\n\r\n\t\tif (keys.length) {\r\n\t\t\treturn this._ndfTransformService\r\n\t\t\t\t.transform(dataFormat, keys)\r\n\t\t\t\t.pipe(map((response) => this._applyLocalization(formats, response)));\r\n\t\t}\r\n\r\n\t\treturn of([]);\r\n\t}\r\n\r\n\tprivate _getUniqueKeysFromFormats(formats: any[]) {\r\n\t\treturn _.uniq(_.flatMap(formats, (item) => _.map(item.buckets, (bk) => this._key(bk.key))));\r\n\t}\r\n\r\n\tprivate _extractBuckets(\r\n\t\tvalues: Pick<ReportDataSource, 'propertyPath' | 'dataFormat'>[],\r\n\t\treportData: ApiResponseModel\r\n\t) {\r\n\t\treturn values\r\n\t\t\t.map((value) => {\r\n\t\t\t\tconst buckets: StatisticBucket[] = _.get(reportData, value.propertyPath);\r\n\t\t\t\tif (buckets?.length) {\r\n\t\t\t\t\treturn {\r\n\t\t\t\t\t\t...value,\r\n\t\t\t\t\t\tbuckets: buckets\r\n\t\t\t\t\t};\r\n\t\t\t\t}\r\n\t\t\t})\r\n\t\t\t.filter(Boolean);\r\n\t}\r\n\r\n\tprivate _applyLocalization(formats: any[], response: any[]) {\r\n\t\treturn !!response?.length\r\n\t\t\t? formats.map((format) => {\r\n\t\t\t\t\tformat.buckets.forEach((bucket) => {\r\n\t\t\t\t\t\tconst cacheItem = _.find(response, { code: this._key(bucket.key) });\r\n\t\t\t\t\t\tif (cacheItem) {\r\n\t\t\t\t\t\t\tbucket.localized = {\r\n\t\t\t\t\t\t\t\tar: cacheItem.arabicTitle,\r\n\t\t\t\t\t\t\t\ten: cacheItem.englishTitle\r\n\t\t\t\t\t\t\t};\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t});\r\n\t\t\t\t\treturn format;\r\n\t\t\t\t})\r\n\t\t\t: [];\r\n\t}\r\n}\r\n"]}