@idea-ionic/uncommon 8.2.1

package/esm2022/src/offline/offlineData.service.mjs

@@ -0,0 +1,479 @@
+import { Injectable, inject } from '@angular/core';
+import { IDEAStorageService, IDEATranslationsService } from '@idea-ionic/common';
+import { IDEAAWSAPIService } from '../AWSAPI.service';
+import { IDEAOfflineService } from './offline.service';
+import * as i0 from "@angular/core";
+/**
+ * After how much time we need to request a synchronisation to keep the contents up-to-date.
+ */
+export const SYNC_EXPIRATION_INTERVAL = 1000 * 60 * 60 * 24; // a day
+/**
+ * Prefix for the key of the API requests queue info in the local storage.
+ */
+export const QUEUE_API_REQUESTS_KEY = 'IDEAOfflineService.queueAPIrequests';
+/**
+ * Prefix for the key of the last sync time info in the local storage.
+ */
+export const LAST_SYNC_KEY = 'IDEAOfflineService.lastSyncAt';
+/**
+ * The max number of elements per resource to synchronize during the first analysis of a synchronisation.
+ * If the number of elements exceeds (there is more data after the 1st page), the operation require manual confirmation.
+ */
+export const NUM_ELEMENTS_WITHOUT_MANUAL_SYNC = 100;
+/**
+ * The max number of elements per resource to request at the same time during a normal synchronisation.
+ */
+export const NUM_ELEMENTS_WITH_MANUAL_SYNC = 300;
+/**
+ * Manage the offline functioning of the app's data (upload/download/synchronization).
+ * Note: it includes all the methods of IDEAOfflineService.
+ *
+ * Download: it works through the **Delta** mechanism on back-end resources.
+ * Practically, the service prepares each possible API GET requests for each of the involved resources.
+ * In this way, if offline, the API service can hit an element by URL in the cache (storage offline).
+ *
+ * **How to use it**. Configure the sync mechanism in the main app.component as it follows:
+ *
+ *    1. Implement a CacheableResource class for each DeltaResource you want to cache offline.
+ *    2. Set up the service (`setUpOfflineData`).
+ *    3. Run a synchronization.
+ *    4. Add the navigation to the Offline Manager (UI).
+ *    5. Optionally, push offline API requests to the queue when offline.
+ *
+ * e.g. of CacheableResource classes:
+ * ```
+ * class CustomerCR extends CacheableResource {
+ *   constructor(description: string) {
+ *     super(DeltaResources.CUSTOMERS, description);
+ *   }
+ *   public listURL(element: any): string {
+ *     return `teams/${element.teamId}/customers`;
+ *   }
+ *   public elementURL(element: any): string {
+ *     return `teams/${element.teamId}/customers/${element.customerId}`;
+ *   }
+ *   public findIndexInList(list: Array<any>, element: any): number {
+ *     return list.findIndex(x => x.customerId === element.customerId);
+ *   }
+ *   public sort(a: any, b: any): number {
+ *     return a.name.localeCompare(b.name);
+ *   }
+ * }
+ */
+export class IDEAOfflineDataService {
+    constructor() {
+        this._storage = inject(IDEAStorageService);
+        this._translate = inject(IDEATranslationsService);
+        this._offline = inject(IDEAOfflineService);
+        this._API = inject(IDEAAWSAPIService);
+        this.queueAPIRequests = new Array();
+        this.resources = new Array();
+        this.cacheableResources = {};
+        // subscribe to network changes
+        this._offline.subscribe(isOnline => {
+            if (isOnline) {
+                // try a synchronization if needed or if the last one failed
+                if (this.errorInLastSync)
+                    this.synchronize();
+                else
+                    this.synchronizeIfNeeded();
+            }
+        });
+    }
+    //
+    // NETWORK STATUS from IDEAOfflineService
+    //
+    /**
+     * Quickly check the connection status.
+     */
+    isOnline() {
+        return this._offline.isOnline();
+    }
+    /**
+     * Quickly check the connection status.
+     */
+    isOffline() {
+        return this._offline.isOffline();
+    }
+    /**
+     * Subscribe to the service to be notified when the connection status changes.
+     */
+    subscribe(callback) {
+        return this._offline.subscribe(callback);
+    }
+    /**
+     * Quickly check for online connection.
+     */
+    check() {
+        return this._offline.check();
+    }
+    //
+    // CONFIGURATION
+    //
+    /**
+     * Whether the offline mode is allowed. You can customize this function, if needed.
+     */
+    isAllowed() {
+        return !!this.resources.length;
+    }
+    /**
+     * Set up the service to use and sync offline data.
+     */
+    setUpOfflineData(teamId, useQueueAPIRequests, cacheableResources) {
+        // set the team
+        this.teamId = teamId;
+        // decide if to allow certain API request while offline
+        this.useQueueAPIRequests = useQueueAPIRequests;
+        // load the API request pending queue, if any
+        this.queueAPIRequestKey = this.teamId ? `${QUEUE_API_REQUESTS_KEY}_${this.teamId}` : QUEUE_API_REQUESTS_KEY;
+        this.loadQueueAPIRequest();
+        // load the lastSyncAt information for the team
+        this.lastSyncKey = this.teamId ? `${LAST_SYNC_KEY}_${this.teamId}` : LAST_SYNC_KEY;
+        this.loadLastSyncAt();
+        // load the cacheable resources
+        this.resources = new Array();
+        this.cacheableResources = {};
+        cacheableResources.forEach(r => this.addCacheableResource(r));
+    }
+    /**
+     * Load from the local storage the last sync at information.
+     */
+    loadLastSyncAt() {
+        return new Promise(resolve => {
+            this._storage.get(this.lastSyncKey).then((lastSyncAt) => {
+                this.lastSyncAt = lastSyncAt ? Number(lastSyncAt) : null;
+                resolve(this.lastSyncAt);
+            });
+        });
+    }
+    /**
+     * Update last sync at info in the local storage.
+     */
+    saveLastSyncAt(lastSyncAt) {
+        this.lastSyncAt = lastSyncAt;
+        return this._storage.set(this.lastSyncKey, lastSyncAt);
+    }
+    /**
+     * Add a CacheableResource.
+     */
+    addCacheableResource(cacheableResource) {
+        if (this.teamId)
+            cacheableResource.teamId = this.teamId;
+        this.cacheableResources[cacheableResource.resource] = cacheableResource;
+        this.resources.push(cacheableResource.resource);
+    }
+    /**
+     * Remove a CacheableResource by its DeltaResource.
+     */
+    removeCacheableResource(resource) {
+        delete this.cacheableResources[resource];
+        this.resources.splice(this.resources.indexOf(resource), 1);
+    }
+    /**
+     * Get the the DeltaResourced configured.
+     */
+    getResources() {
+        return this.resources;
+    }
+    /**
+     * Get a CacheableResource by its DeltaResource.
+     */
+    getCacheableResource(resource) {
+        return this.cacheableResources[resource];
+    }
+    //
+    // UPLOAD
+    //
+    /**
+     * Execute all the API requests in the queue; the requests terminated with an error will remain in the queue.
+     */
+    runQueueAPIRequests() {
+        return new Promise((resolve, reject) => {
+            if (!this.useQueueAPIRequests || this.isOffline() || !this.queueAPIRequests.length)
+                return resolve();
+            this.queueAPIRequests.forEach(async (request) => {
+                const options = {};
+                if (request.resourceId)
+                    options.resourceId = request.resourceId;
+                if (request.body)
+                    options.body = request.body;
+                let promise;
+                try {
+                    switch (request.method.toUpperCase()) {
+                        case 'POST':
+                            promise = await this._API.postResource(request.resource, options);
+                            break;
+                        case 'PUT':
+                            promise = await this._API.putResource(request.resource, options);
+                            break;
+                        case 'PATCH':
+                            promise = await this._API.patchResource(request.resource, options);
+                            break;
+                    }
+                    if (!promise)
+                        request.error = 'INVALID_METHOD';
+                    else
+                        request.error = null;
+                }
+                catch (err) {
+                    request.error = err.message || 'UNKNOWN_ERROR';
+                }
+            });
+            // keep the requests NOT successfully executed
+            this.saveQueueAPIRequest(this.queueAPIRequests.filter(x => x.error)).then(() => {
+                // if the queue is empty, the entire operation was successful
+                if (this.queueAPIRequests.length)
+                    reject();
+                else
+                    resolve();
+            });
+        });
+    }
+    /**
+     * Load from the local storage the API requests queue.
+     */
+    loadQueueAPIRequest() {
+        return new Promise(resolve => {
+            if (!this.useQueueAPIRequests)
+                return resolve([]);
+            this._storage.get(this.queueAPIRequestKey).then((queue) => {
+                this.queueAPIRequests = queue || [];
+                resolve(this.queueAPIRequests);
+            });
+        });
+    }
+    /**
+     * Update the queue in memory and also save the copy in the local storage.
+     */
+    saveQueueAPIRequest(queue) {
+        if (!this.isAllowed())
+            return Promise.reject();
+        this.queueAPIRequests = queue || this.queueAPIRequests;
+        return this._storage.set(this.queueAPIRequestKey, this.queueAPIRequests);
+    }
+    /**
+     * Delete a request stuck in an error.
+     */
+    deleteRequest(request) {
+        if (!this.isAllowed())
+            return Promise.reject();
+        if (request) {
+            this.queueAPIRequests.splice(this.queueAPIRequests.indexOf(request), 1);
+            this.saveQueueAPIRequest();
+        }
+    }
+    //
+    // DOWNLOAD
+    //
+    /**
+     * Save the records of a delta and, if the latter has more pages, go recursive.
+     */
+    async syncDeltaRecords(delta, done) {
+        // for each resource, we reset the status; if a resource still need to be synchronized, it will be flagged below
+        this.resources.forEach(resource => {
+            this.cacheableResources[resource].error = false;
+            this.cacheableResources[resource].synchronizing = false;
+        });
+        try {
+            // synchronze each of the resources included in the delta; this execution can go in parallel
+            await Promise.all(delta.resources.map(async (resource) => {
+                const cr = this.cacheableResources[resource];
+                if (cr) {
+                    // synchronize the delta records; note: the executuion inside a resource must go in series
+                    cr.synchronizing = true;
+                    const success = await this.syncResourceDeltaRecords(resource, delta.records[resource]);
+                    if (!success)
+                        this.errorInLastSync = true;
+                }
+            }));
+            // if there were error of if there is nothing left to sync, we are done
+            if (this.errorInLastSync || !delta.next)
+                return done();
+            // otherwise, get the next page of the delta and go recursive until we are done
+            const params = { next: delta.next, limit: NUM_ELEMENTS_WITH_MANUAL_SYNC };
+            if (this.lastSyncAt)
+                params.since = this.lastSyncAt;
+            const newDelta = await this._API.getResource(this.teamId ? `teams/${this.teamId}/delta` : 'delta', { params });
+            this.syncDeltaRecords(newDelta, done);
+        }
+        catch (err) {
+            // if something went wrong, stops the operation, since we need to make sure the entire flow is consistent
+            this.errorInLastSync = true;
+            return done();
+        }
+    }
+    /**
+     * Save offline a list of DeltaRecords for this resource, creating a map of all the corresponding API GET requests.
+     */
+    async syncResourceDeltaRecords(resource, records) {
+        // acquire the info an a cacheable resource
+        const cr = this.cacheableResources[resource];
+        if (!cr)
+            return Promise.resolve(true);
+        try {
+            // prepare helpers to group executions of elements of the same list
+            let list = null, oldListURL = null;
+            for (const r of records) {
+                // calculate the URL to access the API request key for this element
+                const elementURL = cr.elementURL(r.element);
+                // if the element was deleted (based on delta), delete its corresponding API GET request
+                if (r.deleted)
+                    await this._API.deleteFromCache(elementURL);
+                // otherwise, update it
+                else
+                    await this._API.putInCache(elementURL, r.element);
+                // calculate the URLs to access the API request key for this element's list
+                const listURL = cr.listURL(r.element);
+                // to improve the performance, get/sort/save the list only when it changes from the previous element's one.
+                if (listURL !== oldListURL) {
+                    // skip first cycle (oldListURL === null)
+                    if (oldListURL) {
+                        // re-sort the list; note: it should be sorted from the last time, so we only manage the new element
+                        list = list.sort(cr.sort);
+                        // save the updated list
+                        await this._API.putInCache(oldListURL, list);
+                    }
+                    // get the list of elements from the local storage by the calculated URL
+                    list = await this._API.getFromCache(listURL);
+                    // save the reference to the list for the next cycle
+                    oldListURL = listURL;
+                }
+                // find in the list the element we want to manage
+                const index = cr.findIndexInList(list, r.element);
+                // delete the element from the list
+                if (index !== -1)
+                    list.splice(index, 1);
+                // if the element wasn't deleted (following the delta record information), insert the new version
+                if (!r.deleted)
+                    list.push(r.element);
+            }
+            // in case there were elements, save the last element's list
+            if (oldListURL) {
+                // re-sort the list; note: it should be sorted from the last time, so we only manage the new element
+                list = list.sort(cr.sort);
+                // save the updated list
+                await this._API.putInCache(oldListURL, list);
+            }
+            return Promise.resolve(true);
+        }
+        catch (err) {
+            // if something went wrong, stops the operation, since we need to make sure the entire flow is consistent
+            cr.error = true;
+            return Promise.resolve(false);
+        }
+    }
+    //
+    // SYNCHRONISATION (UPLOAD+DOWNLOAD)
+    //
+    /**
+     * Run a sync, but only if needed, i.e. the cached content expired or we have pending API requests in the queue.
+     */
+    synchronizeIfNeeded() {
+        return new Promise((resolve, reject) => {
+            if (!this.isAllowed())
+                return;
+            this.loadLastSyncAt().then(() => this.loadQueueAPIRequest()
+                .then(() => {
+                if (this.queueAPIRequests.length || Date.now() > this.lastSyncAt + SYNC_EXPIRATION_INTERVAL)
+                    this.synchronize();
+                resolve();
+            })
+                .catch(err => reject(err)));
+        });
+    }
+    /**
+     * Synchronization of the whole set of resources (upload+download).
+     * @param manualConfirmation if true, the request comes directly from a user action (not automatic procedures).
+     */
+    synchronize(manualConfirmation) {
+        return new Promise((resolve, reject) => {
+            if (!this.isAllowed() || this.synchronizing)
+                return resolve();
+            this.synchronizing = true;
+            this.errorInLastSync = false;
+            this.requiresManualConfirmation = false;
+            // load the lastSyncAt information
+            this.loadLastSyncAt().then(() => 
+            // try to run all the pending API requests in the queue, i.e. uploading the offline resources changed
+            this.runQueueAPIRequests()
+                .then(() => {
+                // set this moment in time: if anything happened before the end of the sync, we don't lose fresh data
+                const now = Date.now();
+                // prepare a first "short" Delta request, to see if there is a lot of data to process
+                const params = { limit: NUM_ELEMENTS_WITHOUT_MANUAL_SYNC };
+                if (this.lastSyncAt)
+                    params.since = this.lastSyncAt;
+                this._API
+                    .getResource(this.teamId ? `teams/${this.teamId}/delta` : 'delta', { params })
+                    .then((delta) => {
+                    // decide if to proceed with the sync: in case there is another page, it requires a manual confirmation
+                    if (delta.next && !manualConfirmation) {
+                        this.requiresManualConfirmation = true;
+                        this.synchronizing = false;
+                        return resolve();
+                    }
+                    // save the records in the delta and request possible new pages
+                    this.syncDeltaRecords(delta, () => {
+                        if (this.errorInLastSync) {
+                            this.synchronizing = false;
+                            resolve();
+                        }
+                        else {
+                            // all the resources are succesfully in sync
+                            this.resources.forEach(resource => (this.cacheableResources[resource].synchronizing = false));
+                            // update the timestamp of last sync
+                            this.saveLastSyncAt(now)
+                                .then(() => {
+                                this.synchronizing = false;
+                                resolve();
+                            })
+                                .catch(() => {
+                                // we couldn't save the last sync info
+                                this.errorInLastSync = true;
+                                this.synchronizing = false;
+                                reject();
+                            });
+                        }
+                    });
+                })
+                    .catch(() => {
+                    // we couldn't acquire new information (Delta)
+                    this.errorInLastSync = true;
+                    this.synchronizing = false;
+                    reject();
+                });
+            })
+                .catch(() => {
+                // we stop, since we don't want backend data to override local info not yet uploaded
+                this.errorInLastSync = true;
+                this.synchronizing = false;
+                reject();
+            }));
+        });
+    }
+    /**
+     * Force a full synchronisation.
+     */
+    forceFullSync() {
+        this._storage.clear().then(() => this.synchronize(true));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IDEAOfflineDataService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IDEAOfflineDataService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IDEAOfflineDataService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+/**
+ * The abstract class to implement for each resource to cache offline from the back-end (DOWNLOAD).
+ */
+export class CacheableResource {
+    constructor(resource, description) {
+        this.resource = resource;
+        this.description = description;
+        this.synchronizing = false;
+        this.error = false;
+        // loaded at runtime
+        this.teamId = null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"offlineData.service.js","sourceRoot":"","sources":["../../../../../modules/uncommon/src/offline/offlineData.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport { Subscription } from 'rxjs';\nimport { Delta, DeltaRecord, DeltaResources, epochDateTime } from 'idea-toolbox';\nimport { IDEAStorageService, IDEATranslationsService } from '@idea-ionic/common';\n\nimport { IDEAAWSAPIService, APIRequestOption } from '../AWSAPI.service';\nimport { IDEAOfflineService } from './offline.service';\n\n/**\n * After how much time we need to request a synchronisation to keep the contents up-to-date.\n */\nexport const SYNC_EXPIRATION_INTERVAL = 1000 * 60 * 60 * 24; // a day\n/**\n * Prefix for the key of the API requests queue info in the local storage.\n */\nexport const QUEUE_API_REQUESTS_KEY = 'IDEAOfflineService.queueAPIrequests';\n/**\n * Prefix for the key of the last sync time info in the local storage.\n */\nexport const LAST_SYNC_KEY = 'IDEAOfflineService.lastSyncAt';\n/**\n * The max number of elements per resource to synchronize during the first analysis of a synchronisation.\n * If the number of elements exceeds (there is more data after the 1st page), the operation require manual confirmation.\n */\nexport const NUM_ELEMENTS_WITHOUT_MANUAL_SYNC = 100;\n/**\n * The max number of elements per resource to request at the same time during a normal synchronisation.\n */\nexport const NUM_ELEMENTS_WITH_MANUAL_SYNC = 300;\n\n/**\n * Manage the offline functioning of the app's data (upload/download/synchronization).\n * Note: it includes all the methods of IDEAOfflineService.\n *\n * Download: it works through the **Delta** mechanism on back-end resources.\n * Practically, the service prepares each possible API GET requests for each of the involved resources.\n * In this way, if offline, the API service can hit an element by URL in the cache (storage offline).\n *\n * **How to use it**. Configure the sync mechanism in the main app.component as it follows:\n *\n *    1. Implement a CacheableResource class for each DeltaResource you want to cache offline.\n *    2. Set up the service (`setUpOfflineData`).\n *    3. Run a synchronization.\n *    4. Add the navigation to the Offline Manager (UI).\n *    5. Optionally, push offline API requests to the queue when offline.\n *\n * e.g. of CacheableResource classes:\n * ```\n * class CustomerCR extends CacheableResource {\n *   constructor(description: string) {\n *     super(DeltaResources.CUSTOMERS, description);\n *   }\n *   public listURL(element: any): string {\n *     return `teams/${element.teamId}/customers`;\n *   }\n *   public elementURL(element: any): string {\n *     return `teams/${element.teamId}/customers/${element.customerId}`;\n *   }\n *   public findIndexInList(list: Array<any>, element: any): number {\n *     return list.findIndex(x => x.customerId === element.customerId);\n *   }\n *   public sort(a: any, b: any): number {\n *     return a.name.localeCompare(b.name);\n *   }\n * }\n */\n@Injectable()\nexport class IDEAOfflineDataService {\n  protected _storage = inject(IDEAStorageService);\n  protected _translate = inject(IDEATranslationsService);\n  protected _offline = inject(IDEAOfflineService);\n  protected _API = inject(IDEAAWSAPIService);\n\n  /**\n   * True when running a synchronization.\n   */\n  synchronizing: boolean;\n  /**\n   * The timestamp of the last synchronization.\n   */\n  lastSyncAt: epochDateTime;\n  /**\n   * True if an error happened in the last synchronization.\n   */\n  errorInLastSync: boolean;\n  /**\n   * True if the synchronisation is too vast and so require a manual action of the user.\n   */\n  requiresManualConfirmation: boolean;\n  /**\n   * If false, ignore the entire upload scenario.\n   */\n  useQueueAPIRequests: boolean;\n  /**\n   * The array of the requests not executed because we are/were offline; they need to run once online.\n   */\n  queueAPIRequests: APIRequest[];\n\n  /**\n   * The id of the team of which to manage data offline.\n   * If null, the project isn't teams-based.\n   */\n  protected teamId: string;\n  /**\n   * The array of DeltaResources to cache offline.\n   */\n  protected resources: (DeltaResources | string)[];\n  /**\n   * Helper structure to manage the CacheableResource for each DeltaResource.\n   */\n  protected cacheableResources: { [resource: string]: CacheableResource };\n  /**\n   * Key to acquire from the storage the lastSyncAt information of the team.\n   */\n  protected lastSyncKey: string;\n  /**\n   * Key to acquire from the storage the lastSyncAt information of the team.\n   */\n  protected queueAPIRequestKey: string;\n\n  constructor() {\n    this.queueAPIRequests = new Array<APIRequest>();\n    this.resources = new Array<string>();\n    this.cacheableResources = {};\n    // subscribe to network changes\n    this._offline.subscribe(isOnline => {\n      if (isOnline) {\n        // try a synchronization if needed or if the last one failed\n        if (this.errorInLastSync) this.synchronize();\n        else this.synchronizeIfNeeded();\n      }\n    });\n  }\n\n  //\n  // NETWORK STATUS from IDEAOfflineService\n  //\n\n  /**\n   * Quickly check the connection status.\n   */\n  isOnline(): boolean {\n    return this._offline.isOnline();\n  }\n  /**\n   * Quickly check the connection status.\n   */\n  isOffline(): boolean {\n    return this._offline.isOffline();\n  }\n  /**\n   * Subscribe to the service to be notified when the connection status changes.\n   */\n  subscribe(callback: (isOnline: boolean) => void): Subscription {\n    return this._offline.subscribe(callback);\n  }\n  /**\n   * Quickly check for online connection.\n   */\n  public check(): Promise<boolean> {\n    return this._offline.check();\n  }\n\n  //\n  // CONFIGURATION\n  //\n\n  /**\n   * Whether the offline mode is allowed. You can customize this function, if needed.\n   */\n  isAllowed(): boolean {\n    return !!this.resources.length;\n  }\n  /**\n   * Set up the service to use and sync offline data.\n   */\n  setUpOfflineData(teamId: string, useQueueAPIRequests: boolean, cacheableResources: CacheableResource[]): void {\n    // set the team\n    this.teamId = teamId;\n    // decide if to allow certain API request while offline\n    this.useQueueAPIRequests = useQueueAPIRequests;\n    // load the API request pending queue, if any\n    this.queueAPIRequestKey = this.teamId ? `${QUEUE_API_REQUESTS_KEY}_${this.teamId}` : QUEUE_API_REQUESTS_KEY;\n    this.loadQueueAPIRequest();\n    // load the lastSyncAt information for the team\n    this.lastSyncKey = this.teamId ? `${LAST_SYNC_KEY}_${this.teamId}` : LAST_SYNC_KEY;\n    this.loadLastSyncAt();\n    // load the cacheable resources\n    this.resources = new Array<DeltaResources | string>();\n    this.cacheableResources = {};\n    cacheableResources.forEach(r => this.addCacheableResource(r));\n  }\n  /**\n   * Load from the local storage the last sync at information.\n   */\n  protected loadLastSyncAt(): Promise<number> {\n    return new Promise(resolve => {\n      this._storage.get(this.lastSyncKey).then((lastSyncAt: number): void => {\n        this.lastSyncAt = lastSyncAt ? Number(lastSyncAt) : null;\n        resolve(this.lastSyncAt);\n      });\n    });\n  }\n  /**\n   * Update last sync at info in the local storage.\n   */\n  protected saveLastSyncAt(lastSyncAt: number): Promise<void> {\n    this.lastSyncAt = lastSyncAt;\n    return this._storage.set(this.lastSyncKey, lastSyncAt);\n  }\n  /**\n   * Add a CacheableResource.\n   */\n  protected addCacheableResource(cacheableResource: CacheableResource): void {\n    if (this.teamId) cacheableResource.teamId = this.teamId;\n    this.cacheableResources[cacheableResource.resource] = cacheableResource;\n    this.resources.push(cacheableResource.resource);\n  }\n  /**\n   * Remove a CacheableResource by its DeltaResource.\n   */\n  protected removeCacheableResource(resource: DeltaResources | string): void {\n    delete this.cacheableResources[resource];\n    this.resources.splice(this.resources.indexOf(resource), 1);\n  }\n  /**\n   * Get the the DeltaResourced configured.\n   */\n  getResources(): (DeltaResources | string)[] {\n    return this.resources;\n  }\n  /**\n   * Get a CacheableResource by its DeltaResource.\n   */\n  getCacheableResource(resource: DeltaResources | string): CacheableResource {\n    return this.cacheableResources[resource];\n  }\n\n  //\n  // UPLOAD\n  //\n\n  /**\n   * Execute all the API requests in the queue; the requests terminated with an error will remain in the queue.\n   */\n  protected runQueueAPIRequests(): Promise<void> {\n    return new Promise((resolve, reject): void => {\n      if (!this.useQueueAPIRequests || this.isOffline() || !this.queueAPIRequests.length) return resolve();\n      this.queueAPIRequests.forEach(async request => {\n        const options: APIRequestOption = {};\n        if (request.resourceId) options.resourceId = request.resourceId;\n        if (request.body) options.body = request.body;\n        let promise: Promise<any>;\n        try {\n          switch (request.method.toUpperCase()) {\n            case 'POST':\n              promise = await this._API.postResource(request.resource, options);\n              break;\n            case 'PUT':\n              promise = await this._API.putResource(request.resource, options);\n              break;\n            case 'PATCH':\n              promise = await this._API.patchResource(request.resource, options);\n              break;\n          }\n          if (!promise) request.error = 'INVALID_METHOD';\n          else request.error = null;\n        } catch (err) {\n          request.error = (err as Error).message || 'UNKNOWN_ERROR';\n        }\n      });\n      // keep the requests NOT successfully executed\n      this.saveQueueAPIRequest(this.queueAPIRequests.filter(x => x.error)).then((): void => {\n        // if the queue is empty, the entire operation was successful\n        if (this.queueAPIRequests.length) reject();\n        else resolve();\n      });\n    });\n  }\n  /**\n   * Load from the local storage the API requests queue.\n   */\n  protected loadQueueAPIRequest(): Promise<APIRequest[]> {\n    return new Promise(resolve => {\n      if (!this.useQueueAPIRequests) return resolve([]);\n      this._storage.get(this.queueAPIRequestKey).then((queue: APIRequest[]): void => {\n        this.queueAPIRequests = queue || [];\n        resolve(this.queueAPIRequests);\n      });\n    });\n  }\n  /**\n   * Update the queue in memory and also save the copy in the local storage.\n   */\n  saveQueueAPIRequest(queue?: APIRequest[]): Promise<void> {\n    if (!this.isAllowed()) return Promise.reject();\n    this.queueAPIRequests = queue || this.queueAPIRequests;\n    return this._storage.set(this.queueAPIRequestKey, this.queueAPIRequests);\n  }\n  /**\n   * Delete a request stuck in an error.\n   */\n  deleteRequest(request: APIRequest) {\n    if (!this.isAllowed()) return Promise.reject();\n    if (request) {\n      this.queueAPIRequests.splice(this.queueAPIRequests.indexOf(request), 1);\n      this.saveQueueAPIRequest();\n    }\n  }\n\n  //\n  // DOWNLOAD\n  //\n\n  /**\n   * Save the records of a delta and, if the latter has more pages, go recursive.\n   */\n  protected async syncDeltaRecords(delta: Delta, done?: any): Promise<any> {\n    // for each resource, we reset the status; if a resource still need to be synchronized, it will be flagged below\n    this.resources.forEach(resource => {\n      this.cacheableResources[resource].error = false;\n      this.cacheableResources[resource].synchronizing = false;\n    });\n    try {\n      // synchronze each of the resources included in the delta; this execution can go in parallel\n      await Promise.all(\n        delta.resources.map(async resource => {\n          const cr = this.cacheableResources[resource];\n          if (cr) {\n            // synchronize the delta records; note: the executuion inside a resource must go in series\n            cr.synchronizing = true;\n            const success = await this.syncResourceDeltaRecords(resource, delta.records[resource]);\n            if (!success) this.errorInLastSync = true;\n          }\n        })\n      );\n      // if there were error of if there is nothing left to sync, we are done\n      if (this.errorInLastSync || !delta.next) return done();\n      // otherwise, get the next page of the delta and go recursive until we are done\n      const params: any = { next: delta.next, limit: NUM_ELEMENTS_WITH_MANUAL_SYNC };\n      if (this.lastSyncAt) params.since = this.lastSyncAt;\n      const newDelta = await this._API.getResource(this.teamId ? `teams/${this.teamId}/delta` : 'delta', { params });\n      this.syncDeltaRecords(newDelta, done);\n    } catch (err) {\n      // if something went wrong, stops the operation, since we need to make sure the entire flow is consistent\n      this.errorInLastSync = true;\n      return done();\n    }\n  }\n  /**\n   * Save offline a list of DeltaRecords for this resource, creating a map of all the corresponding API GET requests.\n   */\n  protected async syncResourceDeltaRecords(resource: string, records: DeltaRecord[]): Promise<boolean> {\n    // acquire the info an a cacheable resource\n    const cr = this.cacheableResources[resource];\n    if (!cr) return Promise.resolve(true);\n    try {\n      // prepare helpers to group executions of elements of the same list\n      let list: any[] = null,\n        oldListURL: string = null;\n      for (const r of records) {\n        // calculate the URL to access the API request key for this element\n        const elementURL = cr.elementURL(r.element);\n        // if the element was deleted (based on delta), delete its corresponding API GET request\n        if (r.deleted) await this._API.deleteFromCache(elementURL);\n        // otherwise, update it\n        else await this._API.putInCache(elementURL, r.element);\n        // calculate the URLs to access the API request key for this element's list\n        const listURL = cr.listURL(r.element);\n        // to improve the performance, get/sort/save the list only when it changes from the previous element's one.\n        if (listURL !== oldListURL) {\n          // skip first cycle (oldListURL === null)\n          if (oldListURL) {\n            // re-sort the list; note: it should be sorted from the last time, so we only manage the new element\n            list = list.sort(cr.sort);\n            // save the updated list\n            await this._API.putInCache(oldListURL, list);\n          }\n          // get the list of elements from the local storage by the calculated URL\n          list = await this._API.getFromCache(listURL);\n          // save the reference to the list for the next cycle\n          oldListURL = listURL;\n        }\n        // find in the list the element we want to manage\n        const index = cr.findIndexInList(list, r.element);\n        // delete the element from the list\n        if (index !== -1) list.splice(index, 1);\n        // if the element wasn't deleted (following the delta record information), insert the new version\n        if (!r.deleted) list.push(r.element);\n      }\n      // in case there were elements, save the last element's list\n      if (oldListURL) {\n        // re-sort the list; note: it should be sorted from the last time, so we only manage the new element\n        list = list.sort(cr.sort);\n        // save the updated list\n        await this._API.putInCache(oldListURL, list);\n      }\n      return Promise.resolve(true);\n    } catch (err) {\n      // if something went wrong, stops the operation, since we need to make sure the entire flow is consistent\n      cr.error = true;\n      return Promise.resolve(false);\n    }\n  }\n\n  //\n  // SYNCHRONISATION (UPLOAD+DOWNLOAD)\n  //\n\n  /**\n   * Run a sync, but only if needed, i.e. the cached content expired or we have pending API requests in the queue.\n   */\n  synchronizeIfNeeded(): Promise<void> {\n    return new Promise((resolve, reject): void => {\n      if (!this.isAllowed()) return;\n      this.loadLastSyncAt().then(\n        (): Promise<void> =>\n          this.loadQueueAPIRequest()\n            .then((): void => {\n              if (this.queueAPIRequests.length || Date.now() > this.lastSyncAt + SYNC_EXPIRATION_INTERVAL)\n                this.synchronize();\n              resolve();\n            })\n            .catch(err => reject(err))\n      );\n    });\n  }\n  /**\n   * Synchronization of the whole set of resources (upload+download).\n   * @param manualConfirmation if true, the request comes directly from a user action (not automatic procedures).\n   */\n  synchronize(manualConfirmation?: boolean): Promise<void> {\n    return new Promise((resolve, reject): void => {\n      if (!this.isAllowed() || this.synchronizing) return resolve();\n      this.synchronizing = true;\n      this.errorInLastSync = false;\n      this.requiresManualConfirmation = false;\n      // load the lastSyncAt information\n      this.loadLastSyncAt().then(\n        (): Promise<void> =>\n          // try to run all the pending API requests in the queue, i.e. uploading the offline resources changed\n          this.runQueueAPIRequests()\n            .then((): void => {\n              // set this moment in time: if anything happened before the end of the sync, we don't lose fresh data\n              const now = Date.now();\n              // prepare a first \"short\" Delta request, to see if there is a lot of data to process\n              const params: any = { limit: NUM_ELEMENTS_WITHOUT_MANUAL_SYNC };\n              if (this.lastSyncAt) params.since = this.lastSyncAt;\n              this._API\n                .getResource(this.teamId ? `teams/${this.teamId}/delta` : 'delta', { params })\n                .then((delta: Delta): void => {\n                  // decide if to proceed with the sync: in case there is another page, it requires a manual confirmation\n                  if (delta.next && !manualConfirmation) {\n                    this.requiresManualConfirmation = true;\n                    this.synchronizing = false;\n                    return resolve();\n                  }\n                  // save the records in the delta and request possible new pages\n                  this.syncDeltaRecords(delta, (): void => {\n                    if (this.errorInLastSync) {\n                      this.synchronizing = false;\n                      resolve();\n                    } else {\n                      // all the resources are succesfully in sync\n                      this.resources.forEach(resource => (this.cacheableResources[resource].synchronizing = false));\n                      // update the timestamp of last sync\n                      this.saveLastSyncAt(now)\n                        .then((): void => {\n                          this.synchronizing = false;\n                          resolve();\n                        })\n                        .catch((): void => {\n                          // we couldn't save the last sync info\n                          this.errorInLastSync = true;\n                          this.synchronizing = false;\n                          reject();\n                        });\n                    }\n                  });\n                })\n                .catch((): void => {\n                  // we couldn't acquire new information (Delta)\n                  this.errorInLastSync = true;\n                  this.synchronizing = false;\n                  reject();\n                });\n            })\n            .catch((): void => {\n              // we stop, since we don't want backend data to override local info not yet uploaded\n              this.errorInLastSync = true;\n              this.synchronizing = false;\n              reject();\n            })\n      );\n    });\n  }\n  /**\n   * Force a full synchronisation.\n   */\n  forceFullSync(): void {\n    this._storage.clear().then((): Promise<void> => this.synchronize(true));\n  }\n}\n\n/**\n * The description of an API request to a resource, to use with `IDEAAWSAPI`.\n * Used for queues of requests (UPLOAD).\n */\nexport interface APIRequest {\n  /**\n   * Resource path (e.g. `users` or `teams/${teamId}/users`).\n   */\n  resource: string;\n  /**\n   * The id to identify a specific element of the resource.\n   */\n  resourceId: string;\n  /**\n   * The API request method (e.g. POST, PUT, PATCH).\n   */\n  method: string;\n  /**\n   * The body of the request.\n   */\n  body: any;\n  /**\n   * A description to show for the request.\n   */\n  description?: string;\n  /**\n   * If not null, the request tried to run but it encountered the error.\n   */\n  error?: string;\n}\n\n/**\n * The abstract class to implement for each resource to cache offline from the back-end (DOWNLOAD).\n */\nexport abstract class CacheableResource {\n  /**\n   * The team owning the resource.\n   * If null, the project isn't teams-based.\n   */\n  teamId: string;\n  /**\n   * The identifier of the resource.\n   */\n  resource: DeltaResources | string;\n  /**\n   * The resource description (translated) for the UI.\n   */\n  description: string;\n  /**\n   * Runtime attribute to know if the resource is synchronizing.\n   */\n  synchronizing: boolean;\n  /**\n   * True if one of the elements failed the execution.\n   */\n  error: boolean;\n\n  constructor(resource: string, description: string) {\n    this.resource = resource;\n    this.description = description;\n    this.synchronizing = false;\n    this.error = false;\n    // loaded at runtime\n    this.teamId = null;\n  }\n\n  /**\n   * How to build the relative URL to the resource (list).\n   * E.g. `teams/${element.teamId}/customers` or `customers`.\n   */\n  abstract listURL(element: any): string;\n  /**\n   * How to build the relative URL to the resource element (detail).\n   * E.g. `teams/${element.teamId}/customers/${element.customerId}` or `customers/${element.customerId}`.\n   */\n  abstract elementURL(element: any): string;\n  /**\n   * How to uniquely identify an element in the list (by its ids).\n   * E.g. `return list.findIndex(x => x.customerId === element.customerId);`\n   */\n  abstract findIndexInList(list: any[], element: any): number;\n  /**\n   * How to keep the list sorted.\n   * E.g. `return a.name.localeCompare(b.name);`\n   */\n  abstract sort(a: any, b: any): number;\n}\n"]}

package/esm2022/src/offline/offlineIndicator.component.mjs

@@ -0,0 +1,58 @@
+import { Component, Input, inject } from '@angular/core';
+import { ModalController, AlertController, Platform } from '@ionic/angular';
+import { IDEATranslationsService } from '@idea-ionic/common';
+import { IDEAOfflineManagerComponent } from './offlineManager.component';
+import { IDEAOfflineDataService } from './offlineData.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/angular";
+export class IDEAOfflineIndicatorComponent {
+    constructor() {
+        this._alert = inject(AlertController);
+        this._modal = inject(ModalController);
+        this._translate = inject(IDEATranslationsService);
+        this._platform = inject(Platform);
+        this._offline = inject(IDEAOfflineDataService);
+        /**
+         * Vertical position.
+         */
+        this.vertical = 'bottom';
+        /**
+         * Horizontal position.
+         */
+        this.horizontal = 'start';
+        /**
+         * Whether it is positionated on an edge.
+         */
+        this.edge = false;
+    }
+    async showStatus() {
+        if (this._offline.isOffline()) {
+            const isOnline = await this._offline.check();
+            if (!isOnline) {
+                const alert = await this._alert.create({
+                    header: this._translate._('IDEA_UNCOMMON.OFFLINE.YOU_ARE_OFFLINE'),
+                    message: this._translate._('IDEA_UNCOMMON.OFFLINE.FEATURES_REDUCED_CONTENTS_NOT_UP_TO_DATE'),
+                    buttons: [this._translate._('COMMON.GOT_IT')]
+                });
+                alert.present();
+            }
+        }
+        else if (this._offline.isAllowed()) {
+            const modal = await this._modal.create({ component: IDEAOfflineManagerComponent });
+            modal.present();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IDEAOfflineIndicatorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.1.1", type: IDEAOfflineIndicatorComponent, selector: "idea-offline-indicator", inputs: { vertical: "vertical", horizontal: "horizontal", edge: "edge" }, ngImport: i0, template: "@if (\n  _platform.is('mobile') && (_offline.isOffline() || _offline.synchronizing || _offline.requiresManualConfirmation)\n) {\n  <ion-fab [vertical]=\"vertical\" [horizontal]=\"horizontal\" [edge]=\"edge\">\n    <ion-fab-button color=\"dark\" size=\"small\" (click)=\"showStatus()\">\n      <!-- OFFLINE -->\n      @if (_offline.isOffline()) {\n        <ion-icon name=\"airplane\" />\n      }\n      <!-- SYNCHRONISING -->\n      @if (_offline.isOnline() && _offline.synchronizing) {\n        <ion-icon name=\"sync\" />\n      }\n      <!-- NEED MANAL SYNCHRONISATION -->\n      @if (_offline.isOnline() && _offline.requiresManualConfirmation) {\n        <ion-icon name=\"pause\" />\n      }\n    </ion-fab-button>\n  </ion-fab>\n}\n", styles: [""], dependencies: [{ kind: "component", type: i1.IonFab, selector: "ion-fab", inputs: ["activated", "edge", "horizontal", "vertical"] }, { kind: "component", type: i1.IonFabButton, selector: "ion-fab-button", inputs: ["activated", "closeIcon", "color", "disabled", "download", "href", "mode", "rel", "routerAnimation", "routerDirection", "show", "size", "target", "translucent", "type"] }, { kind: "component", type: i1.IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: IDEAOfflineIndicatorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'idea-offline-indicator', template: "@if (\n  _platform.is('mobile') && (_offline.isOffline() || _offline.synchronizing || _offline.requiresManualConfirmation)\n) {\n  <ion-fab [vertical]=\"vertical\" [horizontal]=\"horizontal\" [edge]=\"edge\">\n    <ion-fab-button color=\"dark\" size=\"small\" (click)=\"showStatus()\">\n      <!-- OFFLINE -->\n      @if (_offline.isOffline()) {\n        <ion-icon name=\"airplane\" />\n      }\n      <!-- SYNCHRONISING -->\n      @if (_offline.isOnline() && _offline.synchronizing) {\n        <ion-icon name=\"sync\" />\n      }\n      <!-- NEED MANAL SYNCHRONISATION -->\n      @if (_offline.isOnline() && _offline.requiresManualConfirmation) {\n        <ion-icon name=\"pause\" />\n      }\n    </ion-fab-button>\n  </ion-fab>\n}\n" }]
+        }], propDecorators: { vertical: [{
+                type: Input
+            }], horizontal: [{
+                type: Input
+            }], edge: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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