@igo2/auth 1.15.3 → 16.0.0-rc.0

package/esm2022/lib/shared/auth.interceptor.mjs

@@ -0,0 +1,164 @@
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Md5 } from 'ts-md5';
+import { ConfigService } from '@igo2/core';
+import { TokenService } from './token.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@igo2/core";
+import * as i2 from "./token.service";
+import * as i3 from "@angular/common/http";
+export class AuthInterceptor {
+    config;
+    tokenService;
+    http;
+    refreshInProgress = false;
+    trustHosts;
+    hostsWithCredentials;
+    hostsWithAuthByKey;
+    constructor(config, tokenService, http) {
+        this.config = config;
+        this.tokenService = tokenService;
+        this.http = http;
+        this.trustHosts = this.config.getConfig('auth.trustHosts') || [];
+        this.trustHosts.push(window.location.hostname);
+        this.hostsWithCredentials =
+            this.config.getConfig('auth.hostsWithCredentials') || [];
+        this.hostsWithAuthByKey = this.config.getConfig('auth.hostsByKey') || [];
+    }
+    intercept(originalReq, next) {
+        const withCredentials = this.handleHostsWithCredentials(originalReq.url);
+        let req = originalReq.clone();
+        const hostWithKey = this.handleHostsAuthByKey(originalReq.url);
+        if (hostWithKey) {
+            req = req.clone({
+                params: req.params.set(hostWithKey.key, hostWithKey.value)
+            });
+        }
+        if (withCredentials) {
+            req = originalReq.clone({
+                withCredentials
+            });
+            return next.handle(req);
+        }
+        this.refreshToken();
+        const token = this.tokenService.get();
+        const element = document.createElement('a');
+        element.href = req.url;
+        if (element.host === '') {
+            element.href = element.href; // FIX IE11, DO NOT REMOVE
+        }
+        if (!token || this.trustHosts.indexOf(element.hostname) === -1) {
+            return next.handle(req);
+        }
+        const authHeader = `Bearer ${token}`;
+        let authReq = req.clone({
+            headers: req.headers.set('Authorization', authHeader)
+        });
+        const tokenDecoded = this.tokenService.decode();
+        if (authReq.params.get('_i') === 'true' &&
+            tokenDecoded &&
+            tokenDecoded.user &&
+            tokenDecoded.user.sourceId) {
+            const hashUser = Md5.hashStr(tokenDecoded.user.sourceId);
+            authReq = authReq.clone({
+                params: authReq.params.set('_i', hashUser)
+            });
+        }
+        else if (authReq.params.get('_i') === 'true') {
+            authReq = authReq.clone({
+                params: authReq.params.delete('_i')
+            });
+        }
+        return next.handle(authReq);
+    }
+    interceptXhr(xhr, url) {
+        const withCredentials = this.handleHostsWithCredentials(url);
+        if (withCredentials) {
+            xhr.withCredentials = withCredentials;
+            return true;
+        }
+        this.refreshToken();
+        const element = document.createElement('a');
+        element.href = url;
+        const token = this.tokenService.get();
+        if (!token || this.trustHosts.indexOf(element.hostname) === -1) {
+            return false;
+        }
+        xhr.setRequestHeader('Authorization', 'Bearer ' + token);
+        return true;
+    }
+    alterUrlWithKeyAuth(url) {
+        const hostWithKey = this.handleHostsAuthByKey(url);
+        let interceptedUrl = url;
+        if (hostWithKey) {
+            const urlDecomposed = interceptedUrl.split(/[?&]/);
+            let urlWithKeyAdded = urlDecomposed.shift();
+            const paramsToKeep = urlDecomposed.filter((p) => p.length !== 0);
+            paramsToKeep.push(`${hostWithKey.key}=${hostWithKey.value}`);
+            if (paramsToKeep.length) {
+                urlWithKeyAdded += '?' + paramsToKeep.join('&');
+            }
+            return urlWithKeyAdded;
+        }
+        return;
+    }
+    handleHostsWithCredentials(reqUrl) {
+        let withCredentials = false;
+        for (const hostWithCredentials of this.hostsWithCredentials) {
+            const domainRegex = new RegExp(hostWithCredentials.domainRegFilters);
+            if (domainRegex.test(reqUrl)) {
+                withCredentials =
+                    hostWithCredentials.withCredentials !== undefined
+                        ? hostWithCredentials.withCredentials
+                        : undefined;
+                break;
+            }
+        }
+        return withCredentials;
+    }
+    handleHostsAuthByKey(reqUrl) {
+        let hostWithKey;
+        for (const hostWithAuthByKey of this.hostsWithAuthByKey) {
+            const domainRegex = new RegExp(hostWithAuthByKey.domainRegFilters);
+            if (domainRegex.test(reqUrl)) {
+                var replace = `${hostWithAuthByKey.keyProperty}=${hostWithAuthByKey.keyValue}`;
+                var keyAdded = new RegExp(replace, 'gm');
+                if (!keyAdded.test(reqUrl)) {
+                    hostWithKey = {
+                        key: hostWithAuthByKey.keyProperty,
+                        value: hostWithAuthByKey.keyValue
+                    };
+                    break;
+                }
+            }
+        }
+        return hostWithKey;
+    }
+    refreshToken() {
+        const jwt = this.tokenService.decode();
+        const currentTime = new Date().getTime() / 1000;
+        if (!this.refreshInProgress &&
+            jwt &&
+            currentTime < jwt.exp &&
+            currentTime > jwt.exp - 1800) {
+            this.refreshInProgress = true;
+            const url = this.config.getConfig('auth.url');
+            return this.http.post(`${url}/refresh`, {}).subscribe((data) => {
+                this.tokenService.set(data.token);
+                this.refreshInProgress = false;
+            }, (err) => {
+                err.error.caught = true;
+                return err;
+            });
+        }
+    }
+    static ɵfac = function AuthInterceptor_Factory(t) { return new (t || AuthInterceptor)(i0.ɵɵinject(i1.ConfigService), i0.ɵɵinject(i2.TokenService), i0.ɵɵinject(i3.HttpClient)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: AuthInterceptor, factory: AuthInterceptor.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AuthInterceptor, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.ConfigService }, { type: i2.TokenService }, { type: i3.HttpClient }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.interceptor.js","sourceRoot":"","sources":["../../../../../packages/auth/src/lib/shared/auth.interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport {\r\n  HttpEvent,\r\n  HttpInterceptor,\r\n  HttpHandler,\r\n  HttpRequest\r\n} from '@angular/common/http';\r\nimport { Observable } from 'rxjs';\r\nimport { Md5 } from 'ts-md5';\r\n\r\nimport { ConfigService } from '@igo2/core';\r\nimport { TokenService } from './token.service';\r\nimport { AuthByKeyOptions, WithCredentialsOptions } from './auth.interface';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class AuthInterceptor implements HttpInterceptor {\r\n  private refreshInProgress = false;\r\n  private trustHosts: string[];\r\n  private hostsWithCredentials: WithCredentialsOptions[];\r\n  private hostsWithAuthByKey: AuthByKeyOptions[];\r\n\r\n  constructor(\r\n    private config: ConfigService,\r\n    private tokenService: TokenService,\r\n    private http: HttpClient\r\n  ) {\r\n    this.trustHosts = this.config.getConfig('auth.trustHosts') || [];\r\n    this.trustHosts.push(window.location.hostname);\r\n\r\n    this.hostsWithCredentials =\r\n      this.config.getConfig('auth.hostsWithCredentials') || [];\r\n    this.hostsWithAuthByKey = this.config.getConfig('auth.hostsByKey') || [];\r\n  }\r\n\r\n  intercept(\r\n    originalReq: HttpRequest<any>,\r\n    next: HttpHandler\r\n  ): Observable<HttpEvent<any>> {\r\n    const withCredentials = this.handleHostsWithCredentials(originalReq.url);\r\n    let req = originalReq.clone();\r\n    const hostWithKey = this.handleHostsAuthByKey(originalReq.url);\r\n    if (hostWithKey) {\r\n      req = req.clone({\r\n        params: req.params.set(hostWithKey.key, hostWithKey.value)\r\n      });\r\n    }\r\n    if (withCredentials) {\r\n      req = originalReq.clone({\r\n        withCredentials\r\n      });\r\n      return next.handle(req);\r\n    }\r\n    this.refreshToken();\r\n    const token = this.tokenService.get();\r\n    const element = document.createElement('a');\r\n    element.href = req.url;\r\n    if (element.host === '') {\r\n      element.href = element.href; // FIX IE11, DO NOT REMOVE\r\n    }\r\n\r\n    if (!token || this.trustHosts.indexOf(element.hostname) === -1) {\r\n      return next.handle(req);\r\n    }\r\n\r\n    const authHeader = `Bearer ${token}`;\r\n    let authReq = req.clone({\r\n      headers: req.headers.set('Authorization', authHeader)\r\n    });\r\n\r\n    const tokenDecoded: any = this.tokenService.decode();\r\n    if (\r\n      authReq.params.get('_i') === 'true' &&\r\n      tokenDecoded &&\r\n      tokenDecoded.user &&\r\n      tokenDecoded.user.sourceId\r\n    ) {\r\n      const hashUser = Md5.hashStr(tokenDecoded.user.sourceId) as string;\r\n      authReq = authReq.clone({\r\n        params: authReq.params.set('_i', hashUser)\r\n      });\r\n    } else if (authReq.params.get('_i') === 'true') {\r\n      authReq = authReq.clone({\r\n        params: authReq.params.delete('_i')\r\n      });\r\n    }\r\n\r\n    return next.handle(authReq);\r\n  }\r\n\r\n  interceptXhr(xhr, url: string): boolean {\r\n    const withCredentials = this.handleHostsWithCredentials(url);\r\n    if (withCredentials) {\r\n      xhr.withCredentials = withCredentials;\r\n      return true;\r\n    }\r\n\r\n    this.refreshToken();\r\n    const element = document.createElement('a');\r\n    element.href = url;\r\n\r\n    const token = this.tokenService.get();\r\n    if (!token || this.trustHosts.indexOf(element.hostname) === -1) {\r\n      return false;\r\n    }\r\n    xhr.setRequestHeader('Authorization', 'Bearer ' + token);\r\n    return true;\r\n  }\r\n\r\n  alterUrlWithKeyAuth(url: string): string {\r\n    const hostWithKey = this.handleHostsAuthByKey(url);\r\n    let interceptedUrl = url;\r\n    if (hostWithKey) {\r\n      const urlDecomposed = interceptedUrl.split(/[?&]/);\r\n      let urlWithKeyAdded = urlDecomposed.shift();\r\n      const paramsToKeep = urlDecomposed.filter((p) => p.length !== 0);\r\n      paramsToKeep.push(`${hostWithKey.key}=${hostWithKey.value}`);\r\n      if (paramsToKeep.length) {\r\n        urlWithKeyAdded += '?' + paramsToKeep.join('&');\r\n      }\r\n      return urlWithKeyAdded;\r\n    }\r\n    return;\r\n  }\r\n\r\n  private handleHostsWithCredentials(reqUrl: string) {\r\n    let withCredentials = false;\r\n    for (const hostWithCredentials of this.hostsWithCredentials) {\r\n      const domainRegex = new RegExp(hostWithCredentials.domainRegFilters);\r\n      if (domainRegex.test(reqUrl)) {\r\n        withCredentials =\r\n          hostWithCredentials.withCredentials !== undefined\r\n            ? hostWithCredentials.withCredentials\r\n            : undefined;\r\n        break;\r\n      }\r\n    }\r\n    return withCredentials;\r\n  }\r\n\r\n  private handleHostsAuthByKey(reqUrl: string): { key: string; value: string } {\r\n    let hostWithKey;\r\n    for (const hostWithAuthByKey of this.hostsWithAuthByKey) {\r\n      const domainRegex = new RegExp(hostWithAuthByKey.domainRegFilters);\r\n      if (domainRegex.test(reqUrl)) {\r\n        var replace = `${hostWithAuthByKey.keyProperty}=${hostWithAuthByKey.keyValue}`;\r\n        var keyAdded = new RegExp(replace, 'gm');\r\n        if (!keyAdded.test(reqUrl)) {\r\n          hostWithKey = {\r\n            key: hostWithAuthByKey.keyProperty,\r\n            value: hostWithAuthByKey.keyValue\r\n          };\r\n          break;\r\n        }\r\n      }\r\n    }\r\n    return hostWithKey;\r\n  }\r\n\r\n  refreshToken() {\r\n    const jwt = this.tokenService.decode();\r\n    const currentTime = new Date().getTime() / 1000;\r\n\r\n    if (\r\n      !this.refreshInProgress &&\r\n      jwt &&\r\n      currentTime < jwt.exp &&\r\n      currentTime > jwt.exp - 1800\r\n    ) {\r\n      this.refreshInProgress = true;\r\n\r\n      const url = this.config.getConfig('auth.url');\r\n      return this.http.post(`${url}/refresh`, {}).subscribe(\r\n        (data: any) => {\r\n          this.tokenService.set(data.token);\r\n          this.refreshInProgress = false;\r\n        },\r\n        (err) => {\r\n          err.error.caught = true;\r\n          return err;\r\n        }\r\n      );\r\n    }\r\n  }\r\n}\r\n"]}

package/{esm2020 → esm2022}/lib/shared/auth.interface.mjs

@@ -1,2 +1,2 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,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
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/auth.service.mjs

@@ -0,0 +1,168 @@
+import { Injectable, Optional } from '@angular/core';
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { Router } from '@angular/router';
+import { BehaviorSubject, of } from 'rxjs';
+import { tap, catchError } from 'rxjs/operators';
+import { globalCacheBusterNotifier } from 'ts-cacheable';
+import { ConfigService, LanguageService, MessageService } from '@igo2/core';
+import { Base64 } from '@igo2/utils';
+import { TokenService } from './token.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./token.service";
+import * as i3 from "@igo2/core";
+import * as i4 from "@angular/router";
+export class AuthService {
+    http;
+    tokenService;
+    config;
+    languageService;
+    messageService;
+    router;
+    authenticate$ = new BehaviorSubject(undefined);
+    logged$ = new BehaviorSubject(undefined);
+    redirectUrl;
+    languageForce = false;
+    anonymous = false;
+    get hasAuthService() {
+        return this.config.getConfig('auth.url') !== undefined;
+    }
+    constructor(http, tokenService, config, languageService, messageService, router) {
+        this.http = http;
+        this.tokenService = tokenService;
+        this.config = config;
+        this.languageService = languageService;
+        this.messageService = messageService;
+        this.router = router;
+        this.authenticate$.next(this.authenticated);
+        this.authenticate$.subscribe((authenticated) => {
+            this.logged$.next(authenticated);
+            globalCacheBusterNotifier.next();
+        });
+    }
+    login(username, password) {
+        const myHeader = new HttpHeaders({ 'Content-Type': 'application/json' });
+        const body = {
+            username,
+            password: this.encodePassword(password)
+        };
+        return this.loginCall(body, myHeader);
+    }
+    loginWithToken(token, type, infosUser) {
+        const myHeader = new HttpHeaders({ 'Content-Type': 'application/json' });
+        const body = {
+            token,
+            typeConnection: type,
+            infosUser
+        };
+        return this.loginCall(body, myHeader);
+    }
+    loginAnonymous() {
+        this.anonymous = true;
+        this.logged$.next(true);
+        return of(true);
+    }
+    refresh() {
+        const url = this.config.getConfig('auth.url');
+        return this.http.post(`${url}/refresh`, {}).pipe(tap((data) => {
+            this.tokenService.set(data.token);
+        }), catchError((err) => {
+            err.error.caught = true;
+            throw err;
+        }));
+    }
+    logout() {
+        this.anonymous = false;
+        this.tokenService.remove();
+        this.authenticate$.next(false);
+        return of(true);
+    }
+    isAuthenticated() {
+        return !this.tokenService.isExpired();
+    }
+    getToken() {
+        return this.tokenService.get();
+    }
+    decodeToken() {
+        if (this.isAuthenticated()) {
+            return this.tokenService.decode();
+        }
+        return false;
+    }
+    goToRedirectUrl() {
+        if (!this.router) {
+            return;
+        }
+        const redirectUrl = this.redirectUrl || this.router.url;
+        const options = this.config.getConfig('auth') || {};
+        if (redirectUrl === options.loginRoute) {
+            const homeRoute = options.homeRoute || '/';
+            this.router.navigateByUrl(homeRoute);
+        }
+        else if (redirectUrl) {
+            this.router.navigateByUrl(redirectUrl);
+        }
+    }
+    getUserInfo() {
+        const url = this.config.getConfig('auth.url') + '/info';
+        return this.http.get(url);
+    }
+    getProfils() {
+        const url = this.config.getConfig('auth.url');
+        return this.http.get(`${url}/profils`);
+    }
+    updateUser(user) {
+        const url = this.config.getConfig('auth.url');
+        return this.http.patch(url, user);
+    }
+    encodePassword(password) {
+        return Base64.encode(password);
+    }
+    // authenticated or anonymous
+    get logged() {
+        return this.authenticated || this.isAnonymous;
+    }
+    get isAnonymous() {
+        return this.anonymous;
+    }
+    get authenticated() {
+        return this.isAuthenticated();
+    }
+    get isAdmin() {
+        const token = this.decodeToken();
+        if (token && token.user && token.user.isAdmin) {
+            return true;
+        }
+        return false;
+    }
+    loginCall(body, headers) {
+        const url = this.config.getConfig('auth.url');
+        return this.http.post(`${url}/login`, body, { headers }).pipe(tap((data) => {
+            this.tokenService.set(data.token);
+            const tokenDecoded = this.decodeToken();
+            if (tokenDecoded && tokenDecoded.user) {
+                if (tokenDecoded.user.locale && !this.languageForce) {
+                    this.languageService.setLanguage(tokenDecoded.user.locale);
+                }
+                if (tokenDecoded.user.isExpired) {
+                    this.messageService.alert('igo.auth.error.Password expired');
+                }
+            }
+            this.authenticate$.next(true);
+        }), catchError((err) => {
+            err.error.caught = true;
+            throw err;
+        }));
+    }
+    static ɵfac = function AuthService_Factory(t) { return new (t || AuthService)(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.TokenService), i0.ɵɵinject(i3.ConfigService), i0.ɵɵinject(i3.LanguageService), i0.ɵɵinject(i3.MessageService), i0.ɵɵinject(i4.Router, 8)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: AuthService, factory: AuthService.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AuthService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.HttpClient }, { type: i2.TokenService }, { type: i3.ConfigService }, { type: i3.LanguageService }, { type: i3.MessageService }, { type: i4.Router, decorators: [{
+                type: Optional
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"","sources":["../../../../../packages/auth/src/lib/shared/auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Optional } from '@angular/core';\r\nimport { HttpClient, HttpHeaders } from '@angular/common/http';\r\nimport { Router } from '@angular/router';\r\n\r\nimport { Observable, BehaviorSubject, of } from 'rxjs';\r\nimport { tap, catchError } from 'rxjs/operators';\r\nimport { globalCacheBusterNotifier } from 'ts-cacheable';\r\n\r\nimport { ConfigService, LanguageService, MessageService } from '@igo2/core';\r\nimport { Base64 } from '@igo2/utils';\r\n\r\nimport { User, IInfosUser } from './auth.interface';\r\nimport { TokenService } from './token.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class AuthService {\r\n  public authenticate$ = new BehaviorSubject<boolean>(undefined);\r\n  public logged$ = new BehaviorSubject<boolean>(undefined);\r\n  public redirectUrl: string;\r\n  public languageForce = false;\r\n  private anonymous = false;\r\n\r\n  get hasAuthService() {\r\n    return this.config.getConfig('auth.url') !== undefined;\r\n  }\r\n\r\n  constructor(\r\n    private http: HttpClient,\r\n    private tokenService: TokenService,\r\n    private config: ConfigService,\r\n    private languageService: LanguageService,\r\n    private messageService: MessageService,\r\n    @Optional() private router: Router\r\n  ) {\r\n    this.authenticate$.next(this.authenticated);\r\n    this.authenticate$.subscribe((authenticated) => {\r\n      this.logged$.next(authenticated);\r\n      globalCacheBusterNotifier.next();\r\n    });\r\n  }\r\n\r\n  login(username: string, password: string): Observable<void> {\r\n    const myHeader = new HttpHeaders({ 'Content-Type': 'application/json' });\r\n\r\n    const body = {\r\n      username,\r\n      password: this.encodePassword(password)\r\n    };\r\n\r\n    return this.loginCall(body, myHeader);\r\n  }\r\n\r\n  loginWithToken(\r\n    token: string,\r\n    type: string,\r\n    infosUser?: IInfosUser\r\n  ): Observable<void> {\r\n    const myHeader = new HttpHeaders({ 'Content-Type': 'application/json' });\r\n\r\n    const body = {\r\n      token,\r\n      typeConnection: type,\r\n      infosUser\r\n    };\r\n\r\n    return this.loginCall(body, myHeader);\r\n  }\r\n\r\n  loginAnonymous(): Observable<boolean> {\r\n    this.anonymous = true;\r\n    this.logged$.next(true);\r\n    return of(true);\r\n  }\r\n\r\n  refresh(): Observable<void> {\r\n    const url = this.config.getConfig('auth.url');\r\n    return this.http.post(`${url}/refresh`, {}).pipe(\r\n      tap((data: any) => {\r\n        this.tokenService.set(data.token);\r\n      }),\r\n      catchError((err) => {\r\n        err.error.caught = true;\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n\r\n  logout(): Observable<boolean> {\r\n    this.anonymous = false;\r\n    this.tokenService.remove();\r\n    this.authenticate$.next(false);\r\n    return of(true);\r\n  }\r\n\r\n  isAuthenticated(): boolean {\r\n    return !this.tokenService.isExpired();\r\n  }\r\n\r\n  getToken(): string {\r\n    return this.tokenService.get();\r\n  }\r\n\r\n  decodeToken() {\r\n    if (this.isAuthenticated()) {\r\n      return this.tokenService.decode();\r\n    }\r\n    return false;\r\n  }\r\n\r\n  goToRedirectUrl() {\r\n    if (!this.router) {\r\n      return;\r\n    }\r\n    const redirectUrl = this.redirectUrl || this.router.url;\r\n\r\n    const options = this.config.getConfig('auth') || {};\r\n    if (redirectUrl === options.loginRoute) {\r\n      const homeRoute = options.homeRoute || '/';\r\n      this.router.navigateByUrl(homeRoute);\r\n    } else if (redirectUrl) {\r\n      this.router.navigateByUrl(redirectUrl);\r\n    }\r\n  }\r\n\r\n  getUserInfo(): Observable<User> {\r\n    const url = this.config.getConfig('auth.url') + '/info';\r\n    return this.http.get<User>(url);\r\n  }\r\n\r\n  getProfils(): Observable<{ profils: string[] }> {\r\n    const url = this.config.getConfig('auth.url');\r\n    return this.http.get<{ profils: string[] }>(`${url}/profils`);\r\n  }\r\n\r\n  updateUser(user: User): Observable<User> {\r\n    const url = this.config.getConfig('auth.url');\r\n    return this.http.patch<User>(url, user);\r\n  }\r\n\r\n  private encodePassword(password: string) {\r\n    return Base64.encode(password);\r\n  }\r\n\r\n  // authenticated or anonymous\r\n  get logged(): boolean {\r\n    return this.authenticated || this.isAnonymous;\r\n  }\r\n\r\n  get isAnonymous(): boolean {\r\n    return this.anonymous;\r\n  }\r\n\r\n  get authenticated(): boolean {\r\n    return this.isAuthenticated();\r\n  }\r\n\r\n  get isAdmin(): boolean {\r\n    const token = this.decodeToken();\r\n    if (token && token.user && token.user.isAdmin) {\r\n      return true;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  private loginCall(body, headers) {\r\n    const url = this.config.getConfig('auth.url');\r\n    return this.http.post(`${url}/login`, body, { headers }).pipe(\r\n      tap((data: any) => {\r\n        this.tokenService.set(data.token);\r\n        const tokenDecoded = this.decodeToken();\r\n        if (tokenDecoded && tokenDecoded.user) {\r\n          if (tokenDecoded.user.locale && !this.languageForce) {\r\n            this.languageService.setLanguage(tokenDecoded.user.locale);\r\n          }\r\n          if (tokenDecoded.user.isExpired) {\r\n            this.messageService.alert('igo.auth.error.Password expired');\r\n          }\r\n        }\r\n        this.authenticate$.next(true);\r\n      }),\r\n      catchError((err) => {\r\n        err.error.caught = true;\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n}\r\n"]}

package/esm2022/lib/shared/logged.guard.mjs

@@ -0,0 +1,38 @@
+import { Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import { ConfigService } from '@igo2/core';
+import { AuthService } from './auth.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./auth.service";
+import * as i2 from "@igo2/core";
+import * as i3 from "@angular/router";
+export class LoggedGuard {
+    authService;
+    config;
+    router;
+    constructor(authService, config, router) {
+        this.authService = authService;
+        this.config = config;
+        this.router = router;
+    }
+    canActivate(route, state) {
+        if (this.authService.logged) {
+            return true;
+        }
+        this.authService.redirectUrl = state.url;
+        const authConfig = this.config.getConfig('auth');
+        if (authConfig && authConfig.loginRoute) {
+            this.router.navigateByUrl(authConfig.loginRoute);
+        }
+        return false;
+    }
+    static ɵfac = function LoggedGuard_Factory(t) { return new (t || LoggedGuard)(i0.ɵɵinject(i1.AuthService), i0.ɵɵinject(i2.ConfigService), i0.ɵɵinject(i3.Router)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: LoggedGuard, factory: LoggedGuard.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LoggedGuard, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.AuthService }, { type: i2.ConfigService }, { type: i3.Router }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/profils.guard.mjs

@@ -0,0 +1,43 @@
+import { Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import { map } from 'rxjs/operators';
+import { ConfigService } from '@igo2/core';
+import { AuthService } from './auth.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./auth.service";
+import * as i2 from "@igo2/core";
+import * as i3 from "@angular/router";
+export class ProfilsGuard {
+    authService;
+    config;
+    router;
+    constructor(authService, config, router) {
+        this.authService = authService;
+        this.config = config;
+        this.router = router;
+    }
+    canActivate(_route, state) {
+        return this.authService.getProfils().pipe(map((profils) => {
+            const authConfig = this.config.getConfig('auth');
+            if (profils &&
+                profils.profils &&
+                profils.profils.some((v) => authConfig.profilsGuard.indexOf(v) !== -1)) {
+                return true;
+            }
+            this.authService.redirectUrl = state.url;
+            if (authConfig && authConfig.loginRoute) {
+                this.router.navigateByUrl(authConfig.loginRoute);
+            }
+            return false;
+        }));
+    }
+    static ɵfac = function ProfilsGuard_Factory(t) { return new (t || ProfilsGuard)(i0.ɵɵinject(i1.AuthService), i0.ɵɵinject(i2.ConfigService), i0.ɵɵinject(i3.Router)); };
+    static ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ProfilsGuard, factory: ProfilsGuard.ɵfac, providedIn: 'root' });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ProfilsGuard, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: i1.AuthService }, { type: i2.ConfigService }, { type: i3.Router }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZmlscy5ndWFyZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2F1dGgvc3JjL2xpYi9zaGFyZWQvcHJvZmlscy5ndWFyZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFDTCxNQUFNLEVBR1AsTUFBTSxpQkFBaUIsQ0FBQztBQUN6QixPQUFPLEVBQUUsR0FBRyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFckMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUMzQyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7Ozs7O0FBSzdDLE1BQU0sT0FBTyxZQUFZO0lBRWI7SUFDQTtJQUNBO0lBSFYsWUFDVSxXQUF3QixFQUN4QixNQUFxQixFQUNyQixNQUFjO1FBRmQsZ0JBQVcsR0FBWCxXQUFXLENBQWE7UUFDeEIsV0FBTSxHQUFOLE1BQU0sQ0FBZTtRQUNyQixXQUFNLEdBQU4sTUFBTSxDQUFRO0lBQ3JCLENBQUM7SUFFSixXQUFXLENBQUMsTUFBOEIsRUFBRSxLQUEwQjtRQUNwRSxPQUFPLElBQUksQ0FBQyxXQUFXLENBQUMsVUFBVSxFQUFFLENBQUMsSUFBSSxDQUN2QyxHQUFHLENBQUMsQ0FBQyxPQUE4QixFQUFFLEVBQUU7WUFDckMsTUFBTSxVQUFVLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLENBQUM7WUFDakQsSUFDRSxPQUFPO2dCQUNQLE9BQU8sQ0FBQyxPQUFPO2dCQUNmLE9BQU8sQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxVQUFVLENBQUMsWUFBWSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxFQUN0RTtnQkFDQSxPQUFPLElBQUksQ0FBQzthQUNiO1lBRUQsSUFBSSxDQUFDLFdBQVcsQ0FBQyxXQUFXLEdBQUcsS0FBSyxDQUFDLEdBQUcsQ0FBQztZQUV6QyxJQUFJLFVBQVUsSUFBSSxVQUFVLENBQUMsVUFBVSxFQUFFO2dCQUN2QyxJQUFJLENBQUMsTUFBTSxDQUFDLGFBQWEsQ0FBQyxVQUFVLENBQUMsVUFBVSxDQUFDLENBQUM7YUFDbEQ7WUFFRCxPQUFPLEtBQUssQ0FBQztRQUNmLENBQUMsQ0FBQyxDQUNILENBQUM7SUFDSixDQUFDO3NFQTVCVSxZQUFZO2dFQUFaLFlBQVksV0FBWixZQUFZLG1CQUZYLE1BQU07O3VGQUVQLFlBQVk7Y0FIeEIsVUFBVTtlQUFDO2dCQUNWLFVBQVUsRUFBRSxNQUFNO2FBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtcbiAgUm91dGVyLFxuICBBY3RpdmF0ZWRSb3V0ZVNuYXBzaG90LFxuICBSb3V0ZXJTdGF0ZVNuYXBzaG90XG59IGZyb20gJ0Bhbmd1bGFyL3JvdXRlcic7XG5pbXBvcnQgeyBtYXAgfSBmcm9tICdyeGpzL29wZXJhdG9ycyc7XG5cbmltcG9ydCB7IENvbmZpZ1NlcnZpY2UgfSBmcm9tICdAaWdvMi9jb3JlJztcbmltcG9ydCB7IEF1dGhTZXJ2aWNlIH0gZnJvbSAnLi9hdXRoLnNlcnZpY2UnO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290J1xufSlcbmV4cG9ydCBjbGFzcyBQcm9maWxzR3VhcmQge1xuICBjb25zdHJ1Y3RvcihcbiAgICBwcml2YXRlIGF1dGhTZXJ2aWNlOiBBdXRoU2VydmljZSxcbiAgICBwcml2YXRlIGNvbmZpZzogQ29uZmlnU2VydmljZSxcbiAgICBwcml2YXRlIHJvdXRlcjogUm91dGVyXG4gICkge31cblxuICBjYW5BY3RpdmF0ZShfcm91dGU6IEFjdGl2YXRlZFJvdXRlU25hcHNob3QsIHN0YXRlOiBSb3V0ZXJTdGF0ZVNuYXBzaG90KSB7XG4gICAgcmV0dXJuIHRoaXMuYXV0aFNlcnZpY2UuZ2V0UHJvZmlscygpLnBpcGUoXG4gICAgICBtYXAoKHByb2ZpbHM6IHsgcHJvZmlsczogc3RyaW5nW10gfSkgPT4ge1xuICAgICAgICBjb25zdCBhdXRoQ29uZmlnID0gdGhpcy5jb25maWcuZ2V0Q29uZmlnKCdhdXRoJyk7XG4gICAgICAgIGlmIChcbiAgICAgICAgICBwcm9maWxzICYmXG4gICAgICAgICAgcHJvZmlscy5wcm9maWxzICYmXG4gICAgICAgICAgcHJvZmlscy5wcm9maWxzLnNvbWUoKHYpID0+IGF1dGhDb25maWcucHJvZmlsc0d1YXJkLmluZGV4T2YodikgIT09IC0xKVxuICAgICAgICApIHtcbiAgICAgICAgICByZXR1cm4gdHJ1ZTtcbiAgICAgICAgfVxuXG4gICAgICAgIHRoaXMuYXV0aFNlcnZpY2UucmVkaXJlY3RVcmwgPSBzdGF0ZS51cmw7XG5cbiAgICAgICAgaWYgKGF1dGhDb25maWcgJiYgYXV0aENvbmZpZy5sb2dpblJvdXRlKSB7XG4gICAgICAgICAgdGhpcy5yb3V0ZXIubmF2aWdhdGVCeVVybChhdXRoQ29uZmlnLmxvZ2luUm91dGUpO1xuICAgICAgICB9XG5cbiAgICAgICAgcmV0dXJuIGZhbHNlO1xuICAgICAgfSlcbiAgICApO1xuICB9XG59XG4iXX0=

package/esm2022/lib/shared/protected.directive.mjs

@@ -0,0 +1,20 @@
+import { Directive, ElementRef } from '@angular/core';
+import { AuthService } from './auth.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./auth.service";
+export class ProtectedDirective {
+    constructor(authentication, el) {
+        if (!authentication.isAuthenticated()) {
+            el.nativeElement.parentNode.removeChild(el.nativeElement);
+        }
+    }
+    static ɵfac = function ProtectedDirective_Factory(t) { return new (t || ProtectedDirective)(i0.ɵɵdirectiveInject(i1.AuthService), i0.ɵɵdirectiveInject(i0.ElementRef)); };
+    static ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: ProtectedDirective, selectors: [["", "igoProtected", ""]] });
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ProtectedDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[igoProtected]'
+            }]
+    }], function () { return [{ type: i1.AuthService }, { type: i0.ElementRef }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdGVjdGVkLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2F1dGgvc3JjL2xpYi9zaGFyZWQvcHJvdGVjdGVkLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN0RCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7OztBQUs3QyxNQUFNLE9BQU8sa0JBQWtCO0lBQzdCLFlBQVksY0FBMkIsRUFBRSxFQUFjO1FBQ3JELElBQUksQ0FBQyxjQUFjLENBQUMsZUFBZSxFQUFFLEVBQUU7WUFDckMsRUFBRSxDQUFDLGFBQWEsQ0FBQyxVQUFVLENBQUMsV0FBVyxDQUFDLEVBQUUsQ0FBQyxhQUFhLENBQUMsQ0FBQztTQUMzRDtJQUNILENBQUM7NEVBTFUsa0JBQWtCOzZEQUFsQixrQkFBa0I7O3VGQUFsQixrQkFBa0I7Y0FIOUIsU0FBUztlQUFDO2dCQUNULFFBQVEsRUFBRSxnQkFBZ0I7YUFDM0IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIEVsZW1lbnRSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEF1dGhTZXJ2aWNlIH0gZnJvbSAnLi9hdXRoLnNlcnZpY2UnO1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbaWdvUHJvdGVjdGVkXSdcbn0pXG5leHBvcnQgY2xhc3MgUHJvdGVjdGVkRGlyZWN0aXZlIHtcbiAgY29uc3RydWN0b3IoYXV0aGVudGljYXRpb246IEF1dGhTZXJ2aWNlLCBlbDogRWxlbWVudFJlZikge1xuICAgIGlmICghYXV0aGVudGljYXRpb24uaXNBdXRoZW50aWNhdGVkKCkpIHtcbiAgICAgIGVsLm5hdGl2ZUVsZW1lbnQucGFyZW50Tm9kZS5yZW1vdmVDaGlsZChlbC5uYXRpdmVFbGVtZW50KTtcbiAgICB9XG4gIH1cbn1cbiJdfQ==

package/{esm2020 → esm2022}/lib/shared/storage.interface.mjs

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