@esfaenza/httpservice 19.2.26 → 19.2.30

package/fesm2022/esfaenza-httpservice.mjs

@@ -105,10 +105,10 @@ class HttpServiceExtensions {
     handleException(status, text) {
         console.error("ESHttpError " + status + " " + text);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.13", ngImport: i0, type: HttpServiceExtensions, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.13", ngImport: i0, type: HttpServiceExtensions, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: HttpServiceExtensions, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: HttpServiceExtensions, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.13", ngImport: i0, type: HttpServiceExtensions, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: HttpServiceExtensions, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -1033,10 +1033,10 @@ class HTTPService {
         }
         return r.length > 0 ? "o:" + r.join(";") : "";
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.13", ngImport: i0, type: HTTPService, deps: [{ token: HttpServiceExtensions }, { token: HTTP_INVALIDATION, optional: true }, { token: CLIENT_CACHE_DURATION_S, optional: true }, { token: CACHE_BY_USER, optional: true }, { token: HTTP_DEBUG_MODE, optional: true }, { token: i2.BaseLocalization, optional: true }, { token: i3.HttpClient }, { token: i4.CacheService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.13", ngImport: i0, type: HTTPService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: HTTPService, deps: [{ token: HttpServiceExtensions }, { token: HTTP_INVALIDATION, optional: true }, { token: CLIENT_CACHE_DURATION_S, optional: true }, { token: CACHE_BY_USER, optional: true }, { token: HTTP_DEBUG_MODE, optional: true }, { token: i2.BaseLocalization, optional: true }, { token: i3.HttpClient }, { token: i4.CacheService, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: HTTPService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.13", ngImport: i0, type: HTTPService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: HTTPService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: HttpServiceExtensions }, { type: undefined, decorators: [{
@@ -1077,11 +1077,11 @@ class HttpserviceModule {
             ]
         };
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.13", ngImport: i0, type: HttpserviceModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.13", ngImport: i0, type: HttpserviceModule }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.13", ngImport: i0, type: HttpserviceModule }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: HttpserviceModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.25", ngImport: i0, type: HttpserviceModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: HttpserviceModule }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.13", ngImport: i0, type: HttpserviceModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.25", ngImport: i0, type: HttpserviceModule, decorators: [{
             type: NgModule
         }] });
 

package/index.d.ts

@@ -1,594 +1,5 @@
-import * as i0 from '@angular/core';
-import { InjectionToken, ModuleWithProviders } from '@angular/core';
-import { HttpClient, HttpParams } from '@angular/common/http';
-import { CacheService } from '@esfaenza/preferences';
-import { BaseLocalization } from '@esfaenza/localizations';
-import { Subject, Observable } from 'rxjs';
-
 /**
- * Dizionario di invalidazioni delle chiamate HTTP
+ * Generated bundle index. Do not edit.
  */
-declare const HTTP_INVALIDATION: InjectionToken<Record<string, string[]>>;
-/**
- * Durata della cache lato libreria dopo il quale la cache verrà ripulita
- */
-declare const CLIENT_CACHE_DURATION_S: InjectionToken<number>;
-/**
- * Nome dell'APP utilizzato per creare le chiavi delle cache specifiche per l'applicazione corrente
- */
-declare const APP_NAME: InjectionToken<string>;
-/**
- * Indica se utilizzare l'identificativo utente nella cache
- */
-declare const CACHE_BY_USER: InjectionToken<boolean>;
-/**
- * Indica se fare log nella console ad ogni azione significativa
- */
-declare const HTTP_DEBUG_MODE: InjectionToken<boolean>;
-
-/**
- * Interfaccia per la 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
- */
-interface IHttpServiceExtensions {
-    /**
-     * Hook per recuperare l'access token con cui effettuare le chiamate HTTP
-     */
-    retrieveAccessToken(): string;
-    /**
-     * Hook per recuperare l'Identity corrente in un oggetto generico con le informazioni di User e Tenant
-     */
-    retrieveIdentity(): {
-        IdUser: string;
-        Idtenant: string;
-    };
-    /**
-     * Hook per leggere dallo stato dell'applicazione se stiamo già venendo ridirezionati al login, in modo da non tentare di effettuare
-     * 10 redirect contemporaneamente qualora molte API fallissero allo stesso tempo nell'autenticazione
-     */
-    readRedirectingToLogin(): boolean;
-    /**
-     * Hook per scrivere nello stato dell'applicazione se stiamo effettuando un redirect al login o meno
-     */
-    writeRedirectingToLogin(status: boolean): any;
-    /**
-     * Hook per effettuare il redirect al login
-     */
-    redirectToLogin(): void;
-    /**
-     * 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(): boolean;
-    /**
-     * Hook per scrivere nello stato dell'applicazione se stiamo gestendo un errore o meno
-     */
-    writeHandlingErrorStatus(status: boolean): any;
-    /**
-     * 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(): boolean;
-    /**
-     * Hook per scrivere nello stato dell'applicazione se stiamo gestendo un redirect o meno
-     */
-    writeRedirectionStatus(status: boolean): void;
-    /**
-     * 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(): boolean;
-    /**
-     * Hook per la gestione di un qualsiasi errore bloccante per l'operazione attuale, ma non fatale (Generalmente gestibile da dialog di avviso)
-     */
-    handleBlockingException(status: number, text: string): any;
-    /**
-     * Hook per la gestione di un qualsiasi errore fatale (Generalmente gestibile tramite navigazione a una pagina di errore custom per l'applicativo)
-     */
-    handleException(status: number, text: string): any;
-}
-
-/**
- * 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
- */
-declare class HttpServiceExtensions implements IHttpServiceExtensions {
-    /**
-     * Hook per recuperare l'access token con cui effettuare le chiamate HTTP
-     */
-    retrieveAccessToken(): string;
-    /**
-     * Hook per recuperare l'Identity corrente in un oggetto generico con le informazioni di User e Tenant
-     */
-    retrieveIdentity(): {
-        IdUser: string;
-        Idtenant: string;
-    };
-    /**
-     * 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(): boolean;
-    /**
-     * Hook per scrivere nello stato dell'applicazione se stiamo effettuando un redirect al login o meno
-     */
-    writeRedirectingToLogin(status: boolean): void;
-    /**
-     * Hook per effettuare il redirect al login
-     */
-    redirectToLogin(): void;
-    /**
-     * 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(): boolean;
-    /**
-     * Hook per scrivere nello stato dell'applicazione se stiamo gestendo un errore o meno
-     */
-    writeHandlingErrorStatus(status: boolean): void;
-    /**
-     * 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(): boolean;
-    /**
-     * Hook per scrivere nello stato dell'applicazione se stiamo gestendo un redirect o meno
-     */
-    writeRedirectionStatus(status: boolean): void;
-    /**
-     * 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(): boolean;
-    /**
-     * Hook per la gestione di un qualsiasi errore bloccante per l'operazione attuale, ma non fatale (Generalmente gestibile da dialog di avviso)
-     */
-    handleBlockingException(status: number, text: string): void;
-    /**
-     * Hook per la gestione di un qualsiasi errore fatale (Generalmente gestibile tramite navigazione a una pagina di errore custom per l'applicativo)
-     */
-    handleException(status: number | string, text: string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<HttpServiceExtensions, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<HttpServiceExtensions>;
-}
-
-declare class Download {
-    state: 'PENDING' | 'IN_PROGRESS' | 'DONE';
-    progress: number;
-    content: Blob | null;
-}
-
-/**
- * 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**
- */
-declare class HTTPService {
-    private EXTENSION_CLASS;
-    private HTTP_INVALIDATION;
-    private CLIENT_CACHE_DURATION_S;
-    private CACHE_BY_USER;
-    private HTTP_DEBUG_MODE;
-    private bc;
-    private http;
-    private localStorage;
-    /** Cache dello stato delle chiamate HTTP attualmente effettuate. Ogni chiamata è rappresentata da un GUID e lo status assume valore **false** solo sugli errori */
-    private callStatus;
-    /** Nome della cache in cui vengono storicizzate le informazioni sulle risposte delle chiamate sotto forma di dictionary */
-    private localStorageHttpCacheKey;
-    /** 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 */
-    private localStorageHttpTimedCacheKey;
-    /** Nome della cache in cui vengono storicizzate le informazioni sullo scadere della cache stessa */
-    private localStorageHttpCacheExpireKey;
-    /** Identità collegata al token di autenticazione da usare, richiesta al programma che utilizza la libreria attraverso l'hook **retrieveIdentity** della **HttpServiceExtensions** */
-    private me;
-    /** Indica che la cache a tempo dev'essere persistita il prima possibile */
-    private PersistTimedCacheASAP;
-    /** Indica che la cache senza limiti di tempo dev'essere persistita il prima possibile */
-    private PersistUntimedCacheASAP;
-    /** Subject emesso quando il servizio http si stabilizza, cioè quando non c'è nessuna chiamata pending o in corso da qualche istante */
-    Stabilized: Subject<true>;
-    /**
-     * Implementazione della classe di estensione per collegare i comportamenti della libreria all'applicazione in cui è usata.
-     *
-     * Se è stato effettuato il provide della classe **HttpServiceExtensions** verrà usato quel provider, altrimenti verrà creata una nuova istanza di default
-     */
-    private ExtensionsImpl;
-    /** Lista delle ultime 3 chiamate completate con successo in ordine di completamento (in posizione 0 c'è l'ultima completata eccetera...) */
-    LastThreeCompletedCalls: {
-        api: string;
-        requestJson: string;
-        responseJson: any;
-    }[];
-    private CacheInitialized;
-    /**
-     * @ignore
-     */
-    constructor(EXTENSION_CLASS: HttpServiceExtensions, HTTP_INVALIDATION: any, CLIENT_CACHE_DURATION_S: any, CACHE_BY_USER: boolean, HTTP_DEBUG_MODE: boolean, bc: BaseLocalization, http: HttpClient, localStorage: CacheService);
-    setAppConfig(myconfig: {
-        AppData: {
-            ModuleId: string;
-            ModuleDefId: number;
-            ComponentEnvironment: string;
-            ComponentVersion: string;
-            ModuleDescription: string;
-        };
-    }): void;
-    /**
-     * 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
-     */
-    private adjustOldStorageSystem;
-    getlocaleObservable(): Observable<string>;
-    /**
-     * 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<T>(url: string, params?: HttpParams, transaction?: string, succesfulResultMandatory?: boolean, errorCallback?: Function): Observable<T>;
-    /**
-     * 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: string, params?: HttpParams, type?: "arraybuffer" | "blob", transaction?: string, succesfulResultMandatory?: boolean, errorCallback?: any): Observable<Blob | ArrayBuffer>;
-    /**
-    * 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<T>(url: string, bodyData: any, params?: HttpParams, transaction?: string, succesfulResultMandatory?: boolean): Observable<T>;
-    /**
-    * 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<T>(url: string, params?: HttpParams, transaction?: string, succesfulResultMandatory?: boolean): Observable<T>;
-    /**
-     * 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<T>(url: string, bodyData: any, params?: HttpParams, transaction?: string, succesfulResultMandatory?: boolean): Observable<T>;
-    /**
-     * 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<T>(url: string, bodyData: any, fileArrayOrFile: File[] | File, params?: HttpParams, succesfulResultMandatory?: boolean, onError?: () => void): Observable<T>;
-    /**
-     * 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<K>(url: string, bodyData: K, filename: string, getFileCallback: (url: string, filename: string) => any, afterGetFile?: () => any, handleError?: boolean, pars?: HttpParams): Promise<void>;
-    /**
-     * 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: string, params: HttpParams, filename: string, getFileCallback: (url: string, filename: string) => any, afterGetFile?: () => any, handleError?: boolean): Promise<void>;
-    /**
-     * 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: string, params?: HttpParams): void;
-    /**
-     * 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: string, params: HttpParams, getFileCallback: (url: string, filename: string) => any): Observable<Download>;
-    /**
-     * 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
-     */
-    private isHttpResponse;
-    /**
-     * 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
-     */
-    private isHttpProgressEvent;
-    /**
-     * 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
-     */
-    private defaultStartCall;
-    /**
-     * 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
-     */
-    private checkCacheInvalidation;
-    /**
-     * 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
-     */
-    private tryFinalizeByGuid;
-    /**
-     * 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
-     */
-    private getFilesFormData;
-    /**
-     * 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
-     */
-    private getHeaders;
-    /**
-     * Gestione di default degli errori
-     *
-     * @param {any} res Risultato della chiamata effettuata
-     * @param {string} guid Identificativo GUID della chiamata effettuata
-     */
-    private onError;
-    /**
-     * 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
-     */
-    private getHttpErrorText;
-    /**
-     * 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
-     */
-    private isCallResult;
-    /**
-     * 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
-     */
-    private isHttpErrorResponse;
-    /**
-    * 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
-    */
-    private isTypeError;
-    /**
-     * 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
-     */
-    private registerErrorAndReturnEmptyObservable;
-    /**
-     * 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
-     */
-    private tryGetCacheInformations;
-    /**
-     * 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**
-     */
-    private cacheResponse;
-    /**
-     * Controlla se la cache per le chiamate senza expire time è scaduta
-     *
-     * @returns {boolean} **true** se la cache è scaduta e dev'essere ripulita, **false** altrimenti
-     */
-    private untimedCacheExpired;
-    /**
-     * 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
-     */
-    private timedCacheItemExpired;
-    /**
-     * 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(): Promise<void>;
-    /**
-     * Ripulisce la cache delle chiamate con un tempo di expire definito
-     */
-    resetHttpTimedCacheStorage(): Promise<void>;
-    /**
-     * 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
-     */
-    private makeCacheKey;
-    /**
-     * Generazione GUID
-     *
-     * @returns {string} Nuovo GUID generato in maniera casuale
-     */
-    private getGUID;
-    /**
-     * Metodo per scrivere log a console qualora **DEBUG_MODE** risultasse **true**
-     *
-     * @param {string} message Messaggio di log
-     */
-    private log;
-    /**
-     * Helper per la localizzazione dei messaggi
-     *
-     * @param {string} message Messaggio da localizzare
-     *
-     * @returns {string} Messaggio localizzato
-     */
-    private loc;
-    /**
-     * 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<T>(view: {
-        items: T[];
-        page: number;
-        itemsperpageoverride: number;
-        selection: {
-            exclusions: T[];
-            all: boolean;
-            items: T[];
-        };
-    }, api: string, pars?: HttpParams, transaction?: string): Observable<T[]>;
-    private hashObject;
-    /*****************************************************************************************************************************************
-     ***************************************************** TRANSACTION HELPERS ***************************************************************
-     *****************************************************************************************************************************************/
-    private GET_Trans_BeginTrans;
-    private GET_Trans_CheckExecution;
-    private GET_Trans_EndTrans;
-    beginTransaction(executionKey: string, secondsTimeout?: number): Observable<string>;
-    checkTransaction(executionKey: string): Observable<number>;
-    endTransaction(transactionKey: string, transactionResult: boolean): Observable<string>;
-    /*****************************************************************************************************************************************
-     ***************************************************** ROBA PER HASHING ******************************************************************
-     *****************************************************************************************************************************************/
-    /**
-     * Blacklist dei tipi da ignorare quando si effettua l'hashing degli oggetti
-     */
-    private objBlacklist;
-    /**
-     * Hash più semplice e più veloce dell'md5, ma meno sicuro
-     *
-     * Vedi https://stackoverflow.com/questions/7616461/generate-a-hash-from-string-in-javascript
-     *
-     * @param {string} str Stringa di cui calcolare l'hash
-     */
-    private simpleHash;
-    /**
-    * Genera una stringa che identifica univocamente l'oggetto in questione
-    *
-    * @param {any} o Oggetto di cui calcolare la stringa univoca
-    * @param {number} level Livello di ricorsione nel caso venga effettuato l'hash di un oggetto che contiene altri oggetti
-    * @param {boolean} navigateFullDepth Indica se navigare l'oggetto per l'intera lunghezza. In caso contrario si ferma al secondo livello
-    */
-    private stringify;
-    static ɵfac: i0.ɵɵFactoryDeclaration<HTTPService, [null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, null, { optional: true; }]>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<HTTPService>;
-}
-
-/**
- * Classe di configurazione per il Modulo della libreria
- */
-declare class HttpServiceModuleConfig {
-    /**
-     * Indica quali chiamate vengono invalidate da quali chiamate quando viene utilizzata una cache sulle risposte
-     */
-    httpInvalidation?: Record<string, string[]>;
-    /**
-     * Indica la durata della cache lato client (Browser), se utilizzata
-     */
-    clientCacheDurationS?: number;
-    /**
-     * Nome dell'applicazione che sta utilizzando la libreria, utilizzato per creare chiavi di cache specifiche per app
-     */
-    appName?: string;
-    /**
-     * Indica se la cache deve basarsi non solo sull'applicazione ma anche sull'utente connesso
-     */
-    cacheByUser?: boolean;
-    /**
-     * Abilita o disabilità la modalità di debug (Log a console)
-     */
-    debugMode?: boolean;
-}
-
-declare class HttpserviceModule {
-    static forRoot(config?: HttpServiceModuleConfig): ModuleWithProviders<HttpserviceModule>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<HttpserviceModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<HttpserviceModule, never, never, never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<HttpserviceModule>;
-}
-
-export { APP_NAME, CACHE_BY_USER, CLIENT_CACHE_DURATION_S, Download, HTTPService, HTTP_DEBUG_MODE, HTTP_INVALIDATION, HttpServiceExtensions, HttpServiceModuleConfig, HttpserviceModule };
-export type { IHttpServiceExtensions };
+/// <amd-module name="@esfaenza/httpservice" />
+export * from './public-api';

package/lib/config/HttpServiceExtensions.d.ts

@@ -0,0 +1,65 @@
+import { IHttpServiceExtensions } from './IHttpServiceExtensions';
+import * as i0 from "@angular/core";
+/**
+ * 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
+ */
+export declare class HttpServiceExtensions implements IHttpServiceExtensions {
+    /**
+     * Hook per recuperare l'access token con cui effettuare le chiamate HTTP
+     */
+    retrieveAccessToken(): string;
+    /**
+     * Hook per recuperare l'Identity corrente in un oggetto generico con le informazioni di User e Tenant
+     */
+    retrieveIdentity(): {
+        IdUser: string;
+        Idtenant: string;
+    };
+    /**
+     * 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(): boolean;
+    /**
+     * Hook per scrivere nello stato dell'applicazione se stiamo effettuando un redirect al login o meno
+     */
+    writeRedirectingToLogin(status: boolean): void;
+    /**
+     * Hook per effettuare il redirect al login
+     */
+    redirectToLogin(): void;
+    /**
+     * 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(): boolean;
+    /**
+     * Hook per scrivere nello stato dell'applicazione se stiamo gestendo un errore o meno
+     */
+    writeHandlingErrorStatus(status: boolean): void;
+    /**
+     * 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(): boolean;
+    /**
+     * Hook per scrivere nello stato dell'applicazione se stiamo gestendo un redirect o meno
+     */
+    writeRedirectionStatus(status: boolean): void;
+    /**
+     * 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(): boolean;
+    /**
+     * Hook per la gestione di un qualsiasi errore bloccante per l'operazione attuale, ma non fatale (Generalmente gestibile da dialog di avviso)
+     */
+    handleBlockingException(status: number, text: string): void;
+    /**
+     * Hook per la gestione di un qualsiasi errore fatale (Generalmente gestibile tramite navigazione a una pagina di errore custom per l'applicativo)
+     */
+    handleException(status: number | string, text: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpServiceExtensions, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HttpServiceExtensions>;
+}

package/lib/config/HttpServiceModuleConfig.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Classe di configurazione per il Modulo della libreria
+ */
+export declare class HttpServiceModuleConfig {
+    /**
+     * Indica quali chiamate vengono invalidate da quali chiamate quando viene utilizzata una cache sulle risposte
+     */
+    httpInvalidation?: Record<string, string[]>;
+    /**
+     * Indica la durata della cache lato client (Browser), se utilizzata
+     */
+    clientCacheDurationS?: number;
+    /**
+     * Nome dell'applicazione che sta utilizzando la libreria, utilizzato per creare chiavi di cache specifiche per app
+     */
+    appName?: string;
+    /**
+     * Indica se la cache deve basarsi non solo sull'applicazione ma anche sull'utente connesso
+     */
+    cacheByUser?: boolean;
+    /**
+     * Abilita o disabilità la modalità di debug (Log a console)
+     */
+    debugMode?: boolean;
+}

package/lib/config/IHttpServiceExtensions.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Interfaccia per la 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
+ */
+export interface IHttpServiceExtensions {
+    /**
+     * Hook per recuperare l'access token con cui effettuare le chiamate HTTP
+     */
+    retrieveAccessToken(): string;
+    /**
+     * Hook per recuperare l'Identity corrente in un oggetto generico con le informazioni di User e Tenant
+     */
+    retrieveIdentity(): {
+        IdUser: string;
+        Idtenant: string;
+    };
+    /**
+     * Hook per leggere dallo stato dell'applicazione se stiamo già venendo ridirezionati al login, in modo da non tentare di effettuare
+     * 10 redirect contemporaneamente qualora molte API fallissero allo stesso tempo nell'autenticazione
+     */
+    readRedirectingToLogin(): boolean;
+    /**
+     * Hook per scrivere nello stato dell'applicazione se stiamo effettuando un redirect al login o meno
+     */
+    writeRedirectingToLogin(status: boolean): any;
+    /**
+     * Hook per effettuare il redirect al login
+     */
+    redirectToLogin(): void;
+    /**
+     * 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(): boolean;
+    /**
+     * Hook per scrivere nello stato dell'applicazione se stiamo gestendo un errore o meno
+     */
+    writeHandlingErrorStatus(status: boolean): any;
+    /**
+     * 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(): boolean;
+    /**
+     * Hook per scrivere nello stato dell'applicazione se stiamo gestendo un redirect o meno
+     */
+    writeRedirectionStatus(status: boolean): void;
+    /**
+     * 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(): boolean;
+    /**
+     * Hook per la gestione di un qualsiasi errore bloccante per l'operazione attuale, ma non fatale (Generalmente gestibile da dialog di avviso)
+     */
+    handleBlockingException(status: number, text: string): any;
+    /**
+     * Hook per la gestione di un qualsiasi errore fatale (Generalmente gestibile tramite navigazione a una pagina di errore custom per l'applicativo)
+     */
+    handleException(status: number, text: string): any;
+}

package/lib/httpservice.module.d.ts

@@ -0,0 +1,9 @@
+import { ModuleWithProviders } from '@angular/core';
+import { HttpServiceModuleConfig } from './config/HttpServiceModuleConfig';
+import * as i0 from "@angular/core";
+export declare class HttpserviceModule {
+    static forRoot(config?: HttpServiceModuleConfig): ModuleWithProviders<HttpserviceModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpserviceModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HttpserviceModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HttpserviceModule>;
+}

package/lib/httpservice.service.d.ts

@@ -0,0 +1,405 @@
+import { HttpClient, HttpParams } from "@angular/common/http";
+import { CacheService } from "@esfaenza/preferences";
+import { BaseLocalization } from "@esfaenza/localizations";
+import { Observable, Subject } from "rxjs";
+import { HttpServiceExtensions } from './config/HttpServiceExtensions';
+import { Download } from './models/Download';
+import * as i0 from "@angular/core";
+/**
+ * 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**
+ */
+export declare class HTTPService {
+    private EXTENSION_CLASS;
+    private HTTP_INVALIDATION;
+    private CLIENT_CACHE_DURATION_S;
+    private CACHE_BY_USER;
+    private HTTP_DEBUG_MODE;
+    private bc;
+    private http;
+    private localStorage;
+    /** Cache dello stato delle chiamate HTTP attualmente effettuate. Ogni chiamata è rappresentata da un GUID e lo status assume valore **false** solo sugli errori */
+    private callStatus;
+    /** Nome della cache in cui vengono storicizzate le informazioni sulle risposte delle chiamate sotto forma di dictionary */
+    private localStorageHttpCacheKey;
+    /** 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 */
+    private localStorageHttpTimedCacheKey;
+    /** Nome della cache in cui vengono storicizzate le informazioni sullo scadere della cache stessa */
+    private localStorageHttpCacheExpireKey;
+    /** Identità collegata al token di autenticazione da usare, richiesta al programma che utilizza la libreria attraverso l'hook **retrieveIdentity** della **HttpServiceExtensions** */
+    private me;
+    /** Indica che la cache a tempo dev'essere persistita il prima possibile */
+    private PersistTimedCacheASAP;
+    /** Indica che la cache senza limiti di tempo dev'essere persistita il prima possibile */
+    private PersistUntimedCacheASAP;
+    /** Subject emesso quando il servizio http si stabilizza, cioè quando non c'è nessuna chiamata pending o in corso da qualche istante */
+    Stabilized: Subject<true>;
+    /**
+     * Implementazione della classe di estensione per collegare i comportamenti della libreria all'applicazione in cui è usata.
+     *
+     * Se è stato effettuato il provide della classe **HttpServiceExtensions** verrà usato quel provider, altrimenti verrà creata una nuova istanza di default
+     */
+    private ExtensionsImpl;
+    /** Lista delle ultime 3 chiamate completate con successo in ordine di completamento (in posizione 0 c'è l'ultima completata eccetera...) */
+    LastThreeCompletedCalls: {
+        api: string;
+        requestJson: string;
+        responseJson: any;
+    }[];
+    private CacheInitialized;
+    /**
+     * @ignore
+     */
+    constructor(EXTENSION_CLASS: HttpServiceExtensions, HTTP_INVALIDATION: any, CLIENT_CACHE_DURATION_S: any, CACHE_BY_USER: boolean, HTTP_DEBUG_MODE: boolean, bc: BaseLocalization, http: HttpClient, localStorage: CacheService);
+    setAppConfig(myconfig: {
+        AppData: {
+            ModuleId: string;
+            ModuleDefId: number;
+            ComponentEnvironment: string;
+            ComponentVersion: string;
+            ModuleDescription: string;
+        };
+    }): void;
+    /**
+     * 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
+     */
+    private adjustOldStorageSystem;
+    getlocaleObservable(): Observable<string>;
+    /**
+     * 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<T>(url: string, params?: HttpParams, transaction?: string, succesfulResultMandatory?: boolean, errorCallback?: Function): Observable<T>;
+    /**
+     * 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: string, params?: HttpParams, type?: "arraybuffer" | "blob", transaction?: string, succesfulResultMandatory?: boolean, errorCallback?: any): Observable<Blob | ArrayBuffer>;
+    /**
+    * 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<T>(url: string, bodyData: any, params?: HttpParams, transaction?: string, succesfulResultMandatory?: boolean): Observable<T>;
+    /**
+    * 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<T>(url: string, params?: HttpParams, transaction?: string, succesfulResultMandatory?: boolean): Observable<T>;
+    /**
+     * 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<T>(url: string, bodyData: any, params?: HttpParams, transaction?: string, succesfulResultMandatory?: boolean): Observable<T>;
+    /**
+     * 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<T>(url: string, bodyData: any, fileArrayOrFile: File[] | File, params?: HttpParams, succesfulResultMandatory?: boolean, onError?: () => void): Observable<T>;
+    /**
+     * 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<K>(url: string, bodyData: K, filename: string, getFileCallback: (url: string, filename: string) => any, afterGetFile?: () => any, handleError?: boolean, pars?: HttpParams): Promise<void>;
+    /**
+     * 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: string, params: HttpParams, filename: string, getFileCallback: (url: string, filename: string) => any, afterGetFile?: () => any, handleError?: boolean): Promise<void>;
+    /**
+     * 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: string, params?: HttpParams): void;
+    /**
+     * 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: string, params: HttpParams, getFileCallback: (url: string, filename: string) => any): Observable<Download>;
+    /**
+     * 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
+     */
+    private isHttpResponse;
+    /**
+     * 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
+     */
+    private isHttpProgressEvent;
+    /**
+     * 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
+     */
+    private defaultStartCall;
+    /**
+     * 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
+     */
+    private checkCacheInvalidation;
+    /**
+     * 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
+     */
+    private tryFinalizeByGuid;
+    /**
+     * 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
+     */
+    private getFilesFormData;
+    /**
+     * 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
+     */
+    private getHeaders;
+    /**
+     * Gestione di default degli errori
+     *
+     * @param {any} res Risultato della chiamata effettuata
+     * @param {string} guid Identificativo GUID della chiamata effettuata
+     */
+    private onError;
+    /**
+     * 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
+     */
+    private getHttpErrorText;
+    /**
+     * 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
+     */
+    private isCallResult;
+    /**
+     * 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
+     */
+    private isHttpErrorResponse;
+    /**
+    * 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
+    */
+    private isTypeError;
+    /**
+     * 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
+     */
+    private registerErrorAndReturnEmptyObservable;
+    /**
+     * 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
+     */
+    private tryGetCacheInformations;
+    /**
+     * 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**
+     */
+    private cacheResponse;
+    /**
+     * Controlla se la cache per le chiamate senza expire time è scaduta
+     *
+     * @returns {boolean} **true** se la cache è scaduta e dev'essere ripulita, **false** altrimenti
+     */
+    private untimedCacheExpired;
+    /**
+     * 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
+     */
+    private timedCacheItemExpired;
+    /**
+     * 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(): Promise<void>;
+    /**
+     * Ripulisce la cache delle chiamate con un tempo di expire definito
+     */
+    resetHttpTimedCacheStorage(): Promise<void>;
+    /**
+     * 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
+     */
+    private makeCacheKey;
+    /**
+     * Generazione GUID
+     *
+     * @returns {string} Nuovo GUID generato in maniera casuale
+     */
+    private getGUID;
+    /**
+     * Metodo per scrivere log a console qualora **DEBUG_MODE** risultasse **true**
+     *
+     * @param {string} message Messaggio di log
+     */
+    private log;
+    /**
+     * Helper per la localizzazione dei messaggi
+     *
+     * @param {string} message Messaggio da localizzare
+     *
+     * @returns {string} Messaggio localizzato
+     */
+    private loc;
+    /**
+     * 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<T>(view: {
+        items: T[];
+        page: number;
+        itemsperpageoverride: number;
+        selection: {
+            exclusions: T[];
+            all: boolean;
+            items: T[];
+        };
+    }, api: string, pars?: HttpParams, transaction?: string): Observable<T[]>;
+    private hashObject;
+    /*****************************************************************************************************************************************
+     ***************************************************** TRANSACTION HELPERS ***************************************************************
+     *****************************************************************************************************************************************/
+    private GET_Trans_BeginTrans;
+    private GET_Trans_CheckExecution;
+    private GET_Trans_EndTrans;
+    beginTransaction(executionKey: string, secondsTimeout?: number): Observable<string>;
+    checkTransaction(executionKey: string): Observable<number>;
+    endTransaction(transactionKey: string, transactionResult: boolean): Observable<string>;
+    /*****************************************************************************************************************************************
+     ***************************************************** ROBA PER HASHING ******************************************************************
+     *****************************************************************************************************************************************/
+    /**
+     * Blacklist dei tipi da ignorare quando si effettua l'hashing degli oggetti
+     */
+    private objBlacklist;
+    /**
+     * Hash più semplice e più veloce dell'md5, ma meno sicuro
+     *
+     * Vedi https://stackoverflow.com/questions/7616461/generate-a-hash-from-string-in-javascript
+     *
+     * @param {string} str Stringa di cui calcolare l'hash
+     */
+    private simpleHash;
+    /**
+    * Genera una stringa che identifica univocamente l'oggetto in questione
+    *
+    * @param {any} o Oggetto di cui calcolare la stringa univoca
+    * @param {number} level Livello di ricorsione nel caso venga effettuato l'hash di un oggetto che contiene altri oggetti
+    * @param {boolean} navigateFullDepth Indica se navigare l'oggetto per l'intera lunghezza. In caso contrario si ferma al secondo livello
+    */
+    private stringify;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HTTPService, [null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HTTPService>;
+}

package/lib/models/CacheInfos.d.ts

@@ -0,0 +1,8 @@
+export declare class CacheInfos {
+    finalUrl: string;
+    cache: boolean;
+    cacheKey: string;
+    cacheTime: string;
+    cacheItem: any;
+    constructor(finalUrl: string, cache: boolean, cacheKey: string, cacheTime: string, cacheItem: any);
+}

package/lib/models/Download.d.ts

@@ -0,0 +1,5 @@
+export declare class Download {
+    state: 'PENDING' | 'IN_PROGRESS' | 'DONE';
+    progress: number;
+    content: Blob | null;
+}

package/lib/tokens.d.ts

@@ -0,0 +1,21 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Dizionario di invalidazioni delle chiamate HTTP
+ */
+export declare const HTTP_INVALIDATION: InjectionToken<Record<string, string[]>>;
+/**
+ * Durata della cache lato libreria dopo il quale la cache verrà ripulita
+ */
+export declare const CLIENT_CACHE_DURATION_S: InjectionToken<number>;
+/**
+ * Nome dell'APP utilizzato per creare le chiavi delle cache specifiche per l'applicazione corrente
+ */
+export declare const APP_NAME: InjectionToken<string>;
+/**
+ * Indica se utilizzare l'identificativo utente nella cache
+ */
+export declare const CACHE_BY_USER: InjectionToken<boolean>;
+/**
+ * Indica se fare log nella console ad ogni azione significativa
+ */
+export declare const HTTP_DEBUG_MODE: InjectionToken<boolean>;

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@esfaenza/httpservice",
-  "version": "19.2.26",
+  "version": "19.2.30",
   "dependencies": {
     "tslib": "^2.3.0"
   },
   "peerDependencies": {
-    "@angular/common": "^19.2.15",
-    "@angular/core": "^19.2.15",
-    "@esfaenza/localizations": "^19.2.23",
-    "@esfaenza/preferences": "^19.2.18"
+    "@angular/common": "^19.2.25",
+    "@angular/core": "^19.2.25",
+    "@esfaenza/localizations": "^19.2.28",
+    "@esfaenza/preferences": "^19.2.24"
   },
   "module": "fesm2022/esfaenza-httpservice.mjs",
   "typings": "index.d.ts",

package/public-api.d.ts

@@ -0,0 +1,7 @@
+export * from './lib/tokens';
+export * from './lib/httpservice.service';
+export * from './lib/httpservice.module';
+export * from './lib/config/HttpServiceModuleConfig';
+export * from './lib/config/IHttpServiceExtensions';
+export * from './lib/config/HttpServiceExtensions';
+export * from './lib/models/Download';