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

package/src/lib/util/pipes/my-number.pipe.ts

@@ -0,0 +1,51 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+const PADDING = '000000';
+
+@Pipe({name: 'myNumberFormat'})
+export class MyNumberPipe implements PipeTransform {
+    private DECIMAL_SEPARATOR: string;
+    private THOUSANDS_SEPARATOR: string;
+
+    constructor() {
+        // TODO comes from configuration settings
+        this.DECIMAL_SEPARATOR = '.';
+        this.THOUSANDS_SEPARATOR = ' ';
+    }
+
+    public transform(value: number | string, fractionSize: number): string {
+        if (value !== '' && value !== null) {
+            let [integer, fraction = ''] = value
+                .toString()
+                .split(this.DECIMAL_SEPARATOR);
+
+            fraction =
+                fractionSize > 0
+                    ? this.DECIMAL_SEPARATOR +
+                    (fraction + PADDING).substring(0, fractionSize)
+                    : '';
+
+            integer = integer.replace(
+                /\B(?=(\d{3})+(?!\d))/g,
+                this.THOUSANDS_SEPARATOR
+            );
+            return integer + fraction;
+        } else {
+            return null;
+        }
+    }
+
+    public parse(value: string, fractionSize: number): string {
+        let [integer, fraction = ''] = (value || '').split(this.DECIMAL_SEPARATOR);
+
+        integer = integer.replace(new RegExp(this.THOUSANDS_SEPARATOR, 'g'), '');
+
+        fraction =
+            parseInt(fraction, 10) > 0 && fractionSize > 0
+                ? this.DECIMAL_SEPARATOR +
+                (fraction + PADDING).substring(0, fractionSize)
+                : '';
+
+        return integer + fraction;
+    }
+}

package/src/lib/util/pipes/third-party-address-search.pipe.ts

@@ -0,0 +1,12 @@
+import {Pipe, PipeTransform} from '@angular/core';
+import {ThirdPartyAddressRapidSearchModel} from "../models/referential/third-party-address-rapid-search.model";
+
+@Pipe({name: 'thirdPartyAddressSearch'})
+export class ThirdPartyAddressSearchPipe implements PipeTransform {
+
+  transform(thirdPartyAddressSearch: ThirdPartyAddressRapidSearchModel, lang?: string): string {
+    const countryLabelMap = new Map<string, string>([['en', thirdPartyAddressSearch.countryEn], ['fr', thirdPartyAddressSearch.countryFr], ['de', thirdPartyAddressSearch.countryDe]]);
+    return thirdPartyAddressSearch?.street + '-' + thirdPartyAddressSearch?.zipCode + '-' + thirdPartyAddressSearch?.city + '-' + countryLabelMap.get(lang);
+  }
+
+}

package/src/lib/util/pipes/third-party-address.pipe.ts

@@ -0,0 +1,13 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import { AdressModel } from "../models";
+
+@Pipe({
+  name: 'thirdPartyAddress'
+})
+export class ThirdPartyAddressPipe implements PipeTransform {
+
+  transform(thirdPartyAddress: AdressModel, ...args: unknown[]): unknown {
+    return thirdPartyAddress?.street1 + '-' + thirdPartyAddress?.zipCode + '-' + thirdPartyAddress?.city + '-' + thirdPartyAddress?.country?.label;
+  }
+
+}

package/src/lib/util/pipes/trim-string.pipe.ts

@@ -0,0 +1,24 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({name: 'myTrimString'})
+export class TrimStringPipe implements PipeTransform {
+
+    public transform(value: string, size: number, message: string): string {
+        // Case 1: test value param
+        if (value === null || value === undefined || value === '') {
+            return value;
+        }
+
+        if (value.length < size) {
+            return value;
+        }
+
+        let posSpace = value.indexOf(' ', size);
+        if (posSpace !== -1) {
+            return value.substring(0, posSpace) + ' ' + message;
+        }
+
+        return value.substring(0, size) + ' ' + message;
+    }
+
+}

package/src/lib/util/regex/regex.service.ts

@@ -0,0 +1,94 @@
+import { Injectable } from '@angular/core';
+
+@Injectable()
+export class RegexService {
+    public isDecimalOrNegative(numberToCheck: number = null): boolean {
+        if (numberToCheck == null) {
+            return false;
+        } else {
+            const myRegexNoDecimal = new RegExp(/^\d+$/, 'i');
+            if (!myRegexNoDecimal.test(numberToCheck.toString())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public isMiloCode(value: string = null): boolean {
+        if (value == null) {
+            return false;
+        } else {
+            const regex = new RegExp(/^[C0-9][0-9]{5}$/, 'i');
+            if (regex.test(value.toString())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public isAmount(value: string = null): boolean {
+        if (value == null) {
+            return false;
+        } else {
+            const regex = new RegExp(/^\d+\.?\d*$/, 'i');
+            if (regex.test(value.toString())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public isYesNo(value: string = null): boolean {
+        if (value == null) {
+            return false;
+        } else {
+            const regex = new RegExp(/^(y|Y|n|N|o|O)$/, 'i');
+            if (regex.test(value.toString())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public isFinancialCondition(value: string = null): boolean {
+        if (value == null) {
+            return false;
+        } else {
+            const regex = new RegExp(/^(f|F|s|S|g|G)$/, 'i');
+            if (regex.test(value.toString())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public isOrderNumber(value: string = null): boolean {
+        if (value == null) {
+            return false;
+        } else {
+            const regex = new RegExp(
+                /^[5](6|8)(2|4|9)(N|O|Y)[0-9]{1}[C0-9][0-9]{5}[0-9]{1}$/,
+                'i'
+            );
+            if (regex.test(value.toString())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public isDate(value: string = null): boolean {
+        if (value == null) {
+            return false;
+        } else {
+            const regex = new RegExp(
+                /^([0-9]{2}[-][0-9]{2}[-][0-9]{4}|[0-9]{4}[-][0-9]{2}[-][0-9]{2})$/,
+                'i'
+            );
+            if (regex.test(value.toString())) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

package/src/lib/util/regex/regex.spec.ts

@@ -0,0 +1,45 @@
+/**
+ * Created by dstoian on 09/03/2017.
+ */
+import { RegexService } from './regex.service';
+
+describe('RegexService', () => {
+    let service: RegexService;
+
+    beforeEach(() => {
+        service = new RegexService();
+    });
+
+    it('should have method checkDecimalNumber()', () => {
+        expect(service.isDecimalOrNegative).toBeDefined();
+    });
+
+    describe('which', () => {
+
+        it('should return false if method has no param ', () => {
+            expect(service.isDecimalOrNegative()).toBeFalsy();
+        });
+
+        it('should return false if number is null', () => {
+            expect(service.isDecimalOrNegative(null)).toBeFalsy();
+        });
+
+        it('should return false if number is not decimal and not negative', () => {
+            expect(service.isDecimalOrNegative(10)).toBeFalsy();
+        });
+
+        it('should return true if number is negative', () => {
+            expect(service.isDecimalOrNegative(-10)).toBeTruthy();
+        });
+
+        it('should return true if number is decimal', () => {
+            expect(service.isDecimalOrNegative(10.5)).toBeTruthy();
+        });
+
+        it('should return true if number is decimal and negative', () => {
+            expect(service.isDecimalOrNegative(-10.5)).toBeTruthy();
+        });
+
+    });
+
+});

package/src/lib/util/services/api/commercial-api.service.ts

@@ -0,0 +1,23 @@
+import {Inject, Injectable} from '@angular/core';
+import {throwError} from "rxjs";
+import {Config, WEB_CONFIG} from "../../config";
+
+@Injectable()
+export class CommercialApiService {
+  public apiUrl: string = this.config.api_url + '/commercial-api/';
+
+  public header: Headers = new Headers({
+    'Content-Type': 'application/json'
+  });
+
+  constructor(@Inject(WEB_CONFIG) private config: Config) {
+  }
+
+  public static handleError(error: Response) {
+    return throwError(error.json() || 'api error');
+  }
+
+  public getAccountWrittingDownload() {
+    window.open(this.apiUrl + 'accounting-writing/get-account-writting-file');
+  }
+}

package/src/lib/util/services/api/common-api.service.ts

@@ -0,0 +1,121 @@
+import { ProductModel, PurchaseOrderModel } from '../../models';
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+// Angular2
+import { Inject, Injectable } from '@angular/core';
+import { Observable, throwError } from 'rxjs';
+import { Config, WEB_CONFIG } from '../../config';
+import { catchError } from 'rxjs/operators';
+import { CookieService } from 'ngx-cookie-service';
+import { JwtHelper } from '../jwt-security/jwt.helpher';
+
+
+const TOKEN_NAME = 'authToken';
+const SECONDARY_TOKEN_NAME = 'authTokenSecondary';
+
+@Injectable()
+export class CommonApiService {
+
+    public headers: HttpHeaders = new HttpHeaders({
+        'Content-Type': 'application/json'
+    });
+
+    public jwtHelper = new JwtHelper();
+
+    constructor(
+        @Inject(WEB_CONFIG) private config: Config,
+        private cookieService: CookieService,
+        private http: HttpClient
+    ) {
+    }
+
+    public static handleError(error) {
+        return throwError(error || 'api error');
+    }
+
+    // Global product search
+    public getProductGlobalSearch(
+        searchInput: string,
+        language: string
+    ): Observable<ProductModel[]> {
+        return this.http
+            .get<ProductModel[]>(
+                this.config.api_url +
+                '/video-api/products/globalSearch?searchInput=' +
+                searchInput +
+                '&language=' +
+                language
+            )
+            .pipe(catchError(CommonApiService.handleError));
+    }
+
+    public getPurchaseOrderByGlobalSearch(
+        searchInput: string,
+        language: string
+    ): Observable<PurchaseOrderModel[]> {
+        return this.http
+            .get<PurchaseOrderModel[]>(
+                this.config.api_url +
+                '/video-api/purchaseOrders/globalSearch?searchInput=' +
+                searchInput +
+                '&language=' +
+                language
+            )
+            .pipe(catchError(CommonApiService.handleError));
+    }
+
+    public setToken(token: string): void {
+        sessionStorage.removeItem(TOKEN_NAME);
+        sessionStorage.setItem(TOKEN_NAME, token);
+    }
+
+    public setSecondaryToken(token: string): void {
+        sessionStorage.removeItem(SECONDARY_TOKEN_NAME);
+        sessionStorage.setItem(SECONDARY_TOKEN_NAME, token);
+    }
+
+    getToken() {
+        const user = this.decodeToken(TOKEN_NAME);
+        if (user && user.superAdmin && sessionStorage.hasOwnProperty(SECONDARY_TOKEN_NAME)) {
+            return sessionStorage.getItem(SECONDARY_TOKEN_NAME);
+        }
+
+        return sessionStorage.getItem(TOKEN_NAME);
+    }
+
+    public decodeToken(tokenName: string) {
+        return sessionStorage.hasOwnProperty(tokenName) ? this.jwtHelper.decodeToken(sessionStorage.getItem(tokenName)) : {};
+    }
+
+    public getUserDataFromToken(): any {
+        const user = this.decodeToken(TOKEN_NAME);
+
+        if (user && user.superAdmin && sessionStorage.hasOwnProperty(SECONDARY_TOKEN_NAME)) {
+            return Object.assign({secondary: true}, this.decodeToken(SECONDARY_TOKEN_NAME));
+        }
+
+        return user;
+    }
+
+    public isTokenValid() {
+        let payload: any;
+        try {
+            payload = this.getUserDataFromToken();
+        } catch (e) {
+            payload = {};
+        }
+
+        if (!payload.exp) {
+            return false;
+        }
+
+        return payload.exp * 1000 > Date.now();
+    }
+
+    public ssoLogin(email: string): Observable<any> {
+        const url: string = this.config.api_url + '/authorization-api/login/email';
+
+        return this.http
+            .post(url, email, {headers: this.headers})
+            .pipe(catchError(CommonApiService.handleError));
+    }
+}

package/src/lib/util/services/api/legal-api.service.ts

@@ -0,0 +1,27 @@
+import {Inject, Injectable} from '@angular/core';
+import {Observable, throwError} from "rxjs";
+import {Config, WEB_CONFIG} from "../../config";
+import {catchError} from "rxjs/operators";
+import {HttpClient} from "@angular/common/http";
+
+@Injectable()
+export class LegalApiService {
+  public apiUrl: string = this.config.api_url + '/legal-api/';
+
+  public header: Headers = new Headers({
+    'Content-Type': 'application/json'
+  });
+
+  constructor(@Inject(WEB_CONFIG) private config: Config,
+              private http: HttpClient
+  ) {
+  }
+  public getMappingSocietesSubsidiaries(): Observable<Record<number, number[]>> {
+    return this.http.get<Record<number, number[]>>(this.apiUrl + 'subsidiaries/societe_mapping')
+      .pipe(catchError(this.handleError));
+  }
+
+  public handleError(error) {
+    return throwError(error || 'api error');
+  }
+}

package/src/lib/util/services/api/video-api.service.ts

@@ -0,0 +1,45 @@
+import {Inject, Injectable} from '@angular/core';
+import {HttpClient, HttpErrorResponse} from "@angular/common/http";
+import {Config, WEB_CONFIG} from "../../config";
+import {CookieService} from "ngx-cookie-service";
+import {Observable, throwError} from "rxjs";
+import {catchError} from "rxjs/operators";
+
+@Injectable()
+export class VideoApiService {
+
+  public apiUrl: string = this.config.api_url + '/video-api/';
+
+  public header: Headers = new Headers({
+    'Content-Type': 'application/json'
+  });
+
+  constructor(
+    @Inject(WEB_CONFIG) private config: Config,
+    private cookieService: CookieService,
+    private http: HttpClient
+  ) {
+  }
+
+  public static handleError(error: HttpErrorResponse) {
+    if (error.error instanceof ErrorEvent) {
+      // A client-side or network error occurred. Handle it accordingly.
+      console.error('An error occurred:', error.error.message);
+    } else {
+      // The backend returned an unsuccessful response code.
+      // The response body may contain clues as to what went wrong,
+      console.error(
+        `Backend returned code ${error.status}, ` +
+        `body was: ${error.ok}`);
+    }
+    // return an observable with a user-facing error message
+    return throwError(
+      'Something bad happened; please try again later.');
+  }
+
+  public getProductExtractionXlsx(lang: string): Observable<any> {
+    return this.http.get(this.apiUrl + `products/all-products-to-xlsx?language=${lang}`, { responseType: 'blob' })
+      .pipe(catchError(VideoApiService.handleError));
+  }
+
+}

package/src/lib/util/services/auth/auth.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { AuthService } from './auth.service';
+
+xdescribe('AuthService', () => {
+  let service: AuthService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(AuthService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

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

@@ -0,0 +1,14 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+
+@Injectable()
+export class AuthService {
+
+  private isAuthenticatedSubject = new BehaviorSubject<boolean>(false);
+
+  isAuthenticated$: Observable<boolean> = this.isAuthenticatedSubject.asObservable();
+
+  public setAuthenticated(isAuthenticated: boolean): void {
+    this.isAuthenticatedSubject.next(isAuthenticated);
+  }
+}

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

@@ -0,0 +1,179 @@
+import {Inject, Injectable} from '@angular/core';
+import {from, Observable} from 'rxjs';
+import {Client as ClientJs} from 'elasticsearch-browser';
+import {Client, MSearchResponse} from 'elasticsearch';
+import {PurchaseOrderRapidSearchModel} from "../../models/expenditure-commitment/purchase-order-rapid-search.model";
+import {ProductRapidSearchModel} from "../../models/video/product-rapid-search.model";
+import {Config, WEB_CONFIG} from '../../config';
+import {WorkVersionRapidSearchModel} from "../../models/referential/work-version-rapid-search.model";
+import {DealRapidSearchModel} from '../../models/commercial/deal-rapid-search-model';
+import {ThirdPartyRapidSearchModel} from "../../models/referential/third-party-rapid-search.model";
+import {WorkRecordRapidSearchModel} from "../../models/commercial/work-record-rapid-search-model";
+import {ContractRapidSearchModel} from "../../models/legal/contract-rapid-search-model";
+import {InvoiceRapidSearchModel} from "../../models/commercial/invoice-rapid-search-model";
+import {AuthUserModel} from "../../models";
+import {SubsidiariesService} from "./subsidiaries.service";
+
+
+@Injectable()
+export class ElasticsearchService {
+
+  constructor(@Inject(WEB_CONFIG) private config: Config,
+              private subsidiariesMappingService: SubsidiariesService) {
+  }
+
+  private client: Client;
+  PROFILE_SEARCH_CONFIG = {
+    'COMMERCIAL': ['unity-invoice*', 'unity-deal*', 'unity-work-record*'],
+    'ACCOUNTANT': ['unity-invoice*', 'unity-deal*', 'unity-work-record*'],
+    'ADMINISTRATIVE_CONTROLLER': ['unity-invoice*', 'unity-deal*', 'unity-work-record*'],
+    'VIDEO_CONSULT': ['unity-product*'],
+    'BDC': ['unity-purchase-order*'],
+    'LEGAL': ['unity-contract*'],
+    'ROYALTY': ['unity-royalty-contract'],
+  }
+
+  private getElasticsearchClient(): Client {
+    if (!this.client) {
+      this.client = new ClientJs({
+        host: this.config.elasticsearch_url
+      });
+    }
+    return this.client;
+  }
+
+  public getSearchResponse(text: string, user: AuthUserModel): Observable<MSearchResponse<any>> {
+    const allIndexes: Set<string> = new Set<string>();
+    allIndexes.add('unity-work-version*')
+    allIndexes.add('unity-third-party*')
+
+    for (const permission of user.permissions) {
+      const indexes = this.PROFILE_SEARCH_CONFIG[permission.code];
+      indexes?.forEach(idx => allIndexes.add(idx));
+    }
+
+    const body: any[] = [];
+    for (const index of allIndexes) {
+      body.push({index});
+      switch (index) {
+        case 'unity-work-version*' :
+          body.push({
+            query: {
+              dis_max: {
+                queries: [{wildcard: {miloCode: {value: '*' + text + '*'}}}, {wildcard: {title: {value: '*' + text + '*'}}}, {wildcard: {title: {value: text + '*'}}}, {wildcard: {title: {value: text}}}],
+                tie_breaker: 0.5
+              }
+            },
+            sort: [{_score: {order: 'desc'}}, {title: {order: "asc"}}],
+            size: 50
+          });
+          break;
+        case 'unity-product*' :
+          body.push({
+            query: {dis_max: {queries: [{wildcard: {ean: {value: '*' + text + '*'}}}, {wildcard: {title: {value: '*' + text + '*'}}}]}},
+            sort: {releaseDate: {order: 'desc'}},
+            size: 50
+          });
+          break;
+        case 'unity-purchase-order*' :
+          body.push({
+            query: {dis_max: {queries: [{wildcard: {poNumber: {value: '*' + text + '*'}}}, {wildcard: {ean: {value: '*' + text + '*'}}}, {wildcard: {basketNumber: {value: '*' + text + '*'}}}]}},
+            size: 50
+          });
+          break;
+        case 'unity-deal*' :
+          body.push({
+            query: {dis_max: {queries: [{wildcard: {dealNumber: {value: '*' + text + '*'}}}]}},
+            sort: [{_score: {order: 'desc'}}, {'dealNumber.keyword': {order: 'asc'}}],
+            size: 50
+          });
+          break;
+        case 'unity-work-record*' :
+          body.push({
+            query: {dis_max: {queries: [{wildcard: {workRecordId: {value: '*' + text + '*'}}}]}},
+            sort: [{'workRecordId.keyword': {order: 'asc'}}],
+            size: 50
+          });
+          break;
+        case 'unity-invoice*' :
+          body.push({
+            query: {dis_max: {queries: [{wildcard: {number: {value: '*' + text + '*'}}}]}},
+            sort: [{'number.keyword': {order: 'asc'}}],
+            size: 50
+          });
+          break;
+        case 'unity-third-party*' :
+          body.push({
+            query: {
+              dis_max: {
+                queries: [{wildcard: {companyOrPersonName: {value: '*' + text + '*'}}}, {wildcard: {companyOrPersonName: {value: text + '*'}}}, {wildcard: {companyOrPersonName: {value: text}}}],
+                tie_breaker: 0.5
+              }
+            },
+            sort: [{_score: {order: 'desc'}}, {companyOrPersonName: {order: 'asc'}}],
+            size: 50
+          });
+          break;
+        case 'unity-contract*' :
+          body.push({
+            query: {bool: this.composeContractQuery(text, user.subsidiaries)},
+            sort: [{'lisaId.keyword': {order: 'asc'}}],
+            size: 50
+          });
+          break;
+        case 'unity-royalty-contract' :
+          body.push({
+            query: {dis_max: {queries: [{wildcard: {contractNumber: {value: '*' + text + '*'}}}]}},
+            sort: [{'contractNumber.keyword': {order: 'asc'}}],
+            size: 50
+          });
+          break;
+      }
+    }
+    return from(this.getElasticsearchClient().msearch({body}));
+  }
+
+  public getDocuments(searchResponse: any): (PurchaseOrderRapidSearchModel | ProductRapidSearchModel |
+    WorkVersionRapidSearchModel | DealRapidSearchModel | WorkRecordRapidSearchModel | ThirdPartyRapidSearchModel | ContractRapidSearchModel)[] {
+    let results = [];
+    if (searchResponse && searchResponse.responses) {
+      for (const r of searchResponse.responses) {
+        if (r.error || !r.hits) {
+          continue;
+        }
+
+        const item = r.hits.hits && r.hits.hits.length > 0 ? r.hits.hits.map(v => this.mapDocument(v)) : [];
+        results = results.concat(item);
+      }
+    }
+    return results;
+  }
+
+  mapDocument(doc: any): any {
+    switch (doc._source.docType) {
+      case 'INVOICE':
+        return Object.assign(new InvoiceRapidSearchModel(), doc._source);
+      case 'WORK_RECORD':
+        return Object.assign(new WorkRecordRapidSearchModel(), doc._source);
+      default:
+        return doc._source;
+    }
+  }
+
+  private composeContractQuery(text: string, subsidiadies) {
+    const societes = this.subsidiariesMappingService.getSocieteAppartenance(subsidiadies);
+    const must: any[] = [
+      {wildcard: {lisaId: {value: '*' + text + '*'}}}
+    ];
+    const should: any[] = [];
+    should.push({bool: {must_not: {exists: {field: 'societeAppartenance'}}}});
+    if (societes && societes.length > 0) {
+      should.push({terms: {societeAppartenance: societes}});
+    }
+    const boolQuery: any = {must};
+    boolQuery.should = should;
+    boolQuery.minimum_should_match = 1;
+    return boolQuery
+  }
+
+}