@geogirafe/lib-geoportal 1.2.0-dev.2872463389 → 1.2.0-dev.2889263072

package/tools/userdata/userdatamanager.js

@@ -10,110 +10,146 @@ import { createObjectFromPath, deletePropertyByPath, getPropertyByPath, setPrope
 class UserDataManager extends GirafeSingleton {
     // Using the full URL as storage key allows having separate user data for apps under the same base URL (e.g. demo apps)
     storageKey = window.location.origin + window.location.pathname;
-    source;
-    WARNING_UNKNOWN_SOURCE = 'User data source isn’t set';
-    WARNING_NOT_IMPLEMENTED = 'Server-side functionality is not implemented yet';
-    setSource(source) {
-        if (source === 'localStorage' || source === 'server') {
-            this.source = source;
-        }
-        else {
-            console.warn(`User data source "${source}" not known`);
-        }
+    config;
+    allowSaveUserPreferences = true;
+    initializeFromConfig(config) {
+        this.config = config;
     }
+    userData;
+    userDataPromise;
     /**
      * Retrieves a specific part of the user data defined by the storage path.
      * @param storagePath path in the user data object to the requested value.
-     * @param forceLocalStorage if true, reads user data from the local storage, ignoring the source.
      * @returns the partial user data object.
      */
-    getUserData(storagePath, forceLocalStorage = false) {
-        const fullUserDataObject = this.load(forceLocalStorage);
-        const { found, parentObject, lastKey } = getPropertyByPath(fullUserDataObject, storagePath);
+    async getUserData(storagePath) {
+        if (this.userData) {
+            // User Data were already loaded
+            return this.extractValue(this.userData, storagePath);
+        }
+        this.userDataPromise = this.load().catch((error) => {
+            this.userDataPromise = undefined;
+            throw error;
+        });
+        this.userData = await this.userDataPromise;
+        return this.extractValue(this.userData, storagePath);
+    }
+    getFromLocalStorage(storagePath) {
+        const storedUserData = localStorage.getItem(this.storageKey);
+        const userData = storedUserData ? JSON.parse(storedUserData) : {};
+        return this.extractValue(userData, storagePath);
+    }
+    extractValue(data, storagePath) {
+        const { found, parentObject, lastKey } = getPropertyByPath(data, storagePath);
         return found && parentObject && lastKey ? parentObject[lastKey] : undefined;
     }
-    /**
-     * Saves user data to a specific path in the storage.
-     * @param storagePath path in the user data object where the value is saved to.
-     * @param newValue user data value to save.
-     * @param forceLocalStorage if true, saves user data to the local storage, ignoring the source.
-     */
-    saveUserData(storagePath, newValue, forceLocalStorage = false) {
-        let fullUserDataObject = this.load(forceLocalStorage);
+    async load() {
+        if (this.config.source === 'localStorage') {
+            return this.loadFromLocalStorage();
+        }
+        else if (this.config.source === 'server') {
+            const userdata = await this.loadFromServer();
+            return userdata;
+        }
+        throw new Error(`Unknown source for user preferences: ${this.config.source}`);
+    }
+    loadFromLocalStorage() {
+        const storedUserData = localStorage.getItem(this.storageKey);
+        return storedUserData ? JSON.parse(storedUserData) : {};
+    }
+    async loadFromServer() {
+        try {
+            const response = await fetch(this.config.getUrl);
+            const storedUserData = await response.json();
+            return storedUserData;
+        }
+        catch {
+            // Cannot load user preference from server.
+            // In this case, we deactivate the save process for user preferences
+            // (because we do not want to override the existing user-preferences if they could not be loaded for some reason)
+            // And we return empty preferences, because we want to be able to start the application
+            // even if the user preferences could not be retrieved.
+            this.allowSaveUserPreferences = false;
+            this.context.errorManager.pushMessage('loadUserPreferencesError', 'User Preferences could not be loaded. Try refreshing the page or contact your administrator.', 'error');
+            return {};
+        }
+    }
+    async saveUserData(storagePath, newValue) {
+        if (!getPropertyByPath(this.userData, storagePath).found) {
+            // Object does not exist in user data yet, create it
+            const newUserData = createObjectFromPath(storagePath);
+            this.userData = mergeObjects(this.userData ?? {}, newUserData);
+        }
+        if (setPropertyByPath(this.userData, storagePath, newValue)) {
+            await this.save(this.userData ?? {});
+        }
+    }
+    saveToLocalStorage(storagePath, newValue) {
+        let fullUserDataObject = this.loadFromLocalStorage();
         if (!getPropertyByPath(fullUserDataObject, storagePath).found) {
             // Object does not exist in user data yet, create it
             const newUserData = createObjectFromPath(storagePath);
             fullUserDataObject = mergeObjects(fullUserDataObject, newUserData);
         }
         if (setPropertyByPath(fullUserDataObject, storagePath, newValue)) {
-            this.save(fullUserDataObject, forceLocalStorage);
+            this.writeToLocalStorage(fullUserDataObject);
         }
     }
-    /**
-     * Delete a specific part of the user data defined by the storage path.
-     * @param storagePath path in the user data object that will be deleted.
-     * @param forceLocalStorage if true, deletes user data in the local storage, ignoring the source.
-     */
-    deleteUserData(storagePath, forceLocalStorage = false) {
-        const currentUserData = this.load(forceLocalStorage);
-        deletePropertyByPath(currentUserData, storagePath);
-        this.save(currentUserData, forceLocalStorage);
-    }
-    /**
-     * Deletes all user data in storage.
-     * @param forceLocalStorage Force deletion from local storage regardless of the currently set data source.
-     */
-    deleteAllUserData(forceLocalStorage = false) {
-        if (this.isInLocalStorage(forceLocalStorage)) {
-            localStorage.removeItem(this.storageKey);
+    async save(fullUserDataObject) {
+        if (this.config.source === 'localStorage') {
+            this.writeToLocalStorage(fullUserDataObject);
         }
-        else if (this.source === 'server') {
-            console.warn(this.WARNING_NOT_IMPLEMENTED);
+        else if (this.config.source === 'server') {
+            await this.writeToServer(fullUserDataObject);
         }
         else {
-            console.warn(this.WARNING_UNKNOWN_SOURCE);
+            throw new Error(`Unknown source for user preferences: ${this.config.source}`);
         }
     }
-    /**
-     * Helper: Load data from the user data storage.
-     * @param forceLocalStorage forces loading data from local storage, independent of the specified source.
-     * @returns the full user data object in the storage.
-     */
-    load(forceLocalStorage) {
-        if (this.isInLocalStorage(forceLocalStorage)) {
-            const storedUserData = localStorage.getItem(this.storageKey);
-            return storedUserData ? JSON.parse(storedUserData) : {};
+    writeToLocalStorage(fullUserDataObject) {
+        localStorage.setItem(this.storageKey, JSON.stringify(fullUserDataObject));
+    }
+    async writeToServer(fullUserDataObject) {
+        if (!this.allowSaveUserPreferences) {
+            return;
         }
-        else if (this.source === 'server') {
-            console.warn(this.WARNING_NOT_IMPLEMENTED);
+        const response = await fetch(this.config.postUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(fullUserDataObject)
+        });
+        if (!response.ok) {
+            console.error(response.text);
+            throw new Error(`Error while saving user preferences: ${response.status}`);
         }
-        else {
-            console.warn(this.WARNING_UNKNOWN_SOURCE);
-        }
-        return {};
     }
-    /**
-     * Helper: Save user data to storage.
-     * @param fullUserDataObject full user data object that is saved.
-     * @param forceLocalStorage forces saving data to local storage, independent of the specified source.
-     * @private
-     */
-    save(fullUserDataObject, forceLocalStorage) {
-        if (this.isInLocalStorage(forceLocalStorage)) {
-            localStorage.setItem(this.storageKey, JSON.stringify(fullUserDataObject));
+    async deleteUserData(storagePath) {
+        deletePropertyByPath(this.userData, storagePath);
+        await this.save(this.userData);
+    }
+    async deleteAllUserData() {
+        this.userData = undefined;
+        if (this.config.source === 'localStorage') {
+            localStorage.removeItem(this.storageKey);
         }
-        else if (this.source === 'server') {
-            console.warn(this.WARNING_NOT_IMPLEMENTED);
+        else if (this.config.source === 'server') {
+            await this.deleteFromServer();
         }
         else {
-            console.warn(this.WARNING_UNKNOWN_SOURCE);
+            throw new Error(`Unknown source for user preferences: ${this.config.source}`);
         }
     }
-    /**
-     * Helper: Determines if a particular operation should use the local browser storage.
-     */
-    isInLocalStorage(forceLocalStorage) {
-        return this.source === 'localStorage' || forceLocalStorage;
+    async deleteFromServer() {
+        if (!this.allowSaveUserPreferences) {
+            return;
+        }
+        const response = await fetch(this.config.postUrl, {
+            method: 'DELETE'
+        });
+        if (!response.ok) {
+            console.error(response.text);
+            throw new Error(`Error while deleting user preferences: ${response.status}`);
+        }
     }
 }
 export default UserDataManager;

package/tools/wfs/wfsmanager.d.ts

@@ -8,7 +8,7 @@ export default class WfsManager extends VendorSpecificOgcServerManager<WfsClient
     private get state();
     getClientId(ogcServer: ServerOgc): string;
     static readonly UnknownFeatureType: string;
-    initializeSingleton(): void;
+    initializeSingleton(): Promise<void>;
     private onSelectedFeaturesFilterChange;
     /**
      * Determines whether the specified layer is the first active child layer of a time-aware group layer,

package/tools/wfs/wfsmanager.js

@@ -10,7 +10,7 @@ export default class WfsManager extends VendorSpecificOgcServerManager {
         return ogcServer.urlWfs ?? '';
     }
     static UnknownFeatureType = 'UNKNOWN';
-    initializeSingleton() {
+    async initializeSingleton() {
         this.context.stateManager.subscribe(/layers\.layersList\..*\.filter/, (_oldFilter, newFilter) => {
             void this.onSelectedFeaturesFilterChange(newFilter);
         });

package/tools/wms/wmsmanager.d.ts

@@ -8,7 +8,7 @@ import IGirafeContext from '../context/icontext.js';
 export default class WmsManager extends VendorSpecificOgcServerManager<WmsClient, OlMap> {
     private readonly map;
     constructor(context: IGirafeContext);
-    initializeSingleton(): void;
+    initializeSingleton(): Promise<void>;
     getClientId(ogcServer: ServerOgc): string;
     createClient(clientClass: new (os: ServerOgc, map: OlMap, context: IGirafeContext) => WmsClient, ogcServer: ServerOgc): WmsClient;
     selectFeatures(extent: number[]): void;

package/tools/wms/wmsmanager.js

@@ -6,7 +6,7 @@ export default class WmsManager extends VendorSpecificOgcServerManager {
         super(context);
         this.map = this.context.mapManager.getMap();
     }
-    initializeSingleton() {
+    async initializeSingleton() {
         // Register the default client
         this.registerClientClass('default', WmsClientDefault);
         this.registerClientClass('geoserver', WmsClientGeoServer);