@esfaenza/httpservice 19.2.15 → 19.2.17

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.15",
+  "version": "19.2.17",
   "dependencies": {
     "tslib": "^2.3.0"
   },
   "peerDependencies": {
-    "@angular/common": "^19.2.14",
-    "@angular/core": "^19.2.14",
-    "@esfaenza/localizations": "^19.2.0",
-    "@esfaenza/preferences": "^19.2.10"
+    "@angular/common": "^19.2.15",
+    "@angular/core": "^19.2.15",
+    "@esfaenza/localizations": "^19.2.15",
+    "@esfaenza/preferences": "^19.2.11"
   },
   "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';