@netgrif/components-core 6.0.1

package/esm5/lib/view/workflow-view/abstract-workflow-view.component.js

@@ -0,0 +1,74 @@
+import { __extends } from "tslib";
+import { Input, ViewChild } from '@angular/core';
+import { ViewWithHeaders } from '../abstract/view-with-headers';
+import { HeaderType } from '../../header/models/header-type';
+import { Net } from '../../process/net';
+import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
+var AbstractWorkflowViewComponent = /** @class */ (function (_super) {
+    __extends(AbstractWorkflowViewComponent, _super);
+    function AbstractWorkflowViewComponent(_sideMenuService, _workflowViewService, _log, _processService) {
+        var _this = _super.call(this, _workflowViewService) || this;
+        _this._sideMenuService = _sideMenuService;
+        _this._workflowViewService = _workflowViewService;
+        _this._log = _log;
+        _this._processService = _processService;
+        _this.showDeleteMenu = false;
+        _this.headerType = HeaderType.WORKFLOW;
+        _this.workflows$ = _this._workflowViewService.workflows$;
+        _this.loading$ = _this._workflowViewService.loading$;
+        _this.footerSize = 0;
+        return _this;
+    }
+    AbstractWorkflowViewComponent.prototype.ngAfterViewInit = function () {
+        this.initializeHeader(this.workflowHeader);
+    };
+    AbstractWorkflowViewComponent.prototype.importSidemenuNet = function (component) {
+        var _this = this;
+        this._sideMenuService.open(component).onClose.subscribe(function (event) {
+            var _a, _b;
+            if (((_a = event.data) === null || _a === void 0 ? void 0 : _a.net) !== undefined) {
+                _this._workflowViewService.reload();
+                if ((_b = event.data) === null || _b === void 0 ? void 0 : _b.net) {
+                    _this._processService.updateNet(new Net(event.data.net));
+                }
+            }
+            else {
+                _this._log.debug('');
+            }
+        });
+    };
+    AbstractWorkflowViewComponent.prototype.trackBy = function (i) {
+        return i;
+    };
+    AbstractWorkflowViewComponent.prototype.loadNextPage = function () {
+        if (!this.viewport) {
+            return;
+        }
+        this._workflowViewService.nextPage(this.viewport.getRenderedRange(), this.viewport.getDataLength());
+    };
+    AbstractWorkflowViewComponent.prototype.calculateListHeight = function (preciseHeight) {
+        if (!this.viewport) {
+            return;
+        }
+        var element = this.viewport.getElementRef().nativeElement;
+        if (preciseHeight !== null && preciseHeight !== undefined) {
+            element.style.height = preciseHeight + 'px';
+        }
+        else {
+            var viewportHeight = window.innerHeight - element.offsetTop - this.footerSize;
+            if (element.style.height !== viewportHeight + 'px') {
+                this._log.info('Virtual scroll height change to: ' + viewportHeight);
+                element.style.height = viewportHeight + 'px';
+            }
+        }
+    };
+    AbstractWorkflowViewComponent.propDecorators = {
+        footerSize: [{ type: Input }],
+        showDeleteMenu: [{ type: Input }],
+        workflowHeader: [{ type: ViewChild, args: ['header',] }],
+        viewport: [{ type: ViewChild, args: [CdkVirtualScrollViewport,] }]
+    };
+    return AbstractWorkflowViewComponent;
+}(ViewWithHeaders));
+export { AbstractWorkflowViewComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/view/workflow-view/models/injection-token-workflow-service.js

@@ -0,0 +1,10 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * An InjectionToken that can be used to set the process filter in workflow view
+ */
+export var NAE_WORKFLOW_SERVICE_FILTER = new InjectionToken('NaeWorkflowServiceFilter');
+/**
+ * An InjectionToken that can be used to enable/disable process delete confirmation dialog
+ */
+export var NAE_WORKFLOW_SERVICE_CONFIRM_DELETE = new InjectionToken('NaeWorkflowServiceConfirmDelete');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5qZWN0aW9uLXRva2VuLXdvcmtmbG93LXNlcnZpY2UuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvdmlldy93b3JrZmxvdy12aWV3L21vZGVscy9pbmplY3Rpb24tdG9rZW4td29ya2Zsb3ctc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsY0FBYyxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBRzdDOztHQUVHO0FBQ0gsTUFBTSxDQUFDLElBQU0sMkJBQTJCLEdBQUcsSUFBSSxjQUFjLENBQXNCLDBCQUEwQixDQUFDLENBQUM7QUFFL0c7O0dBRUc7QUFDSCxNQUFNLENBQUMsSUFBTSxtQ0FBbUMsR0FBRyxJQUFJLGNBQWMsQ0FBVSxpQ0FBaUMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbmplY3Rpb25Ub2tlbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge1BldHJpTmV0UmVxdWVzdEJvZHl9IGZyb20gJy4uLy4uLy4uL3Jlc291cmNlcy9pbnRlcmZhY2UvcGV0cmktbmV0LXJlcXVlc3QtYm9keSc7XG5cbi8qKlxuICogQW4gSW5qZWN0aW9uVG9rZW4gdGhhdCBjYW4gYmUgdXNlZCB0byBzZXQgdGhlIHByb2Nlc3MgZmlsdGVyIGluIHdvcmtmbG93IHZpZXdcbiAqL1xuZXhwb3J0IGNvbnN0IE5BRV9XT1JLRkxPV19TRVJWSUNFX0ZJTFRFUiA9IG5ldyBJbmplY3Rpb25Ub2tlbjxQZXRyaU5ldFJlcXVlc3RCb2R5PignTmFlV29ya2Zsb3dTZXJ2aWNlRmlsdGVyJyk7XG5cbi8qKlxuICogQW4gSW5qZWN0aW9uVG9rZW4gdGhhdCBjYW4gYmUgdXNlZCB0byBlbmFibGUvZGlzYWJsZSBwcm9jZXNzIGRlbGV0ZSBjb25maXJtYXRpb24gZGlhbG9nXG4gKi9cbmV4cG9ydCBjb25zdCBOQUVfV09SS0ZMT1dfU0VSVklDRV9DT05GSVJNX0RFTEVURSA9IG5ldyBJbmplY3Rpb25Ub2tlbjxib29sZWFuPignTmFlV29ya2Zsb3dTZXJ2aWNlQ29uZmlybURlbGV0ZScpO1xuIl19

package/esm5/lib/view/workflow-view/workflow-view.service.js

@@ -0,0 +1,232 @@
+import { __assign, __extends } from "tslib";
+import { Inject, Injectable, Optional } from '@angular/core';
+import { SortableView } from '../abstract/sortable-view';
+import { PetriNetResourceService } from '../../resources/engine-endpoint/petri-net-resource.service';
+import { BehaviorSubject, of } from 'rxjs';
+import { Net } from '../../process/net';
+import { catchError, concatMap, map, mergeMap, scan, tap } from 'rxjs/operators';
+import { LoggerService } from '../../logger/services/logger.service';
+import { HttpParams } from '@angular/common/http';
+import { LoadingEmitter } from '../../utility/loading-emitter';
+import { hasContent } from '../../utility/pagination/page-has-content';
+import { NAE_WORKFLOW_SERVICE_CONFIRM_DELETE, NAE_WORKFLOW_SERVICE_FILTER } from './models/injection-token-workflow-service';
+import { DialogService } from '../../dialog/services/dialog.service';
+import { SnackBarService } from '../../snack-bar/services/snack-bar.service';
+import { TranslateService } from '@ngx-translate/core';
+import { arrayToObservable } from '../../utility/array-to-observable';
+import { SearchIndexResolverService } from '../../search/search-keyword-resolver-service/search-index-resolver.service';
+var WorkflowViewService = /** @class */ (function (_super) {
+    __extends(WorkflowViewService, _super);
+    function WorkflowViewService(_petriNetResource, _log, _dialogService, _snackBarService, _translate, resolver, injectedBaseFilter, confirmDelete) {
+        var _this = _super.call(this, resolver) || this;
+        _this._petriNetResource = _petriNetResource;
+        _this._log = _log;
+        _this._dialogService = _dialogService;
+        _this._snackBarService = _snackBarService;
+        _this._translate = _translate;
+        _this._loading$ = new LoadingEmitter();
+        _this._clear = false;
+        _this._endOfData = false;
+        _this._pagination = {
+            size: 25,
+            totalElements: undefined,
+            totalPages: undefined,
+            number: -1
+        };
+        _this._nextPage$ = new BehaviorSubject(Object.assign({}, _this._pagination, { number: 0 }));
+        _this._baseFilter = injectedBaseFilter !== null ? injectedBaseFilter : {};
+        _this._showDeleteConfirmationDialog = confirmDelete === null || confirmDelete;
+        var workflowsMap = _this._nextPage$.pipe(mergeMap(function (p) { return _this.loadPage(p); }), map(function (petriNets) {
+            if (_this._clear) {
+                // we set an empty value to the virtual scroll and then replace it by the real value forcing it to redraw its content
+                var results = [{ content: [], stopLoading: false }, { content: petriNets, stopLoading: true }];
+                return arrayToObservable(results);
+            }
+            else {
+                return of({ content: petriNets, stopLoading: true });
+            }
+        }), concatMap(function (o) { return o; }), map(function (o) {
+            if (o.stopLoading) {
+                _this._loading$.off();
+            }
+            return o.content;
+        }), map(function (petriNets) {
+            return petriNets.reduce(function (acc, cur) {
+                var _a;
+                return __assign(__assign({}, acc), (_a = {}, _a[cur.stringId] = cur, _a));
+            }, {});
+        }), scan(function (acc, petriNetsMap) {
+            if (_this._clear) {
+                _this._clear = false;
+                return __assign({}, petriNetsMap);
+            }
+            return __assign(__assign({}, acc), petriNetsMap);
+        }, {}));
+        _this._workflows$ = workflowsMap.pipe(map(function (v) { return Object.values(v); }));
+        return _this;
+    }
+    WorkflowViewService.prototype.ngOnDestroy = function () {
+        _super.prototype.ngOnDestroy.call(this);
+        this._loading$.complete();
+        this._nextPage$.complete();
+    };
+    Object.defineProperty(WorkflowViewService.prototype, "loading", {
+        get: function () {
+            return this._loading$.isActive;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WorkflowViewService.prototype, "loading$", {
+        get: function () {
+            return this._loading$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(WorkflowViewService.prototype, "workflows$", {
+        get: function () {
+            return this._workflows$;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    WorkflowViewService.prototype.loadPage = function (pageRequest) {
+        var _this = this;
+        if (pageRequest.number < 0) {
+            return of([]);
+        }
+        var params = new HttpParams();
+        params = this.addSortParams(params);
+        params = this.addPageParams(params, pageRequest);
+        this._loading$.on();
+        return this._petriNetResource.searchPetriNets(this._baseFilter, params).pipe(catchError(function (err) {
+            _this._log.error('Loading Petri nets has failed!', err);
+            return of({ content: [], pagination: __assign({}, _this._pagination) });
+        }), tap(function (res) {
+            Object.assign(_this._pagination, res.pagination);
+        }), tap(function (res) {
+            _this._endOfData = !hasContent(res)
+                || res.pagination.number === res.pagination.totalPages - 1;
+        }), map(function (netsPage) {
+            if (hasContent(netsPage)) {
+                var array_1 = [];
+                netsPage.content.forEach(function (net) {
+                    array_1.push(new Net(net));
+                });
+                return array_1;
+            }
+            return [];
+        }));
+    };
+    WorkflowViewService.prototype.nextPage = function (renderedRange, totalLoaded, pagination) {
+        if (this._endOfData) {
+            return;
+        }
+        if (renderedRange.end === totalLoaded) {
+            var p = pagination;
+            if (p === undefined) {
+                p = Object.assign({}, this._pagination);
+                p.number += 1;
+            }
+            this._nextPage$.next(p);
+        }
+    };
+    WorkflowViewService.prototype.reload = function () {
+        if (!this._workflows$ || !this._pagination) {
+            return;
+        }
+        this._endOfData = false;
+        this._clear = true;
+        var p = Object.assign({}, this._pagination);
+        p.number = 0;
+        var range = {
+            start: -1,
+            end: 0
+        };
+        this.nextPage(range, 0, p);
+    };
+    /**
+     * Opens a dialog (if configured) and then asks the service to delete the selected workflow.
+     * @param workflow the workflow that should be deleted
+     */
+    WorkflowViewService.prototype.deleteWorkflow = function (workflow) {
+        var _this = this;
+        if (this._showDeleteConfirmationDialog) {
+            var confirmationText_1 = this._translate.instant('workflow.delete').toUpperCase();
+            this._dialogService.openPromptDialog(this._translate.instant('workflow.dialog.header', { name: workflow.title, version: workflow.version }), this._translate.instant('workflow.dialog.content'), this._translate.instant('workflow.dialog.typeToConfirm', { delete: confirmationText_1 }))
+                .afterClosed().subscribe(function (result) {
+                if (result !== undefined && result.prompt === confirmationText_1) {
+                    _this._deleteWorkflow(workflow);
+                }
+                else {
+                    _this._snackBarService.openGenericSnackBar(_this._translate.instant('workflow.snackBar.deleteCanceled'), 'info');
+                }
+            });
+        }
+        else {
+            this._deleteWorkflow(workflow);
+        }
+    };
+    /**
+     * Sends the workflow delete to backend and processes the result.
+     * @param workflow the workflow that should be deleted
+     */
+    WorkflowViewService.prototype._deleteWorkflow = function (workflow) {
+        var _this = this;
+        this._petriNetResource.deletePetriNet(workflow.stringId).subscribe(function (response) {
+            _this._snackBarService.openSuccessSnackBar(_this._translate.instant('workflow.snackBar.deleteSuccess'));
+            _this._log.info('Process delete success. Server response: ' + response.success);
+            _this.reload();
+        }, function (error) {
+            _this._snackBarService.openErrorSnackBar(_this._translate.instant('workflow.snackBar.deleteError'));
+            _this._log.error('Process delete failed. Server response: ' + error);
+        });
+    };
+    WorkflowViewService.prototype.getMetaFieldSortId = function () {
+        return this._lastHeaderSearchState.fieldIdentifier;
+    };
+    WorkflowViewService.prototype.getDefaultSortParam = function () {
+        // TODO 7.4.2020 - workflow sorting and searching
+        return '';
+    };
+    WorkflowViewService.prototype.addSortParams = function (params) {
+        if (this._lastHeaderSearchState.sortDirection !== '') {
+            return params.set('sort', this.getSortId() + "," + this._lastHeaderSearchState.sortDirection);
+        }
+        else {
+            return params.set('sort', this.getDefaultSortParam());
+        }
+    };
+    WorkflowViewService.prototype.addPageParams = function (params, pagination) {
+        params = params.set('size', pagination.size + '');
+        params = params.set('page', pagination.number + '');
+        return params;
+    };
+    WorkflowViewService.ctorParameters = function () { return [
+        { type: PetriNetResourceService },
+        { type: LoggerService },
+        { type: DialogService },
+        { type: SnackBarService },
+        { type: TranslateService },
+        { type: SearchIndexResolverService },
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_WORKFLOW_SERVICE_FILTER,] }] },
+        { type: Boolean, decorators: [{ type: Optional }, { type: Inject, args: [NAE_WORKFLOW_SERVICE_CONFIRM_DELETE,] }] }
+    ]; };
+    WorkflowViewService.decorators = [
+        { type: Injectable }
+    ];
+    WorkflowViewService.ctorParameters = function () { return [
+        { type: PetriNetResourceService },
+        { type: LoggerService },
+        { type: DialogService },
+        { type: SnackBarService },
+        { type: TranslateService },
+        { type: SearchIndexResolverService },
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [NAE_WORKFLOW_SERVICE_FILTER,] }] },
+        { type: Boolean, decorators: [{ type: Optional }, { type: Inject, args: [NAE_WORKFLOW_SERVICE_CONFIRM_DELETE,] }] }
+    ]; };
+    return WorkflowViewService;
+}(SortableView));
+export { WorkflowViewService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workflow-view.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/view/workflow-view/workflow-view.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable, OnDestroy, Optional} from '@angular/core';\nimport {SortableView} from '../abstract/sortable-view';\nimport {PetriNetResourceService} from '../../resources/engine-endpoint/petri-net-resource.service';\nimport {BehaviorSubject, Observable, of} from 'rxjs';\nimport {Net} from '../../process/net';\nimport {catchError, concatMap, map, mergeMap, scan, tap} from 'rxjs/operators';\nimport {LoggerService} from '../../logger/services/logger.service';\nimport {PetriNetReference} from '../../resources/interface/petri-net-reference';\nimport {HttpParams} from '@angular/common/http';\nimport {Pagination} from '../../resources/interface/pagination';\nimport {LoadingEmitter} from '../../utility/loading-emitter';\nimport {Page} from '../../resources/interface/page';\nimport {ListRange} from '@angular/cdk/collections';\nimport {hasContent} from '../../utility/pagination/page-has-content';\nimport {PetriNetRequestBody} from '../../resources/interface/petri-net-request-body';\nimport {NAE_WORKFLOW_SERVICE_CONFIRM_DELETE, NAE_WORKFLOW_SERVICE_FILTER} from './models/injection-token-workflow-service';\nimport {DialogService} from '../../dialog/services/dialog.service';\nimport {SnackBarService} from '../../snack-bar/services/snack-bar.service';\nimport {TranslateService} from '@ngx-translate/core';\nimport {arrayToObservable} from '../../utility/array-to-observable';\nimport {SearchIndexResolverService} from '../../search/search-keyword-resolver-service/search-index-resolver.service';\n\n\n@Injectable()\nexport class WorkflowViewService extends SortableView implements OnDestroy {\n\n    // TODO 19.10.2020 - Add support for requests with context (filter), same as Case- and TaskViewServices\n    protected _loading$: LoadingEmitter;\n    protected _workflows$: Observable<Array<Net>>;\n    protected _clear: boolean;\n    protected _nextPage$: BehaviorSubject<Pagination>;\n    protected _endOfData: boolean;\n    protected _pagination: Pagination;\n    protected _baseFilter: PetriNetRequestBody;\n    protected _showDeleteConfirmationDialog: boolean;\n\n    constructor(protected _petriNetResource: PetriNetResourceService,\n                protected _log: LoggerService,\n                protected _dialogService: DialogService,\n                protected _snackBarService: SnackBarService,\n                protected _translate: TranslateService,\n                resolver: SearchIndexResolverService,\n                @Optional() @Inject(NAE_WORKFLOW_SERVICE_FILTER) injectedBaseFilter: PetriNetRequestBody,\n                @Optional() @Inject(NAE_WORKFLOW_SERVICE_CONFIRM_DELETE) confirmDelete: boolean) {\n        super(resolver);\n        this._loading$ = new LoadingEmitter();\n        this._clear = false;\n        this._endOfData = false;\n        this._pagination = {\n            size: 25,\n            totalElements: undefined,\n            totalPages: undefined,\n            number: -1\n        };\n        this._nextPage$ = new BehaviorSubject<Pagination>(\n            Object.assign({}, this._pagination, {number: 0})\n        );\n\n        this._baseFilter = injectedBaseFilter !== null ? injectedBaseFilter : {};\n        this._showDeleteConfirmationDialog = confirmDelete === null || confirmDelete;\n\n        const workflowsMap = this._nextPage$.pipe(\n            mergeMap(p => this.loadPage(p)),\n            map(petriNets => {\n                if (this._clear) {\n                    // we set an empty value to the virtual scroll and then replace it by the real value forcing it to redraw its content\n                    const results = [{content: [], stopLoading: false}, {content: petriNets, stopLoading: true}];\n                    return arrayToObservable(results);\n                } else {\n                    return of({content: petriNets, stopLoading: true});\n                }\n            }),\n            concatMap(o => o),\n            map(o => {\n                if (o.stopLoading) {\n                    this._loading$.off();\n                }\n                return o.content;\n            }),\n            map(petriNets => {\n                return petriNets.reduce((acc, cur) => {\n                    return {...acc, [cur.stringId]: cur};\n                }, {});\n            }),\n            scan((acc, petriNetsMap) => {\n                if (this._clear) {\n                    this._clear = false;\n                    return {...petriNetsMap};\n                }\n                return {...acc, ...petriNetsMap};\n            }, {})\n        );\n\n        this._workflows$ = workflowsMap.pipe(\n            map(v => Object.values(v))\n        );\n    }\n\n    ngOnDestroy(): void {\n        super.ngOnDestroy();\n        this._loading$.complete();\n        this._nextPage$.complete();\n    }\n\n    public get loading(): boolean {\n        return this._loading$.isActive;\n    }\n\n    public get loading$(): Observable<boolean> {\n        return this._loading$.asObservable();\n    }\n\n    public get workflows$(): Observable<Array<Net>> {\n        return this._workflows$;\n    }\n\n    public loadPage(pageRequest: Pagination): Observable<Array<Net>> {\n        if (pageRequest.number < 0) {\n            return of([]);\n        }\n        let params: HttpParams = new HttpParams();\n        params = this.addSortParams(params);\n        params = this.addPageParams(params, pageRequest);\n        this._loading$.on();\n\n        return this._petriNetResource.searchPetriNets(this._baseFilter, params).pipe(\n            catchError(err => {\n                this._log.error('Loading Petri nets has failed!', err);\n                return of({content: [], pagination: {...this._pagination}});\n            }),\n            tap(res => {\n                Object.assign(this._pagination, res.pagination);\n            }),\n            tap(res => {\n                this._endOfData = !hasContent(res)\n                    || res.pagination.number === res.pagination.totalPages - 1;\n            }),\n            map((netsPage: Page<PetriNetReference>) => {\n                if (hasContent(netsPage)) {\n                    const array: Array<Net> = [];\n                    netsPage.content.forEach(net => {\n                        array.push(new Net(net));\n                    });\n                    return array;\n                }\n                return [];\n            })\n        );\n    }\n\n    public nextPage(renderedRange: ListRange, totalLoaded: number, pagination?: Pagination) {\n        if (this._endOfData) {\n            return;\n        }\n\n        if (renderedRange.end === totalLoaded) {\n            let p = pagination;\n            if (p === undefined) {\n                p = Object.assign({}, this._pagination);\n                p.number += 1;\n            }\n            this._nextPage$.next(p);\n        }\n    }\n\n    public reload(): void {\n        if (!this._workflows$ || !this._pagination) {\n            return;\n        }\n\n        this._endOfData = false;\n        this._clear = true;\n        const p = Object.assign({}, this._pagination);\n        p.number = 0;\n        const range = {\n            start: -1,\n            end: 0\n        };\n        this.nextPage(range, 0, p);\n    }\n\n    /**\n     * Opens a dialog (if configured) and then asks the service to delete the selected workflow.\n     * @param workflow the workflow that should be deleted\n     */\n    public deleteWorkflow(workflow: Net): void {\n        if (this._showDeleteConfirmationDialog) {\n            const confirmationText = this._translate.instant('workflow.delete').toUpperCase();\n\n            this._dialogService.openPromptDialog(\n                this._translate.instant('workflow.dialog.header', {name: workflow.title, version: workflow.version}),\n                this._translate.instant('workflow.dialog.content'),\n                this._translate.instant('workflow.dialog.typeToConfirm', {delete: confirmationText}))\n                .afterClosed().subscribe(result => {\n                if (result !== undefined && result.prompt === confirmationText) {\n                    this._deleteWorkflow(workflow);\n                } else {\n                    this._snackBarService.openGenericSnackBar(this._translate.instant('workflow.snackBar.deleteCanceled'), 'info');\n                }\n            });\n        } else {\n            this._deleteWorkflow(workflow);\n        }\n    }\n\n    /**\n     * Sends the workflow delete to backend and processes the result.\n     * @param workflow the workflow that should be deleted\n     */\n    protected _deleteWorkflow(workflow: Net): void {\n        this._petriNetResource.deletePetriNet(workflow.stringId).subscribe(response => {\n                this._snackBarService.openSuccessSnackBar(this._translate.instant('workflow.snackBar.deleteSuccess'));\n                this._log.info('Process delete success. Server response: ' + response.success);\n                this.reload();\n            },\n            error => {\n                this._snackBarService.openErrorSnackBar(this._translate.instant('workflow.snackBar.deleteError'));\n                this._log.error('Process delete failed. Server response: ' + error);\n            }\n        );\n    }\n\n    protected getMetaFieldSortId(): string {\n        return this._lastHeaderSearchState.fieldIdentifier;\n    }\n\n    protected getDefaultSortParam(): string {\n        // TODO 7.4.2020 - workflow sorting and searching\n        return '';\n    }\n\n    protected addSortParams(params: HttpParams): HttpParams {\n        if (this._lastHeaderSearchState.sortDirection !== '') {\n            return params.set('sort', `${this.getSortId()},${this._lastHeaderSearchState.sortDirection}`);\n        } else {\n            return params.set('sort', this.getDefaultSortParam());\n        }\n    }\n\n    protected addPageParams(params: HttpParams, pagination: Pagination): HttpParams {\n        params = params.set('size', pagination.size + '');\n        params = params.set('page', pagination.number + '');\n        return params;\n    }\n\n}\n"]}

package/esm5/netgrif-components-core.js

@@ -0,0 +1,20 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+export { AnonymousAuthenticationInterceptor as ɵj } from './lib/authentication/services/anonymous-authentication-interceptor';
+export { AuthenticationInterceptor as ɵi } from './lib/authentication/services/authentication-interceptor';
+export { AbstractDataFieldComponent as ɵb } from './lib/data-fields/models/abstract-data-field-component';
+export { AbstractTimeInstanceFieldComponent as ɵc } from './lib/data-fields/time-instance-abstract-field/abstract-time-instance-field.component';
+export { AbstractTimeInstanceField as ɵe } from './lib/data-fields/time-instance-abstract-field/models/abstract-time-instance-field';
+export { AlertDialogModule as ɵq } from './lib/dialog/components/alert-dialog/alert-dialog.module';
+export { ConfirmDialogModule as ɵr } from './lib/dialog/components/confirm-dialog/confirm-dialog.module';
+export { PromptDialogModule as ɵs } from './lib/dialog/components/prompt-dialog/prompt-dialog.module';
+export { AbstractDialog as ɵn } from './lib/dialog/models/abstract-dialog';
+export { AbstractHeaderModeComponent as ɵt } from './lib/header/header-modes/abstract-header-mode.component';
+export { AbstractNavigationResizableDrawerComponent as ɵk } from './lib/navigation/navigation-drawer/abstract-navigation-resizable-drawer.component';
+export { PanelWithHeaderBinding as ɵm } from './lib/panel/abstract/panel-with-header-binding';
+export { PanelWithImmediateData as ɵl } from './lib/panel/abstract/panel-with-immediate-data';
+export { DataGroupLayoutType as ɵu } from './lib/resources/interface/data-group-layout';
+export { TranslateInterceptor as ɵa } from './lib/translate/translate-interceptor';
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/public-api.js

@@ -0,0 +1,45 @@
+/*
+ * Public API Surface of netgrif-components-core
+ */
+export * from './commons/schema';
+/* MODULES */
+export * from './lib/material/material.module';
+export * from './lib/covalent/covalent.module';
+export * from './lib/currency/currency.module';
+/* APIS */
+export * from './lib/logger/public-api';
+export * from './lib/data-fields/public-api';
+export * from './lib/authentication/public-api';
+export * from './lib/user/public-api';
+export * from './lib/panel/public-api';
+export * from './lib/configuration/public-api';
+export * from './lib/forms/public-api';
+export * from './lib/toolbar/public-api';
+export * from './lib/tabs/public-api';
+export * from './lib/side-menu/public-api';
+export * from './lib/dialog/public-api';
+export * from './lib/header/public-api';
+export * from './lib/resources/public-api';
+export * from './lib/navigation/public-api';
+export * from './lib/view/public-api';
+export * from './lib/process/public-api';
+export * from './lib/dashboard/public-api';
+export * from './lib/filter/public-api';
+export * from './lib/snack-bar/public-api';
+export * from './lib/search/public-api';
+export * from './lib/translate/public-api';
+export * from './lib/admin/public-api';
+export * from './lib/utility/public-api';
+export * from './lib/routing/public-api';
+export * from './lib/task-content/public-api';
+export * from './lib/task/public-api';
+export * from './lib/moment/public-api';
+export * from './lib/authorization/public-api';
+export * from './lib/public/public-api';
+export * from './lib/groups/public-api';
+export * from './lib/legal/public-api';
+export * from './lib/allowed-nets/public-api';
+export * from './lib/event-queue/public-api';
+export * from './lib/changed-fields/public-api';
+export * from './lib/event/public-api';
+//# sourceMappingURL=data:application/json;base64,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