@esfaenza/httpservice 16.2.27 → 17.3.0

package/fesm2022/esfaenza-httpservice.mjs

@@ -8,983 +8,983 @@ import * as i2 from '@esfaenza/localizations';
 import * as i4 from '@esfaenza/preferences';
 import * as i5 from '@esfaenza/extensions';
 
-/**
- * Dizionario di invalidazioni delle chiamate HTTP
- */
-const HTTP_INVALIDATION = new InjectionToken('HTTP_INVALIDATION');
-/**
- * Durata della cache lato libreria dopo il quale la cache verrà ripulita
- */
-const CLIENT_CACHE_DURATION_S = new InjectionToken('CLIENT_CACHE_DURATION_S');
-/**
- * Nome dell'APP utilizzato per creare le chiavi delle cache specifiche per l'applicazione corrente
- */
-const APP_NAME = new InjectionToken('APP_NAME');
-/**
- * Indica se utilizzare l'identificativo utente nella cache
- */
-const CACHE_BY_USER = new InjectionToken('CACHE_BY_USER');
-/**
- * Indica se fare log nella console ad ogni azione significativa
- */
+/**
+ * Dizionario di invalidazioni delle chiamate HTTP
+ */
+const HTTP_INVALIDATION = new InjectionToken('HTTP_INVALIDATION');
+/**
+ * Durata della cache lato libreria dopo il quale la cache verrà ripulita
+ */
+const CLIENT_CACHE_DURATION_S = new InjectionToken('CLIENT_CACHE_DURATION_S');
+/**
+ * Nome dell'APP utilizzato per creare le chiavi delle cache specifiche per l'applicazione corrente
+ */
+const APP_NAME = new InjectionToken('APP_NAME');
+/**
+ * Indica se utilizzare l'identificativo utente nella cache
+ */
+const CACHE_BY_USER = new InjectionToken('CACHE_BY_USER');
+/**
+ * Indica se fare log nella console ad ogni azione significativa
+ */
 const HTTP_DEBUG_MODE = new InjectionToken('DEBUG_MODE');
 
-/**
- * Classe d'estensione che permette di modificare il comportamento della libreria negli hook definiti da interfaccia, in modo da poterla adattare
- * con un certo grado di customizzazione a qualsiasi struttura di frontend
- */
-class HttpServiceExtensions {
-    /**
-     * Hook per recuperare l'access token con cui effettuare le chiamate HTTP
-     */
-    retrieveAccessToken() {
-        return "";
-    }
-    /**
-     * Hook per recuperare l'Identity corrente in un oggetto generico con le informazioni di User e Tenant
-     */
-    retrieveIdentity() {
-        return null;
-    }
-    /**
-     * Hook per leggere dallo stato dell'applicazione se stiamo già venendo ridirezionati al login, in modo da non tentare di effettuare
-     * N redirect contemporaneamente qualora molte API fallissero allo stesso tempo nell'autenticazione
-     */
-    readRedirectingToLogin() {
-        return false;
-    }
-    /**
-     * Hook per scrivere nello stato dell'applicazione se stiamo effettuando un redirect al login o meno
-     */
-    writeRedirectingToLogin(status) {
-    }
-    /**
-     * Hook per effettuare il redirect al login
-     */
-    redirectToLogin() {
-    }
-    /**
-     * Hook per leggere dallo stato dell'applicazione se stiamo già gestendo un errore, in modo da non tentare di gestire
-     * N errori contemporaneamente qualora molte API fallissero allo stesso tempo
-     */
-    readHandlingErrorStatus() {
-        return false;
-    }
-    /**
-     * Hook per scrivere nello stato dell'applicazione se stiamo gestendo un errore o meno
-     */
-    writeHandlingErrorStatus(status) {
-    }
-    /**
-     * Hook per leggere dallo stato dell'applicazione se stiamo già gestendo un redirect, in modo da non tentare di gestire
-     * N redirect contemporaneamente qualora molte API lo richiedessero allo stesso tempo
-     */
-    readRedirectionStatus() {
-        return false;
-    }
-    /**
-     * Hook per scrivere nello stato dell'applicazione se stiamo gestendo un redirect o meno
-     */
-    writeRedirectionStatus(status) {
-    }
-    /**
-     * Hook per indicare se l'applicazione può gestire eccezioni del tipo "NotConfigured" (444). Qualora l'applicazione che lo implementa dichiari di gestirle verrà chiamata
-     * la funzione **handleBlockingException** per ognuno di questi errori
-     */
-    handleNotConfiguredException() {
-        return false;
-    }
-    /**
-     * Hook per la gestione di un qualsiasi errore bloccante per l'operazione attuale, ma non fatale (Generalmente gestibile da dialog di avviso)
-     */
-    handleBlockingException(status, text) {
-        console.error("ESHttpError Blocking Exception " + status + " " + text);
-    }
-    /**
-     * Hook per la gestione di un qualsiasi errore fatale (Generalmente gestibile tramite navigazione a una pagina di errore custom per l'applicativo)
-     */
-    handleException(status, text) {
-        console.error("ESHttpError " + status + " " + text);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HttpServiceExtensions, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HttpServiceExtensions, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HttpServiceExtensions, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
+/**
+ * Classe d'estensione che permette di modificare il comportamento della libreria negli hook definiti da interfaccia, in modo da poterla adattare
+ * con un certo grado di customizzazione a qualsiasi struttura di frontend
+ */
+class HttpServiceExtensions {
+    /**
+     * Hook per recuperare l'access token con cui effettuare le chiamate HTTP
+     */
+    retrieveAccessToken() {
+        return "";
+    }
+    /**
+     * Hook per recuperare l'Identity corrente in un oggetto generico con le informazioni di User e Tenant
+     */
+    retrieveIdentity() {
+        return null;
+    }
+    /**
+     * Hook per leggere dallo stato dell'applicazione se stiamo già venendo ridirezionati al login, in modo da non tentare di effettuare
+     * N redirect contemporaneamente qualora molte API fallissero allo stesso tempo nell'autenticazione
+     */
+    readRedirectingToLogin() {
+        return false;
+    }
+    /**
+     * Hook per scrivere nello stato dell'applicazione se stiamo effettuando un redirect al login o meno
+     */
+    writeRedirectingToLogin(status) {
+    }
+    /**
+     * Hook per effettuare il redirect al login
+     */
+    redirectToLogin() {
+    }
+    /**
+     * Hook per leggere dallo stato dell'applicazione se stiamo già gestendo un errore, in modo da non tentare di gestire
+     * N errori contemporaneamente qualora molte API fallissero allo stesso tempo
+     */
+    readHandlingErrorStatus() {
+        return false;
+    }
+    /**
+     * Hook per scrivere nello stato dell'applicazione se stiamo gestendo un errore o meno
+     */
+    writeHandlingErrorStatus(status) {
+    }
+    /**
+     * Hook per leggere dallo stato dell'applicazione se stiamo già gestendo un redirect, in modo da non tentare di gestire
+     * N redirect contemporaneamente qualora molte API lo richiedessero allo stesso tempo
+     */
+    readRedirectionStatus() {
+        return false;
+    }
+    /**
+     * Hook per scrivere nello stato dell'applicazione se stiamo gestendo un redirect o meno
+     */
+    writeRedirectionStatus(status) {
+    }
+    /**
+     * Hook per indicare se l'applicazione può gestire eccezioni del tipo "NotConfigured" (444). Qualora l'applicazione che lo implementa dichiari di gestirle verrà chiamata
+     * la funzione **handleBlockingException** per ognuno di questi errori
+     */
+    handleNotConfiguredException() {
+        return false;
+    }
+    /**
+     * Hook per la gestione di un qualsiasi errore bloccante per l'operazione attuale, ma non fatale (Generalmente gestibile da dialog di avviso)
+     */
+    handleBlockingException(status, text) {
+        console.error("ESHttpError Blocking Exception " + status + " " + text);
+    }
+    /**
+     * Hook per la gestione di un qualsiasi errore fatale (Generalmente gestibile tramite navigazione a una pagina di errore custom per l'applicativo)
+     */
+    handleException(status, text) {
+        console.error("ESHttpError " + status + " " + text);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HttpServiceExtensions, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HttpServiceExtensions, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HttpServiceExtensions, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
         }] });
 
-class CacheInfos {
-    constructor(finalUrl, cache, cacheKey, cacheTime, cacheItem) {
-        this.finalUrl = finalUrl;
-        this.cache = cache;
-        this.cacheKey = cacheKey;
-        this.cacheTime = cacheTime;
-        this.cacheItem = cacheItem;
-    }
+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
- * esteso/modificato il comportamento implementando la classe di "hook" **IHttpServiceExtensions** e registrandola nel provider della classe **HttpServiceExtensions**
- */
-class HTTPService {
-    /**
-     * @ignore
-     */
-    constructor(EXTENSION_CLASS, HTTP_INVALIDATION, CLIENT_CACHE_DURATION_S, CACHE_BY_USER, HTTP_DEBUG_MODE, bc, http, localStorage, hash, utisExts) {
-        this.EXTENSION_CLASS = EXTENSION_CLASS;
-        this.HTTP_INVALIDATION = HTTP_INVALIDATION;
-        this.CLIENT_CACHE_DURATION_S = CLIENT_CACHE_DURATION_S;
-        this.CACHE_BY_USER = CACHE_BY_USER;
-        this.HTTP_DEBUG_MODE = HTTP_DEBUG_MODE;
-        this.bc = bc;
-        this.http = http;
-        this.localStorage = localStorage;
-        this.hash = hash;
-        this.utisExts = utisExts;
-        /** 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 */
-        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 */
-        this.localStorageHttpTimedCacheKey = null;
-        /** 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** */
-        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;
-        /** Subject emesso quando il servizio http si stabilizza, cioè quando non c'è nessuna chiamata pending o in corso da qualche istante */
-        this.Stabilized = new Subject();
-        /** Lista delle ultime 3 chiamate completate con successo in ordine di completamento (in posizione 0 c'è l'ultima completata eccetera...) */
-        this.LastThreeCompletedCalls = [];
-        this.CacheInitialized = false;
-        /*****************************************************************************************************************************************
-         ***************************************************** TRANSACTION HELPERS ***************************************************************
-         *****************************************************************************************************************************************/
-        this.GET_Trans_BeginTrans = "/api/Trans/BeginTrans";
-        this.GET_Trans_CheckExecution = "/api/Trans/CheckExecution";
-        this.GET_Trans_EndTrans = "/api/Trans/EndTrans";
-        this.ExtensionsImpl = this.EXTENSION_CLASS || new HttpServiceExtensions();
-    }
-    setAppConfig(myconfig) {
-        this.localStorageHttpCacheKey = (myconfig.AppData.ModuleDescription).replace(/\s/g, '_') + "_HttpCache";
-        this.localStorageHttpTimedCacheKey = (myconfig.AppData.ModuleDescription).replace(/\s/g, '_') + "_HttpTimedCache";
-        this.localStorageHttpCacheExpireKey = this.localStorageHttpCacheKey + "_Expire";
-        this.adjustOldStorageSystem();
-        this.CacheInitialized = true;
-    }
-    /**
-     * 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"
-     *
-     * @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
-     * @param {Function} errorCallback Callback chiamato in caso di errore
-     *
-     * @returns {Observable<T>} Observable che contiene il risultato della chiamata
-     */
-    get(url, params = null, transaction = "", succesfulResultMandatory = true, errorCallback = null) {
-        return forkJoin({
-            myGuid: from([this.defaultStartCall(url)]),
-            locale: this.bc.Locale.pipe(first())
-        }).pipe(concatMap((ret) => {
-            let cachedInfos = this.tryGetCacheInformations(url, params);
-            if (cachedInfos.cache && cachedInfos.cacheItem) {
-                this.log(this.loc("Result for") + " " + url + " " + this.loc("retrieved from cache"));
-                return of(cachedInfos.cacheItem).pipe(delay(0), finalize(() => { this.tryFinalizeByGuid(ret.myGuid); }));
-            }
-            var httpCall = this.http.get(cachedInfos.finalUrl, { headers: this.getHeaders(ret.locale, transaction), params: params });
-            return httpCall.pipe(map((res) => {
-                let responseItem = res;
-                if (cachedInfos.cache) {
-                    this.cacheResponse(this.utisExts.deepClone(responseItem), cachedInfos);
-                    this.log(this.loc("Cached result for") + " " + url);
-                }
-                return responseItem;
-            }), catchError((err, caught) => {
-                if (errorCallback)
-                    errorCallback();
-                return !succesfulResultMandatory ? throwError(err) : this.registerErrorAndReturnEmptyObservable(err, ret.myGuid);
-            }), finalize(() => { this.tryFinalizeByGuid(ret.myGuid, cachedInfos); }));
-        }));
-    }
-    /**
-     * Esecuzione di una GET HTTP con eventualmente la gestione della cache qualora la chiamata termini con la convenzione "#cache"
-     *
-     * Caso specifico di chiamata che deve restituire un Blob o un ArrayBuffer nativo da elaborare
-     *
-     * @param {string} url URL su cui effettuare la chiamata
-     * @param {HttpParams} params Parametri della chiamata
-     * @param {"arraybuffer"| "blob"} type Tipo di ritorno richiesto
-     * @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
-     * @param {Function} errorCallback Callback chiamato in caso di errore
-     *
-     * @returns {Observable<Blob | ArrayBuffer>} Observable che contiene il risultato della chiamata
-     */
-    getRaw(url, params = null, type = "arraybuffer", transaction = "", succesfulResultMandatory = true, errorCallback = null) {
-        return forkJoin({
-            myGuid: from([this.defaultStartCall(url)]),
-            locale: this.bc.Locale.pipe(first())
-        }).pipe(concatMap((ret) => {
-            let cachedInfos = this.tryGetCacheInformations(url, params);
-            if (cachedInfos.cache && cachedInfos.cacheItem) {
-                this.log(this.loc("Result for") + " " + url + " " + this.loc("retrieved from cache"));
-                return of(cachedInfos.cacheItem).pipe(delay(0), finalize(() => { this.tryFinalizeByGuid(ret.myGuid); }));
-            }
-            var httpCall = this.http.get(cachedInfos.finalUrl, { responseType: type, headers: this.getHeaders(ret.locale, transaction), params: params });
-            return httpCall.pipe(map((blob) => {
-                if (cachedInfos.cache) {
-                    this.cacheResponse(blob, cachedInfos);
-                    this.log(this.loc("Cached result for") + " " + url);
-                }
-                return blob;
-            }), catchError((err, caught) => {
-                if (errorCallback)
-                    errorCallback();
-                return !succesfulResultMandatory ? throwError(err) : this.registerErrorAndReturnEmptyObservable(err, ret.myGuid);
-            }), finalize(() => { this.tryFinalizeByGuid(ret.myGuid, cachedInfos); }));
-        }));
-    }
-    /**
-    * 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
-    */
-    post(url, bodyData, params = null, transaction = "", succesfulResultMandatory = true) {
-        return forkJoin({
-            myGuid: from([this.defaultStartCall(url)]),
-            locale: this.bc.Locale.pipe(first())
-        }).pipe(concatMap((ret) => {
-            // Se è una ricerca, shallow copy e rimuovo gli "items" per evitare di farli andare su e giù al backend
-            if (!!bodyData?.items && !!bodyData?.page) {
-                bodyData = { ...bodyData };
-                delete bodyData.items;
-            }
-            var httpCall = this.http.post(url, bodyData, { headers: this.getHeaders(ret.locale, transaction), params: params });
-            return httpCall.pipe(catchError((err, _) => {
-                return !succesfulResultMandatory ? throwError(err) : this.registerErrorAndReturnEmptyObservable(err, ret.myGuid);
-            }), finalize(() => { this.tryFinalizeByGuid(ret.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
-    */
-    delete(url, params = null, transaction = "", succesfulResultMandatory = true) {
-        return forkJoin({
-            myGuid: from([this.defaultStartCall(url)]),
-            locale: this.bc.Locale.pipe(first())
-        }).pipe(concatMap((ret) => {
-            var httpCall = this.http.delete(url, { headers: this.getHeaders(ret.locale, transaction), params: params });
-            return httpCall.pipe(catchError((err, caught) => {
-                return !succesfulResultMandatory ? throwError(err) : this.registerErrorAndReturnEmptyObservable(err, ret.myGuid);
-            }), finalize(() => { this.tryFinalizeByGuid(ret.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
-     */
-    put(url, bodyData, params = null, transaction = "", succesfulResultMandatory = true) {
-        return forkJoin({
-            myGuid: from([this.defaultStartCall(url)]),
-            locale: this.bc.Locale.pipe(first())
-        }).pipe(concatMap((ret) => {
-            var httpCall = this.http.put(url, bodyData, { headers: this.getHeaders(ret.locale, transaction), params: params });
-            return httpCall.pipe(catchError((err, caught) => {
-                return !succesfulResultMandatory ? throwError(err) : this.registerErrorAndReturnEmptyObservable(err, ret.myGuid);
-            }), finalize(() => { this.tryFinalizeByGuid(ret.myGuid); }));
-        }));
-    }
-    /**
-     * Esecuzione di una POST HTTP
-     *
-     * Casistica particolare in cui bisogna anche inviare dei File
-     *
-     * @param {string} url URL su cui effettuare la chiamata
-     * @param {any} bodyData DTO per la chiamata
-     * @param {File[] | File} fileArrayOrFile Singolo file o lista di file da inviare. Il tipo **File** è quello nativo del Javascript
-     *
-     * @returns {Observable<T>} Observable che contiene il risultato della chiamata
-     */
-    postwithFiles(url, bodyData, fileArrayOrFile, params = null, succesfulResultMandatory = true, onError) {
-        return forkJoin({
-            myGuid: from([this.defaultStartCall(url)]),
-            locale: this.bc.Locale.pipe(first())
-        }).pipe(concatMap((ret) => {
-            var formData = this.getFilesFormData(fileArrayOrFile);
-            formData.append("body", JSON.stringify(bodyData));
-            var httpCall = this.http.post(url, formData, { params: params, headers: this.getHeaders(ret.locale, null, true, null, null) });
-            return httpCall.pipe(catchError((err, caught) => {
-                onError?.();
-                return !succesfulResultMandatory ? throwError(err) : this.registerErrorAndReturnEmptyObservable(err, ret.myGuid);
-            }), finalize(() => { this.tryFinalizeByGuid(ret.myGuid); }));
-        }));
-    }
-    /**
-     * Esecuzione di una POST HTTP
-     *
-     * Casistica particolare in cui viene restituito un file gestito come ObjectURL il cui URL si può gestire dal parametro di callback **getFileCallback**.
-     * La chiamata non ha un tipo restituito in quanto il risultato dev'essere gestito attraverso la callback **getFileCallback**
-     *
-     * @param {string} url URL su cui effettuare la chiamata
-     * @param {K} bodyData DTO per la chiamata
-     * @param {string} filename Nome del file che si sta richiedendo, rimane lato Frontend e serve per assegnare arbitrariamente un nome al file restituito, se vuoto viene utilizzata la Content-Disposition della risposta
-     * @param {Function} getFileCallback Callback a due parametri (url: string, filename: string) per gestire il risultato del file richiesto. **Utilizzare UtilityService.fileDownload** di @esfaenza/extensions
-     * @param {Function} afterGetFile Callback da chiamare dopo aver gestito la risposta del **getFileCallback**, in caso **handleError** fosse **false** verrà richiamato anche in caso di errore
-     * @param {boolean} handleError Indica se di default gli errori devono essere gestiti dalla libreria o se devono essere ignorati
-     */
-    async postGetFile(url, bodyData, filename, getFileCallback, afterGetFile = null, handleError = true, pars) {
-        let myGuid = this.defaultStartCall(url);
-        let locale = await this.bc.Locale.pipe(first()).toPromise();
-        this.http.post(url, bodyData, { params: pars, headers: this.getHeaders(locale), observe: 'response', responseType: "blob" }).pipe(catchError((err, caught) => {
-            if (afterGetFile && !handleError)
-                afterGetFile();
-            return this.registerErrorAndReturnEmptyObservable(err, myGuid, handleError);
-        }), finalize(() => { this.tryFinalizeByGuid(myGuid); })).subscribe((response) => {
-            let retUrl = window.URL.createObjectURL(response.body);
-            let fn = response.headers.get('content-disposition')?.split(';')[1]?.split('filename')[1]?.split('=')[1]?.trim().replace(/\"/g, '');
-            getFileCallback(retUrl, filename || fn);
-            if (afterGetFile)
-                afterGetFile();
-        });
-    }
-    /**
-     * Esecuzione di una GET HTTP
-     *
-     * Casistica particolare in cui viene restituito un file gestito come ObjectURL il cui URL si può gestire dal parametro di callback **getFileCallback**.
-     * La chiamata non ha un tipo restituito in quanto il risultato dev'essere gestito attraverso la callback **getFileCallback**
-     *
-     * @param {string} url URL su cui effettuare la chiamata
-     * @param {HttpParams} params Parametri della chiamata
-     * @param {string} filename Nome del file che si sta richiedendo, rimane lato Frontend e serve per assegnare arbitrariamente un nome al file restituito, se vuoto viene utilizzata la Content-Disposition della risposta
-     * @param {Function} getFileCallback Callback a due parametri (url: string, filename: string) per gestire il risultato del file richiesto. **Utilizzare UtilityService.fileDownload** di @esfaenza/extensions
-     * @param {Function} afterGetFile Callback da chiamare dopo aver gestito la risposta del **getFileCallback**, in caso **handleError** fosse **false** verrà richiamato anche in caso di errore
-     * @param {boolean} handleError Indica se di default gli errori devono essere gestiti dalla libreria o se devono essere ignorati
-     */
-    async getFile(url, params = null, filename, getFileCallback, afterGetFile = null, handleError = true) {
-        let myGuid = this.defaultStartCall(url);
-        let locale = await this.bc.Locale.pipe(first()).toPromise();
-        this.http.get(url, { params: params, headers: this.getHeaders(locale), observe: 'response', responseType: "blob" }).pipe(catchError((err, caught) => {
-            if (afterGetFile && !handleError)
-                afterGetFile();
-            return this.registerErrorAndReturnEmptyObservable(err, myGuid, handleError);
-        }), finalize(() => { this.tryFinalizeByGuid(myGuid); })).subscribe((response) => {
-            let retUrl = window.URL.createObjectURL(response.body);
-            let fn = response.headers.get('content-disposition')?.split(';')[1]?.split('filename')[1]?.split('=')[1]?.trim().replace(/\"/g, '');
-            getFileCallback(retUrl, filename || fn);
-            if (afterGetFile)
-                afterGetFile();
-        });
-    }
-    /**
-     * Download nativo di un file. Internamente utilizza il pattern **window.location.href = "..."**
-     *
-     * @param {string} url URL su cui effettuare la chiamata
-     * @param {HttpParams} params Parametri della chiamata
-     */
-    getFileNative(url, params = null) {
-        // Encodo tutti i parametri per evitare casi particolari
-        // var encodedParams = new HttpParams();
-        // let parKeys = params.keys();
-        // for (let i = 0; i < parKeys.length; i++)
-        //   encodedParams = encodedParams.set(parKeys[i], encodeURIComponent(params.get(parKeys[i])));
-        let finalUrl = url + (params ? "?" + params.toString().replace(/\+/g, '%2b') : "");
-        window.location.href = finalUrl;
-    }
-    /**
-     * Esecuzione di una GET di un file che emette i vari eventi di progresso di download.
-     * Utilizzarla per overridare la dialog nativa di progress del browser e sostituirla con qualcosa tipo quello che fa MEGA.
-     *
-     * In caso si voglia ottenere il risultato nativo del browser del download utilizzare **getFileNative(url, pars)**
-     *
-     * @param {string} url URL su cui effettuare la chiamata
-     * @param {HttpParams} params Parametri della chiamata
-     * @param {Function} getFileCallback Callback a due parametri (url: string, filename: string) per gestire il risultato del file richiesto. **Utilizzare UtilityService.fileDownload** di @esfaenza/extensions
-     *
-     * @returns {Observable<Download>} Observable dei vari step di progresso del download
-     */
-    getFileWithProgress(url, params = null, getFileCallback) {
-        return forkJoin({
-            myGuid: from([this.defaultStartCall(url)]),
-            locale: this.bc.Locale.pipe(first())
-        }).pipe(concatMap((ret) => {
-            return this.http.get(url, { responseType: 'blob', headers: this.getHeaders(ret.locale), params: params, observe: 'events', reportProgress: true })
-                .pipe(scan((previous, event) => {
-                if (this.isHttpProgressEvent(event)) {
-                    let progress = event.total ? (event.loaded > event.total ? 100 : Math.round((100 * event.loaded) / event.total)) : previous.progress;
-                    return { progress: progress, state: 'IN_PROGRESS', content: null };
-                }
-                if (this.isHttpResponse(event)) {
-                    if (event.body) {
-                        let cdisp = event.headers.get('content-disposition');
-                        let cdispFilename = cdisp.split(';')[1].split('filename')[1].split('=')[1].trim().replace(/\"/g, '');
-                        let retUrl = window.URL.createObjectURL(event.body);
-                        getFileCallback(retUrl, cdispFilename);
-                    }
-                    return { progress: 100, state: 'DONE', content: event.body };
-                }
-                return previous;
-            }, { state: 'PENDING', progress: 0, content: null }), catchError((err, _) => { return this.registerErrorAndReturnEmptyObservable(err, ret.myGuid); }), finalize(() => { this.tryFinalizeByGuid(ret.myGuid); }));
-        }));
-    }
-    /**
-     * Riconosce se l'evento HTTP è di tipo **HttpResponse** e, se sì, lo casta al tipo corretto per essere utilizzato correttamente nel blocco di codice successivo
-     */
-    isHttpResponse(event) {
-        return event.type === HttpEventType.Response;
-    }
-    /**
-     * Riconosce se l'evento HTTP è di tipo **HttpProgressEvent** e, se sì, lo casta al tipo corretto per essere utilizzato correttamente nel blocco di codice successivo
-     */
-    isHttpProgressEvent(event) {
-        return event.type === HttpEventType.DownloadProgress || event.type === HttpEventType.UploadProgress;
-    }
-    /**
-     * Gestione dell'inizio di una chiamata ad un certo URL, viene generato un GUID da assegnarci, controllata la scadenza della cache,
-     * e eventualmente loggato il fatto che sta per essere effettuata una chiamata HTTP
-     *
-     * @param {string} url Url a cui effettuare la chiamata
-     * @returns {string} GUID assegnato alla chiamata
-     */
-    defaultStartCall(url) {
-        let myGuid = this.getGUID();
-        this.checkCacheInvalidation(url);
-        this.callStatus[myGuid] = { url: url, success: true };
-        this.log(this.loc("Starting call") + " " + myGuid + " " + this.loc("at URL") + ": " + url);
-        return myGuid;
-    }
-    /**
-     * Dato un url vengono controllate le informazioni su tutti gli url da invalidare collegati all'url chiamato e, se presenti in cache, invalidati
-     *
-     * @param {string} url URL per cui controllare se ci sono chiamate in cache da invalidare
-     */
-    checkCacheInvalidation(url) {
-        if (!this.CacheInitialized)
-            return;
-        let cache = this.localStorage.getLocalItem(this.localStorageHttpCacheKey);
-        let tmp = /#cache(:?-(\d+))/gi.exec(url);
-        let cacheTime = tmp ? tmp[2] : null;
-        let normalizedUrl_tmp = url.replace("#cache" + (cacheTime ? "-" + cacheTime : ""), "");
-        let normalizedUrl = normalizedUrl_tmp.substring(normalizedUrl_tmp.indexOf('/api'));
-        if (!cache || !this.HTTP_INVALIDATION || !this.HTTP_INVALIDATION[normalizedUrl])
-            return;
-        let apisToInvalidate = this.HTTP_INVALIDATION[normalizedUrl];
-        if (!apisToInvalidate || apisToInvalidate.length == 0)
-            return;
-        let keysToRemove = [];
-        apisToInvalidate.forEach(api => {
-            let cacheKey = this.makeCacheKey(api, null);
-            for (let item in cache)
-                if (item.indexOf(cacheKey) != -1)
-                    keysToRemove.push(item);
-        });
-        for (let i = 0; i < keysToRemove.length; i++) {
-            let k = keysToRemove[i];
-            this.log(this.loc("Invlalidating cache element") + " " + k);
-            delete cache[k];
-        }
-        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
-     */
-    async tryFinalizeByGuid(guid, cacheInfos) {
-        this.log(this.loc("Finalizing call") + " " + guid + " " + this.loc("with status") + ": " + (!this.callStatus[guid] ? 'Unknown' : this.callStatus[guid].success ? this.loc('Success') : this.loc('Failure')));
-        // TODO: Perdere 3-4 ore per capire perché ogni tanto arriva null in casi pesanti di Observable spammati a random
-        if (this.callStatus[guid]) {
-            // 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].success && this.ExtensionsImpl.readRedirectionStatus())
-                this.ExtensionsImpl.writeRedirectionStatus(false);
-            // Aggiungo la chiamata alla lista delle ultime 3 completate
-            this.LastThreeCompletedCalls.unshift(this.callStatus[guid].url);
-            if (this.LastThreeCompletedCalls.length > 3)
-                this.LastThreeCompletedCalls.pop();
-            // In ogni caso questa posso rimuoverla
-            delete this.callStatus[guid];
-        }
-        // Se non ho nessun'altra chiamata in corso considero la situazione stabilizzatasi
-        if (Object.keys(this.callStatus).length == 0)
-            this.Stabilized.next(true);
-        // 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 && this.CacheInitialized) {
-            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
-     * ad un backend ASP.NET da cui si potrà accedere a Request.Form.Files
-     *
-     * @param {File | File[]} fileArrayOrFile Singolo File o lista di File. N.B: nella firma della funzione viene considerato **any** per fare test sulle proprietà
-     * invece che fare test con l'**istanceof**
-     *
-     * @returns {FormData} FormData contenente tutti i file passati
-     */
-    getFilesFormData(fileArrayOrFile) {
-        var formData = new FormData();
-        if (fileArrayOrFile) {
-            if (fileArrayOrFile.length)
-                fileArrayOrFile.forEach(t => { formData.append("file", t, t.name); });
-            else if (fileArrayOrFile.name)
-                formData.append("files", fileArrayOrFile, fileArrayOrFile.name);
-        }
-        return formData;
-    }
-    /**
-     * Helper che in base ai parametri disponibili genera gli Header HTTP per la chiamata da effettuare
-     *
-     * @param {string} contentType Indica se aggiungere agli header "Content-Type", valorizzato al valore del parametro
-     * @param {string} accept Indica se aggiungere agli header "Accept", valorizzato al valore del parametro
-     * @param {boolean} includeAuth Indica se aggiungere agli header "Authorization", valorizzato col token recuperato dall'hook **retrieveAccessToken** della classe di estensione
-     * @param {string} transactionId Indica se aggiungere agli header "X-TX-ID", valorizzato al valore del parametro
-     *
-     * @returns {HttpHeaders} Header generati in base ai parametri
-     */
-    getHeaders(locale = 'it-IT', transactionId = "", includeAuth = true, contentType = "application/json", accept = "application/json") {
-        var headers = new HttpHeaders();
-        var authtoken = this.ExtensionsImpl.retrieveAccessToken();
-        headers = headers.append("ngsw-bypass", "");
-        if (contentType)
-            headers = headers.append("Content-Type", contentType);
-        if (transactionId)
-            headers = headers.append("X-TX-ID", transactionId);
-        if (authtoken && includeAuth)
-            headers = headers.append("Authorization", "Bearer " + authtoken);
-        if (accept)
-            headers = headers.append("Accept", accept);
-        headers = headers.append("Accept-Language", locale);
-        return headers;
-    }
-    /**
-     * Gestione di default degli errori
-     *
-     * @param {any} res Risultato della chiamata effettuata
-     * @param {string} guid Identificativo GUID della chiamata effettuata
-     */
-    async onError(res, guid) {
-        if (this.callStatus[guid])
-            this.callStatus[guid].success = false;
-        //Mi assicuro che tutti gli errori durante il redirect al login vengano ignorati
-        if (this.ExtensionsImpl.readRedirectingToLogin()) {
-            this.log(this.loc("Redirecting to Login, ignoring HTTP error on call") + " " + guid);
-            return;
-        }
-        //Mi assicuro che venga gestito un solo errore per volta
-        if (this.ExtensionsImpl.readHandlingErrorStatus()) {
-            this.log(this.loc("Already Handling an error, ignoring HTTP error on call") + " " + guid);
-            return;
-        }
-        else
-            this.ExtensionsImpl.writeHandlingErrorStatus(true);
-        let finalError = "";
-        let finalStatus = "";
-        if (this.isTypeError(res)) {
-            finalError = res.message;
-            finalStatus = "HTTP Service Internal Error";
-        }
-        else if (this.isHttpErrorResponse(res)) {
-            finalError = await this.getHttpErrorText(res.error);
-            finalStatus = res.status.toString();
-            switch (res.status) {
-                // Unauthorized
-                case 401:
-                    if (this.ExtensionsImpl.readRedirectionStatus()) {
-                        this.log(this.loc("Error 401 on call") + " " + guid + " " + this.loc("with redirect already in progress. Ignoring this event"));
-                        return;
-                    }
-                    this.log(this.loc("Error 401 on call") + " " + guid + " " + this.loc("redirecting to login."));
-                    this.ExtensionsImpl.writeRedirectionStatus(true);
-                    this.ExtensionsImpl.writeRedirectingToLogin(true);
-                    this.ExtensionsImpl.redirectToLogin();
-                    return;
-                // Handled exception
-                case 400:
-                // No Permissions
-                case 403:
-                    this.ExtensionsImpl.handleBlockingException(res.status, finalError);
-                    return;
-                // Not found
-                case 404:
-                    this.ExtensionsImpl.handleBlockingException(res.status, this.loc("Resource not found"));
-                    return;
-                // NotConfiguredException
-                case 444:
-                    if (this.ExtensionsImpl.readRedirectionStatus())
-                        this.log(this.loc("Error 444 on call") + " " + guid + " " + this.loc("with redirect already in progress. Ignoring this event"));
-                    else if (!this.ExtensionsImpl.handleNotConfiguredException())
-                        this.ExtensionsImpl.handleBlockingException(res.status, finalError);
-                    return;
-                case 0:
-                    finalError = `Generic connection error while calling '[${guid}] - ${this.callStatus[guid].url}' at ${dayjs().format()}. Response: ${JSON.stringify(res)}`;
-            }
-        }
-        this.ExtensionsImpl.handleException(finalStatus, finalError);
-    }
-    /**
-     * Dato un errore restituisce una promise con la stringa finale dell'errore in modo da poter fare un await
-     *
-     * @param {any} err Errore da controllare
-     *
-     * @returns {Promise<string>} Promise che risolve con la stringa finale dell'errore
-     */
-    getHttpErrorText(err) {
-        // Se ho un Blob può essere o un CallResult o suppongo una semplice stringa,
-        // altrimenti potrebbe essere direttamente un CallResult, oppure una semplice stringa
-        return new Promise((resolve) => {
-            if (err instanceof Blob) {
-                let reader = new FileReader();
-                reader.onload = (e) => {
-                    let errMsg = e.target.result;
-                    let jsonerrMsg;
-                    try {
-                        jsonerrMsg = JSON.parse(errMsg);
-                    }
-                    catch (e) { }
-                    return resolve(jsonerrMsg && this.isCallResult(jsonerrMsg) ? jsonerrMsg.error.message : errMsg);
-                };
-                reader.readAsText(err);
-            }
-            else if (this.isCallResult(err))
-                return resolve(err.error.message);
-            else
-                return resolve(err?.toString());
-        });
-    }
-    /**
-     * Riconosce se l'oggetto è di tipo **CallResult** e, se sì, lo casta al tipo corretto per essere utilizzato correttamente nel blocco di codice successivo
-     *
-     * @param {any} err Errore da controllare
-     */
-    isCallResult(err) {
-        return !!err?.error?.message;
-    }
-    /**
-     * Riconosce se l'errore è di tipo **HttpErrorResponse** e, se sì, lo casta al tipo corretto per essere utilizzato correttamente nel blocco di codice successivo
-     *
-     * @param {any} err Errore da controllare
-     */
-    isHttpErrorResponse(err) {
-        return err instanceof HttpErrorResponse;
-    }
-    /**
-    * Riconosce se l'errore è di tipo **TypeError** e, se sì, lo casta al tipo corretto per essere utilizzato correttamente nel blocco di codice successivo
-    *
-    * @param {any} err Errore da controllare
-    */
-    isTypeError(err) {
-        return err.name == "TypeError";
-    }
-    /**
-     * Come dice il nome, registra un errore e restituisce un Observable vuoto come risultato della chiamata
-     *
-     * @param {any} res Risultato della chiamata effettuata
-     * @param {string} guid Identificativo GUID della chiamata effettuata
-     * @param {boolean} handleError Indica se gestire l'errore via libreria o se limitarsi a restituire l'Observable vuoto
-     *
-     * @returns {Observable<any>} Observable vuoto
-     */
-    registerErrorAndReturnEmptyObservable(res, guid, handleError = true) {
-        if (handleError)
-            this.onError(res, guid);
-        return new Observable(() => { });
-    }
-    /**
-     * Dato un Url e dei parametri cerca di recuperare l'eventuale oggetto già salvato in cache con le informazioni base della cache stessa
-     *
-     * @param {string} url URL su cui effettuare la chiamata
-     * @param {HttpParams} params Parametri della chiamata (nulli in caso di POST)
-     *
-     * @returns {CacheInfos} Oggetto contenente le informazioni sulla cache per l'oggetto specificato
-     */
-    tryGetCacheInformations(url, params) {
-        let cachingKey = null, cacheTime = null, item = null;
-        let useCaching = !!(/#cache/gi.exec(url));
-        if (useCaching && this.CacheInitialized) {
-            let tmp = /#cache(:?-(\d+))/gi.exec(url);
-            cacheTime = tmp ? tmp[2] : null;
-            url = url.replace("#cache" + (cacheTime ? "-" + cacheTime : ""), "");
-            if (this.untimedCacheExpired() && !cacheTime)
-                this.resetHttpUntimedCacheStorage();
-            cachingKey = this.makeCacheKey(url, params);
-            let cacheKey = cacheTime ? this.localStorageHttpTimedCacheKey : this.localStorageHttpCacheKey;
-            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
-                if (cacheTime)
-                    delete cache[cachingKey].__expire;
-                item = cache[cachingKey];
-            }
-        }
-        // Per assicurarmi che il rifeirmento degli oggetti sia diverso utilizzo il deepClone
-        return new CacheInfos(url, useCaching && this.CacheInitialized, cachingKey, cacheTime, this.utisExts.deepClone(item));
-    }
-    /**
-     * Inserisce un oggetto nella cache appropriata in base alle informazioni contenute nel parametro **cacheInfos**
-     *
-     * @param {T} item Oggetto da inserire nella cache
-     * @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 = this.localStorage.getLocalItem(cacheKey);
-        let cache = cacheLs ? cacheLs : {};
-        cache[cacheInfos.cacheKey] = item;
-        if (cacheInfos.cacheTime)
-            cache[cacheInfos.cacheKey].__expire = dayjs().add(cacheInfos.cacheTime, "seconds");
-        this.localStorage.setLocalItem(cacheKey, cache);
-    }
-    /**
-     * Controlla se la cache per le chiamate senza expire time è scaduta
-     *
-     * @returns {boolean} **true** se la cache è scaduta e dev'essere ripulita, **false** altrimenti
-     */
-    untimedCacheExpired() {
-        let expire = JSON.parse(localStorage.getItem(this.localStorageHttpCacheExpireKey));
-        return !expire || expire && dayjs(expire) < dayjs();
-    }
-    /**
-     * Controlla se la cache per una chiamata che ha un tempo di vita ben definito è scaduta o meno
-     *
-     * @param {any} item Oggetto recuperato dalla cache a cui ho aggiunto la chiave interna __expire
-     *
-     * @returns {boolean} **true** se la cache è scaduta e dev'essere ripulita, **false** altrimenti
-     */
-    timedCacheItemExpired(item) {
-        return dayjs(item.__expire) < dayjs();
-    }
-    /**
-     * 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**)
-     */
-    async resetHttpUntimedCacheStorage() {
-        if (!this.CacheInitialized)
-            return;
-        await this.localStorage.setItem(this.localStorageHttpCacheKey, {}).toPromise();
-        localStorage.setItem(this.localStorageHttpCacheExpireKey, JSON.stringify(dayjs().add(this.CLIENT_CACHE_DURATION_S, "second")));
-    }
-    /**
-     * Ripulisce la cache delle chiamate con un tempo di expire definito
-     */
-    async resetHttpTimedCacheStorage() {
-        if (!this.CacheInitialized)
-            return;
-        await this.localStorage.setItem(this.localStorageHttpTimedCacheKey, {}).toPromise();
-    }
-    /**
-     * Genera una chiave per la cache delle chiamate in base ad URL e Parametri HTTP
-     *
-     * @param {string} url URL su cui effettuare la chiamata
-     * @param {HttpParams} params Parametri della chiamata
-     *
-     * @returns {string} Chiave che rappresenta in maniera univoca la chiamata
-     */
-    makeCacheKey(url, params) {
-        this.me = this.me || this.ExtensionsImpl.retrieveIdentity();
-        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.substring(url.indexOf("api") + 4) + "?" + paramsKeyPart;
-    }
-    /**
-     * Generazione GUID
-     *
-     * @returns {string} Nuovo GUID generato in maniera casuale
-     */
-    getGUID() {
-        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-            var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
-            return v.toString(16);
-        });
-    }
-    /**
-     * Metodo per scrivere log a console qualora **DEBUG_MODE** risultasse **true**
-     *
-     * @param {string} message Messaggio di log
-     */
-    log(message) {
-        if (this.HTTP_DEBUG_MODE)
-            console.log("@httpservice: " + message);
-    }
-    /**
-     * Helper per la localizzazione dei messaggi
-     *
-     * @param {string} message Messaggio da localizzare
-     *
-     * @returns {string} Messaggio localizzato
-     */
-    loc(message) {
-        // Togliamo velocemente ste localizzazioni inutili....
-        return message;
-    }
-    /**
-     * Helper per lanciare la selezione di tutto quello che è relativo a un api di ricerca con AppSearch (di cui non utilizzo il tipo vero per ridurre le dipendenze)
-     */
-    getAll(view, api, pars, transaction) {
-        if (!view.selection.all)
-            return of(view.selection.items);
-        var jsonView = this.utisExts.deepClone(view);
-        jsonView.page = 1;
-        jsonView.itemsperpageoverride = 999999;
-        return this.post(api, jsonView, pars, transaction).pipe(map(res => {
-            let items = res.items;
-            items.forEach(t => t.hash = this.hash.hashObject(t, null, false));
-            if (res.selection.exclusions?.length > 0)
-                items = items.filter((t) => !res.selection.exclusions.find((e) => this.hash.hashObject(e, null, false) == t.hash));
-            return items;
-        }));
-    }
-    beginTransaction(executionKey, secondsTimeout) {
-        this.log("beginTransaction call received: " + executionKey);
-        var pars = new HttpParams().set("executionKey", executionKey);
-        if (secondsTimeout)
-            pars = pars.set("secondsTimeout", secondsTimeout.toString());
-        return this.get(this.GET_Trans_BeginTrans, pars);
-    }
-    checkTransaction(executionKey) {
-        this.log("checkTransaction call received: " + executionKey);
-        return this.get(this.GET_Trans_CheckExecution, new HttpParams().set("executionKey", executionKey));
-    }
-    endTransaction(transactionKey, transactionResult) {
-        this.log("endTransaction call received: " + transactionKey + " Commit: " + transactionResult);
-        let pars = new HttpParams().set("idtrans", transactionKey).set("success", transactionResult.toString());
-        return this.get(this.GET_Trans_EndTrans, pars);
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HTTPService, deps: [{ token: HttpServiceExtensions }, { token: HTTP_INVALIDATION, optional: true }, { token: CLIENT_CACHE_DURATION_S }, { token: CACHE_BY_USER }, { token: HTTP_DEBUG_MODE }, { token: i2.BaseLocalization }, { token: i3.HttpClient }, { token: i4.CacheService }, { token: i5.HashingService }, { token: i5.UtilityService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HTTPService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HTTPService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: HttpServiceExtensions }, { type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [HTTP_INVALIDATION]
-                }] }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [CLIENT_CACHE_DURATION_S]
-                }] }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [CACHE_BY_USER]
-                }] }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [HTTP_DEBUG_MODE]
-                }] }, { type: i2.BaseLocalization }, { type: i3.HttpClient }, { type: i4.CacheService }, { type: i5.HashingService }, { type: i5.UtilityService }]; } });
+// Angular
+/**
+ * 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**
+ */
+class HTTPService {
+    /**
+     * @ignore
+     */
+    constructor(EXTENSION_CLASS, HTTP_INVALIDATION, CLIENT_CACHE_DURATION_S, CACHE_BY_USER, HTTP_DEBUG_MODE, bc, http, localStorage, hash, utisExts) {
+        this.EXTENSION_CLASS = EXTENSION_CLASS;
+        this.HTTP_INVALIDATION = HTTP_INVALIDATION;
+        this.CLIENT_CACHE_DURATION_S = CLIENT_CACHE_DURATION_S;
+        this.CACHE_BY_USER = CACHE_BY_USER;
+        this.HTTP_DEBUG_MODE = HTTP_DEBUG_MODE;
+        this.bc = bc;
+        this.http = http;
+        this.localStorage = localStorage;
+        this.hash = hash;
+        this.utisExts = utisExts;
+        /** 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 */
+        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 */
+        this.localStorageHttpTimedCacheKey = null;
+        /** 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** */
+        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;
+        /** Subject emesso quando il servizio http si stabilizza, cioè quando non c'è nessuna chiamata pending o in corso da qualche istante */
+        this.Stabilized = new Subject();
+        /** Lista delle ultime 3 chiamate completate con successo in ordine di completamento (in posizione 0 c'è l'ultima completata eccetera...) */
+        this.LastThreeCompletedCalls = [];
+        this.CacheInitialized = false;
+        /*****************************************************************************************************************************************
+         ***************************************************** TRANSACTION HELPERS ***************************************************************
+         *****************************************************************************************************************************************/
+        this.GET_Trans_BeginTrans = "/api/Trans/BeginTrans";
+        this.GET_Trans_CheckExecution = "/api/Trans/CheckExecution";
+        this.GET_Trans_EndTrans = "/api/Trans/EndTrans";
+        this.ExtensionsImpl = this.EXTENSION_CLASS || new HttpServiceExtensions();
+    }
+    setAppConfig(myconfig) {
+        this.localStorageHttpCacheKey = (myconfig.AppData.ModuleDescription).replace(/\s/g, '_') + "_HttpCache";
+        this.localStorageHttpTimedCacheKey = (myconfig.AppData.ModuleDescription).replace(/\s/g, '_') + "_HttpTimedCache";
+        this.localStorageHttpCacheExpireKey = this.localStorageHttpCacheKey + "_Expire";
+        this.adjustOldStorageSystem();
+        this.CacheInitialized = true;
+    }
+    /**
+     * 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"
+     *
+     * @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
+     * @param {Function} errorCallback Callback chiamato in caso di errore
+     *
+     * @returns {Observable<T>} Observable che contiene il risultato della chiamata
+     */
+    get(url, params = null, transaction = "", succesfulResultMandatory = true, errorCallback = null) {
+        return forkJoin({
+            myGuid: from([this.defaultStartCall(url)]),
+            locale: this.bc.Locale.pipe(first())
+        }).pipe(concatMap((ret) => {
+            let cachedInfos = this.tryGetCacheInformations(url, params);
+            if (cachedInfos.cache && cachedInfos.cacheItem) {
+                this.log(this.loc("Result for") + " " + url + " " + this.loc("retrieved from cache"));
+                return of(cachedInfos.cacheItem).pipe(delay(0), finalize(() => { this.tryFinalizeByGuid(ret.myGuid); }));
+            }
+            var httpCall = this.http.get(cachedInfos.finalUrl, { headers: this.getHeaders(ret.locale, transaction), params: params });
+            return httpCall.pipe(map((res) => {
+                let responseItem = res;
+                if (cachedInfos.cache) {
+                    this.cacheResponse(this.utisExts.deepClone(responseItem), cachedInfos);
+                    this.log(this.loc("Cached result for") + " " + url);
+                }
+                return responseItem;
+            }), catchError((err, caught) => {
+                if (errorCallback)
+                    errorCallback();
+                return !succesfulResultMandatory ? throwError(err) : this.registerErrorAndReturnEmptyObservable(err, ret.myGuid);
+            }), finalize(() => { this.tryFinalizeByGuid(ret.myGuid, cachedInfos); }));
+        }));
+    }
+    /**
+     * Esecuzione di una GET HTTP con eventualmente la gestione della cache qualora la chiamata termini con la convenzione "#cache"
+     *
+     * Caso specifico di chiamata che deve restituire un Blob o un ArrayBuffer nativo da elaborare
+     *
+     * @param {string} url URL su cui effettuare la chiamata
+     * @param {HttpParams} params Parametri della chiamata
+     * @param {"arraybuffer"| "blob"} type Tipo di ritorno richiesto
+     * @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
+     * @param {Function} errorCallback Callback chiamato in caso di errore
+     *
+     * @returns {Observable<Blob | ArrayBuffer>} Observable che contiene il risultato della chiamata
+     */
+    getRaw(url, params = null, type = "arraybuffer", transaction = "", succesfulResultMandatory = true, errorCallback = null) {
+        return forkJoin({
+            myGuid: from([this.defaultStartCall(url)]),
+            locale: this.bc.Locale.pipe(first())
+        }).pipe(concatMap((ret) => {
+            let cachedInfos = this.tryGetCacheInformations(url, params);
+            if (cachedInfos.cache && cachedInfos.cacheItem) {
+                this.log(this.loc("Result for") + " " + url + " " + this.loc("retrieved from cache"));
+                return of(cachedInfos.cacheItem).pipe(delay(0), finalize(() => { this.tryFinalizeByGuid(ret.myGuid); }));
+            }
+            var httpCall = this.http.get(cachedInfos.finalUrl, { responseType: type, headers: this.getHeaders(ret.locale, transaction), params: params });
+            return httpCall.pipe(map((blob) => {
+                if (cachedInfos.cache) {
+                    this.cacheResponse(blob, cachedInfos);
+                    this.log(this.loc("Cached result for") + " " + url);
+                }
+                return blob;
+            }), catchError((err, caught) => {
+                if (errorCallback)
+                    errorCallback();
+                return !succesfulResultMandatory ? throwError(err) : this.registerErrorAndReturnEmptyObservable(err, ret.myGuid);
+            }), finalize(() => { this.tryFinalizeByGuid(ret.myGuid, cachedInfos); }));
+        }));
+    }
+    /**
+    * 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
+    */
+    post(url, bodyData, params = null, transaction = "", succesfulResultMandatory = true) {
+        return forkJoin({
+            myGuid: from([this.defaultStartCall(url)]),
+            locale: this.bc.Locale.pipe(first())
+        }).pipe(concatMap((ret) => {
+            // Se è una ricerca, shallow copy e rimuovo gli "items" per evitare di farli andare su e giù al backend
+            if (!!bodyData?.items && !!bodyData?.page) {
+                bodyData = { ...bodyData };
+                delete bodyData.items;
+            }
+            var httpCall = this.http.post(url, bodyData, { headers: this.getHeaders(ret.locale, transaction), params: params });
+            return httpCall.pipe(catchError((err, _) => {
+                return !succesfulResultMandatory ? throwError(err) : this.registerErrorAndReturnEmptyObservable(err, ret.myGuid);
+            }), finalize(() => { this.tryFinalizeByGuid(ret.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
+    */
+    delete(url, params = null, transaction = "", succesfulResultMandatory = true) {
+        return forkJoin({
+            myGuid: from([this.defaultStartCall(url)]),
+            locale: this.bc.Locale.pipe(first())
+        }).pipe(concatMap((ret) => {
+            var httpCall = this.http.delete(url, { headers: this.getHeaders(ret.locale, transaction), params: params });
+            return httpCall.pipe(catchError((err, caught) => {
+                return !succesfulResultMandatory ? throwError(err) : this.registerErrorAndReturnEmptyObservable(err, ret.myGuid);
+            }), finalize(() => { this.tryFinalizeByGuid(ret.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
+     */
+    put(url, bodyData, params = null, transaction = "", succesfulResultMandatory = true) {
+        return forkJoin({
+            myGuid: from([this.defaultStartCall(url)]),
+            locale: this.bc.Locale.pipe(first())
+        }).pipe(concatMap((ret) => {
+            var httpCall = this.http.put(url, bodyData, { headers: this.getHeaders(ret.locale, transaction), params: params });
+            return httpCall.pipe(catchError((err, caught) => {
+                return !succesfulResultMandatory ? throwError(err) : this.registerErrorAndReturnEmptyObservable(err, ret.myGuid);
+            }), finalize(() => { this.tryFinalizeByGuid(ret.myGuid); }));
+        }));
+    }
+    /**
+     * Esecuzione di una POST HTTP
+     *
+     * Casistica particolare in cui bisogna anche inviare dei File
+     *
+     * @param {string} url URL su cui effettuare la chiamata
+     * @param {any} bodyData DTO per la chiamata
+     * @param {File[] | File} fileArrayOrFile Singolo file o lista di file da inviare. Il tipo **File** è quello nativo del Javascript
+     *
+     * @returns {Observable<T>} Observable che contiene il risultato della chiamata
+     */
+    postwithFiles(url, bodyData, fileArrayOrFile, params = null, succesfulResultMandatory = true, onError) {
+        return forkJoin({
+            myGuid: from([this.defaultStartCall(url)]),
+            locale: this.bc.Locale.pipe(first())
+        }).pipe(concatMap((ret) => {
+            var formData = this.getFilesFormData(fileArrayOrFile);
+            formData.append("body", JSON.stringify(bodyData));
+            var httpCall = this.http.post(url, formData, { params: params, headers: this.getHeaders(ret.locale, null, true, null, null) });
+            return httpCall.pipe(catchError((err, caught) => {
+                onError?.();
+                return !succesfulResultMandatory ? throwError(err) : this.registerErrorAndReturnEmptyObservable(err, ret.myGuid);
+            }), finalize(() => { this.tryFinalizeByGuid(ret.myGuid); }));
+        }));
+    }
+    /**
+     * Esecuzione di una POST HTTP
+     *
+     * Casistica particolare in cui viene restituito un file gestito come ObjectURL il cui URL si può gestire dal parametro di callback **getFileCallback**.
+     * La chiamata non ha un tipo restituito in quanto il risultato dev'essere gestito attraverso la callback **getFileCallback**
+     *
+     * @param {string} url URL su cui effettuare la chiamata
+     * @param {K} bodyData DTO per la chiamata
+     * @param {string} filename Nome del file che si sta richiedendo, rimane lato Frontend e serve per assegnare arbitrariamente un nome al file restituito, se vuoto viene utilizzata la Content-Disposition della risposta
+     * @param {Function} getFileCallback Callback a due parametri (url: string, filename: string) per gestire il risultato del file richiesto. **Utilizzare UtilityService.fileDownload** di @esfaenza/extensions
+     * @param {Function} afterGetFile Callback da chiamare dopo aver gestito la risposta del **getFileCallback**, in caso **handleError** fosse **false** verrà richiamato anche in caso di errore
+     * @param {boolean} handleError Indica se di default gli errori devono essere gestiti dalla libreria o se devono essere ignorati
+     */
+    async postGetFile(url, bodyData, filename, getFileCallback, afterGetFile = null, handleError = true, pars) {
+        let myGuid = this.defaultStartCall(url);
+        let locale = await this.bc.Locale.pipe(first()).toPromise();
+        this.http.post(url, bodyData, { params: pars, headers: this.getHeaders(locale), observe: 'response', responseType: "blob" }).pipe(catchError((err, caught) => {
+            if (afterGetFile && !handleError)
+                afterGetFile();
+            return this.registerErrorAndReturnEmptyObservable(err, myGuid, handleError);
+        }), finalize(() => { this.tryFinalizeByGuid(myGuid); })).subscribe((response) => {
+            let retUrl = window.URL.createObjectURL(response.body);
+            let fn = response.headers.get('content-disposition')?.split(';')[1]?.split('filename')[1]?.split('=')[1]?.trim().replace(/\"/g, '');
+            getFileCallback(retUrl, filename || fn);
+            if (afterGetFile)
+                afterGetFile();
+        });
+    }
+    /**
+     * Esecuzione di una GET HTTP
+     *
+     * Casistica particolare in cui viene restituito un file gestito come ObjectURL il cui URL si può gestire dal parametro di callback **getFileCallback**.
+     * La chiamata non ha un tipo restituito in quanto il risultato dev'essere gestito attraverso la callback **getFileCallback**
+     *
+     * @param {string} url URL su cui effettuare la chiamata
+     * @param {HttpParams} params Parametri della chiamata
+     * @param {string} filename Nome del file che si sta richiedendo, rimane lato Frontend e serve per assegnare arbitrariamente un nome al file restituito, se vuoto viene utilizzata la Content-Disposition della risposta
+     * @param {Function} getFileCallback Callback a due parametri (url: string, filename: string) per gestire il risultato del file richiesto. **Utilizzare UtilityService.fileDownload** di @esfaenza/extensions
+     * @param {Function} afterGetFile Callback da chiamare dopo aver gestito la risposta del **getFileCallback**, in caso **handleError** fosse **false** verrà richiamato anche in caso di errore
+     * @param {boolean} handleError Indica se di default gli errori devono essere gestiti dalla libreria o se devono essere ignorati
+     */
+    async getFile(url, params = null, filename, getFileCallback, afterGetFile = null, handleError = true) {
+        let myGuid = this.defaultStartCall(url);
+        let locale = await this.bc.Locale.pipe(first()).toPromise();
+        this.http.get(url, { params: params, headers: this.getHeaders(locale), observe: 'response', responseType: "blob" }).pipe(catchError((err, caught) => {
+            if (afterGetFile && !handleError)
+                afterGetFile();
+            return this.registerErrorAndReturnEmptyObservable(err, myGuid, handleError);
+        }), finalize(() => { this.tryFinalizeByGuid(myGuid); })).subscribe((response) => {
+            let retUrl = window.URL.createObjectURL(response.body);
+            let fn = response.headers.get('content-disposition')?.split(';')[1]?.split('filename')[1]?.split('=')[1]?.trim().replace(/\"/g, '');
+            getFileCallback(retUrl, filename || fn);
+            if (afterGetFile)
+                afterGetFile();
+        });
+    }
+    /**
+     * Download nativo di un file. Internamente utilizza il pattern **window.location.href = "..."**
+     *
+     * @param {string} url URL su cui effettuare la chiamata
+     * @param {HttpParams} params Parametri della chiamata
+     */
+    getFileNative(url, params = null) {
+        // Encodo tutti i parametri per evitare casi particolari
+        // var encodedParams = new HttpParams();
+        // let parKeys = params.keys();
+        // for (let i = 0; i < parKeys.length; i++)
+        //   encodedParams = encodedParams.set(parKeys[i], encodeURIComponent(params.get(parKeys[i])));
+        let finalUrl = url + (params ? "?" + params.toString().replace(/\+/g, '%2b') : "");
+        window.location.href = finalUrl;
+    }
+    /**
+     * Esecuzione di una GET di un file che emette i vari eventi di progresso di download.
+     * Utilizzarla per overridare la dialog nativa di progress del browser e sostituirla con qualcosa tipo quello che fa MEGA.
+     *
+     * In caso si voglia ottenere il risultato nativo del browser del download utilizzare **getFileNative(url, pars)**
+     *
+     * @param {string} url URL su cui effettuare la chiamata
+     * @param {HttpParams} params Parametri della chiamata
+     * @param {Function} getFileCallback Callback a due parametri (url: string, filename: string) per gestire il risultato del file richiesto. **Utilizzare UtilityService.fileDownload** di @esfaenza/extensions
+     *
+     * @returns {Observable<Download>} Observable dei vari step di progresso del download
+     */
+    getFileWithProgress(url, params = null, getFileCallback) {
+        return forkJoin({
+            myGuid: from([this.defaultStartCall(url)]),
+            locale: this.bc.Locale.pipe(first())
+        }).pipe(concatMap((ret) => {
+            return this.http.get(url, { responseType: 'blob', headers: this.getHeaders(ret.locale), params: params, observe: 'events', reportProgress: true })
+                .pipe(scan((previous, event) => {
+                if (this.isHttpProgressEvent(event)) {
+                    let progress = event.total ? (event.loaded > event.total ? 100 : Math.round((100 * event.loaded) / event.total)) : previous.progress;
+                    return { progress: progress, state: 'IN_PROGRESS', content: null };
+                }
+                if (this.isHttpResponse(event)) {
+                    if (event.body) {
+                        let cdisp = event.headers.get('content-disposition');
+                        let cdispFilename = cdisp.split(';')[1].split('filename')[1].split('=')[1].trim().replace(/\"/g, '');
+                        let retUrl = window.URL.createObjectURL(event.body);
+                        getFileCallback(retUrl, cdispFilename);
+                    }
+                    return { progress: 100, state: 'DONE', content: event.body };
+                }
+                return previous;
+            }, { state: 'PENDING', progress: 0, content: null }), catchError((err, _) => { return this.registerErrorAndReturnEmptyObservable(err, ret.myGuid); }), finalize(() => { this.tryFinalizeByGuid(ret.myGuid); }));
+        }));
+    }
+    /**
+     * Riconosce se l'evento HTTP è di tipo **HttpResponse** e, se sì, lo casta al tipo corretto per essere utilizzato correttamente nel blocco di codice successivo
+     */
+    isHttpResponse(event) {
+        return event.type === HttpEventType.Response;
+    }
+    /**
+     * Riconosce se l'evento HTTP è di tipo **HttpProgressEvent** e, se sì, lo casta al tipo corretto per essere utilizzato correttamente nel blocco di codice successivo
+     */
+    isHttpProgressEvent(event) {
+        return event.type === HttpEventType.DownloadProgress || event.type === HttpEventType.UploadProgress;
+    }
+    /**
+     * Gestione dell'inizio di una chiamata ad un certo URL, viene generato un GUID da assegnarci, controllata la scadenza della cache,
+     * e eventualmente loggato il fatto che sta per essere effettuata una chiamata HTTP
+     *
+     * @param {string} url Url a cui effettuare la chiamata
+     * @returns {string} GUID assegnato alla chiamata
+     */
+    defaultStartCall(url) {
+        let myGuid = this.getGUID();
+        this.checkCacheInvalidation(url);
+        this.callStatus[myGuid] = { url: url, success: true };
+        this.log(this.loc("Starting call") + " " + myGuid + " " + this.loc("at URL") + ": " + url);
+        return myGuid;
+    }
+    /**
+     * Dato un url vengono controllate le informazioni su tutti gli url da invalidare collegati all'url chiamato e, se presenti in cache, invalidati
+     *
+     * @param {string} url URL per cui controllare se ci sono chiamate in cache da invalidare
+     */
+    checkCacheInvalidation(url) {
+        if (!this.CacheInitialized)
+            return;
+        let cache = this.localStorage.getLocalItem(this.localStorageHttpCacheKey);
+        let tmp = /#cache(:?-(\d+))/gi.exec(url);
+        let cacheTime = tmp ? tmp[2] : null;
+        let normalizedUrl_tmp = url.replace("#cache" + (cacheTime ? "-" + cacheTime : ""), "");
+        let normalizedUrl = normalizedUrl_tmp.substring(normalizedUrl_tmp.indexOf('/api'));
+        if (!cache || !this.HTTP_INVALIDATION || !this.HTTP_INVALIDATION[normalizedUrl])
+            return;
+        let apisToInvalidate = this.HTTP_INVALIDATION[normalizedUrl];
+        if (!apisToInvalidate || apisToInvalidate.length == 0)
+            return;
+        let keysToRemove = [];
+        apisToInvalidate.forEach(api => {
+            let cacheKey = this.makeCacheKey(api, null);
+            for (let item in cache)
+                if (item.indexOf(cacheKey) != -1)
+                    keysToRemove.push(item);
+        });
+        for (let i = 0; i < keysToRemove.length; i++) {
+            let k = keysToRemove[i];
+            this.log(this.loc("Invlalidating cache element") + " " + k);
+            delete cache[k];
+        }
+        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
+     */
+    async tryFinalizeByGuid(guid, cacheInfos) {
+        this.log(this.loc("Finalizing call") + " " + guid + " " + this.loc("with status") + ": " + (!this.callStatus[guid] ? 'Unknown' : this.callStatus[guid].success ? this.loc('Success') : this.loc('Failure')));
+        // TODO: Perdere 3-4 ore per capire perché ogni tanto arriva null in casi pesanti di Observable spammati a random
+        if (this.callStatus[guid]) {
+            // 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].success && this.ExtensionsImpl.readRedirectionStatus())
+                this.ExtensionsImpl.writeRedirectionStatus(false);
+            // Aggiungo la chiamata alla lista delle ultime 3 completate
+            this.LastThreeCompletedCalls.unshift(this.callStatus[guid].url);
+            if (this.LastThreeCompletedCalls.length > 3)
+                this.LastThreeCompletedCalls.pop();
+            // In ogni caso questa posso rimuoverla
+            delete this.callStatus[guid];
+        }
+        // Se non ho nessun'altra chiamata in corso considero la situazione stabilizzatasi
+        if (Object.keys(this.callStatus).length == 0)
+            this.Stabilized.next(true);
+        // 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 && this.CacheInitialized) {
+            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
+     * ad un backend ASP.NET da cui si potrà accedere a Request.Form.Files
+     *
+     * @param {File | File[]} fileArrayOrFile Singolo File o lista di File. N.B: nella firma della funzione viene considerato **any** per fare test sulle proprietà
+     * invece che fare test con l'**istanceof**
+     *
+     * @returns {FormData} FormData contenente tutti i file passati
+     */
+    getFilesFormData(fileArrayOrFile) {
+        var formData = new FormData();
+        if (fileArrayOrFile) {
+            if (fileArrayOrFile.length)
+                fileArrayOrFile.forEach(t => { formData.append("file", t, t.name); });
+            else if (fileArrayOrFile.name)
+                formData.append("files", fileArrayOrFile, fileArrayOrFile.name);
+        }
+        return formData;
+    }
+    /**
+     * Helper che in base ai parametri disponibili genera gli Header HTTP per la chiamata da effettuare
+     *
+     * @param {string} contentType Indica se aggiungere agli header "Content-Type", valorizzato al valore del parametro
+     * @param {string} accept Indica se aggiungere agli header "Accept", valorizzato al valore del parametro
+     * @param {boolean} includeAuth Indica se aggiungere agli header "Authorization", valorizzato col token recuperato dall'hook **retrieveAccessToken** della classe di estensione
+     * @param {string} transactionId Indica se aggiungere agli header "X-TX-ID", valorizzato al valore del parametro
+     *
+     * @returns {HttpHeaders} Header generati in base ai parametri
+     */
+    getHeaders(locale = 'it-IT', transactionId = "", includeAuth = true, contentType = "application/json", accept = "application/json") {
+        var headers = new HttpHeaders();
+        var authtoken = this.ExtensionsImpl.retrieveAccessToken();
+        headers = headers.append("ngsw-bypass", "");
+        if (contentType)
+            headers = headers.append("Content-Type", contentType);
+        if (transactionId)
+            headers = headers.append("X-TX-ID", transactionId);
+        if (authtoken && includeAuth)
+            headers = headers.append("Authorization", "Bearer " + authtoken);
+        if (accept)
+            headers = headers.append("Accept", accept);
+        headers = headers.append("Accept-Language", locale);
+        return headers;
+    }
+    /**
+     * Gestione di default degli errori
+     *
+     * @param {any} res Risultato della chiamata effettuata
+     * @param {string} guid Identificativo GUID della chiamata effettuata
+     */
+    async onError(res, guid) {
+        if (this.callStatus[guid])
+            this.callStatus[guid].success = false;
+        //Mi assicuro che tutti gli errori durante il redirect al login vengano ignorati
+        if (this.ExtensionsImpl.readRedirectingToLogin()) {
+            this.log(this.loc("Redirecting to Login, ignoring HTTP error on call") + " " + guid);
+            return;
+        }
+        //Mi assicuro che venga gestito un solo errore per volta
+        if (this.ExtensionsImpl.readHandlingErrorStatus()) {
+            this.log(this.loc("Already Handling an error, ignoring HTTP error on call") + " " + guid);
+            return;
+        }
+        else
+            this.ExtensionsImpl.writeHandlingErrorStatus(true);
+        let finalError = "";
+        let finalStatus = "";
+        if (this.isTypeError(res)) {
+            finalError = res.message;
+            finalStatus = "HTTP Service Internal Error";
+        }
+        else if (this.isHttpErrorResponse(res)) {
+            finalError = await this.getHttpErrorText(res.error);
+            finalStatus = res.status.toString();
+            switch (res.status) {
+                // Unauthorized
+                case 401:
+                    if (this.ExtensionsImpl.readRedirectionStatus()) {
+                        this.log(this.loc("Error 401 on call") + " " + guid + " " + this.loc("with redirect already in progress. Ignoring this event"));
+                        return;
+                    }
+                    this.log(this.loc("Error 401 on call") + " " + guid + " " + this.loc("redirecting to login."));
+                    this.ExtensionsImpl.writeRedirectionStatus(true);
+                    this.ExtensionsImpl.writeRedirectingToLogin(true);
+                    this.ExtensionsImpl.redirectToLogin();
+                    return;
+                // Handled exception
+                case 400:
+                // No Permissions
+                case 403:
+                    this.ExtensionsImpl.handleBlockingException(res.status, finalError);
+                    return;
+                // Not found
+                case 404:
+                    this.ExtensionsImpl.handleBlockingException(res.status, this.loc("Resource not found"));
+                    return;
+                // NotConfiguredException
+                case 444:
+                    if (this.ExtensionsImpl.readRedirectionStatus())
+                        this.log(this.loc("Error 444 on call") + " " + guid + " " + this.loc("with redirect already in progress. Ignoring this event"));
+                    else if (!this.ExtensionsImpl.handleNotConfiguredException())
+                        this.ExtensionsImpl.handleBlockingException(res.status, finalError);
+                    return;
+                case 0:
+                    finalError = `Generic connection error while calling '[${guid}] - ${this.callStatus[guid].url}' at ${dayjs().format()}. Response: ${JSON.stringify(res)}`;
+            }
+        }
+        this.ExtensionsImpl.handleException(finalStatus, finalError);
+    }
+    /**
+     * Dato un errore restituisce una promise con la stringa finale dell'errore in modo da poter fare un await
+     *
+     * @param {any} err Errore da controllare
+     *
+     * @returns {Promise<string>} Promise che risolve con la stringa finale dell'errore
+     */
+    getHttpErrorText(err) {
+        // Se ho un Blob può essere o un CallResult o suppongo una semplice stringa,
+        // altrimenti potrebbe essere direttamente un CallResult, oppure una semplice stringa
+        return new Promise((resolve) => {
+            if (err instanceof Blob) {
+                let reader = new FileReader();
+                reader.onload = (e) => {
+                    let errMsg = e.target.result;
+                    let jsonerrMsg;
+                    try {
+                        jsonerrMsg = JSON.parse(errMsg);
+                    }
+                    catch (e) { }
+                    return resolve(jsonerrMsg && this.isCallResult(jsonerrMsg) ? jsonerrMsg.error.message : errMsg);
+                };
+                reader.readAsText(err);
+            }
+            else if (this.isCallResult(err))
+                return resolve(err.error.message);
+            else
+                return resolve(err?.toString());
+        });
+    }
+    /**
+     * Riconosce se l'oggetto è di tipo **CallResult** e, se sì, lo casta al tipo corretto per essere utilizzato correttamente nel blocco di codice successivo
+     *
+     * @param {any} err Errore da controllare
+     */
+    isCallResult(err) {
+        return !!err?.error?.message;
+    }
+    /**
+     * Riconosce se l'errore è di tipo **HttpErrorResponse** e, se sì, lo casta al tipo corretto per essere utilizzato correttamente nel blocco di codice successivo
+     *
+     * @param {any} err Errore da controllare
+     */
+    isHttpErrorResponse(err) {
+        return err instanceof HttpErrorResponse;
+    }
+    /**
+    * Riconosce se l'errore è di tipo **TypeError** e, se sì, lo casta al tipo corretto per essere utilizzato correttamente nel blocco di codice successivo
+    *
+    * @param {any} err Errore da controllare
+    */
+    isTypeError(err) {
+        return err.name == "TypeError";
+    }
+    /**
+     * Come dice il nome, registra un errore e restituisce un Observable vuoto come risultato della chiamata
+     *
+     * @param {any} res Risultato della chiamata effettuata
+     * @param {string} guid Identificativo GUID della chiamata effettuata
+     * @param {boolean} handleError Indica se gestire l'errore via libreria o se limitarsi a restituire l'Observable vuoto
+     *
+     * @returns {Observable<any>} Observable vuoto
+     */
+    registerErrorAndReturnEmptyObservable(res, guid, handleError = true) {
+        if (handleError)
+            this.onError(res, guid);
+        return new Observable(() => { });
+    }
+    /**
+     * Dato un Url e dei parametri cerca di recuperare l'eventuale oggetto già salvato in cache con le informazioni base della cache stessa
+     *
+     * @param {string} url URL su cui effettuare la chiamata
+     * @param {HttpParams} params Parametri della chiamata (nulli in caso di POST)
+     *
+     * @returns {CacheInfos} Oggetto contenente le informazioni sulla cache per l'oggetto specificato
+     */
+    tryGetCacheInformations(url, params) {
+        let cachingKey = null, cacheTime = null, item = null;
+        let useCaching = !!(/#cache/gi.exec(url));
+        if (useCaching && this.CacheInitialized) {
+            let tmp = /#cache(:?-(\d+))/gi.exec(url);
+            cacheTime = tmp ? tmp[2] : null;
+            url = url.replace("#cache" + (cacheTime ? "-" + cacheTime : ""), "");
+            if (this.untimedCacheExpired() && !cacheTime)
+                this.resetHttpUntimedCacheStorage();
+            cachingKey = this.makeCacheKey(url, params);
+            let cacheKey = cacheTime ? this.localStorageHttpTimedCacheKey : this.localStorageHttpCacheKey;
+            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
+                if (cacheTime)
+                    delete cache[cachingKey].__expire;
+                item = cache[cachingKey];
+            }
+        }
+        // Per assicurarmi che il rifeirmento degli oggetti sia diverso utilizzo il deepClone
+        return new CacheInfos(url, useCaching && this.CacheInitialized, cachingKey, cacheTime, this.utisExts.deepClone(item));
+    }
+    /**
+     * Inserisce un oggetto nella cache appropriata in base alle informazioni contenute nel parametro **cacheInfos**
+     *
+     * @param {T} item Oggetto da inserire nella cache
+     * @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 = this.localStorage.getLocalItem(cacheKey);
+        let cache = cacheLs ? cacheLs : {};
+        cache[cacheInfos.cacheKey] = item;
+        if (cacheInfos.cacheTime)
+            cache[cacheInfos.cacheKey].__expire = dayjs().add(cacheInfos.cacheTime, "seconds");
+        this.localStorage.setLocalItem(cacheKey, cache);
+    }
+    /**
+     * Controlla se la cache per le chiamate senza expire time è scaduta
+     *
+     * @returns {boolean} **true** se la cache è scaduta e dev'essere ripulita, **false** altrimenti
+     */
+    untimedCacheExpired() {
+        let expire = JSON.parse(localStorage.getItem(this.localStorageHttpCacheExpireKey));
+        return !expire || expire && dayjs(expire) < dayjs();
+    }
+    /**
+     * Controlla se la cache per una chiamata che ha un tempo di vita ben definito è scaduta o meno
+     *
+     * @param {any} item Oggetto recuperato dalla cache a cui ho aggiunto la chiave interna __expire
+     *
+     * @returns {boolean} **true** se la cache è scaduta e dev'essere ripulita, **false** altrimenti
+     */
+    timedCacheItemExpired(item) {
+        return dayjs(item.__expire) < dayjs();
+    }
+    /**
+     * 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**)
+     */
+    async resetHttpUntimedCacheStorage() {
+        if (!this.CacheInitialized)
+            return;
+        await this.localStorage.setItem(this.localStorageHttpCacheKey, {}).toPromise();
+        localStorage.setItem(this.localStorageHttpCacheExpireKey, JSON.stringify(dayjs().add(this.CLIENT_CACHE_DURATION_S, "second")));
+    }
+    /**
+     * Ripulisce la cache delle chiamate con un tempo di expire definito
+     */
+    async resetHttpTimedCacheStorage() {
+        if (!this.CacheInitialized)
+            return;
+        await this.localStorage.setItem(this.localStorageHttpTimedCacheKey, {}).toPromise();
+    }
+    /**
+     * Genera una chiave per la cache delle chiamate in base ad URL e Parametri HTTP
+     *
+     * @param {string} url URL su cui effettuare la chiamata
+     * @param {HttpParams} params Parametri della chiamata
+     *
+     * @returns {string} Chiave che rappresenta in maniera univoca la chiamata
+     */
+    makeCacheKey(url, params) {
+        this.me = this.me || this.ExtensionsImpl.retrieveIdentity();
+        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.substring(url.indexOf("api") + 4) + "?" + paramsKeyPart;
+    }
+    /**
+     * Generazione GUID
+     *
+     * @returns {string} Nuovo GUID generato in maniera casuale
+     */
+    getGUID() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+            var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        });
+    }
+    /**
+     * Metodo per scrivere log a console qualora **DEBUG_MODE** risultasse **true**
+     *
+     * @param {string} message Messaggio di log
+     */
+    log(message) {
+        if (this.HTTP_DEBUG_MODE)
+            console.log("@httpservice: " + message);
+    }
+    /**
+     * Helper per la localizzazione dei messaggi
+     *
+     * @param {string} message Messaggio da localizzare
+     *
+     * @returns {string} Messaggio localizzato
+     */
+    loc(message) {
+        // Togliamo velocemente ste localizzazioni inutili....
+        return message;
+    }
+    /**
+     * Helper per lanciare la selezione di tutto quello che è relativo a un api di ricerca con AppSearch (di cui non utilizzo il tipo vero per ridurre le dipendenze)
+     */
+    getAll(view, api, pars, transaction) {
+        if (!view.selection.all)
+            return of(view.selection.items);
+        var jsonView = this.utisExts.deepClone(view);
+        jsonView.page = 1;
+        jsonView.itemsperpageoverride = 999999;
+        return this.post(api, jsonView, pars, transaction).pipe(map(res => {
+            let items = res.items;
+            items.forEach(t => t.hash = this.hash.hashObject(t, null, false));
+            if (res.selection.exclusions?.length > 0)
+                items = items.filter((t) => !res.selection.exclusions.find((e) => this.hash.hashObject(e, null, false) == t.hash));
+            return items;
+        }));
+    }
+    beginTransaction(executionKey, secondsTimeout) {
+        this.log("beginTransaction call received: " + executionKey);
+        var pars = new HttpParams().set("executionKey", executionKey);
+        if (secondsTimeout)
+            pars = pars.set("secondsTimeout", secondsTimeout.toString());
+        return this.get(this.GET_Trans_BeginTrans, pars);
+    }
+    checkTransaction(executionKey) {
+        this.log("checkTransaction call received: " + executionKey);
+        return this.get(this.GET_Trans_CheckExecution, new HttpParams().set("executionKey", executionKey));
+    }
+    endTransaction(transactionKey, transactionResult) {
+        this.log("endTransaction call received: " + transactionKey + " Commit: " + transactionResult);
+        let pars = new HttpParams().set("idtrans", transactionKey).set("success", transactionResult.toString());
+        return this.get(this.GET_Trans_EndTrans, pars);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HTTPService, deps: [{ token: HttpServiceExtensions }, { token: HTTP_INVALIDATION, optional: true }, { token: CLIENT_CACHE_DURATION_S }, { token: CACHE_BY_USER }, { token: HTTP_DEBUG_MODE }, { token: i2.BaseLocalization }, { token: i3.HttpClient }, { token: i4.CacheService }, { token: i5.HashingService }, { token: i5.UtilityService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HTTPService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HTTPService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: HttpServiceExtensions }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [HTTP_INVALIDATION]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [CLIENT_CACHE_DURATION_S]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [CACHE_BY_USER]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [HTTP_DEBUG_MODE]
+                }] }, { type: i2.BaseLocalization }, { type: i3.HttpClient }, { type: i4.CacheService }, { type: i5.HashingService }, { type: i5.UtilityService }] });
 
-class HttpserviceModule {
-    static forRoot(config) {
-        return {
-            ngModule: HttpserviceModule,
-            providers: [
-                { provide: HTTP_INVALIDATION, useValue: config?.httpInvalidation },
-                { provide: CLIENT_CACHE_DURATION_S, useValue: config?.clientCacheDurationS || 3600 },
-                { provide: CACHE_BY_USER, useValue: config?.cacheByUser || false },
-                { provide: HTTP_DEBUG_MODE, useValue: config?.debugMode || false }
-            ]
-        };
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HttpserviceModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: HttpserviceModule }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HttpserviceModule }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HttpserviceModule, decorators: [{
-            type: NgModule
+class HttpserviceModule {
+    static forRoot(config) {
+        return {
+            ngModule: HttpserviceModule,
+            providers: [
+                { provide: HTTP_INVALIDATION, useValue: config?.httpInvalidation },
+                { provide: CLIENT_CACHE_DURATION_S, useValue: config?.clientCacheDurationS || 3600 },
+                { provide: CACHE_BY_USER, useValue: config?.cacheByUser || false },
+                { provide: HTTP_DEBUG_MODE, useValue: config?.debugMode || false }
+            ]
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HttpserviceModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: HttpserviceModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HttpserviceModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HttpserviceModule, decorators: [{
+            type: NgModule
         }] });
 
-/**
- * Classe di configurazione per il Modulo della libreria
- */
-class HttpServiceModuleConfig {
+/**
+ * Classe di configurazione per il Modulo della libreria
+ */
+class HttpServiceModuleConfig {
 }
 
-class Download {
+class Download {
 }
 
-/*
- * Public API Surface of httpservice
+/*
+ * Public API Surface of httpservice
  */
 
-/**
- * Generated bundle index. Do not edit.
+/**
+ * Generated bundle index. Do not edit.
  */
 
 export { APP_NAME, CACHE_BY_USER, CLIENT_CACHE_DURATION_S, Download, HTTPService, HTTP_DEBUG_MODE, HTTP_INVALIDATION, HttpServiceExtensions, HttpServiceModuleConfig, HttpserviceModule };