@esfaenza/httpservice 13.1.3 → 13.1.7

package/esm2020/lib/models/CacheInfos.mjs

@@ -0,0 +1,10 @@
+export class CacheInfos {
+    constructor(finalUrl, cache, cacheKey, cacheTime, cacheItem) {
+        this.finalUrl = finalUrl;
+        this.cache = cache;
+        this.cacheKey = cacheKey;
+        this.cacheTime = cacheTime;
+        this.cacheItem = cacheItem;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGVJbmZvcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2h0dHBzZXJ2aWNlL3NyYy9saWIvbW9kZWxzL0NhY2hlSW5mb3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLFVBQVU7SUFDbkIsWUFBbUIsUUFBZ0IsRUFBUyxLQUFjLEVBQVMsUUFBZ0IsRUFBUyxTQUFpQixFQUFTLFNBQWM7UUFBakgsYUFBUSxHQUFSLFFBQVEsQ0FBUTtRQUFTLFVBQUssR0FBTCxLQUFLLENBQVM7UUFBUyxhQUFRLEdBQVIsUUFBUSxDQUFRO1FBQVMsY0FBUyxHQUFULFNBQVMsQ0FBUTtRQUFTLGNBQVMsR0FBVCxTQUFTLENBQUs7SUFBSSxDQUFDO0NBQzVJIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIENhY2hlSW5mb3Mge1xyXG4gICAgY29uc3RydWN0b3IocHVibGljIGZpbmFsVXJsOiBzdHJpbmcsIHB1YmxpYyBjYWNoZTogYm9vbGVhbiwgcHVibGljIGNhY2hlS2V5OiBzdHJpbmcsIHB1YmxpYyBjYWNoZVRpbWU6IHN0cmluZywgcHVibGljIGNhY2hlSXRlbTogYW55KSB7IH1cclxufSJdfQ==

package/fesm2015/esfaenza-httpservice.mjs

@@ -4,7 +4,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
@@ -134,9 +135,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;
+    }
+}
+
 /**
  * Servizio utilizzato per effettuare qualsiasi tipo di chiamata HTTP dall'applicazione, gestisce errori e cache delle risposte nativamente e ne può essere
  * esteso/modificato il comportamento implementando la classe di "hook" **IHttpServiceExtensions** e registrandola nel provider della classe **HttpServiceExtensions**
@@ -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) {
         var _a, _b;
         this.BACKEND_URL = BACKEND_URL;
         this.EXTENSION_CLASS = EXTENSION_CLASS;
@@ -156,34 +172,51 @@ 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 = ((_a = this.APP_NAME) !== null && _a !== void 0 ? _a : "APP").replace(/\s/g, '_') + "_HttpCache";
         this.localStorageHttpTimedCacheKey = ((_b = this.APP_NAME) !== null && _b !== void 0 ? _b : "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
+     */
+    adjustOldStorageSystem() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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) : {};
+            yield 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"
      *
@@ -215,7 +248,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"
@@ -250,7 +283,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
@@ -465,7 +498,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, "");
@@ -486,21 +519,53 @@ 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) {
-        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
-        if (this.callStatus[guid] && this.ExtensionsImpl.readRedirectionStatus())
-            this.ExtensionsImpl.writeRedirectionStatus(false);
-        //In ogni caso questa posso rimuoverla
-        delete this.callStatus[guid];
+    tryFinalizeByGuid(guid, cacheInfos) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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
+            if (this.callStatus[guid] && this.ExtensionsImpl.readRedirectionStatus())
+                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 = yield 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
@@ -687,7 +752,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;
@@ -700,8 +765,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
@@ -710,22 +775,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
@@ -751,14 +816,18 @@ class HTTPService {
      */
     resetHttpUntimedCacheStorage() {
         var _a;
-        localStorage.setItem(this.localStorageHttpCacheKey, JSON.stringify({}));
-        localStorage.setItem(this.localStorageHttpCacheExpireKey, JSON.stringify(dayjs().add((_a = this.CLIENT_CACHE_DURATION_S) !== null && _a !== void 0 ? _a : 3600, "second")));
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.localStorage.setItem(this.localStorageHttpCacheKey, {}).toPromise();
+            localStorage.setItem(this.localStorageHttpCacheExpireKey, JSON.stringify(dayjs().add((_a = this.CLIENT_CACHE_DURATION_S) !== null && _a !== void 0 ? _a : 3600, "second")));
+        });
     }
     /**
      * Ripulisce la cache delle chiamate con un tempo di expire definito
      */
     resetHttpTimedCacheStorage() {
-        localStorage.setItem(this.localStorageHttpTimedCacheKey, JSON.stringify({}));
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.localStorage.setItem(this.localStorageHttpTimedCacheKey, {}).toPromise();
+        });
     }
     /**
      * Genera una chiave per la cache delle chiamate in base ad URL e Parametri HTTP
@@ -770,8 +839,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
@@ -808,7 +877,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
@@ -846,7 +915,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 {