@esfaenza/httpservice 12.2.22 → 13.1.0

package/fesm2020/esfaenza-httpservice.mjs

@@ -0,0 +1,885 @@
+import * as i2 from '@angular/common/http';
+import { HttpEventType, HttpHeaders, HttpErrorResponse } from '@angular/common/http';
+import * as i0 from '@angular/core';
+import { InjectionToken, Injectable, Inject, Optional, NgModule } from '@angular/core';
+import { delay, finalize, map, catchError, scan } from 'rxjs/operators';
+import { of, throwError, Observable } from 'rxjs';
+
+/**
+ * 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');
+/**
+ * URL del Backend a cui inviare le chiamate
+ */
+const BACKEND_URL = new InjectionToken('BACKEND_URL');
+/**
+ * Locale della libreria per messaggi d'errore ed Header di default "Accept-Language". Sono supportati "it-IT" ed "en-US"
+ */
+const HTTP_LOCALE = new InjectionToken('HTTP_LOCALE');
+/**
+ * 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 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);
+    }
+}
+
+/**
+ * Oggetto statico di localizzazione per i messaggi
+ */
+const Loc = {
+    "Result for": { "en-US": "Result for", "it-IT": "Risultato per", },
+    "retrieved from cache": { "en-US": "retrieved from cache", "it-IT": "recuperato dalla cache", },
+    "Cached result for": { "en-US": "Cached result for", "it-IT": "Messo in cache risultato per", },
+    "Starting call": { "en-US": "Starting call", "it-IT": "Inizio la chiamata", },
+    "at URL": { "en-US": "at URL", "it-IT": "all'URL", },
+    "Invlalidating cache element": { "en-US": "Invlalidating cache element", "it-IT": "Invalido elemento della cache", },
+    "Finalizing call": { "en-US": "Finalizing call", "it-IT": "Finalizzo chiamata", },
+    "with status": { "en-US": "with status", "it-IT": "con stato", },
+    "Success": { "en-US": "Success", "it-IT": "Successso", },
+    "Failure": { "en-US": "Failure", "it-IT": "Fallimento", },
+    "Error 401 on call": { "en-US": "Error 401 on call", "it-IT": "Errore 401 su chiamata", },
+    "with redirect already in progress. Ignoring this event": { "en-US": "with redirect already in progress. Ignoring this event", "it-IT": "con redirezione già in corso. Ignoro l'evento", },
+    "redirecting to login": { "en-US": "redirecting to login", "it-IT": "redireziono al login", },
+    "Redirecting to Login, ignoring HTTP error on call": { "en-US": "Redirecting to Login, ignoring HTTP error on call", "it-IT": "Redireziono al login ignorando errori sulla chiamata", },
+    "Already Handling an error, ignoring HTTP error on call": { "en-US": "Already Handling an error, ignoring HTTP error on call", "it-IT": "sto già gestendo un errore, ignoro quello corrente per la chiamata HTTP", },
+    "Error 444 on call": { "en-US": "Error 444 on call", "it-IT": "Errore 444 su chiamata" },
+    "Resource not found": { "en-US": "Resource not found", "it-IT": "Risorsa non trovata" }
+};
+
+// 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(BACKEND_URL, EXTENSION_CLASS, HTTP_INVALIDATION, LOCALE, APP_NAME, CLIENT_CACHE_DURATION_S, CACHE_BY_USER, DEBUG_MODE, http) {
+        this.BACKEND_URL = BACKEND_URL;
+        this.EXTENSION_CLASS = EXTENSION_CLASS;
+        this.HTTP_INVALIDATION = HTTP_INVALIDATION;
+        this.LOCALE = LOCALE;
+        this.APP_NAME = APP_NAME;
+        this.CLIENT_CACHE_DURATION_S = CLIENT_CACHE_DURATION_S;
+        this.CACHE_BY_USER = CACHE_BY_USER;
+        this.DEBUG_MODE = DEBUG_MODE;
+        this.http = http;
+        /**
+         * Cache dello stato delle chiamate HTTP attualmente effettuate. Ogni chiamata è rappresentata da un GUID e lo status assume valore **false** solo sugli errori
+         */
+        this.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;
+        this.ExtensionsImpl = this.EXTENSION_CLASS || new HttpServiceExtensions();
+        this.me = this.ExtensionsImpl.retrieveIdentity();
+        this.localStorageHttpCacheKey = (this.APP_NAME ?? "APP").replace(/\s/g, '_') + "_HttpCache";
+        this.localStorageHttpTimedCacheKey = (this.APP_NAME ?? "APP").replace(/\s/g, '_') + "_HttpTimedCache";
+        this.localStorageHttpCacheExpireKey = this.localStorageHttpCacheKey + "_Expire";
+        if (this.untimedCacheExpired())
+            this.resetHttpUntimedCacheStorage();
+    }
+    /**
+     * 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) {
+        let myGuid = this.defaultStartCall(url);
+        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(myGuid); }));
+        }
+        var httpCall = this.http.get(cachedInfos.finalUrl, { headers: this.getHeaders(transaction), params: params });
+        return httpCall.pipe(map((res) => {
+            let responseItem = res;
+            if (cachedInfos.cache) {
+                this.cacheResponse(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, myGuid);
+        }), finalize(() => { this.tryFinalizeByGuid(myGuid); }));
+    }
+    /**
+     * 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) {
+        let myGuid = this.defaultStartCall(url);
+        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(myGuid); }));
+        }
+        var httpCall = this.http.get(cachedInfos.finalUrl, { responseType: type, headers: this.getHeaders(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, myGuid);
+        }), finalize(() => { this.tryFinalizeByGuid(myGuid); }));
+    }
+    /**
+    * 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) {
+        let myGuid = this.defaultStartCall(url);
+        var httpCall = this.http.post(url, bodyData, { headers: this.getHeaders(transaction), params: params });
+        return httpCall.pipe(map((res) => {
+            let responseItem = res;
+            return responseItem;
+        }), catchError((err, caught) => {
+            return !succesfulResultMandatory ? throwError(err) : this.registerErrorAndReturnEmptyObservable(err, myGuid);
+        }), finalize(() => { this.tryFinalizeByGuid(myGuid); }));
+    }
+    /**
+    * Esecuzione di una DELETE HTTP
+    *
+    * @param {string} url URL su cui effettuare la chiamata
+    * @param {HttpParams} params Parametri della chiamata
+    * @param {string} transaction Codice transazione collegato a questa chiamata. Viene inserito nell'Header "X-TX-ID" e lato Backend dovrà essere gestito di conseguenza
+    * @param {boolean} succesfulResultMandatory Indica che questa chiamata deve assolutamente andare bene. In caso contrario viene fisicamente fatto il throw che può essere
+    * raccolto da chi usa la libreria nella pipe "onError" dell'Observable restituito ed essere gestito in maniera non standard
+    *
+    * @returns {Observable<T>} Observable che contiene il risultato della chiamata
+    */
+    delete(url, params = null, transaction = "", succesfulResultMandatory = true) {
+        let myGuid = this.defaultStartCall(url);
+        var httpCall = this.http.delete(url, { headers: this.getHeaders(transaction), params: params });
+        return httpCall.pipe(map((res) => {
+            let responseItem = res;
+            return responseItem;
+        }), catchError((err, caught) => {
+            return !succesfulResultMandatory ? throwError(err) : this.registerErrorAndReturnEmptyObservable(err, myGuid);
+        }), finalize(() => { this.tryFinalizeByGuid(myGuid); }));
+    }
+    /**
+     * Esecuzione di una PUT HTTP
+     *
+     * @param {string} url URL su cui effettuare la chiamata
+     * @param {any} bodyData DTO per la chiamata
+     * @param {HttpParams} params Parametri della chiamata
+     * @param {string} transaction Codice transazione collegato a questa chiamata. Viene inserito nell'Header "X-TX-ID" e lato Backend dovrà essere gestito di conseguenza
+     * @param {boolean} succesfulResultMandatory Indica che questa chiamata deve assolutamente andare bene. In caso contrario viene fisicamente fatto il throw che può essere
+     * raccolto da chi usa la libreria nella pipe "onError" dell'Observable restituito ed essere gestito in maniera non standard
+     *
+     * @returns {Observable<T>} Observable che contiene il risultato della chiamata
+     */
+    put(url, bodyData, params = null, transaction = "", succesfulResultMandatory = true) {
+        let myGuid = this.defaultStartCall(url);
+        var httpCall = this.http.put(url, bodyData, { headers: this.getHeaders(transaction), params: params });
+        return httpCall.pipe(map((res) => {
+            let responseItem = res;
+            return responseItem;
+        }), catchError((err, caught) => {
+            return !succesfulResultMandatory ? throwError(err) : this.registerErrorAndReturnEmptyObservable(err, myGuid);
+        }), finalize(() => { this.tryFinalizeByGuid(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) {
+        let myGuid = this.defaultStartCall(url);
+        var formData = this.getFilesFormData(fileArrayOrFile);
+        formData.append("body", JSON.stringify(bodyData));
+        var httpCall = this.http.post(url, formData, { headers: this.getHeaders(null, true, null, null) });
+        return httpCall.pipe(catchError((err, caught) => { return this.registerErrorAndReturnEmptyObservable(err, myGuid); }), finalize(() => { this.tryFinalizeByGuid(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
+     */
+    postGetFile(url, bodyData, filename, getFileCallback, afterGetFile = null, handleError = true) {
+        let myGuid = this.defaultStartCall(url);
+        this.http.post(url, bodyData, { headers: this.getHeaders(), 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
+     */
+    getFile(url, params = null, filename, getFileCallback, afterGetFile = null, handleError = true) {
+        let myGuid = this.defaultStartCall(url);
+        this.http.get(url, { params: params, headers: this.getHeaders(), 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) {
+        let finalUrl = url + (params ? "?" + params.toString() : "");
+        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) {
+        let myGuid = this.defaultStartCall(url);
+        return this.http.get(url, { responseType: 'blob', headers: this.getHeaders(), 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, myGuid); }), finalize(() => { this.tryFinalizeByGuid(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] = 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) {
+        let cache = JSON.parse(localStorage.getItem(this.localStorageHttpCacheKey));
+        let tmp = /#cache(:?-(\d+))/gi.exec(url);
+        let cacheTime = tmp ? tmp[2] : null;
+        let normalizedUrl = url.replace("#cache" + (cacheTime ? "-" + cacheTime : ""), "").replace(this.BACKEND_URL, "");
+        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];
+        }
+        localStorage.setItem(this.localStorageHttpCacheKey, JSON.stringify(cache));
+    }
+    /**
+     * Finalizzazione di una chiamata
+     *
+     * @param {string} guid GUID collegato alla chiamata appena terminata
+     */
+    tryFinalizeByGuid(guid) {
+        this.log(this.loc("Finalizing call") + " " + guid + " " + this.loc("with status") + ": " + (this.callStatus[guid] ? this.loc('Success') : this.loc('Failure')));
+        //Alla prima chiamata buona, significa che almeno il login ce l'ho. Posso mettermi in modalità redirectInProgress false
+        //e riiniziare a valutare errori di javashit
+        if (this.callStatus[guid] && this.ExtensionsImpl.readRedirectionStatus())
+            this.ExtensionsImpl.writeRedirectionStatus(false);
+        //In ogni caso questa posso rimuoverla
+        delete this.callStatus[guid];
+    }
+    /**
+     * 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(transactionId = "", includeAuth = true, contentType = "application/json", accept = "application/json") {
+        var headers = new HttpHeaders();
+        var authtoken = this.ExtensionsImpl.retrieveAccessToken();
+        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", "application/json");
+        headers = headers.append("Accept-Language", this.LOCALE ?? 'it-IT');
+        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) {
+        this.callStatus[guid] = 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 = "Server might be offline" + (res.statusText ? " (" + res.statusText + ") " : "");
+            }
+        }
+        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 {{ finalUrl: string, cache: boolean, cacheKey: string, cacheTime: string, cacheItem: any }} Oggetto contenente le informazioni sulla cache per l'oggetto specificato
+     */
+    tryGetCacheInformations(url, params) {
+        let cachingKey = null, cacheTime = null, cache = null, item = null;
+        let useCaching = !!(/#cache/gi.exec(url));
+        if (useCaching) {
+            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 = localStorage.getItem(cacheKey);
+            let cache = cacheLs ? JSON.parse(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];
+            }
+        }
+        return { finalUrl: url, cache: useCaching, cacheKey: cachingKey, cacheTime: cacheTime, cacheItem: item };
+    }
+    /**
+     * Inserisce un oggetto nella cache appropriata in base alle informazioni contenute nel parametro **cacheInfos**
+     *
+     * @param {T} item Oggetto da inserire nella cache
+     * @param {{ finalUrl: string, cache: boolean, cacheKey: string, cacheTime: string, cacheItem: any }} cacheInfos Informazioni sulla cache recuperate da una chiamata precedente a **tryGetCacheInformations**
+     */
+    cacheResponse(item, cacheInfos) {
+        let cacheKey = cacheInfos.cacheTime ? this.localStorageHttpTimedCacheKey : this.localStorageHttpCacheKey;
+        let cacheLs = localStorage.getItem(cacheKey);
+        let cache = cacheLs ? JSON.parse(cacheLs) : {};
+        cache[cacheInfos.cacheKey] = item;
+        if (cacheInfos.cacheTime)
+            cache[cacheInfos.cacheKey].__expire = dayjs().add(cacheInfos.cacheTime, "seconds");
+        localStorage.setItem(cacheKey, JSON.stringify(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**)
+     */
+    resetHttpUntimedCacheStorage() {
+        localStorage.setItem(this.localStorageHttpCacheKey, JSON.stringify({}));
+        localStorage.setItem(this.localStorageHttpCacheExpireKey, JSON.stringify(dayjs().add(this.CLIENT_CACHE_DURATION_S ?? 3600, "second")));
+    }
+    /**
+     * Ripulisce la cache delle chiamate con un tempo di expire definito
+     */
+    resetHttpTimedCacheStorage() {
+        localStorage.setItem(this.localStorageHttpTimedCacheKey, JSON.stringify({}));
+    }
+    /**
+     * 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) {
+        let authKeyPart = (this.me ? this.me.Idtenant : "") + (this.me && this.CACHE_BY_USER ? this.me.IdUser : "");
+        let paramsKeyPart = params && params.keys().length > 0 ? params.keys().reduce((prev, next) => prev + next + '=' + params.get(next), "") : "";
+        return authKeyPart + url + paramsKeyPart;
+    }
+    /**
+     * 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.DEBUG_MODE)
+            console.log("@httpservice: " + message);
+    }
+    /**
+     * Helper per la localizzazione dei messaggi
+     *
+     * @param {string} message Messaggio da localizzare
+     *
+     * @returns {string} Messaggio localizzato
+     */
+    loc(message) {
+        if (!Loc[message]) {
+            console.warn("Untranslated message: " + message);
+            return "";
+        }
+        return Loc[message][this.LOCALE];
+    }
+}
+HTTPService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: HTTPService, deps: [{ token: BACKEND_URL }, { token: HttpServiceExtensions }, { token: HTTP_INVALIDATION, optional: true }, { token: HTTP_LOCALE, optional: true }, { token: APP_NAME, optional: true }, { token: CLIENT_CACHE_DURATION_S, optional: true }, { token: CACHE_BY_USER, optional: true }, { token: DEBUG_MODE, optional: true }, { token: i2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+HTTPService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: HTTPService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: HTTPService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [BACKEND_URL]
+                }] }, { type: HttpServiceExtensions }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [HTTP_INVALIDATION]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [HTTP_LOCALE]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [APP_NAME]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [CLIENT_CACHE_DURATION_S]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [CACHE_BY_USER]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [DEBUG_MODE]
+                }] }, { type: i2.HttpClient }]; } });
+
+class HttpserviceModule {
+    static forRoot(config) {
+        return {
+            ngModule: HttpserviceModule,
+            providers: [
+                HTTPService,
+                HttpServiceExtensions,
+                { provide: HTTP_INVALIDATION, useValue: config?.httpInvalidation },
+                { provide: CLIENT_CACHE_DURATION_S, useValue: config?.clientCacheDurationS },
+                { provide: BACKEND_URL, useValue: config?.backendUrl },
+                { provide: HTTP_LOCALE, useValue: config?.httpLocale || 'it-IT' },
+                { provide: APP_NAME, useValue: config?.appName },
+                { provide: CACHE_BY_USER, useValue: config?.cacheByUser },
+                { provide: DEBUG_MODE, useValue: config?.debugMode }
+            ]
+        };
+    }
+}
+HttpserviceModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: HttpserviceModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+HttpserviceModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: HttpserviceModule });
+HttpserviceModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: HttpserviceModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: HttpserviceModule, decorators: [{
+            type: NgModule
+        }] });
+
+/**
+ * Classe di configurazione per il Modulo della libreria
+ */
+class HttpServiceModuleConfig {
+}
+
+class Download {
+}
+
+/*
+ * Public API Surface of httpservice
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { Download, HTTPService, HttpServiceExtensions, HttpServiceModuleConfig, HttpserviceModule };
+//# sourceMappingURL=esfaenza-httpservice.mjs.map