@esfaenza/httpservice 15.2.3 → 15.2.4

package/fesm2020/esfaenza-httpservice.mjs

@@ -1,11 +1,12 @@
-import * as i2 from '@angular/common/http';
+import * as i3 from '@angular/common/http';
 import { HttpEventType, HttpHeaders, HttpErrorResponse } from '@angular/common/http';
 import * as i0 from '@angular/core';
 import { InjectionToken, Injectable, Optional, Inject, NgModule } from '@angular/core';
-import { concatMap, delay, finalize, map, catchError, scan } from 'rxjs/operators';
+import { concatMap, delay, finalize, map, catchError, first, scan } from 'rxjs/operators';
 import { forkJoin, from, of, throwError, Observable } from 'rxjs';
-import * as i3 from '@esfaenza/preferences';
-import * as i4 from '@esfaenza/extensions';
+import * as i2 from '@esfaenza/localizations';
+import * as i4 from '@esfaenza/preferences';
+import * as i5 from '@esfaenza/extensions';
 
 /**
  * Dizionario di invalidazioni delle chiamate HTTP
@@ -15,10 +16,6 @@ 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');
-/**
- * Locale della libreria per messaggi d'errore ed Header di default "Accept-Language". Sono supportati "it-IT" ed "en-US"
- */
-const HTTP_LOCALE = new InjectionToken('HTTP_LOCALE');
 /**
  * Nome dell'APP utilizzato per creare le chiavi delle cache specifiche per l'applicazione corrente
  */
@@ -109,35 +106,13 @@ class HttpServiceExtensions {
     handleException(status, text) {
         console.error("ESHttpError " + status + " " + text);
     }
-}
-
-/**
- * Oggetto statico di localizzazione per i messaggi
- */
-const Loc = {
-    "Result for": { "en-US": "Result for", "it-IT": "Risultato per", },
-    "retrieved from cache": { "en-US": "retrieved from cache", "it-IT": "recuperato dalla cache", },
-    "Cached result for": { "en-US": "Cached result for", "it-IT": "Messo in cache risultato per", },
-    "Starting call": { "en-US": "Starting call", "it-IT": "Inizio la chiamata", },
-    "at URL": { "en-US": "at URL", "it-IT": "all'URL", },
-    "Invlalidating cache element": { "en-US": "Invlalidating cache element", "it-IT": "Invalido elemento della cache", },
-    "Finalizing call": { "en-US": "Finalizing call", "it-IT": "Finalizzo chiamata", },
-    "with status": { "en-US": "with status", "it-IT": "con stato", },
-    "Success": { "en-US": "Success", "it-IT": "Successso", },
-    "Failure": { "en-US": "Failure", "it-IT": "Fallimento", },
-    "Error 401 on call": { "en-US": "Error 401 on call", "it-IT": "Errore 401 su chiamata", },
-    "with redirect already in progress. Ignoring this event": { "en-US": "with redirect already in progress. Ignoring this event", "it-IT": "con redirezione già in corso. Ignoro l'evento", },
-    "redirecting to login": { "en-US": "redirecting to login", "it-IT": "redireziono al login", },
-    "Redirecting to Login, ignoring HTTP error on call": { "en-US": "Redirecting to Login, ignoring HTTP error on call", "it-IT": "Redireziono al login ignorando errori sulla chiamata", },
-    "Already Handling an error, ignoring HTTP error on call": { "en-US": "Already Handling an error, ignoring HTTP error on call", "it-IT": "sto già gestendo un errore, ignoro quello corrente per la chiamata HTTP", },
-    "Error 444 on call": { "en-US": "Error 444 on call", "it-IT": "Errore 444 su chiamata" },
-    "Resource not found": { "en-US": "Resource not found", "it-IT": "Risorsa non trovata" },
-    "Converted old storage system to new one": { "en-US": "Converted old storage system to new one", "it-IT": "Convertito il vecchio sistema di storicizzazione al nuovo" },
-    "Marking cache to be persisted as soon as possible": { "en-US": "Marking cache to be persisted as soon as possible", "it-IT": "Marco cache da persistere il prima possibile" },
-    "No more HTTP calls to be executed, entering idle state and persisting modified caches": { "en-US": "No more HTTP calls to be executed, entering idle state and persisting modified caches", "it-IT": "Nessun'altra chiamata HTTP dev'essere eseguita, entro in stato IDLE e persisto le cache modificate" },
-    "Caches succesfully persisted": { "en-US": "Caches succesfully persisted", "it-IT": "Le cache sono state persistite con successo" },
-    "Errors persisting modified caches": { "en-US": "Errors persisting modified caches", "it-IT": "Errori nella persistizione delle cache (esiste persistizione? boh...)" },
-};
+}
+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) {
@@ -158,14 +133,14 @@ class HTTPService {
     /**
      * @ignore
      */
-    constructor(EXTENSION_CLASS, HTTP_INVALIDATION, LOCALE, APP_NAME, CLIENT_CACHE_DURATION_S, CACHE_BY_USER, DEBUG_MODE, http, localStorage, utisExts) {
+    constructor(EXTENSION_CLASS, HTTP_INVALIDATION, APP_NAME, CLIENT_CACHE_DURATION_S, CACHE_BY_USER, DEBUG_MODE, bc, http, localStorage, utisExts) {
         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.bc = bc;
         this.http = http;
         this.localStorage = localStorage;
         this.utisExts = utisExts;
@@ -226,14 +201,16 @@ class HTTPService {
      * @returns {Observable<T>} Observable che contiene il risultato della chiamata
      */
     get(url, params = null, transaction = "", succesfulResultMandatory = true, errorCallback = null) {
-        // TODO provare e testare
-        return from([this.defaultStartCall(url)]).pipe(concatMap((myGuid) => {
+        return forkJoin({
+            myGuid: from([this.defaultStartCall(url)]),
+            locale: this.bc.Locale
+        }).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(myGuid); }));
+                return of(cachedInfos.cacheItem).pipe(delay(0), finalize(() => { this.tryFinalizeByGuid(ret.myGuid); }));
             }
-            var httpCall = this.http.get(cachedInfos.finalUrl, { headers: this.getHeaders(transaction), params: params });
+            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) {
@@ -244,8 +221,8 @@ class HTTPService {
             }), catchError((err, caught) => {
                 if (errorCallback)
                     errorCallback();
-                return !succesfulResultMandatory ? throwError(err) : this.registerErrorAndReturnEmptyObservable(err, myGuid);
-            }), finalize(() => { this.tryFinalizeByGuid(myGuid, cachedInfos); }));
+                return !succesfulResultMandatory ? throwError(err) : this.registerErrorAndReturnEmptyObservable(err, ret.myGuid);
+            }), finalize(() => { this.tryFinalizeByGuid(ret.myGuid, cachedInfos); }));
         }));
     }
     /**
@@ -264,13 +241,16 @@ class HTTPService {
      * @returns {Observable<Blob | ArrayBuffer>} Observable che contiene il risultato della chiamata
      */
     getRaw(url, params = null, type = "arraybuffer", transaction = "", succesfulResultMandatory = true, errorCallback = null) {
-        return from([this.defaultStartCall(url)]).pipe(concatMap((myGuid) => {
+        return forkJoin({
+            myGuid: from([this.defaultStartCall(url)]),
+            locale: this.bc.Locale
+        }).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(myGuid); }));
+                return of(cachedInfos.cacheItem).pipe(delay(0), finalize(() => { this.tryFinalizeByGuid(ret.myGuid); }));
             }
-            var httpCall = this.http.get(cachedInfos.finalUrl, { responseType: type, headers: this.getHeaders(transaction), params: params });
+            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);
@@ -280,8 +260,8 @@ class HTTPService {
             }), catchError((err, caught) => {
                 if (errorCallback)
                     errorCallback();
-                return !succesfulResultMandatory ? throwError(err) : this.registerErrorAndReturnEmptyObservable(err, myGuid);
-            }), finalize(() => { this.tryFinalizeByGuid(myGuid, cachedInfos); }));
+                return !succesfulResultMandatory ? throwError(err) : this.registerErrorAndReturnEmptyObservable(err, ret.myGuid);
+            }), finalize(() => { this.tryFinalizeByGuid(ret.myGuid, cachedInfos); }));
         }));
     }
     /**
@@ -297,11 +277,14 @@ class HTTPService {
     * @returns {Observable<T>} Observable che contiene il risultato della chiamata
     */
     post(url, bodyData, params = null, transaction = "", succesfulResultMandatory = true) {
-        return from([this.defaultStartCall(url)]).pipe(concatMap((myGuid) => {
-            var httpCall = this.http.post(url, bodyData, { headers: this.getHeaders(transaction), params: params });
+        return forkJoin({
+            myGuid: from([this.defaultStartCall(url)]),
+            locale: this.bc.Locale
+        }).pipe(concatMap((ret) => {
+            var httpCall = this.http.post(url, bodyData, { headers: this.getHeaders(ret.locale, transaction), params: params });
             return httpCall.pipe(catchError((err, caught) => {
-                return !succesfulResultMandatory ? throwError(err) : this.registerErrorAndReturnEmptyObservable(err, myGuid);
-            }), finalize(() => { this.tryFinalizeByGuid(myGuid); }));
+                return !succesfulResultMandatory ? throwError(err) : this.registerErrorAndReturnEmptyObservable(err, ret.myGuid);
+            }), finalize(() => { this.tryFinalizeByGuid(ret.myGuid); }));
         }));
     }
     /**
@@ -316,11 +299,14 @@ class HTTPService {
     * @returns {Observable<T>} Observable che contiene il risultato della chiamata
     */
     delete(url, params = null, transaction = "", succesfulResultMandatory = true) {
-        return from([this.defaultStartCall(url)]).pipe(concatMap((myGuid) => {
-            var httpCall = this.http.delete(url, { headers: this.getHeaders(transaction), params: params });
+        return forkJoin({
+            myGuid: from([this.defaultStartCall(url)]),
+            locale: this.bc.Locale
+        }).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, myGuid);
-            }), finalize(() => { this.tryFinalizeByGuid(myGuid); }));
+                return !succesfulResultMandatory ? throwError(err) : this.registerErrorAndReturnEmptyObservable(err, ret.myGuid);
+            }), finalize(() => { this.tryFinalizeByGuid(ret.myGuid); }));
         }));
     }
     /**
@@ -336,11 +322,14 @@ class HTTPService {
      * @returns {Observable<T>} Observable che contiene il risultato della chiamata
      */
     put(url, bodyData, params = null, transaction = "", succesfulResultMandatory = true) {
-        return from([this.defaultStartCall(url)]).pipe(concatMap((myGuid) => {
-            var httpCall = this.http.put(url, bodyData, { headers: this.getHeaders(transaction), params: params });
+        return forkJoin({
+            myGuid: from([this.defaultStartCall(url)]),
+            locale: this.bc.Locale
+        }).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, myGuid);
-            }), finalize(() => { this.tryFinalizeByGuid(myGuid); }));
+                return !succesfulResultMandatory ? throwError(err) : this.registerErrorAndReturnEmptyObservable(err, ret.myGuid);
+            }), finalize(() => { this.tryFinalizeByGuid(ret.myGuid); }));
         }));
     }
     /**
@@ -355,11 +344,14 @@ class HTTPService {
      * @returns {Observable<T>} Observable che contiene il risultato della chiamata
      */
     postwithFiles(url, bodyData, fileArrayOrFile, params = null) {
-        return from([this.defaultStartCall(url)]).pipe(concatMap((myGuid) => {
+        return forkJoin({
+            myGuid: from([this.defaultStartCall(url)]),
+            locale: this.bc.Locale
+        }).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(null, true, null, null) });
-            return httpCall.pipe(catchError((err, caught) => { return this.registerErrorAndReturnEmptyObservable(err, myGuid); }), finalize(() => { this.tryFinalizeByGuid(myGuid); }));
+            var httpCall = this.http.post(url, formData, { params: params, headers: this.getHeaders(ret.locale, null, true, null, null) });
+            return httpCall.pipe(catchError((err, caught) => { return this.registerErrorAndReturnEmptyObservable(err, ret.myGuid); }), finalize(() => { this.tryFinalizeByGuid(ret.myGuid); }));
         }));
     }
     /**
@@ -375,9 +367,10 @@ class HTTPService {
      * @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) {
+    async postGetFile(url, bodyData, filename, getFileCallback, afterGetFile = null, handleError = true, pars) {
         let myGuid = this.defaultStartCall(url);
-        this.http.post(url, bodyData, { params: pars, headers: this.getHeaders(), observe: 'response', responseType: "blob" }).pipe(catchError((err, caught) => {
+        let locale = await 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);
@@ -402,9 +395,10 @@ class HTTPService {
      * @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) {
+    async getFile(url, params = null, filename, getFileCallback, afterGetFile = null, handleError = true) {
         let myGuid = this.defaultStartCall(url);
-        this.http.get(url, { params: params, headers: this.getHeaders(), observe: 'response', responseType: "blob" }).pipe(catchError((err, caught) => {
+        let locale = await 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);
@@ -444,24 +438,28 @@ class HTTPService {
      * @returns {Observable<Download>} Observable dei vari step di progresso del download
      */
     getFileWithProgress(url, params = null, getFileCallback) {
-        let myGuid = this.defaultStartCall(url);
-        return this.http.get(url, { responseType: 'blob', headers: this.getHeaders(), params: params, observe: 'events', reportProgress: true })
-            .pipe(scan((previous, event) => {
-            if (this.isHttpProgressEvent(event)) {
-                let progress = event.total ? (event.loaded > event.total ? 100 : Math.round((100 * event.loaded) / event.total)) : previous.progress;
-                return { progress: progress, state: 'IN_PROGRESS', content: null };
-            }
-            if (this.isHttpResponse(event)) {
-                if (event.body) {
-                    let cdisp = event.headers.get('content-disposition');
-                    let cdispFilename = cdisp.split(';')[1].split('filename')[1].split('=')[1].trim().replace(/\"/g, '');
-                    let retUrl = window.URL.createObjectURL(event.body);
-                    getFileCallback(retUrl, cdispFilename);
+        return forkJoin({
+            myGuid: from([this.defaultStartCall(url)]),
+            locale: this.bc.Locale
+        }).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 };
                 }
-                return { progress: 100, state: 'DONE', content: event.body };
-            }
-            return previous;
-        }, { state: 'PENDING', progress: 0, content: null }), catchError((err, _) => { return this.registerErrorAndReturnEmptyObservable(err, myGuid); }), finalize(() => { this.tryFinalizeByGuid(myGuid); }));
+                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
@@ -599,7 +597,7 @@ class HTTPService {
      *
      * @returns {HttpHeaders} Header generati in base ai parametri
      */
-    getHeaders(transactionId = "", includeAuth = true, contentType = "application/json", accept = "application/json") {
+    getHeaders(locale = 'it-IT', transactionId = "", includeAuth = true, contentType = "application/json", accept = "application/json") {
         var headers = new HttpHeaders();
         var authtoken = this.ExtensionsImpl.retrieveAccessToken();
         if (contentType)
@@ -610,7 +608,7 @@ class HTTPService {
             headers = headers.append("Authorization", "Bearer " + authtoken);
         if (accept)
             headers = headers.append("Accept", accept);
-        headers = headers.append("Accept-Language", this.LOCALE ?? 'it-IT');
+        headers = headers.append("Accept-Language", locale);
         return headers;
     }
     /**
@@ -866,17 +864,15 @@ class HTTPService {
      * @returns {string} Messaggio localizzato
      */
     loc(message) {
-        if (!Loc[message]) {
-            console.warn("Untranslated message: " + message);
-            return "";
-        }
-        return Loc[message][this.LOCALE];
+        // Togliamo velocemente ste localizzazioni inutili....
+        return message;
     }
 }
-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: HTTP_LOCALE, optional: true }, { token: APP_NAME, optional: true }, { token: CLIENT_CACHE_DURATION_S, optional: true }, { token: CACHE_BY_USER, optional: true }, { token: DEBUG_MODE, optional: true }, { token: i2.HttpClient }, { token: i3.CacheService }, { token: i4.UtilityService }], target: i0.ɵɵFactoryTarget.Injectable });
-HTTPService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HTTPService });
+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, optional: true }, { token: CLIENT_CACHE_DURATION_S, optional: true }, { token: CACHE_BY_USER, optional: true }, { token: DEBUG_MODE, optional: true }, { token: i2.BaseLocalization }, { token: i3.HttpClient }, { token: i4.CacheService }, { 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
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return [{ type: HttpServiceExtensions }, { type: undefined, decorators: [{
                     type: Optional
                 }, {
@@ -884,11 +880,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImpor
                     args: [HTTP_INVALIDATION]
                 }] }, { type: undefined, decorators: [{
                     type: Optional
-                }, {
-                    type: Inject,
-                    args: [HTTP_LOCALE]
-                }] }, { type: undefined, decorators: [{
-                    type: Optional
                 }, {
                     type: Inject,
                     args: [APP_NAME]
@@ -907,18 +898,15 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImpor
                 }, {
                     type: Inject,
                     args: [DEBUG_MODE]
-                }] }, { type: i2.HttpClient }, { type: i3.CacheService }, { type: i4.UtilityService }]; } });
+                }] }, { type: i2.BaseLocalization }, { type: i3.HttpClient }, { type: i4.CacheService }, { type: i5.UtilityService }]; } });
 
 class HttpserviceModule {
     static forRoot(config) {
         return {
             ngModule: HttpserviceModule,
             providers: [
-                HTTPService,
-                HttpServiceExtensions,
                 { provide: HTTP_INVALIDATION, useValue: config?.httpInvalidation },
                 { provide: CLIENT_CACHE_DURATION_S, useValue: config?.clientCacheDurationS },
-                { provide: HTTP_LOCALE, useValue: config?.httpLocale || 'it-IT' },
                 { provide: APP_NAME, useValue: config?.appName },
                 { provide: CACHE_BY_USER, useValue: config?.cacheByUser },
                 { provide: DEBUG_MODE, useValue: config?.debugMode }