ssi-security-commons 0.19.0 → 0.19.1

package/esm2022/lib/services/session.service.mjs

@@ -0,0 +1,438 @@
+/* eslint-disable max-lines-per-function */
+/* eslint-disable arrow-body-style */
+/* eslint-disable @typescript-eslint/naming-convention */
+import { Inject, Injectable } from '@angular/core';
+import { HttpHeaders } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+import { REFRESH_TOKEN, TOKEN, USERDATA } from '../shared/constants';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./crypto.service";
+import * as i3 from "./jwt.service";
+export class SessionService {
+    constructor(http, environment, cryptoService, jwtService) {
+        this.http = http;
+        this.cryptoService = cryptoService;
+        this.jwtService = jwtService;
+        this.loginUrl = 'http://localhost:4200/login';
+        this.endPoint = environment.endPointCore;
+        this.applicationId = environment.applicationId;
+        this.environment = environment;
+    }
+    buildUserdataFromToken(token) {
+        const tokenData = this.jwtService.decodeToken(token);
+        const userData = {
+            givenName: tokenData.given_name,
+            familyName: tokenData.family_name,
+            name: tokenData.name,
+            roles: tokenData.realm_access.roles,
+            userId: tokenData.sub,
+            username: tokenData.preferred_username,
+            email: tokenData.email,
+            emailVerified: tokenData.email_verified,
+            countryCode: tokenData.country_code
+        };
+        return userData;
+    }
+    async reviewSessionData() {
+        const value = await this.checkSessionData();
+        console.log(`async result: ${value}`);
+        return value;
+    }
+    setUserdata(userdata) {
+        this.userdata = userdata;
+    }
+    setTokens(token, refreshToken) {
+        this.token = token;
+        this.refreshToken = refreshToken;
+    }
+    getUserdata() {
+        return this.userdata;
+    }
+    setRefreshToken(refreshToken) {
+        this.refreshToken = refreshToken;
+        this.saveStorageData(REFRESH_TOKEN, refreshToken);
+    }
+    getRefreshToken() {
+        return this.refreshToken;
+    }
+    setToken(token) {
+        this.token = token;
+        this.saveStorageData(TOKEN, token);
+    }
+    getToken() {
+        return this.token;
+    }
+    destroyCredentials() {
+        this.token = undefined;
+        this.refreshToken = undefined;
+        this.deleteStorageData(TOKEN);
+        this.deleteStorageData(REFRESH_TOKEN);
+    }
+    destroyUserData() {
+        this.userdata = undefined;
+        this.deleteStorageData(USERDATA);
+    }
+    saveCredentials(token, refreshToken) {
+        this.token = token;
+        this.refreshToken = refreshToken;
+        this.saveStorageData(TOKEN, token);
+        this.saveStorageData(REFRESH_TOKEN, refreshToken);
+        this.saveUserData(this.buildUserdataFromToken(token));
+    }
+    saveUserData(userData) {
+        this.userdata = userData;
+        this.saveStorageData(USERDATA, JSON.stringify(userData));
+    }
+    isLoggedIn() {
+        return !!this.userdata;
+    }
+    logout() {
+        let clientId = this.environment.authClient;
+        if (this.refreshToken) {
+            const decoded = this.jwtService.decodeToken(this.refreshToken);
+            clientId = decoded.azp;
+        }
+        return new Promise((resolve, reject) => {
+            this.logoutApiClient(clientId).subscribe(res => {
+                console.log(res);
+                this.destroyCredentials();
+                this.destroyUserData();
+                this.goToLogin();
+                resolve(null);
+            }, (err) => {
+                this.destroyCredentials();
+                this.destroyUserData();
+                console.error(err);
+                reject(err);
+            });
+        });
+    }
+    getNewToken(refreshToken) {
+        console.log('getNewToken');
+        const body = 'grant_type=refresh_token' + '&refresh_token=' + refreshToken + '&client_id=' + this.environment.authClient;
+        const headers = new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded');
+        return this.http.post(`${this.environment.authEndPoint}/realms/${this.environment.authRealm}/protocol/openid-connect/token`, body, { headers })
+            .pipe(map(res => res));
+    }
+    getNewTokenClient(refreshToken, clientId) {
+        console.log('getNewToken');
+        const body = 'grant_type=refresh_token' + '&refresh_token=' + refreshToken + '&client_id=' + clientId;
+        const headers = new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded');
+        return this.http.post(`${this.environment.authEndPoint}/realms/${this.environment.authRealm}/protocol/openid-connect/token`, body, { headers })
+            .pipe(map(res => res));
+    }
+    getTokenClientCode(refreshToken, clientId) {
+        console.log('getNewToken');
+        const body = 'grant_type=refresh_token' + '&refresh_token=' + refreshToken + '&client_id=' + clientId;
+        const headers = new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded');
+        return this.http.post(`${this.environment.authEndPoint}/realms/${this.environment.authRealm}/protocol/openid-connect/token`, body, { headers })
+            .pipe(map(res => res));
+    }
+    getLoginUrl() {
+        return this.http.get(this.endPoint + '/auth/login/url/' + this.environment.authClient)
+            .pipe(map(res => res));
+    }
+    getHomeUrl() {
+        return this.http.get(this.endPoint + '/auth/home/url/' + this.environment.authClient)
+            .pipe(map(res => res));
+    }
+    logoutApi() {
+        const body = 'refresh_token=' + this.refreshToken + '&client_id=' + this.environment.authClient;
+        const headers = new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded');
+        return this.http.post(`${this.environment.authEndPoint}/realms/${this.environment.authRealm}/protocol/openid-connect/logout`, body, { headers })
+            .pipe(map(res => res));
+    }
+    logoutApiClient(clientId) {
+        const body = 'refresh_token=' + this.refreshToken + '&client_id=' + clientId;
+        const headers = new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded');
+        return this.http.post(`${this.environment.authEndPoint}/realms/${this.environment.authRealm}/protocol/openid-connect/logout`, body, { headers })
+            .pipe(map(res => res));
+    }
+    goToLogin() {
+        this.getLoginUrl().subscribe(res => {
+            console.log(res);
+            const loginUrl = res.data;
+            window.location.href = loginUrl;
+        }, (err) => {
+            console.error(err);
+        });
+    }
+    loadSessionData() {
+        let data;
+        let token;
+        let refreshToken;
+        if (this.environment.production) {
+            const u = this.cryptoService.encrypt(USERDATA);
+            const t = this.cryptoService.encrypt(TOKEN);
+            const r = this.cryptoService.encrypt(REFRESH_TOKEN);
+            data = window.localStorage.getItem(u);
+            token = window.localStorage.getItem(t);
+            refreshToken = window.localStorage.getItem(r);
+            if (data && token && refreshToken) {
+                data = this.cryptoService.decrypt(data);
+                token = this.cryptoService.decrypt(token);
+                refreshToken = this.cryptoService.decrypt(refreshToken);
+            }
+        }
+        else {
+            data = window.localStorage.getItem(USERDATA);
+            token = window.localStorage.getItem(TOKEN);
+            refreshToken = window.localStorage.getItem(REFRESH_TOKEN);
+        }
+        if (data && token && refreshToken) {
+            const user = JSON.parse(data);
+            this.setTokens(token, refreshToken);
+            this.setUserdata(user);
+        }
+    }
+    userHasOptionsInApp(userId, applicationId) {
+        return this.http.get(this.endPoint + `/security/option/${applicationId}/${userId}`)
+            .pipe(map(res => res));
+    }
+    checkAppPermissions() {
+        const promise = new Promise((resolve, reject) => {
+            console.log(this.userdata?.userId, this.applicationId);
+            if (this.applicationId) {
+                this.userHasOptionsInApp(this.userdata?.userId, this.applicationId).subscribe(res => {
+                    console.log(res);
+                    if (res.data) {
+                        resolve('ok');
+                    }
+                    else {
+                        this.getHomeUrl().subscribe(res1 => {
+                            console.log(res1);
+                            const homeUrl = res1.data;
+                            window.location.href = homeUrl;
+                            reject('nok');
+                        }, (err) => {
+                            console.error(err);
+                            reject('nok');
+                        });
+                    }
+                }, (err) => {
+                    console.error(err);
+                    reject('nok');
+                });
+            }
+            else {
+                resolve('ok');
+            }
+        });
+        return promise;
+    }
+    // eslint-disable-next-line max-len
+    getOptionsUser(applicationId, type, language, entityCode, parentOptionId, includeData) {
+        const param = {
+            userId: this.userdata?.userId,
+            applicationId,
+            type,
+            language,
+            entityCode,
+            parentOptionId,
+            includeData
+        };
+        return this.http.post(this.endPoint + '/security/option/user', param)
+            .pipe(map(res => res));
+    }
+    registerException(param) {
+        const headers = new HttpHeaders().set('skipError', 'true');
+        return this.http.post(this.endPoint + '/auth/exception/log', param, { headers })
+            .pipe(map(res => res));
+    }
+    saveStorageData(key, value) {
+        if (this.environment.production) {
+            const k = this.cryptoService.encrypt(key);
+            const v = this.cryptoService.encrypt(value);
+            window.localStorage.setItem(k, v);
+        }
+        else {
+            window.localStorage.setItem(key, value);
+        }
+    }
+    deleteStorageData(key) {
+        if (this.environment.production) {
+            const k = this.cryptoService.encrypt(key);
+            window.localStorage.removeItem(k);
+        }
+        else {
+            window.localStorage.removeItem(key);
+        }
+    }
+    getStorageData(key) {
+        let res;
+        if (this.environment.production) {
+            const k = this.cryptoService.encrypt(key);
+            const v = window.localStorage.getItem(k);
+            if (v) {
+                res = this.cryptoService.decrypt(v);
+                return res;
+            }
+            else {
+                res = null;
+            }
+        }
+        else {
+            res = window.localStorage.getItem(key);
+        }
+        return res;
+    }
+    removeUrlData() {
+        const url = new URL(window.location.href);
+        const queryParams = url.searchParams;
+        queryParams.delete('code');
+        const newUrl = url.origin + url.pathname + '?' + queryParams.toString();
+        window.history.replaceState({}, document.title, newUrl);
+    }
+    checkSessionData() {
+        const promise = new Promise((resolve, reject) => {
+            let data;
+            let token;
+            let refreshToken;
+            const currentUrl = new URL(window.location.href);
+            const code = currentUrl.searchParams.get('code');
+            console.log('code', code);
+            if (code) {
+                const codeDecoded = this.getDecodedAuthCode(code);
+                // console.log('code', codeDecoded);
+                const decoded = this.jwtService.decodeToken(codeDecoded);
+                this.getTokenClientCode(codeDecoded, decoded.azp).subscribe({
+                    next: (res) => {
+                        console.log(res);
+                        token = res.access_token;
+                        refreshToken = res.refresh_token;
+                        this.saveCredentials(token, refreshToken);
+                        this.checkAppPermissions().then((res1) => {
+                            console.log(res1);
+                            this.removeUrlData();
+                            resolve('OK');
+                        }, (err) => {
+                            console.error(err);
+                            reject(err);
+                        });
+                    },
+                    error: (err) => {
+                        console.error(err);
+                        reject(err);
+                    }
+                });
+            }
+            else {
+                data = this.getStorageData(USERDATA);
+                token = this.getStorageData(TOKEN);
+                refreshToken = this.getStorageData(REFRESH_TOKEN);
+                if (data && token && refreshToken) {
+                    this.saveCredentials(token, refreshToken);
+                    this.checkAppPermissions().then((res1) => {
+                        console.log(res1);
+                        resolve('OK');
+                    }, (err) => {
+                        console.error(err);
+                        reject(err);
+                    });
+                }
+                else {
+                    const url = window.location.href;
+                    if (url.indexOf('/redirect') > -1) {
+                        resolve('OK');
+                    }
+                    else {
+                        this.destroyCredentials();
+                        this.destroyUserData();
+                        this.getLoginUrl().subscribe(res1 => {
+                            console.log(res1);
+                            this.loginUrl = res1.data;
+                            if (url.indexOf('/login') < 0 && url.indexOf('/forgot') < 0 &&
+                                url.indexOf('/reset') < 0 && url.indexOf('/verify') < 0 &&
+                                url.indexOf('/sign_up') < 0) {
+                                window.location.href = this.loginUrl + '?continue=' + encodeURIComponent(url);
+                            }
+                            resolve('NOK');
+                        }, (err) => {
+                            console.error(err);
+                            reject(err);
+                        });
+                    }
+                }
+            }
+        });
+        return promise;
+    }
+    checkSessionDataMicrofront() {
+        const promise = new Promise((resolve, reject) => {
+            let data;
+            let token;
+            let refreshToken;
+            if (this.environment.production) {
+                const u = this.cryptoService.encrypt(USERDATA);
+                const t = this.cryptoService.encrypt(TOKEN);
+                const r = this.cryptoService.encrypt(REFRESH_TOKEN);
+                const d1 = window.localStorage.getItem(u);
+                const d2 = window.localStorage.getItem(t);
+                const d3 = window.localStorage.getItem(r);
+                if (d1 && d2 && d3) {
+                    data = this.cryptoService.decrypt(d1);
+                    token = this.cryptoService.decrypt(d2);
+                    refreshToken = this.cryptoService.decrypt(d3);
+                }
+            }
+            else {
+                data = window.localStorage.getItem(USERDATA);
+                token = window.localStorage.getItem(TOKEN);
+                refreshToken = window.localStorage.getItem(REFRESH_TOKEN);
+            }
+            if (data && token && refreshToken) {
+                console.log('local session ok');
+                this.saveCredentials(token, refreshToken);
+                resolve('OK');
+            }
+            else {
+                console.error('local session nok');
+                reject('NOK');
+            }
+        });
+        return promise;
+    }
+    getAuthCode() {
+        const enc = this.cryptoService.encrypt(this.refreshToken ? this.refreshToken : '');
+        return encodeURIComponent(enc);
+    }
+    getDecodedAuthCode(code) {
+        const dec = decodeURIComponent(code);
+        return this.cryptoService.decrypt(dec);
+    }
+    refreshSession() {
+        const promise = new Promise((resolve, reject) => {
+            const refreshToken = this.getRefreshToken();
+            if (refreshToken) {
+                const decoded = this.jwtService.decodeToken(refreshToken);
+                this.getNewTokenClient(refreshToken, decoded.azp).subscribe({
+                    next: (res) => {
+                        console.log(res);
+                        this.setToken(res.access_token);
+                        this.setRefreshToken(res.refresh_token);
+                        this.saveCredentials(res.access_token, res.refresh_token);
+                        resolve('OK');
+                    },
+                    error: (err) => {
+                        console.error(err);
+                        reject(err);
+                    }
+                });
+            }
+            else {
+                reject('NOK');
+            }
+        });
+        return promise;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: SessionService, deps: [{ token: i1.HttpClient }, { token: 'environment' }, { token: i2.CryptoService }, { token: i3.JwtService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: SessionService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: SessionService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }, { type: i2.CryptoService }, { type: i3.JwtService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"session.service.js","sourceRoot":"","sources":["../../../../../projects/ssi-security-commons/src/lib/services/session.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable max-lines-per-function */\n/* eslint-disable arrow-body-style */\n/* eslint-disable @typescript-eslint/naming-convention */\nimport { Inject, Injectable } from '@angular/core';\nimport { HttpClient, HttpHeaders } from '@angular/common/http';\nimport { FrontEndException, UserData } from '../user.model';\nimport { Observable } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { JwtService } from './jwt.service';\nimport { CryptoService } from './crypto.service';\nimport { REFRESH_TOKEN, TOKEN, USERDATA } from '../shared/constants';\n\n\n@Injectable()\nexport class SessionService {\n\n  userdata: UserData | undefined;\n  token: string | undefined;\n  refreshToken: string | undefined;\n  endPoint: string;\n  loginUrl = 'http://localhost:4200/login';\n  applicationId: any;\n  environment: any;\n\n  constructor(private http: HttpClient,\n    @Inject('environment') environment: any,\n              private cryptoService: CryptoService,\n              private jwtService: JwtService) {\n    this.endPoint = environment.endPointCore;\n    this.applicationId = environment.applicationId;\n    this.environment = environment;\n  }\n\n  public buildUserdataFromToken(token: string): any {\n    const tokenData = this.jwtService.decodeToken(token);\n    const userData: UserData = {\n      givenName: tokenData.given_name,\n      familyName: tokenData.family_name,\n      name: tokenData.name,\n      roles: tokenData.realm_access.roles,\n      userId: tokenData.sub,\n      username: tokenData.preferred_username,\n      email: tokenData.email,\n      emailVerified: tokenData.email_verified,\n      countryCode: tokenData.country_code\n    };\n    return userData;\n  }\n\n  public async reviewSessionData(): Promise<any> {\n    const value = await this.checkSessionData() as any;\n    console.log(`async result: ${value}`);\n    return value;\n  }\n\n  public setUserdata(userdata: any): void {\n    this.userdata = userdata;\n  }\n\n  public setTokens(token: any, refreshToken: any): void {\n    this.token = token;\n    this.refreshToken = refreshToken;\n  }\n\n  public getUserdata(): UserData | undefined {\n    return this.userdata;\n  }\n\n  public setRefreshToken(refreshToken: any): void {\n    this.refreshToken = refreshToken;\n    this.saveStorageData(REFRESH_TOKEN, refreshToken);\n  }\n\n  public getRefreshToken(): string | undefined {\n    return this.refreshToken;\n  }\n\n  public setToken(token: any): any {\n    this.token = token;\n    this.saveStorageData(TOKEN, token);\n  }\n\n  public getToken(): any {\n    return this.token;\n  }\n\n  public destroyCredentials(): void {\n    this.token = undefined;\n    this.refreshToken = undefined;\n    this.deleteStorageData(TOKEN);\n    this.deleteStorageData(REFRESH_TOKEN);\n  }\n\n  public destroyUserData(): void {\n    this.userdata = undefined;\n    this.deleteStorageData(USERDATA);\n  }\n\n  public saveCredentials(token: any, refreshToken: any): void {\n    this.token = token;\n    this.refreshToken = refreshToken;\n    this.saveStorageData(TOKEN, token);\n    this.saveStorageData(REFRESH_TOKEN, refreshToken);\n    this.saveUserData(this.buildUserdataFromToken(token));\n  }\n\n  public saveUserData(userData: any): void {\n    this.userdata = userData;\n    this.saveStorageData(USERDATA, JSON.stringify(userData));\n  }\n\n  public isLoggedIn(): boolean {\n    return !!this.userdata;\n  }\n\n  logout(): Promise<any> {\n    let clientId = this.environment.authClient;\n    if (this.refreshToken) {\n      const decoded = this.jwtService.decodeToken(this.refreshToken);\n      clientId = decoded.azp;\n    }\n    return new Promise((resolve, reject) => {\n      this.logoutApiClient(clientId).subscribe(res => {\n        console.log(res);\n        this.destroyCredentials();\n        this.destroyUserData();\n        this.goToLogin();\n        resolve(null);\n      }, (err) => {\n        this.destroyCredentials();\n        this.destroyUserData();\n        console.error(err);\n        reject(err);\n      });\n    });\n  }\n\n  getNewToken(refreshToken: string): any {\n    console.log('getNewToken');\n    const body = 'grant_type=refresh_token' + '&refresh_token=' + refreshToken + '&client_id=' + this.environment.authClient;\n\n    const headers = new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded');\n    return this.http.post<any>(`${this.environment.authEndPoint}/realms/${this.environment.authRealm}/protocol/openid-connect/token`,\n      body, {headers})\n      .pipe(\n        map(res => res));\n  }\n\n  getNewTokenClient(refreshToken: string, clientId: string): any {\n    console.log('getNewToken');\n    const body = 'grant_type=refresh_token' + '&refresh_token=' + refreshToken + '&client_id=' + clientId;\n\n    const headers = new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded');\n    return this.http.post<any>(`${this.environment.authEndPoint}/realms/${this.environment.authRealm}/protocol/openid-connect/token`,\n      body, {headers})\n      .pipe(\n        map(res => res));\n  }\n\n  getTokenClientCode(refreshToken: string, clientId: string): Observable<any> {\n    console.log('getNewToken');\n    const body = 'grant_type=refresh_token' + '&refresh_token=' + refreshToken + '&client_id=' + clientId;\n\n    const headers = new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded');\n    return this.http.post<any>(`${this.environment.authEndPoint}/realms/${this.environment.authRealm}/protocol/openid-connect/token`,\n      body, {headers})\n      .pipe(\n        map(res => res));\n  }\n\n\n  getLoginUrl(): Observable<any> {\n    return this.http.get<any>(this.endPoint + '/auth/login/url/'+this.environment.authClient)\n      .pipe(\n        map(res => res));\n  }\n\n  getHomeUrl(): Observable<any> {\n    return this.http.get<any>(this.endPoint + '/auth/home/url/'+this.environment.authClient)\n      .pipe(\n        map(res => res));\n  }\n\n  logoutApi(): Observable<any> {\n    const body = 'refresh_token=' + this.refreshToken + '&client_id=' + this.environment.authClient;\n    const headers = new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded');\n    return this.http.post<any>(`${this.environment.authEndPoint}/realms/${this.environment.authRealm}/protocol/openid-connect/logout`,\n      body, {headers})\n      .pipe(\n        map(res => res));\n  }\n\n  logoutApiClient(clientId: string): Observable<any> {\n    const body = 'refresh_token=' + this.refreshToken + '&client_id=' + clientId;\n    const headers = new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded');\n    return this.http.post<any>(`${this.environment.authEndPoint}/realms/${this.environment.authRealm}/protocol/openid-connect/logout`,\n      body, {headers})\n      .pipe(\n        map(res => res));\n  }\n\n  goToLogin(): void {\n    this.getLoginUrl().subscribe(res => {\n      console.log(res);\n      const loginUrl = res.data;\n      window.location.href = loginUrl;\n    }, (err) => {\n      console.error(err);\n    });\n  }\n\n  public loadSessionData(): void {\n    let data;\n    let token;\n    let refreshToken;\n    if (this.environment.production) {\n      const u = this.cryptoService.encrypt(USERDATA);\n      const t = this.cryptoService.encrypt(TOKEN);\n      const r = this.cryptoService.encrypt(REFRESH_TOKEN);\n      data = window.localStorage.getItem(u);\n      token = window.localStorage.getItem(t);\n      refreshToken = window.localStorage.getItem(r);\n      if (data && token && refreshToken) {\n        data = this.cryptoService.decrypt(data);\n        token = this.cryptoService.decrypt(token);\n        refreshToken = this.cryptoService.decrypt(refreshToken);\n      }\n    } else {\n      data = window.localStorage.getItem(USERDATA);\n      token = window.localStorage.getItem(TOKEN);\n      refreshToken = window.localStorage.getItem(REFRESH_TOKEN);\n    }\n    if (data && token && refreshToken) {\n      const user = JSON.parse(data);\n      this.setTokens(token, refreshToken);\n      this.setUserdata(user);\n    }\n  }\n\n  userHasOptionsInApp(userId: any, applicationId: any): Observable<any> {\n    return this.http.get<any>(this.endPoint + `/security/option/${applicationId}/${userId}`)\n      .pipe(\n        map(res => res));\n  }\n\n  checkAppPermissions(): Promise<any> {\n    const promise = new Promise((resolve, reject) => {\n      console.log(this.userdata?.userId, this.applicationId);\n      if (this.applicationId) {\n        this.userHasOptionsInApp(this.userdata?.userId, this.applicationId).subscribe(res => {\n          console.log(res);\n          if (res.data) {\n            resolve('ok');\n          } else {\n            this.getHomeUrl().subscribe(res1 => {\n              console.log(res1);\n              const homeUrl = res1.data;\n              window.location.href = homeUrl;\n              reject('nok');\n            }, (err) => {\n              console.error(err);\n              reject('nok');\n            });\n          }\n        }, (err) => {\n          console.error(err);\n          reject('nok');\n        });\n      } else {\n        resolve('ok');\n      }\n    });\n    return promise;\n  }\n\n\n  // eslint-disable-next-line max-len\n  public getOptionsUser(applicationId: number | null, type: string | null, language: string | null, entityCode: string | null, parentOptionId: number | null, includeData: boolean | null): Observable<any> {\n    const param = {\n      userId: this.userdata?.userId,\n      applicationId,\n      type,\n      language,\n      entityCode,\n      parentOptionId,\n      includeData\n    };\n    return this.http.post<any>(this.endPoint + '/security/option/user', param)\n      .pipe(\n        map(res => res));\n  }\n\n  registerException(param: FrontEndException): Observable<any> {\n    const headers = new HttpHeaders().set('skipError', 'true');\n    return this.http.post<any>(this.endPoint + '/auth/exception/log', param, {headers})\n      .pipe(\n        map(res => res));\n  }\n\n  saveStorageData(key: string, value: string): void {\n    if (this.environment.production) {\n      const k = this.cryptoService.encrypt(key);\n      const v = this.cryptoService.encrypt(value);\n      window.localStorage.setItem(k, v);\n    } else {\n      window.localStorage.setItem(key, value);\n    }\n  }\n\n  deleteStorageData(key: string): void {\n    if (this.environment.production) {\n      const k = this.cryptoService.encrypt(key);\n      window.localStorage.removeItem(k);\n    } else {\n      window.localStorage.removeItem(key);\n    }\n  }\n\n  getStorageData(key: string): string | null {\n    let res: string | null;\n    if (this.environment.production) {\n      const k = this.cryptoService.encrypt(key);\n      const v = window.localStorage.getItem(k);\n      if (v) {\n        res = this.cryptoService.decrypt(v);\n        return res;\n      } else {\n        res = null;\n      }\n    } else {\n      res = window.localStorage.getItem(key);\n    }\n    return res;\n  }\n\n\n  public removeUrlData(): void {\n    const url = new URL(window.location.href);\n    const queryParams = url.searchParams;\n    queryParams.delete('code');\n    const newUrl = url.origin + url.pathname + '?' + queryParams.toString();\n    window.history.replaceState({}, document.title, newUrl);\n  }\n\n  public checkSessionData(): Promise<any> {\n    const promise = new Promise((resolve, reject) => {\n      let data;\n      let token;\n      let refreshToken;\n\n      const currentUrl = new URL(window.location.href);\n      const code = currentUrl.searchParams.get('code');\n      console.log('code', code);\n      if (code) {\n        const codeDecoded = this.getDecodedAuthCode(code);\n        // console.log('code', codeDecoded);\n        const decoded = this.jwtService.decodeToken(codeDecoded);\n        this.getTokenClientCode(codeDecoded, decoded.azp).subscribe({\n          next: (res) => {\n            console.log(res);\n            token = res.access_token;\n            refreshToken = res.refresh_token;\n            this.saveCredentials(token, refreshToken);\n            this.checkAppPermissions().then((res1) => {\n              console.log(res1);\n              this.removeUrlData();\n              resolve('OK');\n            }, (err) => {\n              console.error(err);\n              reject(err);\n            });\n          },\n          error: (err) => {\n            console.error(err);\n            reject(err);\n          }\n        });\n      } else {\n        data = this.getStorageData(USERDATA);\n        token = this.getStorageData(TOKEN);\n        refreshToken = this.getStorageData(REFRESH_TOKEN);\n        if (data && token && refreshToken) {\n          this.saveCredentials(token, refreshToken);\n          this.checkAppPermissions().then((res1) => {\n            console.log(res1);\n            resolve('OK');\n          }, (err) => {\n            console.error(err);\n            reject(err);\n          });\n        } else {\n          const url = window.location.href;\n          if (url.indexOf('/redirect')>-1) {\n            resolve('OK');\n          } else {\n            this.destroyCredentials();\n            this.destroyUserData();\n            this.getLoginUrl().subscribe(res1 => {\n              console.log(res1);\n              this.loginUrl = res1.data;\n              if (url.indexOf('/login')<0 && url.indexOf('/forgot')<0 &&\n                  url.indexOf('/reset')<0 && url.indexOf('/verify')<0 &&\n                  url.indexOf('/sign_up')<0) {\n                window.location.href = this.loginUrl + '?continue='+encodeURIComponent(url);\n              }\n              resolve('NOK');\n            }, (err) => {\n              console.error(err);\n              reject(err);\n            });\n          }\n        }\n      }\n    });\n    return promise;\n  }\n\n\n\n  public checkSessionDataMicrofront(): Promise<any> {\n    const promise = new Promise((resolve, reject) => {\n      let data;\n      let token;\n      let refreshToken;\n      if (this.environment.production) {\n        const u = this.cryptoService.encrypt(USERDATA);\n        const t = this.cryptoService.encrypt(TOKEN);\n        const r = this.cryptoService.encrypt(REFRESH_TOKEN);\n        const d1 = window.localStorage.getItem(u);\n        const d2 = window.localStorage.getItem(t);\n        const d3 = window.localStorage.getItem(r);\n        if (d1 && d2 && d3) {\n          data = this.cryptoService.decrypt(d1);\n          token = this.cryptoService.decrypt(d2);\n          refreshToken = this.cryptoService.decrypt(d3);\n        }\n      } else {\n        data = window.localStorage.getItem(USERDATA);\n        token = window.localStorage.getItem(TOKEN);\n        refreshToken = window.localStorage.getItem(REFRESH_TOKEN);\n      }\n      if (data && token && refreshToken) {\n        console.log('local session ok');\n        this.saveCredentials(token, refreshToken);\n        resolve('OK');\n      } else {\n        console.error('local session nok');\n        reject('NOK');\n      }\n    });\n    return promise;\n  }\n\n  public getAuthCode(): string {\n    const enc = this.cryptoService.encrypt(this.refreshToken?this.refreshToken:'');\n    return encodeURIComponent(enc);\n  }\n\n  private getDecodedAuthCode(code: string): string {\n    const dec = decodeURIComponent(code);\n    return this.cryptoService.decrypt(dec);\n  }\n\n  public refreshSession(): Promise<any> {\n    const promise = new Promise((resolve, reject) => {\n      const refreshToken = this.getRefreshToken();\n      if (refreshToken) {\n        const decoded = this.jwtService.decodeToken(refreshToken);\n        this.getNewTokenClient(refreshToken, decoded.azp).subscribe({\n          next: (res: any) => {\n            console.log(res);\n            this.setToken(res.access_token);\n            this.setRefreshToken(res.refresh_token);\n            this.saveCredentials(res.access_token, res.refresh_token);\n            resolve('OK');\n          },\n          error: (err: any) => {\n            console.error(err);\n            reject(err);\n          }\n        });\n      } else {\n        reject('NOK');\n      }\n    });\n    return promise;\n  }\n\n}\n\n"]}

package/esm2022/lib/services/user-event.service.mjs

@@ -0,0 +1,31 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class UserEventService {
+    constructor(http, environment) {
+        this.http = http;
+        this.endPoint = environment.endPointCore;
+    }
+    registerUserEvent(eventType, optionId, entityType, entityId, paramsIn, paramsOut) {
+        const param = {
+            eventType,
+            optionId,
+            entityType,
+            entityId,
+            paramsIn,
+            paramsOut
+        };
+        return this.http.post(this.endPoint + '/security/user/event', param)
+            .pipe(map((res) => res));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: UserEventService, deps: [{ token: i1.HttpClient }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: UserEventService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: UserEventService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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