@esfaenza/httpservice 12.2.21 → 13.1.2

package/bundles/esfaenza-httpservice.umd.js

@@ -1,1253 +0,0 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/common/http'), require('@angular/core'), require('rxjs/operators'), require('rxjs')) :
-    typeof define === 'function' && define.amd ? define('@esfaenza/httpservice', ['exports', '@angular/common/http', '@angular/core', 'rxjs/operators', 'rxjs'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.esfaenza = global.esfaenza || {}, global.esfaenza.httpservice = {}), global.ng.common.http, global.ng.core, global.rxjs.operators, global.rxjs));
-}(this, (function (exports, http, core, operators, rxjs) { 'use strict';
-
-    /*! *****************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-    /* global Reflect, Promise */
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b)
-                if (Object.prototype.hasOwnProperty.call(b, p))
-                    d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    function __extends(d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    }
-    var __assign = function () {
-        __assign = Object.assign || function __assign(t) {
-            for (var s, i = 1, n = arguments.length; i < n; i++) {
-                s = arguments[i];
-                for (var p in s)
-                    if (Object.prototype.hasOwnProperty.call(s, p))
-                        t[p] = s[p];
-            }
-            return t;
-        };
-        return __assign.apply(this, arguments);
-    };
-    function __rest(s, e) {
-        var t = {};
-        for (var p in s)
-            if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-                t[p] = s[p];
-        if (s != null && typeof Object.getOwnPropertySymbols === "function")
-            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                    t[p[i]] = s[p[i]];
-            }
-        return t;
-    }
-    function __decorate(decorators, target, key, desc) {
-        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-        if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-            r = Reflect.decorate(decorators, target, key, desc);
-        else
-            for (var i = decorators.length - 1; i >= 0; i--)
-                if (d = decorators[i])
-                    r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-        return c > 3 && r && Object.defineProperty(target, key, r), r;
-    }
-    function __param(paramIndex, decorator) {
-        return function (target, key) { decorator(target, key, paramIndex); };
-    }
-    function __metadata(metadataKey, metadataValue) {
-        if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
-            return Reflect.metadata(metadataKey, metadataValue);
-    }
-    function __awaiter(thisArg, _arguments, P, generator) {
-        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-        return new (P || (P = Promise))(function (resolve, reject) {
-            function fulfilled(value) { try {
-                step(generator.next(value));
-            }
-            catch (e) {
-                reject(e);
-            } }
-            function rejected(value) { try {
-                step(generator["throw"](value));
-            }
-            catch (e) {
-                reject(e);
-            } }
-            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-            step((generator = generator.apply(thisArg, _arguments || [])).next());
-        });
-    }
-    function __generator(thisArg, body) {
-        var _ = { label: 0, sent: function () { if (t[0] & 1)
-                throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
-        function verb(n) { return function (v) { return step([n, v]); }; }
-        function step(op) {
-            if (f)
-                throw new TypeError("Generator is already executing.");
-            while (_)
-                try {
-                    if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
-                        return t;
-                    if (y = 0, t)
-                        op = [op[0] & 2, t.value];
-                    switch (op[0]) {
-                        case 0:
-                        case 1:
-                            t = op;
-                            break;
-                        case 4:
-                            _.label++;
-                            return { value: op[1], done: false };
-                        case 5:
-                            _.label++;
-                            y = op[1];
-                            op = [0];
-                            continue;
-                        case 7:
-                            op = _.ops.pop();
-                            _.trys.pop();
-                            continue;
-                        default:
-                            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
-                                _ = 0;
-                                continue;
-                            }
-                            if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
-                                _.label = op[1];
-                                break;
-                            }
-                            if (op[0] === 6 && _.label < t[1]) {
-                                _.label = t[1];
-                                t = op;
-                                break;
-                            }
-                            if (t && _.label < t[2]) {
-                                _.label = t[2];
-                                _.ops.push(op);
-                                break;
-                            }
-                            if (t[2])
-                                _.ops.pop();
-                            _.trys.pop();
-                            continue;
-                    }
-                    op = body.call(thisArg, _);
-                }
-                catch (e) {
-                    op = [6, e];
-                    y = 0;
-                }
-                finally {
-                    f = t = 0;
-                }
-            if (op[0] & 5)
-                throw op[1];
-            return { value: op[0] ? op[1] : void 0, done: true };
-        }
-    }
-    var __createBinding = Object.create ? (function (o, m, k, k2) {
-        if (k2 === undefined)
-            k2 = k;
-        Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });
-    }) : (function (o, m, k, k2) {
-        if (k2 === undefined)
-            k2 = k;
-        o[k2] = m[k];
-    });
-    function __exportStar(m, o) {
-        for (var p in m)
-            if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
-                __createBinding(o, m, p);
-    }
-    function __values(o) {
-        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-        if (m)
-            return m.call(o);
-        if (o && typeof o.length === "number")
-            return {
-                next: function () {
-                    if (o && i >= o.length)
-                        o = void 0;
-                    return { value: o && o[i++], done: !o };
-                }
-            };
-        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-    }
-    function __read(o, n) {
-        var m = typeof Symbol === "function" && o[Symbol.iterator];
-        if (!m)
-            return o;
-        var i = m.call(o), r, ar = [], e;
-        try {
-            while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
-                ar.push(r.value);
-        }
-        catch (error) {
-            e = { error: error };
-        }
-        finally {
-            try {
-                if (r && !r.done && (m = i["return"]))
-                    m.call(i);
-            }
-            finally {
-                if (e)
-                    throw e.error;
-            }
-        }
-        return ar;
-    }
-    /** @deprecated */
-    function __spread() {
-        for (var ar = [], i = 0; i < arguments.length; i++)
-            ar = ar.concat(__read(arguments[i]));
-        return ar;
-    }
-    /** @deprecated */
-    function __spreadArrays() {
-        for (var s = 0, i = 0, il = arguments.length; i < il; i++)
-            s += arguments[i].length;
-        for (var r = Array(s), k = 0, i = 0; i < il; i++)
-            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
-                r[k] = a[j];
-        return r;
-    }
-    function __spreadArray(to, from) {
-        for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-            to[j] = from[i];
-        return to;
-    }
-    function __await(v) {
-        return this instanceof __await ? (this.v = v, this) : new __await(v);
-    }
-    function __asyncGenerator(thisArg, _arguments, generator) {
-        if (!Symbol.asyncIterator)
-            throw new TypeError("Symbol.asyncIterator is not defined.");
-        var g = generator.apply(thisArg, _arguments || []), i, q = [];
-        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
-        function verb(n) { if (g[n])
-            i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
-        function resume(n, v) { try {
-            step(g[n](v));
-        }
-        catch (e) {
-            settle(q[0][3], e);
-        } }
-        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-        function fulfill(value) { resume("next", value); }
-        function reject(value) { resume("throw", value); }
-        function settle(f, v) { if (f(v), q.shift(), q.length)
-            resume(q[0][0], q[0][1]); }
-    }
-    function __asyncDelegator(o) {
-        var i, p;
-        return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
-        function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
-    }
-    function __asyncValues(o) {
-        if (!Symbol.asyncIterator)
-            throw new TypeError("Symbol.asyncIterator is not defined.");
-        var m = o[Symbol.asyncIterator], i;
-        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); }
-    }
-    function __makeTemplateObject(cooked, raw) {
-        if (Object.defineProperty) {
-            Object.defineProperty(cooked, "raw", { value: raw });
-        }
-        else {
-            cooked.raw = raw;
-        }
-        return cooked;
-    }
-    ;
-    var __setModuleDefault = Object.create ? (function (o, v) {
-        Object.defineProperty(o, "default", { enumerable: true, value: v });
-    }) : function (o, v) {
-        o["default"] = v;
-    };
-    function __importStar(mod) {
-        if (mod && mod.__esModule)
-            return mod;
-        var result = {};
-        if (mod != null)
-            for (var k in mod)
-                if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
-                    __createBinding(result, mod, k);
-        __setModuleDefault(result, mod);
-        return result;
-    }
-    function __importDefault(mod) {
-        return (mod && mod.__esModule) ? mod : { default: mod };
-    }
-    function __classPrivateFieldGet(receiver, privateMap) {
-        if (!privateMap.has(receiver)) {
-            throw new TypeError("attempted to get private field on non-instance");
-        }
-        return privateMap.get(receiver);
-    }
-    function __classPrivateFieldSet(receiver, privateMap, value) {
-        if (!privateMap.has(receiver)) {
-            throw new TypeError("attempted to set private field on non-instance");
-        }
-        privateMap.set(receiver, value);
-        return value;
-    }
-
-    /**
-     * Dizionario di invalidazioni delle chiamate HTTP
-     */
-    var HTTP_INVALIDATION = new core.InjectionToken('HTTP_INVALIDATION');
-    /**
-     * Durata della cache lato libreria dopo il quale la cache verrà ripulita
-     */
-    var CLIENT_CACHE_DURATION_S = new core.InjectionToken('CLIENT_CACHE_DURATION_S');
-    /**
-     * URL del Backend a cui inviare le chiamate
-     */
-    var BACKEND_URL = new core.InjectionToken('BACKEND_URL');
-    /**
-     * Locale della libreria per messaggi d'errore ed Header di default "Accept-Language". Sono supportati "it-IT" ed "en-US"
-     */
-    var HTTP_LOCALE = new core.InjectionToken('HTTP_LOCALE');
-    /**
-     * Nome dell'APP utilizzato per creare le chiavi delle cache specifiche per l'applicazione corrente
-     */
-    var APP_NAME = new core.InjectionToken('APP_NAME');
-    /**
-     * Indica se utilizzare l'identificativo utente nella cache
-     */
-    var CACHE_BY_USER = new core.InjectionToken('CACHE_BY_USER');
-    /**
-     * Indica se fare log nella console ad ogni azione significativa
-     */
-    var DEBUG_MODE = new core.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
-     */
-    var HttpServiceExtensions = /** @class */ (function () {
-        function HttpServiceExtensions() {
-        }
-        /**
-         * Hook per recuperare l'access token con cui effettuare le chiamate HTTP
-         */
-        HttpServiceExtensions.prototype.retrieveAccessToken = function () {
-            return "";
-        };
-        /**
-         * Hook per recuperare l'Identity corrente in un oggetto generico con le informazioni di User e Tenant
-         */
-        HttpServiceExtensions.prototype.retrieveIdentity = function () {
-            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
-         */
-        HttpServiceExtensions.prototype.readRedirectingToLogin = function () {
-            return false;
-        };
-        /**
-         * Hook per scrivere nello stato dell'applicazione se stiamo effettuando un redirect al login o meno
-         */
-        HttpServiceExtensions.prototype.writeRedirectingToLogin = function (status) {
-        };
-        /**
-         * Hook per effettuare il redirect al login
-         */
-        HttpServiceExtensions.prototype.redirectToLogin = function () {
-        };
-        /**
-         * 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
-         */
-        HttpServiceExtensions.prototype.readHandlingErrorStatus = function () {
-            return false;
-        };
-        /**
-         * Hook per scrivere nello stato dell'applicazione se stiamo gestendo un errore o meno
-         */
-        HttpServiceExtensions.prototype.writeHandlingErrorStatus = function (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
-         */
-        HttpServiceExtensions.prototype.readRedirectionStatus = function () {
-            return false;
-        };
-        /**
-         * Hook per scrivere nello stato dell'applicazione se stiamo gestendo un redirect o meno
-         */
-        HttpServiceExtensions.prototype.writeRedirectionStatus = function (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
-         */
-        HttpServiceExtensions.prototype.handleNotConfiguredException = function () {
-            return false;
-        };
-        /**
-         * Hook per la gestione di un qualsiasi errore bloccante per l'operazione attuale, ma non fatale (Generalmente gestibile da dialog di avviso)
-         */
-        HttpServiceExtensions.prototype.handleBlockingException = function (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)
-         */
-        HttpServiceExtensions.prototype.handleException = function (status, text) {
-            console.error("ESHttpError " + status + " " + text);
-        };
-        return HttpServiceExtensions;
-    }());
-
-    /**
-     * Oggetto statico di localizzazione per i messaggi
-     */
-    var Loc = {
-        "Result for": { "en-US": "Result for", "it-IT": "Risultato per", },
-        "retrieved from cache": { "en-US": "retrieved from cache", "it-IT": "recuperato dalla cache", },
-        "Cached result for": { "en-US": "Cached result for", "it-IT": "Messo in cache risultato per", },
-        "Starting call": { "en-US": "Starting call", "it-IT": "Inizio la chiamata", },
-        "at URL": { "en-US": "at URL", "it-IT": "all'URL", },
-        "Invlalidating cache element": { "en-US": "Invlalidating cache element", "it-IT": "Invalido elemento della cache", },
-        "Finalizing call": { "en-US": "Finalizing call", "it-IT": "Finalizzo chiamata", },
-        "with status": { "en-US": "with status", "it-IT": "con stato", },
-        "Success": { "en-US": "Success", "it-IT": "Successso", },
-        "Failure": { "en-US": "Failure", "it-IT": "Fallimento", },
-        "Error 401 on call": { "en-US": "Error 401 on call", "it-IT": "Errore 401 su chiamata", },
-        "with redirect already in progress. Ignoring this event": { "en-US": "with redirect already in progress. Ignoring this event", "it-IT": "con redirezione già in corso. Ignoro l'evento", },
-        "redirecting to login": { "en-US": "redirecting to login", "it-IT": "redireziono al login", },
-        "Redirecting to Login, ignoring HTTP error on call": { "en-US": "Redirecting to Login, ignoring HTTP error on call", "it-IT": "Redireziono al login ignorando errori sulla chiamata", },
-        "Already Handling an error, ignoring HTTP error on call": { "en-US": "Already Handling an error, ignoring HTTP error on call", "it-IT": "sto già gestendo un errore, ignoro quello corrente per la chiamata HTTP", },
-        "Error 444 on call": { "en-US": "Error 444 on call", "it-IT": "Errore 444 su chiamata" },
-        "Resource not found": { "en-US": "Resource not found", "it-IT": "Risorsa non trovata" }
-    };
-
-    /**
-     * 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**
-     */
-    var HTTPService = /** @class */ (function () {
-        /**
-         * @ignore
-         */
-        function HTTPService(BACKEND_URL, EXTENSION_CLASS, HTTP_INVALIDATION, LOCALE, APP_NAME, CLIENT_CACHE_DURATION_S, CACHE_BY_USER, DEBUG_MODE, http) {
-            var _a, _b;
-            this.BACKEND_URL = BACKEND_URL;
-            this.EXTENSION_CLASS = EXTENSION_CLASS;
-            this.HTTP_INVALIDATION = HTTP_INVALIDATION;
-            this.LOCALE = LOCALE;
-            this.APP_NAME = APP_NAME;
-            this.CLIENT_CACHE_DURATION_S = CLIENT_CACHE_DURATION_S;
-            this.CACHE_BY_USER = CACHE_BY_USER;
-            this.DEBUG_MODE = DEBUG_MODE;
-            this.http = http;
-            /**
-             * Cache dello stato delle chiamate HTTP attualmente effettuate. Ogni chiamata è rappresentata da un GUID e lo status assume valore **false** solo sugli errori
-             */
-            this.callStatus = {};
-            /**
-             * Nome della cache in cui vengono storicizzate le informazioni sulle risposte delle chiamate sotto forma di dictionary
-             */
-            this.localStorageHttpCacheKey = null;
-            /**
-             * Nome della cache in cui vengono storicizzate le informazioni sulle risposte delle chiamate sotto forma di dictionary, solo per le chiamate con un tempo definito di caching
-             */
-            this.localStorageHttpTimedCacheKey = null;
-            /**
-             * Nome della cache in cui vengono storicizzate le informazioni sullo scadere della cache stessa
-             */
-            this.localStorageHttpCacheExpireKey = null;
-            /**
-             * Identità collegata al token di autenticazione da usare, richiesta al programma che utilizza la libreria attraverso l'hook **retrieveIdentity** della **HttpServiceExtensions**
-             */
-            this.me = null;
-            this.ExtensionsImpl = this.EXTENSION_CLASS || new HttpServiceExtensions();
-            this.me = this.ExtensionsImpl.retrieveIdentity();
-            this.localStorageHttpCacheKey = ((_a = this.APP_NAME) !== null && _a !== void 0 ? _a : "APP").replace(/\s/g, '_') + "_HttpCache";
-            this.localStorageHttpTimedCacheKey = ((_b = this.APP_NAME) !== null && _b !== void 0 ? _b : "APP").replace(/\s/g, '_') + "_HttpTimedCache";
-            this.localStorageHttpCacheExpireKey = this.localStorageHttpCacheKey + "_Expire";
-            if (this.untimedCacheExpired())
-                this.resetHttpUntimedCacheStorage();
-        }
-        /**
-         * Esecuzione di una GET HTTP con eventualmente la gestione della cache qualora la chiamata termini con la convenzione "#cache"
-         *
-         * @param {string} url URL su cui effettuare la chiamata
-         * @param {HttpParams} params Parametri della chiamata
-         * @param {string} transaction Codice transazione collegato a questa chiamata. Viene inserito nell'Header "X-TX-ID" e lato Backend dovrà essere gestito di conseguenza
-         * @param {boolean} succesfulResultMandatory Indica che questa chiamata deve assolutamente andare bene. In caso contrario viene fisicamente fatto il throw che può essere
-         * raccolto da chi usa la libreria nella pipe "onError" dell'Observable restituito ed essere gestito in maniera non standard
-         * @param {Function} errorCallback Callback chiamato in caso di errore
-         *
-         * @returns {Observable<T>} Observable che contiene il risultato della chiamata
-         */
-        HTTPService.prototype.get = function (url, params, transaction, succesfulResultMandatory, errorCallback) {
-            var _this = this;
-            if (params === void 0) { params = null; }
-            if (transaction === void 0) { transaction = ""; }
-            if (succesfulResultMandatory === void 0) { succesfulResultMandatory = true; }
-            if (errorCallback === void 0) { errorCallback = null; }
-            var myGuid = this.defaultStartCall(url);
-            var cachedInfos = this.tryGetCacheInformations(url, params);
-            if (cachedInfos.cache && cachedInfos.cacheItem) {
-                this.log(this.loc("Result for") + " " + url + " " + this.loc("retrieved from cache"));
-                return rxjs.of(cachedInfos.cacheItem).pipe(operators.delay(0), operators.finalize(function () { _this.tryFinalizeByGuid(myGuid); }));
-            }
-            var httpCall = this.http.get(cachedInfos.finalUrl, { headers: this.getHeaders(transaction), params: params });
-            return httpCall.pipe(operators.map(function (res) {
-                var responseItem = res;
-                if (cachedInfos.cache) {
-                    _this.cacheResponse(responseItem, cachedInfos);
-                    _this.log(_this.loc("Cached result for") + " " + url);
-                }
-                return responseItem;
-            }), operators.catchError(function (err, caught) {
-                if (errorCallback)
-                    errorCallback();
-                return !succesfulResultMandatory ? rxjs.throwError(err) : _this.registerErrorAndReturnEmptyObservable(err, myGuid);
-            }), operators.finalize(function () { _this.tryFinalizeByGuid(myGuid); }));
-        };
-        /**
-         * Esecuzione di una GET HTTP con eventualmente la gestione della cache qualora la chiamata termini con la convenzione "#cache"
-         *
-         * Caso specifico di chiamata che deve restituire un Blob o un ArrayBuffer nativo da elaborare
-         *
-         * @param {string} url URL su cui effettuare la chiamata
-         * @param {HttpParams} params Parametri della chiamata
-         * @param {"arraybuffer"| "blob"} type Tipo di ritorno richiesto
-         * @param {string} transaction Codice transazione collegato a questa chiamata. Viene inserito nell'Header "X-TX-ID" e lato Backend dovrà essere gestito di conseguenza
-         * @param {boolean} succesfulResultMandatory Indica che questa chiamata deve assolutamente andare bene. In caso contrario viene fisicamente fatto il throw che può essere
-         * raccolto da chi usa la libreria nella pipe "onError" dell'Observable restituito ed essere gestito in maniera non standard
-         * @param {Function} errorCallback Callback chiamato in caso di errore
-         *
-         * @returns {Observable<Blob | ArrayBuffer>} Observable che contiene il risultato della chiamata
-         */
-        HTTPService.prototype.getRaw = function (url, params, type, transaction, succesfulResultMandatory, errorCallback) {
-            var _this = this;
-            if (params === void 0) { params = null; }
-            if (type === void 0) { type = "arraybuffer"; }
-            if (transaction === void 0) { transaction = ""; }
-            if (succesfulResultMandatory === void 0) { succesfulResultMandatory = true; }
-            if (errorCallback === void 0) { errorCallback = null; }
-            var myGuid = this.defaultStartCall(url);
-            var cachedInfos = this.tryGetCacheInformations(url, params);
-            if (cachedInfos.cache && cachedInfos.cacheItem) {
-                this.log(this.loc("Result for") + " " + url + " " + this.loc("retrieved from cache"));
-                return rxjs.of(cachedInfos.cacheItem).pipe(operators.delay(0), operators.finalize(function () { _this.tryFinalizeByGuid(myGuid); }));
-            }
-            var httpCall = this.http.get(cachedInfos.finalUrl, { responseType: type, headers: this.getHeaders(transaction), params: params });
-            return httpCall.pipe(operators.map(function (blob) {
-                if (cachedInfos.cache) {
-                    _this.cacheResponse(blob, cachedInfos);
-                    _this.log(_this.loc("Cached result for") + " " + url);
-                }
-                return blob;
-            }), operators.catchError(function (err, caught) {
-                if (errorCallback)
-                    errorCallback();
-                return !succesfulResultMandatory ? rxjs.throwError(err) : _this.registerErrorAndReturnEmptyObservable(err, myGuid);
-            }), operators.finalize(function () { _this.tryFinalizeByGuid(myGuid); }));
-        };
-        /**
-        * Esecuzione di una POST HTTP
-        *
-        * @param {string} url URL su cui effettuare la chiamata
-        * @param {any} bodyData DTO per la chiamata
-        * @param {HttpParams} params Parametri della chiamata
-        * @param {string} transaction Codice transazione collegato a questa chiamata. Viene inserito nell'Header "X-TX-ID" e lato Backend dovrà essere gestito di conseguenza
-        * @param {boolean} succesfulResultMandatory Indica che questa chiamata deve assolutamente andare bene. In caso contrario viene fisicamente fatto il throw che può essere
-        * raccolto da chi usa la libreria nella pipe "onError" dell'Observable restituito ed essere gestito in maniera non standard
-        *
-        * @returns {Observable<T>} Observable che contiene il risultato della chiamata
-        */
-        HTTPService.prototype.post = function (url, bodyData, params, transaction, succesfulResultMandatory) {
-            var _this = this;
-            if (params === void 0) { params = null; }
-            if (transaction === void 0) { transaction = ""; }
-            if (succesfulResultMandatory === void 0) { succesfulResultMandatory = true; }
-            var myGuid = this.defaultStartCall(url);
-            var httpCall = this.http.post(url, bodyData, { headers: this.getHeaders(transaction), params: params });
-            return httpCall.pipe(operators.map(function (res) {
-                var responseItem = res;
-                return responseItem;
-            }), operators.catchError(function (err, caught) {
-                return !succesfulResultMandatory ? rxjs.throwError(err) : _this.registerErrorAndReturnEmptyObservable(err, myGuid);
-            }), operators.finalize(function () { _this.tryFinalizeByGuid(myGuid); }));
-        };
-        /**
-        * Esecuzione di una DELETE HTTP
-        *
-        * @param {string} url URL su cui effettuare la chiamata
-        * @param {HttpParams} params Parametri della chiamata
-        * @param {string} transaction Codice transazione collegato a questa chiamata. Viene inserito nell'Header "X-TX-ID" e lato Backend dovrà essere gestito di conseguenza
-        * @param {boolean} succesfulResultMandatory Indica che questa chiamata deve assolutamente andare bene. In caso contrario viene fisicamente fatto il throw che può essere
-        * raccolto da chi usa la libreria nella pipe "onError" dell'Observable restituito ed essere gestito in maniera non standard
-        *
-        * @returns {Observable<T>} Observable che contiene il risultato della chiamata
-        */
-        HTTPService.prototype.delete = function (url, params, transaction, succesfulResultMandatory) {
-            var _this = this;
-            if (params === void 0) { params = null; }
-            if (transaction === void 0) { transaction = ""; }
-            if (succesfulResultMandatory === void 0) { succesfulResultMandatory = true; }
-            var myGuid = this.defaultStartCall(url);
-            var httpCall = this.http.delete(url, { headers: this.getHeaders(transaction), params: params });
-            return httpCall.pipe(operators.map(function (res) {
-                var responseItem = res;
-                return responseItem;
-            }), operators.catchError(function (err, caught) {
-                return !succesfulResultMandatory ? rxjs.throwError(err) : _this.registerErrorAndReturnEmptyObservable(err, myGuid);
-            }), operators.finalize(function () { _this.tryFinalizeByGuid(myGuid); }));
-        };
-        /**
-         * Esecuzione di una PUT HTTP
-         *
-         * @param {string} url URL su cui effettuare la chiamata
-         * @param {any} bodyData DTO per la chiamata
-         * @param {HttpParams} params Parametri della chiamata
-         * @param {string} transaction Codice transazione collegato a questa chiamata. Viene inserito nell'Header "X-TX-ID" e lato Backend dovrà essere gestito di conseguenza
-         * @param {boolean} succesfulResultMandatory Indica che questa chiamata deve assolutamente andare bene. In caso contrario viene fisicamente fatto il throw che può essere
-         * raccolto da chi usa la libreria nella pipe "onError" dell'Observable restituito ed essere gestito in maniera non standard
-         *
-         * @returns {Observable<T>} Observable che contiene il risultato della chiamata
-         */
-        HTTPService.prototype.put = function (url, bodyData, params, transaction, succesfulResultMandatory) {
-            var _this = this;
-            if (params === void 0) { params = null; }
-            if (transaction === void 0) { transaction = ""; }
-            if (succesfulResultMandatory === void 0) { succesfulResultMandatory = true; }
-            var myGuid = this.defaultStartCall(url);
-            var httpCall = this.http.put(url, bodyData, { headers: this.getHeaders(transaction), params: params });
-            return httpCall.pipe(operators.map(function (res) {
-                var responseItem = res;
-                return responseItem;
-            }), operators.catchError(function (err, caught) {
-                return !succesfulResultMandatory ? rxjs.throwError(err) : _this.registerErrorAndReturnEmptyObservable(err, myGuid);
-            }), operators.finalize(function () { _this.tryFinalizeByGuid(myGuid); }));
-        };
-        /**
-         * Esecuzione di una POST HTTP
-         *
-         * Casistica particolare in cui bisogna anche inviare dei File
-         *
-         * @param {string} url URL su cui effettuare la chiamata
-         * @param {any} bodyData DTO per la chiamata
-         * @param {File[] | File} fileArrayOrFile Singolo file o lista di file da inviare. Il tipo **File** è quello nativo del Javascript
-         *
-         * @returns {Observable<T>} Observable che contiene il risultato della chiamata
-         */
-        HTTPService.prototype.postwithFiles = function (url, bodyData, fileArrayOrFile) {
-            var _this = this;
-            var myGuid = this.defaultStartCall(url);
-            var formData = this.getFilesFormData(fileArrayOrFile);
-            formData.append("body", JSON.stringify(bodyData));
-            var httpCall = this.http.post(url, formData, { headers: this.getHeaders(null, true, null, null) });
-            return httpCall.pipe(operators.catchError(function (err, caught) { return _this.registerErrorAndReturnEmptyObservable(err, myGuid); }), operators.finalize(function () { _this.tryFinalizeByGuid(myGuid); }));
-        };
-        /**
-         * Esecuzione di una POST HTTP
-         *
-         * Casistica particolare in cui viene restituito un file gestito come ObjectURL il cui URL si può gestire dal parametro di callback **getFileCallback**.
-         * La chiamata non ha un tipo restituito in quanto il risultato dev'essere gestito attraverso la callback **getFileCallback**
-         *
-         * @param {string} url URL su cui effettuare la chiamata
-         * @param {K} bodyData DTO per la chiamata
-         * @param {string} filename Nome del file che si sta richiedendo, rimane lato Frontend e serve per assegnare arbitrariamente un nome al file restituito, se vuoto viene utilizzata la Content-Disposition della risposta
-         * @param {Function} getFileCallback Callback a due parametri (url: string, filename: string) per gestire il risultato del file richiesto. **Utilizzare UtilityService.fileDownload** di @esfaenza/extensions
-         * @param {Function} afterGetFile Callback da chiamare dopo aver gestito la risposta del **getFileCallback**, in caso **handleError** fosse **false** verrà richiamato anche in caso di errore
-         * @param {boolean} handleError Indica se di default gli errori devono essere gestiti dalla libreria o se devono essere ignorati
-         */
-        HTTPService.prototype.postGetFile = function (url, bodyData, filename, getFileCallback, afterGetFile, handleError) {
-            var _this = this;
-            if (afterGetFile === void 0) { afterGetFile = null; }
-            if (handleError === void 0) { handleError = true; }
-            var myGuid = this.defaultStartCall(url);
-            this.http.post(url, bodyData, { headers: this.getHeaders(), observe: 'response', responseType: "blob" }).pipe(operators.catchError(function (err, caught) {
-                if (afterGetFile && !handleError)
-                    afterGetFile();
-                return _this.registerErrorAndReturnEmptyObservable(err, myGuid, handleError);
-            }), operators.finalize(function () { _this.tryFinalizeByGuid(myGuid); })).subscribe(function (response) {
-                var _a, _b, _c, _d;
-                var retUrl = window.URL.createObjectURL(response.body);
-                var 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
-         */
-        HTTPService.prototype.getFile = function (url, params, filename, getFileCallback, afterGetFile, handleError) {
-            var _this = this;
-            if (params === void 0) { params = null; }
-            if (afterGetFile === void 0) { afterGetFile = null; }
-            if (handleError === void 0) { handleError = true; }
-            var myGuid = this.defaultStartCall(url);
-            this.http.get(url, { params: params, headers: this.getHeaders(), observe: 'response', responseType: "blob" }).pipe(operators.catchError(function (err, caught) {
-                if (afterGetFile && !handleError)
-                    afterGetFile();
-                return _this.registerErrorAndReturnEmptyObservable(err, myGuid, handleError);
-            }), operators.finalize(function () { _this.tryFinalizeByGuid(myGuid); })).subscribe(function (response) {
-                var _a, _b, _c, _d;
-                var retUrl = window.URL.createObjectURL(response.body);
-                var 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
-         */
-        HTTPService.prototype.getFileNative = function (url, params) {
-            if (params === void 0) { params = null; }
-            var finalUrl = url + (params ? "?" + params.toString() : "");
-            window.location.href = finalUrl;
-        };
-        /**
-         * Esecuzione di una GET di un file che emette i vari eventi di progresso di download.
-         * Utilizzarla per overridare la dialog nativa di progress del browser e sostituirla con qualcosa tipo quello che fa MEGA.
-         *
-         * In caso si voglia ottenere il risultato nativo del browser del download utilizzare **getFileNative(url, pars)**
-         *
-         * @param {string} url URL su cui effettuare la chiamata
-         * @param {HttpParams} params Parametri della chiamata
-         * @param {Function} getFileCallback Callback a due parametri (url: string, filename: string) per gestire il risultato del file richiesto. **Utilizzare UtilityService.fileDownload** di @esfaenza/extensions
-         *
-         * @returns {Observable<Download>} Observable dei vari step di progresso del download
-         */
-        HTTPService.prototype.getFileWithProgress = function (url, params, getFileCallback) {
-            var _this = this;
-            if (params === void 0) { params = null; }
-            var myGuid = this.defaultStartCall(url);
-            return this.http.get(url, { responseType: 'blob', headers: this.getHeaders(), params: params, observe: 'events', reportProgress: true })
-                .pipe(operators.scan(function (previous, event) {
-                if (_this.isHttpProgressEvent(event)) {
-                    var 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) {
-                        var cdisp = event.headers.get('content-disposition');
-                        var cdispFilename = cdisp.split(';')[1].split('filename')[1].split('=')[1].trim().replace(/\"/g, '');
-                        var 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 }), operators.catchError(function (err, _) { return _this.registerErrorAndReturnEmptyObservable(err, myGuid); }), operators.finalize(function () { _this.tryFinalizeByGuid(myGuid); }));
-        };
-        /**
-         * Riconosce se l'evento HTTP è di tipo **HttpResponse** e, se sì, lo casta al tipo corretto per essere utilizzato correttamente nel blocco di codice successivo
-         */
-        HTTPService.prototype.isHttpResponse = function (event) {
-            return event.type === http.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
-         */
-        HTTPService.prototype.isHttpProgressEvent = function (event) {
-            return event.type === http.HttpEventType.DownloadProgress || event.type === http.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
-         */
-        HTTPService.prototype.defaultStartCall = function (url) {
-            var myGuid = this.getGUID();
-            this.checkCacheInvalidation(url);
-            this.callStatus[myGuid] = true;
-            this.log(this.loc("Starting call") + " " + myGuid + " " + this.loc("at URL") + ": " + url);
-            return myGuid;
-        };
-        /**
-         * Dato un url vengono controllate le informazioni su tutti gli url da invalidare collegati all'url chiamato e, se presenti in cache, invalidati
-         *
-         * @param {string} url URL per cui controllare se ci sono chiamate in cache da invalidare
-         */
-        HTTPService.prototype.checkCacheInvalidation = function (url) {
-            var _this = this;
-            var cache = JSON.parse(localStorage.getItem(this.localStorageHttpCacheKey));
-            var tmp = /#cache(:?-(\d+))/gi.exec(url);
-            var cacheTime = tmp ? tmp[2] : null;
-            var normalizedUrl = url.replace("#cache" + (cacheTime ? "-" + cacheTime : ""), "").replace(this.BACKEND_URL, "");
-            if (!cache || !this.HTTP_INVALIDATION || !this.HTTP_INVALIDATION[normalizedUrl])
-                return;
-            var apisToInvalidate = this.HTTP_INVALIDATION[normalizedUrl];
-            if (!apisToInvalidate || apisToInvalidate.length == 0)
-                return;
-            var keysToRemove = [];
-            apisToInvalidate.forEach(function (api) {
-                var cacheKey = _this.makeCacheKey(api, null);
-                for (var item in cache)
-                    if (item.indexOf(cacheKey) != -1)
-                        keysToRemove.push(item);
-            });
-            for (var i = 0; i < keysToRemove.length; i++) {
-                var k = keysToRemove[i];
-                this.log(this.loc("Invlalidating cache element") + " " + k);
-                delete cache[k];
-            }
-            localStorage.setItem(this.localStorageHttpCacheKey, JSON.stringify(cache));
-        };
-        /**
-         * Finalizzazione di una chiamata
-         *
-         * @param {string} guid GUID collegato alla chiamata appena terminata
-         */
-        HTTPService.prototype.tryFinalizeByGuid = function (guid) {
-            this.log(this.loc("Finalizing call") + " " + guid + " " + this.loc("with status") + ": " + (this.callStatus[guid] ? this.loc('Success') : this.loc('Failure')));
-            //Alla prima chiamata buona, significa che almeno il login ce l'ho. Posso mettermi in modalità redirectInProgress false
-            //e riiniziare a valutare errori di javashit
-            if (this.callStatus[guid] && this.ExtensionsImpl.readRedirectionStatus())
-                this.ExtensionsImpl.writeRedirectionStatus(false);
-            //In ogni caso questa posso rimuoverla
-            delete this.callStatus[guid];
-        };
-        /**
-         * Helper che dato un unico File o una lista di File crea un oggetto FormData che può essere inviato comodamente
-         * ad un backend ASP.NET da cui si potrà accedere a Request.Form.Files
-         *
-         * @param {File | File[]} fileArrayOrFile Singolo File o lista di File. N.B: nella firma della funzione viene considerato **any** per fare test sulle proprietà
-         * invece che fare test con l'**istanceof**
-         *
-         * @returns {FormData} FormData contenente tutti i file passati
-         */
-        HTTPService.prototype.getFilesFormData = function (fileArrayOrFile) {
-            var formData = new FormData();
-            if (fileArrayOrFile) {
-                if (fileArrayOrFile.length)
-                    fileArrayOrFile.forEach(function (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
-         */
-        HTTPService.prototype.getHeaders = function (transactionId, includeAuth, contentType, accept) {
-            if (transactionId === void 0) { transactionId = ""; }
-            if (includeAuth === void 0) { includeAuth = true; }
-            if (contentType === void 0) { contentType = "application/json"; }
-            if (accept === void 0) { accept = "application/json"; }
-            var _a;
-            var headers = new http.HttpHeaders();
-            var authtoken = this.ExtensionsImpl.retrieveAccessToken();
-            if (contentType)
-                headers = headers.append("Content-Type", contentType);
-            if (transactionId)
-                headers = headers.append("X-TX-ID", transactionId);
-            if (authtoken && includeAuth)
-                headers = headers.append("Authorization", "Bearer " + authtoken);
-            if (accept)
-                headers = headers.append("Accept", "application/json");
-            headers = headers.append("Accept-Language", (_a = this.LOCALE) !== null && _a !== void 0 ? _a : 'it-IT');
-            return headers;
-        };
-        /**
-         * Gestione di default degli errori
-         *
-         * @param {any} res Risultato della chiamata effettuata
-         * @param {string} guid Identificativo GUID della chiamata effettuata
-         */
-        HTTPService.prototype.onError = function (res, guid) {
-            return __awaiter(this, void 0, void 0, function () {
-                var finalError, finalStatus;
-                return __generator(this, function (_e) {
-                    switch (_e.label) {
-                        case 0:
-                            this.callStatus[guid] = false;
-                            //Mi assicuro che tutti gli errori durante il redirect al login vengano ignorati
-                            if (this.ExtensionsImpl.readRedirectingToLogin()) {
-                                this.log(this.loc("Redirecting to Login, ignoring HTTP error on call") + " " + guid);
-                                return [2 /*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 [2 /*return*/];
-                            }
-                            else
-                                this.ExtensionsImpl.writeHandlingErrorStatus(true);
-                            finalError = "";
-                            finalStatus = "";
-                            if (!this.isTypeError(res)) return [3 /*break*/, 1];
-                            finalError = res.message;
-                            finalStatus = "HTTP Service Internal Error";
-                            return [3 /*break*/, 3];
-                        case 1:
-                            if (!this.isHttpErrorResponse(res)) return [3 /*break*/, 3];
-                            return [4 /*yield*/, this.getHttpErrorText(res.error)];
-                        case 2:
-                            finalError = _e.sent();
-                            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 [2 /*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 [2 /*return*/];
-                                // Handled exception
-                                case 400:
-                                // No Permissions
-                                case 403:
-                                    this.ExtensionsImpl.handleBlockingException(res.status, finalError);
-                                    return [2 /*return*/];
-                                // Not found
-                                case 404:
-                                    this.ExtensionsImpl.handleBlockingException(res.status, this.loc("Resource not found"));
-                                    return [2 /*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 [2 /*return*/];
-                                case 0:
-                                    finalError = "Server might be offline" + (res.statusText ? " (" + res.statusText + ") " : "");
-                            }
-                            _e.label = 3;
-                        case 3:
-                            this.ExtensionsImpl.handleException(finalStatus, finalError);
-                            return [2 /*return*/];
-                    }
-                });
-            });
-        };
-        /**
-         * 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
-         */
-        HTTPService.prototype.getHttpErrorText = function (err) {
-            var _this = this;
-            // 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(function (resolve) {
-                if (err instanceof Blob) {
-                    var reader = new FileReader();
-                    reader.onload = function (e) {
-                        var errMsg = e.target.result;
-                        var 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
-         */
-        HTTPService.prototype.isCallResult = function (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
-         */
-        HTTPService.prototype.isHttpErrorResponse = function (err) {
-            return err instanceof http.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
-        */
-        HTTPService.prototype.isTypeError = function (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
-         */
-        HTTPService.prototype.registerErrorAndReturnEmptyObservable = function (res, guid, handleError) {
-            if (handleError === void 0) { handleError = true; }
-            if (handleError)
-                this.onError(res, guid);
-            return new rxjs.Observable(function () { });
-        };
-        /**
-         * Dato un Url e dei parametri cerca di recuperare l'eventuale oggetto già salvato in cache con le informazioni base della cache stessa
-         *
-         * @param {string} url URL su cui effettuare la chiamata
-         * @param {HttpParams} params Parametri della chiamata (nulli in caso di POST)
-         *
-         * @returns {{ finalUrl: string, cache: boolean, cacheKey: string, cacheTime: string, cacheItem: any }} Oggetto contenente le informazioni sulla cache per l'oggetto specificato
-         */
-        HTTPService.prototype.tryGetCacheInformations = function (url, params) {
-            var cachingKey = null, cacheTime = null, cache = null, item = null;
-            var useCaching = !!(/#cache/gi.exec(url));
-            if (useCaching) {
-                var 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);
-                var cacheKey = cacheTime ? this.localStorageHttpTimedCacheKey : this.localStorageHttpCacheKey;
-                var cacheLs = localStorage.getItem(cacheKey);
-                var cache_1 = cacheLs ? JSON.parse(cacheLs) : {};
-                if (cache_1 && cache_1[cachingKey] && !this.timedCacheItemExpired(cache_1[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_1[cachingKey].__expire;
-                    item = cache_1[cachingKey];
-                }
-            }
-            return { finalUrl: url, cache: useCaching, cacheKey: cachingKey, cacheTime: cacheTime, cacheItem: item };
-        };
-        /**
-         * Inserisce un oggetto nella cache appropriata in base alle informazioni contenute nel parametro **cacheInfos**
-         *
-         * @param {T} item Oggetto da inserire nella cache
-         * @param {{ finalUrl: string, cache: boolean, cacheKey: string, cacheTime: string, cacheItem: any }} cacheInfos Informazioni sulla cache recuperate da una chiamata precedente a **tryGetCacheInformations**
-         */
-        HTTPService.prototype.cacheResponse = function (item, cacheInfos) {
-            var cacheKey = cacheInfos.cacheTime ? this.localStorageHttpTimedCacheKey : this.localStorageHttpCacheKey;
-            var cacheLs = localStorage.getItem(cacheKey);
-            var cache = cacheLs ? JSON.parse(cacheLs) : {};
-            cache[cacheInfos.cacheKey] = item;
-            if (cacheInfos.cacheTime)
-                cache[cacheInfos.cacheKey].__expire = dayjs().add(cacheInfos.cacheTime, "seconds");
-            localStorage.setItem(cacheKey, JSON.stringify(cache));
-        };
-        /**
-         * Controlla se la cache per le chiamate senza expire time è scaduta
-         *
-         * @returns {boolean} **true** se la cache è scaduta e dev'essere ripulita, **false** altrimenti
-         */
-        HTTPService.prototype.untimedCacheExpired = function () {
-            var 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
-         */
-        HTTPService.prototype.timedCacheItemExpired = function (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**)
-         */
-        HTTPService.prototype.resetHttpUntimedCacheStorage = function () {
-            var _a;
-            localStorage.setItem(this.localStorageHttpCacheKey, JSON.stringify({}));
-            localStorage.setItem(this.localStorageHttpCacheExpireKey, JSON.stringify(dayjs().add((_a = this.CLIENT_CACHE_DURATION_S) !== null && _a !== void 0 ? _a : 3600, "second")));
-        };
-        /**
-         * Ripulisce la cache delle chiamate con un tempo di expire definito
-         */
-        HTTPService.prototype.resetHttpTimedCacheStorage = function () {
-            localStorage.setItem(this.localStorageHttpTimedCacheKey, JSON.stringify({}));
-        };
-        /**
-         * Genera una chiave per la cache delle chiamate in base ad URL e Parametri HTTP
-         *
-         * @param {string} url URL su cui effettuare la chiamata
-         * @param {HttpParams} params Parametri della chiamata
-         *
-         * @returns {string} Chiave che rappresenta in maniera univoca la chiamata
-         */
-        HTTPService.prototype.makeCacheKey = function (url, params) {
-            var authKeyPart = (this.me ? this.me.Idtenant : "") + (this.me && this.CACHE_BY_USER ? this.me.IdUser : "");
-            var paramsKeyPart = params && params.keys().length > 0 ? params.keys().reduce(function (prev, next) { return prev + next + '=' + params.get(next); }, "") : "";
-            return authKeyPart + url + paramsKeyPart;
-        };
-        /**
-         * Generazione GUID
-         *
-         * @returns {string} Nuovo GUID generato in maniera casuale
-         */
-        HTTPService.prototype.getGUID = function () {
-            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
-         */
-        HTTPService.prototype.log = function (message) {
-            if (this.DEBUG_MODE)
-                console.log("@httpservice: " + message);
-        };
-        /**
-         * Helper per la localizzazione dei messaggi
-         *
-         * @param {string} message Messaggio da localizzare
-         *
-         * @returns {string} Messaggio localizzato
-         */
-        HTTPService.prototype.loc = function (message) {
-            if (!Loc[message]) {
-                console.warn("Untranslated message: " + message);
-                return "";
-            }
-            return Loc[message][this.LOCALE];
-        };
-        return HTTPService;
-    }());
-    HTTPService.decorators = [
-        { type: core.Injectable }
-    ];
-    HTTPService.ctorParameters = function () { return [
-        { type: undefined, decorators: [{ type: core.Inject, args: [BACKEND_URL,] }] },
-        { type: HttpServiceExtensions },
-        { type: undefined, decorators: [{ type: core.Optional }, { type: core.Inject, args: [HTTP_INVALIDATION,] }] },
-        { type: undefined, decorators: [{ type: core.Optional }, { type: core.Inject, args: [HTTP_LOCALE,] }] },
-        { type: undefined, decorators: [{ type: core.Optional }, { type: core.Inject, args: [APP_NAME,] }] },
-        { type: undefined, decorators: [{ type: core.Optional }, { type: core.Inject, args: [CLIENT_CACHE_DURATION_S,] }] },
-        { type: Boolean, decorators: [{ type: core.Optional }, { type: core.Inject, args: [CACHE_BY_USER,] }] },
-        { type: Boolean, decorators: [{ type: core.Optional }, { type: core.Inject, args: [DEBUG_MODE,] }] },
-        { type: http.HttpClient }
-    ]; };
-
-    var HttpserviceModule = /** @class */ (function () {
-        function HttpserviceModule() {
-        }
-        HttpserviceModule.forRoot = function (config) {
-            return {
-                ngModule: HttpserviceModule,
-                providers: [
-                    HTTPService,
-                    HttpServiceExtensions,
-                    { 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 },
-                    { provide: BACKEND_URL, useValue: config === null || config === void 0 ? void 0 : config.backendUrl },
-                    { provide: HTTP_LOCALE, useValue: (config === null || config === void 0 ? void 0 : config.httpLocale) || 'it-IT' },
-                    { provide: APP_NAME, useValue: config === null || config === void 0 ? void 0 : config.appName },
-                    { provide: CACHE_BY_USER, useValue: config === null || config === void 0 ? void 0 : config.cacheByUser },
-                    { provide: DEBUG_MODE, useValue: config === null || config === void 0 ? void 0 : config.debugMode }
-                ]
-            };
-        };
-        return HttpserviceModule;
-    }());
-    HttpserviceModule.decorators = [
-        { type: core.NgModule }
-    ];
-
-    /**
-     * Classe di configurazione per il Modulo della libreria
-     */
-    var HttpServiceModuleConfig = /** @class */ (function () {
-        function HttpServiceModuleConfig() {
-        }
-        return HttpServiceModuleConfig;
-    }());
-
-    var Download = /** @class */ (function () {
-        function Download() {
-        }
-        return Download;
-    }());
-
-    /*
-     * Public API Surface of httpservice
-     */
-
-    /**
-     * Generated bundle index. Do not edit.
-     */
-
-    exports.Download = Download;
-    exports.HTTPService = HTTPService;
-    exports.HttpServiceExtensions = HttpServiceExtensions;
-    exports.HttpServiceModuleConfig = HttpServiceModuleConfig;
-    exports.HttpserviceModule = HttpserviceModule;
-    exports.ɵa = HTTP_INVALIDATION;
-    exports.ɵb = CLIENT_CACHE_DURATION_S;
-    exports.ɵc = BACKEND_URL;
-    exports.ɵd = HTTP_LOCALE;
-    exports.ɵe = APP_NAME;
-    exports.ɵf = CACHE_BY_USER;
-    exports.ɵg = DEBUG_MODE;
-
-    Object.defineProperty(exports, '__esModule', { value: true });
-
-})));
-//# sourceMappingURL=esfaenza-httpservice.umd.js.map