new-front-common-library 16.1.32-ROY-2 → 16.1.32-ROY-3

package/src/lib/util/services/elasticsearch/subsidiaries.service.ts

@@ -0,0 +1,48 @@
+import {inject, Injectable} from "@angular/core";
+import {SubsidiaryModel} from "../../models";
+import {LegalApiService} from "../api/legal-api.service";
+
+@Injectable({providedIn: 'root'})
+export class SubsidiariesService {
+
+  private readonly legalService: LegalApiService = inject(LegalApiService);
+
+  private defaultMapping: Record<number, number[]> = {
+    1: [4991],
+    2: [332, 333, 334, 739, 335, 1379, 1380, 4988, 4990],
+    3: [332, 333, 334, 739, 335, 1379, 1380, 4988, 4990],
+    4: [332, 333, 334, 739, 335, 1379, 1380, 4988, 4990],
+    5: [332, 333, 334, 739, 335, 1379, 1380, 4988, 4990],
+    6: [332, 333, 334, 739, 335, 1379, 1380, 4988, 4990],
+    7: [332, 333, 334, 739, 335, 1379, 1380, 4988, 4990]
+  }
+
+  private subsidiaryToSocieteMapLegal: Record<number, number[]> = {};
+
+  constructor() {
+    this.loadTableSocieteAppartenance();
+  }
+  loadTableSocieteAppartenance() {
+    this.legalService.getMappingSocietesSubsidiaries().subscribe({
+      next: (map: Record<number, number[]>) => {
+        this.subsidiaryToSocieteMapLegal = map;
+      },
+      error: () => {
+        console.log('Default mapping for subsidiaryToSocieteMapLegal');
+        this.subsidiaryToSocieteMapLegal = {...this.defaultMapping};
+      }
+    })
+  }
+
+  getSocieteAppartenance(subsidiaries: SubsidiaryModel[]) {
+    if (subsidiaries === null) {
+      return null;
+    }
+    return subsidiaries
+      .reduce((acc: number[], sub) => {
+        const societes = this.subsidiaryToSocieteMapLegal[sub.id] || [];
+        return acc.concat(societes);
+      }, [])
+      .filter((v, i, arr) => arr.indexOf(v) === i);
+  }
+}

package/src/lib/util/services/form-action/form-actions-events.service.ts

@@ -0,0 +1,25 @@
+import { EventEmitter, Injectable } from '@angular/core';
+
+@Injectable()
+export class FormActionsEventsService {
+
+    public updateEvent: EventEmitter<boolean> = new EventEmitter<boolean>(true);
+    public consultToEdit: EventEmitter<boolean> = new EventEmitter<boolean>(true);
+    public EditToConsult: EventEmitter<boolean> = new EventEmitter<boolean>(true);
+    public consultToDuplicate: EventEmitter<boolean> = new EventEmitter<boolean>(true);
+
+    constructor() {
+    }
+
+    public emitUpdateEvent() {
+        this.updateEvent.emit();
+    }
+
+    public emitEventIsUpdateTrue() {
+        this.consultToEdit.emit(true);
+    }
+
+    public emitConsultEvent() {
+        this.EditToConsult.emit();
+    }
+}

package/src/lib/util/services/guard/auth.guard.ts

@@ -0,0 +1,44 @@
+import {ActivatedRouteSnapshot, CanActivateFn, RouterStateSnapshot } from '@angular/router';
+import { WEB_CONFIG } from '../../config';
+import { CookieService } from 'ngx-cookie-service';
+import { CommonApiService } from '../api/common-api.service';
+import { catchError, map } from 'rxjs/operators';
+import { AuthUserModel } from '../../models';
+import { inject } from '@angular/core';
+import { AuthService } from '../auth/auth.service';
+import { of } from "rxjs";
+
+export const authGuard: CanActivateFn = (
+  route: ActivatedRouteSnapshot,
+  state: RouterStateSnapshot
+) => {
+  const cookieService = inject(CookieService);
+  const commonApiService = inject(CommonApiService);
+  const webConfig = inject(WEB_CONFIG);
+  const authService = inject(AuthService);
+
+  if (state.url.includes('/login/invalid')) {
+    return true;
+  }
+
+  if (commonApiService.isTokenValid()) {
+    authService.setAuthenticated(true);
+    return true;
+  }
+
+  const user: AuthUserModel = commonApiService.getUserDataFromToken();
+  const email: string = user.secondary ? user.email : cookieService.get('auth-mail');
+
+  return commonApiService.ssoLogin(email).pipe(
+    map((data) => {
+      user.secondary ? commonApiService.setSecondaryToken(data.token) : commonApiService.setToken(data.token);
+      authService.setAuthenticated(true);
+      return true;
+    }),
+    catchError(() => {
+      authService.setAuthenticated(false);
+      window.location.href = webConfig.api_url + '/login/invalid';
+      return of(false);
+    })
+  );
+};

package/src/lib/util/services/guard/login.guard.ts

@@ -0,0 +1,26 @@
+import { inject } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { MyDialogPopupLoginComponent } from '../../component/popup/popup-login/popup-login.component';
+import { AuthService } from '../auth/auth.service';
+import {map} from "rxjs/operators";
+
+export const loginGuard = () => {
+    const dialog = inject(MatDialog);
+    const authService = inject(AuthService);
+
+  if (sessionStorage.getItem('authToken') !== null) {
+      authService.setAuthenticated(true);
+      return true;
+  } else {
+    const dialogRef = dialog.open(MyDialogPopupLoginComponent, {
+      disableClose: true
+    });
+
+    return dialogRef.afterClosed().pipe(
+      map((res: boolean) => {
+        authService.setAuthenticated(res);
+        return res;
+      })
+    );
+  }
+};

package/src/lib/util/services/history/history.service.ts

@@ -0,0 +1,38 @@
+import { Injectable } from '@angular/core';
+import { LocalStorageService } from '../storage/local-storage.service';
+
+@Injectable()
+export class HistoryService {
+
+    constructor(private localStorage: LocalStorageService) {
+    }
+
+    public add(type: 'PRODUCT' | 'PO' | 'DEAL' | 'WORK' | 'CONTRACT_ACQ' | 'CONTRACT_CESS' | 'CONTRACT_AUTH' | 'BUDGET', id: string, ref: any) {
+        let history = [];
+        if (this.localStorage.exist('history')) {
+            history = this.localStorage.get('history');
+        }
+        // DELETE EXISTING SCREEN
+        history.forEach((element, index) => {
+            if (this.exist(type, id, ref, element)) history.splice(index, 1);
+        });
+        // ADD THE LAST CONSULTED SCREEN TO THE BEGINNING
+        history.unshift({type: type, id: id, ref: ref});
+
+        // SHOW ONLY THE 10 LAST CONSULTED SCREENS
+        if (history.length >= 10) {
+            history = history.slice(0, 10);
+        }
+
+        // POST TO LOCAL STORAGE
+        this.localStorage.post('history', history);
+    }
+
+    private exist(type: 'PRODUCT' | 'PO' | 'DEAL' | 'WORK' | 'CONTRACT_ACQ' | 'CONTRACT_CESS' | 'CONTRACT_AUTH' | 'BUDGET', id: string, ref: string, history: any) {
+        if (type == history.type && id == history.id && ref == history.ref) {
+            return true;
+        }
+        return false;
+    }
+
+}

package/src/lib/util/services/interceptor/auth.interceptor.ts

@@ -0,0 +1,66 @@
+import { Injectable } from '@angular/core';
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { filter, switchMap, take } from 'rxjs/operators';
+import { CookieService } from 'ngx-cookie-service';
+import { CommonApiService } from '../api/common-api.service';
+import { AuthUserModel } from '../../models';
+
+@Injectable()
+export class AuthInterceptor implements HttpInterceptor {
+
+    private refreshTokenInProgress = false;
+    private refreshTokenSubject: BehaviorSubject<any> = new BehaviorSubject<any>(
+        null
+    );
+
+    constructor(
+        private authService: CommonApiService,
+        private cookieService: CookieService
+    ) {
+    }
+
+    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+        if (request.url.includes('/login/email') || request.url.includes('/login/findUser') || request.url.startsWith('./')) {
+            return next.handle(request);
+        }
+
+        if (!this.authService.isTokenValid()) {
+            if (this.refreshTokenInProgress) {
+                return this.refreshTokenSubject.pipe(
+                    filter((result) => result !== null),
+                    take(1),
+                    switchMap(() => next.handle(this.addToken(request)))
+                );
+            } else {
+                this.refreshTokenInProgress = true;
+                this.refreshTokenSubject.next(null);
+                const user: AuthUserModel = this.authService.getUserDataFromToken();
+                const email: string = user.secondary ? user.email : this.cookieService.get('auth-mail');
+
+                return this.authService.ssoLogin(email)
+                    .pipe(
+                        switchMap((data: any) => {
+                            this.authService.setToken(data.token);
+                            this.refreshTokenInProgress = false;
+                            this.refreshTokenSubject.next(data.token);
+                            return next.handle(this.addToken(request));
+                        })
+                    );
+            }
+        }
+
+        return next.handle(this.addToken(request));
+    }
+
+    private addToken(request: HttpRequest<any>): HttpRequest<any> {
+        const token = this.authService.getToken();
+        if (!token) {
+            return request;
+        }
+
+        return request.clone({
+            headers: request.headers.set('Authorization', `Bearer ${token}`)
+        });
+    }
+}

package/src/lib/util/services/jwt-security/aes.service.ts

@@ -0,0 +1,48 @@
+import { Injectable } from '@angular/core';
+import * as CryptoJS from 'crypto-js';
+
+@Injectable()
+export class AesService {
+
+    // private SECRET_CODE: string ;
+    private readonly SECRET_CODE: string = '1234567891234567';
+    private keySize: number = 128 / 32;
+    private iterationCount = 1000;
+    // private  iv: string  ;
+    // private salt: string ;
+    private pwdEncrypted: string;
+
+    // private cipherText: string;
+
+    constructor() {
+    }
+
+    public generateKey(salt: string) {
+
+        // this.SECRET_CODE = sessionStorage.getItem('_uniqueKey');
+        const key = CryptoJS.PBKDF2(
+            this.SECRET_CODE,
+            CryptoJS.enc.Hex.parse(salt),
+            {keySize: this.keySize, iterations: this.iterationCount});
+
+        return key;
+    }
+
+    public encrypt(planText: string) {
+        const iv = CryptoJS.lib.WordArray.random(16).toString(CryptoJS.enc.Hex);
+        const salt = CryptoJS.lib.WordArray.random(16).toString(CryptoJS.enc.Hex);
+
+        const key = this.generateKey(salt);
+
+        const encrypted = CryptoJS.AES.encrypt(planText, key, {iv: CryptoJS.enc.Hex.parse(iv)});
+
+        const cipherText = encrypted.ciphertext.toString(CryptoJS.enc.Base64);
+
+        const aesPassword = (iv + '::' + salt + '::' + cipherText);
+        // conversion en base 64
+        this.pwdEncrypted = btoa(aesPassword);
+
+        return this.pwdEncrypted;
+    }
+
+}

package/src/lib/util/services/jwt-security/interceptorhttp.service.ts

@@ -0,0 +1,98 @@
+import { Injectable } from '@angular/core';
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
+import { Observable } from 'rxjs';
+
+const AUTH_HEADER_KEY = 'Authorization';
+const AUTH_PREFIX = 'Bearer ';
+const TOKEN_NAME = 'authToken';
+
+@Injectable()
+export class InterceptorHttpService implements HttpInterceptor {
+
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+        const token = `${AUTH_PREFIX}${sessionStorage.getItem(TOKEN_NAME)}`;
+        req.headers.set(AUTH_HEADER_KEY, `${AUTH_PREFIX} ${token}`);
+        return next.handle(req);
+    }
+
+    // TODO à refaire lorsque l'on réactivera l'interceptor du BACK d'orphe
+    // public request(url: string | Request): Observable<Response> {
+    //
+    //   const token = sessionStorage.getItem(TOKEN_NAME);
+    //
+    //   const options = {headers: new Headers()};
+    //   if (typeof url === 'string') {
+    //
+    //     options.headers.set(AUTH_HEADER_KEY, `${AUTH_PREFIX} ${token}`);
+    //   } else {
+    //     url.headers.set(AUTH_HEADER_KEY, `${AUTH_PREFIX} ${token}`);
+    //   }
+    //   return super.request(url, options).catch(this.catchError);
+    // }
+    //
+    // public get(url: string, options?): Observable<Response> {
+    //   const enhacedOptions = this.setAuthorizationHeader(options);
+    //   return super.get(url, enhacedOptions).pipe(catchError(this.catchError));
+    // }
+    //
+    // public post(url: string, body: any, options?): Observable<Response> {
+    //   const enhacedOptions = this.setAuthorizationHeader(options);
+    //   return super.post(url, body, enhacedOptions).pipe(catchError(this.catchError));
+    // }
+    //
+    // public put(url: string, body: any, options?): Observable<Response> {
+    //   const enhacedOptions = this.setAuthorizationHeader(options);
+    //   return super.put(url, body, enhacedOptions).pipe(catchError(this.catchError));
+    // }
+    //
+    // public delete(url: string, options?): Observable<Response> {
+    //   const enhacedOptions = this.setAuthorizationHeader(options);
+    //   return super.delete(url, enhacedOptions).pipe(catchError(this.catchError));
+    // }
+    //
+    // public patch(url: string, body: any, options?): Observable<Response> {
+    //   const enhacedOptions = this.setAuthorizationHeader(options);
+    //   return super.patch(url, body, enhacedOptions).pipe(catchError(this.catchError));
+    // }
+    //
+    // public head(url: string, options?): Observable<Response> {
+    //   const enhacedOptions = this.setAuthorizationHeader(options);
+    //   return super.head(url, enhacedOptions).pipe(catchError(this.catchError));
+    // }
+    //
+    // public options(url: string, options?): Observable<Response> {
+    //   const enhacedOptions = this.setAuthorizationHeader(options);
+    //   return super.options(url, enhacedOptions).pipe(catchError(this.catchError));
+    // }
+    //
+    // // Ajout de l'attribut Authorization au Header
+    // private setAuthorizationHeader(options?) {
+    //
+    //   const token = `${AUTH_PREFIX}${sessionStorage.getItem(TOKEN_NAME)}`;
+    //   // Copie du header dans le RequestOptions et ajout du token a 'Authorization'
+    //   const headers = {
+    //     ...options.headers.toJSON(),
+    //     Authorization: token
+    //   };
+    //   options.headers = new Headers(headers);
+    //   return options;
+    // }
+    //
+    // // Response Interceptor
+    // private catchError(error: any): Observable<any> {
+    //
+    //   if (error instanceof HttpErrorResponse) {
+    //     return Observable.throw(error);
+    //   } else if (error instanceof Response) {
+    //     if (sessionStorage.getItem('loginFlag') === 'true' && error.status === 401) {
+    //       sessionStorage.removeItem(TOKEN_NAME);
+    //       sessionStorage.removeItem('loginFlag');
+    //       window.location.reload();
+    //     }
+    //     return Observable.throw(error);
+    //   } else {
+    //     return Observable.throw(error);
+    //   }
+    // }
+}
+

package/src/lib/util/services/jwt-security/jwt.helpher.ts

@@ -0,0 +1,38 @@
+export class JwtHelper {
+
+    public decodeToken(token: string) {
+        let parts = token.split('.');
+        if (parts.length !== 3) {
+            throw new Error('JWT must have 3 parts');
+        }
+        let decoded = this.urlBase64Decode(parts[1]);
+        if (!decoded) {
+            throw new Error('Cannot decode the token');
+        }
+        return JSON.parse(decoded);
+    }
+
+    private urlBase64Decode(str: string) {
+        let output = str.replace(/-/g, '+').replace(/_/g, '/');
+        switch (output.length % 4) {
+            case 0: {
+                break;
+            }
+            case 2: {
+                output += '==';
+                break;
+            }
+            case 3: {
+                output += '=';
+                break;
+            }
+            default: {
+                throw 'Illegal base64url string!';
+            }
+        }
+        return decodeURIComponent((<any>window).escape(window.atob(output)));
+
+    }
+
+
+}

package/src/lib/util/services/storage/local-storage.service.ts

@@ -0,0 +1,36 @@
+import { Injectable } from '@angular/core';
+import { LocalStorageEventsService } from '../../event/storage/local-storage-events.service';
+
+@Injectable()
+export class LocalStorageService {
+
+    constructor(private localStorageEvents: LocalStorageEventsService) {
+    }
+
+    // Check if the data exist in the session storage
+    public exist(key: string) {
+        return localStorage.hasOwnProperty(key);
+    }
+
+    public get(key: string) {
+        return this.exist(key) ? JSON.parse(localStorage.getItem(key)) : null;
+    }
+
+    public post(key: string, data: any) {
+        localStorage.setItem(key, JSON.stringify(data));
+        this.localStorageEvents.emitLocalStorageEvent();
+    }
+
+    // check if the key exist in the local storage and if it equals to the value param
+    public contains(key: string, data: any) {
+        return localStorage.getItem(key).indexOf(JSON.stringify(data)) !== -1 ? true : false;
+    }
+
+    public delete(key: string): boolean {
+        if (this.exist(key)) {
+            localStorage.removeItem(key);
+            return true;
+        }
+        return false;
+    }
+}

package/src/lib/util/services/storage/session-storage.service.ts

@@ -0,0 +1,39 @@
+// Angular 2
+import { Injectable } from '@angular/core';
+import { SessionStorageEventsService } from '../../event/storage/session-storage-events.service';
+
+// Services
+
+@Injectable()
+export class SessionStorageService {
+
+    constructor(private sessionsStorageEvents: SessionStorageEventsService) {
+    }
+
+    // Check if the data exist in the session storage
+    public exist(key: string) {
+        return (undefined !== sessionStorage.getItem(key) && null !== sessionStorage.getItem(key)) ? true : false;
+    }
+
+    public get(key: string) {
+        return this.exist(key) ? JSON.parse(sessionStorage.getItem(key)) : null;
+    }
+
+    public post(key: string, data: any) {
+        sessionStorage.setItem(key, JSON.stringify(data));
+        this.sessionsStorageEvents.emitUpdate();
+    }
+
+    // check if the key exist in the session storage and if it equals to the value param
+    public contains(key: string, data: any) {
+        return this.get(key).indexOf(JSON.stringify(data)) !== -1 ? true : false;
+    }
+
+    public delete(key: string): boolean {
+        if (this.exist(key)) {
+            sessionStorage.removeItem(key);
+            return true;
+        }
+        return false;
+    }
+}

package/src/lib/util/services/translate-language/lang.service.ts

@@ -0,0 +1,26 @@
+import { EventEmitter, Injectable } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { LocalStorageService } from "../storage/local-storage.service";
+
+@Injectable()
+export class LangService {
+    public switchLangEmitter: EventEmitter<any> = new EventEmitter();
+
+    constructor(private translate: TranslateService, private localStorage: LocalStorageService) {
+    }
+
+    translateLanguage() {
+        this.translate.addLangs(['en', 'fr', 'de']);
+        if (this.localStorage.exist('lang') && this.translate.getLangs().indexOf(this.localStorage.get('lang')) != -1) {
+            this.translate.use(this.localStorage.get('lang'));
+        } else {
+            this.translate.use(this.translate.getLangs().indexOf(this.translate.getBrowserLang()) != -1 ? this.translate.getBrowserLang() : 'en');
+        }
+        this.localStorage.post('lang', this.translate.currentLang);
+    }
+
+    // emit an event when local storage change
+    public switchLang() {
+        this.switchLangEmitter.emit();
+    }
+}