@esfaenza/httpservice 15.2.19 → 15.2.20

package/fesm2015/esfaenza-httpservice.mjs

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