@netgrif/components-core 6.0.1

package/esm5/lib/process/process.service.js

@@ -0,0 +1,325 @@
+import { __assign } from "tslib";
+import { Injectable } from '@angular/core';
+import { forkJoin, of, ReplaySubject, Subject } from 'rxjs';
+import { Net } from './net';
+import { PetriNetResourceService } from '../resources/engine-endpoint/petri-net-resource.service';
+import { LoggerService } from '../logger/services/logger.service';
+import { catchError, map, switchMap, tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../resources/engine-endpoint/petri-net-resource.service";
+import * as i2 from "../logger/services/logger.service";
+/**
+ * Process service is responsible for loading and caching processes needed for any functionality of an app.
+ */
+var ProcessService = /** @class */ (function () {
+    function ProcessService(_petriNetResource, _log) {
+        this._petriNetResource = _petriNetResource;
+        this._log = _log;
+        this._nets = {};
+        this._netsSubject = new Subject();
+        this._netUpdate = new Subject();
+        this._requestCache = new Map();
+        this._referenceRequestCache = new Map();
+    }
+    ProcessService.prototype.ngOnDestroy = function () {
+        this._netsSubject.complete();
+        this._netUpdate.complete();
+        Array.from(this._requestCache.values()).forEach(function (net) { return net.complete(); });
+        Array.from(this._referenceRequestCache.values()).forEach(function (net) { return net.complete(); });
+    };
+    /**
+     * Get process nets according to provided identifiers.
+     * If any of the requested processes is not cached it will be loaded from the server and saved for later.
+     * @param identifiers Array of identifiers of requested processes. See {@link Net}
+     * @param forceLoad when set to `true` cached processes will be ignored and a backend request will always be made
+     * (unless another is already pending)
+     * @returns Observable of array of loaded processes. Array is emitted only when every process finished loading.
+     * If any of the processes failed to load it is skipped from the result.
+     */
+    ProcessService.prototype.getNets = function (identifiers, forceLoad) {
+        var _this = this;
+        if (forceLoad === void 0) { forceLoad = false; }
+        if (identifiers.length === 0) {
+            return of([]);
+        }
+        return forkJoin(identifiers.map(function (i) {
+            return _this.getNet(i, forceLoad);
+        })).pipe(map(function (nets) { return nets.filter(function (n) { return !!n; }); }), tap(function (nets) {
+            if (nets.length === 0) {
+                return;
+            }
+            _this._netsSubject.next(_this._nets);
+            nets.forEach(function (n) { return _this._netUpdate.next(n); });
+        }));
+    };
+    /**
+     * Get process net by identifier.
+     * @param identifier Identifier of the requested process. See {@link Net}
+     * @param forceLoad when set to `true` cached processes will be ignored and a backend request will always be made
+     * (unless another is already pending)
+     * @returns Observable of [the process]{@link Net}. Process is loaded from a server or picked from the cache.
+     */
+    ProcessService.prototype.getNet = function (identifier, forceLoad) {
+        var _this = this;
+        if (forceLoad === void 0) { forceLoad = false; }
+        if (!forceLoad && this._nets[identifier]) {
+            this._log.debug("returning net '" + identifier + "' from cache");
+            return of(this._nets[identifier]);
+        }
+        if (this._requestCache.has(identifier)) {
+            this._log.debug("returning net '" + identifier + "' from pending requests");
+            return this._requestCache.get(identifier).asObservable();
+        }
+        this._log.debug("retrieving net '" + identifier + "' from backend");
+        this._requestCache.set(identifier, new ReplaySubject(1));
+        return this.loadNet(identifier).pipe(tap(function (net) {
+            var s = _this._requestCache.get(identifier);
+            if (s) {
+                s.next(net);
+                s.complete();
+                _this._requestCache.delete(identifier);
+            }
+            if (net) {
+                _this.publishUpdate(net);
+            }
+        }));
+    };
+    /**
+     * Get process net referencess according to provided identifiers.
+     *
+     * `PetriNetReferences` are not cached.
+     * Each call will result in a new backend request unless a request for the same net is already pending.
+     * @param identifiers Array of identifiers of requested processes. See {@link Net}
+     * @returns Observable of array of loaded processes. Array is emitted only when every process finished loading.
+     * If any of the processes failed to load it is skipped from the result.
+     */
+    ProcessService.prototype.getNetReferences = function (identifiers) {
+        var _this = this;
+        if (identifiers.length === 0) {
+            return of([]);
+        }
+        return forkJoin(identifiers.map(function (i) {
+            return _this.getNetReference(i);
+        })).pipe(map(function (references) { return references.filter(function (r) { return !!r; }); }));
+    };
+    /**
+     * Get process net reference by identifier.
+     *
+     * `PetriNetReferences` are not cached.
+     * Each call will result in a new backend request unless a request for the same net is already pending.
+     * @param identifier Identifier of the requested process. See {@link Net}
+     * @returns Observable of [the process]{@link Net}. Process is loaded from a server or picked from the cache.
+     */
+    ProcessService.prototype.getNetReference = function (identifier) {
+        var _this = this;
+        if (this._referenceRequestCache.has(identifier)) {
+            return this._referenceRequestCache.get(identifier).asObservable();
+        }
+        this._referenceRequestCache.set(identifier, new ReplaySubject(1));
+        return this.loadNetReference(identifier).pipe(switchMap(function (ref) {
+            if (ref !== null) {
+                return forkJoin({ net: of(ref), roles: _this.loadRoles(ref.stringId) });
+            }
+            else {
+                return of({ net: ref, roles: undefined });
+            }
+        }), map(function (result) {
+            if (result.net === null) {
+                return null;
+            }
+            return __assign(__assign({}, result.net), { roles: result.roles.processRoles, permissions: result.roles.permissions });
+        }), tap(function (reference) {
+            var s = _this._referenceRequestCache.get(identifier);
+            if (s) {
+                s.next(reference);
+                s.complete();
+                _this._referenceRequestCache.delete(identifier);
+            }
+        }));
+    };
+    /**
+     * Remove cached process by identifier. If the process is not found nothing happens.
+     * @param identifier Process identifier
+     */
+    ProcessService.prototype.removeNet = function (identifier) {
+        if (!this._nets[identifier]) {
+            return;
+        }
+        delete this._nets[identifier];
+        this.publishUpdate();
+    };
+    /**
+     * Update cached process object. If the process is not found nothing happens. Process object is replaced.
+     * @param net Updated process object.
+     */
+    ProcessService.prototype.updateNet = function (net) {
+        var _this = this;
+        if (!this._nets[net.identifier]) {
+            return;
+        }
+        if (!net.transitions.length || !net.transactions.length || !net.roles.length) {
+            forkJoin({
+                transitions: this.loadTransitions(net.stringId),
+                transactions: this.loadTransactions(net.stringId),
+                roles: this.loadRoles(net.stringId)
+            }).subscribe(function (values) {
+                net.transitions = values.transitions;
+                net.transactions = values.transactions;
+                net.roles = values.roles.processRoles;
+                net.permissions = values.roles.permissions;
+                _this._nets[net.identifier] = net;
+                _this.publishUpdate(net);
+            }, function (error) {
+                _this._log.error('Failed to load part of Petri net ' + net.title, error);
+                // throw error;
+            });
+        }
+        else {
+            this._nets[net.identifier] = net;
+            this.publishUpdate(net);
+        }
+    };
+    Object.defineProperty(ProcessService.prototype, "nets$", {
+        /**
+         * Stream of change of the process cache.
+         * New state of cache is emitted every time the cached changed by inserting, updating or deleting a process.
+         * @returns Observable of whole updated cache.
+         */
+        get: function () {
+            return this._netsSubject.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ProcessService.prototype, "netUpdate$", {
+        /**
+         * Stream of change in the process cache.
+         * New state of cache is emitted every time the cached changed by inserting, updating or deleting a process.
+         * @returns Observable of updated or newly loaded process net.
+         */
+        get: function () {
+            return this._netUpdate.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ProcessService.prototype.areNetsLoaded = function (identifiers) {
+        var _this = this;
+        return identifiers.every(function (identifier) { return _this.isNetLoaded(identifier); });
+    };
+    ProcessService.prototype.isNetLoaded = function (identifier) {
+        return !!this._nets[identifier];
+    };
+    ProcessService.prototype.loadNet = function (id) {
+        var _this = this;
+        var returnNet = new ReplaySubject(1);
+        this.loadNetReference(id).subscribe(function (net) {
+            if (net === null) {
+                _this._log.debug("loadNetReference for net '" + id + "' returned null");
+                returnNet.next(null);
+                returnNet.complete();
+                return;
+            }
+            _this._log.debug("loading net '" + id + "' transitions, transactions and roles");
+            forkJoin({
+                transitions: _this.loadTransitions(net.stringId),
+                transactions: _this.loadTransactions(net.stringId),
+                roles: _this.loadRoles(net.stringId)
+            }).subscribe(function (values) {
+                _this._nets[net.identifier] = new Net(net);
+                _this._nets[net.identifier].transitions = values.transitions;
+                _this._nets[net.identifier].transactions = values.transactions;
+                _this._nets[net.identifier].roles = values.roles.processRoles;
+                _this._nets[net.identifier].permissions = values.roles.permissions;
+                returnNet.next(_this._nets[net.identifier]);
+                returnNet.complete();
+            }, function (error) {
+                _this._log.error('Failed to load part of Petri net ' + net.title, error);
+                returnNet.next(_this._nets[net.identifier]);
+                returnNet.complete();
+                // throw error;
+            });
+        });
+        return returnNet.asObservable();
+    };
+    ProcessService.prototype.loadNetReference = function (id) {
+        var _this = this;
+        var returnReference = new ReplaySubject(1);
+        this._petriNetResource.getOne(id, '^').subscribe(function (reference) {
+            returnReference.next(!reference.stringId ? null : reference);
+            returnReference.complete();
+            return;
+        }, function (error) {
+            _this._log.error('Failed to load Petri net', error);
+            returnReference.next(null);
+            returnReference.complete();
+        });
+        return returnReference.asObservable();
+    };
+    ProcessService.prototype.loadTransitions = function (id) {
+        var _this = this;
+        return this._petriNetResource.getPetriNetTransitions(id).pipe(map(function (trans) {
+            if (trans instanceof Array) {
+                return trans;
+            }
+            return [];
+        }), tap(function (trans) {
+            if (trans.length === 0) {
+                _this._log.info('References for transitions of net ' + id + ' were not found!');
+            }
+        }), catchError(function (err) {
+            _this._log.error('References for transitions of net ' + id + ' failed to load!', err);
+            throw err;
+        }));
+    };
+    ProcessService.prototype.loadTransactions = function (id) {
+        var _this = this;
+        return this._petriNetResource.getPetriNetTransactions(id).pipe(map(function (trans) {
+            if (trans instanceof Array) {
+                return trans;
+            }
+            return [];
+        }), tap(function (trans) {
+            if (trans.length === 0) {
+                _this._log.info('References for transactions of net ' + id + ' were not found!');
+            }
+        }), catchError(function (err) {
+            _this._log.error('References for transactions of net ' + id + ' failed to load!', err);
+            throw err;
+        }));
+    };
+    ProcessService.prototype.loadRoles = function (id) {
+        var _this = this;
+        return this._petriNetResource.getPetriNetRoles(id).pipe(tap(function (rolesAndPerm) {
+            if (rolesAndPerm.processRoles.length === 0) {
+                _this._log.info('Roles reference of net ' + id + ' were not found!');
+            }
+        }), catchError(function (err) {
+            _this._log.error('Roles reference of net ' + id + ' failed to load!', err);
+            throw err;
+        }));
+    };
+    ProcessService.prototype.publishUpdate = function (net) {
+        this._netsSubject.next(this._nets);
+        if (net) {
+            this._netUpdate.next(net);
+        }
+    };
+    ProcessService.ctorParameters = function () { return [
+        { type: PetriNetResourceService },
+        { type: LoggerService }
+    ]; };
+    ProcessService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ProcessService_Factory() { return new ProcessService(i0.ɵɵinject(i1.PetriNetResourceService), i0.ɵɵinject(i2.LoggerService)); }, token: ProcessService, providedIn: "root" });
+    ProcessService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    ProcessService.ctorParameters = function () { return [
+        { type: PetriNetResourceService },
+        { type: LoggerService }
+    ]; };
+    return ProcessService;
+}());
+export { ProcessService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"process.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/process/process.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\nimport {forkJoin, Observable, of, ReplaySubject, Subject} from 'rxjs';\nimport {Net} from './net';\nimport {PetriNetResourceService} from '../resources/engine-endpoint/petri-net-resource.service';\nimport {LoggerService} from '../logger/services/logger.service';\nimport Transition from './transition';\nimport Transaction from './transaction';\nimport {catchError, map, switchMap, tap} from 'rxjs/operators';\nimport RolesAndPermissions from './rolesAndPermissions';\nimport {PetriNetReference} from '../resources/interface/petri-net-reference';\nimport {PetriNetReferenceWithPermissions} from './petri-net-reference-with-permissions';\n\nexport interface NetCache {\n    [k: string]: Net;\n}\n\n/**\n * Process service is responsible for loading and caching processes needed for any functionality of an app.\n */\n@Injectable({\n    providedIn: 'root'\n})\nexport class ProcessService implements OnDestroy {\n\n    protected readonly _nets: NetCache;\n    protected _netsSubject: Subject<NetCache>;\n    protected _netUpdate: Subject<Net>;\n    protected _requestCache: Map<string, ReplaySubject<Net>>;\n    protected _referenceRequestCache: Map<string, ReplaySubject<PetriNetReferenceWithPermissions>>;\n\n    constructor(private _petriNetResource: PetriNetResourceService, private _log: LoggerService) {\n        this._nets = {};\n        this._netsSubject = new Subject<NetCache>();\n        this._netUpdate = new Subject<Net>();\n        this._requestCache = new Map<string, ReplaySubject<Net>>();\n        this._referenceRequestCache = new Map<string, ReplaySubject<PetriNetReferenceWithPermissions>>();\n    }\n\n    ngOnDestroy(): void {\n        this._netsSubject.complete();\n        this._netUpdate.complete();\n        Array.from(this._requestCache.values()).forEach(net => net.complete());\n        Array.from(this._referenceRequestCache.values()).forEach(net => net.complete());\n    }\n\n    /**\n     * Get process nets according to provided identifiers.\n     * If any of the requested processes is not cached it will be loaded from the server and saved for later.\n     * @param identifiers Array of identifiers of requested processes. See {@link Net}\n     * @param forceLoad when set to `true` cached processes will be ignored and a backend request will always be made\n     * (unless another is already pending)\n     * @returns Observable of array of loaded processes. Array is emitted only when every process finished loading.\n     * If any of the processes failed to load it is skipped from the result.\n     */\n    public getNets(identifiers: Array<string>, forceLoad = false): Observable<Array<Net>> {\n        if (identifiers.length === 0) {\n            return of([]);\n        }\n        return forkJoin(identifiers.map(i => {\n            return this.getNet(i, forceLoad);\n        })).pipe(\n            map(nets => nets.filter(n => !!n)),\n            tap(nets => {\n                if (nets.length === 0) {\n                    return;\n                }\n                this._netsSubject.next(this._nets);\n                nets.forEach(n => this._netUpdate.next(n));\n            })\n        );\n    }\n\n    /**\n     * Get process net by identifier.\n     * @param identifier Identifier of the requested process. See {@link Net}\n     * @param forceLoad when set to `true` cached processes will be ignored and a backend request will always be made\n     * (unless another is already pending)\n     * @returns Observable of [the process]{@link Net}. Process is loaded from a server or picked from the cache.\n     */\n    public getNet(identifier: string, forceLoad = false): Observable<Net> {\n        if (!forceLoad && this._nets[identifier]) {\n            this._log.debug(`returning net '${identifier}' from cache`);\n            return of(this._nets[identifier]);\n        }\n        if (this._requestCache.has(identifier)) {\n            this._log.debug(`returning net '${identifier}' from pending requests`);\n            return this._requestCache.get(identifier).asObservable();\n        }\n        this._log.debug(`retrieving net '${identifier}' from backend`);\n        this._requestCache.set(identifier, new ReplaySubject<Net>(1));\n        return this.loadNet(identifier).pipe(\n            tap(net => {\n                const s = this._requestCache.get(identifier);\n                if (s) {\n                    s.next(net);\n                    s.complete();\n                    this._requestCache.delete(identifier);\n                }\n                if (net) {\n                    this.publishUpdate(net);\n                }\n            })\n        );\n    }\n\n    /**\n     * Get process net referencess according to provided identifiers.\n     *\n     * `PetriNetReferences` are not cached.\n     * Each call will result in a new backend request unless a request for the same net is already pending.\n     * @param identifiers Array of identifiers of requested processes. See {@link Net}\n     * @returns Observable of array of loaded processes. Array is emitted only when every process finished loading.\n     * If any of the processes failed to load it is skipped from the result.\n     */\n    public getNetReferences(identifiers: Array<string>): Observable<Array<PetriNetReferenceWithPermissions>> {\n        if (identifiers.length === 0) {\n            return of([]);\n        }\n        return forkJoin(identifiers.map(i => {\n            return this.getNetReference(i);\n        })).pipe(\n            map(references => references.filter(r => !!r))\n        );\n    }\n\n    /**\n     * Get process net reference by identifier.\n     *\n     * `PetriNetReferences` are not cached.\n     * Each call will result in a new backend request unless a request for the same net is already pending.\n     * @param identifier Identifier of the requested process. See {@link Net}\n     * @returns Observable of [the process]{@link Net}. Process is loaded from a server or picked from the cache.\n     */\n    public getNetReference(identifier: string): Observable<PetriNetReferenceWithPermissions> {\n        if (this._referenceRequestCache.has(identifier)) {\n            return this._referenceRequestCache.get(identifier).asObservable();\n        }\n        this._referenceRequestCache.set(identifier, new ReplaySubject<PetriNetReferenceWithPermissions>(1));\n        return this.loadNetReference(identifier).pipe(\n            switchMap(ref => {\n                if (ref !== null) {\n                    return forkJoin({net: of(ref), roles: this.loadRoles(ref.stringId)});\n                } else {\n                    return of({net: ref, roles: undefined});\n                }\n            }),\n            map(result => {\n                if (result.net === null) {\n                    return null;\n                }\n                return {\n                    ...result.net,\n                    roles: result.roles.processRoles,\n                    permissions: result.roles.permissions\n                };\n            }),\n            tap(reference => {\n                const s = this._referenceRequestCache.get(identifier);\n                if (s) {\n                    s.next(reference);\n                    s.complete();\n                    this._referenceRequestCache.delete(identifier);\n                }\n            })\n        );\n    }\n\n    /**\n     * Remove cached process by identifier. If the process is not found nothing happens.\n     * @param identifier Process identifier\n     */\n    public removeNet(identifier: string): void {\n        if (!this._nets[identifier]) {\n            return;\n        }\n        delete this._nets[identifier];\n        this.publishUpdate();\n    }\n\n    /**\n     * Update cached process object. If the process is not found nothing happens. Process object is replaced.\n     * @param net Updated process object.\n     */\n    public updateNet(net: Net): void {\n        if (!this._nets[net.identifier]) {\n            return;\n        }\n        if (!net.transitions.length || !net.transactions.length || !net.roles.length) {\n            forkJoin({\n                transitions: this.loadTransitions(net.stringId),\n                transactions: this.loadTransactions(net.stringId),\n                roles: this.loadRoles(net.stringId)\n            }).subscribe(values => {\n                net.transitions = values.transitions;\n                net.transactions = values.transactions;\n                net.roles = values.roles.processRoles;\n                net.permissions = values.roles.permissions;\n                this._nets[net.identifier] = net;\n                this.publishUpdate(net);\n            }, error => {\n                this._log.error('Failed to load part of Petri net ' + net.title, error);\n                // throw error;\n            });\n        } else {\n            this._nets[net.identifier] = net;\n            this.publishUpdate(net);\n        }\n    }\n\n    /**\n     * Stream of change of the process cache.\n     * New state of cache is emitted every time the cached changed by inserting, updating or deleting a process.\n     * @returns Observable of whole updated cache.\n     */\n    public get nets$(): Observable<NetCache> {\n        return this._netsSubject.asObservable();\n    }\n\n    /**\n     * Stream of change in the process cache.\n     * New state of cache is emitted every time the cached changed by inserting, updating or deleting a process.\n     * @returns Observable of updated or newly loaded process net.\n     */\n    public get netUpdate$(): Observable<Net> {\n        return this._netUpdate.asObservable();\n    }\n\n    public areNetsLoaded(identifiers: Array<string>): boolean {\n        return identifiers.every(identifier => this.isNetLoaded(identifier));\n    }\n\n    public isNetLoaded(identifier: string): boolean {\n        return !!this._nets[identifier];\n    }\n\n    protected loadNet(id: string): Observable<Net> {\n        const returnNet = new ReplaySubject<Net>(1);\n        this.loadNetReference(id).subscribe(net => {\n            if (net === null) {\n                this._log.debug(`loadNetReference for net '${id}' returned null`);\n                returnNet.next(null);\n                returnNet.complete();\n                return;\n            }\n            this._log.debug(`loading net '${id}' transitions, transactions and roles`);\n            forkJoin({\n                transitions: this.loadTransitions(net.stringId),\n                transactions: this.loadTransactions(net.stringId),\n                roles: this.loadRoles(net.stringId)\n            }).subscribe(values => {\n                this._nets[net.identifier] = new Net(net);\n                this._nets[net.identifier].transitions = values.transitions;\n                this._nets[net.identifier].transactions = values.transactions;\n                this._nets[net.identifier].roles = values.roles.processRoles;\n                this._nets[net.identifier].permissions = values.roles.permissions;\n                returnNet.next(this._nets[net.identifier]);\n                returnNet.complete();\n            }, error => {\n                this._log.error('Failed to load part of Petri net ' + net.title, error);\n                returnNet.next(this._nets[net.identifier]);\n                returnNet.complete();\n                // throw error;\n            });\n        });\n        return returnNet.asObservable();\n    }\n\n    protected loadNetReference(id: string): Observable<PetriNetReference> {\n        const returnReference = new ReplaySubject<PetriNetReference>(1);\n        this._petriNetResource.getOne(id, '^').subscribe(reference => {\n            returnReference.next(!reference.stringId ? null : reference);\n            returnReference.complete();\n            return;\n        }, error => {\n            this._log.error('Failed to load Petri net', error);\n            returnReference.next(null);\n            returnReference.complete();\n        });\n        return returnReference.asObservable();\n    }\n\n    protected loadTransitions(id: string): Observable<Array<Transition>> {\n        return this._petriNetResource.getPetriNetTransitions(id).pipe(\n            map(trans => {\n                if (trans instanceof Array) {\n                    return trans;\n                }\n                return [];\n            }),\n            tap(trans => {\n                if (trans.length === 0) {\n                    this._log.info('References for transitions of net ' + id + ' were not found!');\n                }\n            }),\n            catchError(err => {\n                this._log.error('References for transitions of net ' + id + ' failed to load!', err);\n                throw err;\n            })\n        );\n    }\n\n    protected loadTransactions(id: string): Observable<Array<Transaction>> {\n        return this._petriNetResource.getPetriNetTransactions(id).pipe(\n            map(trans => {\n                if (trans instanceof Array) {\n                    return trans;\n                }\n                return [];\n            }),\n            tap(trans => {\n                if (trans.length === 0) {\n                    this._log.info('References for transactions of net ' + id + ' were not found!');\n                }\n            }),\n            catchError(err => {\n                this._log.error('References for transactions of net ' + id + ' failed to load!', err);\n                throw err;\n            })\n        );\n    }\n\n    protected loadRoles(id: string): Observable<RolesAndPermissions> {\n        return this._petriNetResource.getPetriNetRoles(id).pipe(\n            tap(rolesAndPerm => {\n                if (rolesAndPerm.processRoles.length === 0) {\n                    this._log.info('Roles reference of net ' + id + ' were not found!');\n                }\n            }),\n            catchError(err => {\n                this._log.error('Roles reference of net ' + id + ' failed to load!', err);\n                throw err;\n            })\n        );\n    }\n\n    protected publishUpdate(net?: Net): void {\n        this._netsSubject.next(this._nets);\n        if (net) {\n            this._netUpdate.next(net);\n        }\n    }\n}\n"]}

package/esm5/lib/process/public-api.js

@@ -0,0 +1,8 @@
+export * from './process.service';
+export * from './net';
+export * from './transition';
+export * from './transaction';
+export * from './netRole';
+export * from './public-process.service';
+export * from './petri-net-reference-with-permissions';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9wcm9jZXNzL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLE9BQU8sQ0FBQztBQUN0QixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsd0NBQXdDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3Byb2Nlc3Muc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL25ldCc7XG5leHBvcnQgKiBmcm9tICcuL3RyYW5zaXRpb24nO1xuZXhwb3J0ICogZnJvbSAnLi90cmFuc2FjdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL25ldFJvbGUnO1xuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtcHJvY2Vzcy5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vcGV0cmktbmV0LXJlZmVyZW5jZS13aXRoLXBlcm1pc3Npb25zJztcbiJdfQ==

package/esm5/lib/process/public-process.service.js

@@ -0,0 +1,34 @@
+import { __extends } from "tslib";
+import { Injectable } from '@angular/core';
+import { ProcessService } from './process.service';
+import { PublicPetriNetResourceService } from '../resources/engine-endpoint/public/public-petri-net-resource.service';
+import { LoggerService } from '../logger/services/logger.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../resources/engine-endpoint/public/public-petri-net-resource.service";
+import * as i2 from "../logger/services/logger.service";
+var PublicProcessService = /** @class */ (function (_super) {
+    __extends(PublicProcessService, _super);
+    function PublicProcessService(_publicPetriNetResource, _logger) {
+        var _this = _super.call(this, _publicPetriNetResource, _logger) || this;
+        _this._publicPetriNetResource = _publicPetriNetResource;
+        _this._logger = _logger;
+        return _this;
+    }
+    PublicProcessService.ctorParameters = function () { return [
+        { type: PublicPetriNetResourceService },
+        { type: LoggerService }
+    ]; };
+    PublicProcessService.ɵprov = i0.ɵɵdefineInjectable({ factory: function PublicProcessService_Factory() { return new PublicProcessService(i0.ɵɵinject(i1.PublicPetriNetResourceService), i0.ɵɵinject(i2.LoggerService)); }, token: PublicProcessService, providedIn: "root" });
+    PublicProcessService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    PublicProcessService.ctorParameters = function () { return [
+        { type: PublicPetriNetResourceService },
+        { type: LoggerService }
+    ]; };
+    return PublicProcessService;
+}(ProcessService));
+export { PublicProcessService };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLXByb2Nlc3Muc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9wcm9jZXNzL3B1YmxpYy1wcm9jZXNzLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFDLGNBQWMsRUFBQyxNQUFNLG1CQUFtQixDQUFDO0FBQ2pELE9BQU8sRUFBQyw2QkFBNkIsRUFBQyxNQUFNLHVFQUF1RSxDQUFDO0FBQ3BILE9BQU8sRUFBQyxhQUFhLEVBQUMsTUFBTSxtQ0FBbUMsQ0FBQzs7OztBQUVoRTtJQUcwQyx3Q0FBYztJQUNwRCw4QkFBb0IsdUJBQXNELEVBQVUsT0FBc0I7UUFBMUcsWUFDSSxrQkFBTSx1QkFBdUIsRUFBRSxPQUFPLENBQUMsU0FDMUM7UUFGbUIsNkJBQXVCLEdBQXZCLHVCQUF1QixDQUErQjtRQUFVLGFBQU8sR0FBUCxPQUFPLENBQWU7O0lBRTFHLENBQUM7O2dCQUY0Qyw2QkFBNkI7Z0JBQW1CLGFBQWE7Ozs7Z0JBSjdHLFVBQVUsU0FBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkI7OztnQkFMTyw2QkFBNkI7Z0JBQzdCLGFBQWE7OytCQUhyQjtDQVlDLEFBUEQsQ0FHMEMsY0FBYyxHQUl2RDtTQUpZLG9CQUFvQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7UHJvY2Vzc1NlcnZpY2V9IGZyb20gJy4vcHJvY2Vzcy5zZXJ2aWNlJztcbmltcG9ydCB7UHVibGljUGV0cmlOZXRSZXNvdXJjZVNlcnZpY2V9IGZyb20gJy4uL3Jlc291cmNlcy9lbmdpbmUtZW5kcG9pbnQvcHVibGljL3B1YmxpYy1wZXRyaS1uZXQtcmVzb3VyY2Uuc2VydmljZSc7XG5pbXBvcnQge0xvZ2dlclNlcnZpY2V9IGZyb20gJy4uL2xvZ2dlci9zZXJ2aWNlcy9sb2dnZXIuc2VydmljZSc7XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIFB1YmxpY1Byb2Nlc3NTZXJ2aWNlIGV4dGVuZHMgUHJvY2Vzc1NlcnZpY2Uge1xuICAgIGNvbnN0cnVjdG9yKHByaXZhdGUgX3B1YmxpY1BldHJpTmV0UmVzb3VyY2U6IFB1YmxpY1BldHJpTmV0UmVzb3VyY2VTZXJ2aWNlLCBwcml2YXRlIF9sb2dnZXI6IExvZ2dlclNlcnZpY2UpIHtcbiAgICAgICAgc3VwZXIoX3B1YmxpY1BldHJpTmV0UmVzb3VyY2UsIF9sb2dnZXIpO1xuICAgIH1cbn1cbiJdfQ==

package/esm5/lib/process/rolesAndPermissions.js

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

package/esm5/lib/process/transaction.js

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

package/esm5/lib/process/transition.js

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

package/esm5/lib/public/factories/get-net-and-create-case.js

@@ -0,0 +1,22 @@
+import { mergeMap } from 'rxjs/operators';
+export var getNetAndCreateCase = function (router, route, process, caseResourceService, snackBarService, translate) {
+    process.getNet(route.snapshot.paramMap.get('petriNetId')).pipe(mergeMap(function (net) {
+        if (net) {
+            var newCase = {
+                title: (net.defaultCaseName !== undefined && net.defaultCaseName !== '') ?
+                    net.defaultCaseName : translate.instant('side-menu.new-case.case'),
+                color: 'panel-primary-icon',
+                netId: net.stringId
+            };
+            return caseResourceService.createCase(newCase);
+        }
+        else {
+            snackBarService.openWarningSnackBar(translate.instant('publicView.netNotExist'));
+        }
+    })).subscribe(function (response) {
+        router.navigate([route.snapshot.url.join('/') + '/' + response.outcome.aCase.stringId]);
+    }, function (error) {
+        snackBarService.openErrorSnackBar(translate.instant('publicView.errorCreate') + error);
+    });
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/public/factories/public-factory-resolver.js

@@ -0,0 +1,13 @@
+export var publicFactoryResolver = function (userService, sessionService, authService, router, publicResolverService, privateService, publicService) {
+    if (!sessionService.isInitialized) {
+        publicResolverService.url = router.url;
+        router.navigate(['/public-resolver']);
+    }
+    else if (authService.isAuthenticated && userService.user.id !== '' && userService.user.email !== 'anonymous@netgrif.com') {
+        return privateService;
+    }
+    else {
+        return publicService;
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/public/factories/public-search-factory.js

@@ -0,0 +1,17 @@
+import { getNetAndCreateCase } from './get-net-and-create-case';
+import { SimpleFilter } from '../../filter/models/simple-filter';
+import { FilterType } from '../../filter/models/filter-type';
+export var publicBaseFilterFactory = function (router, route, process, caseResourceService, snackBarService, translate) {
+    if (route.snapshot.paramMap.get('caseId') === null && route.snapshot.paramMap.get('petriNetId') !== null) {
+        getNetAndCreateCase(router, route, process, caseResourceService, snackBarService, translate);
+    }
+    else if (route.snapshot.paramMap.get('caseId') !== null) {
+        return {
+            filter: new SimpleFilter('', FilterType.TASK, { case: { id: route.snapshot.paramMap.get('caseId') } })
+        };
+    }
+    return {
+        filter: new SimpleFilter('', FilterType.TASK, { case: { id: 'No Case' } })
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/public/public-api.js

@@ -0,0 +1,5 @@
+export * from './factories/public-factory-resolver';
+export * from './factories/get-net-and-create-case';
+export * from './factories/public-search-factory';
+export * from './services/public-url-resolver.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9wdWJsaWMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLHdDQUF3QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9mYWN0b3JpZXMvcHVibGljLWZhY3RvcnktcmVzb2x2ZXInO1xuZXhwb3J0ICogZnJvbSAnLi9mYWN0b3JpZXMvZ2V0LW5ldC1hbmQtY3JlYXRlLWNhc2UnO1xuZXhwb3J0ICogZnJvbSAnLi9mYWN0b3JpZXMvcHVibGljLXNlYXJjaC1mYWN0b3J5JztcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvcHVibGljLXVybC1yZXNvbHZlci5zZXJ2aWNlJztcbiJdfQ==

package/esm5/lib/public/services/public-url-resolver.service.js

@@ -0,0 +1,26 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+var PublicUrlResolverService = /** @class */ (function () {
+    function PublicUrlResolverService() {
+    }
+    Object.defineProperty(PublicUrlResolverService.prototype, "url", {
+        get: function () {
+            return this._url;
+        },
+        set: function (url) {
+            this._url = url;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PublicUrlResolverService.ɵprov = i0.ɵɵdefineInjectable({ factory: function PublicUrlResolverService_Factory() { return new PublicUrlResolverService(); }, token: PublicUrlResolverService, providedIn: "root" });
+    PublicUrlResolverService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    PublicUrlResolverService.ctorParameters = function () { return []; };
+    return PublicUrlResolverService;
+}());
+export { PublicUrlResolverService };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLXVybC1yZXNvbHZlci5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5ldGdyaWYvY29tcG9uZW50cy1jb3JlLyIsInNvdXJjZXMiOlsibGliL3B1YmxpYy9zZXJ2aWNlcy9wdWJsaWMtdXJsLXJlc29sdmVyLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFVBQVUsRUFBQyxNQUFNLGVBQWUsQ0FBQzs7QUFFekM7SUFNSTtJQUNBLENBQUM7SUFFRCxzQkFBSSx5Q0FBRzthQUlQO1lBQ0ksT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDO1FBQ3JCLENBQUM7YUFORCxVQUFRLEdBQVc7WUFDZixJQUFJLENBQUMsSUFBSSxHQUFHLEdBQUcsQ0FBQztRQUNwQixDQUFDOzs7T0FBQTs7O2dCQVhKLFVBQVUsU0FBQztvQkFDUixVQUFVLEVBQUUsTUFBTTtpQkFDckI7OzttQ0FKRDtDQWtCQyxBQWhCRCxJQWdCQztTQWJZLHdCQUF3QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7SW5qZWN0YWJsZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBJbmplY3RhYmxlKHtcbiAgICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgUHVibGljVXJsUmVzb2x2ZXJTZXJ2aWNlIHtcblxuICAgIHByb3RlY3RlZCBfdXJsOiBzdHJpbmc7XG4gICAgY29uc3RydWN0b3IoKSB7XG4gICAgfVxuXG4gICAgc2V0IHVybCh1cmw6IHN0cmluZykge1xuICAgICAgICB0aGlzLl91cmwgPSB1cmw7XG4gICAgfVxuXG4gICAgZ2V0IHVybCgpIHtcbiAgICAgICAgcmV0dXJuIHRoaXMuX3VybDtcbiAgICB9XG59XG4iXX0=