@dflat-core/web 1.0.45 → 1.0.46

package/fesm2022/dflat-core-web-core-services.mjs

@@ -1,1622 +1,1847 @@
-import * as i7 from '@dflat-core/web/core';
-import { Utilities, EnsureModuleLoadedOnceGuard } from '@dflat-core/web/core';
-import { DictionnaryWrapper, UserUpdatedMessage, Notification, User, CoreModelModule, ApiErrorTypes } from '@dflat-core/web/core-model';
-import { CommonModule } from '@angular/common';
-import * as i3 from '@angular/common/http';
-import { HttpHeaders, provideHttpClient, withInterceptorsFromDi, HttpErrorResponse } from '@angular/common/http';
-import * as i0 from '@angular/core';
-import { Injectable, EventEmitter, Optional, SkipSelf, NgModule, InjectionToken, Inject } from '@angular/core';
-import * as i1 from '@angular/router';
-import jwt_decode from 'jwt-decode';
-import { Subject, ReplaySubject, timer, throwError, BehaviorSubject, empty } from 'rxjs';
-import { filter, map, finalize, catchError } from 'rxjs/operators';
-import * as i1$1 from '@angular/platform-browser';
-import * as signalR from '@microsoft/signalr';
-
-class AppConfiguration {
-    constructor() {
-        this.searchText = "";
-        this.isSearchAllowed = false;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: AppConfiguration, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: AppConfiguration }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: AppConfiguration, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [] });
-
-class AppKeys {
-    static { this.CURRENT_USER = "current_user"; }
-    static { this.ACCESS_TOKEN = "access_token"; }
-    static { this.REFRESH_TOKEN = "refresh_token"; }
-    static { this.TOKEN_EXPIRES_IN = "expires_in"; }
-    static { this.REMEMBER_ME = "remember_me"; }
-    static { this.PERMISSIONS = "permissions"; }
-    static { this.LAST_GEOLOCATIONS = "geolocations"; }
-    static { this.REFERENCE_SUPPLIER_ID = "refsuppid"; }
-    static { this.USER_COMPANY_ID = "companyid"; }
-    static { this.SELECTED_COMPANY = "selectedcompany"; }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: AppKeys, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: AppKeys }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: AppKeys, decorators: [{
-            type: Injectable
-        }] });
-
-class BusMessageService {
-    constructor() {
-        this.message$ = new Subject();
-    }
-    publish(message) {
-        const channel = message.constructor.name;
-        this.message$.next({ Channel: channel, Data: message });
-    }
-    of(messageType) {
-        const channel = messageType.name;
-        return this.message$.pipe(filter(m => m.Channel === channel), map(m => m.Data));
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: BusMessageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: BusMessageService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: BusMessageService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [] });
-class NotificationMqService {
-    constructor() {
-        this.message$ = new Subject();
-    }
-    publish(message) {
-        const defaultchannel = message.entityType;
-        this.message$.next({ Channel: defaultchannel, Data: message });
-        if (!Utilities.IsUndefined(message.entityId)) {
-            const detailchannel = `${message.entityType}-${message.entityId}`;
-            this.message$.next({ Channel: detailchannel, Data: message });
-        }
-    }
-    of(channelKey) {
-        const channel = channelKey;
-        return this.message$.pipe(filter(m => m.Channel === channel), map(m => m.Data));
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: NotificationMqService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: NotificationMqService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: NotificationMqService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [] });
-
-class LocalStoreManager {
-    constructor() {
-        this.syncKeys = [];
-        this.initEvent = new Subject();
-        this.reservedKeys = ['sync_keys', 'addToSyncKeys', 'removeFromSyncKeys',
-            'getSessionStorage', 'setSessionStorage', 'addToSessionStorage', 'removeFromSessionStorage', 'clearAllSessionsStorage'];
-        this.sessionStorageTransferHandler = (event) => {
-            if (!event.newValue)
-                return;
-            if (event.key == 'getSessionStorage') {
-                if (sessionStorage.length) {
-                    this.localStorageSetItem('setSessionStorage', sessionStorage);
-                    localStorage.removeItem('setSessionStorage');
-                }
-            }
-            else if (event.key == 'setSessionStorage') {
-                if (!this.syncKeys.length)
-                    this.loadSyncKeys();
-                let data = JSON.parse(event.newValue);
-                //console.info("Set => Key: Transfer setSessionStorage" + ",  data: " + JSON.stringify(data));
-                for (let key in data) {
-                    if (this.syncKeysContains(key))
-                        this.sessionStorageSetItem(key, JSON.parse(data[key]));
-                }
-                this.onInit();
-            }
-            else if (event.key === 'addToSessionStorage') {
-                let data = JSON.parse(event.newValue);
-                //console.warn("Set => Key: Transfer addToSessionStorage" + ",  data: " + JSON.stringify(data));
-                this.addToSessionStorageHelper(data["data"], data["key"]);
-            }
-            else if (event.key === 'removeFromSessionStorage') {
-                this.removeFromSessionStorageHelper(event.newValue);
-            }
-            else if (event.key === 'clearAllSessionsStorage' && sessionStorage.length) {
-                this.clearInstanceSessionStorage();
-            }
-            else if (event.key === 'addToSyncKeys') {
-                this.addToSyncKeysHelper(event.newValue);
-            }
-            else if (event.key === 'removeFromSyncKeys') {
-                this.removeFromSyncKeysHelper(event.newValue);
-            }
-        };
-    }
-    static { this.syncListenerInitialised = false; }
-    static { this.DBKEY_USER_DATA = "user_data"; }
-    static { this.DBKEY_SYNC_KEYS = "sync_keys"; }
-    //Todo: Implement EventListeners for the various event operations and a SessionStorageEvent for specific data keys
-    initialiseStorageSyncListener() {
-        if (LocalStoreManager.syncListenerInitialised == true)
-            return;
-        LocalStoreManager.syncListenerInitialised = true;
-        window.addEventListener("storage", this.sessionStorageTransferHandler, false);
-        this.syncSessionStorage();
-    }
-    deinitialiseStorageSyncListener() {
-        window.removeEventListener("storage", this.sessionStorageTransferHandler, false);
-        LocalStoreManager.syncListenerInitialised = false;
-    }
-    syncSessionStorage() {
-        localStorage.setItem('getSessionStorage', '_dummy');
-        localStorage.removeItem('getSessionStorage');
-    }
-    clearAllStorage() {
-        this.clearAllSessionsStorage();
-        this.clearLocalStorage();
-    }
-    clearAllSessionsStorage() {
-        this.clearInstanceSessionStorage();
-        localStorage.removeItem(LocalStoreManager.DBKEY_SYNC_KEYS);
-        localStorage.setItem('clearAllSessionsStorage', '_dummy');
-        localStorage.removeItem('clearAllSessionsStorage');
-    }
-    clearInstanceSessionStorage() {
-        sessionStorage.clear();
-        this.syncKeys = [];
-    }
-    clearLocalStorage() {
-        localStorage.clear();
-    }
-    addToSessionStorage(data, key) {
-        this.addToSessionStorageHelper(data, key);
-        this.addToSyncKeysBackup(key);
-        this.localStorageSetItem('addToSessionStorage', { key: key, data: data });
-        localStorage.removeItem('addToSessionStorage');
-    }
-    addToSessionStorageHelper(data, key) {
-        this.addToSyncKeysHelper(key);
-        this.sessionStorageSetItem(key, data);
-    }
-    removeFromSessionStorage(keyToRemove) {
-        this.removeFromSessionStorageHelper(keyToRemove);
-        this.removeFromSyncKeysBackup(keyToRemove);
-        localStorage.setItem('removeFromSessionStorage', keyToRemove);
-        localStorage.removeItem('removeFromSessionStorage');
-    }
-    removeFromSessionStorageHelper(keyToRemove) {
-        sessionStorage.removeItem(keyToRemove);
-        this.removeFromSyncKeysHelper(keyToRemove);
-    }
-    testForInvalidKeys(key) {
-        if (!key)
-            throw new Error("key cannot be empty");
-        if (this.reservedKeys.some(x => x === key))
-            throw new Error(`The storage key "${key}" is reserved and cannot be used. Please use a different key`);
-    }
-    syncKeysContains(key) {
-        return this.syncKeys.some(x => x === key);
-    }
-    loadSyncKeys() {
-        if (this.syncKeys.length)
-            return;
-        this.syncKeys = this.getSyncKeysFromStorage();
-    }
-    getSyncKeysFromStorage(defaultValue = []) {
-        let data = this.localStorageGetItem(LocalStoreManager.DBKEY_SYNC_KEYS);
-        if (data == null)
-            return defaultValue;
-        else
-            return data;
-    }
-    addToSyncKeys(key) {
-        this.addToSyncKeysHelper(key);
-        this.addToSyncKeysBackup(key);
-        localStorage.setItem('addToSyncKeys', key);
-        localStorage.removeItem('addToSyncKeys');
-    }
-    addToSyncKeysBackup(key) {
-        let storedSyncKeys = this.getSyncKeysFromStorage();
-        if (!storedSyncKeys.some(x => x === key)) {
-            storedSyncKeys.push(key);
-            this.localStorageSetItem(LocalStoreManager.DBKEY_SYNC_KEYS, storedSyncKeys);
-        }
-    }
-    removeFromSyncKeysBackup(key) {
-        let storedSyncKeys = this.getSyncKeysFromStorage();
-        let index = storedSyncKeys.indexOf(key);
-        if (index > -1) {
-            storedSyncKeys.splice(index, 1);
-            this.localStorageSetItem(LocalStoreManager.DBKEY_SYNC_KEYS, storedSyncKeys);
-        }
-    }
-    addToSyncKeysHelper(key) {
-        if (!this.syncKeysContains(key))
-            this.syncKeys.push(key);
-    }
-    removeFromSyncKeys(key) {
-        this.removeFromSyncKeysHelper(key);
-        this.removeFromSyncKeysBackup(key);
-        localStorage.setItem('removeFromSyncKeys', key);
-        localStorage.removeItem('removeFromSyncKeys');
-    }
-    removeFromSyncKeysHelper(key) {
-        let index = this.syncKeys.indexOf(key);
-        if (index > -1) {
-            this.syncKeys.splice(index, 1);
-        }
-    }
-    saveSessionData(data, key = LocalStoreManager.DBKEY_USER_DATA) {
-        this.testForInvalidKeys(key);
-        this.removeFromSyncKeys(key);
-        localStorage.removeItem(key);
-        this.sessionStorageSetItem(key, data);
-    }
-    saveSyncedSessionData(data, key = LocalStoreManager.DBKEY_USER_DATA) {
-        this.testForInvalidKeys(key);
-        localStorage.removeItem(key);
-        this.addToSessionStorage(data, key);
-    }
-    savePermanentData(data, key = LocalStoreManager.DBKEY_USER_DATA) {
-        this.testForInvalidKeys(key);
-        this.removeFromSessionStorage(key);
-        this.localStorageSetItem(key, data);
-    }
-    moveDataToSessionStorage(key = LocalStoreManager.DBKEY_USER_DATA) {
-        this.testForInvalidKeys(key);
-        let data = this.getData(key);
-        if (data == null)
-            return;
-        this.saveSessionData(data, key);
-    }
-    moveDataToSyncedSessionStorage(key = LocalStoreManager.DBKEY_USER_DATA) {
-        this.testForInvalidKeys(key);
-        let data = this.getData(key);
-        if (data == null)
-            return;
-        this.saveSyncedSessionData(data, key);
-    }
-    moveDataToPermanentStorage(key = LocalStoreManager.DBKEY_USER_DATA) {
-        this.testForInvalidKeys(key);
-        let data = this.getData(key);
-        if (data == null)
-            return;
-        this.savePermanentData(data, key);
-    }
-    exists(key = LocalStoreManager.DBKEY_USER_DATA) {
-        let data = sessionStorage.getItem(key);
-        if (data == null)
-            data = localStorage.getItem(key);
-        return data != null;
-    }
-    getData(key = LocalStoreManager.DBKEY_USER_DATA) {
-        this.testForInvalidKeys(key);
-        let data = this.sessionStorageGetItem(key);
-        if (data == null)
-            data = this.localStorageGetItem(key);
-        return data;
-    }
-    getDataObject(key = LocalStoreManager.DBKEY_USER_DATA, isDateType = false) {
-        let data = this.getData(key);
-        if (data != null) {
-            if (isDateType)
-                data = new Date(data);
-            return data;
-        }
-        else {
-            return null;
-        }
-    }
-    deleteData(key = LocalStoreManager.DBKEY_USER_DATA) {
-        this.testForInvalidKeys(key);
-        this.removeFromSessionStorage(key);
-        localStorage.removeItem(key);
-    }
-    localStorageSetItem(key, data) {
-        localStorage.setItem(key, JSON.stringify(data));
-    }
-    sessionStorageSetItem(key, data) {
-        sessionStorage.setItem(key, JSON.stringify(data));
-    }
-    localStorageGetItem(key) {
-        return Utilities.JSonTryParse(localStorage.getItem(key));
-    }
-    sessionStorageGetItem(key) {
-        return Utilities.JSonTryParse(sessionStorage.getItem(key));
-    }
-    onInit() {
-        setTimeout(() => {
-            this.initEvent.next({});
-            this.initEvent.complete();
-        });
-    }
-    getInitEvent() {
-        return this.initEvent.asObservable();
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: LocalStoreManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: LocalStoreManager }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: LocalStoreManager, decorators: [{
-            type: Injectable
-        }] });
-
-class HeadersService {
-    constructor(localStorage) {
-        this.localStorage = localStorage;
-    }
-    // for requesting secure data using json
-    authJsonHeaders() {
-        let result = new HttpHeaders()
-            .set('Content-Type', 'application/json')
-            .set('Accept', 'application/json')
-            .set('Authorization', `Bearer ${this.geJWTToken}`);
-        return result;
-    }
-    // for requesting secure data from a form post
-    authFormHeaders() {
-        let result = new HttpHeaders()
-            .set('Content-Type', 'application/x-www-form-urlencoded')
-            .set('Accept', 'application/json')
-            .set('Authorization', `Bearer ${this.geJWTToken}`);
-        return result;
-    }
-    authFileUploadHeaders() {
-        return new HttpHeaders()
-            .set('Authorization', `Bearer ${this.geJWTToken}`);
-    }
-    // for requesting unsecured data using json
-    jsonHeaders() {
-        return new HttpHeaders()
-            .set('Content-Type', 'application/json')
-            .set('Accept', 'application/json');
-    }
-    // for requesting unsecured data using form post
-    contentHeadersV2() {
-        return new HttpHeaders()
-            .set('Content-Type', 'application/x-www-form-urlencoded')
-            .set('Accept', 'application/json');
-    }
-    get geJWTToken() {
-        let result = this.localStorage.getDataObject(AppKeys.ACCESS_TOKEN);
-        if (Utilities.IsNil(result))
-            return '';
-        return result;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: HeadersService, deps: [{ token: LocalStoreManager }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: HeadersService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: HeadersService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: LocalStoreManager }] });
-
-class ServerUrl {
-    static { this.isProduction = false; }
-    // POUR TESTER L'ENVIRONNEMENT DE PROD EN LOCAL DECOMMENTER LES LIGNES
-    // static  baseUrl =  (ServerUrl.isProduction ? 'http://localhost:56407' : 'http://localhost:56407');
-    static { this.baseUrl = (ServerUrl.isProduction ? '' : 'http://localhost:56407'); }
-    static { this.apiUrl = ServerUrl.baseUrl + '/api'; }
-    static { this.hubUrl = ServerUrl.baseUrl + '/hub'; }
-    static { this.loginPath = '/Account/Login'; }
-    static { this.connectPath = '/Account/Connect'; }
-    static { this.registerPath = '/Account/Register'; }
-    static { this.activatePath = '/Account/Activate'; }
-    static { this.refreshPath = '/Account/RefreshToken'; }
-    static { this.disconnectPath = '/Account/Disconnect'; }
-}
-
-class PermissionService {
-    constructor(localStorage) {
-        this.localStorage = localStorage;
-    }
-    hasPermission(permission) {
-        return this.permissions != null && this.permissions.some(p => p === permission) || this.isAdmin;
-    }
-    get permissions() {
-        let permissions = this.localStorage.getDataObject(AppKeys.PERMISSIONS);
-        let parsed_permissions = JSON.parse(permissions);
-        return parsed_permissions;
-    }
-    get isAdmin() {
-        let parsed = JSON.parse(this.currentUser);
-        return parsed && parsed.IsAdmin || false;
-    }
-    get currentUser() {
-        return this.localStorage.getDataObject(AppKeys.CURRENT_USER);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: PermissionService, deps: [{ token: LocalStoreManager }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: PermissionService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: PermissionService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: LocalStoreManager }] });
-
-class MenuService {
-    constructor(permissionService) {
-        this.permissionService = permissionService;
-        this.current = new ReplaySubject(1);
-        this.hasPermission = (permKey) => {
-            if (permKey === undefined)
-                return true;
-            return this.permissionService.hasPermission(permKey);
-        };
-        this.hasAnyPermission = (permKeys) => {
-            let result = false;
-            permKeys.forEach(p => result = result || this.hasPermission(p));
-            return result;
-        };
-    }
-    setCurrent(menu) {
-        this.current.next(menu);
-    }
-    getCurrent() {
-        return this.current;
-    }
-    get permissionRouteMap() {
-        if (Utilities.IsNil(this._permissionRouteMap)) {
-            this._permissionRouteMap = new DictionnaryWrapper();
-            this.getAllMenuItems(true).forEach(item => {
-                if (!Utilities.IsNil(item.sublinks)) {
-                    item.sublinks.forEach(subItem => {
-                        if (subItem.permissionKey) {
-                            this._permissionRouteMap.dictionary[subItem.link] = subItem.permissionKey;
-                        }
-                    });
-                }
-            });
-        }
-        return this._permissionRouteMap;
-    }
-    resetPermissionMap() {
-        this._permissionRouteMap = undefined;
-    }
-    hasAccessToThisRoute(url) {
-        let menuItems = this.getAccessGrantedMenuItems();
-        if (!Utilities.IsNil(menuItems) && menuItems.findIndex(f => f.link === url) >= 0)
-            return true;
-        if (this.permissionRouteMap.containsKeyOrPartKey(url)) {
-            return this.hasPermission(this.permissionRouteMap.getPartKey(url));
-        }
-        // Le menu n'a pas de permissions associé, on renvoie true
-        return true;
-    }
-    pushItem(items, menuItem, isAdmin) {
-        if (Utilities.IsNil(menuItem.permissionKey) ||
-            isAdmin || this.hasPermission(menuItem.permissionKey)) {
-            items.push(menuItem);
-        }
-    }
-    getMenuItems(isAdmin) {
-        let results = this.getAllMenuItems(isAdmin);
-        for (let i = 0; i < results.length; i++)
-            results[i].id = i;
-        return this.sortLinks(results);
-    }
-    sortLinks(links) {
-        return links.map(t => { return { ...t, sublinks: this.sortLinksSubLevel(t.sublinks) }; });
-    }
-    sortLinksSubLevel(links) {
-        if (!links)
-            return null;
-        return links.sort((a, b) => a.title.localeCompare(b.title));
-    }
-    //  private fillmap(map: Map<string,MenuItem>,menuItems: MenuItem[], parent: string = null )
-    //   {
-    //     if ( ! Utilities.IsNil(menuItems)) {
-    //             menuItems.forEach(x =>{
-    //                     if ( ! Utilities.IsNil(parent))
-    //                         parent = parent.concat("/" + x.title);
-    //                     else
-    //                         parent = x.title;
-    //                     map.set(parent,x);
-    //                     this.fillmap(map,x.sublinks,parent);
-    //             });
-    //         }
-    //         return map;
-    //     }
-    //   public mergeall(Menus:MenuItem[][]): MenuItem[]
-    //   {
-    //     let menuItem  = Array<MenuItem>();
-    //     let map = new Map<string,MenuItem>();
-    //     Menus.forEach(menuItem => {
-    //         this.fillmap(map,menuItem,null);
-    //     });
-    //     let sortedmap = new Map([...map].sort());
-    //     sortedmap.forEach(element => {
-    //         menuItem.push()
-    //     });
-    //     return menuItem;
-    //   }
-    merge(Menus) {
-        //  let titles : string[];
-        //             if (!(item.title in titles)){
-        //                 titles.push(item.title);
-        //                 menu.push(item);
-        //             }
-        //             else{
-        let menu = [];
-        Menus.forEach(item => {
-            let index = menu.findIndex(x => x.title == item.title);
-            if (index >= 0)
-                menu[index].sublinks = [...menu[index].sublinks, ...item.sublinks];
-            else
-                menu.push(item);
-        });
-        return menu;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: MenuService, deps: [{ token: PermissionService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: MenuService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: MenuService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: PermissionService }] });
-
+import * as i7 from "@dflat-core/web/core";
+import { EnsureModuleLoadedOnceGuard, Utilities } from "@dflat-core/web/core";
+import { ApiErrorTypes, CoreModelModule, DictionnaryWrapper, Notification, User, UserUpdatedMessage } from "@dflat-core/web/core-model";
+import { CommonModule } from "@angular/common";
+import * as i3 from "@angular/common/http";
+import { HttpErrorResponse, HttpHeaders, provideHttpClient, withInterceptorsFromDi, withXhr } from "@angular/common/http";
+import * as i0 from "@angular/core";
+import { EventEmitter, Inject, Injectable, InjectionToken, NgModule, Optional, SkipSelf } from "@angular/core";
+import jwt_decode from "jwt-decode";
+import { BehaviorSubject, ReplaySubject, Subject, empty, throwError, timer } from "rxjs";
+import { catchError, filter, finalize, map } from "rxjs/operators";
+import * as i4 from "@angular/router";
+import * as i1 from "@angular/platform-browser";
+import * as signalR from "@microsoft/signalr";
+var AppConfiguration = class AppConfiguration {
+	constructor() {
+		this.searchText = "";
+		this.isSearchAllowed = false;
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: AppConfiguration,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: AppConfiguration
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: AppConfiguration,
+	decorators: [{ type: Injectable }],
+	ctorParameters: () => []
+});
+var AppKeys = class AppKeys {
+	static {
+		this.CURRENT_USER = "current_user";
+	}
+	static {
+		this.ACCESS_TOKEN = "access_token";
+	}
+	static {
+		this.REFRESH_TOKEN = "refresh_token";
+	}
+	static {
+		this.TOKEN_EXPIRES_IN = "expires_in";
+	}
+	static {
+		this.REMEMBER_ME = "remember_me";
+	}
+	static {
+		this.PERMISSIONS = "permissions";
+	}
+	static {
+		this.LAST_GEOLOCATIONS = "geolocations";
+	}
+	static {
+		this.REFERENCE_SUPPLIER_ID = "refsuppid";
+	}
+	static {
+		this.USER_COMPANY_ID = "companyid";
+	}
+	static {
+		this.SELECTED_COMPANY = "selectedcompany";
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: AppKeys,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: AppKeys
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: AppKeys,
+	decorators: [{ type: Injectable }]
+});
+var ServerUrl = class ServerUrl {
+	static {
+		this.isProduction = false;
+	}
+	static {
+		this.baseUrl = ServerUrl.isProduction ? "" : "http://localhost:56407";
+	}
+	static {
+		this.apiUrl = ServerUrl.baseUrl + "/api";
+	}
+	static {
+		this.hubUrl = ServerUrl.baseUrl + "/hub";
+	}
+	static {
+		this.loginPath = "/Account/Login";
+	}
+	static {
+		this.connectPath = "/Account/Connect";
+	}
+	static {
+		this.registerPath = "/Account/Register";
+	}
+	static {
+		this.activatePath = "/Account/Activate";
+	}
+	static {
+		this.refreshPath = "/Account/RefreshToken";
+	}
+	static {
+		this.disconnectPath = "/Account/Disconnect";
+	}
+};
+var LocalStoreManager = class LocalStoreManager {
+	constructor() {
+		this.syncKeys = [];
+		this.initEvent = new Subject();
+		this.reservedKeys = [
+			"sync_keys",
+			"addToSyncKeys",
+			"removeFromSyncKeys",
+			"getSessionStorage",
+			"setSessionStorage",
+			"addToSessionStorage",
+			"removeFromSessionStorage",
+			"clearAllSessionsStorage"
+		];
+		this.sessionStorageTransferHandler = (event) => {
+			if (!event.newValue) return;
+			if (event.key == "getSessionStorage") {
+				if (sessionStorage.length) {
+					this.localStorageSetItem("setSessionStorage", sessionStorage);
+					localStorage.removeItem("setSessionStorage");
+				}
+			} else if (event.key == "setSessionStorage") {
+				if (!this.syncKeys.length) this.loadSyncKeys();
+				let data = JSON.parse(event.newValue);
+				for (let key in data) if (this.syncKeysContains(key)) this.sessionStorageSetItem(key, JSON.parse(data[key]));
+				this.onInit();
+			} else if (event.key === "addToSessionStorage") {
+				let data = JSON.parse(event.newValue);
+				this.addToSessionStorageHelper(data["data"], data["key"]);
+			} else if (event.key === "removeFromSessionStorage") this.removeFromSessionStorageHelper(event.newValue);
+			else if (event.key === "clearAllSessionsStorage" && sessionStorage.length) this.clearInstanceSessionStorage();
+			else if (event.key === "addToSyncKeys") this.addToSyncKeysHelper(event.newValue);
+			else if (event.key === "removeFromSyncKeys") this.removeFromSyncKeysHelper(event.newValue);
+		};
+	}
+	static {
+		this.syncListenerInitialised = false;
+	}
+	static {
+		this.DBKEY_USER_DATA = "user_data";
+	}
+	static {
+		this.DBKEY_SYNC_KEYS = "sync_keys";
+	}
+	initialiseStorageSyncListener() {
+		if (LocalStoreManager.syncListenerInitialised == true) return;
+		LocalStoreManager.syncListenerInitialised = true;
+		window.addEventListener("storage", this.sessionStorageTransferHandler, false);
+		this.syncSessionStorage();
+	}
+	deinitialiseStorageSyncListener() {
+		window.removeEventListener("storage", this.sessionStorageTransferHandler, false);
+		LocalStoreManager.syncListenerInitialised = false;
+	}
+	syncSessionStorage() {
+		localStorage.setItem("getSessionStorage", "_dummy");
+		localStorage.removeItem("getSessionStorage");
+	}
+	clearAllStorage() {
+		this.clearAllSessionsStorage();
+		this.clearLocalStorage();
+	}
+	clearAllSessionsStorage() {
+		this.clearInstanceSessionStorage();
+		localStorage.removeItem(LocalStoreManager.DBKEY_SYNC_KEYS);
+		localStorage.setItem("clearAllSessionsStorage", "_dummy");
+		localStorage.removeItem("clearAllSessionsStorage");
+	}
+	clearInstanceSessionStorage() {
+		sessionStorage.clear();
+		this.syncKeys = [];
+	}
+	clearLocalStorage() {
+		localStorage.clear();
+	}
+	addToSessionStorage(data, key) {
+		this.addToSessionStorageHelper(data, key);
+		this.addToSyncKeysBackup(key);
+		this.localStorageSetItem("addToSessionStorage", {
+			key,
+			data
+		});
+		localStorage.removeItem("addToSessionStorage");
+	}
+	addToSessionStorageHelper(data, key) {
+		this.addToSyncKeysHelper(key);
+		this.sessionStorageSetItem(key, data);
+	}
+	removeFromSessionStorage(keyToRemove) {
+		this.removeFromSessionStorageHelper(keyToRemove);
+		this.removeFromSyncKeysBackup(keyToRemove);
+		localStorage.setItem("removeFromSessionStorage", keyToRemove);
+		localStorage.removeItem("removeFromSessionStorage");
+	}
+	removeFromSessionStorageHelper(keyToRemove) {
+		sessionStorage.removeItem(keyToRemove);
+		this.removeFromSyncKeysHelper(keyToRemove);
+	}
+	testForInvalidKeys(key) {
+		if (!key) throw new Error("key cannot be empty");
+		if (this.reservedKeys.some((x) => x === key)) throw new Error(`The storage key "${key}" is reserved and cannot be used. Please use a different key`);
+	}
+	syncKeysContains(key) {
+		return this.syncKeys.some((x) => x === key);
+	}
+	loadSyncKeys() {
+		if (this.syncKeys.length) return;
+		this.syncKeys = this.getSyncKeysFromStorage();
+	}
+	getSyncKeysFromStorage(defaultValue = []) {
+		let data = this.localStorageGetItem(LocalStoreManager.DBKEY_SYNC_KEYS);
+		if (data == null) return defaultValue;
+		else return data;
+	}
+	addToSyncKeys(key) {
+		this.addToSyncKeysHelper(key);
+		this.addToSyncKeysBackup(key);
+		localStorage.setItem("addToSyncKeys", key);
+		localStorage.removeItem("addToSyncKeys");
+	}
+	addToSyncKeysBackup(key) {
+		let storedSyncKeys = this.getSyncKeysFromStorage();
+		if (!storedSyncKeys.some((x) => x === key)) {
+			storedSyncKeys.push(key);
+			this.localStorageSetItem(LocalStoreManager.DBKEY_SYNC_KEYS, storedSyncKeys);
+		}
+	}
+	removeFromSyncKeysBackup(key) {
+		let storedSyncKeys = this.getSyncKeysFromStorage();
+		let index = storedSyncKeys.indexOf(key);
+		if (index > -1) {
+			storedSyncKeys.splice(index, 1);
+			this.localStorageSetItem(LocalStoreManager.DBKEY_SYNC_KEYS, storedSyncKeys);
+		}
+	}
+	addToSyncKeysHelper(key) {
+		if (!this.syncKeysContains(key)) this.syncKeys.push(key);
+	}
+	removeFromSyncKeys(key) {
+		this.removeFromSyncKeysHelper(key);
+		this.removeFromSyncKeysBackup(key);
+		localStorage.setItem("removeFromSyncKeys", key);
+		localStorage.removeItem("removeFromSyncKeys");
+	}
+	removeFromSyncKeysHelper(key) {
+		let index = this.syncKeys.indexOf(key);
+		if (index > -1) this.syncKeys.splice(index, 1);
+	}
+	saveSessionData(data, key = LocalStoreManager.DBKEY_USER_DATA) {
+		this.testForInvalidKeys(key);
+		this.removeFromSyncKeys(key);
+		localStorage.removeItem(key);
+		this.sessionStorageSetItem(key, data);
+	}
+	saveSyncedSessionData(data, key = LocalStoreManager.DBKEY_USER_DATA) {
+		this.testForInvalidKeys(key);
+		localStorage.removeItem(key);
+		this.addToSessionStorage(data, key);
+	}
+	savePermanentData(data, key = LocalStoreManager.DBKEY_USER_DATA) {
+		this.testForInvalidKeys(key);
+		this.removeFromSessionStorage(key);
+		this.localStorageSetItem(key, data);
+	}
+	moveDataToSessionStorage(key = LocalStoreManager.DBKEY_USER_DATA) {
+		this.testForInvalidKeys(key);
+		let data = this.getData(key);
+		if (data == null) return;
+		this.saveSessionData(data, key);
+	}
+	moveDataToSyncedSessionStorage(key = LocalStoreManager.DBKEY_USER_DATA) {
+		this.testForInvalidKeys(key);
+		let data = this.getData(key);
+		if (data == null) return;
+		this.saveSyncedSessionData(data, key);
+	}
+	moveDataToPermanentStorage(key = LocalStoreManager.DBKEY_USER_DATA) {
+		this.testForInvalidKeys(key);
+		let data = this.getData(key);
+		if (data == null) return;
+		this.savePermanentData(data, key);
+	}
+	exists(key = LocalStoreManager.DBKEY_USER_DATA) {
+		let data = sessionStorage.getItem(key);
+		if (data == null) data = localStorage.getItem(key);
+		return data != null;
+	}
+	getData(key = LocalStoreManager.DBKEY_USER_DATA) {
+		this.testForInvalidKeys(key);
+		let data = this.sessionStorageGetItem(key);
+		if (data == null) data = this.localStorageGetItem(key);
+		return data;
+	}
+	getDataObject(key = LocalStoreManager.DBKEY_USER_DATA, isDateType = false) {
+		let data = this.getData(key);
+		if (data != null) {
+			if (isDateType) data = new Date(data);
+			return data;
+		} else return null;
+	}
+	deleteData(key = LocalStoreManager.DBKEY_USER_DATA) {
+		this.testForInvalidKeys(key);
+		this.removeFromSessionStorage(key);
+		localStorage.removeItem(key);
+	}
+	localStorageSetItem(key, data) {
+		localStorage.setItem(key, JSON.stringify(data));
+	}
+	sessionStorageSetItem(key, data) {
+		sessionStorage.setItem(key, JSON.stringify(data));
+	}
+	localStorageGetItem(key) {
+		return Utilities.JSonTryParse(localStorage.getItem(key));
+	}
+	sessionStorageGetItem(key) {
+		return Utilities.JSonTryParse(sessionStorage.getItem(key));
+	}
+	onInit() {
+		setTimeout(() => {
+			this.initEvent.next({});
+			this.initEvent.complete();
+		});
+	}
+	getInitEvent() {
+		return this.initEvent.asObservable();
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: LocalStoreManager,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: LocalStoreManager
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: LocalStoreManager,
+	decorators: [{ type: Injectable }]
+});
+var HeadersService = class HeadersService {
+	constructor(localStorage) {
+		this.localStorage = localStorage;
+	}
+	authJsonHeaders() {
+		return new HttpHeaders().set("Content-Type", "application/json").set("Accept", "application/json").set("Authorization", `Bearer ${this.geJWTToken}`);
+	}
+	authFormHeaders() {
+		return new HttpHeaders().set("Content-Type", "application/x-www-form-urlencoded").set("Accept", "application/json").set("Authorization", `Bearer ${this.geJWTToken}`);
+	}
+	authFileUploadHeaders() {
+		return new HttpHeaders().set("Authorization", `Bearer ${this.geJWTToken}`);
+	}
+	jsonHeaders() {
+		return new HttpHeaders().set("Content-Type", "application/json").set("Accept", "application/json");
+	}
+	contentHeadersV2() {
+		return new HttpHeaders().set("Content-Type", "application/x-www-form-urlencoded").set("Accept", "application/json");
+	}
+	get geJWTToken() {
+		let result = this.localStorage.getDataObject(AppKeys.ACCESS_TOKEN);
+		if (Utilities.IsNil(result)) return "";
+		return result;
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: HeadersService,
+			deps: [{ token: LocalStoreManager }],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: HeadersService
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: HeadersService,
+	decorators: [{ type: Injectable }],
+	ctorParameters: () => [{ type: LocalStoreManager }]
+});
+var BusMessageService = class BusMessageService {
+	constructor() {
+		this.message$ = new Subject();
+	}
+	publish(message) {
+		const channel = message.constructor.name;
+		this.message$.next({
+			Channel: channel,
+			Data: message
+		});
+	}
+	of(messageType) {
+		const channel = messageType.name;
+		return this.message$.pipe(filter((m) => m.Channel === channel), map((m) => m.Data));
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: BusMessageService,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: BusMessageService
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: BusMessageService,
+	decorators: [{ type: Injectable }],
+	ctorParameters: () => []
+});
+var NotificationMqService = class NotificationMqService {
+	constructor() {
+		this.message$ = new Subject();
+	}
+	publish(message) {
+		const defaultchannel = message.entityType;
+		this.message$.next({
+			Channel: defaultchannel,
+			Data: message
+		});
+		if (!Utilities.IsUndefined(message.entityId)) {
+			const detailchannel = `${message.entityType}-${message.entityId}`;
+			this.message$.next({
+				Channel: detailchannel,
+				Data: message
+			});
+		}
+	}
+	of(channelKey) {
+		const channel = channelKey;
+		return this.message$.pipe(filter((m) => m.Channel === channel), map((m) => m.Data));
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: NotificationMqService,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: NotificationMqService
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: NotificationMqService,
+	decorators: [{ type: Injectable }],
+	ctorParameters: () => []
+});
+var PermissionService = class PermissionService {
+	constructor(localStorage) {
+		this.localStorage = localStorage;
+	}
+	hasPermission(permission) {
+		return this.permissions != null && this.permissions.some((p) => p === permission) || this.isAdmin;
+	}
+	get permissions() {
+		let permissions = this.localStorage.getDataObject(AppKeys.PERMISSIONS);
+		return JSON.parse(permissions);
+	}
+	get isAdmin() {
+		let parsed = JSON.parse(this.currentUser);
+		return parsed && parsed.IsAdmin || false;
+	}
+	get currentUser() {
+		return this.localStorage.getDataObject(AppKeys.CURRENT_USER);
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: PermissionService,
+			deps: [{ token: LocalStoreManager }],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: PermissionService
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: PermissionService,
+	decorators: [{ type: Injectable }],
+	ctorParameters: () => [{ type: LocalStoreManager }]
+});
+var MenuService = class MenuService {
+	constructor(permissionService) {
+		this.permissionService = permissionService;
+		this.current = new ReplaySubject(1);
+		this.hasPermission = (permKey) => {
+			if (permKey === void 0) return true;
+			return this.permissionService.hasPermission(permKey);
+		};
+		this.hasAnyPermission = (permKeys) => {
+			let result = false;
+			permKeys.forEach((p) => result = result || this.hasPermission(p));
+			return result;
+		};
+	}
+	setCurrent(menu) {
+		this.current.next(menu);
+	}
+	getCurrent() {
+		return this.current;
+	}
+	get permissionRouteMap() {
+		if (Utilities.IsNil(this._permissionRouteMap)) {
+			this._permissionRouteMap = new DictionnaryWrapper();
+			this.getAllMenuItems(true).forEach((item) => {
+				if (!Utilities.IsNil(item.sublinks)) item.sublinks.forEach((subItem) => {
+					if (subItem.permissionKey) this._permissionRouteMap.dictionary[subItem.link] = subItem.permissionKey;
+				});
+			});
+		}
+		return this._permissionRouteMap;
+	}
+	resetPermissionMap() {
+		this._permissionRouteMap = void 0;
+	}
+	hasAccessToThisRoute(url) {
+		let menuItems = this.getAccessGrantedMenuItems();
+		if (!Utilities.IsNil(menuItems) && menuItems.findIndex((f) => f.link === url) >= 0) return true;
+		if (this.permissionRouteMap.containsKeyOrPartKey(url)) return this.hasPermission(this.permissionRouteMap.getPartKey(url));
+		return true;
+	}
+	pushItem(items, menuItem, isAdmin) {
+		if (Utilities.IsNil(menuItem.permissionKey) || isAdmin || this.hasPermission(menuItem.permissionKey)) items.push(menuItem);
+	}
+	getMenuItems(isAdmin) {
+		let results = this.getAllMenuItems(isAdmin);
+		for (let i = 0; i < results.length; i++) results[i].id = i;
+		return this.sortLinks(results);
+	}
+	sortLinks(links) {
+		return links.map((t) => {
+			return {
+				...t,
+				sublinks: this.sortLinksSubLevel(t.sublinks)
+			};
+		});
+	}
+	sortLinksSubLevel(links) {
+		if (!links) return null;
+		return links.sort((a, b) => a.title.localeCompare(b.title));
+	}
+	merge(Menus) {
+		let menu = [];
+		Menus.forEach((item) => {
+			let index = menu.findIndex((x) => x.title == item.title);
+			if (index >= 0) menu[index].sublinks = [...menu[index].sublinks, ...item.sublinks];
+			else menu.push(item);
+		});
+		return menu;
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: MenuService,
+			deps: [{ token: PermissionService }],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: MenuService
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: MenuService,
+	decorators: [{ type: Injectable }],
+	ctorParameters: () => [{ type: PermissionService }]
+});
 var AuthTokenType;
-(function (AuthTokenType) {
-    AuthTokenType[AuthTokenType["AccessToken"] = 0] = "AccessToken";
-    AuthTokenType[AuthTokenType["RefreshToken"] = 1] = "RefreshToken";
+(function(AuthTokenType) {
+	AuthTokenType[AuthTokenType["AccessToken"] = 0] = "AccessToken";
+	AuthTokenType[AuthTokenType["RefreshToken"] = 1] = "RefreshToken";
 })(AuthTokenType || (AuthTokenType = {}));
-class AuthService {
-    constructor(headersService, busMsg, httpClient, router, localStorage, menuService, env) {
-        this.headersService = headersService;
-        this.busMsg = busMsg;
-        this.httpClient = httpClient;
-        this.router = router;
-        this.localStorage = localStorage;
-        this.menuService = menuService;
-        this.env = env;
-        this.baseUrl = this.env.apiUrl;
-        this.refreshTokenTimerCheckId = "is_refreshToken_timer_started";
-        this.scheduleRefreshToken(this.isLoggedIn, false);
-    }
-    // After a successful login, save token data into session storage
-    // note: use "localStorage" for persistent, browser-wide logins; "sessionStorage" for per-session storage.
-    login(username, password, rememberMe) {
-        // console.log(`login base url : ${this.baseUrl}  (environment is production : ${this.env.production})`);
-        let body = JSON.stringify({ "username": username, "password": password });
-        let _url = this.baseUrl + ServerUrl.connectPath;
-        return this.httpClient.post(_url, body, { headers: this.headersService.authJsonHeaders() }).pipe(map((resp) => {
-            // login successful if there's a jwt token in the response
-            // let user = (resp as any) as IUserCredential;
-            let user = resp;
-            if (user && user.AccessToken) {
-                // store user details and jwt token in local storage to keep user logged in between page refreshes
-                this.saveUserInfos(user, JSON.stringify(user), rememberMe);
-                // publish token
-                this.busMsg.publish(new UserUpdatedMessage(user.AccessToken));
-                // schedule refresh token
-                this.scheduleRefreshToken(true, true);
-                return user;
-            }
-        }));
-    }
-    // After a successful login, save token data into session storage
-    // note: use "localStorage" for persistent, browser-wide logins; "sessionStorage" for per-session storage.
-    register(captchaToken, firstName, lastName, email, password, rememberMe) {
-        // console.log(`login base url : ${this.baseUrl}  (environment is production : ${this.env.production})`);
-        let body = JSON.stringify({ "CaptchaToken": captchaToken, "FirstName": firstName, "LastName": lastName, "Email": email, "Password": password });
-        let _url = this.baseUrl + ServerUrl.registerPath;
-        return this.httpClient.post(_url, body, { headers: this.headersService.authJsonHeaders() }).pipe(map((resp) => {
-            // login successful if there's a jwt token in the response
-            let user = resp;
-            if (user && user.AccessToken) {
-                // store user details and jwt token in local storage to keep user logged in between page refreshes
-                this.saveUserInfos(user, JSON.stringify(user), rememberMe);
-                // publish token
-                this.busMsg.publish(new UserUpdatedMessage(user.AccessToken));
-                // schedule refresh token
-                this.scheduleRefreshToken(true, true);
-                return user;
-            }
-        }));
-    }
-    // Activation d'un utilisateur
-    activate(code) {
-        // console.log(`login base url : ${this.baseUrl}  (environment is production : ${this.env.production})`);
-        let body = JSON.stringify({ "ActivationCode": code });
-        let _url = this.baseUrl + ServerUrl.activatePath;
-        return this.httpClient.post(_url, body, { headers: this.headersService.authJsonHeaders() }).pipe(map((resp) => {
-            return resp;
-        }));
-    }
-    saveUserInfos(user, userDetails, rememberMe) {
-        // check permissions        
-        let permissions = user.Permissions || new Array();
-        // this.getPermissions(user.AccessToken) || new Array<any>();
-        if (rememberMe) {
-            this.localStorage.savePermanentData(user.AccessToken, AppKeys.ACCESS_TOKEN);
-            this.localStorage.savePermanentData(user.RefreshToken, AppKeys.REFRESH_TOKEN);
-            this.localStorage.savePermanentData(userDetails, AppKeys.CURRENT_USER);
-            this.localStorage.savePermanentData(JSON.stringify(permissions), AppKeys.PERMISSIONS);
-        }
-        else {
-            this.localStorage.saveSyncedSessionData(user.AccessToken, AppKeys.ACCESS_TOKEN);
-            this.localStorage.saveSyncedSessionData(user.RefreshToken, AppKeys.REFRESH_TOKEN);
-            this.localStorage.saveSyncedSessionData(userDetails, AppKeys.CURRENT_USER);
-            this.localStorage.saveSyncedSessionData(JSON.stringify(permissions), AppKeys.PERMISSIONS);
-        }
-        if (rememberMe) {
-            this.localStorage.savePermanentData(rememberMe, AppKeys.REMEMBER_ME);
-        }
-    }
-    getPermissions(token) {
-        let decodedToken = jwt_decode(token);
-        let permissions = new Array();
-        if (decodedToken.permissions) {
-            permissions = Array.isArray(decodedToken.permissions) ? decodedToken.permissions : [decodedToken.permissions];
-        }
-        return permissions;
-    }
-    removeUserInfos() {
-        this.localStorage.deleteData(AppKeys.ACCESS_TOKEN);
-        this.localStorage.deleteData(AppKeys.REFRESH_TOKEN);
-        this.localStorage.deleteData(AppKeys.CURRENT_USER);
-        this.loginRedirectUrl = '/';
-    }
-    // called when logging out user; clears tokens from browser
-    logout(pseudo) {
-        this.disconnect(pseudo);
-    }
-    disconnect(pseudo) {
-        const headers = new HttpHeaders({ "Content-Type": "application/json" });
-        const model = { refreshToken: this.refreshToken };
-        return this.httpClient
-            .post(`${this.baseUrl}${ServerUrl.disconnectPath}`, model, { headers: headers })
-            .pipe(map(response => response || {}), finalize(() => {
-            this.ensureLogout();
-            // navigate to home page
-            this.router.navigate(['/']);
-        })).subscribe(result => {
-            console.log("logout", result);
-        });
-    }
-    ensureLogout() {
-        this.menuService.resetPermissionMap();
-        this.busMsg.publish(new UserUpdatedMessage(null));
-        this.removeUserInfos();
-        this.unscheduleRefreshToken(true);
-    }
-    redirectLoginUser() {
-        let redirect = this.loginRedirectUrl && this.loginRedirectUrl !== '/' ? this.loginRedirectUrl : '/';
-        this.loginRedirectUrl = null;
-        let urlParamsAndFragment = Utilities.splitInTwo(redirect, '#');
-        let urlAndParams = Utilities.splitInTwo(urlParamsAndFragment.firstPart, '?');
-        let navigationExtras = {
-            fragment: urlParamsAndFragment.secondPart,
-            queryParams: Utilities.getQueryParamsFromString(urlAndParams.secondPart),
-            queryParamsHandling: "merge"
-        };
-        this.router.navigate([urlAndParams.firstPart], navigationExtras);
-    }
-    invalidateCurrentTabId() {
-        if (!this.rememberMe) {
-            return;
-        }
-        const currentTabId = this.getCurrentTabId();
-        if (this.timerStat && this.timerStat.tabId === currentTabId) {
-            this.setRefreshTokenTimerStopped();
-        }
-    }
-    scheduleRefreshToken(isAuthUserLoggedIn, calledFromLogin) {
-        this.unscheduleRefreshToken(false);
-        if (!this.isLoggedIn) {
-            return;
-        }
-        const expDateUtc = this.getAccessTokenExpirationDateUtc();
-        if (!expDateUtc) {
-            throw new Error("This access token has not the `exp` property.");
-        }
-        const expiresAtUtc = expDateUtc.valueOf();
-        const nowUtc = new Date().valueOf();
-        // 3s pour empêcher les timers des autres onglets de tourner moins de 3s
-        const initialDelay = Math.max(1, expiresAtUtc - nowUtc - 3000);
-        const timerSource$ = timer(initialDelay);
-        this.refreshTokenSubscription = timerSource$.subscribe(() => {
-            if (calledFromLogin || !this.isRefreshTokenTimerStartedInAnotherTab()) {
-                this.updateToken();
-            }
-            else {
-                this.scheduleRefreshToken(isAuthUserLoggedIn, false);
-            }
-        });
-        if (calledFromLogin || !this.isRefreshTokenTimerStartedInAnotherTab()) {
-            this.setRefreshTokenTimerStarted();
-        }
-    }
-    setRefreshTokenTimerStopped() {
-        this.localStorage.savePermanentData(JSON.stringify({
-            isStarted: false,
-            tabId: -1
-        }), this.refreshTokenTimerCheckId);
-    }
-    setRefreshTokenTimerStarted() {
-        this.localStorage.savePermanentData(JSON.stringify({
-            isStarted: true,
-            tabId: this.getCurrentTabId()
-        }), this.refreshTokenTimerCheckId);
-    }
-    deleteRefreshTokenTimerCheckId() {
-        this.localStorage.deleteData(this.refreshTokenTimerCheckId);
-    }
-    isRefreshTokenTimerStartedInAnotherTab() {
-        if (!this.rememberMe) {
-            return false; // Chaque onglet gère son token (infos stockés dans le local storage)
-        }
-        const currentTabId = this.getCurrentTabId();
-        // console.log("RefreshTokenTimer Check", {
-        //     refreshTokenTimerCheckId: this.timerStat,
-        //     currentTabId: currentTabId
-        // });
-        const isStarted = this.timerStat && this.timerStat.isStarted === true && this.timerStat.tabId !== currentTabId;
-        // if (isStarted) {
-        //     console.log(`RefreshToken timer has already been started in another tab with tabId=${this.timerStat.tabId}.
-        //   currentTabId=${currentTabId}.`);
-        // }
-        return isStarted;
-    }
-    getCurrentTabId() {
-        const tabIdToken = "currentTabId";
-        let tabId = this.localStorage.getData(tabIdToken);
-        if (tabId) {
-            return tabId;
-        }
-        tabId = Math.random();
-        this.localStorage.saveSyncedSessionData(tabId, tabIdToken);
-        return tabId;
-    }
-    getAccessTokenExpirationDateUtc() {
-        const decoded = this.getDecodedAccessToken();
-        if (decoded.exp === undefined) {
-            return null;
-        }
-        const date = new Date(0);
-        date.setUTCSeconds(decoded.exp);
-        // console.log(`Token Expires at ${date}`);
-        return date;
-    }
-    isAccessTokenTokenExpired() {
-        const expirationDateUtc = this.getAccessTokenExpirationDateUtc();
-        if (!expirationDateUtc) {
-            return true;
-        }
-        return !(expirationDateUtc.valueOf() > new Date().valueOf());
-    }
-    getDecodedAccessToken() {
-        return jwt_decode(this.token);
-    }
-    isEmptyString(value) {
-        return !value || 0 === value.length;
-    }
-    unscheduleRefreshToken(cancelTimerCheckToken) {
-        if (this.refreshTokenSubscription) {
-            this.refreshTokenSubscription.unsubscribe();
-        }
-        if (cancelTimerCheckToken) {
-            this.deleteRefreshTokenTimerCheckId();
-        }
-    }
-    updateToken() {
-        console.log(`Entering updateToken()`);
-        const headers = new HttpHeaders({ "Content-Type": "application/json" });
-        const model = { refreshToken: this.refreshToken };
-        return this.httpClient
-            .post(`${this.baseUrl}${ServerUrl.refreshPath}`, model, { headers: headers })
-            .pipe(map(response => response || {}), catchError((error) => throwError(() => new Error(error.error))))
-            .subscribe(resp => {
-            // login successful if there's a jwt token in the response
-            let user = resp;
-            if (user && user.AccessToken) {
-                // store user details and jwt token in local storage to keep user logged in between page refreshes
-                this.saveUserInfos(user, JSON.stringify(user), this.rememberMe);
-                // publish token
-                this.busMsg.publish(new UserUpdatedMessage(user.AccessToken));
-                this.scheduleRefreshToken(this.isLoggedIn, false);
-                return user;
-            }
-        });
-    }
-    hasPermission(permission) {
-        return this.permissions != null && this.permissions.some(p => p === permission) || this.isAdmin;
-    }
-    //#region Fields
-    get timerStat() {
-        const timerStat_key = this.localStorage.getDataObject(this.refreshTokenTimerCheckId);
-        const timerStat = JSON.parse(timerStat_key);
-        return timerStat;
-    }
-    get isLoggedIn() {
-        const accessToken = this.token;
-        const refreshToken = this.refreshToken;
-        const hasTokens = !this.isEmptyString(accessToken) && !this.isEmptyString(refreshToken);
-        return hasTokens && !this.isAccessTokenTokenExpired();
-    }
-    get isAdmin() {
-        let parsed = JSON.parse(this.currentUser);
-        if (Utilities.IsNil(parsed))
-            return false;
-        return parsed.IsAdmin || false;
-    }
-    get pseudo() {
-        let parsed = JSON.parse(this.currentUser);
-        return parsed.Username || '';
-    }
-    get userId() {
-        let parsed = JSON.parse(this.currentUser);
-        return parsed.Id || 0;
-    }
-    get currentUser() {
-        return this.localStorage.getDataObject(AppKeys.CURRENT_USER);
-    }
-    get rememberMe() {
-        return this.localStorage.getDataObject(AppKeys.REMEMBER_ME) === true;
-    }
-    get token() {
-        return this.localStorage.getDataObject(AppKeys.ACCESS_TOKEN);
-    }
-    get refreshToken() {
-        return this.localStorage.getDataObject(AppKeys.REFRESH_TOKEN);
-    }
-    get permissions() {
-        let permissions = this.localStorage.getDataObject(AppKeys.PERMISSIONS);
-        let parsed_permissions = JSON.parse(permissions);
-        return parsed_permissions;
-    }
-    get companyId() {
-        const decoded = this.getDecodedAccessToken();
-        if (Utilities.IsNil(decoded[AppKeys.USER_COMPANY_ID])) {
-            return null;
-        }
-        return decoded[AppKeys.USER_COMPANY_ID];
-    }
-    get referenceSupplierId() {
-        const decoded = this.getDecodedAccessToken();
-        if (Utilities.IsNil(decoded[AppKeys.REFERENCE_SUPPLIER_ID])) {
-            return null;
-        }
-        return decoded[AppKeys.REFERENCE_SUPPLIER_ID];
-    }
-    //#endregion 
-    navigateToHome() {
-        this.router.navigate(['/']);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: AuthService, deps: [{ token: HeadersService }, { token: BusMessageService }, { token: i3.HttpClient }, { token: i1.Router }, { token: LocalStoreManager }, { token: MenuService }, { token: i7.EnvironmentBase }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: AuthService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: AuthService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: HeadersService }, { type: BusMessageService }, { type: i3.HttpClient }, { type: i1.Router }, { type: LocalStoreManager }, { type: MenuService }, { type: i7.EnvironmentBase }] });
-
-class AuthGuard {
-    constructor(authService, menuService, router) {
-        this.authService = authService;
-        this.menuService = menuService;
-        this.router = router;
-    }
-    canActivate(route, state) {
-        let url = state.url;
-        return this.checkLogin(url);
-    }
-    canActivateChild(route, state) {
-        return this.canActivate(route, state);
-    }
-    canLoad(route) {
-        let url = `/${route.path}`;
-        return this.checkLogin(url);
-    }
-    checkLogin(url) {
-        if (this.authService.isLoggedIn) {
-            if (url === '/accessDenied' || this.authService.isAdmin) {
-                return true;
-            }
-            return this.hasAuthUserAccessToThisRoute(url);
-        }
-        this.menuService.resetPermissionMap();
-        this.authService.loginRedirectUrl = url;
-        this.router.navigate(['/login']);
-        return false;
-    }
-    hasAuthUserAccessToThisRoute(returnUrl) {
-        if (!this.menuService.hasAccessToThisRoute(Utilities.splitInTwo(returnUrl, '?').firstPart)) {
-            this.showAccessDenied(returnUrl);
-            return false;
-        }
-        return true;
-    }
-    showAccessDenied(returnUrl) {
-        this.router.navigate(['/accessDenied']);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: AuthGuard, deps: [{ token: AuthService }, { token: MenuService }, { token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: AuthGuard }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: AuthGuard, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: AuthService }, { type: MenuService }, { type: i1.Router }] });
-
-class BreadcrumbService {
-    constructor(title) {
-        this.title = title;
-        this.initialData = {
-            description: '',
-            display: false,
-            header: '',
-            levels: [
-                {
-                    icon: 'clock-o',
-                    link: ['/'],
-                    title: 'Default'
-                }
-            ]
-        };
-        this.current = new ReplaySubject(1);
-        this.clear();
-    }
-    setCurrent(data) {
-        if (data.description !== undefined && data.description !== '') {
-            this.title.setTitle('DFlat - ' + data.levels[data.levels.length - 1].title);
-        }
-        else
-            this.title.setTitle('DFlat');
-        this.current.next(data);
-    }
-    getCurrent() {
-        return this.current;
-    }
-    clear() {
-        this.setCurrent(this.initialData);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: BreadcrumbService, deps: [{ token: i1$1.Title }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: BreadcrumbService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: BreadcrumbService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1$1.Title }] });
-
-class FilterService {
-    get DisplayFilter() { return this.displayFilter; }
-    get Keywords() { return this.keywords; }
-    set Keywords(value) { this.keywords = value; }
-    constructor() {
-        this.displayFilterChangedSubject = new BehaviorSubject(false);
-        this.filterChanged$ = this.displayFilterChangedSubject.asObservable();
-        this.displayFilter = true;
-        this.keywords = '';
-    }
-    setFilterDisplay(value) {
-        if (this.displayFilter != value) {
-            this.displayFilter = value;
-            // Déclenchement de l'évènement de changement d'affichage du filtre
-            this.displayFilterChangedSubject.next(this.displayFilter);
-        }
-    }
-    toggleFilterDisplay() {
-        this.displayFilter = !this.displayFilter;
-        // Déclenchement de l'évènement de changement d'affichage du filtre
-        this.displayFilterChangedSubject.next(this.displayFilter);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: FilterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: FilterService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: FilterService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [] });
-
-class GeolocationService {
-    constructor(localStore) {
-        this.localStore = localStore;
-        this.positionsHistory = new Array(0);
-        this.positionChanged = new EventEmitter();
-        try {
-            let saveLocations = localStore.getDataObject(AppKeys.LAST_GEOLOCATIONS, false);
-            if (!Utilities.IsNil(saveLocations))
-                this.positionsHistory = saveLocations;
-        }
-        catch { }
-    }
-    getCurrentPosition() {
-        // Retourne la dernière valeur de l'historique
-        if (!Utilities.IsNil(this.positionsHistory) && this.positionsHistory.length > 0)
-            return this.positionsHistory[0];
-    }
-    setCurrentPosition(formattedName, placeId, latitude, longitude) {
-        // Création d'un objet de type NamedPosition
-        let currentPosition = {
-            placeId: placeId,
-            formattedName: formattedName,
-            latitude: latitude,
-            longitude: longitude
-        };
-        // Insertion de la dernière position dans l'historique (on ne garde que les 5 dernières positions)
-        this.positionsHistory.unshift(currentPosition);
-        if (this.positionsHistory.length > 5)
-            this.positionsHistory.pop();
-        // Sauvegarde dans le localStorage
-        this.localStore.savePermanentData(this.positionsHistory, AppKeys.LAST_GEOLOCATIONS);
-        // Déclenchement de l'évènement de changemetn de position courante.
-        this.positionChanged.emit(currentPosition);
-    }
-    /**
-     * Calcule la distance en mètres entre la position courante et le point dont les coordonnées GPS sont spécifiées en paramètre.
-     * @param latitude Latitude du point
-     * @param longitude Longitude du point
-     * @returns La distance en mètres entre la position courante et le point dont les coordonnées GPS sont spécifiées en paramètre.
-     */
-    getDistanceToCurrent(latitude, longitude) {
-        // Distance entre les coordonnées spécifiées et la position courante.
-        let position = this.getCurrentPosition();
-        if (Utilities.IsNil(position))
-            return undefined;
-        return this.getDistance(position.latitude, position.longitude, latitude, longitude);
-    }
-    /** Calcule la distance en mètres entre 2 points en coordonnées GPS.
-     * @param latitude1 Latitude du point 1
-     * @param longitude1 Longitude du point 1
-     * @param latitude2 Latitude du point 2
-     * @param longitude2 Longitude du point 2
-     * @returns Une estimation la distance en mètres entre les point GPS 1 et 2 dont les coordonnées sont spécifiées.
-     */
-    getDistance(latitude1, longitude1, latitude2, longitude2) {
-        // Connaissant la position de deux points A et B sur une sphère, calculer la distance entre eux
-        // revient à calculer l'abscisse curviligne S (AB) sur le grand cercle passant par A et B.
-        // Si l’on considère deux points A et B sur la sphère, de latitudes ϕA et ϕB et de longitudes λA et λB, 
-        // alors la distance angulaire en radians SA-B entre A et B est donnée par la relation fondamentale de trigonométrie
-        // sphérique, utilisant dλ = λB – λA :
-        //                      SA-B = arc cos (sin ϕA sin ϕB + cos ϕA cos ϕB cos dλ)
-        // La distance S en mètres, s’obtient en multipliant SA-B par un rayon de la Terre conventionnel (6 378 137 mètres par exemple).
-        // Conversion en radian
-        let a = latitude1 * Math.PI / 180;
-        let b = longitude1 * Math.PI / 180;
-        let c = latitude2 * Math.PI / 180;
-        let d = longitude2 * Math.PI / 180;
-        // Calcul de la distance en m
-        let e = Math.sin(a) * Math.sin(c) + Math.cos(a) * Math.cos(c) * Math.cos(d - b);
-        let result = 6378137 * Math.acos(e);
-        return result;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: GeolocationService, deps: [{ token: LocalStoreManager }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: GeolocationService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: GeolocationService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: LocalStoreManager }] });
-
-class NotificationsService {
-    // public markThreadAsRead: Subject<any> = new Subject<any>();
-    constructor() {
-        this.notificationsList = [];
-        // a stream that publishes new notifications only once
-        this.newNotifications = new Subject();
-        // `notifications` is a stream that emits an array of the most up to date notifications
-        this.notifications = new ReplaySubject(1);
-        // `updates` receives _operations_ to be applied to our `notifications`
-        // it's a way we can perform changes on *all* notifications (that are currently
-        // stored in `notifications`)
-        this.updates = new Subject();
-        // action streams
-        this.create = new Subject();
-        // recois des operation, et les fais sur la liste interne, puis diffuse le resultat sur notifications
-        this.updates.subscribe((ope) => {
-            this.notificationsList = ope(this.notificationsList);
-            this.notifications.next(this.notificationsList);
-        });
-        this.newNotifications.pipe(map(function (notification) {
-            return (notifications) => {
-                return notifications.concat(notification);
-            };
-        }))
-            .subscribe(this.updates);
-    }
-    // an imperative function call to this action stream
-    addNotification(notification) {
-        this.newNotifications.next(notification);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: NotificationsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: NotificationsService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: NotificationsService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [] });
-
+var AuthService = class AuthService {
+	constructor(headersService, busMsg, httpClient, router, localStorage, menuService, env) {
+		this.headersService = headersService;
+		this.busMsg = busMsg;
+		this.httpClient = httpClient;
+		this.router = router;
+		this.localStorage = localStorage;
+		this.menuService = menuService;
+		this.env = env;
+		this.baseUrl = this.env.apiUrl;
+		this.refreshTokenTimerCheckId = "is_refreshToken_timer_started";
+		this.scheduleRefreshToken(this.isLoggedIn, false);
+	}
+	login(username, password, rememberMe) {
+		let body = JSON.stringify({
+			"username": username,
+			"password": password
+		});
+		let _url = this.baseUrl + ServerUrl.connectPath;
+		return this.httpClient.post(_url, body, { headers: this.headersService.authJsonHeaders() }).pipe(map((resp) => {
+			let user = resp;
+			if (user && user.AccessToken) {
+				this.saveUserInfos(user, JSON.stringify(user), rememberMe);
+				this.busMsg.publish(new UserUpdatedMessage(user.AccessToken));
+				this.scheduleRefreshToken(true, true);
+				return user;
+			}
+		}));
+	}
+	register(captchaToken, firstName, lastName, email, password, rememberMe) {
+		let body = JSON.stringify({
+			"CaptchaToken": captchaToken,
+			"FirstName": firstName,
+			"LastName": lastName,
+			"Email": email,
+			"Password": password
+		});
+		let _url = this.baseUrl + ServerUrl.registerPath;
+		return this.httpClient.post(_url, body, { headers: this.headersService.authJsonHeaders() }).pipe(map((resp) => {
+			let user = resp;
+			if (user && user.AccessToken) {
+				this.saveUserInfos(user, JSON.stringify(user), rememberMe);
+				this.busMsg.publish(new UserUpdatedMessage(user.AccessToken));
+				this.scheduleRefreshToken(true, true);
+				return user;
+			}
+		}));
+	}
+	activate(code) {
+		let body = JSON.stringify({ "ActivationCode": code });
+		let _url = this.baseUrl + ServerUrl.activatePath;
+		return this.httpClient.post(_url, body, { headers: this.headersService.authJsonHeaders() }).pipe(map((resp) => {
+			return resp;
+		}));
+	}
+	saveUserInfos(user, userDetails, rememberMe) {
+		let permissions = user.Permissions || new Array();
+		if (rememberMe) {
+			this.localStorage.savePermanentData(user.AccessToken, AppKeys.ACCESS_TOKEN);
+			this.localStorage.savePermanentData(user.RefreshToken, AppKeys.REFRESH_TOKEN);
+			this.localStorage.savePermanentData(userDetails, AppKeys.CURRENT_USER);
+			this.localStorage.savePermanentData(JSON.stringify(permissions), AppKeys.PERMISSIONS);
+		} else {
+			this.localStorage.saveSyncedSessionData(user.AccessToken, AppKeys.ACCESS_TOKEN);
+			this.localStorage.saveSyncedSessionData(user.RefreshToken, AppKeys.REFRESH_TOKEN);
+			this.localStorage.saveSyncedSessionData(userDetails, AppKeys.CURRENT_USER);
+			this.localStorage.saveSyncedSessionData(JSON.stringify(permissions), AppKeys.PERMISSIONS);
+		}
+		if (rememberMe) this.localStorage.savePermanentData(rememberMe, AppKeys.REMEMBER_ME);
+	}
+	getPermissions(token) {
+		let decodedToken = jwt_decode(token);
+		let permissions = new Array();
+		if (decodedToken.permissions) permissions = Array.isArray(decodedToken.permissions) ? decodedToken.permissions : [decodedToken.permissions];
+		return permissions;
+	}
+	removeUserInfos() {
+		this.localStorage.deleteData(AppKeys.ACCESS_TOKEN);
+		this.localStorage.deleteData(AppKeys.REFRESH_TOKEN);
+		this.localStorage.deleteData(AppKeys.CURRENT_USER);
+		this.loginRedirectUrl = "/";
+	}
+	logout(pseudo) {
+		this.disconnect(pseudo);
+	}
+	disconnect(pseudo) {
+		const headers = new HttpHeaders({ "Content-Type": "application/json" });
+		const model = { refreshToken: this.refreshToken };
+		return this.httpClient.post(`${this.baseUrl}${ServerUrl.disconnectPath}`, model, { headers }).pipe(map((response) => response || {}), finalize(() => {
+			this.ensureLogout();
+			this.router.navigate(["/"]);
+		})).subscribe((result) => {
+			console.log("logout", result);
+		});
+	}
+	ensureLogout() {
+		this.menuService.resetPermissionMap();
+		this.busMsg.publish(new UserUpdatedMessage(null));
+		this.removeUserInfos();
+		this.unscheduleRefreshToken(true);
+	}
+	redirectLoginUser() {
+		let redirect = this.loginRedirectUrl && this.loginRedirectUrl !== "/" ? this.loginRedirectUrl : "/";
+		this.loginRedirectUrl = null;
+		let urlParamsAndFragment = Utilities.splitInTwo(redirect, "#");
+		let urlAndParams = Utilities.splitInTwo(urlParamsAndFragment.firstPart, "?");
+		let navigationExtras = {
+			fragment: urlParamsAndFragment.secondPart,
+			queryParams: Utilities.getQueryParamsFromString(urlAndParams.secondPart),
+			queryParamsHandling: "merge"
+		};
+		this.router.navigate([urlAndParams.firstPart], navigationExtras);
+	}
+	invalidateCurrentTabId() {
+		if (!this.rememberMe) return;
+		const currentTabId = this.getCurrentTabId();
+		if (this.timerStat && this.timerStat.tabId === currentTabId) this.setRefreshTokenTimerStopped();
+	}
+	scheduleRefreshToken(isAuthUserLoggedIn, calledFromLogin) {
+		this.unscheduleRefreshToken(false);
+		if (!this.isLoggedIn) return;
+		const expDateUtc = this.getAccessTokenExpirationDateUtc();
+		if (!expDateUtc) throw new Error("This access token has not the `exp` property.");
+		const expiresAtUtc = expDateUtc.valueOf();
+		const nowUtc = (/* @__PURE__ */ new Date()).valueOf();
+		const initialDelay = Math.max(1, expiresAtUtc - nowUtc - 3e3);
+		const timerSource$ = timer(initialDelay);
+		this.refreshTokenSubscription = timerSource$.subscribe(() => {
+			if (calledFromLogin || !this.isRefreshTokenTimerStartedInAnotherTab()) this.updateToken();
+			else this.scheduleRefreshToken(isAuthUserLoggedIn, false);
+		});
+		if (calledFromLogin || !this.isRefreshTokenTimerStartedInAnotherTab()) this.setRefreshTokenTimerStarted();
+	}
+	setRefreshTokenTimerStopped() {
+		this.localStorage.savePermanentData(JSON.stringify({
+			isStarted: false,
+			tabId: -1
+		}), this.refreshTokenTimerCheckId);
+	}
+	setRefreshTokenTimerStarted() {
+		this.localStorage.savePermanentData(JSON.stringify({
+			isStarted: true,
+			tabId: this.getCurrentTabId()
+		}), this.refreshTokenTimerCheckId);
+	}
+	deleteRefreshTokenTimerCheckId() {
+		this.localStorage.deleteData(this.refreshTokenTimerCheckId);
+	}
+	isRefreshTokenTimerStartedInAnotherTab() {
+		if (!this.rememberMe) return false;
+		const currentTabId = this.getCurrentTabId();
+		return this.timerStat && this.timerStat.isStarted === true && this.timerStat.tabId !== currentTabId;
+	}
+	getCurrentTabId() {
+		const tabIdToken = "currentTabId";
+		let tabId = this.localStorage.getData(tabIdToken);
+		if (tabId) return tabId;
+		tabId = Math.random();
+		this.localStorage.saveSyncedSessionData(tabId, tabIdToken);
+		return tabId;
+	}
+	getAccessTokenExpirationDateUtc() {
+		const decoded = this.getDecodedAccessToken();
+		if (decoded.exp === void 0) return null;
+		const date = /* @__PURE__ */ new Date(0);
+		date.setUTCSeconds(decoded.exp);
+		return date;
+	}
+	isAccessTokenTokenExpired() {
+		const expirationDateUtc = this.getAccessTokenExpirationDateUtc();
+		if (!expirationDateUtc) return true;
+		return !(expirationDateUtc.valueOf() > (/* @__PURE__ */ new Date()).valueOf());
+	}
+	getDecodedAccessToken() {
+		return jwt_decode(this.token);
+	}
+	isEmptyString(value) {
+		return !value || 0 === value.length;
+	}
+	unscheduleRefreshToken(cancelTimerCheckToken) {
+		if (this.refreshTokenSubscription) this.refreshTokenSubscription.unsubscribe();
+		if (cancelTimerCheckToken) this.deleteRefreshTokenTimerCheckId();
+	}
+	updateToken() {
+		console.log(`Entering updateToken()`);
+		const headers = new HttpHeaders({ "Content-Type": "application/json" });
+		const model = { refreshToken: this.refreshToken };
+		return this.httpClient.post(`${this.baseUrl}${ServerUrl.refreshPath}`, model, { headers }).pipe(map((response) => response || {}), catchError((error) => throwError(() => new Error(error.error)))).subscribe((resp) => {
+			let user = resp;
+			if (user && user.AccessToken) {
+				this.saveUserInfos(user, JSON.stringify(user), this.rememberMe);
+				this.busMsg.publish(new UserUpdatedMessage(user.AccessToken));
+				this.scheduleRefreshToken(this.isLoggedIn, false);
+				return user;
+			}
+		});
+	}
+	hasPermission(permission) {
+		return this.permissions != null && this.permissions.some((p) => p === permission) || this.isAdmin;
+	}
+	get timerStat() {
+		const timerStat_key = this.localStorage.getDataObject(this.refreshTokenTimerCheckId);
+		return JSON.parse(timerStat_key);
+	}
+	get isLoggedIn() {
+		const accessToken = this.token;
+		const refreshToken = this.refreshToken;
+		return !this.isEmptyString(accessToken) && !this.isEmptyString(refreshToken) && !this.isAccessTokenTokenExpired();
+	}
+	get isAdmin() {
+		let parsed = JSON.parse(this.currentUser);
+		if (Utilities.IsNil(parsed)) return false;
+		return parsed.IsAdmin || false;
+	}
+	get pseudo() {
+		return JSON.parse(this.currentUser).Username || "";
+	}
+	get userId() {
+		return JSON.parse(this.currentUser).Id || 0;
+	}
+	get currentUser() {
+		return this.localStorage.getDataObject(AppKeys.CURRENT_USER);
+	}
+	get rememberMe() {
+		return this.localStorage.getDataObject(AppKeys.REMEMBER_ME) === true;
+	}
+	get token() {
+		return this.localStorage.getDataObject(AppKeys.ACCESS_TOKEN);
+	}
+	get refreshToken() {
+		return this.localStorage.getDataObject(AppKeys.REFRESH_TOKEN);
+	}
+	get permissions() {
+		let permissions = this.localStorage.getDataObject(AppKeys.PERMISSIONS);
+		return JSON.parse(permissions);
+	}
+	get companyId() {
+		const decoded = this.getDecodedAccessToken();
+		if (Utilities.IsNil(decoded[AppKeys.USER_COMPANY_ID])) return null;
+		return decoded[AppKeys.USER_COMPANY_ID];
+	}
+	get referenceSupplierId() {
+		const decoded = this.getDecodedAccessToken();
+		if (Utilities.IsNil(decoded[AppKeys.REFERENCE_SUPPLIER_ID])) return null;
+		return decoded[AppKeys.REFERENCE_SUPPLIER_ID];
+	}
+	navigateToHome() {
+		this.router.navigate(["/"]);
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: AuthService,
+			deps: [
+				{ token: HeadersService },
+				{ token: BusMessageService },
+				{ token: i3.HttpClient },
+				{ token: i4.Router },
+				{ token: LocalStoreManager },
+				{ token: MenuService },
+				{ token: i7.EnvironmentBase }
+			],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: AuthService
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: AuthService,
+	decorators: [{ type: Injectable }],
+	ctorParameters: () => [
+		{ type: HeadersService },
+		{ type: BusMessageService },
+		{ type: i3.HttpClient },
+		{ type: i4.Router },
+		{ type: LocalStoreManager },
+		{ type: MenuService },
+		{ type: i7.EnvironmentBase }
+	]
+});
+var AuthGuard = class AuthGuard {
+	constructor(authService, menuService, router) {
+		this.authService = authService;
+		this.menuService = menuService;
+		this.router = router;
+	}
+	canActivate(route, state) {
+		let url = state.url;
+		return this.checkLogin(url);
+	}
+	canActivateChild(route, state) {
+		return this.canActivate(route, state);
+	}
+	canLoad(route) {
+		let url = `/${route.path}`;
+		return this.checkLogin(url);
+	}
+	checkLogin(url) {
+		if (this.authService.isLoggedIn) {
+			if (url === "/accessDenied" || this.authService.isAdmin) return true;
+			return this.hasAuthUserAccessToThisRoute(url);
+		}
+		this.menuService.resetPermissionMap();
+		this.authService.loginRedirectUrl = url;
+		this.router.navigate(["/login"]);
+		return false;
+	}
+	hasAuthUserAccessToThisRoute(returnUrl) {
+		if (!this.menuService.hasAccessToThisRoute(Utilities.splitInTwo(returnUrl, "?").firstPart)) {
+			this.showAccessDenied(returnUrl);
+			return false;
+		}
+		return true;
+	}
+	showAccessDenied(returnUrl) {
+		this.router.navigate(["/accessDenied"]);
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: AuthGuard,
+			deps: [
+				{ token: AuthService },
+				{ token: MenuService },
+				{ token: i4.Router }
+			],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: AuthGuard
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: AuthGuard,
+	decorators: [{ type: Injectable }],
+	ctorParameters: () => [
+		{ type: AuthService },
+		{ type: MenuService },
+		{ type: i4.Router }
+	]
+});
+var BreadcrumbService = class BreadcrumbService {
+	constructor(title) {
+		this.title = title;
+		this.initialData = {
+			description: "",
+			display: false,
+			header: "",
+			levels: [{
+				icon: "clock-o",
+				link: ["/"],
+				title: "Default"
+			}]
+		};
+		this.current = new ReplaySubject(1);
+		this.clear();
+	}
+	setCurrent(data) {
+		if (data.description !== void 0 && data.description !== "") this.title.setTitle("DFlat - " + data.levels[data.levels.length - 1].title);
+		else this.title.setTitle("DFlat");
+		this.current.next(data);
+	}
+	getCurrent() {
+		return this.current;
+	}
+	clear() {
+		this.setCurrent(this.initialData);
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: BreadcrumbService,
+			deps: [{ token: i1.Title }],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: BreadcrumbService
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: BreadcrumbService,
+	decorators: [{ type: Injectable }],
+	ctorParameters: () => [{ type: i1.Title }]
+});
+var FilterService = class FilterService {
+	get DisplayFilter() {
+		return this.displayFilter;
+	}
+	get Keywords() {
+		return this.keywords;
+	}
+	set Keywords(value) {
+		this.keywords = value;
+	}
+	constructor() {
+		this.displayFilterChangedSubject = new BehaviorSubject(false);
+		this.filterChanged$ = this.displayFilterChangedSubject.asObservable();
+		this.displayFilter = true;
+		this.keywords = "";
+	}
+	setFilterDisplay(value) {
+		if (this.displayFilter != value) {
+			this.displayFilter = value;
+			this.displayFilterChangedSubject.next(this.displayFilter);
+		}
+	}
+	toggleFilterDisplay() {
+		this.displayFilter = !this.displayFilter;
+		this.displayFilterChangedSubject.next(this.displayFilter);
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: FilterService,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: FilterService
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: FilterService,
+	decorators: [{ type: Injectable }],
+	ctorParameters: () => []
+});
+var GeolocationService = class GeolocationService {
+	constructor(localStore) {
+		this.localStore = localStore;
+		this.positionsHistory = new Array(0);
+		this.positionChanged = new EventEmitter();
+		try {
+			let saveLocations = localStore.getDataObject(AppKeys.LAST_GEOLOCATIONS, false);
+			if (!Utilities.IsNil(saveLocations)) this.positionsHistory = saveLocations;
+		} catch {}
+	}
+	getCurrentPosition() {
+		if (!Utilities.IsNil(this.positionsHistory) && this.positionsHistory.length > 0) return this.positionsHistory[0];
+	}
+	setCurrentPosition(formattedName, placeId, latitude, longitude) {
+		let currentPosition = {
+			placeId,
+			formattedName,
+			latitude,
+			longitude
+		};
+		this.positionsHistory.unshift(currentPosition);
+		if (this.positionsHistory.length > 5) this.positionsHistory.pop();
+		this.localStore.savePermanentData(this.positionsHistory, AppKeys.LAST_GEOLOCATIONS);
+		this.positionChanged.emit(currentPosition);
+	}
+	getDistanceToCurrent(latitude, longitude) {
+		let position = this.getCurrentPosition();
+		if (Utilities.IsNil(position)) return void 0;
+		return this.getDistance(position.latitude, position.longitude, latitude, longitude);
+	}
+	getDistance(latitude1, longitude1, latitude2, longitude2) {
+		let a = latitude1 * Math.PI / 180;
+		let b = longitude1 * Math.PI / 180;
+		let c = latitude2 * Math.PI / 180;
+		let d = longitude2 * Math.PI / 180;
+		let e = Math.sin(a) * Math.sin(c) + Math.cos(a) * Math.cos(c) * Math.cos(d - b);
+		return 6378137 * Math.acos(e);
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: GeolocationService,
+			deps: [{ token: LocalStoreManager }],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: GeolocationService
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: GeolocationService,
+	decorators: [{ type: Injectable }],
+	ctorParameters: () => [{ type: LocalStoreManager }]
+});
+var NotificationsService = class NotificationsService {
+	constructor() {
+		this.notificationsList = [];
+		this.newNotifications = new Subject();
+		this.notifications = new ReplaySubject(1);
+		this.updates = new Subject();
+		this.create = new Subject();
+		this.updates.subscribe((ope) => {
+			this.notificationsList = ope(this.notificationsList);
+			this.notifications.next(this.notificationsList);
+		});
+		this.newNotifications.pipe(map(function(notification) {
+			return (notifications) => {
+				return notifications.concat(notification);
+			};
+		})).subscribe(this.updates);
+	}
+	addNotification(notification) {
+		this.newNotifications.next(notification);
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: NotificationsService,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: NotificationsService
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: NotificationsService,
+	decorators: [{ type: Injectable }],
+	ctorParameters: () => []
+});
 var RequestState;
-(function (RequestState) {
-    RequestState[RequestState["Pending"] = 0] = "Pending";
-    RequestState[RequestState["InProgress"] = 1] = "InProgress";
-    RequestState[RequestState["Success"] = 2] = "Success";
-    RequestState[RequestState["Error"] = 3] = "Error";
-    RequestState[RequestState["Warning"] = 4] = "Warning";
+(function(RequestState) {
+	RequestState[RequestState["Pending"] = 0] = "Pending";
+	RequestState[RequestState["InProgress"] = 1] = "InProgress";
+	RequestState[RequestState["Success"] = 2] = "Success";
+	RequestState[RequestState["Error"] = 3] = "Error";
+	RequestState[RequestState["Warning"] = 4] = "Warning";
 })(RequestState || (RequestState = {}));
-/*
-    signalR Hub Service.
-    Currently chimera class, both registering to a the dflatHub and registering handlers.
-    TODO Extract handlers elsewhere.
-*/
-class HubService {
-    get hubOptions() {
-        let _self = this;
-        var options = {
-            skipNegotiation: true,
-            transport: signalR.HttpTransportType.WebSockets,
-            accessTokenFactory: () => {
-                const token = _self.localStorage.getDataObject(AppKeys.ACCESS_TOKEN);
-                return token;
-            }
-        };
-        return options;
-    }
-    constructor(localStorage, notificationService, busMsg, mqMsg, authService, env) {
-        this.localStorage = localStorage;
-        this.notificationService = notificationService;
-        this.busMsg = busMsg;
-        this.mqMsg = mqMsg;
-        this.authService = authService;
-        this.env = env;
-        this.hubUrl = this.env.hubUrl;
-        this.hubConnection = null;
-        this.isConnected = false;
-        this.isReconnect = false;
-        this.busMsg.of(UserUpdatedMessage).subscribe(msg => {
-            // log out
-            if (msg.userKey === null) {
-                this.disposeConnection();
-            }
-            else {
-                this.startHub();
-            }
-        });
-    }
-    //TODO REFACTO
-    init() {
-        if (!this.isInit) {
-            this.startHub();
-            this.isInit = true;
-        }
-    }
-    disposeConnection() {
-        if (this.hubConnection) {
-            this.hubConnection.stop();
-        }
-    }
-    startHub() {
-        // Si la connnexion est déjà active ou qu'un utilisateur n'est pas connecté on ne fait rien.
-        if (this.isConnected || !this.authService.isLoggedIn || this.isConnecting)
-            return;
-        this.isConnecting = true;
-        var options = this.hubOptions;
-        ;
-        this.hubConnection = new signalR.HubConnectionBuilder()
-            .withUrl(this.hubUrl, options)
-            .configureLogging(signalR.LogLevel.Trace)
-            .build();
-        this.hubConnection.serverTimeoutInMilliseconds = 30000;
-        this.configure();
-        this.hubConnection
-            .start()
-            .then(() => {
-            console.log('*****Connection started!');
-            this.isConnected = true;
-            this.isConnecting = false;
-            clearInterval(this.timer$);
-        })
-            .catch(err => {
-            console.log('Error while establishing connection :(', err);
-            this.isConnected = false;
-            this.isConnecting = false;
-            clearInterval(this.timer$);
-            this.scheduleStartingHub();
-        });
-    }
-    configure() {
-        // subscribe to operation log from server
-        this.hubConnection.on('OperationLog', (uid, message) => {
-            this.publishEvents(new Notification({ id: undefined, content: message, class: undefined, entityType: uid, entityId: undefined }));
-        });
-        // subscribe to broadcasted messagse from server
-        this.hubConnection.on('BroadcastMessage', (name, message) => {
-            // console.log(`BroadcastMessage received : ${message}, ${name}`);
-        });
-        //Subscriptions have to be prior the connection start so the server hub knows which 'events' this client is eligible for.
-        this.hubConnection.on("ReportProgress", (name, message, state, entityType, entityId) => {
-            // console.log(`ReportProgress: name: ${name} | message: ${message} | state: ${state} | entityType: ${entityType} | entityId: ${entityId}  `);
-            //let end = state === RequestState.Success || state === RequestState.Error || state === RequestState.Warning ;
-            let classNotif = "info";
-            //if (end) {
-            const notif = new Notification({ id: name, content: message, class: classNotif, entityType: entityType, entityId: entityId });
-            this.publishEvents(notif);
-            //}
-        });
-        //Registers a handler that will be invoked when the connection is closed.
-        this.hubConnection.onclose(e => {
-            console.log(`Hub connection closed !`);
-            this.isConnected = false;
-            this.scheduleStartingHub();
-        });
-    }
-    scheduleStartingHub() {
-        // chaque 30s
-        this.timer$ = setInterval(() => {
-            console.log("retry start hub");
-            this.startHub();
-        }, 30000);
-    }
-    publishEvents(notif) {
-        this.mqMsg.publish(notif);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: HubService, deps: [{ token: LocalStoreManager }, { token: NotificationsService }, { token: BusMessageService }, { token: NotificationMqService }, { token: AuthService }, { token: i7.EnvironmentBase }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: HubService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: HubService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: LocalStoreManager }, { type: NotificationsService }, { type: BusMessageService }, { type: NotificationMqService }, { type: AuthService }, { type: i7.EnvironmentBase }] });
-
-class MessagesService {
-    // public markThreadAsRead: Subject<any> = new Subject<any>();
-    constructor() {
-        this.messagesList = [];
-        // a stream that publishes new messages only once
-        this.newMessages = new Subject();
-        // `messages` is a stream that emits an array of the most up to date messages
-        this.messages = new ReplaySubject(1);
-        // `updates` receives _operations_ to be applied to our `messages`
-        // it's a way we can perform changes on *all* messages (that are currently
-        // stored in `messages`)
-        this.updates = new Subject();
-        // action streams
-        this.create = new Subject();
-        // recois des operation, et les fais sur la liste interne, puis diffuse le resultat sur messages
-        this.updates.subscribe((ope) => {
-            this.messagesList = ope(this.messagesList);
-            this.messages.next(this.messagesList);
-        });
-        this.newMessages.pipe(map(function (message) {
-            return (messages) => {
-                return messages.concat(message);
-            };
-        }))
-            .subscribe(this.updates);
-    }
-    // an imperative function call to this action stream
-    addMessage(message) {
-        this.newMessages.next(message);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: MessagesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: MessagesService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: MessagesService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [] });
-
-class ScreenService {
-    constructor() {
-        this.screenChanged = new EventEmitter();
-        this.scrollChanged = new EventEmitter();
-    }
-    getScreenConfiguration() {
-        return this.config;
-    }
-    setScreenConfiguration(value) {
-        // Si la valeur passée est vide, on ne fait rien.
-        if (Utilities.IsNil(value))
-            return;
-        // Sinon, on vérifie qu'une des valeurs de configuration a changé
-        if (Utilities.IsNil(this.config)
-            || this.config.isExtraSmallScreen != value.isExtraSmallScreen
-            || this.config.isSmallScreen != value.isSmallScreen
-            || this.config.isLargeScreen != value.isLargeScreen) {
-            this.config = value;
-            // Déclenchement de l'évènement de changemetn de position courante.
-            this.screenChanged.emit(this.config);
-        }
-    }
-    scroll(elt) {
-        // Déclenchement de l'évènement de scrolling
-        this.scrollChanged.emit(elt);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: ScreenService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: ScreenService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: ScreenService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [] });
-
-class UserService {
-    constructor(router, authService) {
-        this.router = router;
-        this.authService = authService;
-        this.userChanged = new EventEmitter();
-        this.current = new ReplaySubject(1);
-        this.editUser = new ReplaySubject(1);
-    }
-    setCurrent(user) {
-        this.current.next(user);
-        this.userChanged.emit(user);
-    }
-    getCurrent() {
-        return this.current;
-    }
-    openEditUser() {
-        this.editUser.next(1);
-    }
-    getEditUser() {
-        return this.editUser;
-    }
-    get AuthenticatedUser() {
-        let user = this.authService.currentUser;
-        let parsed = JSON.parse(user);
-        let login = parsed;
-        if (Utilities.IsNil(login))
-            return undefined;
-        return new User(login);
-    }
-    logout() {
-        const user = new User({});
-        user.IsConnected = false;
-        this.setCurrent(user);
-        this.authService.logout(this.authService.pseudo);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: UserService, deps: [{ token: i1.Router }, { token: AuthService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: UserService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: UserService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1.Router }, { type: AuthService }] });
-
-// IMPORTANT : DANS LE BUT DE FACILITER LES MERGE ET LA LECTURE DU CODE.
-// 1. TOUJOURS CONSERVER LE TRI SUR LES IMPORTS
-// UTILISER L'EXTENSION "TypeScript Import Sorter" DANS VSCODE.
-// CONFIGURER L'EXTENSION POUR ACTIVER LA MISE EN FORME AUTOMATIQUE A LA SAUVEGARDE 
-// 2. UTILISER CTRL-SHIFT O POUR SUPPRIMER AUTOMATIQUEMENT LES IMPORTS INUTILES
-// 3. TRIER LES COMPOSANTS OU DEPENDANCES DANS  LES DECLARATIONS (IMPORTS, EXPORTS)
-// SELECTION DU TEXTE PUIS CTRL-SHIFT P, "Sort Lines Ascending"
-// ON PEUT PARAMETRER DES RACCOURCIS CLAVIER DANS VSCODE
-// Ensure that CoreServicesModule is only loaded into AppModule
-class CoreServicesModule extends EnsureModuleLoadedOnceGuard {
-    // Looks for the module in the parent injector to see if it's already been loaded (only want it loaded once)
-    constructor(parentModule) {
-        super(parentModule);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: CoreServicesModule, deps: [{ token: CoreServicesModule, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.4", ngImport: i0, type: CoreServicesModule, imports: [CommonModule, CoreModelModule] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: CoreServicesModule, providers: [
-            LocalStoreManager,
-            GeolocationService,
-            MessagesService,
-            NotificationsService,
-            PermissionService,
-            UserService,
-            AuthGuard,
-            AuthService,
-            HeadersService,
-            BusMessageService,
-            BreadcrumbService,
-            ScreenService,
-            AppConfiguration,
-            HubService,
-            NotificationMqService,
-            FilterService,
-            provideHttpClient(withInterceptorsFromDi())
-        ], imports: [CommonModule, CoreModelModule] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: CoreServicesModule, decorators: [{
-            type: NgModule,
-            args: [{ exports: [],
-                    declarations: [], imports: [CommonModule, CoreModelModule], providers: [
-                        LocalStoreManager,
-                        GeolocationService,
-                        MessagesService,
-                        NotificationsService,
-                        PermissionService,
-                        UserService,
-                        AuthGuard,
-                        AuthService,
-                        HeadersService,
-                        BusMessageService,
-                        BreadcrumbService,
-                        ScreenService,
-                        AppConfiguration,
-                        HubService,
-                        NotificationMqService,
-                        FilterService,
-                        provideHttpClient(withInterceptorsFromDi())
-                    ] }]
-        }], ctorParameters: () => [{ type: CoreServicesModule, decorators: [{
-                    type: Optional
-                }, {
-                    type: SkipSelf
-                }] }] });
-
-class AuthInterceptor {
-    constructor(router, injector) {
-        this.router = router;
-        this.injector = injector;
-    }
-    intercept(req, next) {
-        const headersService = this.injector.get(HeadersService);
-        const authService = this.injector.get(AuthService);
-        switch (req.method) {
-            case "GET":
-                req = req.clone({ headers: headersService.authFormHeaders(), withCredentials: true });
-                break;
-            case "POST":
-                // let isFileUpload = req.url.match(/Upload|File/)
-                // let headers;
-                // if (isFileUpload) {
-                //     headers = headersService.authFileUploadHeaders();
-                // }
-                // else {
-                //     headers = headersService.authJsonHeaders();
-                //}
-                if (req.headers['lazyUpdate'] == null) {
-                    req = req.clone({ headers: headersService.authJsonHeaders(), withCredentials: true });
-                }
-                break;
-            default:
-                req = req;
-                break;
-        }
-        const r = req;
-        return next.handle(req).pipe(catchError(err => {
-            console.log(err);
-            if (err instanceof HttpErrorResponse) {
-                // Ignore signalr failure
-                if (r.url.includes("/hub/")) {
-                    return empty();
-                }
-                if (err.status === 401 || err.status === 403) {
-                    // Ignore   login failed
-                    if (!(r.url.endsWith("/api/Account/Connect"))) {
-                        authService.ensureLogout();
-                        this.router.navigate(['/login']);
-                        return empty();
-                    }
-                }
-                else if (err.status === 400) {
-                    let apiError = {};
-                    apiError.ApiErrorType = ApiErrorTypes.UserError;
-                    apiError.Message = err.error;
-                    this.onError(err, apiError);
-                }
-                else {
-                    try {
-                        if (err.error instanceof Blob) {
-                            err.error.text().then((str => {
-                                let apiError = JSON.parse(str);
-                                this.onError(err, apiError);
-                            }));
-                        }
-                        else {
-                            let apiError = err.error;
-                            this.onError(err, apiError);
-                        }
-                        // if (typeof err.error === "string") {
-                        // }
-                        // else {
-                        //     let reader = new FileReader();
-                        //     reader.addEventListener("loadend",
-                        //         () => {
-                        //             let result = reader.result as string;
-                        //             result = trimChar(result, "\"");
-                        //             this.onError(err, result);
-                        //         });
-                        //     reader.readAsText(err.error);
-                        // }
-                    }
-                    catch (error) {
-                        let apiError = {};
-                        apiError.ApiErrorType = ApiErrorTypes.UserError;
-                        apiError.Message = "Une erreur a été détectée. Merci de contacter le service technique !";
-                        this.onError(err, apiError);
-                    }
-                }
-            }
-            return throwError(err);
-        }));
-    }
-    onError(errResponse, error) {
-        console.log(error.Message);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: AuthInterceptor, deps: [{ token: i1.Router }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: AuthInterceptor }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: AuthInterceptor, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1.Router }, { type: i0.Injector }] });
-
-class CanActivateGuard {
-    constructor(router, userService) {
-        this.router = router;
-        this.userService = userService;
-        this.connected = false;
-        this.userService.getCurrent().subscribe((user) => {
-            this.connected = user.IsConnected;
-        });
-    }
-    canActivate() {
-        if (!this.connected) {
-            this.router.navigate(['login']);
-        }
-        return this.connected;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: CanActivateGuard, deps: [{ token: i1.Router }, { token: UserService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: CanActivateGuard }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: CanActivateGuard, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1.Router }, { type: UserService }] });
-
+var HubService = class HubService {
+	get hubOptions() {
+		let _self = this;
+		return {
+			skipNegotiation: true,
+			transport: signalR.HttpTransportType.WebSockets,
+			accessTokenFactory: () => {
+				return _self.localStorage.getDataObject(AppKeys.ACCESS_TOKEN);
+			}
+		};
+	}
+	constructor(localStorage, notificationService, busMsg, mqMsg, authService, env) {
+		this.localStorage = localStorage;
+		this.notificationService = notificationService;
+		this.busMsg = busMsg;
+		this.mqMsg = mqMsg;
+		this.authService = authService;
+		this.env = env;
+		this.hubUrl = this.env.hubUrl;
+		this.hubConnection = null;
+		this.isConnected = false;
+		this.isReconnect = false;
+		this.busMsg.of(UserUpdatedMessage).subscribe((msg) => {
+			if (msg.userKey === null) this.disposeConnection();
+			else this.startHub();
+		});
+	}
+	init() {
+		if (!this.isInit) {
+			this.startHub();
+			this.isInit = true;
+		}
+	}
+	disposeConnection() {
+		if (this.hubConnection) this.hubConnection.stop();
+	}
+	startHub() {
+		if (this.isConnected || !this.authService.isLoggedIn || this.isConnecting) return;
+		this.isConnecting = true;
+		var options = this.hubOptions;
+		this.hubConnection = new signalR.HubConnectionBuilder().withUrl(this.hubUrl, options).configureLogging(signalR.LogLevel.Trace).build();
+		this.hubConnection.serverTimeoutInMilliseconds = 3e4;
+		this.configure();
+		this.hubConnection.start().then(() => {
+			console.log("*****Connection started!");
+			this.isConnected = true;
+			this.isConnecting = false;
+			clearInterval(this.timer$);
+		}).catch((err) => {
+			console.log("Error while establishing connection :(", err);
+			this.isConnected = false;
+			this.isConnecting = false;
+			clearInterval(this.timer$);
+			this.scheduleStartingHub();
+		});
+	}
+	configure() {
+		this.hubConnection.on("OperationLog", (uid, message) => {
+			this.publishEvents(new Notification({
+				id: void 0,
+				content: message,
+				class: void 0,
+				entityType: uid,
+				entityId: void 0
+			}));
+		});
+		this.hubConnection.on("BroadcastMessage", (name, message) => {});
+		this.hubConnection.on("ReportProgress", (name, message, state, entityType, entityId) => {
+			const notif = new Notification({
+				id: name,
+				content: message,
+				class: "info",
+				entityType,
+				entityId
+			});
+			this.publishEvents(notif);
+		});
+		this.hubConnection.onclose((e) => {
+			console.log(`Hub connection closed !`);
+			this.isConnected = false;
+			this.scheduleStartingHub();
+		});
+	}
+	scheduleStartingHub() {
+		this.timer$ = setInterval(() => {
+			console.log("retry start hub");
+			this.startHub();
+		}, 3e4);
+	}
+	publishEvents(notif) {
+		this.mqMsg.publish(notif);
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: HubService,
+			deps: [
+				{ token: LocalStoreManager },
+				{ token: NotificationsService },
+				{ token: BusMessageService },
+				{ token: NotificationMqService },
+				{ token: AuthService },
+				{ token: i7.EnvironmentBase }
+			],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: HubService
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: HubService,
+	decorators: [{ type: Injectable }],
+	ctorParameters: () => [
+		{ type: LocalStoreManager },
+		{ type: NotificationsService },
+		{ type: BusMessageService },
+		{ type: NotificationMqService },
+		{ type: AuthService },
+		{ type: i7.EnvironmentBase }
+	]
+});
+var MessagesService = class MessagesService {
+	constructor() {
+		this.messagesList = [];
+		this.newMessages = new Subject();
+		this.messages = new ReplaySubject(1);
+		this.updates = new Subject();
+		this.create = new Subject();
+		this.updates.subscribe((ope) => {
+			this.messagesList = ope(this.messagesList);
+			this.messages.next(this.messagesList);
+		});
+		this.newMessages.pipe(map(function(message) {
+			return (messages) => {
+				return messages.concat(message);
+			};
+		})).subscribe(this.updates);
+	}
+	addMessage(message) {
+		this.newMessages.next(message);
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: MessagesService,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: MessagesService
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: MessagesService,
+	decorators: [{ type: Injectable }],
+	ctorParameters: () => []
+});
+var ScreenService = class ScreenService {
+	constructor() {
+		this.screenChanged = new EventEmitter();
+		this.scrollChanged = new EventEmitter();
+	}
+	getScreenConfiguration() {
+		return this.config;
+	}
+	setScreenConfiguration(value) {
+		if (Utilities.IsNil(value)) return;
+		if (Utilities.IsNil(this.config) || this.config.isExtraSmallScreen != value.isExtraSmallScreen || this.config.isSmallScreen != value.isSmallScreen || this.config.isLargeScreen != value.isLargeScreen) {
+			this.config = value;
+			this.screenChanged.emit(this.config);
+		}
+	}
+	scroll(elt) {
+		this.scrollChanged.emit(elt);
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: ScreenService,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: ScreenService
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: ScreenService,
+	decorators: [{ type: Injectable }],
+	ctorParameters: () => []
+});
+var UserService = class UserService {
+	constructor(router, authService) {
+		this.router = router;
+		this.authService = authService;
+		this.userChanged = new EventEmitter();
+		this.current = new ReplaySubject(1);
+		this.editUser = new ReplaySubject(1);
+	}
+	setCurrent(user) {
+		this.current.next(user);
+		this.userChanged.emit(user);
+	}
+	getCurrent() {
+		return this.current;
+	}
+	openEditUser() {
+		this.editUser.next(1);
+	}
+	getEditUser() {
+		return this.editUser;
+	}
+	get AuthenticatedUser() {
+		let user = this.authService.currentUser;
+		let login = JSON.parse(user);
+		if (Utilities.IsNil(login)) return void 0;
+		return new User(login);
+	}
+	logout() {
+		const user = new User({});
+		user.IsConnected = false;
+		this.setCurrent(user);
+		this.authService.logout(this.authService.pseudo);
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: UserService,
+			deps: [{ token: i4.Router }, { token: AuthService }],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: UserService
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: UserService,
+	decorators: [{ type: Injectable }],
+	ctorParameters: () => [{ type: i4.Router }, { type: AuthService }]
+});
+var CoreServicesModule = class CoreServicesModule extends EnsureModuleLoadedOnceGuard {
+	constructor(parentModule) {
+		super(parentModule);
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: CoreServicesModule,
+			deps: [{
+				token: CoreServicesModule,
+				optional: true,
+				skipSelf: true
+			}],
+			target: i0.ɵɵFactoryTarget.NgModule
+		});
+	}
+	static {
+		this.ɵmod = i0.ɵɵngDeclareNgModule({
+			minVersion: "14.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: CoreServicesModule,
+			imports: [CommonModule, CoreModelModule]
+		});
+	}
+	static {
+		this.ɵinj = i0.ɵɵngDeclareInjector({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: CoreServicesModule,
+			providers: [
+				LocalStoreManager,
+				GeolocationService,
+				MessagesService,
+				NotificationsService,
+				PermissionService,
+				UserService,
+				AuthGuard,
+				AuthService,
+				HeadersService,
+				BusMessageService,
+				BreadcrumbService,
+				ScreenService,
+				AppConfiguration,
+				HubService,
+				NotificationMqService,
+				FilterService,
+				provideHttpClient(withXhr(), withInterceptorsFromDi())
+			],
+			imports: [CommonModule, CoreModelModule]
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: CoreServicesModule,
+	decorators: [{
+		type: NgModule,
+		args: [{
+			exports: [],
+			declarations: [],
+			imports: [CommonModule, CoreModelModule],
+			providers: [
+				LocalStoreManager,
+				GeolocationService,
+				MessagesService,
+				NotificationsService,
+				PermissionService,
+				UserService,
+				AuthGuard,
+				AuthService,
+				HeadersService,
+				BusMessageService,
+				BreadcrumbService,
+				ScreenService,
+				AppConfiguration,
+				HubService,
+				NotificationMqService,
+				FilterService,
+				provideHttpClient(withXhr(), withInterceptorsFromDi())
+			]
+		}]
+	}],
+	ctorParameters: () => [{
+		type: CoreServicesModule,
+		decorators: [{ type: Optional }, { type: SkipSelf }]
+	}]
+});
+var AuthInterceptor = class AuthInterceptor {
+	constructor(router, injector) {
+		this.router = router;
+		this.injector = injector;
+	}
+	intercept(req, next) {
+		const headersService = this.injector.get(HeadersService);
+		const authService = this.injector.get(AuthService);
+		switch (req.method) {
+			case "GET":
+				req = req.clone({
+					headers: headersService.authFormHeaders(),
+					withCredentials: true
+				});
+				break;
+			case "POST":
+				if (req.headers["lazyUpdate"] == null) req = req.clone({
+					headers: headersService.authJsonHeaders(),
+					withCredentials: true
+				});
+				break;
+			default: req = req;
+		}
+		const r = req;
+		return next.handle(req).pipe(catchError((err) => {
+			console.log(err);
+			if (err instanceof HttpErrorResponse) {
+				if (r.url.includes("/hub/")) return empty();
+				if (err.status === 401 || err.status === 403) {
+					if (!r.url.endsWith("/api/Account/Connect")) {
+						authService.ensureLogout();
+						this.router.navigate(["/login"]);
+						return empty();
+					}
+				} else if (err.status === 400) {
+					let apiError = {};
+					apiError.ApiErrorType = ApiErrorTypes.UserError;
+					apiError.Message = err.error;
+					this.onError(err, apiError);
+				} else try {
+					if (err.error instanceof Blob) err.error.text().then(((str) => {
+						let apiError = JSON.parse(str);
+						this.onError(err, apiError);
+					}));
+					else {
+						let apiError = err.error;
+						this.onError(err, apiError);
+					}
+				} catch (error) {
+					let apiError = {};
+					apiError.ApiErrorType = ApiErrorTypes.UserError;
+					apiError.Message = "Une erreur a été détectée. Merci de contacter le service technique !";
+					this.onError(err, apiError);
+				}
+			}
+			return throwError(err);
+		}));
+	}
+	onError(errResponse, error) {
+		console.log(error.Message);
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: AuthInterceptor,
+			deps: [{ token: i4.Router }, { token: i0.Injector }],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: AuthInterceptor
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: AuthInterceptor,
+	decorators: [{ type: Injectable }],
+	ctorParameters: () => [{ type: i4.Router }, { type: i0.Injector }]
+});
+var CanActivateGuard = class CanActivateGuard {
+	constructor(router, userService) {
+		this.router = router;
+		this.userService = userService;
+		this.connected = false;
+		this.userService.getCurrent().subscribe((user) => {
+			this.connected = user.IsConnected;
+		});
+	}
+	canActivate() {
+		if (!this.connected) this.router.navigate(["login"]);
+		return this.connected;
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: CanActivateGuard,
+			deps: [{ token: i4.Router }, { token: UserService }],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: CanActivateGuard
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: CanActivateGuard,
+	decorators: [{ type: Injectable }],
+	ctorParameters: () => [{ type: i4.Router }, { type: UserService }]
+});
 function trimChar(str, c) {
-    // Escape special char when needed
-    c = c === "]"
-        ? "\\]"
-        : c === "\\"
-            ? "\\\\"
-            : c;
-    return str.replace(new RegExp(`^[${c}]+|[${c}]+$`, "g"), "");
+	c = c === "]" ? "\\]" : c === "\\" ? "\\\\" : c;
+	return str.replace(new RegExp(`^[${c}]+|[${c}]+$`, "g"), "");
 }
-
-/**
- * Menus des modules de l'application : chaque module racine ([module]-root) y déclare le sien,
- * `{ provide: MODULE_MENU_SERVICES, useExisting: <Module>MenuService, multi: true }`.
- * ApplicationMenuService les réunit en un seul menu.
- */
-const MODULE_MENU_SERVICES = new InjectionToken('MODULE_MENU_SERVICES');
-
-class MenuItem {
-    constructor(title, link, icon, sublinks, permissionKey) {
-        this.external = false;
-        this.target = '';
-        this.title = title;
-        this.link = link;
-        this.icon = icon;
-        this.sublinks = sublinks;
-        this.permissionKey = permissionKey;
-    }
-}
-
-/**
- * Menu de l'application : réunion des menus de tous ses modules (déclarés sous
- * MODULE_MENU_SERVICES), dans l'ordre de déclaration. Les thèmes de même libellé sont fusionnés
- * et leurs éléments réunis sans doublon (même lien). Chaque module filtre ses éléments selon les
- * permissions de l'utilisateur connecté.
- *
- * Fourni sous MenuService par DflatAppModule.
- */
-class ApplicationMenuService extends MenuService {
-    constructor(permissionService, moduleMenus) {
-        super(permissionService);
-        this.moduleMenus = moduleMenus;
-    }
-    getAllMenuItems(isAdmin) {
-        // Copies : merge complète les éléments de son premier thème de chaque libellé.
-        const themes = (this.moduleMenus ?? [])
-            .reduce((all, menu) => all.concat(menu.getAllMenuItems(isAdmin)), new Array())
-            .map(theme => new MenuItem(theme.title, theme.link, theme.icon, [...(theme.sublinks ?? [])], theme.permissionKey));
-        return this.merge(themes)
-            .map(theme => new MenuItem(theme.title, theme.link, theme.icon, this.distinctItems(theme.sublinks), theme.permissionKey));
-    }
-    getAccessGrantedMenuItems() {
-        return (this.moduleMenus ?? [])
-            .reduce((all, menu) => all.concat(menu.getAccessGrantedMenuItems() ?? []), new Array());
-    }
-    /** Éléments sans doublon : le premier élément de chaque lien est gardé. */
-    distinctItems(items) {
-        const links = new Set();
-        return (items ?? []).filter(item => {
-            if (item.link !== undefined && links.has(item.link))
-                return false;
-            links.add(item.link);
-            return true;
-        });
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: ApplicationMenuService, deps: [{ token: PermissionService }, { token: MODULE_MENU_SERVICES, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: ApplicationMenuService }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.4", ngImport: i0, type: ApplicationMenuService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: PermissionService }, { type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [MODULE_MENU_SERVICES]
-                }] }] });
-
-/**
- * Generated bundle index. Do not edit.
- */
-
+const MODULE_MENU_SERVICES = new InjectionToken("MODULE_MENU_SERVICES");
+var MenuItem = class {
+	constructor(title, link, icon, sublinks, permissionKey) {
+		this.external = false;
+		this.target = "";
+		this.title = title;
+		this.link = link;
+		this.icon = icon;
+		this.sublinks = sublinks;
+		this.permissionKey = permissionKey;
+	}
+};
+var ApplicationMenuService = class ApplicationMenuService extends MenuService {
+	constructor(permissionService, moduleMenus) {
+		super(permissionService);
+		this.moduleMenus = moduleMenus;
+	}
+	getAllMenuItems(isAdmin) {
+		const themes = (this.moduleMenus ?? []).reduce((all, menu) => all.concat(menu.getAllMenuItems(isAdmin)), new Array()).map((theme) => new MenuItem(theme.title, theme.link, theme.icon, [...theme.sublinks ?? []], theme.permissionKey));
+		return this.merge(themes).map((theme) => new MenuItem(theme.title, theme.link, theme.icon, this.distinctItems(theme.sublinks), theme.permissionKey));
+	}
+	getAccessGrantedMenuItems() {
+		return (this.moduleMenus ?? []).reduce((all, menu) => all.concat(menu.getAccessGrantedMenuItems() ?? []), new Array());
+	}
+	distinctItems(items) {
+		const links = /* @__PURE__ */ new Set();
+		return (items ?? []).filter((item) => {
+			if (item.link !== void 0 && links.has(item.link)) return false;
+			links.add(item.link);
+			return true;
+		});
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: ApplicationMenuService,
+			deps: [{ token: PermissionService }, {
+				token: MODULE_MENU_SERVICES,
+				optional: true
+			}],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: ApplicationMenuService
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: ApplicationMenuService,
+	decorators: [{ type: Injectable }],
+	ctorParameters: () => [{ type: PermissionService }, {
+		type: void 0,
+		decorators: [{ type: Optional }, {
+			type: Inject,
+			args: [MODULE_MENU_SERVICES]
+		}]
+	}]
+});
 export { AppConfiguration, AppKeys, ApplicationMenuService, AuthGuard, AuthInterceptor, AuthService, AuthTokenType, BreadcrumbService, BusMessageService, CanActivateGuard, CoreServicesModule, FilterService, GeolocationService, HeadersService, HubService, LocalStoreManager, MODULE_MENU_SERVICES, MenuItem, MenuService, MessagesService, NotificationMqService, NotificationsService, PermissionService, ScreenService, ServerUrl, UserService, trimChar };
-//# sourceMappingURL=dflat-core-web-core-services.mjs.map
+
+//# sourceMappingURL=dflat-core-web-core-services.mjs.map