@esfaenza/httpservice 11.2.30 → 11.2.34

package/bundles/esfaenza-httpservice.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/common/http'), require('@angular/core'), require('rxjs/operators'), require('rxjs')) :
-    typeof define === 'function' && define.amd ? define('@esfaenza/httpservice', ['exports', '@angular/common/http', '@angular/core', 'rxjs/operators', 'rxjs'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.esfaenza = global.esfaenza || {}, global.esfaenza.httpservice = {}), global.ng.common.http, global.ng.core, global.rxjs.operators, global.rxjs));
-})(this, (function (exports, http, core, operators, rxjs) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/common/http'), require('@angular/core'), require('@esfaenza/preferences'), require('rxjs/operators'), require('rxjs')) :
+    typeof define === 'function' && define.amd ? define('@esfaenza/httpservice', ['exports', '@angular/common/http', '@angular/core', '@esfaenza/preferences', 'rxjs/operators', 'rxjs'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.esfaenza = global.esfaenza || {}, global.esfaenza.httpservice = {}), global.ng.common.http, global.ng.core, global.preferences, global.rxjs.operators, global.rxjs));
+})(this, (function (exports, http, core, preferences, operators, rxjs) { 'use strict';
 
     /*! *****************************************************************************
     Copyright (c) Microsoft Corporation.
@@ -444,9 +444,25 @@
         "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...)" },
     };
 
+    var CacheInfos = /** @class */ (function () {
+        function CacheInfos(finalUrl, cache, cacheKey, cacheTime, cacheItem) {
+            this.finalUrl = finalUrl;
+            this.cache = cache;
+            this.cacheKey = cacheKey;
+            this.cacheTime = cacheTime;
+            this.cacheItem = cacheItem;
+        }
+        return CacheInfos;
+    }());
+
     /**
      * 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**
@@ -455,7 +471,7 @@
         /**
          * @ignore
          */
-        function HTTPService(BACKEND_URL, EXTENSION_CLASS, HTTP_INVALIDATION, LOCALE, APP_NAME, CLIENT_CACHE_DURATION_S, CACHE_BY_USER, DEBUG_MODE, http) {
+        function HTTPService(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;
@@ -466,34 +482,60 @@
             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
+         */
+        HTTPService.prototype.adjustOldStorageSystem = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var lsTimed, lsUntimed;
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
+                        case 0:
+                            lsTimed = localStorage.getItem(this.localStorageHttpTimedCacheKey);
+                            lsUntimed = localStorage.getItem(this.localStorageHttpCacheKey);
+                            if (!lsTimed && !lsUntimed)
+                                return [2 /*return*/];
+                            localStorage.removeItem(this.localStorageHttpTimedCacheKey);
+                            localStorage.removeItem(this.localStorageHttpCacheKey);
+                            lsTimed = lsTimed ? JSON.parse(lsTimed) : {};
+                            lsUntimed = lsUntimed ? JSON.parse(lsUntimed) : {};
+                            return [4 /*yield*/, rxjs.forkJoin([
+                                    this.localStorage.store(this.localStorageHttpTimedCacheKey, lsTimed),
+                                    this.localStorage.store(this.localStorageHttpCacheKey, lsUntimed)
+                                ]).toPromise()];
+                        case 1:
+                            _e.sent();
+                            this.log(this.loc("Converted old storage system to new one"));
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
         /**
          * Esecuzione di una GET HTTP con eventualmente la gestione della cache qualora la chiamata termini con la convenzione "#cache"
          *
@@ -530,7 +572,7 @@
                 if (errorCallback)
                     errorCallback();
                 return !succesfulResultMandatory ? rxjs.throwError(err) : _this.registerErrorAndReturnEmptyObservable(err, myGuid);
-            }), operators.finalize(function () { _this.tryFinalizeByGuid(myGuid); }));
+            }), operators.finalize(function () { _this.tryFinalizeByGuid(myGuid, cachedInfos); }));
         };
         /**
          * Esecuzione di una GET HTTP con eventualmente la gestione della cache qualora la chiamata termini con la convenzione "#cache"
@@ -571,26 +613,78 @@
                 if (errorCallback)
                     errorCallback();
                 return !succesfulResultMandatory ? rxjs.throwError(err) : _this.registerErrorAndReturnEmptyObservable(err, myGuid);
-            }), operators.finalize(function () { _this.tryFinalizeByGuid(myGuid); }));
+            }), operators.finalize(function () { _this.tryFinalizeByGuid(myGuid, cachedInfos); }));
         };
         /**
-        * Esecuzione di una POST HTTP. Tipizzata sia in Input che in Output
-        *
+        * Esecuzione di una POST HTTP
         *
         * @param {string} url URL su cui effettuare la chiamata
         * @param {any} bodyData DTO per la chiamata
+        * @param {HttpParams} params Parametri della chiamata
+        * @param {string} transaction Codice transazione collegato a questa chiamata. Viene inserito nell'Header "X-TX-ID" e lato Backend dovrà essere gestito di conseguenza
+        * @param {boolean} succesfulResultMandatory Indica che questa chiamata deve assolutamente andare bene. In caso contrario viene fisicamente fatto il throw che può essere
+        * raccolto da chi usa la libreria nella pipe "onError" dell'Observable restituito ed essere gestito in maniera non standard
+        *
+        * @returns {Observable<T>} Observable che contiene il risultato della chiamata
+        */
+        HTTPService.prototype.post = function (url, bodyData, params, transaction, succesfulResultMandatory) {
+            var _this = this;
+            if (params === void 0) { params = null; }
+            if (transaction === void 0) { transaction = ""; }
+            if (succesfulResultMandatory === void 0) { succesfulResultMandatory = true; }
+            var myGuid = this.defaultStartCall(url);
+            var httpCall = this.http.post(url, bodyData, { headers: this.getHeaders(transaction), params: params });
+            return httpCall.pipe(operators.map(function (res) {
+                var responseItem = res;
+                return responseItem;
+            }), operators.catchError(function (err, caught) {
+                return !succesfulResultMandatory ? rxjs.throwError(err) : _this.registerErrorAndReturnEmptyObservable(err, myGuid);
+            }), operators.finalize(function () { _this.tryFinalizeByGuid(myGuid); }));
+        };
+        /**
+        * Esecuzione di una DELETE HTTP
+        *
+        * @param {string} url URL su cui effettuare la chiamata
+        * @param {HttpParams} params Parametri della chiamata
         * @param {string} transaction Codice transazione collegato a questa chiamata. Viene inserito nell'Header "X-TX-ID" e lato Backend dovrà essere gestito di conseguenza
         * @param {boolean} succesfulResultMandatory Indica che questa chiamata deve assolutamente andare bene. In caso contrario viene fisicamente fatto il throw che può essere
         * raccolto da chi usa la libreria nella pipe "onError" dell'Observable restituito ed essere gestito in maniera non standard
         *
         * @returns {Observable<T>} Observable che contiene il risultato della chiamata
         */
-        HTTPService.prototype.post = function (url, bodyData, transaction, succesfulResultMandatory) {
+        HTTPService.prototype.delete = function (url, params, transaction, succesfulResultMandatory) {
+            var _this = this;
+            if (params === void 0) { params = null; }
+            if (transaction === void 0) { transaction = ""; }
+            if (succesfulResultMandatory === void 0) { succesfulResultMandatory = true; }
+            var myGuid = this.defaultStartCall(url);
+            var httpCall = this.http.delete(url, { headers: this.getHeaders(transaction), params: params });
+            return httpCall.pipe(operators.map(function (res) {
+                var responseItem = res;
+                return responseItem;
+            }), operators.catchError(function (err, caught) {
+                return !succesfulResultMandatory ? rxjs.throwError(err) : _this.registerErrorAndReturnEmptyObservable(err, myGuid);
+            }), operators.finalize(function () { _this.tryFinalizeByGuid(myGuid); }));
+        };
+        /**
+         * Esecuzione di una PUT HTTP
+         *
+         * @param {string} url URL su cui effettuare la chiamata
+         * @param {any} bodyData DTO per la chiamata
+         * @param {HttpParams} params Parametri della chiamata
+         * @param {string} transaction Codice transazione collegato a questa chiamata. Viene inserito nell'Header "X-TX-ID" e lato Backend dovrà essere gestito di conseguenza
+         * @param {boolean} succesfulResultMandatory Indica che questa chiamata deve assolutamente andare bene. In caso contrario viene fisicamente fatto il throw che può essere
+         * raccolto da chi usa la libreria nella pipe "onError" dell'Observable restituito ed essere gestito in maniera non standard
+         *
+         * @returns {Observable<T>} Observable che contiene il risultato della chiamata
+         */
+        HTTPService.prototype.put = function (url, bodyData, params, transaction, succesfulResultMandatory) {
             var _this = this;
+            if (params === void 0) { params = null; }
             if (transaction === void 0) { transaction = ""; }
             if (succesfulResultMandatory === void 0) { succesfulResultMandatory = true; }
             var myGuid = this.defaultStartCall(url);
-            var httpCall = this.http.post(url, bodyData, { headers: this.getHeaders(transaction) });
+            var httpCall = this.http.put(url, bodyData, { headers: this.getHeaders(transaction), params: params });
             return httpCall.pipe(operators.map(function (res) {
                 var responseItem = res;
                 return responseItem;
@@ -758,7 +852,7 @@
          */
         HTTPService.prototype.checkCacheInvalidation = function (url) {
             var _this = this;
-            var cache = JSON.parse(localStorage.getItem(this.localStorageHttpCacheKey));
+            var cache = this.localStorage.retrieveLocal(this.localStorageHttpCacheKey);
             var tmp = /#cache(:?-(\d+))/gi.exec(url);
             var cacheTime = tmp ? tmp[2] : null;
             var normalizedUrl = url.replace("#cache" + (cacheTime ? "-" + cacheTime : ""), "").replace(this.BACKEND_URL, "");
@@ -779,21 +873,60 @@
                 this.log(this.loc("Invlalidating cache element") + " " + k);
                 delete cache[k];
             }
-            localStorage.setItem(this.localStorageHttpCacheKey, JSON.stringify(cache));
+            this.localStorage.storeLocal(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
          */
-        HTTPService.prototype.tryFinalizeByGuid = function (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];
+        HTTPService.prototype.tryFinalizeByGuid = function (guid, cacheInfos) {
+            return __awaiter(this, void 0, void 0, function () {
+                var toCall, tmpKey, ret;
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
+                        case 0:
+                            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"));
+                            }
+                            if (!((this.PersistTimedCacheASAP || this.PersistUntimedCacheASAP) && Object.keys(this.callStatus).length == 0)) return [3 /*break*/, 2];
+                            toCall = [];
+                            tmpKey = "";
+                            if (this.PersistTimedCacheASAP) {
+                                tmpKey = this.localStorageHttpTimedCacheKey;
+                                toCall.push(this.localStorage.store(tmpKey, this.localStorage.retrieveLocal(tmpKey)));
+                            }
+                            if (this.PersistUntimedCacheASAP) {
+                                tmpKey = this.localStorageHttpCacheKey;
+                                toCall.push(this.localStorage.store(tmpKey, this.localStorage.retrieveLocal(tmpKey)));
+                            }
+                            this.log(this.loc("No more HTTP calls to be executed, entering idle state and persisting modified caches..."));
+                            return [4 /*yield*/, rxjs.forkJoin(toCall).toPromise()];
+                        case 1:
+                            ret = _e.sent();
+                            if (ret)
+                                this.log(this.loc("Caches succesfully persisted"));
+                            else
+                                this.log(this.loc("Errors persisting modified caches"));
+                            this.PersistTimedCacheASAP = false;
+                            this.PersistUntimedCacheASAP = false;
+                            _e.label = 2;
+                        case 2: return [2 /*return*/];
+                    }
+                });
+            });
         };
         /**
          * Helper che dato un unico File o una lista di File crea un oggetto FormData che può essere inviato comodamente
@@ -997,7 +1130,7 @@
          * @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
          */
         HTTPService.prototype.tryGetCacheInformations = function (url, params) {
             var cachingKey = null, cacheTime = null, cache = null, item = null;
@@ -1010,8 +1143,8 @@
                     this.resetHttpUntimedCacheStorage();
                 cachingKey = this.makeCacheKey(url, params);
                 var cacheKey = cacheTime ? this.localStorageHttpTimedCacheKey : this.localStorageHttpCacheKey;
-                var cacheLs = localStorage.getItem(cacheKey);
-                var cache_1 = cacheLs ? JSON.parse(cacheLs) : {};
+                var cacheLs = this.localStorage.retrieveLocal(cacheKey);
+                var cache_1 = cacheLs ? cacheLs : {};
                 if (cache_1 && cache_1[cachingKey] && !this.timedCacheItemExpired(cache_1[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
@@ -1020,22 +1153,22 @@
                     item = cache_1[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**
          */
         HTTPService.prototype.cacheResponse = function (item, cacheInfos) {
             var cacheKey = cacheInfos.cacheTime ? this.localStorageHttpTimedCacheKey : this.localStorageHttpCacheKey;
-            var cacheLs = localStorage.getItem(cacheKey);
-            var cache = cacheLs ? JSON.parse(cacheLs) : {};
+            var cacheLs = this.localStorage.retrieveLocal(cacheKey);
+            var 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.storeLocal(cacheKey, cache);
         };
         /**
          * Controlla se la cache per le chiamate senza expire time è scaduta
@@ -1061,14 +1194,14 @@
          */
         HTTPService.prototype.resetHttpUntimedCacheStorage = function () {
             var _a;
-            localStorage.setItem(this.localStorageHttpCacheKey, JSON.stringify({}));
+            this.localStorage.store(this.localStorageHttpCacheKey, {}).subscribe();
             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
          */
         HTTPService.prototype.resetHttpTimedCacheStorage = function () {
-            localStorage.setItem(this.localStorageHttpTimedCacheKey, JSON.stringify({}));
+            this.localStorage.store(this.localStorageHttpTimedCacheKey, {});
         };
         /**
          * Genera una chiave per la cache delle chiamate in base ad URL e Parametri HTTP
@@ -1080,8 +1213,8 @@
          */
         HTTPService.prototype.makeCacheKey = function (url, params) {
             var authKeyPart = (this.me ? this.me.Idtenant : "") + (this.me && this.CACHE_BY_USER ? this.me.IdUser : "");
-            var paramsKeyPart = params && params.keys().length > 0 ? params.keys().reduce(function (prev, next) { return prev + next + '=' + params.get(next); }, "") : "";
-            return authKeyPart + url + paramsKeyPart;
+            var paramsKeyPart = params && params.keys().length > 0 ? params.keys().reduce(function (prev, next) { return prev + "," + next + '=' + params.get(next); }, "") : "";
+            return authKeyPart + "_" + url.substring(url.indexOf("api") + 4) + "?" + paramsKeyPart;
         };
         /**
          * Generazione GUID
@@ -1131,7 +1264,8 @@
         { type: undefined, decorators: [{ type: core.Optional }, { type: core.Inject, args: [CLIENT_CACHE_DURATION_S,] }] },
         { type: Boolean, decorators: [{ type: core.Optional }, { type: core.Inject, args: [CACHE_BY_USER,] }] },
         { type: Boolean, decorators: [{ type: core.Optional }, { type: core.Inject, args: [DEBUG_MODE,] }] },
-        { type: http.HttpClient }
+        { type: http.HttpClient },
+        { type: preferences.PreferencesService }
     ]; };
 
     var HttpserviceModule = /** @class */ (function () {