@esfaenza/httpservice 13.1.3 → 13.1.7

package/fesm2020/esfaenza-httpservice.mjs

@@ -3,7 +3,8 @@ import { HttpEventType, HttpHeaders, HttpErrorResponse } from '@angular/common/h
 import * as i0 from '@angular/core';
 import { InjectionToken, Injectable, Inject, Optional, NgModule } from '@angular/core';
 import { delay, finalize, map, catchError, scan } from 'rxjs/operators';
-import { of, throwError, Observable } from 'rxjs';
+import { forkJoin, of, throwError, Observable } from 'rxjs';
+import * as i3 from '@esfaenza/preferences';
 
 /**
  * Dizionario di invalidazioni delle chiamate HTTP
@@ -133,9 +134,24 @@ const Loc = {
     "Redirecting to Login, ignoring HTTP error on call": { "en-US": "Redirecting to Login, ignoring HTTP error on call", "it-IT": "Redireziono al login ignorando errori sulla chiamata", },
     "Already Handling an error, ignoring HTTP error on call": { "en-US": "Already Handling an error, ignoring HTTP error on call", "it-IT": "sto già gestendo un errore, ignoro quello corrente per la chiamata HTTP", },
     "Error 444 on call": { "en-US": "Error 444 on call", "it-IT": "Errore 444 su chiamata" },
-    "Resource not found": { "en-US": "Resource not found", "it-IT": "Risorsa non trovata" }
+    "Resource not found": { "en-US": "Resource not found", "it-IT": "Risorsa non trovata" },
+    "Converted old storage system to new one": { "en-US": "Converted old storage system to new one", "it-IT": "Convertito il vecchio sistema di storicizzazione al nuovo" },
+    "Marking cache to be persisted as soon as possible": { "en-US": "Marking cache to be persisted as soon as possible", "it-IT": "Marco cache da persistere il prima possibile" },
+    "No more HTTP calls to be executed, entering idle state and persisting modified caches": { "en-US": "No more HTTP calls to be executed, entering idle state and persisting modified caches", "it-IT": "Nessun'altra chiamata HTTP dev'essere eseguita, entro in stato IDLE e persisto le cache modificate" },
+    "Caches succesfully persisted": { "en-US": "Caches succesfully persisted", "it-IT": "Le cache sono state persistite con successo" },
+    "Errors persisting modified caches": { "en-US": "Errors persisting modified caches", "it-IT": "Errori nella persistizione delle cache (esiste persistizione? boh...)" },
 };
 
+class CacheInfos {
+    constructor(finalUrl, cache, cacheKey, cacheTime, cacheItem) {
+        this.finalUrl = finalUrl;
+        this.cache = cache;
+        this.cacheKey = cacheKey;
+        this.cacheTime = cacheTime;
+        this.cacheItem = cacheItem;
+    }
+}
+
 // Angular
 /**
  * Servizio utilizzato per effettuare qualsiasi tipo di chiamata HTTP dall'applicazione, gestisce errori e cache delle risposte nativamente e ne può essere
@@ -145,7 +161,7 @@ class HTTPService {
     /**
      * @ignore
      */
-    constructor(BACKEND_URL, EXTENSION_CLASS, HTTP_INVALIDATION, LOCALE, APP_NAME, CLIENT_CACHE_DURATION_S, CACHE_BY_USER, DEBUG_MODE, http) {
+    constructor(BACKEND_URL, EXTENSION_CLASS, HTTP_INVALIDATION, LOCALE, APP_NAME, CLIENT_CACHE_DURATION_S, CACHE_BY_USER, DEBUG_MODE, http, localStorage) {
         this.BACKEND_URL = BACKEND_URL;
         this.EXTENSION_CLASS = EXTENSION_CLASS;
         this.HTTP_INVALIDATION = HTTP_INVALIDATION;
@@ -155,34 +171,49 @@ class HTTPService {
         this.CACHE_BY_USER = CACHE_BY_USER;
         this.DEBUG_MODE = DEBUG_MODE;
         this.http = http;
-        /**
-         * Cache dello stato delle chiamate HTTP attualmente effettuate. Ogni chiamata è rappresentata da un GUID e lo status assume valore **false** solo sugli errori
-         */
+        this.localStorage = localStorage;
+        /** Cache dello stato delle chiamate HTTP attualmente effettuate. Ogni chiamata è rappresentata da un GUID e lo status assume valore **false** solo sugli errori */
         this.callStatus = {};
-        /**
-         * Nome della cache in cui vengono storicizzate le informazioni sulle risposte delle chiamate sotto forma di dictionary
-         */
+        /** Nome della cache in cui vengono storicizzate le informazioni sulle risposte delle chiamate sotto forma di dictionary */
         this.localStorageHttpCacheKey = null;
-        /**
-         * Nome della cache in cui vengono storicizzate le informazioni sulle risposte delle chiamate sotto forma di dictionary, solo per le chiamate con un tempo definito di caching
-         */
+        /** Nome della cache in cui vengono storicizzate le informazioni sulle risposte delle chiamate sotto forma di dictionary, solo per le chiamate con un tempo definito di caching */
         this.localStorageHttpTimedCacheKey = null;
-        /**
-         * Nome della cache in cui vengono storicizzate le informazioni sullo scadere della cache stessa
-         */
+        /** Nome della cache in cui vengono storicizzate le informazioni sullo scadere della cache stessa */
         this.localStorageHttpCacheExpireKey = null;
-        /**
-         * Identità collegata al token di autenticazione da usare, richiesta al programma che utilizza la libreria attraverso l'hook **retrieveIdentity** della **HttpServiceExtensions**
-         */
+        /** Identità collegata al token di autenticazione da usare, richiesta al programma che utilizza la libreria attraverso l'hook **retrieveIdentity** della **HttpServiceExtensions** */
         this.me = null;
+        /** Indica che la cache a tempo dev'essere persistita il prima possibile */
+        this.PersistTimedCacheASAP = false;
+        /** Indica che la cache senza limiti di tempo dev'essere persistita il prima possibile */
+        this.PersistUntimedCacheASAP = false;
         this.ExtensionsImpl = this.EXTENSION_CLASS || new HttpServiceExtensions();
         this.me = this.ExtensionsImpl.retrieveIdentity();
         this.localStorageHttpCacheKey = (this.APP_NAME ?? "APP").replace(/\s/g, '_') + "_HttpCache";
         this.localStorageHttpTimedCacheKey = (this.APP_NAME ?? "APP").replace(/\s/g, '_') + "_HttpTimedCache";
         this.localStorageHttpCacheExpireKey = this.localStorageHttpCacheKey + "_Expire";
+        this.adjustOldStorageSystem();
         if (this.untimedCacheExpired())
             this.resetHttpUntimedCacheStorage();
     }
+    /**
+     * Se vedo che ci sono elementi salvati nel localStorage provo a toglierli e a risalvarli via preference.
+     * Nel caso migliore li sposto dal localStorage al DB di preference, nel caso peggiore li tolgo e li risalvo nel localStorage
+     */
+    async adjustOldStorageSystem() {
+        var lsTimed = localStorage.getItem(this.localStorageHttpTimedCacheKey);
+        var lsUntimed = localStorage.getItem(this.localStorageHttpCacheKey);
+        if (!lsTimed && !lsUntimed)
+            return;
+        localStorage.removeItem(this.localStorageHttpTimedCacheKey);
+        localStorage.removeItem(this.localStorageHttpCacheKey);
+        lsTimed = lsTimed ? JSON.parse(lsTimed) : {};
+        lsUntimed = lsUntimed ? JSON.parse(lsUntimed) : {};
+        await forkJoin([
+            this.localStorage.setItem(this.localStorageHttpTimedCacheKey, lsTimed),
+            this.localStorage.setItem(this.localStorageHttpCacheKey, lsUntimed)
+        ]).toPromise();
+        this.log(this.loc("Converted old storage system to new one"));
+    }
     /**
      * Esecuzione di una GET HTTP con eventualmente la gestione della cache qualora la chiamata termini con la convenzione "#cache"
      *
@@ -214,7 +245,7 @@ class HTTPService {
             if (errorCallback)
                 errorCallback();
             return !succesfulResultMandatory ? throwError(err) : this.registerErrorAndReturnEmptyObservable(err, myGuid);
-        }), finalize(() => { this.tryFinalizeByGuid(myGuid); }));
+        }), finalize(() => { this.tryFinalizeByGuid(myGuid, cachedInfos); }));
     }
     /**
      * Esecuzione di una GET HTTP con eventualmente la gestione della cache qualora la chiamata termini con la convenzione "#cache"
@@ -249,7 +280,7 @@ class HTTPService {
             if (errorCallback)
                 errorCallback();
             return !succesfulResultMandatory ? throwError(err) : this.registerErrorAndReturnEmptyObservable(err, myGuid);
-        }), finalize(() => { this.tryFinalizeByGuid(myGuid); }));
+        }), finalize(() => { this.tryFinalizeByGuid(myGuid, cachedInfos); }));
     }
     /**
     * Esecuzione di una POST HTTP
@@ -462,7 +493,7 @@ class HTTPService {
      * @param {string} url URL per cui controllare se ci sono chiamate in cache da invalidare
      */
     checkCacheInvalidation(url) {
-        let cache = JSON.parse(localStorage.getItem(this.localStorageHttpCacheKey));
+        let cache = this.localStorage.getLocalItem(this.localStorageHttpCacheKey);
         let tmp = /#cache(:?-(\d+))/gi.exec(url);
         let cacheTime = tmp ? tmp[2] : null;
         let normalizedUrl = url.replace("#cache" + (cacheTime ? "-" + cacheTime : ""), "").replace(this.BACKEND_URL, "");
@@ -483,14 +514,16 @@ class HTTPService {
             this.log(this.loc("Invlalidating cache element") + " " + k);
             delete cache[k];
         }
-        localStorage.setItem(this.localStorageHttpCacheKey, JSON.stringify(cache));
+        this.localStorage.setItem(this.localStorageHttpCacheKey, cache);
     }
     /**
      * Finalizzazione di una chiamata
      *
      * @param {string} guid GUID collegato alla chiamata appena terminata
+     * @param {boolean} persistCacheIfIdle Effettua il persist della cache HTTP solo se non ci sono altre chiamate in corso, per evitare
+     * che mi cambi sotto l'oggetto di cache mentre sto salvando le informazioni
      */
-    tryFinalizeByGuid(guid) {
+    async tryFinalizeByGuid(guid, cacheInfos) {
         this.log(this.loc("Finalizing call") + " " + guid + " " + this.loc("with status") + ": " + (this.callStatus[guid] ? this.loc('Success') : this.loc('Failure')));
         //Alla prima chiamata buona, significa che almeno il login ce l'ho. Posso mettermi in modalità redirectInProgress false
         //e riiniziare a valutare errori di javashit
@@ -498,6 +531,34 @@ class HTTPService {
             this.ExtensionsImpl.writeRedirectionStatus(false);
         //In ogni caso questa posso rimuoverla
         delete this.callStatus[guid];
+        // Se vengo da una chiamata che ha aggiornato la cache a timer o globale marco il fatto che quella cache dev'essere aggiornata
+        if (cacheInfos && cacheInfos.cache) {
+            this.PersistTimedCacheASAP = this.PersistTimedCacheASAP || !!cacheInfos.cacheTime;
+            this.PersistUntimedCacheASAP = this.PersistTimedCacheASAP || !cacheInfos.cacheTime;
+            this.log(this.loc("Marking cache to be persisted as soon as possible"));
+        }
+        // Se una delle due cache devono essere aggiornate e non ho nessuna chiamata in corso effettuo l'aggiornamento in base a quale delle due va aggiornata
+        // Alla fine di tutto marco come fatto
+        if ((this.PersistTimedCacheASAP || this.PersistUntimedCacheASAP) && Object.keys(this.callStatus).length == 0) {
+            var toCall = [];
+            let tmpKey = "";
+            if (this.PersistTimedCacheASAP) {
+                tmpKey = this.localStorageHttpTimedCacheKey;
+                toCall.push(this.localStorage.setItem(tmpKey, this.localStorage.getLocalItem(tmpKey)));
+            }
+            if (this.PersistUntimedCacheASAP) {
+                tmpKey = this.localStorageHttpCacheKey;
+                toCall.push(this.localStorage.setItem(tmpKey, this.localStorage.getLocalItem(tmpKey)));
+            }
+            this.log(this.loc("No more HTTP calls to be executed, entering idle state and persisting modified caches..."));
+            var ret = await forkJoin(toCall).toPromise();
+            if (ret)
+                this.log(this.loc("Caches succesfully persisted"));
+            else
+                this.log(this.loc("Errors persisting modified caches"));
+            this.PersistTimedCacheASAP = false;
+            this.PersistUntimedCacheASAP = false;
+        }
     }
     /**
      * Helper che dato un unico File o una lista di File crea un oggetto FormData che può essere inviato comodamente
@@ -680,7 +741,7 @@ class HTTPService {
      * @param {string} url URL su cui effettuare la chiamata
      * @param {HttpParams} params Parametri della chiamata (nulli in caso di POST)
      *
-     * @returns {{ finalUrl: string, cache: boolean, cacheKey: string, cacheTime: string, cacheItem: any }} Oggetto contenente le informazioni sulla cache per l'oggetto specificato
+     * @returns {CacheInfos} Oggetto contenente le informazioni sulla cache per l'oggetto specificato
      */
     tryGetCacheInformations(url, params) {
         let cachingKey = null, cacheTime = null, cache = null, item = null;
@@ -693,8 +754,8 @@ class HTTPService {
                 this.resetHttpUntimedCacheStorage();
             cachingKey = this.makeCacheKey(url, params);
             let cacheKey = cacheTime ? this.localStorageHttpTimedCacheKey : this.localStorageHttpCacheKey;
-            let cacheLs = localStorage.getItem(cacheKey);
-            let cache = cacheLs ? JSON.parse(cacheLs) : {};
+            let cacheLs = this.localStorage.getLocalItem(cacheKey);
+            let cache = cacheLs ? cacheLs : {};
             if (cache && cache[cachingKey] && !this.timedCacheItemExpired(cache[cachingKey])) {
                 // Se gestisco il tempo esatto della cache prima di restituire l'oggetto cachato lo ripulisco 
                 // dalle proprietà interne che gli ho aggiunto per controllarne la scadenza
@@ -703,22 +764,22 @@ class HTTPService {
                 item = cache[cachingKey];
             }
         }
-        return { finalUrl: url, cache: useCaching, cacheKey: cachingKey, cacheTime: cacheTime, cacheItem: item };
+        return new CacheInfos(url, useCaching, cachingKey, cacheTime, item);
     }
     /**
      * Inserisce un oggetto nella cache appropriata in base alle informazioni contenute nel parametro **cacheInfos**
      *
      * @param {T} item Oggetto da inserire nella cache
-     * @param {{ finalUrl: string, cache: boolean, cacheKey: string, cacheTime: string, cacheItem: any }} cacheInfos Informazioni sulla cache recuperate da una chiamata precedente a **tryGetCacheInformations**
+     * @param {CacheInfos} cacheInfos Informazioni sulla cache recuperate da una chiamata precedente a **tryGetCacheInformations**
      */
     cacheResponse(item, cacheInfos) {
         let cacheKey = cacheInfos.cacheTime ? this.localStorageHttpTimedCacheKey : this.localStorageHttpCacheKey;
-        let cacheLs = localStorage.getItem(cacheKey);
-        let cache = cacheLs ? JSON.parse(cacheLs) : {};
+        let cacheLs = this.localStorage.getLocalItem(cacheKey);
+        let cache = cacheLs ? cacheLs : {};
         cache[cacheInfos.cacheKey] = item;
         if (cacheInfos.cacheTime)
             cache[cacheInfos.cacheKey].__expire = dayjs().add(cacheInfos.cacheTime, "seconds");
-        localStorage.setItem(cacheKey, JSON.stringify(cache));
+        this.localStorage.setLocalItem(cacheKey, cache);
     }
     /**
      * Controlla se la cache per le chiamate senza expire time è scaduta
@@ -742,15 +803,15 @@ class HTTPService {
     /**
      * Ripulisce la cache e imposta la prossima scadenza ad adesso + **CLIENT_CACHE_DURATION_S** (token valorizzato in fase di configurazione dalla proprietà **clientCacheDurationS** della classe **HttpServiceModuleConfig**)
      */
-    resetHttpUntimedCacheStorage() {
-        localStorage.setItem(this.localStorageHttpCacheKey, JSON.stringify({}));
+    async resetHttpUntimedCacheStorage() {
+        await this.localStorage.setItem(this.localStorageHttpCacheKey, {}).toPromise();
         localStorage.setItem(this.localStorageHttpCacheExpireKey, JSON.stringify(dayjs().add(this.CLIENT_CACHE_DURATION_S ?? 3600, "second")));
     }
     /**
      * Ripulisce la cache delle chiamate con un tempo di expire definito
      */
-    resetHttpTimedCacheStorage() {
-        localStorage.setItem(this.localStorageHttpTimedCacheKey, JSON.stringify({}));
+    async resetHttpTimedCacheStorage() {
+        await this.localStorage.setItem(this.localStorageHttpTimedCacheKey, {}).toPromise();
     }
     /**
      * Genera una chiave per la cache delle chiamate in base ad URL e Parametri HTTP
@@ -762,8 +823,8 @@ class HTTPService {
      */
     makeCacheKey(url, params) {
         let authKeyPart = (this.me ? this.me.Idtenant : "") + (this.me && this.CACHE_BY_USER ? this.me.IdUser : "");
-        let paramsKeyPart = params && params.keys().length > 0 ? params.keys().reduce((prev, next) => prev + next + '=' + params.get(next), "") : "";
-        return authKeyPart + url + paramsKeyPart;
+        let paramsKeyPart = params && params.keys().length > 0 ? params.keys().reduce((prev, next) => prev + "," + next + '=' + params.get(next), "") : "";
+        return authKeyPart + "_" + url.substring(url.indexOf("api") + 4) + "?" + paramsKeyPart;
     }
     /**
      * Generazione GUID
@@ -800,7 +861,7 @@ class HTTPService {
         return Loc[message][this.LOCALE];
     }
 }
-HTTPService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: HTTPService, deps: [{ token: BACKEND_URL }, { token: HttpServiceExtensions }, { token: HTTP_INVALIDATION, optional: true }, { token: HTTP_LOCALE, optional: true }, { token: APP_NAME, optional: true }, { token: CLIENT_CACHE_DURATION_S, optional: true }, { token: CACHE_BY_USER, optional: true }, { token: DEBUG_MODE, optional: true }, { token: i2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+HTTPService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: HTTPService, deps: [{ token: BACKEND_URL }, { token: HttpServiceExtensions }, { token: HTTP_INVALIDATION, optional: true }, { token: HTTP_LOCALE, optional: true }, { token: APP_NAME, optional: true }, { token: CLIENT_CACHE_DURATION_S, optional: true }, { token: CACHE_BY_USER, optional: true }, { token: DEBUG_MODE, optional: true }, { token: i2.HttpClient }, { token: i3.PreferencesService }], target: i0.ɵɵFactoryTarget.Injectable });
 HTTPService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: HTTPService });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: HTTPService, decorators: [{
             type: Injectable
@@ -837,7 +898,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImpor
                 }, {
                     type: Inject,
                     args: [DEBUG_MODE]
-                }] }, { type: i2.HttpClient }]; } });
+                }] }, { type: i2.HttpClient }, { type: i3.PreferencesService }]; } });
 
 class HttpserviceModule {
     static forRoot(config) {