@netgrif/components-core 6.0.1

package/esm2015/lib/allowed-nets/services/allowed-nets.service.js

@@ -0,0 +1,74 @@
+import { Injectable } from '@angular/core';
+import { Observable, ReplaySubject, Subscription } from 'rxjs';
+import { ProcessService } from '../../process/process.service';
+import { map, switchMap, tap } from 'rxjs/operators';
+/**
+ * This service holds the information about the allowed nets for a specific view.
+ */
+export class AllowedNetsService {
+    /**
+     * The service converts identifiers to {@link Net} objects on its own.
+     *
+     * When a new set of allowed nets is emitted into the input Observable the allowed nets for the view are updated.
+     *
+     * @param allowedNetIdentifiers$ identifiers of the allowed nets
+     * @param _processService process service
+     */
+    constructor(allowedNetIdentifiers$, _processService) {
+        this._processService = _processService;
+        this._allowedNets$ = new ReplaySubject(1);
+        this._allowedNetsIdentifiers$ = new ReplaySubject(1);
+        this.subAllowedNets = allowedNetIdentifiers$.pipe(tap(identifiers => {
+            this._allowedNetsIdentifiers$.next(identifiers);
+            this._allowedNetsIdentifiers = [...identifiers];
+        }), map(identifiers => this._processService.getNets(identifiers)), switchMap(nets => nets)).subscribe(nets => {
+            this._allowedNets$.next(nets);
+            this._allowedNets = [...nets];
+        });
+    }
+    /**
+     * Emits any time the allowed nets change. The first emission comes after the source observable emits for the first time.
+     *
+     * If a value has already been emitted, subscribing to the stream will provide the last emitted value.
+     */
+    get allowedNets$() {
+        return this._allowedNets$.asObservable();
+    }
+    /**
+     * @returns the current value of the allowed nets. If allowed nets are yet to bee set, `undefined` is returned.
+     */
+    get allowedNets() {
+        return this._allowedNets;
+    }
+    /**
+     * Emits any time the allowed nets change. The first emission comes after the source observable emits for the first time.
+     *
+     * If a value has already been emitted, subscribing to the stream will provide the last emitted value.
+     */
+    get allowedNetsIdentifiers$() {
+        return this._allowedNetsIdentifiers$.asObservable();
+    }
+    /**
+     * @returns the current value of the allowed nets identifiers. If allowed nets are yet to bee set, `undefined` is returned.
+     */
+    get allowedNetsIdentifiers() {
+        return this._allowedNetsIdentifiers;
+    }
+    ngOnDestroy() {
+        this._allowedNets$.complete();
+        this._allowedNetsIdentifiers$.complete();
+        this.subAllowedNets.unsubscribe();
+    }
+}
+AllowedNetsService.ctorParameters = () => [
+    { type: Observable },
+    { type: ProcessService }
+];
+AllowedNetsService.decorators = [
+    { type: Injectable }
+];
+AllowedNetsService.ctorParameters = () => [
+    { type: Observable },
+    { type: ProcessService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/allowed-nets/services/base-allowed-nets.service.js

@@ -0,0 +1,54 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class BaseAllowedNetsService {
+    constructor() {
+        this._baseAllowedNets = new BehaviorSubject([]);
+    }
+    ngOnDestroy() {
+        this._baseAllowedNets.complete();
+        if (this._sub !== undefined) {
+            this._sub.unsubscribe();
+        }
+    }
+    /**
+     * Sets the new identifiers of the base allowed nets
+     * @param nets new base net identifiers
+     */
+    set allowedNets(nets) {
+        this._baseAllowedNets.next(nets);
+    }
+    /**
+     * @returns the currently set allowed nets. Returns an empty array if no value was set.
+     */
+    get allowedNets() {
+        return this._baseAllowedNets.value;
+    }
+    /**
+     * Subscribes to the provided `Observable` and forwards the emissions to the baseAllowedNets `Subject`.
+     * If a new `Observable` is set, the previous Subscription is unsubscribed.
+     * @param observableNets an observable emitting the new base net identifiers
+     */
+    set allowedNets$(observableNets) {
+        if (this._sub !== undefined) {
+            this._sub.unsubscribe();
+        }
+        this._sub = observableNets.subscribe(nets => {
+            this._baseAllowedNets.next(nets);
+        });
+    }
+    /**
+     * @returns an observable that emits the currently set base allowed nets and any subsequent values
+     */
+    get allowedNets$() {
+        return this._baseAllowedNets.asObservable();
+    }
+}
+BaseAllowedNetsService.ɵprov = i0.ɵɵdefineInjectable({ factory: function BaseAllowedNetsService_Factory() { return new BaseAllowedNetsService(); }, token: BaseAllowedNetsService, providedIn: "root" });
+BaseAllowedNetsService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+BaseAllowedNetsService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/allowed-nets/services/factory/allowed-nets-service-factory.js

@@ -0,0 +1,129 @@
+import { Injectable } from '@angular/core';
+import { ProcessService } from '../../../process/process.service';
+import { AllowedNetsService } from '../allowed-nets.service';
+import { switchMap } from 'rxjs/operators';
+import { of } from 'rxjs';
+import { PetriNetResourceService } from '../../../resources/engine-endpoint/petri-net-resource.service';
+import { ConfigurationService } from '../../../configuration/configuration.service';
+import { LoggerService } from '../../../logger/services/logger.service';
+import { getImmediateData } from '../../../utility/get-immediate-data';
+import { UserFilterConstants } from '../../../filter/models/user-filter-constants';
+import { getFieldFromDataGroups } from '../../../utility/get-field';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../process/process.service";
+import * as i2 from "../../../resources/engine-endpoint/petri-net-resource.service";
+import * as i3 from "../../../configuration/configuration.service";
+import * as i4 from "../../../logger/services/logger.service";
+/**
+ * Convenience method that can be used as an allowed nets factory for tabbed task views.
+ * If no allowed nets are provided in the injected data then an {@link AllowedNetsService} with no allowed nets is created.
+ * It has a dependency on this class and {@link NAE_TAB_DATA} injection token.
+ */
+export function tabbedAllowedNetsServiceFactory(factory, tabData) {
+    var _a;
+    return factory.createFromArray((_a = tabData === null || tabData === void 0 ? void 0 : tabData.allowedNets) !== null && _a !== void 0 ? _a : []);
+}
+/**
+ * Convenience method that can be used as an allowed nets factory for views that are loaded from filter process instances.
+ * It has a dependency on this class and {@link NAE_NAVIGATION_ITEM_TASK_DATA} injection token.
+ */
+export function navigationItemTaskAllowedNetsServiceFactory(factory, baseAllowedNets, navigationItemTaskData) {
+    const filterField = getFieldFromDataGroups(navigationItemTaskData, UserFilterConstants.FILTER_FIELD_ID);
+    if (filterField === undefined) {
+        throw new Error(`Provided navigation item task data does not contain a filter field with ID '${UserFilterConstants.FILTER_FIELD_ID}'! Allowed nets cannot be generated from it!`);
+    }
+    const nets = [...filterField.allowedNets];
+    if (filterField.filterMetadata.inheritAllowedNets) {
+        nets.push(...baseAllowedNets.allowedNets);
+    }
+    const uniqueNets = new Set(nets);
+    return factory.createFromArray(Array.from(uniqueNets));
+}
+/**
+ * Simplifies the creation of {@link AllowedNetsService} instances
+ */
+export class AllowedNetsServiceFactory {
+    constructor(_processService, _petriNetResource, _configService, _log) {
+        this._processService = _processService;
+        this._petriNetResource = _petriNetResource;
+        this._configService = _configService;
+        this._log = _log;
+    }
+    /**
+     * Creates an instance of {@link AllowedNetsService} without having to provide all the dependencies yourself.
+     * @returns an instance of {@link AllowedNetsService} with all nets set as the `allowedNets`
+     */
+    createWithAllNets() {
+        return new AllowedNetsService(this._petriNetResource.getAll().pipe(switchMap(nets => {
+            if (nets && Array.isArray(nets)) {
+                return of(nets.map(n => n.identifier));
+            }
+            else {
+                return of([]);
+            }
+        })), this._processService);
+    }
+    /**
+     * Creates an instance of {@link AllowedNetsService} without having to provide all the dependencies yourself.
+     * @param allowedNetsIdentifiers identifiers of the allowed nets
+     */
+    createFromArray(allowedNetsIdentifiers) {
+        return new AllowedNetsService(of(allowedNetsIdentifiers), this._processService);
+    }
+    /**
+     * Creates an instance of {@link AllowedNetsService} without having to provide all the dependencies yourself.
+     * @param webViewPath path to the view as specified in its configuration. No leading backslash.
+     * Allowed nets are loaded from the configuration of the view.
+     */
+    createFromConfig(webViewPath) {
+        var _a, _b;
+        const view = this._configService.getViewByPath(webViewPath);
+        if (((_a = view === null || view === void 0 ? void 0 : view.layout) === null || _a === void 0 ? void 0 : _a.params) === undefined) {
+            throw new Error(`Can't load configuration for view with webPath: '${webViewPath}'`);
+        }
+        const viewParams = view.layout.params;
+        if (viewParams.allowedNets === undefined) {
+            this._log.warn(`No 'allowedNets' provided for view with webPath '${webViewPath}'`);
+        }
+        return new AllowedNetsService(of((_b = viewParams.allowedNets) !== null && _b !== void 0 ? _b : []), this._processService);
+    }
+    /**
+     * Creates an instance of {@link AllowedNetsService} without having to provide all the dependencies yourself.
+     * @param netIdentifiers$ observable containing the identifiers of the allowed nets.
+     * When a new value is emitted the allowed nets will be updated.
+     */
+    createFromObservable(netIdentifiers$) {
+        return new AllowedNetsService(netIdentifiers$, this._processService);
+    }
+    /**
+     * Creates an instance of {@link AllowedNetsService} without having to provide all the dependencies yourself.
+     * @param filterCase a filter process instance
+     * Allowed nets are set from filter process immediate data
+     */
+    createFromFilterCase(filterCase) {
+        const filterData = getImmediateData(filterCase, UserFilterConstants.FILTER_FIELD_ID);
+        if (filterData === undefined) {
+            throw new Error(`Cannot get filter from case '${filterCase.title}' with id '${filterCase.stringId}'`);
+        }
+        return new AllowedNetsService(of(filterData.allowedNets), this._processService);
+    }
+}
+AllowedNetsServiceFactory.ctorParameters = () => [
+    { type: ProcessService },
+    { type: PetriNetResourceService },
+    { type: ConfigurationService },
+    { type: LoggerService }
+];
+AllowedNetsServiceFactory.ɵprov = i0.ɵɵdefineInjectable({ factory: function AllowedNetsServiceFactory_Factory() { return new AllowedNetsServiceFactory(i0.ɵɵinject(i1.ProcessService), i0.ɵɵinject(i2.PetriNetResourceService), i0.ɵɵinject(i3.ConfigurationService), i0.ɵɵinject(i4.LoggerService)); }, token: AllowedNetsServiceFactory, providedIn: "root" });
+AllowedNetsServiceFactory.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+AllowedNetsServiceFactory.ctorParameters = () => [
+    { type: ProcessService },
+    { type: PetriNetResourceService },
+    { type: ConfigurationService },
+    { type: LoggerService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"allowed-nets-service-factory.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/allowed-nets/services/factory/allowed-nets-service-factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AACzC,OAAO,EAAC,cAAc,EAAC,MAAM,kCAAkC,CAAC;AAChE,OAAO,EAAC,kBAAkB,EAAC,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAC,SAAS,EAAC,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAa,EAAE,EAAC,MAAM,MAAM,CAAC;AACpC,OAAO,EAAC,uBAAuB,EAAC,MAAM,+DAA+D,CAAC;AACtG,OAAO,EAAC,oBAAoB,EAAC,MAAM,8CAA8C,CAAC;AAElF,OAAO,EAAC,aAAa,EAAC,MAAM,yCAAyC,CAAC;AAItE,OAAO,EAAC,gBAAgB,EAAC,MAAM,qCAAqC,CAAC;AACrE,OAAO,EAAC,mBAAmB,EAAC,MAAM,8CAA8C,CAAC;AAEjF,OAAO,EAAC,sBAAsB,EAAC,MAAM,4BAA4B,CAAC;;;;;;AAKlE;;;;GAIG;AACH,MAAM,UAAU,+BAA+B,CAAC,OAAkC,EAClC,OAAmC;;IAC/E,OAAO,OAAO,CAAC,eAAe,OAAC,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,WAAW,mCAAI,EAAE,CAAC,CAAC;AAC/D,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,2CAA2C,CAAC,OAAkC,EAClC,eAAuC,EACvC,sBAAwC;IAChG,MAAM,WAAW,GAAG,sBAAsB,CAAC,sBAAsB,EAAE,mBAAmB,CAAC,eAAe,CAAgB,CAAC;IAEvH,IAAI,WAAW,KAAK,SAAS,EAAE;QAC3B,MAAM,IAAI,KAAK,CAAC,+EAA+E,mBAAmB,CAAC,eACnH,8CAA8C,CAAC,CAAC;KACnD;IAED,MAAM,IAAI,GAAG,CAAC,GAAG,WAAW,CAAC,WAAW,CAAC,CAAC;IAE1C,IAAI,WAAW,CAAC,cAAc,CAAC,kBAAkB,EAAE;QAC/C,IAAI,CAAC,IAAI,CAAC,GAAG,eAAe,CAAC,WAAW,CAAC,CAAC;KAC7C;IAED,MAAM,UAAU,GAAG,IAAI,GAAG,CAAS,IAAI,CAAC,CAAC;IAEzC,OAAO,OAAO,CAAC,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;AAC3D,CAAC;AAED;;GAEG;AAIH,MAAM,OAAO,yBAAyB;IAElC,YAAsB,eAA+B,EAC/B,iBAA0C,EAC1C,cAAoC,EACpC,IAAmB;QAHnB,oBAAe,GAAf,eAAe,CAAgB;QAC/B,sBAAiB,GAAjB,iBAAiB,CAAyB;QAC1C,mBAAc,GAAd,cAAc,CAAsB;QACpC,SAAI,GAAJ,IAAI,CAAe;IACzC,CAAC;IAED;;;OAGG;IACI,iBAAiB;QACpB,OAAO,IAAI,kBAAkB,CACzB,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,CAAC,IAAI,CAChC,SAAS,CAAC,IAAI,CAAC,EAAE;YACb,IAAI,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;gBAC7B,OAAO,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;aAC1C;iBAAM;gBACH,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;aACjB;QACL,CAAC,CAAC,CACL,EACD,IAAI,CAAC,eAAe,CACvB,CAAC;IACN,CAAC;IAED;;;OAGG;IACI,eAAe,CAAC,sBAAqC;QACxD,OAAO,IAAI,kBAAkB,CACzB,EAAE,CAAC,sBAAsB,CAAC,EAC1B,IAAI,CAAC,eAAe,CACvB,CAAC;IACN,CAAC;IAED;;;;OAIG;IACI,gBAAgB,CAAC,WAAmB;;QACvC,MAAM,IAAI,GAAG,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC;QAC5D,IAAI,OAAA,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,MAAM,0CAAE,MAAM,MAAK,SAAS,EAAE;YACpC,MAAM,IAAI,KAAK,CAAC,oDAAoD,WAAW,GAAG,CAAC,CAAC;SACvF;QACD,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,MAAyC,CAAC;QACzE,IAAI,UAAU,CAAC,WAAW,KAAK,SAAS,EAAE;YACtC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,oDAAoD,WAAW,GAAG,CAAC,CAAC;SACtF;QACD,OAAO,IAAI,kBAAkB,CACzB,EAAE,OAAC,UAAU,CAAC,WAAW,mCAAI,EAAE,CAAC,EAChC,IAAI,CAAC,eAAe,CACvB,CAAC;IACN,CAAC;IAED;;;;OAIG;IACI,oBAAoB,CAAC,eAA0C;QAClE,OAAO,IAAI,kBAAkB,CACzB,eAAe,EACf,IAAI,CAAC,eAAe,CACvB,CAAC;IACN,CAAC;IAED;;;;OAIG;IACI,oBAAoB,CAAC,UAAgB;QACxC,MAAM,UAAU,GAAG,gBAAgB,CAAC,UAAU,EAAE,mBAAmB,CAAC,eAAe,CAAC,CAAC;QACrF,IAAI,UAAU,KAAK,SAAS,EAAE;YAC1B,MAAM,IAAI,KAAK,CAAC,gCAAgC,UAAU,CAAC,KAAK,cAAc,UAAU,CAAC,QAAQ,GAAG,CAAC,CAAC;SACzG;QACD,OAAO,IAAI,kBAAkB,CACzB,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC,EAC1B,IAAI,CAAC,eAAe,CACvB,CAAC;IACN,CAAC;;;YAlFsC,cAAc;YACZ,uBAAuB;YAC1B,oBAAoB;YAC9B,aAAa;;;;YAR5C,UAAU,SAAC;gBACR,UAAU,EAAE,MAAM;aACrB;;;YA3DO,cAAc;YAId,uBAAuB;YACvB,oBAAoB;YAEpB,aAAa","sourcesContent":["import {Injectable} from '@angular/core';\nimport {ProcessService} from '../../../process/process.service';\nimport {AllowedNetsService} from '../allowed-nets.service';\nimport {switchMap} from 'rxjs/operators';\nimport {Observable, of} from 'rxjs';\nimport {PetriNetResourceService} from '../../../resources/engine-endpoint/petri-net-resource.service';\nimport {ConfigurationService} from '../../../configuration/configuration.service';\nimport {CaseViewParams} from '../../../view/case-view/models/case-view-params';\nimport {LoggerService} from '../../../logger/services/logger.service';\nimport {TaskViewParams} from '../../../view/task-view/models/task-view-params';\nimport {InjectedTabbedTaskViewData} from '../../../view/task-view/models/injected-tabbed-task-view-data';\nimport {Case} from '../../../resources/interface/case';\nimport {getImmediateData} from '../../../utility/get-immediate-data';\nimport {UserFilterConstants} from '../../../filter/models/user-filter-constants';\nimport {DataGroup} from '../../../resources/public-api';\nimport {getFieldFromDataGroups} from '../../../utility/get-field';\nimport {FilterField} from '../../../data-fields/filter-field/models/filter-field';\nimport {BaseAllowedNetsService} from '../base-allowed-nets.service';\n\n\n/**\n * Convenience method that can be used as an allowed nets factory for tabbed task views.\n * If no allowed nets are provided in the injected data then an {@link AllowedNetsService} with no allowed nets is created.\n * It has a dependency on this class and {@link NAE_TAB_DATA} injection token.\n */\nexport function tabbedAllowedNetsServiceFactory(factory: AllowedNetsServiceFactory,\n                                                tabData: InjectedTabbedTaskViewData): AllowedNetsService {\n    return factory.createFromArray(tabData?.allowedNets ?? []);\n}\n\n/**\n * Convenience method that can be used as an allowed nets factory for views that are loaded from filter process instances.\n * It has a dependency on this class and {@link NAE_NAVIGATION_ITEM_TASK_DATA} injection token.\n */\nexport function navigationItemTaskAllowedNetsServiceFactory(factory: AllowedNetsServiceFactory,\n                                                            baseAllowedNets: BaseAllowedNetsService,\n                                                            navigationItemTaskData: Array<DataGroup>): AllowedNetsService {\n    const filterField = getFieldFromDataGroups(navigationItemTaskData, UserFilterConstants.FILTER_FIELD_ID) as FilterField;\n\n    if (filterField === undefined) {\n        throw new Error(`Provided navigation item task data does not contain a filter field with ID '${UserFilterConstants.FILTER_FIELD_ID\n        }'! Allowed nets cannot be generated from it!`);\n    }\n\n    const nets = [...filterField.allowedNets];\n\n    if (filterField.filterMetadata.inheritAllowedNets) {\n        nets.push(...baseAllowedNets.allowedNets);\n    }\n\n    const uniqueNets = new Set<string>(nets);\n\n    return factory.createFromArray(Array.from(uniqueNets));\n}\n\n/**\n * Simplifies the creation of {@link AllowedNetsService} instances\n */\n@Injectable({\n    providedIn: 'root'\n})\nexport class AllowedNetsServiceFactory {\n\n    constructor(protected _processService: ProcessService,\n                protected _petriNetResource: PetriNetResourceService,\n                protected _configService: ConfigurationService,\n                protected _log: LoggerService) {\n    }\n\n    /**\n     * Creates an instance of {@link AllowedNetsService} without having to provide all the dependencies yourself.\n     * @returns an instance of {@link AllowedNetsService} with all nets set as the `allowedNets`\n     */\n    public createWithAllNets(): AllowedNetsService {\n        return new AllowedNetsService(\n            this._petriNetResource.getAll().pipe(\n                switchMap(nets => {\n                    if (nets && Array.isArray(nets)) {\n                        return of(nets.map(n => n.identifier));\n                    } else {\n                        return of([]);\n                    }\n                })\n            ),\n            this._processService\n        );\n    }\n\n    /**\n     * Creates an instance of {@link AllowedNetsService} without having to provide all the dependencies yourself.\n     * @param allowedNetsIdentifiers identifiers of the allowed nets\n     */\n    public createFromArray(allowedNetsIdentifiers: Array<string>): AllowedNetsService {\n        return new AllowedNetsService(\n            of(allowedNetsIdentifiers),\n            this._processService\n        );\n    }\n\n    /**\n     * Creates an instance of {@link AllowedNetsService} without having to provide all the dependencies yourself.\n     * @param webViewPath path to the view as specified in its configuration. No leading backslash.\n     * Allowed nets are loaded from the configuration of the view.\n     */\n    public createFromConfig(webViewPath: string): AllowedNetsService {\n        const view = this._configService.getViewByPath(webViewPath);\n        if (view?.layout?.params === undefined) {\n            throw new Error(`Can't load configuration for view with webPath: '${webViewPath}'`);\n        }\n        const viewParams = view.layout.params as CaseViewParams | TaskViewParams;\n        if (viewParams.allowedNets === undefined) {\n            this._log.warn(`No 'allowedNets' provided for view with webPath '${webViewPath}'`);\n        }\n        return new AllowedNetsService(\n            of(viewParams.allowedNets ?? []),\n            this._processService\n        );\n    }\n\n    /**\n     * Creates an instance of {@link AllowedNetsService} without having to provide all the dependencies yourself.\n     * @param netIdentifiers$ observable containing the identifiers of the allowed nets.\n     * When a new value is emitted the allowed nets will be updated.\n     */\n    public createFromObservable(netIdentifiers$: Observable<Array<string>>): AllowedNetsService {\n        return new AllowedNetsService(\n            netIdentifiers$,\n            this._processService\n        );\n    }\n\n    /**\n     * Creates an instance of {@link AllowedNetsService} without having to provide all the dependencies yourself.\n     * @param filterCase a filter process instance\n     * Allowed nets are set from filter process immediate data\n     */\n    public createFromFilterCase(filterCase: Case): AllowedNetsService {\n        const filterData = getImmediateData(filterCase, UserFilterConstants.FILTER_FIELD_ID);\n        if (filterData === undefined) {\n            throw new Error(`Cannot get filter from case '${filterCase.title}' with id '${filterCase.stringId}'`);\n        }\n        return new AllowedNetsService(\n            of(filterData.allowedNets),\n            this._processService\n        );\n    }\n}\n"]}

package/esm2015/lib/authentication/anonymous/anonymous.service.js

@@ -0,0 +1,63 @@
+import { Injectable } from '@angular/core';
+import { ConfigurationService } from '../../configuration/configuration.service';
+import { NullStorage } from '../session/null-storage';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../../configuration/configuration.service";
+export class AnonymousService {
+    constructor(_config) {
+        this._config = _config;
+        this._jwtHeader = this._config.get().providers.auth.jwtBearer ?
+            this._config.get().providers.auth.jwtBearer : AnonymousService.JWT_BEARER_HEADER_DEFAULT;
+        this._storage = this.resolveStorage(this._config.get().providers.auth['local']);
+        this._tokenSet = new BehaviorSubject(false);
+    }
+    get jwtHeader() {
+        return this._jwtHeader;
+    }
+    get tokenSet() {
+        return this._tokenSet.asObservable();
+    }
+    getToken() {
+        return this._storage.getItem(this._jwtHeader);
+    }
+    setToken(token) {
+        this._storage.setItem(this._jwtHeader, token);
+        if (!this._tokenSet.getValue())
+            this._tokenSet.next(true);
+    }
+    removeToken() {
+        this._storage.removeItem(this._jwtHeader);
+        this._tokenSet.next(false);
+    }
+    ngOnDestroy() {
+        localStorage.removeItem(this._jwtHeader);
+        this._tokenSet.complete();
+    }
+    resolveStorage(storage) {
+        switch (storage) {
+            case 'local':
+                return localStorage;
+            case 'session':
+                return sessionStorage;
+            case 'null':
+                return new NullStorage();
+            default:
+                return localStorage;
+        }
+    }
+}
+AnonymousService.JWT_BEARER_HEADER_DEFAULT = 'X-Jwt-Token';
+AnonymousService.ctorParameters = () => [
+    { type: ConfigurationService }
+];
+AnonymousService.ɵprov = i0.ɵɵdefineInjectable({ factory: function AnonymousService_Factory() { return new AnonymousService(i0.ɵɵinject(i1.ConfigurationService)); }, token: AnonymousService, providedIn: "root" });
+AnonymousService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+AnonymousService.ctorParameters = () => [
+    { type: ConfigurationService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/authentication/authentication.factory.js

@@ -0,0 +1,16 @@
+import { NullAuthenticationService } from './services/methods/null-authentication/null-authentication.service';
+import { BasicAuthenticationService } from './services/methods/basic-authentication/basic-authentication.service';
+export function authenticationServiceFactory(config, http) {
+    const auth = config.get().providers.auth;
+    if (!auth || !auth.authentication) {
+        return new NullAuthenticationService();
+    }
+    const authType = auth.authentication.toLowerCase();
+    if (authType === 'basic') {
+        return new BasicAuthenticationService(http, config);
+    }
+    else {
+        return new NullAuthenticationService();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/authentication/authentication.module.js

@@ -0,0 +1,32 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { HTTP_INTERCEPTORS, HttpClient, HttpClientModule } from '@angular/common/http';
+import { AuthenticationInterceptor } from './services/authentication-interceptor';
+import { authenticationServiceFactory } from './authentication.factory';
+import { ConfigurationService } from '../configuration/configuration.service';
+import { AuthenticationMethodService } from './services/authentication-method.service';
+import { OverlayModule } from '@angular/cdk/overlay';
+import { MatProgressSpinnerModule, MatSpinner } from '@angular/material/progress-spinner';
+import { AnonymousAuthenticationInterceptor } from './services/anonymous-authentication-interceptor';
+const ɵ0 = authenticationServiceFactory;
+export class AuthenticationModule {
+}
+AuthenticationModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [],
+                imports: [
+                    CommonModule,
+                    HttpClientModule,
+                    MatProgressSpinnerModule,
+                    OverlayModule,
+                ],
+                providers: [
+                    { provide: HTTP_INTERCEPTORS, useClass: AuthenticationInterceptor, multi: true },
+                    { provide: HTTP_INTERCEPTORS, useClass: AnonymousAuthenticationInterceptor, multi: true },
+                    { provide: AuthenticationMethodService, useFactory: ɵ0, deps: [ConfigurationService, HttpClient] },
+                ],
+                entryComponents: [MatSpinner]
+            },] }
+];
+export { ɵ0 };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/authentication/components/abstract-authentication-overlay.js

@@ -0,0 +1,50 @@
+export class AbstractAuthenticationOverlay {
+    constructor(_session, _spinnerOverlay, router, redirectService, userService) {
+        this._session = _session;
+        this._spinnerOverlay = _spinnerOverlay;
+        this.router = router;
+        this.redirectService = redirectService;
+        this.userService = userService;
+    }
+    ngOnInit() {
+        if (this._session.verified) {
+            this.redirectService.redirect();
+        }
+        else if (!this._session.verified && this._session.isVerifying) {
+            this._spinnerOverlay.spin$.next(true);
+            this.subSession = this._session.verifying.subscribe(active => {
+                this.userService.user$.subscribe(user => {
+                    if (!!user.id && user.id.length > 0) {
+                        this.redirect(!active);
+                    }
+                });
+            });
+        }
+        else if (!this._session.verified && !this._session.isInitialized) {
+            this._spinnerOverlay.spin$.next(true);
+            this.subInitializing = this._session.initializing.subscribe(initialized => {
+                this.redirect(initialized);
+            });
+        }
+    }
+    redirect(bool) {
+        if (bool) {
+            this._spinnerOverlay.spin$.next(false);
+            if (this._session.verified) {
+                this.redirectService.redirect();
+            }
+        }
+    }
+    ngOnDestroy() {
+        if (this.subSession) {
+            this.subSession.unsubscribe();
+        }
+        if (this.subInitializing) {
+            this.subInitializing.unsubscribe();
+        }
+        if (this.user) {
+            this.user.unsubscribe();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/authentication/models/credentials.js

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

package/esm2015/lib/authentication/models/public-api.js

@@ -0,0 +1,5 @@
+/* CLASSES */
+export * from './credentials';
+export * from './transformer';
+export * from './user.transformer';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9hdXRoZW50aWNhdGlvbi9tb2RlbHMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxhQUFhO0FBQ2IsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxvQkFBb0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIENMQVNTRVMgKi9cbmV4cG9ydCAqIGZyb20gJy4vY3JlZGVudGlhbHMnO1xuZXhwb3J0ICogZnJvbSAnLi90cmFuc2Zvcm1lcic7XG5leHBvcnQgKiBmcm9tICcuL3VzZXIudHJhbnNmb3JtZXInO1xuIl19

package/esm2015/lib/authentication/models/transformer.js

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

package/esm2015/lib/authentication/models/user.transformer.js

@@ -0,0 +1,19 @@
+import { User } from '../../user/models/user';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class UserTransformer {
+    transformAuthorities(authorities) {
+        return !authorities ? [] : authorities.map(a => a.authority);
+    }
+    transform(user) {
+        const groups = []; // TODO groups parsing
+        return new User(user.id, user.email, user.name, user.surname, this.transformAuthorities(user.authorities), user.processRoles, groups, user.nextGroups);
+    }
+}
+UserTransformer.ɵprov = i0.ɵɵdefineInjectable({ factory: function UserTransformer_Factory() { return new UserTransformer(); }, token: UserTransformer, providedIn: "root" });
+UserTransformer.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/authentication/public-api.js

@@ -0,0 +1,14 @@
+/* APIS */
+export * from './models/public-api';
+export * from './services/public-api';
+export * from './session/public-api';
+export * from './sign-up/public-api';
+/* MODULES */
+export * from './authentication.module';
+/* CLASSES */
+export * from './authentication.factory';
+/* SERVICES */
+export * from './anonymous/anonymous.service';
+/* COMPONENTS */
+export * from './components/abstract-authentication-overlay';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9hdXRoZW50aWNhdGlvbi9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFVBQVU7QUFDVixjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHNCQUFzQixDQUFDO0FBRXJDLGFBQWE7QUFDYixjQUFjLHlCQUF5QixDQUFDO0FBRXhDLGFBQWE7QUFDYixjQUFjLDBCQUEwQixDQUFDO0FBRXpDLGNBQWM7QUFDZCxjQUFjLCtCQUErQixDQUFDO0FBRTlDLGdCQUFnQjtBQUNoQixjQUFjLDhDQUE4QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyogQVBJUyAqL1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMvcHVibGljLWFwaSc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL3B1YmxpYy1hcGknO1xuZXhwb3J0ICogZnJvbSAnLi9zZXNzaW9uL3B1YmxpYy1hcGknO1xuZXhwb3J0ICogZnJvbSAnLi9zaWduLXVwL3B1YmxpYy1hcGknO1xuXG4vKiBNT0RVTEVTICovXG5leHBvcnQgKiBmcm9tICcuL2F1dGhlbnRpY2F0aW9uLm1vZHVsZSc7XG5cbi8qIENMQVNTRVMgKi9cbmV4cG9ydCAqIGZyb20gJy4vYXV0aGVudGljYXRpb24uZmFjdG9yeSc7XG5cbi8qIFNFUlZJQ0VTICovXG5leHBvcnQgKiBmcm9tICcuL2Fub255bW91cy9hbm9ueW1vdXMuc2VydmljZSc7XG5cbi8qIENPTVBPTkVOVFMgKi9cbmV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cy9hYnN0cmFjdC1hdXRoZW50aWNhdGlvbi1vdmVybGF5JztcbiJdfQ==

package/esm2015/lib/authentication/services/anonymous-authentication-interceptor.js

@@ -0,0 +1,44 @@
+import { Injectable } from '@angular/core';
+import { HttpErrorResponse, HttpResponse } from '@angular/common/http';
+import { throwError } from 'rxjs';
+import { catchError, tap } from 'rxjs/operators';
+import { AnonymousService } from '../anonymous/anonymous.service';
+export class AnonymousAuthenticationInterceptor {
+    constructor(_anonymousService) {
+        this._anonymousService = _anonymousService;
+    }
+    intercept(req, next) {
+        const jwtAuthToken = this._anonymousService.getToken();
+        if (!this._anonymousService) {
+            next.handle(req);
+        }
+        if (!!jwtAuthToken) {
+            req = req.clone({
+                headers: req.headers.set(this._anonymousService.jwtHeader, jwtAuthToken)
+            });
+        }
+        return next.handle(req).pipe(tap(event => {
+            if (event instanceof HttpResponse) {
+                if (event.headers.has(this._anonymousService.jwtHeader)) {
+                    this._anonymousService.setToken(event.headers.get(this._anonymousService.jwtHeader));
+                }
+            }
+        }), catchError(errorEvent => {
+            if (errorEvent instanceof HttpErrorResponse && errorEvent.status === 401) {
+                console.debug('Authentication token is invalid. Clearing session token');
+                this._anonymousService.removeToken();
+            }
+            return throwError(errorEvent);
+        }));
+    }
+}
+AnonymousAuthenticationInterceptor.ctorParameters = () => [
+    { type: AnonymousService }
+];
+AnonymousAuthenticationInterceptor.decorators = [
+    { type: Injectable }
+];
+AnonymousAuthenticationInterceptor.ctorParameters = () => [
+    { type: AnonymousService }
+];
+//# sourceMappingURL=data:application/json;base64,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