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

package/src/lib/util/models/section.model.ts

@@ -0,0 +1,11 @@
+import { PermissionModel } from './permission.model';
+
+export class SectionModel {
+
+    public id: number = null;
+    public sectionName: string = null;
+    public permissions: PermissionModel[] = [];
+
+    constructor() {
+    }
+}

package/src/lib/util/models/select/options.model.ts

@@ -0,0 +1,8 @@
+export class OptionHtmlModel {
+    constructor(
+        public id: string = null,
+        public value: number = null,
+        public label = null
+    ) {
+    }
+}

package/src/lib/util/models/select/select.model.ts

@@ -0,0 +1,4 @@
+export class SelectHtmlModel {
+    constructor(public options: any[] = [], public disabled: boolean = false) {
+    }
+}

package/src/lib/util/models/subsidiary.model.ts

@@ -0,0 +1,10 @@
+import { FamilyModel } from "./family.model";
+
+export class SubsidiaryModel {
+  public id: number = null;
+  public label: string = null;
+  public family: FamilyModel = null;
+
+  constructor() {
+  }
+}

package/src/lib/util/models/subtitle-content.model.ts

@@ -0,0 +1,39 @@
+/**
+ * Created by mmichieli on 13/02/2017.
+ */
+import { ReferentielModel } from './referentiel.model';
+
+export class SubtitleContentModel {
+    public id: number = null;
+    public isDefault = false;
+    public materialNumber: number;
+    public languageId: number;
+    public contentId: number;
+    public stateId: number;
+    public typeId: number;
+    public origin: string = null;
+    public localisation: string = null;
+    public availabilityDate: string = null;
+    public statusId: number;
+
+    public languageLabel: string = null;
+    public contentLabel: string = null;
+    public stateLabel: string = null;
+    public typeLabel: string = null;
+    public statusLabel: string = null;
+
+    public status: ReferentielModel = new ReferentielModel();
+    public uuid: string;
+
+    constructor() {
+    }
+
+    public fromJSON(json) {
+        for (const propName in json) {
+            if (json.hasOwnProperty(propName)) {
+                this[propName] = json[propName];
+            }
+        }
+        return this;
+    }
+}

package/src/lib/util/models/user-video.model.ts

@@ -0,0 +1,29 @@
+export class UserVideoModel {
+    public id: number;
+    public login: string;
+    public lastName: string;
+    public firstName: string;
+    public profile: string;
+
+    constructor() {
+    }
+
+    public fromJSON(json) {
+        for (const propName in json) {
+            if (json.hasOwnProperty(propName)) {
+                this[propName] = json[propName];
+            }
+        }
+        return this;
+    }
+
+    public fromJSONs(jsons) {
+        const refs: UserVideoModel[] = [];
+        if (jsons) {
+            jsons.forEach(json => {
+                refs.push(new UserVideoModel().fromJSON(json));
+            });
+        }
+        return refs;
+    }
+}

package/src/lib/util/models/user.model.ts

@@ -0,0 +1,41 @@
+import { SectionModel } from './section.model';
+import { PermissionModel } from './permission.model';
+import { SubsidiaryModel } from "./subsidiary.model";
+
+export class UserModel {
+    public id: number = null;
+    public login: string = null;
+    public password: string = null;
+    public name: string = null;
+    public firstName: string = null;
+    public fullName: string = null;
+    public serialNumber: string = null;
+    public type: number = null;
+    public dateBegin = null;
+    public dateEnd = null;
+    public entity: number = null;
+    public management: number = null;
+    public email: string = null;
+    public administrator: boolean = false;
+    public active: boolean = true;
+    public comment: string = null;
+    public sections: SectionModel[] = [];
+    public permissions: PermissionModel[] = [];
+    public subsidiaries: SubsidiaryModel[] = [];
+
+    constructor() {
+    }
+
+    public getFullName(): string {
+        return this.firstName + ' ' + this.name;
+    }
+
+    public fromJSON(json) {
+        for (let propName in json) {
+            if (json.hasOwnProperty(propName)) {
+                this[propName] = json[propName];
+            }
+        }
+        return this;
+    }
+}

package/src/lib/util/models/video/product-rapid-search.model.ts

@@ -0,0 +1,10 @@
+import { SupportRapidSearchModel } from './support-rapid-search.model';
+
+export class ProductRapidSearchModel {
+  public ean: string;
+  public productId: number;
+  public title: string;
+  public docType: string;
+  public support: SupportRapidSearchModel;
+}
+

package/src/lib/util/models/video/support-rapid-search.model.ts

@@ -0,0 +1,7 @@
+export class SupportRapidSearchModel {
+  public id: number;
+  public labelFr: string;
+  public labelEn: string;
+  public labelDe: string;
+}
+

package/src/lib/util/models/video-content.model.ts

@@ -0,0 +1,37 @@
+import { ReferentielModel } from './referentiel.model';
+
+export class VideoContentModel {
+    public id: number = null;
+    public materialNumber: string;
+    public diffusionFormatId: number;
+    public supportId: number;
+    public ratioId: number;
+    public colorId: number;
+    public localisation: string;
+    public duration: string;
+    public origin: string;
+    public isFormatRespected = false;
+    public availabilityDate: string;
+    public checked = false;
+
+    public ratioLabel: string;
+    public formatLabel: string;
+    public colorLabel: string;
+    public supportLabel: string;
+    public statusLabel: string;
+
+    public status: ReferentielModel = new ReferentielModel();
+    public uuid: string;
+
+    constructor() {
+    }
+
+    public fromJSON(json) {
+        for (const propName in json) {
+            if (json.hasOwnProperty(propName)) {
+                this[propName] = json[propName];
+            }
+        }
+        return this;
+    }
+}

package/src/lib/util/number.validator.ts

@@ -0,0 +1,123 @@
+import { AbstractControl, ValidatorFn } from '@angular/forms';
+
+// @dynamic
+export class NumberValidator {
+    constructor() {
+    }
+
+    public static validatorNumberGreaterThanZero(): ValidatorFn {
+        return (control: AbstractControl): { [key: string]: any } => {
+            if (control.value === '' || control.value === undefined) {
+                return null;
+            } else if (control.value !== null) {
+                const numberWithoutSpaces = control.value.toString().replace(/ /g, '');
+                if (+numberWithoutSpaces === 0) {
+                    return {validatorNumberGreaterThanZero: true};
+                }
+            } else {
+                return null;
+            }
+        };
+    }
+
+    /**
+     *
+     * @returns (control:AbstractControl)=>{}
+     */
+    // Tests if a number is negative or not. Returns true in case of negative numbers
+    public validatorNumberNegative(): ValidatorFn {
+        return (control: AbstractControl): { [key: string]: any } => {
+            if (control.value === null || +control.value === 0) {
+                return null;
+            } else {
+                const numberWithoutSpaces = control.value
+                    .toString()
+                    .replace(/ /g, '')
+                    .replace(',', '.');
+                if (+numberWithoutSpaces >= 0) {
+                    return null;
+                } else {
+                    return {validatorNumberNegative: true};
+                }
+            }
+        };
+    }
+
+    // Tests if a number is a valid percentage value (between 0 and 100)
+    public validatorNumberValidPercentage(): ValidatorFn {
+        return (control: AbstractControl): { [key: string]: any } => {
+            if (control.value == null) {
+                return null;
+            }
+            const numberWithoutComma = control.value.toString().replace(',', '.');
+            if (+numberWithoutComma >= 0 && +numberWithoutComma <= 100) {
+                return null;
+            } else if (+control.value >= 0 && +control.value <= 100) {
+                return null;
+            } else {
+                return {validatorNumberValidPercentages: true};
+            }
+        };
+    }
+
+    /*
+   tests if a number is not an integer(it contains another characters than digits and -).
+     If the number is not an integer, it will return true.
+     Also tests if a number starts with 0. If the number starts with 0 -> return true
+  */
+    public validatorNumberInteger(): ValidatorFn {
+        return (control: AbstractControl): { [key: string]: any } => {
+            if (control.value === '' || control.value === undefined) {
+                return null;
+            } else if (+control.value === 0) {
+                return null;
+            } else if (control.value !== null) {
+                const numberWithoutSpaces = control.value.toString().replace(/ /g, '');
+                const myRegexNoDecimal = new RegExp(/^-?^[1-9]\d*$/, 'i');
+                if (!myRegexNoDecimal.test(numberWithoutSpaces)) {
+                    return {validatorNumberInteger: true};
+                }
+            } else {
+                return null;
+            }
+        };
+    }
+
+    // tests if a number is lesser than another number
+    public validatorNumberLesserThanAnother(anotherValue: number): ValidatorFn {
+        return (control: AbstractControl): { [key: string]: any } => {
+            if (control.value === null) {
+                return null;
+            } else {
+                const numberWithoutSpaces = control.value
+                    .toString()
+                    .replace(/ /g, '')
+                    .replace(',', '.');
+                if (+numberWithoutSpaces <= anotherValue) {
+                    return null;
+                } else {
+                    return {validatorNumberLesserThanAnother: true};
+                }
+            }
+        };
+    }
+
+    // tests if a number is MAX than another number
+    public validatorNumberMaxThanAnother(anotherValue: number): ValidatorFn {
+        return (control: AbstractControl): { [key: string]: any } => {
+            if (control.value === null) {
+                return null;
+            } else {
+                const numberWithoutSpaces = control.value
+                    .toString()
+                    .replace(/ /g, '')
+                    .replace(',', '.');
+                if (+numberWithoutSpaces > anotherValue) {
+                    return null;
+                } else {
+                    return {validatorNumberLesserThanAnother: true};
+                }
+            }
+        };
+    }
+}

package/src/lib/util/paginator/custom-paginator-configuration.ts

@@ -0,0 +1,68 @@
+import { Injectable, OnDestroy } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { Subject, takeUntil } from 'rxjs';
+import { MatPaginatorIntl } from "@angular/material/paginator";
+
+@Injectable()
+export class CustomMatPaginatorIntl extends MatPaginatorIntl implements OnDestroy {
+
+
+  unsubscribe: Subject<void> = new Subject<void>();
+  OF_LABEL = 'of';
+
+  constructor(private translate: TranslateService) {
+    super();
+
+    this.translate.onLangChange
+      .pipe(takeUntil(this.unsubscribe))
+      .subscribe(() => {
+        this.getAndInitTranslations();
+      });
+
+    this.getAndInitTranslations();
+  }
+
+  ngOnDestroy() {
+    this.unsubscribe.next();
+    this.unsubscribe.complete();
+  }
+
+  getAndInitTranslations() {
+    this.translate
+      .get([
+        'PAGINATOR.ITEMS_PER_PAGE',
+        'PAGINATOR.NEXT_PAGE',
+        'PAGINATOR.PREVIOUS_PAGE',
+        'PAGINATOR.OF_LABEL',
+      ])
+      .pipe(takeUntil(this.unsubscribe))
+      .subscribe(translation => {
+        this.itemsPerPageLabel =
+          translation['PAGINATOR.ITEMS_PER_PAGE'];
+        this.nextPageLabel = translation['PAGINATOR.NEXT_PAGE'];
+        this.previousPageLabel =
+          translation['PAGINATOR.PREVIOUS_PAGE'];
+        this.OF_LABEL = translation['PAGINATOR.OF_LABEL'];
+        this.changes.next();
+      });
+  }
+
+  getRangeLabel = (
+    page: number,
+    pageSize: number,
+    length: number,
+  ) => {
+    if (length === 0 || pageSize === 0) {
+      return `0 ${this.OF_LABEL} ${length}`;
+    }
+    length = Math.max(length, 0);
+    const startIndex = page * pageSize;
+    const endIndex =
+      startIndex < length
+        ? Math.min(startIndex + pageSize, length)
+        : startIndex + pageSize;
+    return `${startIndex + 1} - ${endIndex} ${
+      this.OF_LABEL
+    } ${length}`;
+  };
+}

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

@@ -0,0 +1,47 @@
+import { Injectable } from '@angular/core';
+import { User } from '../decorators/user.decorator';
+import { NgxPermissionsService } from 'ngx-permissions';
+import { UserSubsidiaryService } from '../services/user/user-subsidiary.service';
+
+export const CANAL_PLUS_INTERNATIONAL_RESTRICTION = 'CANAL_PLUS_INTERNATIONAL_RESTRICTION';
+
+@Injectable()
+export class PermissionsService {
+    @User() public user;
+
+    constructor(private readonly permissionsService: NgxPermissionsService,
+                private readonly userSubsidiaryService: UserSubsidiaryService) {
+    }
+
+    public init(): void {
+        if (this.user?.permissions?.length > 0 && this.shouldLoadUserPermissions()) {
+            const userPermissions: string[] = this.user.permissions.map((p) => p.code);
+
+            // Create a virtual permission that can be used to restrict access if user only has access to "C+I"
+            // subsidiaries
+            if (this.userSubsidiaryService.isCanalPlusInternationalUser()) {
+              userPermissions.push(CANAL_PLUS_INTERNATIONAL_RESTRICTION);
+            }
+
+            this.permissionsService.loadPermissions(userPermissions);
+        }
+    }
+
+    public hasPermission(code: string): boolean {
+        return this.user?.permissions?.filter((p) => p.code === code).length > 0;
+    }
+
+    private shouldLoadUserPermissions() {
+        const loadedPermissions = Object.keys(this.permissionsService.getPermissions());
+        if (loadedPermissions.length !== this.user.permissions.length) {
+            return true;
+        }
+        let res = false;
+        this.user.permissions.forEach((p) => {
+            if (loadedPermissions.indexOf(p.code) === -1) {
+                res = true;
+            }
+        });
+        return res;
+    }
+}

package/src/lib/util/pipes/capitalizefirst.pipe.ts

@@ -0,0 +1,39 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+/*
+@Pipe({
+  name: 'capitalizeFirst'
+})
+*/
+
+@Pipe({
+    name: 'myCapitalizeFirst'
+})
+export class CapitalizefirstPipe implements PipeTransform {
+
+    constructor() {
+    }
+
+    public transform(value: string): string {
+        if (value == null) {
+            return '';
+        }
+        let valueArgs;
+
+        let args = (value.split('-'));
+        if (args.length === 2) {
+            for (let i = 0; i < args.length; i++) {
+                args[i] = args[i].charAt(0).toUpperCase() + args[i].slice(1).toLowerCase();
+                valueArgs = args.join('-');
+            }
+        } else {
+            args = value.split(' ');
+            for (let i = 0; i < args.length; i++) {
+                args[i] = args[i].charAt(0).toUpperCase() + args[i].slice(1).toLowerCase();
+                valueArgs = args.join(' ');
+            }
+        }
+
+        return valueArgs;
+    }
+}

package/src/lib/util/pipes/comma-separated-number.pipe.ts

@@ -0,0 +1,9 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({name: 'mySpacesNumberPipe'})
+export class SpacesNumberPipe implements PipeTransform {
+    public transform(value: any): any {
+        // we remove all spaces
+        return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
+    }
+}

package/src/lib/util/pipes/common-translate.pipe.ts

@@ -0,0 +1,37 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import { en } from '../i18n/en';
+import { fr } from '../i18n/fr';
+import { de } from '../i18n/de';
+import { LocalStorageService } from "../services/storage/local-storage.service";
+
+
+@Pipe({name: 'commonTranslate'})
+export class CommonTranslatePipe implements PipeTransform {
+
+    private availableTranslations = {en, fr, de};
+
+    constructor(private localStorageService: LocalStorageService) {
+    }
+
+    public transform(value: string, lang?: string): string {
+        let currentLang = lang;
+        if (!lang) {
+            currentLang = this.localStorageService.get('lang');
+        }
+
+        if (this.isValidLang(currentLang)) {
+            const currentTranslation = this.availableTranslations[currentLang];
+            return currentTranslation[value];
+        }
+    }
+
+    private isValidLang(lang: string) {
+        if (lang) {
+            const languages = ['en', 'fr', 'de'];
+            if (languages.indexOf(lang) !== -1) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

package/src/lib/util/pipes/display-html.pipe.ts

@@ -0,0 +1,15 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+
+@Pipe({
+    name: 'mySanitizeHtml'
+})
+export class SanitizeHtml implements PipeTransform {
+
+    constructor(private _sanitizer: DomSanitizer) {
+    }
+
+    public transform(html: string): SafeHtml {
+        return this._sanitizer.bypassSecurityTrustHtml(html);
+    }
+}

package/src/lib/util/pipes/display-null.pipe.ts

@@ -0,0 +1,19 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({name: 'myDisplayNullPipe'})
+export class DisplayNullPipe implements PipeTransform {
+
+    private static returnCorrectFormat(object: any) {
+        return (object) ? object : '-';
+    }
+
+    public transform(value: any, fieldName: string = ''): any {
+        // Case 1: test value param
+        if (!fieldName) {
+            return DisplayNullPipe.returnCorrectFormat(value);
+        } else {
+            // Case 2: test sub attribut value
+            return (value) ? DisplayNullPipe.returnCorrectFormat(value[fieldName]) : '-';
+        }
+    }
+}

package/src/lib/util/pipes/format-currency.pipe.ts

@@ -0,0 +1,26 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import { CurrencyPipe } from '@angular/common';
+
+@Pipe({
+  name: 'formatCurrency'
+})
+export class FormatCurrencyPipe implements PipeTransform {
+
+  constructor(private currencyPipe: CurrencyPipe) {
+  }
+
+  transform(value: number, currencyCode?: string, display?: string | boolean, digitsInfo?: string, language?: string): string {
+    let formattedValue: string = this.currencyPipe.transform(value, currencyCode, display, digitsInfo);
+    if(formattedValue) {
+      if (language == 'de') {
+        let [thousands, decimal] = formattedValue.split(',');
+        thousands = thousands.replace(/\s/g, '.');
+        formattedValue = thousands + ',' + decimal;
+      } else {
+        formattedValue = formattedValue.replace(',', '.');
+      }
+    }
+
+    return formattedValue ? formattedValue : '';
+  }
+}

package/src/lib/util/pipes/format-duration.pipe.ts

@@ -0,0 +1,16 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+  name: 'formatDuration'
+})
+export class FormatDurationPipe implements PipeTransform {
+  transform(value): string {
+     if (value > 0 && value < 60) {
+       return value + 'min';
+     } else {
+       const h = Math.floor(value / 60);
+       const min = value % 60;
+       return  min === 0 ? h + 'h' : h + 'h ' + min + 'min';
+     }
+  }
+}

package/src/lib/util/pipes/format-number-input.pipe.ts

@@ -0,0 +1,19 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({name: 'myAddSpacesInputPipe'})
+export class FormatNumberInput implements PipeTransform {
+    public transform(numberValue: any): any {
+        if (numberValue === null || numberValue < 0 || isNaN(numberValue)) {
+            return null;
+        }
+        numberValue = numberValue.toString();
+
+        // remove spaces
+        numberValue = numberValue.replace(/ /g, '');
+
+        // add spaces
+        numberValue = numberValue.replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
+
+        return numberValue;
+    }
+}

package/src/lib/util/pipes/local-date.pipe.ts

@@ -0,0 +1,29 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import { DatePipe } from '@angular/common';
+
+@Pipe({name: 'myLocalDateFormat'})
+export class LocalDatePipe implements PipeTransform {
+
+    public perpetuityLabel = '';
+
+    constructor() {
+    }
+
+    public transform(
+        value: any,
+        currentLanguage: string,
+        format: string
+    ): string {
+
+        if (currentLanguage === 'fr') {
+            this.perpetuityLabel = 'Perpétuité';
+        } else if (currentLanguage === 'en' || currentLanguage === 'de') {
+            this.perpetuityLabel = 'Perpetuity';
+        }
+
+        if (value === '-' || value === this.perpetuityLabel) {
+            return this.perpetuityLabel;
+        }
+        return new DatePipe(currentLanguage).transform(value, format);
+    }
+}