@netgrif/components-core 6.2.3 → 6.3.0-beta.2

package/esm2020/lib/data-fields/task-ref-field/abstract-task-ref-field.component.mjs

@@ -0,0 +1,133 @@
+import { Component, Inject, Input, Optional } from '@angular/core';
+import { AbstractDataFieldComponent } from '../models/abstract-data-field-component';
+import { NAE_INFORM_ABOUT_INVALID_DATA } from '../models/invalid-data-policy-token';
+import { TaskRefDashboardConstants } from './model/task-ref-dashboard-constants';
+import { TaskRefDashboardTileConstants } from './model/task-ref-dashboard-tile-constants';
+import * as i0 from "@angular/core";
+import * as i1 from "../../logger/public-api";
+export class AbstractTaskRefFieldComponent extends AbstractDataFieldComponent {
+    constructor(_logger, informAboutInvalidData) {
+        super(informAboutInvalidData);
+        this._logger = _logger;
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.createDashboardTiles();
+    }
+    createDashboardTiles() {
+        const gridRows = this.dataField.dashboardRows;
+        if (gridRows === undefined) {
+            this._logger.error(`TaskRef Dashboard '${this.dataField.stringId}' does not specify grid height! Add a number field with id '${TaskRefDashboardConstants.DASHBOARD_ROWS}' to the same task as the task ref field, to specify the height.`);
+        }
+        const gridCols = this.dataField.dashboardCols;
+        if (gridCols === undefined) {
+            this._logger.error(`TaskRef Dashboard '${this.dataField.stringId}' does not specify grid width! Add a number field with id '${TaskRefDashboardConstants.DASHBOARD_COLS}' to the same task as the task ref field, to specify the width.`);
+        }
+        const occupiedTiles = this.createFlagGrid(gridRows, gridCols);
+        this.dashboardTiles = [];
+        if (this.dataField.dashboardTiles && this.dataField.dashboardTiles.length > 0) {
+            for (const extractedTile of this.dataField.dashboardTiles) {
+                const tile = this.createDashboardTile(extractedTile);
+                this.dashboardTiles.push(tile);
+                this.occupySpace(occupiedTiles, tile.y, tile.x, tile.cols, tile.rows);
+            }
+        }
+        for (let y = 0; y < occupiedTiles.length; y++) {
+            for (let x = 0; x < occupiedTiles[y].length; x++) {
+                if (!occupiedTiles[y][x]) {
+                    this.dashboardTiles.push(this.createEmptyDashboardTile(x, y));
+                }
+            }
+        }
+    }
+    createFlagGrid(rows = 1, cols = 1) {
+        const result = [];
+        for (let r = 0; r < rows; r++) {
+            result.push(Array(cols).fill(false));
+        }
+        return result;
+    }
+    createDashboardTile(tile) {
+        const result = {
+            dataGroups: tile.dataGroups
+        };
+        for (const dg of tile.dataGroups) {
+            for (const field of dg.fields) {
+                switch (field.stringId) {
+                    case TaskRefDashboardTileConstants.DASHBOARD_TILE_X:
+                        result.x = field.value;
+                        break;
+                    case TaskRefDashboardTileConstants.DASHBOARD_TILE_Y:
+                        result.y = field.value;
+                        break;
+                    case TaskRefDashboardTileConstants.DASHBOARD_TILE_ROWS:
+                        result.rows = field.value;
+                        break;
+                    case TaskRefDashboardTileConstants.DASHBOARD_TILE_COLS:
+                        result.cols = field.value;
+                        break;
+                }
+            }
+        }
+        if (result.x === undefined) {
+            if (tile.dataGroups.length > 0) {
+                this._logger.error(`Task ref dashboard tile from task '${tile.dataGroups[0].parentTaskId}' transition '${tile.dataGroups[0].parentTransitionId}' case '${tile.dataGroups[0].parentCaseId}' does not specify tile grid X coordinate! Add a number field with ID '${TaskRefDashboardTileConstants.DASHBOARD_TILE_X}' to the referenced task to specify it.`);
+            }
+            result.x = 0;
+        }
+        if (result.y === undefined) {
+            if (tile.dataGroups.length > 0) {
+                this._logger.error(`Task ref dashboard tile from task '${tile.dataGroups[0].parentTaskId}' transition '${tile.dataGroups[0].parentTransitionId}' case '${tile.dataGroups[0].parentCaseId}' does not specify tile grid Y coordinate! Add a number field with ID '${TaskRefDashboardTileConstants.DASHBOARD_TILE_Y}' to the referenced task to specify it.`);
+            }
+            result.y = 0;
+        }
+        if (result.rows === undefined) {
+            if (tile.dataGroups.length > 0) {
+                this._logger.error(`Task ref dashboard tile from task '${tile.dataGroups[0].parentTaskId}' transition '${tile.dataGroups[0].parentTransitionId}' case '${tile.dataGroups[0].parentCaseId}' does not specify tile height coordinate! Add a number field with ID '${TaskRefDashboardTileConstants.DASHBOARD_TILE_ROWS}' to the referenced task to specify it.`);
+            }
+            result.rows = 1;
+        }
+        if (result.cols === undefined) {
+            if (tile.dataGroups.length > 0) {
+                this._logger.error(`Task ref dashboard tile from task '${tile.dataGroups[0].parentTaskId}' transition '${tile.dataGroups[0].parentTransitionId}' case '${tile.dataGroups[0].parentCaseId}' does not specify tile width coordinate! Add a number field with ID '${TaskRefDashboardTileConstants.DASHBOARD_TILE_COLS}' to the referenced task to specify it.`);
+            }
+            result.cols = 1;
+        }
+        return result;
+    }
+    // TODO a modified copy of a method of the same name from AbstractTaskContentComponent
+    occupySpace(grid, y, x, width, height) {
+        for (let j = y; j < y + height; j++) {
+            for (let i = x; i < x + width; i++) {
+                grid[j][i] = true;
+            }
+        }
+    }
+    createEmptyDashboardTile(x, y) {
+        return {
+            dataGroups: [],
+            x,
+            y,
+            rows: 1,
+            cols: 1,
+            isEmpty: true
+        };
+    }
+}
+AbstractTaskRefFieldComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AbstractTaskRefFieldComponent, deps: [{ token: i1.LoggerService }, { token: NAE_INFORM_ABOUT_INVALID_DATA, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+AbstractTaskRefFieldComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: AbstractTaskRefFieldComponent, selector: "ncc-abstract-task-ref-field", inputs: { dataField: "dataField" }, usesInheritance: true, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AbstractTaskRefFieldComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ncc-abstract-task-ref-field',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: i1.LoggerService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [NAE_INFORM_ABOUT_INVALID_DATA]
+                }] }]; }, propDecorators: { dataField: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-task-ref-field.component.js","sourceRoot":"","sources":["../../../../../../projects/netgrif-components-core/src/lib/data-fields/task-ref-field/abstract-task-ref-field.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, Inject, Input, OnInit, Optional} from '@angular/core';\nimport {LoggerService} from '../../logger/public-api';\nimport {AbstractDataFieldComponent} from '../models/abstract-data-field-component';\nimport {NAE_INFORM_ABOUT_INVALID_DATA} from '../models/invalid-data-policy-token';\nimport {TaskRefDashboardConstants} from './model/task-ref-dashboard-constants';\nimport {TaskRefField} from './model/task-ref-field';\nimport {TaskRefDashboardTileConstants} from './model/task-ref-dashboard-tile-constants';\nimport {TaskRefDashboardTile} from './model/task-ref-dashboard-tile';\n\n@Component({\n    selector: 'ncc-abstract-task-ref-field',\n    template: ''\n})\nexport abstract class AbstractTaskRefFieldComponent extends AbstractDataFieldComponent implements OnInit {\n\n    @Input() dataField: TaskRefField;\n    dashboardTiles: Array<TaskRefDashboardTile>;\n\n    protected constructor(protected _logger: LoggerService,\n                          @Optional() @Inject(NAE_INFORM_ABOUT_INVALID_DATA) informAboutInvalidData: boolean | null) {\n        super(informAboutInvalidData);\n    }\n\n    ngOnInit() {\n        super.ngOnInit();\n        this.createDashboardTiles();\n    }\n\n    protected createDashboardTiles() {\n        const gridRows = this.dataField.dashboardRows;\n        if (gridRows === undefined) {\n            this._logger.error(`TaskRef Dashboard '${this.dataField.stringId}' does not specify grid height! Add a number field with id '${TaskRefDashboardConstants.DASHBOARD_ROWS}' to the same task as the task ref field, to specify the height.`);\n        }\n        const gridCols = this.dataField.dashboardCols;\n        if (gridCols === undefined) {\n            this._logger.error(`TaskRef Dashboard '${this.dataField.stringId}' does not specify grid width! Add a number field with id '${TaskRefDashboardConstants.DASHBOARD_COLS}' to the same task as the task ref field, to specify the width.`);\n        }\n        const occupiedTiles = this.createFlagGrid(gridRows, gridCols);\n        this.dashboardTiles = [];\n        if (this.dataField.dashboardTiles && this.dataField.dashboardTiles.length > 0) {\n            for (const extractedTile of this.dataField.dashboardTiles) {\n                const tile = this.createDashboardTile(extractedTile);\n                this.dashboardTiles.push(tile);\n                this.occupySpace(occupiedTiles, tile.y, tile.x, tile.cols, tile.rows);\n            }\n        }\n        for (let y = 0; y < occupiedTiles.length; y++) {\n            for (let x = 0; x < occupiedTiles[y].length; x++) {\n                if (!occupiedTiles[y][x]) {\n                    this.dashboardTiles.push(this.createEmptyDashboardTile(x, y));\n                }\n            }\n        }\n    }\n\n    protected createFlagGrid(rows: number = 1, cols: number = 1): Array<Array<boolean>> {\n        const result = [];\n        for (let r = 0; r < rows; r++) {\n            result.push(Array(cols).fill(false));\n        }\n        return result;\n    }\n\n    protected createDashboardTile(tile: TaskRefDashboardTile): TaskRefDashboardTile {\n        const result: TaskRefDashboardTile = {\n            dataGroups: tile.dataGroups\n        };\n\n        for (const dg of tile.dataGroups) {\n            for (const field of dg.fields) {\n                switch (field.stringId) {\n                    case TaskRefDashboardTileConstants.DASHBOARD_TILE_X:\n                        result.x = field.value;\n                        break;\n                    case TaskRefDashboardTileConstants.DASHBOARD_TILE_Y:\n                        result.y = field.value;\n                        break;\n                    case TaskRefDashboardTileConstants.DASHBOARD_TILE_ROWS:\n                        result.rows = field.value;\n                        break;\n                    case TaskRefDashboardTileConstants.DASHBOARD_TILE_COLS:\n                        result.cols = field.value;\n                        break;\n\n                }\n            }\n        }\n\n        if (result.x === undefined) {\n            if (tile.dataGroups.length > 0) {\n                this._logger.error(`Task ref dashboard tile from task '${tile.dataGroups[0].parentTaskId}' transition '${tile.dataGroups[0].parentTransitionId}' case '${tile.dataGroups[0].parentCaseId}' does not specify tile grid X coordinate! Add a number field with ID '${TaskRefDashboardTileConstants.DASHBOARD_TILE_X}' to the referenced task to specify it.`);\n            }\n            result.x = 0;\n        }\n        if (result.y === undefined) {\n            if (tile.dataGroups.length > 0) {\n                this._logger.error(`Task ref dashboard tile from task '${tile.dataGroups[0].parentTaskId}' transition '${tile.dataGroups[0].parentTransitionId}' case '${tile.dataGroups[0].parentCaseId}' does not specify tile grid Y coordinate! Add a number field with ID '${TaskRefDashboardTileConstants.DASHBOARD_TILE_Y}' to the referenced task to specify it.`);\n            }\n            result.y = 0;\n        }\n        if (result.rows === undefined) {\n            if (tile.dataGroups.length > 0) {\n                this._logger.error(`Task ref dashboard tile from task '${tile.dataGroups[0].parentTaskId}' transition '${tile.dataGroups[0].parentTransitionId}' case '${tile.dataGroups[0].parentCaseId}' does not specify tile height coordinate! Add a number field with ID '${TaskRefDashboardTileConstants.DASHBOARD_TILE_ROWS}' to the referenced task to specify it.`);\n            }\n            result.rows = 1;\n        }\n        if (result.cols === undefined) {\n            if (tile.dataGroups.length > 0) {\n                this._logger.error(`Task ref dashboard tile from task '${tile.dataGroups[0].parentTaskId}' transition '${tile.dataGroups[0].parentTransitionId}' case '${tile.dataGroups[0].parentCaseId}' does not specify tile width coordinate! Add a number field with ID '${TaskRefDashboardTileConstants.DASHBOARD_TILE_COLS}' to the referenced task to specify it.`);\n            }\n            result.cols = 1;\n        }\n\n        return result;\n    }\n\n    // TODO a modified copy of a method of the same name from AbstractTaskContentComponent\n    protected occupySpace(grid: Array<Array<boolean>>, y: number, x: number, width: number, height: number) {\n        for (let j = y; j < y + height; j++) {\n            for (let i = x; i < x + width; i++) {\n                grid[j][i] = true;\n            }\n        }\n    }\n\n    protected createEmptyDashboardTile(x: number, y: number): TaskRefDashboardTile {\n        return {\n            dataGroups: [],\n            x,\n            y,\n            rows: 1,\n            cols: 1,\n            isEmpty: true\n        }\n    }\n}\n"]}

package/esm2020/lib/data-fields/task-ref-field/model/task-ref-components.mjs

@@ -0,0 +1,8 @@
+/**
+ * A collection of Task ref field component names supported by the application engine.
+ */
+export var TaskRefComponents;
+(function (TaskRefComponents) {
+    TaskRefComponents["DASHBOARD"] = "dashboard";
+})(TaskRefComponents || (TaskRefComponents = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay1yZWYtY29tcG9uZW50cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25ldGdyaWYtY29tcG9uZW50cy1jb3JlL3NyYy9saWIvZGF0YS1maWVsZHMvdGFzay1yZWYtZmllbGQvbW9kZWwvdGFzay1yZWYtY29tcG9uZW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sQ0FBTixJQUFZLGlCQUVYO0FBRkQsV0FBWSxpQkFBaUI7SUFDekIsNENBQXVCLENBQUE7QUFDM0IsQ0FBQyxFQUZXLGlCQUFpQixLQUFqQixpQkFBaUIsUUFFNUIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEEgY29sbGVjdGlvbiBvZiBUYXNrIHJlZiBmaWVsZCBjb21wb25lbnQgbmFtZXMgc3VwcG9ydGVkIGJ5IHRoZSBhcHBsaWNhdGlvbiBlbmdpbmUuXG4gKi9cbmV4cG9ydCBlbnVtIFRhc2tSZWZDb21wb25lbnRzIHtcbiAgICBEQVNIQk9BUkQgPSAnZGFzaGJvYXJkJ1xufVxuIl19

package/esm2020/lib/data-fields/task-ref-field/model/task-ref-dashboard-constants.mjs

@@ -0,0 +1,10 @@
+/**
+ * A collection of Task ref field dashboard component constants used to reference elements of the underlying processes
+ */
+export var TaskRefDashboardConstants;
+(function (TaskRefDashboardConstants) {
+    TaskRefDashboardConstants["DASHBOARD_ROWS"] = "rows";
+    TaskRefDashboardConstants["DASHBOARD_COLS"] = "cols";
+    TaskRefDashboardConstants["DASHBOARD_TASK_REF"] = "dashboard";
+})(TaskRefDashboardConstants || (TaskRefDashboardConstants = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay1yZWYtZGFzaGJvYXJkLWNvbnN0YW50cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25ldGdyaWYtY29tcG9uZW50cy1jb3JlL3NyYy9saWIvZGF0YS1maWVsZHMvdGFzay1yZWYtZmllbGQvbW9kZWwvdGFzay1yZWYtZGFzaGJvYXJkLWNvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sQ0FBTixJQUFZLHlCQUlYO0FBSkQsV0FBWSx5QkFBeUI7SUFDakMsb0RBQXVCLENBQUE7SUFDdkIsb0RBQXVCLENBQUE7SUFDdkIsNkRBQWdDLENBQUE7QUFDcEMsQ0FBQyxFQUpXLHlCQUF5QixLQUF6Qix5QkFBeUIsUUFJcEMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEEgY29sbGVjdGlvbiBvZiBUYXNrIHJlZiBmaWVsZCBkYXNoYm9hcmQgY29tcG9uZW50IGNvbnN0YW50cyB1c2VkIHRvIHJlZmVyZW5jZSBlbGVtZW50cyBvZiB0aGUgdW5kZXJseWluZyBwcm9jZXNzZXNcbiAqL1xuZXhwb3J0IGVudW0gVGFza1JlZkRhc2hib2FyZENvbnN0YW50cyB7XG4gICAgREFTSEJPQVJEX1JPV1MgPSAncm93cycsXG4gICAgREFTSEJPQVJEX0NPTFMgPSAnY29scycsXG4gICAgREFTSEJPQVJEX1RBU0tfUkVGID0gJ2Rhc2hib2FyZCcsXG59XG4iXX0=

package/esm2020/lib/data-fields/task-ref-field/model/task-ref-dashboard-tile-constants.mjs

@@ -0,0 +1,13 @@
+/**
+ * A collection of Task ref field dashboard tile component constants used to reference elements of the underlying processes
+ */
+export var TaskRefDashboardTileConstants;
+(function (TaskRefDashboardTileConstants) {
+    TaskRefDashboardTileConstants["DASHBOARD_TILE_X"] = "x";
+    TaskRefDashboardTileConstants["DASHBOARD_TILE_Y"] = "y";
+    TaskRefDashboardTileConstants["DASHBOARD_TILE_ROWS"] = "rows";
+    TaskRefDashboardTileConstants["DASHBOARD_TILE_COLS"] = "cols";
+    TaskRefDashboardTileConstants["DASHBOARD_TILE_PARENT_ID"] = "parent_dashboard_id";
+    TaskRefDashboardTileConstants["DASHBOARD_TILE_PROCESS_IDENTIFIER"] = "dashboard_tile";
+})(TaskRefDashboardTileConstants || (TaskRefDashboardTileConstants = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay1yZWYtZGFzaGJvYXJkLXRpbGUtY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmV0Z3JpZi1jb21wb25lbnRzLWNvcmUvc3JjL2xpYi9kYXRhLWZpZWxkcy90YXNrLXJlZi1maWVsZC9tb2RlbC90YXNrLXJlZi1kYXNoYm9hcmQtdGlsZS1jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxNQUFNLENBQU4sSUFBWSw2QkFPWDtBQVBELFdBQVksNkJBQTZCO0lBQ3JDLHVEQUFzQixDQUFBO0lBQ3RCLHVEQUFzQixDQUFBO0lBQ3RCLDZEQUE0QixDQUFBO0lBQzVCLDZEQUE0QixDQUFBO0lBQzVCLGlGQUFnRCxDQUFBO0lBQ2hELHFGQUFvRCxDQUFBO0FBQ3hELENBQUMsRUFQVyw2QkFBNkIsS0FBN0IsNkJBQTZCLFFBT3hDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBBIGNvbGxlY3Rpb24gb2YgVGFzayByZWYgZmllbGQgZGFzaGJvYXJkIHRpbGUgY29tcG9uZW50IGNvbnN0YW50cyB1c2VkIHRvIHJlZmVyZW5jZSBlbGVtZW50cyBvZiB0aGUgdW5kZXJseWluZyBwcm9jZXNzZXNcbiAqL1xuZXhwb3J0IGVudW0gVGFza1JlZkRhc2hib2FyZFRpbGVDb25zdGFudHMge1xuICAgIERBU0hCT0FSRF9USUxFX1ggPSAneCcsXG4gICAgREFTSEJPQVJEX1RJTEVfWSA9ICd5JyxcbiAgICBEQVNIQk9BUkRfVElMRV9ST1dTID0gJ3Jvd3MnLFxuICAgIERBU0hCT0FSRF9USUxFX0NPTFMgPSAnY29scycsXG4gICAgREFTSEJPQVJEX1RJTEVfUEFSRU5UX0lEID0gJ3BhcmVudF9kYXNoYm9hcmRfaWQnLFxuICAgIERBU0hCT0FSRF9USUxFX1BST0NFU1NfSURFTlRJRklFUiA9ICdkYXNoYm9hcmRfdGlsZSdcbn1cbiJdfQ==

package/esm2020/lib/data-fields/task-ref-field/model/task-ref-dashboard-tile.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay1yZWYtZGFzaGJvYXJkLXRpbGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZXRncmlmLWNvbXBvbmVudHMtY29yZS9zcmMvbGliL2RhdGEtZmllbGRzL3Rhc2stcmVmLWZpZWxkL21vZGVsL3Rhc2stcmVmLWRhc2hib2FyZC10aWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0RhdGFHcm91cH0gZnJvbSAnLi4vLi4vLi4vcmVzb3VyY2VzL2ludGVyZmFjZS9kYXRhLWdyb3Vwcyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgVGFza1JlZkRhc2hib2FyZFRpbGUge1xuICAgIGRhdGFHcm91cHM6IEFycmF5PERhdGFHcm91cD5cbiAgICB4PzogbnVtYmVyO1xuICAgIHk/OiBudW1iZXI7XG4gICAgcm93cz86IG51bWJlcjtcbiAgICBjb2xzPzogbnVtYmVyO1xuICAgIGlzRW1wdHk/OiBib29sZWFuO1xufVxuIl19

package/esm2020/lib/data-fields/task-ref-field/model/task-ref-field.mjs

@@ -3,5 +3,23 @@ export class TaskRefField extends DataField {
     constructor(stringId, title, initialValue, behavior, placeholder, description, layout, validations, component, parentTaskId) {
         super(stringId, title, initialValue, behavior, placeholder, description, layout, validations, component, parentTaskId);
     }
+    get dashboardTiles() {
+        return this._dashboardTiles;
+    }
+    set dashboardTiles(value) {
+        this._dashboardTiles = value;
+    }
+    get dashboardRows() {
+        return this._dashboardRows;
+    }
+    set dashboardRows(value) {
+        this._dashboardRows = value;
+    }
+    get dashboardCols() {
+        return this._dashboardCols;
+    }
+    set dashboardCols(value) {
+        this._dashboardCols = value;
+    }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay1yZWYtZmllbGQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZXRncmlmLWNvbXBvbmVudHMtY29yZS9zcmMvbGliL2RhdGEtZmllbGRzL3Rhc2stcmVmLWZpZWxkL21vZGVsL3Rhc2stcmVmLWZpZWxkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxTQUFTLEVBQUMsTUFBTSxrQ0FBa0MsQ0FBQztBQU0zRCxNQUFNLE9BQU8sWUFBYSxTQUFRLFNBQXdCO0lBRXRELFlBQVksUUFBZ0IsRUFBRSxLQUFhLEVBQUUsWUFBMkIsRUFBRSxRQUFrQixFQUNoRixXQUFvQixFQUFFLFdBQW9CLEVBQUUsTUFBZSxFQUFFLFdBQStCLEVBQUUsU0FBcUIsRUFDbkgsWUFBcUI7UUFDN0IsS0FBSyxDQUFDLFFBQVEsRUFBRSxLQUFLLEVBQUUsWUFBWSxFQUFFLFFBQVEsRUFBRSxXQUFXLEVBQUUsV0FBVyxFQUFFLE1BQU0sRUFBRSxXQUFXLEVBQUUsU0FBUyxFQUFFLFlBQVksQ0FBQyxDQUFDO0lBQzNILENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7RGF0YUZpZWxkfSBmcm9tICcuLi8uLi9tb2RlbHMvYWJzdHJhY3QtZGF0YS1maWVsZCc7XG5pbXBvcnQge0JlaGF2aW9yfSBmcm9tICcuLi8uLi9tb2RlbHMvYmVoYXZpb3InO1xuaW1wb3J0IHtMYXlvdXR9IGZyb20gJy4uLy4uL21vZGVscy9sYXlvdXQnO1xuaW1wb3J0IHtDb21wb25lbnR9IGZyb20gJy4uLy4uL21vZGVscy9jb21wb25lbnQnO1xuaW1wb3J0IHtWYWxpZGF0aW9ufSBmcm9tICcuLi8uLi9tb2RlbHMvdmFsaWRhdGlvbic7XG5cbmV4cG9ydCBjbGFzcyBUYXNrUmVmRmllbGQgZXh0ZW5kcyBEYXRhRmllbGQ8QXJyYXk8c3RyaW5nPj4ge1xuXG4gICAgY29uc3RydWN0b3Ioc3RyaW5nSWQ6IHN0cmluZywgdGl0bGU6IHN0cmluZywgaW5pdGlhbFZhbHVlOiBBcnJheTxzdHJpbmc+LCBiZWhhdmlvcjogQmVoYXZpb3IsXG4gICAgICAgICAgICAgICAgcGxhY2Vob2xkZXI/OiBzdHJpbmcsIGRlc2NyaXB0aW9uPzogc3RyaW5nLCBsYXlvdXQ/OiBMYXlvdXQsIHZhbGlkYXRpb25zPzogQXJyYXk8VmFsaWRhdGlvbj4sIGNvbXBvbmVudD86IENvbXBvbmVudCxcbiAgICAgICAgICAgICAgICBwYXJlbnRUYXNrSWQ/OiBzdHJpbmcpIHtcbiAgICAgICAgc3VwZXIoc3RyaW5nSWQsIHRpdGxlLCBpbml0aWFsVmFsdWUsIGJlaGF2aW9yLCBwbGFjZWhvbGRlciwgZGVzY3JpcHRpb24sIGxheW91dCwgdmFsaWRhdGlvbnMsIGNvbXBvbmVudCwgcGFyZW50VGFza0lkKTtcbiAgICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/data-fields/task-ref-field/task-ref-dashboard-field/task-ref-dashboard-tile/abstract-task-ref-dashboard-tile.component.mjs

@@ -0,0 +1,140 @@
+import { Component, Inject, Input } from '@angular/core';
+import { TaskRefDashboardConstants } from '../../model/task-ref-dashboard-constants';
+import { TaskRefDashboardTileConstants } from '../../model/task-ref-dashboard-tile-constants';
+import { switchMap } from 'rxjs/operators';
+import { FieldTypeResource } from '../../../../task-content/model/field-type-resource';
+import { NAE_TASK_OPERATIONS } from '../../../../task/models/task-operations-injection-token';
+import { AfterAction } from '../../../../utility/call-chain/after-action';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../resources/engine-endpoint/case-resource.service";
+import * as i2 from "../../../../process/process.service";
+import * as i3 from "../../../../logger/services/logger.service";
+import * as i4 from "../../../../resources/engine-endpoint/task-resource.service";
+import * as i5 from "../../../../utility/call-chain/call-chain.service";
+import * as i6 from "../../../../task-content/services/task-content.service";
+import * as i7 from "../../../../task/services/task-data.service";
+export class AbstractTaskRefDashboardTileComponent {
+    constructor(_caseResourceService, _processService, _logger, _taskResourceService, _callChainService, _parentTaskContentService, _taskDataService, _taskOperations) {
+        this._caseResourceService = _caseResourceService;
+        this._processService = _processService;
+        this._logger = _logger;
+        this._taskResourceService = _taskResourceService;
+        this._callChainService = _callChainService;
+        this._parentTaskContentService = _parentTaskContentService;
+        this._taskDataService = _taskDataService;
+        this._taskOperations = _taskOperations;
+        this.caseCreating = false;
+    }
+    ngOnDestroy() {
+        if (this._sub !== undefined) {
+            this._sub.unsubscribe();
+        }
+    }
+    createNewDashboardTile() {
+        if (this.caseCreating) {
+            return;
+        }
+        this.caseCreating = true;
+        this._sub = this._processService.getNet(TaskRefDashboardTileConstants.DASHBOARD_TILE_PROCESS_IDENTIFIER).pipe(switchMap(net => this._caseResourceService.createCase({
+            netId: net.stringId,
+            title: `tile (${this.tile.x}, ${this.tile.y})`
+        }))).subscribe(outcome => {
+            if (outcome.error) {
+                this._logger.error(`Could not create task ref dashboard tile case`, outcome.error);
+                return;
+            }
+            const _case = outcome.outcome.aCase;
+            // set tile info
+            this.assignSetData(_case.tasks[0].task, {
+                [_case.tasks[0].task]: {
+                    [TaskRefDashboardTileConstants.DASHBOARD_TILE_X]: {
+                        type: FieldTypeResource.NUMBER,
+                        value: this.tile.x
+                    },
+                    [TaskRefDashboardTileConstants.DASHBOARD_TILE_Y]: {
+                        type: FieldTypeResource.NUMBER,
+                        value: this.tile.y
+                    },
+                    [TaskRefDashboardTileConstants.DASHBOARD_TILE_ROWS]: {
+                        type: FieldTypeResource.NUMBER,
+                        value: this.tile.rows
+                    },
+                    [TaskRefDashboardTileConstants.DASHBOARD_TILE_COLS]: {
+                        type: FieldTypeResource.NUMBER,
+                        value: this.tile.cols
+                    },
+                    [TaskRefDashboardTileConstants.DASHBOARD_TILE_PARENT_ID]: {
+                        type: FieldTypeResource.TEXT,
+                        value: this._parentTaskContentService.task.caseId
+                    }
+                }
+            }, this._callChainService.create(success => {
+                if (!success) {
+                    return;
+                }
+                // reference new tile in task ref
+                this._taskResourceService.setData(this._parentTaskContentService.task.stringId, {
+                    [this._parentTaskContentService.task.stringId]: {
+                        [TaskRefDashboardConstants.DASHBOARD_TASK_REF]: {
+                            type: FieldTypeResource.TASK_REF,
+                            value: [...this.taskRef.value, _case.tasks[0].task]
+                        }
+                    }
+                }).subscribe(outcome => {
+                    if (outcome.error) {
+                        this._logger.error(`Could not reference created task ref dashboard tile in the task ref`, outcome.error);
+                        return;
+                    }
+                    this._taskDataService.initializeTaskDataFields(new AfterAction(), true);
+                }, error => {
+                    this._logger.error(`Could not reference created task ref dashboard tile in the task ref`, error);
+                });
+            }));
+        }, error => {
+            this._logger.error(`Could not create task ref dashboard tile case`, error);
+        });
+    }
+    // TODO copy of a similar method found in UserFilterService
+    assignSetData(taskId, data, callChain) {
+        this._taskResourceService.assignTask(taskId).subscribe(assignOutcome => {
+            if (assignOutcome.error) {
+                this._logger.error(`Could not assign task '${taskId}'`, assignOutcome.error);
+                callChain.next(false);
+                return;
+            }
+            this._taskResourceService.setData(taskId, data).subscribe(setDataOutcome => {
+                if (setDataOutcome.error) {
+                    this._logger.error(`Could not set data of task '${taskId}'`, data, setDataOutcome.error);
+                    callChain.next(false);
+                    return;
+                }
+                callChain.next(true);
+            }, error => {
+                this._logger.error(`Could not set data of task '${taskId}'`, data, error);
+                callChain.next(false);
+            });
+        }, error => {
+            this._logger.error(`Could not assign task '${taskId}'`, error);
+            callChain.next(false);
+        });
+    }
+}
+AbstractTaskRefDashboardTileComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AbstractTaskRefDashboardTileComponent, deps: [{ token: i1.CaseResourceService }, { token: i2.ProcessService }, { token: i3.LoggerService }, { token: i4.TaskResourceService }, { token: i5.CallChainService }, { token: i6.TaskContentService }, { token: i7.TaskDataService }, { token: NAE_TASK_OPERATIONS }], target: i0.ɵɵFactoryTarget.Component });
+AbstractTaskRefDashboardTileComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: AbstractTaskRefDashboardTileComponent, selector: "ncc-abstract-task-ref-dashboard-tile", inputs: { tile: "tile", taskRef: "taskRef", fc: "fc" }, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AbstractTaskRefDashboardTileComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ncc-abstract-task-ref-dashboard-tile',
+                    template: '',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.CaseResourceService }, { type: i2.ProcessService }, { type: i3.LoggerService }, { type: i4.TaskResourceService }, { type: i5.CallChainService }, { type: i6.TaskContentService }, { type: i7.TaskDataService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [NAE_TASK_OPERATIONS]
+                }] }]; }, propDecorators: { tile: [{
+                type: Input
+            }], taskRef: [{
+                type: Input
+            }], fc: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-task-ref-dashboard-tile.component.js","sourceRoot":"","sources":["../../../../../../../../projects/netgrif-components-core/src/lib/data-fields/task-ref-field/task-ref-dashboard-field/task-ref-dashboard-tile/abstract-task-ref-dashboard-tile.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, Inject, Input, OnDestroy} from '@angular/core';\nimport {TaskRefDashboardTile} from '../../model/task-ref-dashboard-tile';\nimport {CaseResourceService} from '../../../../resources/engine-endpoint/case-resource.service';\nimport {TaskRefField} from '../../model/task-ref-field';\nimport {TaskRefDashboardConstants} from '../../model/task-ref-dashboard-constants';\nimport {TaskRefDashboardTileConstants} from '../../model/task-ref-dashboard-tile-constants';\nimport {Subject, Subscription} from 'rxjs';\nimport {ProcessService} from '../../../../process/process.service';\nimport {switchMap} from 'rxjs/operators';\nimport {CreateCaseEventOutcome} from '../../../../event/model/event-outcomes/case-outcomes/create-case-event-outcome';\nimport {FormControl} from '@angular/forms';\nimport {LoggerService} from '../../../../logger/services/logger.service';\nimport {TaskSetDataRequestBody} from '../../../../resources/interface/task-set-data-request-body';\nimport {TaskResourceService} from '../../../../resources/engine-endpoint/task-resource.service';\nimport {CallChainService} from '../../../../utility/call-chain/call-chain.service';\nimport {FieldTypeResource} from '../../../../task-content/model/field-type-resource';\nimport {TaskContentService} from '../../../../task-content/services/task-content.service';\nimport {TaskOperations} from '../../../../task/interfaces/task-operations';\nimport {NAE_TASK_OPERATIONS} from '../../../../task/models/task-operations-injection-token';\nimport {TaskDataService} from '../../../../task/services/task-data.service';\nimport {AfterAction} from '../../../../utility/call-chain/after-action';\n\n@Component({\n    selector: 'ncc-abstract-task-ref-dashboard-tile',\n    template: '',\n})\nexport abstract class AbstractTaskRefDashboardTileComponent implements OnDestroy {\n\n    @Input() tile: TaskRefDashboardTile;\n    @Input() taskRef: TaskRefField;\n    @Input() fc: FormControl;\n\n    private _sub: Subscription;\n    private caseCreating = false;\n\n    protected constructor(protected _caseResourceService: CaseResourceService,\n                          protected _processService: ProcessService,\n                          protected _logger: LoggerService,\n                          protected _taskResourceService: TaskResourceService,\n                          protected _callChainService: CallChainService,\n                          protected _parentTaskContentService: TaskContentService,\n                          protected _taskDataService: TaskDataService,\n                          @Inject(NAE_TASK_OPERATIONS) protected _taskOperations: TaskOperations) {\n    }\n\n    ngOnDestroy(): void {\n        if (this._sub !== undefined) {\n            this._sub.unsubscribe();\n        }\n    }\n\n    public createNewDashboardTile(): void {\n        if (this.caseCreating) {\n            return;\n        }\n        this.caseCreating = true;\n        this._sub = this._processService.getNet(TaskRefDashboardTileConstants.DASHBOARD_TILE_PROCESS_IDENTIFIER).pipe(\n            switchMap(net => this._caseResourceService.createCase({\n                netId: net.stringId,\n                title: `tile (${this.tile.x}, ${this.tile.y})`\n            }))\n        ).subscribe(outcome => {\n            if (outcome.error) {\n                this._logger.error(`Could not create task ref dashboard tile case`, outcome.error);\n                return;\n            }\n            const _case = (outcome.outcome as CreateCaseEventOutcome).aCase;\n\n            // set tile info\n            this.assignSetData(_case.tasks[0].task, {\n                [_case.tasks[0].task]: {\n                    [TaskRefDashboardTileConstants.DASHBOARD_TILE_X]: {\n                        type: FieldTypeResource.NUMBER,\n                        value: this.tile.x\n                    },\n                    [TaskRefDashboardTileConstants.DASHBOARD_TILE_Y]: {\n                        type: FieldTypeResource.NUMBER,\n                        value: this.tile.y\n                    },\n                    [TaskRefDashboardTileConstants.DASHBOARD_TILE_ROWS]: {\n                        type: FieldTypeResource.NUMBER,\n                        value: this.tile.rows\n                    },\n                    [TaskRefDashboardTileConstants.DASHBOARD_TILE_COLS]: {\n                        type: FieldTypeResource.NUMBER,\n                        value: this.tile.cols\n                    },\n                    [TaskRefDashboardTileConstants.DASHBOARD_TILE_PARENT_ID]: {\n                        type: FieldTypeResource.TEXT,\n                        value: this._parentTaskContentService.task.caseId\n                    }\n                }\n            }, this._callChainService.create(success => {\n                if (!success) {\n                    return;\n                }\n\n                // reference new tile in task ref\n                this._taskResourceService.setData(this._parentTaskContentService.task.stringId, {\n                    [this._parentTaskContentService.task.stringId]: {\n                        [TaskRefDashboardConstants.DASHBOARD_TASK_REF]: {\n                            type: FieldTypeResource.TASK_REF,\n                            value: [...this.taskRef.value, _case.tasks[0].task]\n                        }\n                    }\n                }).subscribe(outcome => {\n                    if (outcome.error) {\n                        this._logger.error(`Could not reference created task ref dashboard tile in the task ref`, outcome.error);\n                        return;\n                    }\n                    this._taskDataService.initializeTaskDataFields(new AfterAction(), true);\n                }, error => {\n                    this._logger.error(`Could not reference created task ref dashboard tile in the task ref`, error);\n                });\n            }));\n        }, error => {\n            this._logger.error(`Could not create task ref dashboard tile case`, error);\n        });\n    }\n\n    // TODO copy of a similar method found in UserFilterService\n    protected assignSetData(taskId: string, data: TaskSetDataRequestBody, callChain: Subject<boolean>): void {\n        this._taskResourceService.assignTask(taskId).subscribe(assignOutcome => {\n            if (assignOutcome.error) {\n                this._logger.error(`Could not assign task '${taskId}'`, assignOutcome.error);\n                callChain.next(false);\n                return;\n            }\n\n            this._taskResourceService.setData(taskId, data).subscribe(setDataOutcome => {\n                if (setDataOutcome.error) {\n                    this._logger.error(`Could not set data of task '${taskId}'`, data, setDataOutcome.error);\n                    callChain.next(false);\n                    return;\n                }\n\n                callChain.next(true);\n\n            }, error => {\n                this._logger.error(`Could not set data of task '${taskId}'`, data, error);\n                callChain.next(false);\n            });\n        }, error => {\n            this._logger.error(`Could not assign task '${taskId}'`, error);\n            callChain.next(false);\n        });\n    }\n}\n"]}

package/esm2020/lib/data-fields/text-field/abstract-dashboard-text-field.component.mjs

@@ -0,0 +1,42 @@
+import { Component, Input } from '@angular/core';
+import { AbstractTextErrorsComponent } from './abstract-text-errors.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class AbstractDashboardTextFieldComponent extends AbstractTextErrorsComponent {
+    constructor(translate) {
+        super(translate);
+        this.initialized = false;
+    }
+    ngOnInit() {
+        if (this.formControlRef.value !== undefined) {
+            this.card = this.createCard(this.formControlRef.value);
+            this.initialized = true;
+        }
+        this._sub = this.formControlRef.valueChanges.subscribe(newVal => {
+            this.card = this.createCard(newVal);
+            this.initialized = true;
+        });
+    }
+    ngOnDestroy() {
+        this._sub.unsubscribe();
+    }
+    getErrorMessage() {
+        return this.buildErrorMessage(this.textField, this.formControlRef);
+    }
+}
+AbstractDashboardTextFieldComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AbstractDashboardTextFieldComponent, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Component });
+AbstractDashboardTextFieldComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: AbstractDashboardTextFieldComponent, selector: "ncc-abstract-dashboard-text-field", inputs: { textField: "textField", formControlRef: "formControlRef", showLargeLayout: "showLargeLayout" }, usesInheritance: true, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AbstractDashboardTextFieldComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ncc-abstract-dashboard-text-field',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }]; }, propDecorators: { textField: [{
+                type: Input
+            }], formControlRef: [{
+                type: Input
+            }], showLargeLayout: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/data-fields/text-field/dashboard-bar-chart-text-field/abstract-dashboard-bar-chart-text-field.component.mjs

@@ -0,0 +1,33 @@
+import { Component } from '@angular/core';
+import { DashboardCardTypes } from '../../../dashboard/cards/model/dashboard-card-types';
+import { FilterType } from '../../../filter/models/filter-type';
+import { AbstractDashboardTextFieldComponent } from '../abstract-dashboard-text-field.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class AbstractDashboardBarChartTextFieldComponent extends AbstractDashboardTextFieldComponent {
+    constructor(translate) {
+        super(translate);
+    }
+    createCard(textFieldValue) {
+        const parsedValue = JSON.parse(textFieldValue);
+        return {
+            type: DashboardCardTypes.BAR,
+            query: parsedValue.query,
+            title: parsedValue.title,
+            xAxisLabel: parsedValue.xAxisLabel,
+            yAxisLabel: parsedValue.yAxisLabel,
+            resourceType: !!parsedValue.resourceType ? parsedValue.resourceType : FilterType.CASE,
+            layout: { x: 0, y: 0, rows: 1, cols: 1 }
+        };
+    }
+}
+AbstractDashboardBarChartTextFieldComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AbstractDashboardBarChartTextFieldComponent, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Component });
+AbstractDashboardBarChartTextFieldComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: AbstractDashboardBarChartTextFieldComponent, selector: "ncc-abstract-dashboard-bar-chart-text-field", usesInheritance: true, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AbstractDashboardBarChartTextFieldComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ncc-abstract-dashboard-bar-chart-text-field',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/data-fields/text-field/dashboard-iframe-text-field/abstract-dashboard-iframe-text-field.component.mjs

@@ -0,0 +1,27 @@
+import { Component } from '@angular/core';
+import { DashboardCardTypes } from '../../../dashboard/cards/model/dashboard-card-types';
+import { AbstractDashboardTextFieldComponent } from '../abstract-dashboard-text-field.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class AbstractDashboardIframeTextFieldComponent extends AbstractDashboardTextFieldComponent {
+    constructor(translate) {
+        super(translate);
+    }
+    createCard(textFieldValue) {
+        return {
+            url: textFieldValue,
+            type: DashboardCardTypes.IFRAME,
+            layout: { x: 0, y: 0, rows: 1, cols: 1 }
+        };
+    }
+}
+AbstractDashboardIframeTextFieldComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AbstractDashboardIframeTextFieldComponent, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Component });
+AbstractDashboardIframeTextFieldComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: AbstractDashboardIframeTextFieldComponent, selector: "ncc-abstract-dashboard-iframe-text-field", usesInheritance: true, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AbstractDashboardIframeTextFieldComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ncc-abstract-dashboard-iframe-text-field',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/data-fields/text-field/dashboard-line-chart-text-field/abstract-dashboard-line-chart-text-field.component.mjs

@@ -0,0 +1,33 @@
+import { Component } from '@angular/core';
+import { DashboardCardTypes } from '../../../dashboard/cards/model/dashboard-card-types';
+import { FilterType } from '../../../filter/models/filter-type';
+import { AbstractDashboardTextFieldComponent } from '../abstract-dashboard-text-field.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class AbstractDashboardLineChartTextFieldComponent extends AbstractDashboardTextFieldComponent {
+    constructor(translate) {
+        super(translate);
+    }
+    createCard(textFieldValue) {
+        const parsedValue = JSON.parse(textFieldValue);
+        return {
+            type: DashboardCardTypes.LINE,
+            query: parsedValue.query,
+            title: parsedValue.title,
+            xAxisLabel: parsedValue.xAxisLabel,
+            yAxisLabel: parsedValue.yAxisLabel,
+            resourceType: !!parsedValue.resourceType ? parsedValue.resourceType : FilterType.CASE,
+            layout: { x: 0, y: 0, rows: 1, cols: 1 }
+        };
+    }
+}
+AbstractDashboardLineChartTextFieldComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AbstractDashboardLineChartTextFieldComponent, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Component });
+AbstractDashboardLineChartTextFieldComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: AbstractDashboardLineChartTextFieldComponent, selector: "ncc-abstract-dashboard-line-chart-text-field", usesInheritance: true, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: AbstractDashboardLineChartTextFieldComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ncc-abstract-dashboard-line-chart-text-field',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }]; } });
+//# sourceMappingURL=data:application/json;base64,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