@dsivd/prestations-ng 16.4.0-beta.8 → 16.4.0

package/CHANGELOG.md

@@ -10,6 +10,20 @@
 
 ### Added
 
+-   [foehn-page-expiration-timer.component.ts](projects/prestations-ng/src/foehn-page/foehn-page-expiration-timer/foehn-page-expiration-timer.component.ts)
+-   [foehn-page-expiration-timer.component.html](projects/prestations-ng/src/foehn-page/foehn-page-expiration-timer/foehn-page-expiration-timer.component.html)
+
+    -   added a timer message to alert user of session expiration
+    -   `session-token.session-time-to-live-in-minutes` can be overridden in back-end properties
+    -   `session-token.message-delay-in-minutes` can be overridden in back-end properties
+
+-   New dictionary keys:
+
+    -   `foehn-page-expiration-timer.count-down-message` is the message displayed when timer is running
+    -   `foehn-page-expiration-timer.count-down-message.sr-only` same as above but for screen reader
+    -   `foehn-page-expiration-timer.expired-message` is the message displayed when session has expired
+    -   `foehn-page-expiration-timer.expired-message.sr-only` same as above but for screen reader
+
 -   [foehn-multi-upload.component.ts](projects/prestations-ng/src/foehn-upload/foehn-multi-upload/foehn-multi-upload.component.ts)
 -   [foehn-bo-multi-upload.component.ts](projects/prestations-ng/src/foehn-upload/foehn-bo-multi-upload/foehn-bo-multi-upload.component.ts)
 
@@ -18,11 +32,20 @@
 
 -   [foehn-multi-upload.component.ts](projects/prestations-ng/src/foehn-upload/foehn-multi-upload/foehn-multi-upload.component.ts)
 -   [foehn-bo-multi-upload.component.ts](projects/prestations-ng/src/foehn-upload/foehn-bo-multi-upload/foehn-bo-multi-upload.component.ts)
+
     -   added `@Input() maxFilesSizeInMo;`
     -   prevents global upload of more than `maxFilesSizeInMo` Mo and displays an alert from default-dictionary.ts (`foehn-uploader.max-files-size-reached`)
 
+-   [gesdem-handler.service.ts](projects/prestations-ng/src/gesdem/gesdem-handler.service.ts)
+    -   added a second optional parameter to `save(form: any, displaySuccessMessage: boolean = true): Observable<any>`
+    -   `displaySuccessMessage` by default is true. When set to false, the form success saving message is not displayed
+
 ### Updated
 
+-   [foehn-page.component.html](projects/prestations-ng/src/foehn-page/foehn-page-expiration-timer/foehn-page-expiration-timer.component.html)
+
+    -   updated `foehn-page` to add session expiration timer message
+
 -   [gesdem-action-recovery-registration.component.ts](projects/prestations-ng/src/gesdem-action-recovery/gesdem-action-recovery-registration/gesdem-action-recovery-registration.component.ts)
 
     -   updated recovery registration modal to inform the user of its current registration
@@ -41,9 +64,19 @@
     -   `Integer draftDemRetentionDaysConnected : number` conservation duration of draft demands when connected (in days)
 
 -   [I18NForm](projects/prestations-ng/src/i18n-form.ts)
+
     -   added field `referenceInterne = ''`, since the reference interne can now be set via action recovery, it has to be kept in sync with the form
         -   you can use this field to request the user for a reference interne.
 
+-   [pending-upload.service.ts](projects/prestations-ng/src/foehn-upload/foehn-multi-upload/pending-upload.service.ts)
+    -   Does not display the form success saving message after saving pending files
+
+### Fixed
+
+-   [pattern.const](projects/prestations-ng/src/foehn-input/pattern.const.ts)
+
+    -   fixed `HTML_PHONE_PATTERN` not escaping parenthesis
+
 ## [16.3.0] - must be aligned with prestations-be
 
 ### Added

package/UPGRADING_V16.md

@@ -406,29 +406,48 @@ In your `app-routing.module.ts` of your application
 +canActivate: [gesdemLoaderGuard]
 ```
 
-#### Replacing `CanActivate`
+#### Replacing `CanActivate` guard by `CanActiveFn`
 
-##### Quick guard replacement
+CanActivate, CanActivateChild, CanDeactivate, CanLoad or CanMatch have been deprecated.
 
-In your `redirect.guard.ts` file :
+See [https://angular.io/api/router#structures](https://angular.io/api/router#structures).
 
-```diff
--export class RedirectGuard implements CanActivate {
-+export class RedirectGuard {
-    canActivate(route: ActivatedRouteSnapshot): boolean {
-```
+You can find in the previous link a quick fix but it is better to rewrite your guard so it becomes a `CanActiveFn`, `CanActivateChildFn`, `CanDeactivateFn`, `CanLoadFn` or `CanMatchFn`.
 
-In your `app-routing.module.ts` of your application
+##### Rewriting examples
+
+See [gesdemLoaderGuard generated doc](https://dsi-vd.github.io/prestations-ng/generateddoc/miscellaneous/variables.html#gesdemLoaderGuard) as an example.
+
+Or here is an example of rewriting a `CanActivate` guard returning an `Observable` of `boolean` :
 
 ```diff
--canActivate: [RedirectGuard],
-+canActivate: [(route: ActivatedRouteSnapshot) => inject(RedirectGuard).canActivate(route)],
+- @Injectable({
+-     providedIn: 'root'
+- })
+- export class YourGuard implements CanActivate {
++ export const yourGuard: CanActivateFn = (next: ActivatedRouteSnapshot): Observable<boolean> => {
+
+-    constructor(
+-        private service1: YourService1,
+-        private service2: YourService2
+-    ) {}
++    const service1 = ServiceLocator.injector.get(YourService1);
++    const service2 = ServiceLocator.injector.get(YourService2);
+
+-     canActivate(
+-         next: ActivatedRouteSnapshot
+-     ): Observable<boolean> {
+        if (YOUR_CONDITION) {
+            return of(false);
+        }
+        return of(true);
+-     }
+}
 ```
 
-##### Rewriting your guard
+CanActivate, CanActivateChild, CanDeactivate, CanLoad or CanMatch will need the same approach to be rewritten.
 
-You can rewrite your guard to become a `CanActiveFn`.
-See [gesdemLoaderGuard generated doc](https://dsi-vd.github.io/prestations-ng/generateddoc/miscellaneous/variables.html#gesdemLoaderGuard) as an example.
+They all return : `Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree;` same as the deprecated version of themselves.
 
 #### Replacing `.subscribe` with an error callback
 

package/esm2020/foehn-input/pattern.const.mjs

@@ -1,7 +1,7 @@
 // Patterns for HTML so iOS dans display the proper keyboard
 export const HTML_NO_DECIMAL_PATTERN = '[0-9]*';
 export const HTML_DECIMAL_PATTERN = '[0-9\\.,]*';
-export const HTML_PHONE_PATTERN = '[0-9\\.\\-()+]*';
+export const HTML_PHONE_PATTERN = '[0-9\\.\\-\\(\\)+]*';
 // Validation patterns for the field
 export const NUMBERS_PATTERN = /^[0-9]*$/;
 export const DECIMAL_NUMBERS_PATTERN = /^([0-9]+\.?)?[0-9]*$/;
@@ -13,4 +13,4 @@ export const CLEAN_NUMBERS_PATTERN = /[^0-9]/g;
 export const CLEAN_DECIMAL_NUMBERS_PATTERN = /[^0-9\.]/g;
 export const CLEAN_NEGATIVE_NUMBERS_PATTERN = /[^0-9\-]/g;
 export const CLEAN_NEGATIVE_AND_DECIMAL_NUMBERS_PATTERN = /[^0-9\-\.]/g;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/foehn-page/foehn-page-expiration-timer/demande-expiration-interceptor.mjs

@@ -0,0 +1,62 @@
+import { HTTP_INTERCEPTORS, HttpEventType, HttpResponse } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import dayjs from 'dayjs';
+import { tap } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./demande-expiration.service";
+export class DemandeExpirationInterceptor {
+    constructor(demandeExpirationService) {
+        this.demandeExpirationService = demandeExpirationService;
+    }
+    intercept(request, next) {
+        return next.handle(request).pipe(tap((httpEvent) => {
+            if (httpEvent.type === HttpEventType.Sent) {
+                return;
+            }
+            if (httpEvent instanceof HttpResponse) {
+                if (httpEvent.headers.has('Demande-Expiration')) {
+                    this.manageDemandeExpirationHeader(httpEvent.headers.get('Demande-Expiration'), 
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    httpEvent.body);
+                }
+            }
+        }));
+    }
+    manageDemandeExpirationHeader(expirationByDemande, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    formPostResponse) {
+        const expirationByDemandeMap = this.getExpirationByDemandeMap(expirationByDemande);
+        if (!!formPostResponse.meta) {
+            const dateTime = expirationByDemandeMap.get(formPostResponse.meta.reference);
+            const dateTimeAsDayJs = dayjs(dateTime);
+            if (dateTimeAsDayJs.isValid()) {
+                this.demandeExpirationService.setDemandeExpirationDateTime(dayjs(dateTime));
+            }
+        }
+    }
+    getExpirationByDemandeMap(expirationByDemande) {
+        const myMap = new Map();
+        const expirationByDemandesAsArray = expirationByDemande.split(';');
+        expirationByDemandesAsArray.forEach(value => {
+            const valueAsArray = value.split(',');
+            myMap.set(valueAsArray[0], new Date(valueAsArray[1]));
+        });
+        return myMap;
+    }
+}
+DemandeExpirationInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DemandeExpirationInterceptor, deps: [{ token: i1.DemandeExpirationService }], target: i0.ɵɵFactoryTarget.Injectable });
+DemandeExpirationInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DemandeExpirationInterceptor, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DemandeExpirationInterceptor, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DemandeExpirationService }]; } });
+export const DEMANDE_EXPIRATION_INTERCEPTOR_PROVIDER = [
+    {
+        provide: HTTP_INTERCEPTORS,
+        useExisting: DemandeExpirationInterceptor,
+        multi: true
+    }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/foehn-page/foehn-page-expiration-timer/demande-expiration.service.mjs

@@ -0,0 +1,46 @@
+import { Injectable } from '@angular/core';
+import dayjs from 'dayjs';
+import { BehaviorSubject, combineLatest, Subject } from 'rxjs';
+import { filter, map, shareReplay, tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class DemandeExpirationService {
+    constructor() {
+        this.PULLING_IN_MILLISECONDS = 1000;
+        this._demandeExpirationDateTimeSubject = new BehaviorSubject(null);
+        this.intervalSubject = new Subject();
+    }
+    shouldDisplayExpirationTimerMessage() {
+        return combineLatest([
+            this.getDemandeExpirationDateTime(),
+            this.intervalSubject.asObservable()
+        ]).pipe(map(([value]) => dayjs().isSame(value) || dayjs().isAfter(value)), tap(visible => {
+            if (visible) {
+                this.clearPulling();
+            }
+        }), shareReplay(1));
+    }
+    setDemandeExpirationDateTime(date) {
+        this._demandeExpirationDateTimeSubject.next(date);
+    }
+    getDemandeExpirationDateTime() {
+        return this._demandeExpirationDateTimeSubject.asObservable().pipe(filter(value => !!value && value.isValid()), tap(() => this.startPulling()), shareReplay(1));
+    }
+    startPulling() {
+        this.clearPulling();
+        this.interval = setInterval(() => {
+            this.intervalSubject.next();
+        }, this.PULLING_IN_MILLISECONDS);
+    }
+    clearPulling() {
+        clearInterval(this.interval);
+    }
+}
+DemandeExpirationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DemandeExpirationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+DemandeExpirationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DemandeExpirationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DemandeExpirationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/foehn-page/foehn-page-expiration-timer/foehn-page-expiration-timer.component.mjs

@@ -0,0 +1,147 @@
+import { Component } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { debounceTime, filter, map, shareReplay, tap } from 'rxjs/operators';
+import { DateHelper } from '../../sdk-date/date.helper';
+import * as i0 from "@angular/core";
+import * as i1 from "../../sdk-appinfo/application-info.service";
+import * as i2 from "../..//sdk-dictionary/sdk-dictionary.service";
+import * as i3 from "@angular/common";
+import * as i4 from "../../sdk-dictionary/sdk-dictionary.pipe";
+export class FoehnPageExpirationTimerComponent {
+    constructor(applicationInfoService, dictionaryService) {
+        this.applicationInfoService = applicationInfoService;
+        this.dictionaryService = dictionaryService;
+        this.countDownTimeInSeconds = new BehaviorSubject(null);
+        this.sessionHasExpired = new BehaviorSubject(false);
+        this.srAnnouncementsSubject = new BehaviorSubject('');
+        this.dateHelper = new DateHelper();
+        this.PULLING_IN_MILLISECONDS = 1000;
+        this.SR_ANNOUNCEMENT_CLEAR_TIMEOUT_INTERVAL_MS = 2000;
+        this.sessionExpired = this.sessionHasExpired
+            .asObservable()
+            .pipe(shareReplay(1));
+        this.srAnnouncements = this.srAnnouncementsSubject
+            .asObservable()
+            .pipe(debounceTime(0)); // debounceTime to "avoid expression has changes before..."
+        this.countDownTimeToDisplay = this.countDownTimeInSeconds
+            .asObservable()
+            .pipe(tap(countDownTimeInSeconds => this.sessionHasExpired.next(countDownTimeInSeconds === 0)), map(countDownTimeInSeconds => this.formatTime(countDownTimeInSeconds)), shareReplay(1));
+        this.applicationInfoRetrieved = this.applicationInfoService.data.pipe(map((info) => info.configuration.session.messageDelayInMinutes), filter(messageDelayInMinutes => !!messageDelayInMinutes), tap(messageDelayInMinutes => this.countDownTimeInSeconds.next(messageDelayInMinutes * 60)), map(() => true), shareReplay(1));
+    }
+    ngAfterViewInit() {
+        this.startTimer();
+    }
+    ngOnDestroy() {
+        this.clearTimer();
+    }
+    startTimer() {
+        this.interval = setInterval(() => {
+            let time = this.countDownTimeInSeconds.getValue();
+            if (time === 0) {
+                this.clearTimer();
+                return;
+            }
+            time -= 1;
+            this.countDownTimeInSeconds.next(time);
+        }, this.PULLING_IN_MILLISECONDS);
+    }
+    clearTimer() {
+        clearInterval(this.interval);
+    }
+    formatTime(timeInSeconds) {
+        const hours = Math.floor(timeInSeconds / (60 * 60));
+        const divisor_for_minutes = timeInSeconds % (60 * 60);
+        const minutes = Math.floor(divisor_for_minutes / 60);
+        const divisor_for_seconds = divisor_for_minutes % 60;
+        const seconds = Math.ceil(divisor_for_seconds);
+        this.manageScreenReaderAnnouncement(timeInSeconds, hours, minutes, seconds);
+        const leftPadHours = this.dateHelper.leftPad(hours.toString());
+        const leftPadMinutes = this.dateHelper.leftPad(minutes.toString());
+        const leftPadSeconds = this.dateHelper.leftPad(seconds.toString());
+        return `${leftPadHours}:${leftPadMinutes}:${leftPadSeconds}`;
+    }
+    announceSrMessage(msg) {
+        clearTimeout(this.srAnnouncementClearTimer);
+        this.srAnnouncementsSubject.next(msg);
+        this.srAnnouncementClearTimer = setTimeout(() => {
+            this.srAnnouncementsSubject.next('');
+        }, this.SR_ANNOUNCEMENT_CLEAR_TIMEOUT_INTERVAL_MS);
+    }
+    getReadableTimerForScreenReader(hours, minutes, seconds) {
+        if (!hours && !minutes && !seconds) {
+            return '';
+        }
+        if (!!hours && !minutes && !seconds) {
+            return `${hours} heures`;
+        }
+        if (!!minutes && !hours && !seconds) {
+            return `${minutes} minutes`;
+        }
+        if (!!seconds && !minutes && !hours) {
+            return `${seconds} secondes`;
+        }
+        if (!!hours && !!minutes && !!seconds) {
+            return `${hours} heures ${minutes} minutes et ${seconds} secondes`;
+        }
+        if (!!hours && !!minutes && !seconds) {
+            return `${hours} heures et ${minutes} minutes`;
+        }
+        if (!!hours && !!seconds && !minutes) {
+            return `${hours} heures et ${seconds} secondes`;
+        }
+        if (!!minutes && !!seconds && !hours) {
+            return `${minutes} minutes et ${seconds} secondes`;
+        }
+    }
+    manageScreenReaderAnnouncement(timeInSeconds, hours, minutes, seconds) {
+        const _1_hourInSeconds = 60 * 60;
+        const _5_minutesInSeconds = 5 * 60;
+        const _10_minutesInSeconds = 10 * 60;
+        const _1_minuteInSeconds = 60;
+        const _2_minuteInSeconds = 2 * 60;
+        // When finished, display expired message
+        if (timeInSeconds === 0) {
+            this.srAnnouncementsSubject.next(this.dictionaryService.getKeySync('foehn-page-expiration-timer.expired-message.sr-only'));
+            return;
+        }
+        // Every second for the last 15s
+        if (timeInSeconds <= 15) {
+            this.srAnnouncementsSubject.next(timeInSeconds.toString());
+            return;
+        }
+        // Every 30s when less than 2 minutes
+        if (timeInSeconds <= _2_minuteInSeconds && timeInSeconds % 30 === 0) {
+            const msg = this.getReadableTimerForScreenReader(hours, minutes, seconds);
+            this.announceSrMessage(this.dictionaryService.getKeySync('foehn-page-expiration-timer.count-down-message.sr-only', { countDownValue: msg }));
+            return;
+        }
+        // Every minute for the last 5 minutes
+        if (timeInSeconds <= _5_minutesInSeconds &&
+            timeInSeconds % _1_minuteInSeconds === 0) {
+            const msg = this.getReadableTimerForScreenReader(hours, minutes, seconds);
+            this.announceSrMessage(this.dictionaryService.getKeySync('foehn-page-expiration-timer.count-down-message.sr-only', { countDownValue: msg }));
+            return;
+        }
+        // Every 10 minutes when less than an hour
+        if (timeInSeconds < _1_hourInSeconds &&
+            timeInSeconds % _10_minutesInSeconds === 0) {
+            const msg = this.getReadableTimerForScreenReader(hours, minutes, seconds);
+            this.announceSrMessage(this.dictionaryService.getKeySync('foehn-page-expiration-timer.count-down-message.sr-only', { countDownValue: msg }));
+            return;
+        }
+        // Every hour when more than an hour
+        if (timeInSeconds >= _1_hourInSeconds &&
+            timeInSeconds % _1_hourInSeconds === 0) {
+            const msg = this.getReadableTimerForScreenReader(hours, minutes, seconds);
+            this.announceSrMessage(this.dictionaryService.getKeySync('foehn-page-expiration-timer.count-down-message.sr-only', { countDownValue: msg }));
+            return;
+        }
+    }
+}
+FoehnPageExpirationTimerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FoehnPageExpirationTimerComponent, deps: [{ token: i1.ApplicationInfoService }, { token: i2.SdkDictionaryService }], target: i0.ɵɵFactoryTarget.Component });
+FoehnPageExpirationTimerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.9", type: FoehnPageExpirationTimerComponent, selector: "foehn-page-expiration-timer", ngImport: i0, template: "<div\n    *ngIf=\"applicationInfoRetrieved | async\"\n    class=\"sticky-top alert text-center my-0\"\n    [class.alert-warning]=\"(sessionExpired | async) === false\"\n    [class.alert-danger]=\"(sessionExpired | async) === true\"\n    tabindex=\"-1\"\n    aria-hidden=\"true\"\n>\n    <div\n        *ngIf=\"(sessionExpired | async) === false\"\n        [innerHTML]=\"\n            'foehn-page-expiration-timer.count-down-message'\n                | fromDictionary\n                    : { countDownValue: countDownTimeToDisplay | async }\n        \"\n    ></div>\n    <div\n        *ngIf=\"(sessionExpired | async) === true\"\n        [innerHTML]=\"\n            'foehn-page-expiration-timer.expired-message' | fromDictionary\n        \"\n    ></div>\n</div>\n\n<p class=\"sr-only\" aria-live=\"assertive\" aria-atomic=\"true\">\n    {{ srAnnouncements | async }}\n</p>\n", dependencies: [{ kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }, { kind: "pipe", type: i4.SdkDictionaryPipe, name: "fromDictionary" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FoehnPageExpirationTimerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'foehn-page-expiration-timer', template: "<div\n    *ngIf=\"applicationInfoRetrieved | async\"\n    class=\"sticky-top alert text-center my-0\"\n    [class.alert-warning]=\"(sessionExpired | async) === false\"\n    [class.alert-danger]=\"(sessionExpired | async) === true\"\n    tabindex=\"-1\"\n    aria-hidden=\"true\"\n>\n    <div\n        *ngIf=\"(sessionExpired | async) === false\"\n        [innerHTML]=\"\n            'foehn-page-expiration-timer.count-down-message'\n                | fromDictionary\n                    : { countDownValue: countDownTimeToDisplay | async }\n        \"\n    ></div>\n    <div\n        *ngIf=\"(sessionExpired | async) === true\"\n        [innerHTML]=\"\n            'foehn-page-expiration-timer.expired-message' | fromDictionary\n        \"\n    ></div>\n</div>\n\n<p class=\"sr-only\" aria-live=\"assertive\" aria-atomic=\"true\">\n    {{ srAnnouncements | async }}\n</p>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.ApplicationInfoService }, { type: i2.SdkDictionaryService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"foehn-page-expiration-timer.component.js","sourceRoot":"","sources":["../../../../../projects/prestations-ng/src/foehn-page/foehn-page-expiration-timer/foehn-page-expiration-timer.component.ts","../../../../../projects/prestations-ng/src/foehn-page/foehn-page-expiration-timer/foehn-page-expiration-timer.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Component, OnDestroy } from '@angular/core';\nimport { BehaviorSubject, Observable } from 'rxjs';\nimport { debounceTime, filter, map, shareReplay, tap } from 'rxjs/operators';\n\nimport { SdkDictionaryService } from '../..//sdk-dictionary/sdk-dictionary.service';\nimport { ApplicationInfo } from '../../sdk-appinfo/application-info';\nimport { ApplicationInfoService } from '../../sdk-appinfo/application-info.service';\nimport { DateHelper } from '../../sdk-date/date.helper';\n\n@Component({\n    selector: 'foehn-page-expiration-timer',\n    templateUrl: './foehn-page-expiration-timer.component.html'\n})\nexport class FoehnPageExpirationTimerComponent\n    implements AfterViewInit, OnDestroy {\n    applicationInfoRetrieved: Observable<boolean>;\n    countDownTimeToDisplay: Observable<string>;\n    sessionExpired: Observable<boolean>;\n    srAnnouncements: Observable<string>;\n\n    private countDownTimeInSeconds = new BehaviorSubject<number>(null);\n    private sessionHasExpired = new BehaviorSubject<boolean>(false);\n    private srAnnouncementsSubject = new BehaviorSubject<string>('');\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    private interval: any;\n    private dateHelper = new DateHelper();\n\n    private readonly PULLING_IN_MILLISECONDS = 1000;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    private srAnnouncementClearTimer: any;\n    private readonly SR_ANNOUNCEMENT_CLEAR_TIMEOUT_INTERVAL_MS = 2000;\n\n    constructor(\n        private applicationInfoService: ApplicationInfoService,\n        private dictionaryService: SdkDictionaryService\n    ) {\n        this.sessionExpired = this.sessionHasExpired\n            .asObservable()\n            .pipe(shareReplay(1));\n\n        this.srAnnouncements = this.srAnnouncementsSubject\n            .asObservable()\n            .pipe(debounceTime(0)); // debounceTime to \"avoid expression has changes before...\"\n\n        this.countDownTimeToDisplay = this.countDownTimeInSeconds\n            .asObservable()\n            .pipe(\n                tap(countDownTimeInSeconds =>\n                    this.sessionHasExpired.next(countDownTimeInSeconds === 0)\n                ),\n                map(countDownTimeInSeconds =>\n                    this.formatTime(countDownTimeInSeconds)\n                ),\n                shareReplay(1)\n            );\n\n        this.applicationInfoRetrieved = this.applicationInfoService.data.pipe(\n            map(\n                (info: ApplicationInfo) =>\n                    info.configuration.session.messageDelayInMinutes\n            ),\n            filter(messageDelayInMinutes => !!messageDelayInMinutes),\n            tap(messageDelayInMinutes =>\n                this.countDownTimeInSeconds.next(messageDelayInMinutes * 60)\n            ),\n            map(() => true),\n            shareReplay(1)\n        );\n    }\n\n    ngAfterViewInit(): void {\n        this.startTimer();\n    }\n\n    ngOnDestroy(): void {\n        this.clearTimer();\n    }\n\n    private startTimer(): void {\n        this.interval = setInterval(() => {\n            let time = this.countDownTimeInSeconds.getValue();\n            if (time === 0) {\n                this.clearTimer();\n                return;\n            }\n            time -= 1;\n            this.countDownTimeInSeconds.next(time);\n        }, this.PULLING_IN_MILLISECONDS);\n    }\n\n    private clearTimer(): void {\n        clearInterval(this.interval);\n    }\n\n    private formatTime(timeInSeconds: number): string {\n        const hours = Math.floor(timeInSeconds / (60 * 60));\n\n        const divisor_for_minutes = timeInSeconds % (60 * 60);\n        const minutes = Math.floor(divisor_for_minutes / 60);\n\n        const divisor_for_seconds = divisor_for_minutes % 60;\n        const seconds = Math.ceil(divisor_for_seconds);\n\n        this.manageScreenReaderAnnouncement(\n            timeInSeconds,\n            hours,\n            minutes,\n            seconds\n        );\n\n        const leftPadHours = this.dateHelper.leftPad(hours.toString());\n        const leftPadMinutes = this.dateHelper.leftPad(minutes.toString());\n\n        const leftPadSeconds = this.dateHelper.leftPad(seconds.toString());\n        return `${leftPadHours}:${leftPadMinutes}:${leftPadSeconds}`;\n    }\n\n    private announceSrMessage(msg: string): void {\n        clearTimeout(this.srAnnouncementClearTimer);\n        this.srAnnouncementsSubject.next(msg);\n\n        this.srAnnouncementClearTimer = setTimeout(() => {\n            this.srAnnouncementsSubject.next('');\n        }, this.SR_ANNOUNCEMENT_CLEAR_TIMEOUT_INTERVAL_MS);\n    }\n\n    private getReadableTimerForScreenReader(\n        hours: number,\n        minutes: number,\n        seconds: number\n    ): string {\n        if (!hours && !minutes && !seconds) {\n            return '';\n        }\n        if (!!hours && !minutes && !seconds) {\n            return `${hours} heures`;\n        }\n        if (!!minutes && !hours && !seconds) {\n            return `${minutes} minutes`;\n        }\n        if (!!seconds && !minutes && !hours) {\n            return `${seconds} secondes`;\n        }\n        if (!!hours && !!minutes && !!seconds) {\n            return `${hours} heures ${minutes} minutes et ${seconds} secondes`;\n        }\n        if (!!hours && !!minutes && !seconds) {\n            return `${hours} heures et ${minutes} minutes`;\n        }\n        if (!!hours && !!seconds && !minutes) {\n            return `${hours} heures et ${seconds} secondes`;\n        }\n        if (!!minutes && !!seconds && !hours) {\n            return `${minutes} minutes et ${seconds} secondes`;\n        }\n    }\n\n    private manageScreenReaderAnnouncement(\n        timeInSeconds: number,\n        hours: number,\n        minutes: number,\n        seconds: number\n    ): void {\n        const _1_hourInSeconds = 60 * 60;\n        const _5_minutesInSeconds = 5 * 60;\n        const _10_minutesInSeconds = 10 * 60;\n        const _1_minuteInSeconds = 60;\n        const _2_minuteInSeconds = 2 * 60;\n\n        // When finished, display expired message\n        if (timeInSeconds === 0) {\n            this.srAnnouncementsSubject.next(\n                this.dictionaryService.getKeySync(\n                    'foehn-page-expiration-timer.expired-message.sr-only'\n                )\n            );\n            return;\n        }\n        // Every second for the last 15s\n        if (timeInSeconds <= 15) {\n            this.srAnnouncementsSubject.next(timeInSeconds.toString());\n            return;\n        }\n        // Every 30s when less than 2 minutes\n        if (timeInSeconds <= _2_minuteInSeconds && timeInSeconds % 30 === 0) {\n            const msg = this.getReadableTimerForScreenReader(\n                hours,\n                minutes,\n                seconds\n            );\n            this.announceSrMessage(\n                this.dictionaryService.getKeySync(\n                    'foehn-page-expiration-timer.count-down-message.sr-only',\n                    { countDownValue: msg }\n                )\n            );\n            return;\n        }\n        // Every minute for the last 5 minutes\n        if (\n            timeInSeconds <= _5_minutesInSeconds &&\n            timeInSeconds % _1_minuteInSeconds === 0\n        ) {\n            const msg = this.getReadableTimerForScreenReader(\n                hours,\n                minutes,\n                seconds\n            );\n            this.announceSrMessage(\n                this.dictionaryService.getKeySync(\n                    'foehn-page-expiration-timer.count-down-message.sr-only',\n                    { countDownValue: msg }\n                )\n            );\n            return;\n        }\n        // Every 10 minutes when less than an hour\n        if (\n            timeInSeconds < _1_hourInSeconds &&\n            timeInSeconds % _10_minutesInSeconds === 0\n        ) {\n            const msg = this.getReadableTimerForScreenReader(\n                hours,\n                minutes,\n                seconds\n            );\n            this.announceSrMessage(\n                this.dictionaryService.getKeySync(\n                    'foehn-page-expiration-timer.count-down-message.sr-only',\n                    { countDownValue: msg }\n                )\n            );\n            return;\n        }\n        // Every hour when more than an hour\n        if (\n            timeInSeconds >= _1_hourInSeconds &&\n            timeInSeconds % _1_hourInSeconds === 0\n        ) {\n            const msg = this.getReadableTimerForScreenReader(\n                hours,\n                minutes,\n                seconds\n            );\n            this.announceSrMessage(\n                this.dictionaryService.getKeySync(\n                    'foehn-page-expiration-timer.count-down-message.sr-only',\n                    { countDownValue: msg }\n                )\n            );\n            return;\n        }\n    }\n}\n","<div\n    *ngIf=\"applicationInfoRetrieved | async\"\n    class=\"sticky-top alert text-center my-0\"\n    [class.alert-warning]=\"(sessionExpired | async) === false\"\n    [class.alert-danger]=\"(sessionExpired | async) === true\"\n    tabindex=\"-1\"\n    aria-hidden=\"true\"\n>\n    <div\n        *ngIf=\"(sessionExpired | async) === false\"\n        [innerHTML]=\"\n            'foehn-page-expiration-timer.count-down-message'\n                | fromDictionary\n                    : { countDownValue: countDownTimeToDisplay | async }\n        \"\n    ></div>\n    <div\n        *ngIf=\"(sessionExpired | async) === true\"\n        [innerHTML]=\"\n            'foehn-page-expiration-timer.expired-message' | fromDictionary\n        \"\n    ></div>\n</div>\n\n<p class=\"sr-only\" aria-live=\"assertive\" aria-atomic=\"true\">\n    {{ srAnnouncements | async }}\n</p>\n"]}