@netgrif/components-core 6.0.1

package/esm5/lib/admin/user-invite/services/organization-list.service.js

@@ -0,0 +1,82 @@
+import { Injectable } from '@angular/core';
+import { LoadingEmitter } from '../../../utility/loading-emitter';
+import { UserResourceService } from '../../../resources/engine-endpoint/user-resource.service';
+import { LoggerService } from '../../../logger/services/logger.service';
+import { of } from 'rxjs';
+import { take } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../resources/engine-endpoint/user-resource.service";
+import * as i2 from "../../../logger/services/logger.service";
+var OrganizationListService = /** @class */ (function () {
+    function OrganizationListService(_resource, _log) {
+        this._resource = _resource;
+        this._log = _log;
+        this._groups = [];
+        this._loading$ = new LoadingEmitter();
+    }
+    Object.defineProperty(OrganizationListService.prototype, "loading", {
+        get: function () {
+            return this._loading$.isActive;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(OrganizationListService.prototype, "loading$", {
+        get: function () {
+            return this._loading$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(OrganizationListService.prototype, "groups", {
+        get: function () {
+            return this._groups;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(OrganizationListService.prototype, "groups$", {
+        get: function () {
+            return of(this._groups);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    OrganizationListService.prototype.loadGroups = function () {
+        var _this = this;
+        if (this._loading$.isActive) {
+            return;
+        }
+        this._loading$.on();
+        this._resource.getAllGroups().pipe(take(1)).subscribe(function (groups) {
+            if (Array.isArray(groups.groups) && groups.groups.length !== 0) {
+                _this._groups = groups.groups;
+                _this._loading$.off();
+            }
+            else {
+                _this._log.info('There are no Groups');
+                _this._loading$.off();
+            }
+        }, function (error) {
+            _this._log.debug('Getting groups failed', error);
+            _this._loading$.off();
+        });
+    };
+    OrganizationListService.ctorParameters = function () { return [
+        { type: UserResourceService },
+        { type: LoggerService }
+    ]; };
+    OrganizationListService.ɵprov = i0.ɵɵdefineInjectable({ factory: function OrganizationListService_Factory() { return new OrganizationListService(i0.ɵɵinject(i1.UserResourceService), i0.ɵɵinject(i2.LoggerService)); }, token: OrganizationListService, providedIn: "root" });
+    OrganizationListService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    OrganizationListService.ctorParameters = function () { return [
+        { type: UserResourceService },
+        { type: LoggerService }
+    ]; };
+    return OrganizationListService;
+}());
+export { OrganizationListService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/admin/user-invite/services/user-invite.service.js

@@ -0,0 +1,37 @@
+import { Injectable } from '@angular/core';
+import { ProcessList } from '../../role-assignment/services/ProcessList';
+import { PetriNetResourceService } from '../../../resources/engine-endpoint/petri-net-resource.service';
+import { LoggerService } from '../../../logger/services/logger.service';
+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";
+var UserInviteService = /** @class */ (function () {
+    function UserInviteService(processResources, _log) {
+        this._log = _log;
+        this._processList = new ProcessList(processResources, _log);
+    }
+    Object.defineProperty(UserInviteService.prototype, "processList", {
+        get: function () {
+            return this._processList;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    UserInviteService.ctorParameters = function () { return [
+        { type: PetriNetResourceService },
+        { type: LoggerService }
+    ]; };
+    UserInviteService.ɵprov = i0.ɵɵdefineInjectable({ factory: function UserInviteService_Factory() { return new UserInviteService(i0.ɵɵinject(i1.PetriNetResourceService), i0.ɵɵinject(i2.LoggerService)); }, token: UserInviteService, providedIn: "root" });
+    UserInviteService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    UserInviteService.ctorParameters = function () { return [
+        { type: PetriNetResourceService },
+        { type: LoggerService }
+    ]; };
+    return UserInviteService;
+}());
+export { UserInviteService };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlci1pbnZpdGUuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9hZG1pbi91c2VyLWludml0ZS9zZXJ2aWNlcy91c2VyLWludml0ZS5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFDLFdBQVcsRUFBQyxNQUFNLDRDQUE0QyxDQUFDO0FBQ3ZFLE9BQU8sRUFBQyx1QkFBdUIsRUFBQyxNQUFNLCtEQUErRCxDQUFDO0FBQ3RHLE9BQU8sRUFBQyxhQUFhLEVBQUMsTUFBTSx5Q0FBeUMsQ0FBQzs7OztBQUV0RTtJQU9JLDJCQUFZLGdCQUF5QyxFQUFVLElBQW1CO1FBQW5CLFNBQUksR0FBSixJQUFJLENBQWU7UUFDOUUsSUFBSSxDQUFDLFlBQVksR0FBRyxJQUFJLFdBQVcsQ0FBQyxnQkFBZ0IsRUFBRSxJQUFJLENBQUMsQ0FBQztJQUNoRSxDQUFDO0lBRUQsc0JBQVcsMENBQVc7YUFBdEI7WUFDSSxPQUFPLElBQUksQ0FBQyxZQUFZLENBQUM7UUFDN0IsQ0FBQzs7O09BQUE7O2dCQU42Qix1QkFBdUI7Z0JBQWdCLGFBQWE7Ozs7Z0JBUHJGLFVBQVUsU0FBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkI7OztnQkFMTyx1QkFBdUI7Z0JBQ3ZCLGFBQWE7OzRCQUhyQjtDQW1CQyxBQWRELElBY0M7U0FYWSxpQkFBaUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge1Byb2Nlc3NMaXN0fSBmcm9tICcuLi8uLi9yb2xlLWFzc2lnbm1lbnQvc2VydmljZXMvUHJvY2Vzc0xpc3QnO1xuaW1wb3J0IHtQZXRyaU5ldFJlc291cmNlU2VydmljZX0gZnJvbSAnLi4vLi4vLi4vcmVzb3VyY2VzL2VuZ2luZS1lbmRwb2ludC9wZXRyaS1uZXQtcmVzb3VyY2Uuc2VydmljZSc7XG5pbXBvcnQge0xvZ2dlclNlcnZpY2V9IGZyb20gJy4uLy4uLy4uL2xvZ2dlci9zZXJ2aWNlcy9sb2dnZXIuc2VydmljZSc7XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIFVzZXJJbnZpdGVTZXJ2aWNlIHtcblxuICAgIHByaXZhdGUgcmVhZG9ubHkgX3Byb2Nlc3NMaXN0OiBQcm9jZXNzTGlzdDtcblxuICAgIGNvbnN0cnVjdG9yKHByb2Nlc3NSZXNvdXJjZXM6IFBldHJpTmV0UmVzb3VyY2VTZXJ2aWNlLCBwcml2YXRlIF9sb2c6IExvZ2dlclNlcnZpY2UpIHtcbiAgICAgICAgdGhpcy5fcHJvY2Vzc0xpc3QgPSBuZXcgUHJvY2Vzc0xpc3QocHJvY2Vzc1Jlc291cmNlcywgX2xvZyk7XG4gICAgfVxuXG4gICAgcHVibGljIGdldCBwcm9jZXNzTGlzdCgpOiBQcm9jZXNzTGlzdCB7XG4gICAgICAgIHJldHVybiB0aGlzLl9wcm9jZXNzTGlzdDtcbiAgICB9XG59XG4iXX0=

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

@@ -0,0 +1,4 @@
+export * from './services/allowed-nets.service';
+export * from './services/base-allowed-nets.service';
+export * from './services/factory/allowed-nets-service-factory';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9hbGxvd2VkLW5ldHMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyxpREFBaUQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvYWxsb3dlZC1uZXRzLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zZXJ2aWNlcy9iYXNlLWFsbG93ZWQtbmV0cy5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvZmFjdG9yeS9hbGxvd2VkLW5ldHMtc2VydmljZS1mYWN0b3J5JztcbiJdfQ==

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

@@ -0,0 +1,94 @@
+import { __read, __spread } from "tslib";
+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.
+ */
+var AllowedNetsService = /** @class */ (function () {
+    /**
+     * 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
+     */
+    function AllowedNetsService(allowedNetIdentifiers$, _processService) {
+        var _this = this;
+        this._processService = _processService;
+        this._allowedNets$ = new ReplaySubject(1);
+        this._allowedNetsIdentifiers$ = new ReplaySubject(1);
+        this.subAllowedNets = allowedNetIdentifiers$.pipe(tap(function (identifiers) {
+            _this._allowedNetsIdentifiers$.next(identifiers);
+            _this._allowedNetsIdentifiers = __spread(identifiers);
+        }), map(function (identifiers) { return _this._processService.getNets(identifiers); }), switchMap(function (nets) { return nets; })).subscribe(function (nets) {
+            _this._allowedNets$.next(nets);
+            _this._allowedNets = __spread(nets);
+        });
+    }
+    Object.defineProperty(AllowedNetsService.prototype, "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: function () {
+            return this._allowedNets$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AllowedNetsService.prototype, "allowedNets", {
+        /**
+         * @returns the current value of the allowed nets. If allowed nets are yet to bee set, `undefined` is returned.
+         */
+        get: function () {
+            return this._allowedNets;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AllowedNetsService.prototype, "allowedNetsIdentifiers$", {
+        /**
+         * 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: function () {
+            return this._allowedNetsIdentifiers$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AllowedNetsService.prototype, "allowedNetsIdentifiers", {
+        /**
+         * @returns the current value of the allowed nets identifiers. If allowed nets are yet to bee set, `undefined` is returned.
+         */
+        get: function () {
+            return this._allowedNetsIdentifiers;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AllowedNetsService.prototype.ngOnDestroy = function () {
+        this._allowedNets$.complete();
+        this._allowedNetsIdentifiers$.complete();
+        this.subAllowedNets.unsubscribe();
+    };
+    AllowedNetsService.ctorParameters = function () { return [
+        { type: Observable },
+        { type: ProcessService }
+    ]; };
+    AllowedNetsService.decorators = [
+        { type: Injectable }
+    ];
+    AllowedNetsService.ctorParameters = function () { return [
+        { type: Observable },
+        { type: ProcessService }
+    ]; };
+    return AllowedNetsService;
+}());
+export { AllowedNetsService };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,65 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+var BaseAllowedNetsService = /** @class */ (function () {
+    function BaseAllowedNetsService() {
+        this._baseAllowedNets = new BehaviorSubject([]);
+    }
+    BaseAllowedNetsService.prototype.ngOnDestroy = function () {
+        this._baseAllowedNets.complete();
+        if (this._sub !== undefined) {
+            this._sub.unsubscribe();
+        }
+    };
+    Object.defineProperty(BaseAllowedNetsService.prototype, "allowedNets", {
+        /**
+         * @returns the currently set allowed nets. Returns an empty array if no value was set.
+         */
+        get: function () {
+            return this._baseAllowedNets.value;
+        },
+        /**
+         * Sets the new identifiers of the base allowed nets
+         * @param nets new base net identifiers
+         */
+        set: function (nets) {
+            this._baseAllowedNets.next(nets);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseAllowedNetsService.prototype, "allowedNets$", {
+        /**
+         * @returns an observable that emits the currently set base allowed nets and any subsequent values
+         */
+        get: function () {
+            return this._baseAllowedNets.asObservable();
+        },
+        /**
+         * 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: function (observableNets) {
+            var _this = this;
+            if (this._sub !== undefined) {
+                this._sub.unsubscribe();
+            }
+            this._sub = observableNets.subscribe(function (nets) {
+                _this._baseAllowedNets.next(nets);
+            });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BaseAllowedNetsService.ɵprov = i0.ɵɵdefineInjectable({ factory: function BaseAllowedNetsService_Factory() { return new BaseAllowedNetsService(); }, token: BaseAllowedNetsService, providedIn: "root" });
+    BaseAllowedNetsService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    BaseAllowedNetsService.ctorParameters = function () { return []; };
+    return BaseAllowedNetsService;
+}());
+export { BaseAllowedNetsService };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,132 @@
+import { __read, __spread } from "tslib";
+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) {
+    var 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!");
+    }
+    var nets = __spread(filterField.allowedNets);
+    if (filterField.filterMetadata.inheritAllowedNets) {
+        nets.push.apply(nets, __spread(baseAllowedNets.allowedNets));
+    }
+    var uniqueNets = new Set(nets);
+    return factory.createFromArray(Array.from(uniqueNets));
+}
+/**
+ * Simplifies the creation of {@link AllowedNetsService} instances
+ */
+var AllowedNetsServiceFactory = /** @class */ (function () {
+    function AllowedNetsServiceFactory(_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`
+     */
+    AllowedNetsServiceFactory.prototype.createWithAllNets = function () {
+        return new AllowedNetsService(this._petriNetResource.getAll().pipe(switchMap(function (nets) {
+            if (nets && Array.isArray(nets)) {
+                return of(nets.map(function (n) { return 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
+     */
+    AllowedNetsServiceFactory.prototype.createFromArray = function (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.
+     */
+    AllowedNetsServiceFactory.prototype.createFromConfig = function (webViewPath) {
+        var _a, _b;
+        var 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 + "'");
+        }
+        var 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.
+     */
+    AllowedNetsServiceFactory.prototype.createFromObservable = function (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
+     */
+    AllowedNetsServiceFactory.prototype.createFromFilterCase = function (filterCase) {
+        var 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 = function () { return [
+        { 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 = function () { return [
+        { type: ProcessService },
+        { type: PetriNetResourceService },
+        { type: ConfigurationService },
+        { type: LoggerService }
+    ]; };
+    return AllowedNetsServiceFactory;
+}());
+export { AllowedNetsServiceFactory };
+//# 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":"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","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/esm5/lib/authentication/anonymous/anonymous.service.js

@@ -0,0 +1,73 @@
+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";
+var AnonymousService = /** @class */ (function () {
+    function AnonymousService(_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);
+    }
+    Object.defineProperty(AnonymousService.prototype, "jwtHeader", {
+        get: function () {
+            return this._jwtHeader;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AnonymousService.prototype, "tokenSet", {
+        get: function () {
+            return this._tokenSet.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AnonymousService.prototype.getToken = function () {
+        return this._storage.getItem(this._jwtHeader);
+    };
+    AnonymousService.prototype.setToken = function (token) {
+        this._storage.setItem(this._jwtHeader, token);
+        if (!this._tokenSet.getValue())
+            this._tokenSet.next(true);
+    };
+    AnonymousService.prototype.removeToken = function () {
+        this._storage.removeItem(this._jwtHeader);
+        this._tokenSet.next(false);
+    };
+    AnonymousService.prototype.ngOnDestroy = function () {
+        localStorage.removeItem(this._jwtHeader);
+        this._tokenSet.complete();
+    };
+    AnonymousService.prototype.resolveStorage = function (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 = function () { return [
+        { 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 = function () { return [
+        { type: ConfigurationService }
+    ]; };
+    return AnonymousService;
+}());
+export { AnonymousService };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5vbnltb3VzLnNlcnZpY2UuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvYXV0aGVudGljYXRpb24vYW5vbnltb3VzL2Fub255bW91cy5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxVQUFVLEVBQVksTUFBTSxlQUFlLENBQUM7QUFDcEQsT0FBTyxFQUFDLG9CQUFvQixFQUFDLE1BQU0sMkNBQTJDLENBQUM7QUFDL0UsT0FBTyxFQUFDLFdBQVcsRUFBQyxNQUFNLHlCQUF5QixDQUFDO0FBQ3BELE9BQU8sRUFBQyxlQUFlLEVBQWEsTUFBTSxNQUFNLENBQUM7OztBQUdqRDtJQVVJLDBCQUFzQixPQUE2QjtRQUE3QixZQUFPLEdBQVAsT0FBTyxDQUFzQjtRQUMvQyxJQUFJLENBQUMsVUFBVSxHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztZQUMzRCxJQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsRUFBRSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxnQkFBZ0IsQ0FBQyx5QkFBeUIsQ0FBQztRQUM3RixJQUFJLENBQUMsUUFBUSxHQUFHLElBQUksQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLEVBQUUsQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUM7UUFDaEYsSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLGVBQWUsQ0FBVSxLQUFLLENBQUMsQ0FBQztJQUN6RCxDQUFDO0lBRUQsc0JBQUksdUNBQVM7YUFBYjtZQUNJLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQztRQUMzQixDQUFDOzs7T0FBQTtJQUVELHNCQUFJLHNDQUFRO2FBQVo7WUFDSSxPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsWUFBWSxFQUFFLENBQUM7UUFDekMsQ0FBQzs7O09BQUE7SUFFTSxtQ0FBUSxHQUFmO1FBQ0ksT0FBTyxJQUFJLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUM7SUFDbEQsQ0FBQztJQUVNLG1DQUFRLEdBQWYsVUFBZ0IsS0FBYTtRQUN6QixJQUFJLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsVUFBVSxFQUFFLEtBQUssQ0FBQyxDQUFDO1FBQzlDLElBQUksQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLFFBQVEsRUFBRTtZQUMxQixJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUNsQyxDQUFDO0lBRU0sc0NBQVcsR0FBbEI7UUFDSSxJQUFJLENBQUMsUUFBUSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDMUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDL0IsQ0FBQztJQUVELHNDQUFXLEdBQVg7UUFDSSxZQUFZLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUN6QyxJQUFJLENBQUMsU0FBUyxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQzlCLENBQUM7SUFFUyx5Q0FBYyxHQUF4QixVQUF5QixPQUFlO1FBQ3BDLFFBQVEsT0FBTyxFQUFFO1lBQ2IsS0FBSyxPQUFPO2dCQUNSLE9BQU8sWUFBWSxDQUFDO1lBQ3hCLEtBQUssU0FBUztnQkFDVixPQUFPLGNBQWMsQ0FBQztZQUMxQixLQUFLLE1BQU07Z0JBQ1AsT0FBTyxJQUFJLFdBQVcsRUFBRSxDQUFDO1lBQzdCO2dCQUNJLE9BQU8sWUFBWSxDQUFDO1NBQzNCO0lBQ0wsQ0FBQztJQW5Ec0IsMENBQXlCLEdBQUcsYUFBYSxDQUFDOztnQkFLbEMsb0JBQW9COzs7O2dCQVZ0RCxVQUFVLFNBQUM7b0JBQ1IsVUFBVSxFQUFFLE1BQU07aUJBQ3JCOzs7Z0JBUE8sb0JBQW9COzsyQkFENUI7Q0ErREMsQUF6REQsSUF5REM7U0F0RFksZ0JBQWdCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtJbmplY3RhYmxlLCBPbkRlc3Ryb3l9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtDb25maWd1cmF0aW9uU2VydmljZX0gZnJvbSAnLi4vLi4vY29uZmlndXJhdGlvbi9jb25maWd1cmF0aW9uLnNlcnZpY2UnO1xuaW1wb3J0IHtOdWxsU3RvcmFnZX0gZnJvbSAnLi4vc2Vzc2lvbi9udWxsLXN0b3JhZ2UnO1xuaW1wb3J0IHtCZWhhdmlvclN1YmplY3QsIE9ic2VydmFibGV9IGZyb20gJ3J4anMnO1xuXG5cbkBJbmplY3RhYmxlKHtcbiAgICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgQW5vbnltb3VzU2VydmljZSBpbXBsZW1lbnRzIE9uRGVzdHJveSB7XG5cbiAgICBwdWJsaWMgc3RhdGljIHJlYWRvbmx5IEpXVF9CRUFSRVJfSEVBREVSX0RFRkFVTFQgPSAnWC1Kd3QtVG9rZW4nO1xuICAgIHByb3RlY3RlZCByZWFkb25seSBfand0SGVhZGVyOiBzdHJpbmc7XG4gICAgcHJvdGVjdGVkIF9zdG9yYWdlOiBTdG9yYWdlO1xuICAgIHByb3RlY3RlZCBfdG9rZW5TZXQ6IEJlaGF2aW9yU3ViamVjdDxib29sZWFuPjtcblxuICAgIGNvbnN0cnVjdG9yKHByb3RlY3RlZCBfY29uZmlnOiBDb25maWd1cmF0aW9uU2VydmljZSkge1xuICAgICAgICB0aGlzLl9qd3RIZWFkZXIgPSB0aGlzLl9jb25maWcuZ2V0KCkucHJvdmlkZXJzLmF1dGguand0QmVhcmVyID9cbiAgICAgICAgICAgIHRoaXMuX2NvbmZpZy5nZXQoKS5wcm92aWRlcnMuYXV0aC5qd3RCZWFyZXIgOiBBbm9ueW1vdXNTZXJ2aWNlLkpXVF9CRUFSRVJfSEVBREVSX0RFRkFVTFQ7XG4gICAgICAgIHRoaXMuX3N0b3JhZ2UgPSB0aGlzLnJlc29sdmVTdG9yYWdlKHRoaXMuX2NvbmZpZy5nZXQoKS5wcm92aWRlcnMuYXV0aFsnbG9jYWwnXSk7XG4gICAgICAgIHRoaXMuX3Rva2VuU2V0ID0gbmV3IEJlaGF2aW9yU3ViamVjdDxib29sZWFuPihmYWxzZSk7XG4gICAgfVxuXG4gICAgZ2V0IGp3dEhlYWRlcigpOiBzdHJpbmcge1xuICAgICAgICByZXR1cm4gdGhpcy5fand0SGVhZGVyO1xuICAgIH1cblxuICAgIGdldCB0b2tlblNldCgpOiBPYnNlcnZhYmxlPGJvb2xlYW4+IHtcbiAgICAgICAgcmV0dXJuIHRoaXMuX3Rva2VuU2V0LmFzT2JzZXJ2YWJsZSgpO1xuICAgIH1cblxuICAgIHB1YmxpYyBnZXRUb2tlbigpOiBzdHJpbmcge1xuICAgICAgICByZXR1cm4gdGhpcy5fc3RvcmFnZS5nZXRJdGVtKHRoaXMuX2p3dEhlYWRlcik7XG4gICAgfVxuXG4gICAgcHVibGljIHNldFRva2VuKHRva2VuOiBzdHJpbmcpOiB2b2lkIHtcbiAgICAgICAgdGhpcy5fc3RvcmFnZS5zZXRJdGVtKHRoaXMuX2p3dEhlYWRlciwgdG9rZW4pO1xuICAgICAgICBpZiAoIXRoaXMuX3Rva2VuU2V0LmdldFZhbHVlKCkpXG4gICAgICAgICAgICB0aGlzLl90b2tlblNldC5uZXh0KHRydWUpO1xuICAgIH1cblxuICAgIHB1YmxpYyByZW1vdmVUb2tlbigpOiB2b2lkIHtcbiAgICAgICAgdGhpcy5fc3RvcmFnZS5yZW1vdmVJdGVtKHRoaXMuX2p3dEhlYWRlcik7XG4gICAgICAgIHRoaXMuX3Rva2VuU2V0Lm5leHQoZmFsc2UpO1xuICAgIH1cblxuICAgIG5nT25EZXN0cm95KCk6IHZvaWQge1xuICAgICAgICBsb2NhbFN0b3JhZ2UucmVtb3ZlSXRlbSh0aGlzLl9qd3RIZWFkZXIpO1xuICAgICAgICB0aGlzLl90b2tlblNldC5jb21wbGV0ZSgpO1xuICAgIH1cblxuICAgIHByb3RlY3RlZCByZXNvbHZlU3RvcmFnZShzdG9yYWdlOiBzdHJpbmcpOiBhbnkge1xuICAgICAgICBzd2l0Y2ggKHN0b3JhZ2UpIHtcbiAgICAgICAgICAgIGNhc2UgJ2xvY2FsJzpcbiAgICAgICAgICAgICAgICByZXR1cm4gbG9jYWxTdG9yYWdlO1xuICAgICAgICAgICAgY2FzZSAnc2Vzc2lvbic6XG4gICAgICAgICAgICAgICAgcmV0dXJuIHNlc3Npb25TdG9yYWdlO1xuICAgICAgICAgICAgY2FzZSAnbnVsbCc6XG4gICAgICAgICAgICAgICAgcmV0dXJuIG5ldyBOdWxsU3RvcmFnZSgpO1xuICAgICAgICAgICAgZGVmYXVsdDpcbiAgICAgICAgICAgICAgICByZXR1cm4gbG9jYWxTdG9yYWdlO1xuICAgICAgICB9XG4gICAgfVxufVxuIl19

package/esm5/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) {
+    var auth = config.get().providers.auth;
+    if (!auth || !auth.authentication) {
+        return new NullAuthenticationService();
+    }
+    var 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/esm5/lib/authentication/authentication.module.js

@@ -0,0 +1,36 @@
+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';
+var ɵ0 = authenticationServiceFactory;
+var AuthenticationModule = /** @class */ (function () {
+    function 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]
+                },] }
+    ];
+    return AuthenticationModule;
+}());
+export { AuthenticationModule };
+export { ɵ0 };
+//# sourceMappingURL=data:application/json;base64,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