@netgrif/components-core 6.0.1

package/esm5/lib/authentication/session/services/session.service.js

@@ -0,0 +1,193 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, throwError } from 'rxjs';
+import { ConfigurationService } from '../../../configuration/configuration.service';
+import { NullStorage } from '../null-storage';
+import { HttpClient, HttpErrorResponse, HttpHeaders } from '@angular/common/http';
+import { LoggerService } from '../../../logger/services/logger.service';
+import { catchError, map, take, tap } from 'rxjs/operators';
+import { LoadingEmitter } from '../../../utility/loading-emitter';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../configuration/configuration.service";
+import * as i2 from "../../../logger/services/logger.service";
+import * as i3 from "@angular/common/http";
+var SessionService = /** @class */ (function () {
+    function SessionService(_config, _log, _http) {
+        var _this = this;
+        this._config = _config;
+        this._log = _log;
+        this._http = _http;
+        // const sessionConfig = this._config.get().providers.auth.session;
+        this._storage = this.resolveStorage(this._config.get().providers.auth['sessionStore']);
+        this._sessionHeader = this._config.get().providers.auth.sessionBearer ?
+            this._config.get().providers.auth.sessionBearer : SessionService.SESSION_BEARER_HEADER_DEFAULT;
+        this._session$ = new BehaviorSubject(null);
+        this._verified = false;
+        this._verifying = new LoadingEmitter();
+        this._initialized = new LoadingEmitter(false);
+        setTimeout(function () {
+            _this.load();
+        });
+    }
+    SessionService.prototype.ngOnDestroy = function () {
+        this._session$.complete();
+        this._verifying.complete();
+    };
+    Object.defineProperty(SessionService.prototype, "session$", {
+        get: function () {
+            return this._session$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SessionService.prototype, "sessionToken", {
+        get: function () {
+            return this._session$.getValue();
+        },
+        set: function (sessionToken) {
+            this._session$.next(sessionToken);
+            this._storage.setItem(SessionService.SESSION_TOKEN_STORAGE_KEY, btoa(SessionService.SESSION_TOKEN_STORAGE_KEY + ':' + sessionToken));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SessionService.prototype, "sessionHeader", {
+        get: function () {
+            return this._sessionHeader;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SessionService.prototype, "verified", {
+        get: function () {
+            return this._verified;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SessionService.prototype, "verifying", {
+        get: function () {
+            return this._verifying.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SessionService.prototype, "isVerifying", {
+        get: function () {
+            return this._verifying.isActive;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SessionService.prototype, "isInitialized", {
+        get: function () {
+            return this._initialized.isActive;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(SessionService.prototype, "initializing", {
+        get: function () {
+            return this._initialized.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    SessionService.prototype.setVerifiedToken = function (sessionToken) {
+        this._log.warn('Session token without explicit verification was set');
+        this._verified = true;
+        this.sessionToken = sessionToken;
+    };
+    SessionService.prototype.clear = function () {
+        this._verified = false;
+        this.sessionToken = '';
+        this._storage.removeItem(SessionService.SESSION_TOKEN_STORAGE_KEY);
+    };
+    SessionService.prototype.verify = function (token) {
+        var _this = this;
+        this._verifying.on();
+        token = !!token ? token : this.sessionToken;
+        var authConfig = this._config.get().providers.auth;
+        var url = authConfig.address;
+        url += authConfig.endpoints && authConfig.endpoints['verification'] ? authConfig.endpoints['verification'] :
+            (authConfig.endpoints && authConfig.endpoints['login'] ? authConfig.endpoints['login'] : '');
+        if (!url || url === authConfig.address) {
+            this.clear();
+            this._verifying.off();
+            this._initialized.on();
+            return throwError(new Error('Cannot verify session token. ' +
+                'Login URL is not defined in the config [nae.providers.auth.endpoints.login].'));
+        }
+        else {
+            return this._http.get(url, {
+                headers: new HttpHeaders().set(this._sessionHeader, token),
+                observe: 'response'
+            }).pipe(catchError(function (error) {
+                if (error instanceof HttpErrorResponse && error.status === 401) {
+                    _this._log.warn('Authentication token is invalid. Clearing session token');
+                    _this.clear();
+                }
+                _this._verifying.off();
+                _this._initialized.on();
+                return throwError(error);
+            }), map(function (response) {
+                _this._log.debug(response.body.success);
+                _this._verified = true;
+                _this._initialized.on();
+                _this.sessionToken = token;
+                return true;
+            }), tap(function (_) { return _this._verifying.off(); }));
+        }
+    };
+    SessionService.prototype.load = function () {
+        var _this = this;
+        var token = this._storage.getItem(SessionService.SESSION_TOKEN_STORAGE_KEY);
+        this._verified = false;
+        if (token) {
+            token = this.resolveToken(token);
+            this.sessionToken = token;
+            this.verify(token).pipe(take(1)).subscribe(function (ver) {
+                _this._log.debug('Token ' + token + ' verified status: ' + ver);
+            });
+        }
+        else {
+            this._initialized.on();
+        }
+        return '';
+    };
+    SessionService.prototype.resolveToken = function (raw) {
+        return raw ? atob(raw).split(':')[1] : '';
+    };
+    SessionService.prototype.resolveStorage = function (storage) {
+        switch (storage) {
+            case 'local':
+                return localStorage;
+            case 'session':
+                return sessionStorage;
+            case 'null':
+                return new NullStorage();
+            default:
+                return localStorage;
+        }
+    };
+    SessionService.SESSION_TOKEN_STORAGE_KEY = 'naet';
+    SessionService.SESSION_BEARER_HEADER_DEFAULT = 'X-Auth-Token';
+    SessionService.ctorParameters = function () { return [
+        { type: ConfigurationService },
+        { type: LoggerService },
+        { type: HttpClient }
+    ]; };
+    SessionService.ɵprov = i0.ɵɵdefineInjectable({ factory: function SessionService_Factory() { return new SessionService(i0.ɵɵinject(i1.ConfigurationService), i0.ɵɵinject(i2.LoggerService), i0.ɵɵinject(i3.HttpClient)); }, token: SessionService, providedIn: "root" });
+    SessionService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    SessionService.ctorParameters = function () { return [
+        { type: ConfigurationService },
+        { type: LoggerService },
+        { type: HttpClient }
+    ]; };
+    return SessionService;
+}());
+export { SessionService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"session.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/authentication/session/services/session.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAY,MAAM,eAAe,CAAC;AACpD,OAAO,EAAC,eAAe,EAAc,UAAU,EAAC,MAAM,MAAM,CAAC;AAC7D,OAAO,EAAC,oBAAoB,EAAC,MAAM,8CAA8C,CAAC;AAClF,OAAO,EAAC,WAAW,EAAC,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAC,UAAU,EAAE,iBAAiB,EAAE,WAAW,EAAC,MAAM,sBAAsB,CAAC;AAChF,OAAO,EAAC,aAAa,EAAC,MAAM,yCAAyC,CAAC;AACtE,OAAO,EAAC,UAAU,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAC,MAAM,gBAAgB,CAAC;AAE1D,OAAO,EAAC,cAAc,EAAC,MAAM,kCAAkC,CAAC;;;;;AAEhE;IAeI,wBAAoB,OAA6B,EAAU,IAAmB,EAAU,KAAiB;QAAzG,iBAYC;QAZmB,YAAO,GAAP,OAAO,CAAsB;QAAU,SAAI,GAAJ,IAAI,CAAe;QAAU,UAAK,GAAL,KAAK,CAAY;QACrG,mEAAmE;QACnE,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC;QACvF,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YACnE,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,cAAc,CAAC,6BAA6B,CAAC;QACnG,IAAI,CAAC,SAAS,GAAG,IAAI,eAAe,CAAS,IAAI,CAAC,CAAC;QACnD,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACvB,IAAI,CAAC,UAAU,GAAG,IAAI,cAAc,EAAE,CAAC;QACvC,IAAI,CAAC,YAAY,GAAG,IAAI,cAAc,CAAC,KAAK,CAAC,CAAC;QAC9C,UAAU,CAAC;YACP,KAAI,CAAC,IAAI,EAAE,CAAC;QAChB,CAAC,CAAC,CAAC;IACP,CAAC;IAED,oCAAW,GAAX;QACI,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;QAC1B,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;IAC/B,CAAC;IAED,sBAAI,oCAAQ;aAAZ;YACI,OAAO,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,CAAC;QACzC,CAAC;;;OAAA;IAED,sBAAI,wCAAY;aAMhB;YACI,OAAO,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;QACrC,CAAC;aARD,UAAiB,YAAoB;YACjC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YAClC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,cAAc,CAAC,yBAAyB,EAC1D,IAAI,CAAC,cAAc,CAAC,yBAAyB,GAAG,GAAG,GAAG,YAAY,CAAC,CAAC,CAAC;QAC7E,CAAC;;;OAAA;IAMD,sBAAI,yCAAa;aAAjB;YACI,OAAO,IAAI,CAAC,cAAc,CAAC;QAC/B,CAAC;;;OAAA;IAED,sBAAI,oCAAQ;aAAZ;YACI,OAAO,IAAI,CAAC,SAAS,CAAC;QAC1B,CAAC;;;OAAA;IAED,sBAAI,qCAAS;aAAb;YACI,OAAO,IAAI,CAAC,UAAU,CAAC,YAAY,EAAE,CAAC;QAC1C,CAAC;;;OAAA;IAED,sBAAI,uCAAW;aAAf;YACI,OAAO,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC;QACpC,CAAC;;;OAAA;IAED,sBAAI,yCAAa;aAAjB;YACI,OAAO,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC;QACtC,CAAC;;;OAAA;IAED,sBAAI,wCAAY;aAAhB;YACI,OAAO,IAAI,CAAC,YAAY,CAAC,YAAY,EAAE,CAAC;QAC5C,CAAC;;;OAAA;IAEM,yCAAgB,GAAvB,UAAwB,YAAoB;QACxC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,qDAAqD,CAAC,CAAC;QACtE,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;IACrC,CAAC;IAEM,8BAAK,GAAZ;QACI,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACvB,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;QACvB,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,cAAc,CAAC,yBAAyB,CAAC,CAAC;IACvE,CAAC;IAEM,+BAAM,GAAb,UAAc,KAAc;QAA5B,iBAsCC;QArCG,IAAI,CAAC,UAAU,CAAC,EAAE,EAAE,CAAC;QACrB,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC;QAE5C,IAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC;QACrD,IAAI,GAAG,GAAG,UAAU,CAAC,OAAO,CAAC;QAC7B,GAAG,IAAI,UAAU,CAAC,SAAS,IAAI,UAAU,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC,CAAC;YACxG,CAAC,UAAU,CAAC,SAAS,IAAI,UAAU,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QACjG,IAAI,CAAC,GAAG,IAAI,GAAG,KAAK,UAAU,CAAC,OAAO,EAAE;YACpC,IAAI,CAAC,KAAK,EAAE,CAAC;YACb,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC;YACtB,IAAI,CAAC,YAAY,CAAC,EAAE,EAAE,CAAC;YACvB,OAAO,UAAU,CAAC,IAAI,KAAK,CAAC,+BAA+B;gBACvD,8EAA8E,CAAC,CAAC,CAAC;SACxF;aAAM;YACH,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAkB,GAAG,EAAE;gBACxC,OAAO,EAAE,IAAI,WAAW,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,cAAc,EAAE,KAAK,CAAC;gBAC1D,OAAO,EAAE,UAAU;aACtB,CAAC,CAAC,IAAI,CACH,UAAU,CAAC,UAAA,KAAK;gBACZ,IAAI,KAAK,YAAY,iBAAiB,IAAI,KAAK,CAAC,MAAM,KAAK,GAAG,EAAE;oBAC5D,KAAI,CAAC,IAAI,CAAC,IAAI,CAAC,yDAAyD,CAAC,CAAC;oBAC1E,KAAI,CAAC,KAAK,EAAE,CAAC;iBAChB;gBACD,KAAI,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC;gBACtB,KAAI,CAAC,YAAY,CAAC,EAAE,EAAE,CAAC;gBACvB,OAAO,UAAU,CAAC,KAAK,CAAC,CAAC;YAC7B,CAAC,CAAC,EACF,GAAG,CAAC,UAAA,QAAQ;gBACR,KAAI,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBACvC,KAAI,CAAC,SAAS,GAAG,IAAI,CAAC;gBACtB,KAAI,CAAC,YAAY,CAAC,EAAE,EAAE,CAAC;gBACvB,KAAI,CAAC,YAAY,GAAG,KAAK,CAAC;gBAC1B,OAAO,IAAI,CAAC;YAChB,CAAC,CAAC,EACF,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,KAAI,CAAC,UAAU,CAAC,GAAG,EAAE,EAArB,CAAqB,CAAC,CAClC,CAAC;SACL;IACL,CAAC;IAES,6BAAI,GAAd;QAAA,iBAaC;QAZG,IAAI,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,cAAc,CAAC,yBAAyB,CAAC,CAAC;QAC5E,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACvB,IAAI,KAAK,EAAE;YACP,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;YACjC,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;YAC1B,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,UAAA,GAAG;gBAC1C,KAAI,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,KAAK,GAAG,oBAAoB,GAAG,GAAG,CAAC,CAAC;YACnE,CAAC,CAAC,CAAC;SACN;aAAM;YACH,IAAI,CAAC,YAAY,CAAC,EAAE,EAAE,CAAC;SAC1B;QACD,OAAO,EAAE,CAAC;IACd,CAAC;IAEO,qCAAY,GAApB,UAAqB,GAAW;QAC5B,OAAO,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAC9C,CAAC;IAEO,uCAAc,GAAtB,UAAuB,OAAe;QAClC,QAAQ,OAAO,EAAE;YACb,KAAK,OAAO;gBACR,OAAO,YAAY,CAAC;YACxB,KAAK,SAAS;gBACV,OAAO,cAAc,CAAC;YAC1B,KAAK,MAAM;gBACP,OAAO,IAAI,WAAW,EAAE,CAAC;YAC7B;gBACI,OAAO,YAAY,CAAC;SAC3B;IACL,CAAC;IArJsB,wCAAyB,GAAG,MAAM,CAAC;IACnC,4CAA6B,GAAG,cAAc,CAAC;;gBASzC,oBAAoB;gBAAgB,aAAa;gBAAiB,UAAU;;;;gBAf5G,UAAU,SAAC;oBACR,UAAU,EAAE,MAAM;iBACrB;;;gBAVO,oBAAoB;gBAGpB,aAAa;gBADb,UAAU;;yBAJlB;CAqKC,AA3JD,IA2JC;SAxJY,cAAc","sourcesContent":["import {Injectable, OnDestroy} from '@angular/core';\nimport {BehaviorSubject, Observable, throwError} from 'rxjs';\nimport {ConfigurationService} from '../../../configuration/configuration.service';\nimport {NullStorage} from '../null-storage';\nimport {HttpClient, HttpErrorResponse, HttpHeaders} from '@angular/common/http';\nimport {LoggerService} from '../../../logger/services/logger.service';\nimport {catchError, map, take, tap} from 'rxjs/operators';\nimport {MessageResource} from '../../../resources/interface/message-resource';\nimport {LoadingEmitter} from '../../../utility/loading-emitter';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class SessionService implements OnDestroy {\n\n    public static readonly SESSION_TOKEN_STORAGE_KEY = 'naet';\n    public static readonly SESSION_BEARER_HEADER_DEFAULT = 'X-Auth-Token';\n\n    private _session$: BehaviorSubject<string>;\n    private _storage: Storage;\n    private readonly _sessionHeader: string;\n    private _verified: boolean;\n    private _verifying: LoadingEmitter;\n    private _initialized: LoadingEmitter;\n\n    constructor(private _config: ConfigurationService, private _log: LoggerService, private _http: HttpClient) {\n        // const sessionConfig = this._config.get().providers.auth.session;\n        this._storage = this.resolveStorage(this._config.get().providers.auth['sessionStore']);\n        this._sessionHeader = this._config.get().providers.auth.sessionBearer ?\n            this._config.get().providers.auth.sessionBearer : SessionService.SESSION_BEARER_HEADER_DEFAULT;\n        this._session$ = new BehaviorSubject<string>(null);\n        this._verified = false;\n        this._verifying = new LoadingEmitter();\n        this._initialized = new LoadingEmitter(false);\n        setTimeout(() => {\n            this.load();\n        });\n    }\n\n    ngOnDestroy(): void {\n        this._session$.complete();\n        this._verifying.complete();\n    }\n\n    get session$(): Observable<string> {\n        return this._session$.asObservable();\n    }\n\n    set sessionToken(sessionToken: string) {\n        this._session$.next(sessionToken);\n        this._storage.setItem(SessionService.SESSION_TOKEN_STORAGE_KEY,\n            btoa(SessionService.SESSION_TOKEN_STORAGE_KEY + ':' + sessionToken));\n    }\n\n    get sessionToken(): string {\n        return this._session$.getValue();\n    }\n\n    get sessionHeader(): string {\n        return this._sessionHeader;\n    }\n\n    get verified(): boolean {\n        return this._verified;\n    }\n\n    get verifying(): Observable<boolean> {\n        return this._verifying.asObservable();\n    }\n\n    get isVerifying(): boolean {\n        return this._verifying.isActive;\n    }\n\n    get isInitialized(): boolean {\n        return this._initialized.isActive;\n    }\n\n    get initializing(): Observable<boolean> {\n        return this._initialized.asObservable();\n    }\n\n    public setVerifiedToken(sessionToken: string) {\n        this._log.warn('Session token without explicit verification was set');\n        this._verified = true;\n        this.sessionToken = sessionToken;\n    }\n\n    public clear(): void {\n        this._verified = false;\n        this.sessionToken = '';\n        this._storage.removeItem(SessionService.SESSION_TOKEN_STORAGE_KEY);\n    }\n\n    public verify(token?: string): Observable<boolean> {\n        this._verifying.on();\n        token = !!token ? token : this.sessionToken;\n\n        const authConfig = this._config.get().providers.auth;\n        let url = authConfig.address;\n        url += authConfig.endpoints && authConfig.endpoints['verification'] ? authConfig.endpoints['verification'] :\n            (authConfig.endpoints && authConfig.endpoints['login'] ? authConfig.endpoints['login'] : '');\n        if (!url || url === authConfig.address) {\n            this.clear();\n            this._verifying.off();\n            this._initialized.on();\n            return throwError(new Error('Cannot verify session token. ' +\n                'Login URL is not defined in the config [nae.providers.auth.endpoints.login].'));\n        } else {\n            return this._http.get<MessageResource>(url, {\n                headers: new HttpHeaders().set(this._sessionHeader, token),\n                observe: 'response'\n            }).pipe(\n                catchError(error => {\n                    if (error instanceof HttpErrorResponse && error.status === 401) {\n                        this._log.warn('Authentication token is invalid. Clearing session token');\n                        this.clear();\n                    }\n                    this._verifying.off();\n                    this._initialized.on();\n                    return throwError(error);\n                }),\n                map(response => {\n                    this._log.debug(response.body.success);\n                    this._verified = true;\n                    this._initialized.on();\n                    this.sessionToken = token;\n                    return true;\n                }),\n                tap(_ => this._verifying.off())\n            );\n        }\n    }\n\n    protected load(): string {\n        let token = this._storage.getItem(SessionService.SESSION_TOKEN_STORAGE_KEY);\n        this._verified = false;\n        if (token) {\n            token = this.resolveToken(token);\n            this.sessionToken = token;\n            this.verify(token).pipe(take(1)).subscribe(ver => {\n                this._log.debug('Token ' + token + ' verified status: ' + ver);\n            });\n        } else {\n            this._initialized.on();\n        }\n        return '';\n    }\n\n    private resolveToken(raw: string): string {\n        return raw ? atob(raw).split(':')[1] : '';\n    }\n\n    private resolveStorage(storage: string): any {\n        switch (storage) {\n            case 'local':\n                return localStorage;\n            case 'session':\n                return sessionStorage;\n            case 'null':\n                return new NullStorage();\n            default:\n                return localStorage;\n        }\n    }\n}\n"]}

package/esm5/lib/authentication/sign-up/models/user-invitation-request.js

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

package/esm5/lib/authentication/sign-up/models/user-registration-request.js

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

package/esm5/lib/authentication/sign-up/public-api.js

@@ -0,0 +1,8 @@
+/* MODULES */
+export * from './sign-up.module';
+/* SERVICES */
+export * from './services/sign-up.service';
+/* MODELS */
+export * from './models/user-invitation-request';
+export * from './models/user-registration-request';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9hdXRoZW50aWNhdGlvbi9zaWduLXVwL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsYUFBYTtBQUNiLGNBQWMsa0JBQWtCLENBQUM7QUFFakMsY0FBYztBQUNkLGNBQWMsNEJBQTRCLENBQUM7QUFFM0MsWUFBWTtBQUNaLGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyxvQ0FBb0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIlxuLyogTU9EVUxFUyAqL1xuZXhwb3J0ICogZnJvbSAnLi9zaWduLXVwLm1vZHVsZSc7XG5cbi8qIFNFUlZJQ0VTICovXG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL3NpZ24tdXAuc2VydmljZSc7XG5cbi8qIE1PREVMUyAqL1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMvdXNlci1pbnZpdGF0aW9uLXJlcXVlc3QnO1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMvdXNlci1yZWdpc3RyYXRpb24tcmVxdWVzdCc7XG4iXX0=

package/esm5/lib/authentication/sign-up/services/sign-up.service.js

@@ -0,0 +1,107 @@
+import { Injectable } from '@angular/core';
+import { LoggerService } from '../../../logger/services/logger.service';
+import { ConfigurationService } from '../../../configuration/configuration.service';
+import { HttpClient } from '@angular/common/http';
+import { switchMap } from 'rxjs/operators';
+import { SignUpModule } from '../sign-up.module';
+import { processMessageResponse } from '../../../utility/process-message-response';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../configuration/configuration.service";
+import * as i2 from "@angular/common/http";
+import * as i3 from "../../../logger/services/logger.service";
+import * as i4 from "../sign-up.module";
+var SignUpService = /** @class */ (function () {
+    function SignUpService(_config, _http, _log) {
+        this._config = _config;
+        this._http = _http;
+        this._log = _log;
+        var authAddress = _config.get().providers.auth.address;
+        if (!authAddress) {
+            throw new Error('Authentication provider address is not set!');
+        }
+        this._signUpUrl = this.resolveEndpoint('signup', authAddress);
+        this._verifyUrl = this.resolveEndpoint('verify', authAddress);
+        this._inviteUrl = this.resolveEndpoint('invite', authAddress);
+        this._resetUrl = this.resolveEndpoint('reset', authAddress);
+        this._recoverUrl = this.resolveEndpoint('recover', authAddress);
+    }
+    SignUpService.prototype.signup = function (newUser) {
+        if (!this._signUpUrl) {
+            throw new Error('SingUp URL is not set in authentication provider endpoints!');
+        }
+        newUser.password = btoa(newUser.password);
+        return this._http.post(this._signUpUrl, newUser).pipe(switchMap(processMessageResponse));
+    };
+    SignUpService.prototype.invite = function (invitation) {
+        if (!this._inviteUrl) {
+            throw new Error('Invite URL is not set in authentication provider endpoints!');
+        }
+        if (!invitation.groups) {
+            invitation.groups = [];
+        }
+        if (!invitation.processRoles) {
+            invitation.processRoles = [];
+        }
+        return this._http.post(this._inviteUrl, invitation).pipe(switchMap(processMessageResponse));
+    };
+    SignUpService.prototype.resetPassword = function (email) {
+        if (!this._resetUrl) {
+            throw new Error('Reset URL is not set in authentication provider endpoints!');
+        }
+        return this._http.post(this._resetUrl, email).pipe(switchMap(processMessageResponse));
+    };
+    SignUpService.prototype.recoverPassword = function (token, password) {
+        if (!this._recoverUrl) {
+            throw new Error('Recover URL is not set in authentication provider endpoints!');
+        }
+        var request = {
+            token: token,
+            password: btoa(password),
+            email: '',
+            name: '',
+            surname: ''
+        };
+        return this._http.post(this._recoverUrl, request).pipe(switchMap(processMessageResponse));
+    };
+    SignUpService.prototype.verify = function (token) {
+        if (!this._verifyUrl) {
+            throw new Error('Verify URL is not set in authentication provider endpoints!');
+        }
+        return this._http.post(this._verifyUrl, token).pipe(switchMap(processMessageResponse));
+    };
+    /**
+     * @param endpointKey the attribute name of the endpoint address in `nae.json`
+     * @param baseUrl the base of the endpoint URL. Content resolved by key from `nae.json` is appended to the URL provided by this argument
+     * @returns the endpoint address or `undefined` if such endpoint is not defined in `nae.json`
+     */
+    SignUpService.prototype.resolveEndpoint = function (endpointKey, baseUrl) {
+        var config = this._config.get();
+        if (!config
+            || !config.providers
+            || !config.providers.auth
+            || !config.providers.auth.endpoints
+            || !config.providers.auth.endpoints[endpointKey]) {
+            return undefined;
+        }
+        return baseUrl + config.providers.auth.endpoints[endpointKey];
+    };
+    SignUpService.ctorParameters = function () { return [
+        { type: ConfigurationService },
+        { type: HttpClient },
+        { type: LoggerService }
+    ]; };
+    SignUpService.ɵprov = i0.ɵɵdefineInjectable({ factory: function SignUpService_Factory() { return new SignUpService(i0.ɵɵinject(i1.ConfigurationService), i0.ɵɵinject(i2.HttpClient), i0.ɵɵinject(i3.LoggerService)); }, token: SignUpService, providedIn: i4.SignUpModule });
+    SignUpService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: SignUpModule
+                },] }
+    ];
+    SignUpService.ctorParameters = function () { return [
+        { type: ConfigurationService },
+        { type: HttpClient },
+        { type: LoggerService }
+    ]; };
+    return SignUpService;
+}());
+export { SignUpService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sign-up.service.js","sourceRoot":"ng://@netgrif/components-core/","sources":["lib/authentication/sign-up/services/sign-up.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Injectable} from '@angular/core';\nimport {LoggerService} from '../../../logger/services/logger.service';\nimport {ConfigurationService} from '../../../configuration/configuration.service';\nimport {HttpClient} from '@angular/common/http';\nimport {Observable} from 'rxjs';\nimport {UserRegistrationRequest} from '../models/user-registration-request';\nimport {MessageResource} from '../../../resources/interface/message-resource';\nimport {switchMap} from 'rxjs/operators';\nimport {UserInvitationRequest} from '../models/user-invitation-request';\nimport {SignUpModule} from '../sign-up.module';\nimport {processMessageResponse} from '../../../utility/process-message-response';\n\n@Injectable({\n    providedIn: SignUpModule\n})\nexport class SignUpService {\n\n    protected readonly _signUpUrl: string;\n    protected readonly _verifyUrl: string;\n    protected readonly _inviteUrl: string;\n    protected readonly _resetUrl: string;\n    protected readonly _recoverUrl: string;\n\n    constructor(protected _config: ConfigurationService, protected _http: HttpClient, protected _log: LoggerService) {\n        const authAddress = _config.get().providers.auth.address;\n        if (!authAddress) {\n            throw new Error('Authentication provider address is not set!');\n        }\n        this._signUpUrl = this.resolveEndpoint('signup', authAddress);\n        this._verifyUrl = this.resolveEndpoint('verify', authAddress);\n        this._inviteUrl = this.resolveEndpoint('invite', authAddress);\n        this._resetUrl = this.resolveEndpoint('reset', authAddress);\n        this._recoverUrl = this.resolveEndpoint('recover', authAddress);\n    }\n\n    public signup(newUser: UserRegistrationRequest): Observable<MessageResource> {\n        if (!this._signUpUrl) {\n            throw new Error('SingUp URL is not set in authentication provider endpoints!');\n        }\n        newUser.password = btoa(newUser.password);\n        return this._http.post<MessageResource>(this._signUpUrl, newUser).pipe(\n            switchMap(processMessageResponse)\n        );\n    }\n\n    public invite(invitation: UserInvitationRequest): Observable<MessageResource> {\n        if (!this._inviteUrl) {\n            throw new Error('Invite URL is not set in authentication provider endpoints!');\n        }\n        if (!invitation.groups) {\n            invitation.groups = [];\n        }\n        if (!invitation.processRoles) {\n            invitation.processRoles = [];\n        }\n        return this._http.post<MessageResource>(this._inviteUrl, invitation).pipe(\n            switchMap(processMessageResponse)\n        );\n    }\n\n    public resetPassword(email: string): Observable<MessageResource> {\n        if (!this._resetUrl) {\n            throw new Error('Reset URL is not set in authentication provider endpoints!');\n        }\n        return this._http.post<MessageResource>(this._resetUrl, email).pipe(\n            switchMap(processMessageResponse)\n        );\n    }\n\n    public recoverPassword(token, password): Observable<MessageResource> {\n        if (!this._recoverUrl) {\n            throw new Error('Recover URL is not set in authentication provider endpoints!');\n        }\n        const request = {\n            token,\n            password: btoa(password),\n            email: '',\n            name: '',\n            surname: ''\n        };\n        return this._http.post<MessageResource>(this._recoverUrl, request).pipe(\n            switchMap(processMessageResponse)\n        );\n    }\n\n    public verify(token: string): Observable<MessageResource> {\n        if (!this._verifyUrl) {\n            throw new Error('Verify URL is not set in authentication provider endpoints!');\n        }\n        return this._http.post<MessageResource>(this._verifyUrl, token).pipe(\n            switchMap(processMessageResponse)\n        );\n    }\n\n    /**\n     * @param endpointKey the attribute name of the endpoint address in `nae.json`\n     * @param baseUrl the base of the endpoint URL. Content resolved by key from `nae.json` is appended to the URL provided by this argument\n     * @returns the endpoint address or `undefined` if such endpoint is not defined in `nae.json`\n     */\n    protected resolveEndpoint(endpointKey: string, baseUrl: string): string | undefined {\n        const config = this._config.get();\n        if (!config\n            || !config.providers\n            || !config.providers.auth\n            || !config.providers.auth.endpoints\n            || !config.providers.auth.endpoints[endpointKey]) {\n            return undefined;\n        }\n        return baseUrl + config.providers.auth.endpoints[endpointKey];\n    }\n}\n"]}

package/esm5/lib/authentication/sign-up/sign-up.module.js

@@ -0,0 +1,17 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+var SignUpModule = /** @class */ (function () {
+    function SignUpModule() {
+    }
+    SignUpModule.decorators = [
+        { type: NgModule, args: [{
+                    declarations: [],
+                    imports: [
+                        CommonModule
+                    ]
+                },] }
+    ];
+    return SignUpModule;
+}());
+export { SignUpModule };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lnbi11cC5tb2R1bGUuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvYXV0aGVudGljYXRpb24vc2lnbi11cC9zaWduLXVwLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQztBQUc3QztJQUFBO0lBT0EsQ0FBQzs7Z0JBUEEsUUFBUSxTQUFDO29CQUNOLFlBQVksRUFBRSxFQUFFO29CQUNoQixPQUFPLEVBQUU7d0JBQ0wsWUFBWTtxQkFDZjtpQkFDSjs7SUFFRCxtQkFBQztDQUFBLEFBUEQsSUFPQztTQURZLFlBQVkiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge05nTW9kdWxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7Q29tbW9uTW9kdWxlfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuXG5cbkBOZ01vZHVsZSh7XG4gICAgZGVjbGFyYXRpb25zOiBbXSxcbiAgICBpbXBvcnRzOiBbXG4gICAgICAgIENvbW1vbk1vZHVsZVxuICAgIF1cbn0pXG5leHBvcnQgY2xhc3MgU2lnblVwTW9kdWxlIHtcbn1cbiJdfQ==

package/esm5/lib/authorization/authority/authority-guard.service.js

@@ -0,0 +1,52 @@
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot, CanActivate, Router, RouterStateSnapshot, UrlTree } from '@angular/router';
+import { UserService } from '../../user/services/user.service';
+import { AuthenticationModule } from '../../authentication/authentication.module';
+import { RedirectService } from '../../routing/redirect-service/redirect.service';
+import { ConfigurationService } from '../../configuration/configuration.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../routing/redirect-service/redirect.service";
+import * as i2 from "../../user/services/user.service";
+import * as i3 from "../../configuration/configuration.service";
+import * as i4 from "@angular/router";
+import * as i5 from "../../authentication/authentication.module";
+var AuthorityGuardService = /** @class */ (function () {
+    function AuthorityGuardService(_redirectService, _userService, _configService, _router) {
+        this._redirectService = _redirectService;
+        this._userService = _userService;
+        this._configService = _configService;
+        this._router = _router;
+        this._loginUrl = this._redirectService.resolveLoginPath();
+    }
+    AuthorityGuardService.prototype.canActivate = function (route, state) {
+        this._redirectService.intendedRoute = route;
+        var view = this._configService.getViewByUrl(state.url.toString());
+        return this.canAccessView(view);
+    };
+    AuthorityGuardService.prototype.canAccessView = function (view) {
+        if (typeof view.access !== 'string' && view.access.hasOwnProperty('authority')) {
+            return this._userService.hasAuthority(view.access.authority);
+        }
+    };
+    AuthorityGuardService.ctorParameters = function () { return [
+        { type: RedirectService },
+        { type: UserService },
+        { type: ConfigurationService },
+        { type: Router }
+    ]; };
+    AuthorityGuardService.ɵprov = i0.ɵɵdefineInjectable({ factory: function AuthorityGuardService_Factory() { return new AuthorityGuardService(i0.ɵɵinject(i1.RedirectService), i0.ɵɵinject(i2.UserService), i0.ɵɵinject(i3.ConfigurationService), i0.ɵɵinject(i4.Router)); }, token: AuthorityGuardService, providedIn: i5.AuthenticationModule });
+    AuthorityGuardService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: AuthenticationModule
+                },] }
+    ];
+    AuthorityGuardService.ctorParameters = function () { return [
+        { type: RedirectService },
+        { type: UserService },
+        { type: ConfigurationService },
+        { type: Router }
+    ]; };
+    return AuthorityGuardService;
+}());
+export { AuthorityGuardService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/lib/authorization/group/group-guard.service.js

@@ -0,0 +1,69 @@
+import { Injectable } from '@angular/core';
+import { AuthenticationModule } from '../../authentication/authentication.module';
+import { RedirectService } from '../../routing/redirect-service/redirect.service';
+import { UserService } from '../../user/services/user.service';
+import { ConfigurationService } from '../../configuration/configuration.service';
+import { LoggerService } from '../../logger/services/logger.service';
+import { NextGroupService } from '../../groups/services/next-group.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../routing/redirect-service/redirect.service";
+import * as i2 from "../../user/services/user.service";
+import * as i3 from "../../groups/services/next-group.service";
+import * as i4 from "../../configuration/configuration.service";
+import * as i5 from "../../logger/services/logger.service";
+import * as i6 from "../../authentication/authentication.module";
+var GroupGuardService = /** @class */ (function () {
+    function GroupGuardService(_redirectService, _userService, _nextGroupService, _configService, _log) {
+        this._redirectService = _redirectService;
+        this._userService = _userService;
+        this._nextGroupService = _nextGroupService;
+        this._configService = _configService;
+        this._log = _log;
+        this._loginUrl = this._redirectService.resolveLoginPath();
+    }
+    GroupGuardService.prototype.canActivate = function (route, state) {
+        this._redirectService.intendedRoute = route;
+        var view = this._configService.getViewByUrl(state.url.toString());
+        return this.canAccessView(view, state.url.toString());
+    };
+    GroupGuardService.prototype.canAccessView = function (view, url) {
+        if (typeof view.access !== 'string' && view.access.hasOwnProperty('group')) {
+            var allowedGroups = void 0;
+            if (Array.isArray(view.access.group)) {
+                allowedGroups = view.access.group;
+            }
+            else {
+                allowedGroups = [view.access.group];
+            }
+            var groupOfUser_1 = this._nextGroupService.groupOfUser.map(function (group) { return group.title; });
+            return allowedGroups.some(function (groupTitle) {
+                return groupOfUser_1.includes(groupTitle);
+            });
+        }
+        throw new Error('Group guard is declared for a view with no group guard configuration!'
+            + (" Add group guard configuration for view at " + url + ", or remove the guard."));
+    };
+    GroupGuardService.ctorParameters = function () { return [
+        { type: RedirectService },
+        { type: UserService },
+        { type: NextGroupService },
+        { type: ConfigurationService },
+        { type: LoggerService }
+    ]; };
+    GroupGuardService.ɵprov = i0.ɵɵdefineInjectable({ factory: function GroupGuardService_Factory() { return new GroupGuardService(i0.ɵɵinject(i1.RedirectService), i0.ɵɵinject(i2.UserService), i0.ɵɵinject(i3.NextGroupService), i0.ɵɵinject(i4.ConfigurationService), i0.ɵɵinject(i5.LoggerService)); }, token: GroupGuardService, providedIn: i6.AuthenticationModule });
+    GroupGuardService.decorators = [
+        { type: Injectable, args: [{
+                    providedIn: AuthenticationModule
+                },] }
+    ];
+    GroupGuardService.ctorParameters = function () { return [
+        { type: RedirectService },
+        { type: UserService },
+        { type: NextGroupService },
+        { type: ConfigurationService },
+        { type: LoggerService }
+    ]; };
+    return GroupGuardService;
+}());
+export { GroupGuardService };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ3JvdXAtZ3VhcmQuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BuZXRncmlmL2NvbXBvbmVudHMtY29yZS8iLCJzb3VyY2VzIjpbImxpYi9hdXRob3JpemF0aW9uL2dyb3VwL2dyb3VwLWd1YXJkLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFVBQVUsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUMsb0JBQW9CLEVBQUMsTUFBTSw0Q0FBNEMsQ0FBQztBQUdoRixPQUFPLEVBQUMsZUFBZSxFQUFDLE1BQU0saURBQWlELENBQUM7QUFDaEYsT0FBTyxFQUFDLFdBQVcsRUFBQyxNQUFNLGtDQUFrQyxDQUFDO0FBQzdELE9BQU8sRUFBQyxvQkFBb0IsRUFBQyxNQUFNLDJDQUEyQyxDQUFDO0FBQy9FLE9BQU8sRUFBQyxhQUFhLEVBQUMsTUFBTSxzQ0FBc0MsQ0FBQztBQUVuRSxPQUFPLEVBQUMsZ0JBQWdCLEVBQUMsTUFBTSwwQ0FBMEMsQ0FBQzs7Ozs7Ozs7QUFFMUU7SUFPSSwyQkFBc0IsZ0JBQWlDLEVBQ2pDLFlBQXlCLEVBQ3pCLGlCQUFtQyxFQUNuQyxjQUFvQyxFQUNwQyxJQUFtQjtRQUpuQixxQkFBZ0IsR0FBaEIsZ0JBQWdCLENBQWlCO1FBQ2pDLGlCQUFZLEdBQVosWUFBWSxDQUFhO1FBQ3pCLHNCQUFpQixHQUFqQixpQkFBaUIsQ0FBa0I7UUFDbkMsbUJBQWMsR0FBZCxjQUFjLENBQXNCO1FBQ3BDLFNBQUksR0FBSixJQUFJLENBQWU7UUFDckMsSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsZ0JBQWdCLEVBQUUsQ0FBQztJQUM5RCxDQUFDO0lBRUQsdUNBQVcsR0FBWCxVQUFZLEtBQTZCLEVBQUUsS0FBMEI7UUFFakUsSUFBSSxDQUFDLGdCQUFnQixDQUFDLGFBQWEsR0FBRyxLQUFLLENBQUM7UUFDNUMsSUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLGNBQWMsQ0FBQyxZQUFZLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxRQUFRLEVBQUUsQ0FBQyxDQUFDO1FBQ3BFLE9BQU8sSUFBSSxDQUFDLGFBQWEsQ0FBQyxJQUFJLEVBQUUsS0FBSyxDQUFDLEdBQUcsQ0FBQyxRQUFRLEVBQUUsQ0FBQyxDQUFDO0lBQzFELENBQUM7SUFFTSx5Q0FBYSxHQUFwQixVQUFxQixJQUFVLEVBQUUsR0FBVztRQUN4QyxJQUFJLE9BQU8sSUFBSSxDQUFDLE1BQU0sS0FBSyxRQUFRLElBQUksSUFBSSxDQUFDLE1BQU0sQ0FBQyxjQUFjLENBQUMsT0FBTyxDQUFDLEVBQUU7WUFDeEUsSUFBSSxhQUFhLFNBQWUsQ0FBQztZQUNqQyxJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsRUFBRTtnQkFDbEMsYUFBYSxHQUFHLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDO2FBQ3JDO2lCQUFNO2dCQUNILGFBQWEsR0FBRyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUM7YUFDdkM7WUFDRCxJQUFNLGFBQVcsR0FBRyxJQUFJLENBQUMsaUJBQWlCLENBQUMsV0FBVyxDQUFDLEdBQUcsQ0FBQyxVQUFBLEtBQUssSUFBSSxPQUFBLEtBQUssQ0FBQyxLQUFLLEVBQVgsQ0FBVyxDQUFDLENBQUM7WUFFakYsT0FBTyxhQUFhLENBQUMsSUFBSSxDQUFDLFVBQUEsVUFBVTtnQkFDaEMsT0FBTyxhQUFXLENBQUMsUUFBUSxDQUFDLFVBQVUsQ0FBQyxDQUFDO1lBQzVDLENBQUMsQ0FBQyxDQUFDO1NBQ047UUFDRCxNQUFNLElBQUksS0FBSyxDQUFDLHVFQUF1RTtlQUNqRixnREFBOEMsR0FBRywyQkFBd0IsQ0FBQSxDQUFDLENBQUM7SUFDckYsQ0FBQzs7Z0JBL0J1QyxlQUFlO2dCQUNuQixXQUFXO2dCQUNOLGdCQUFnQjtnQkFDbkIsb0JBQW9CO2dCQUM5QixhQUFhOzs7O2dCQVg1QyxVQUFVLFNBQUM7b0JBQ0osVUFBVSxFQUFFLG9CQUFvQjtpQkFDdkM7OztnQkFUTyxlQUFlO2dCQUNmLFdBQVc7Z0JBSVgsZ0JBQWdCO2dCQUhoQixvQkFBb0I7Z0JBQ3BCLGFBQWE7OzRCQVByQjtDQWtEQyxBQXZDRCxJQXVDQztTQXBDWSxpQkFBaUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0luamVjdGFibGV9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtBdXRoZW50aWNhdGlvbk1vZHVsZX0gZnJvbSAnLi4vLi4vYXV0aGVudGljYXRpb24vYXV0aGVudGljYXRpb24ubW9kdWxlJztcbmltcG9ydCB7QWN0aXZhdGVkUm91dGVTbmFwc2hvdCwgQ2FuQWN0aXZhdGUsIFJvdXRlclN0YXRlU25hcHNob3QsIFVybFRyZWV9IGZyb20gJ0Bhbmd1bGFyL3JvdXRlcic7XG5pbXBvcnQge09ic2VydmFibGV9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHtSZWRpcmVjdFNlcnZpY2V9IGZyb20gJy4uLy4uL3JvdXRpbmcvcmVkaXJlY3Qtc2VydmljZS9yZWRpcmVjdC5zZXJ2aWNlJztcbmltcG9ydCB7VXNlclNlcnZpY2V9IGZyb20gJy4uLy4uL3VzZXIvc2VydmljZXMvdXNlci5zZXJ2aWNlJztcbmltcG9ydCB7Q29uZmlndXJhdGlvblNlcnZpY2V9IGZyb20gJy4uLy4uL2NvbmZpZ3VyYXRpb24vY29uZmlndXJhdGlvbi5zZXJ2aWNlJztcbmltcG9ydCB7TG9nZ2VyU2VydmljZX0gZnJvbSAnLi4vLi4vbG9nZ2VyL3NlcnZpY2VzL2xvZ2dlci5zZXJ2aWNlJztcbmltcG9ydCB7Vmlld30gZnJvbSAnLi4vLi4vLi4vY29tbW9ucy9zY2hlbWEnO1xuaW1wb3J0IHtOZXh0R3JvdXBTZXJ2aWNlfSBmcm9tICcuLi8uLi9ncm91cHMvc2VydmljZXMvbmV4dC1ncm91cC5zZXJ2aWNlJztcblxuQEluamVjdGFibGUoe1xuICAgICAgICBwcm92aWRlZEluOiBBdXRoZW50aWNhdGlvbk1vZHVsZVxufSlcbmV4cG9ydCBjbGFzcyBHcm91cEd1YXJkU2VydmljZSBpbXBsZW1lbnRzIENhbkFjdGl2YXRlIHtcblxuICAgIHByaXZhdGUgcmVhZG9ubHkgX2xvZ2luVXJsOiBzdHJpbmc7XG5cbiAgICBjb25zdHJ1Y3Rvcihwcm90ZWN0ZWQgX3JlZGlyZWN0U2VydmljZTogUmVkaXJlY3RTZXJ2aWNlLFxuICAgICAgICAgICAgICAgIHByb3RlY3RlZCBfdXNlclNlcnZpY2U6IFVzZXJTZXJ2aWNlLFxuICAgICAgICAgICAgICAgIHByb3RlY3RlZCBfbmV4dEdyb3VwU2VydmljZTogTmV4dEdyb3VwU2VydmljZSxcbiAgICAgICAgICAgICAgICBwcm90ZWN0ZWQgX2NvbmZpZ1NlcnZpY2U6IENvbmZpZ3VyYXRpb25TZXJ2aWNlLFxuICAgICAgICAgICAgICAgIHByb3RlY3RlZCBfbG9nOiBMb2dnZXJTZXJ2aWNlKSB7XG4gICAgICAgIHRoaXMuX2xvZ2luVXJsID0gdGhpcy5fcmVkaXJlY3RTZXJ2aWNlLnJlc29sdmVMb2dpblBhdGgoKTtcbiAgICB9XG5cbiAgICBjYW5BY3RpdmF0ZShyb3V0ZTogQWN0aXZhdGVkUm91dGVTbmFwc2hvdCwgc3RhdGU6IFJvdXRlclN0YXRlU25hcHNob3QpOlxuICAgICAgICBPYnNlcnZhYmxlPGJvb2xlYW4gfCBVcmxUcmVlPiB8IFByb21pc2U8Ym9vbGVhbiB8IFVybFRyZWU+IHwgYm9vbGVhbiB8IFVybFRyZWUge1xuICAgICAgICB0aGlzLl9yZWRpcmVjdFNlcnZpY2UuaW50ZW5kZWRSb3V0ZSA9IHJvdXRlO1xuICAgICAgICBjb25zdCB2aWV3ID0gdGhpcy5fY29uZmlnU2VydmljZS5nZXRWaWV3QnlVcmwoc3RhdGUudXJsLnRvU3RyaW5nKCkpO1xuICAgICAgICByZXR1cm4gdGhpcy5jYW5BY2Nlc3NWaWV3KHZpZXcsIHN0YXRlLnVybC50b1N0cmluZygpKTtcbiAgICB9XG5cbiAgICBwdWJsaWMgY2FuQWNjZXNzVmlldyh2aWV3OiBWaWV3LCB1cmw6IHN0cmluZyk6IGJvb2xlYW4ge1xuICAgICAgICBpZiAodHlwZW9mIHZpZXcuYWNjZXNzICE9PSAnc3RyaW5nJyAmJiB2aWV3LmFjY2Vzcy5oYXNPd25Qcm9wZXJ0eSgnZ3JvdXAnKSkge1xuICAgICAgICAgICAgbGV0IGFsbG93ZWRHcm91cHM6IEFycmF5PHN0cmluZz47XG4gICAgICAgICAgICBpZiAoQXJyYXkuaXNBcnJheSh2aWV3LmFjY2Vzcy5ncm91cCkpIHtcbiAgICAgICAgICAgICAgICBhbGxvd2VkR3JvdXBzID0gdmlldy5hY2Nlc3MuZ3JvdXA7XG4gICAgICAgICAgICB9IGVsc2Uge1xuICAgICAgICAgICAgICAgIGFsbG93ZWRHcm91cHMgPSBbdmlldy5hY2Nlc3MuZ3JvdXBdO1xuICAgICAgICAgICAgfVxuICAgICAgICAgICAgY29uc3QgZ3JvdXBPZlVzZXIgPSB0aGlzLl9uZXh0R3JvdXBTZXJ2aWNlLmdyb3VwT2ZVc2VyLm1hcChncm91cCA9PiBncm91cC50aXRsZSk7XG5cbiAgICAgICAgICAgIHJldHVybiBhbGxvd2VkR3JvdXBzLnNvbWUoZ3JvdXBUaXRsZSA9PiB7XG4gICAgICAgICAgICAgICAgcmV0dXJuIGdyb3VwT2ZVc2VyLmluY2x1ZGVzKGdyb3VwVGl0bGUpO1xuICAgICAgICAgICAgfSk7XG4gICAgICAgIH1cbiAgICAgICAgdGhyb3cgbmV3IEVycm9yKCdHcm91cCBndWFyZCBpcyBkZWNsYXJlZCBmb3IgYSB2aWV3IHdpdGggbm8gZ3JvdXAgZ3VhcmQgY29uZmlndXJhdGlvbiEnXG4gICAgICAgICAgICArIGAgQWRkIGdyb3VwIGd1YXJkIGNvbmZpZ3VyYXRpb24gZm9yIHZpZXcgYXQgJHt1cmx9LCBvciByZW1vdmUgdGhlIGd1YXJkLmApO1xuICAgIH1cbn1cbiJdfQ==