@dflat-core/web 1.0.0-beta

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

@@ -0,0 +1,1568 @@
+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 } 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 }] });
+
+var AuthTokenType;
+(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('Marsow - ' + data.levels[data.levels.length - 1].title);
+        }
+        else
+            this.title.setTitle('Marsow');
+        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 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";
+})(RequestState || (RequestState = {}));
+/*
+    signalR Hub Service.
+    Currently chimera class, both registering to a the marsowHub 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 }] });
+
+function trimChar(str, c) {
+    // Escape special char when needed
+    c = c === "]"
+        ? "\\]"
+        : c === "\\"
+            ? "\\\\"
+            : c;
+    return str.replace(new RegExp(`^[${c}]+|[${c}]+$`, "g"), "");
+}
+
+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;
+    }
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AppConfiguration, AppKeys, AuthGuard, AuthInterceptor, AuthService, AuthTokenType, BreadcrumbService, BusMessageService, CanActivateGuard, CoreServicesModule, FilterService, GeolocationService, HeadersService, HubService, LocalStoreManager, MenuItem, MenuService, MessagesService, NotificationMqService, NotificationsService, PermissionService, ScreenService, ServerUrl, UserService, trimChar };
+//# sourceMappingURL=dflat-core-web-core-services.mjs.map