@esfaenza/extensions 15.2.4 → 15.2.5

package/fesm2020/esfaenza-extensions.mjs

@@ -1,12 +1,12 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, NgModule, Injector, Injectable, Inject, Optional } from '@angular/core';
+import { InjectionToken, Injectable, Optional, Inject, Pipe, NgModule, Injector } from '@angular/core';
 import * as i1 from '@esfaenza/localizations';
-import { BaseLocalization } from '@esfaenza/localizations';
-import swal from 'sweetalert2';
+import { LocalizationModule } from '@esfaenza/localizations';
 import { first, map } from 'rxjs/operators';
+import { Deserialize } from 'cerialize';
+import swal from 'sweetalert2';
 import { ToastrService } from 'ngx-toastr';
 import { of, Subject } from 'rxjs';
-import { Deserialize } from 'cerialize';
 
 /**
  * Token che indica il prefisso delle searchView che serve per storicizzarle evitando di tirarsi in memoria anche tutti gli oggetti. Se vuoto viene supposto 'Hot'
@@ -19,1389 +19,1426 @@ const EXT_ALLOW_UTC = new InjectionToken('EXT_ALLOW_UTC');
 
 // Angular
 /**
- * Modulo di estensione che non registra nessun servizio di estensione, dovranno essere dichiarati 1 per 1 dall'applicazione che li utilizza
- */
-class ExtensionsModule {
-    static forRoot(config) {
-        return {
-            ngModule: ExtensionsModule,
-            providers: [
-                { provide: APPSEARCH_PREFIX, useValue: config?.appsearch_prefix || 'Hot' },
-                { provide: EXT_ALLOW_UTC, useValue: config?.allow_utc == null ? false : config?.allow_utc }
-            ]
-        };
-    }
-}
-ExtensionsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ExtensionsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-ExtensionsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: ExtensionsModule });
-ExtensionsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ExtensionsModule, providers: [BaseLocalization] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ExtensionsModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    providers: [BaseLocalization]
-                }]
-        }] });
-
-// Angular
-/**
- * Service che fornisce funzionalità di alert nei tipi fondamentali: success, info, warning e danger
- */
-class MessageService {
+* Service che fornisce dei metodi di estensione per la gestione/manipolazione delle date
+*/
+class DateService {
     /**
      * Costruttore
      *
      * @ignore
      */
-    constructor(injector, locProvider) {
-        this.injector = injector;
+    constructor(locProvider, allowUtc) {
         this.locProvider = locProvider;
+        this.allowUtc = allowUtc;
         /**
-         * Oggetto statico in supporto alla localizzazione
+         * Oggetto statico di localizzazione per i messaggi di questa Service
          */
         this.loc = {
-            'Confirm': { 'en-US': "Confirm", 'it-IT': "Conferma", },
-            'Cancel': { 'en-US': "Cancel", 'it-IT': "Annulla", },
-            'Close': { 'en-US': "Close", 'it-IT': "Chiudi", },
-            'Error': { 'en-US': "Error", 'it-IT': "Errore", },
-            'Info': { 'en-US': "Info", 'it-IT': "Informazione", },
-            'Success': { 'en-US': "Success", 'it-IT': "Successo", },
-            'Warning': { 'en-US': "Warning", 'it-IT': "Attenzione", }
+            "SMALL_DATE_FORMAT": { 'en-US': "MM/DD/YYYY", 'it-IT': "DD/MM/YYYY" },
+            "FULL_DATE_FORMAT": { 'en-US': "MM/DD/YYYY HH:mm:ss", 'it-IT': "DD/MM/YYYY HH:mm:ss" },
+            "FULL_DATE_FORMAT_NO_SS": { 'en-US': "MM/DD/YYYY HH:mm", 'it-IT': "DD/MM/YYYY HH:mm" },
+            "SMALL_DATE_DISPLAY_FORMAT": { 'en-US': "DD/MM/YYYY", 'it-IT': "DD/MM/YYYY" },
+            "SMALL_DATE_DISPLAY_FORMAT_WITH_HOUR": { 'en-US': "DD/MM/YYYY HH", 'it-IT': "DD/MM/YYYY HH" },
+            "SMALL_DATE_DISPLAY_FORMAT_WITH_MINUTE": { 'en-US': "DD/MM/YYYY HH:mm", 'it-IT': "DD/MM/YYYY HH:mm" },
+            "FULL_DATE_DISPLAY_FORMAT": { 'en-US': "DD/MM/YYYY HH:mm:ss", 'it-IT': "DD/MM/YYYY HH:mm:ss" },
+            "FULL_DATE_DISPLAY_FORMAT_NO_SS": { 'en-US': "DD/MM/YYYY HH:mm", 'it-IT': "DD/MM/YYYY HH:mm" }
+        };
+        /**
+         * Oggetto di configurazione per tenere da conto le informazioni sui formati
+         */
+        this.cfg = {
+            fulldate: "",
+            fulldateDisplay: "",
+            smallDate: "",
+            fulldateNoSS: "",
+            smallDateWithH: "",
+            smallDateWithM: "",
+            fulldateDisplayNoSS: ""
         };
         this.init();
     }
-    get toastr() {
-        return this.injector.get(ToastrService);
-    }
     async init() {
         let LOCALE = this.locProvider ? await this.locProvider.Locale.pipe(first()).toPromise() : 'it-IT';
-        this.expiredSessionSwal = swal.mixin({
-            showCancelButton: false,
-            confirmButtonText: 'Login',
-            customClass: {
-                confirmButton: "btn btn-primary",
-                container: "app-wrap",
-            },
-            buttonsStyling: false,
-            reverseButtons: false,
-            allowOutsideClick: false,
-            icon: "warning"
-        });
-        this.successSwalWithCancel = swal.mixin({
-            title: this.loc["Success"][LOCALE],
-            customClass: {
-                confirmButton: "btn btn-primary",
-                cancelButton: "btn btn-secondary app-margin-right-10",
-                container: "app-wrap",
-            },
-            buttonsStyling: false,
-            reverseButtons: true,
-            showCancelButton: true,
-            confirmButtonText: this.loc["Confirm"][LOCALE],
-            cancelButtonText: this.loc["Cancel"][LOCALE],
-            icon: "success"
-        });
-        this.warningSwalWithCancel = swal.mixin({
-            title: this.loc["Warning"][LOCALE],
-            customClass: {
-                confirmButton: "btn btn-primary",
-                cancelButton: "btn btn-secondary app-margin-right-10",
-                container: "app-wrap",
-            },
-            buttonsStyling: false,
-            reverseButtons: true,
-            showCancelButton: true,
-            confirmButtonText: this.loc["Confirm"][LOCALE],
-            cancelButtonText: this.loc["Cancel"][LOCALE],
-            icon: "warning"
-        });
-        this.warningSwal = swal.mixin({
-            title: this.loc["Warning"][LOCALE],
-            customClass: {
-                confirmButton: "btn btn-primary",
-                container: "app-wrap",
-            },
-            buttonsStyling: false,
-            reverseButtons: true,
-            showCancelButton: false,
-            confirmButtonText: this.loc["Close"][LOCALE],
-            icon: "warning"
-        });
-        this.successSwal = swal.mixin({
-            title: this.loc["Success"][LOCALE],
-            customClass: {
-                confirmButton: "btn btn-primary",
-                container: "app-wrap",
-            },
-            buttonsStyling: false,
-            reverseButtons: true,
-            showCancelButton: false,
-            confirmButtonText: this.loc["Close"][LOCALE],
-            icon: "success"
-        });
-        this.errorSwal = swal.mixin({
-            title: this.loc["Error"][LOCALE],
-            customClass: {
-                confirmButton: "btn btn-primary",
-                container: "app-wrap",
-            },
-            buttonsStyling: false,
-            reverseButtons: true,
-            showCancelButton: false,
-            confirmButtonText: this.loc["Close"][LOCALE],
-            icon: "error"
-        });
-        this.infoSwal = swal.mixin({
-            title: this.loc["Info"][LOCALE],
-            customClass: {
-                confirmButton: "btn btn-primary",
-                container: "app-wrap",
-            },
-            buttonsStyling: false,
-            reverseButtons: true,
-            showCancelButton: false,
-            confirmButtonText: this.loc["Close"][LOCALE],
-            icon: "info"
-        });
+        this.cfg.smallDate = this.loc["SMALL_DATE_FORMAT"][LOCALE];
+        this.cfg.fulldate = this.loc["FULL_DATE_FORMAT"][LOCALE];
+        this.cfg.fulldateNoSS = this.loc["FULL_DATE_FORMAT_NO_SS"][LOCALE];
+        this.cfg.fulldateDisplay = this.loc["FULL_DATE_DISPLAY_FORMAT"][LOCALE];
+        this.cfg.fulldateDisplayNoSS = this.loc["FULL_DATE_DISPLAY_FORMAT_NO_SS"][LOCALE];
+        this.cfg.smallDate = this.loc["SMALL_DATE_DISPLAY_FORMAT"][LOCALE];
+        this.cfg.smallDateWithH = this.loc["SMALL_DATE_DISPLAY_FORMAT_WITH_HOUR"][LOCALE];
+        this.cfg.smallDateWithM = this.loc["SMALL_DATE_DISPLAY_FORMAT_WITH_MINUTE"][LOCALE];
     }
     /**
-     * Presentazione di un semplice messaggio di successo
+     * Aggiusta una data in "istante finale" in base a qual è la parte di data significativa.
      *
-     * Se viene chiamato con le impostazioni di default e toastr è abilitato, viene mostrato al centro
-     * Se viene chiamato con override su toastr vuol dire che è una notifica secondaria e appare in alto a destra
+     * Es. Istante finale delle ore: 05/10/1992 --> 04/10/1992 24:00(:00)
      *
-     * @param {string} text Testo da mostrare
-     * @param {"toastr" | "swal" | null} secondaryNotificationType Qualora sia una notifica secondaria, ne indica il tipo
+     * @param {any} date Data qualsiasi (Date, stringa, dayjs...), verrà ricondotta ad un oggetto dayJs
+     * @param {'day' | 'hour' | 'minute'} timepart Parte significativa della data
+     * @param {boolean} printSeconds Indica se effettuare la stampa dei secondi o no
      */
-    simpleSuccess(text, secondaryNotificationType = null, secondaryNotificationTimeout = null) {
-        let tos = this.toastrOrSwal(secondaryNotificationType);
-        if (tos == "swal")
-            this.successSwal.fire("", text);
-        else
-            this.toastr.success(text, null, { positionClass: tos == "toastr" ? "toast-top-right" : "toast-top-center", timeOut: secondaryNotificationTimeout || (tos == "toastr" ? 0 : 5000), extendedTimeOut: tos == "toastr" ? 0 : 1000 });
+    adjustDateToFinalInstant(date, timepart, printSeconds = true) {
+        let mydt = this.getDateConvertion(date);
+        if (mydt == null)
+            return "FE: Not a Date";
+        let isZeroTime = mydt.startOf(timepart).valueOf() === mydt.valueOf();
+        if (!isZeroTime) {
+            if (timepart == "day" && mydt.subtract(1, "hour").hour() == mydt.hour()) {
+                // Se l'ora precedente è lo stesso orario dell'ora attuale l'istante finale dev'essere mandato avanti di 1
+                mydt = mydt.add(1, "hour");
+            }
+            return printSeconds ? mydt.format(this.cfg.fulldateDisplay) : mydt.format(this.cfg.fulldateDisplayNoSS);
+        }
+        let tmpValue = mydt.subtract(1, timepart);
+        let value = "";
+        // Istante finale delle ore: 05/10/1992 --> 04/10/1992 24:00(:00)
+        if (timepart == 'day')
+            value = tmpValue.format(this.cfg.smallDate) + " 24:00" + (printSeconds ? ':00' : '');
+        // Istante finale dei minuti: giorno 05/10/1992 04:00:00 --> 05/10/1992 03:60(:00)
+        else if (timepart == 'hour')
+            value = tmpValue.format(this.cfg.smallDateWithH) + ":60" + (printSeconds ? ':00' : '');
+        // Istante finale dei secondi: giorno 05/10/1992 04:10:00 --> 05/10/1992 04:09:60
+        else if (timepart == 'minute')
+            value = tmpValue.format(this.cfg.smallDateWithM) + ":60";
+        return value;
     }
     /**
-     * Presentazione di un semplice messaggio di informazione
+     * Funzione che effettua l'ordinamento fra 2 date in base alla direzione specificata
      *
-     * Se viene chiamato con le impostazioni di default e toastr è abilitato, viene mostrato al centro
-     * Se viene chiamato con override su toastr vuol dire che è una notifica secondaria e appare in alto a destra
+     * @param {any} a Prima data per il confronto
+     * @param {any} b Seconda data per il confronto
+     * @param {'asc' | 'desc'} direction Direzione rispetto a cui ordinare le due date
      *
-     * @param {string} text Testo da mostrare
-     * @param {"toastr" | "swal" | null} secondaryNotificationType Qualora sia una notifica secondaria, ne indica il tipo
+     * @returns {number} 0 se le date sono uguali, 1 se la data A deve venire logicamente prima della data B, -1 altrimenti
      */
-    simpleInfo(text, secondaryNotificationType = null, secondaryNotificationTimeout = null) {
-        let tos = this.toastrOrSwal(secondaryNotificationType);
-        if (tos == "swal")
-            this.infoSwal.fire("", text);
-        else
-            this.toastr.info(text, null, { positionClass: tos == "toastr" ? "toast-top-right" : "toast-top-center", timeOut: secondaryNotificationTimeout || (tos == "toastr" ? 0 : 5000), extendedTimeOut: tos == "toastr" ? 0 : 1000 });
+    dateSort(a, b, direction) {
+        if (a < b)
+            return direction == 'asc' ? 1 : -1;
+        else if (a > b)
+            return direction == 'asc' ? -1 : 1;
+        // con a uguale a b
+        return 0;
     }
     /**
-     * Presentazione di un semplice messaggio di errore
+     * Effettua il trim dei secondi da una data espressa come stringa
      *
-     * Se viene chiamato con le impostazioni di default e toastr è abilitato, viene mostrato al centro
-     * Se viene chiamato con override su toastr vuol dire che è una notifica secondaria e appare in alto a destra
+     * @param {string} value Data espressa come stringa
      *
-     * @param {string} text Testo da mostrare
-     * @param {"toastr" | "swal" | null} secondaryNotificationType Qualora sia una notifica secondaria, ne indica il tipo
+     * @returns {string} Data senza i secondi
      */
-    simpleError(text, secondaryNotificationType = null, secondaryNotificationTimeout = null) {
-        let tos = this.toastrOrSwal(secondaryNotificationType);
-        if (tos == "swal")
-            this.errorSwal.fire("", text);
-        else
-            this.toastr.error(text, null, { positionClass: tos == "toastr" ? "toast-top-right" : "toast-top-center", timeOut: secondaryNotificationTimeout || (tos == "toastr" ? 0 : 5000), extendedTimeOut: tos == "toastr" ? 0 : 1000 });
+    trimSeconds(value) {
+        //I numeri mangiati da dayjs spesso vengono ricondotti a date vere. Mi assicuro che se ci sono solo numeri proseguo
+        if (!isNaN(value))
+            return value;
+        //Se non ho qualcosa del tipo XX/YY/ZZZZ aa:bb:cc di sicuro non è una data che mi interessa
+        if (!/^\d\d\/\d\d\/\d\d\d\d \d\d:\d\d:\d\d$/g.test(value))
+            return value;
+        //In questo caso mi arrivano valori che devono essere stampati as-is, solo tagliando i secondi
+        return "'" + value.substr(0, value.length - 3);
     }
     /**
-     * Presentazione di un semplice messaggio di avviso
+     * Data una lista di date Da e una lista di date A restituisce un oggetto rappresentante il range che include tutte le date passate
      *
-     * Se viene chiamato con le impostazioni di default e toastr è abilitato, viene mostrato al centro
-     * Se viene chiamato con override su toastr vuol dire che è una notifica secondaria e appare in alto a destra
+     * @param {any[]} fromDates Lista dei Da
+     * @param {any[]} toDates Lista dei A
      *
-     * @param {string} text Testo da mostrare
-     * @param {"toastr" | "swal" | null} secondaryNotificationType Qualora sia una notifica secondaria, ne indica il tipo
-     */
-    simpleWarning(text, secondaryNotificationType = null, secondaryNotificationTimeout = null) {
-        let tos = this.toastrOrSwal(secondaryNotificationType);
-        if (tos == "swal")
-            this.warningSwal.fire("", text);
-        else
-            this.toastr.warning(text, null, { positionClass: tos == "toastr" ? "toast-top-right" : "toast-top-center", timeOut: secondaryNotificationTimeout || (tos == "toastr" ? 0 : 5000), extendedTimeOut: tos == "toastr" ? 0 : 1000 });
-    }
-    /**
-     * Ripulisce tutti i messaggi presenti in un dato momento sullo schermo
+     * @returns {{ from: any, to: any }} Range di date Da - A che include tutti i valori di **fromDates** e **toDates**
      */
-    clearMessages() {
-        this.toastr.clear();
-        swal.close();
+    getMinMaxDatesRange(fromDates, toDates) {
+        let datesFroms = [];
+        let datesTo = [];
+        for (let i = 0; i < fromDates.length; i++) {
+            let d = fromDates[i];
+            var convertion = this.getDateConvertion(d);
+            if (convertion)
+                datesFroms.push(convertion);
+        }
+        for (let i = 0; i < toDates.length; i++) {
+            let d = toDates[i];
+            var convertion = this.getDateConvertion(d);
+            if (convertion)
+                datesTo.push(convertion);
+        }
+        return { from: dayjs.min(datesFroms), to: dayjs.max(datesTo) };
     }
     /**
-     * Mostra un messaggio di avviso con richiesta di conferma
+     * Ottiene la conversione di una data in qualsiasi formato al formato standard DayJs
      *
-     * @param {string} title Titolo del messaggio
-     * @param {string} text Contenuto del messaggio
+     * @param {any} date Oggetto rappresentante una data. Potrebbe essere una stringa, un Date o già un DayJs
+     * @param {boolean} useUtc Indica se usare l'estensione utc di Dayjs per parsare la data o no
      *
-     * @returns {Promise} Restituisce una Promise col risultato scelto dall'utente (conferma o no)
+     * @returns {any} Data in modalità DayJs
      */
-    promiseWarningWithChoice(title, text) {
-        return this.warningSwalWithCancel.fire(title, text);
+    getDateConvertion(date, useUtc = false) {
+        if (!date)
+            return null;
+        if (this.isDayJs(date))
+            return date;
+        if (this.isJsDate(date))
+            return useUtc ? dayjs.utc(date) : dayjs(date);
+        // Se non c'è la proprietà length vuol dire che non è una stringa e a questo punto non ho idea di che minchia sia
+        let length = date.length;
+        if (!length)
+            return null;
+        if (useUtc && !this.allowUtc)
+            throw "@esfaenza/extensions: Richiesta data UTC ma da configurazione la libreria non lo supporta";
+        // Per risparmiare chiamate a tentoni, in base alla lunghezza della stringa chiamo direttamente il metodo giusto, 
+        // controllando poi che mi generi una data come me la aspetto io
+        let tryThis = null;
+        let toCall = useUtc ? dayjs.utc : dayjs;
+        // Se la data contiene la lettera "T" vuol dire che è una data del tipo 2020-10-15T00:00:00, direttamente parsabile dal dayjs col locale corretto.
+        // Per il resto mi baso sulla lunghezza della stringa
+        if (date.includes("T"))
+            tryThis = toCall(date);
+        else if (length == this.cfg.fulldate.length)
+            tryThis = toCall(date, this.cfg.fulldate);
+        else if (length == this.cfg.smallDate.length)
+            tryThis = toCall(date, this.cfg.smallDate);
+        else if (length == this.cfg.fulldateNoSS.length)
+            tryThis = toCall(date, this.cfg.fulldateNoSS);
+        if (tryThis && tryThis.isValid && tryThis.isValid())
+            return tryThis;
+        // Se niente funziona, null. 
+        // Ricondurre l'Input ad una data non è possibile.
+        return null;
     }
     /**
-     * In base alla configurazione attuale e all'eventuale override per la chiamata del caso indica se bisogna utilizzare toastr o sweetalert
-     *
-     * @param {"toastr" | "swal" | null} providerOverride Override alla modalità configurata
+     * Helper che restituisce **true** qualora l'oggetto passato fosse una data vera e propria, **false** altrimenti
      *
-     * @returns {"toastr" | "swal"} Indicazione su che provider di messaggi di avviso debba essere utilizzato
-     */
-    toastrOrSwal(providerOverride) {
-        if (providerOverride != null)
-            return providerOverride;
-        return "swal";
-    }
-    /**
-     * Mostra un messaggio di avviso con richiesta di conferma e gestisce il risultato chiamato i callback **onsuccess** o **onerror**
+     * @param {any} check Oggetto da controllare
      *
-     * @param {string} title Titolo del messaggio
-     * @param {string} text Contenuto del messaggio
-     * @param {Function} onsuccess Callback da chimare su conferma
-     * @param {Function} onerror Callback da chimare su errori
+     * @returns {boolean} Indicazione se l'oggetto è un vero Date di Javascript o no
      */
-    simpleWarningWithChoice(title, text, onsuccess = null, onerror = null) {
-        this.warningSwalWithCancel.fire(title, text).then((result) => {
-            if (result.value && onsuccess)
-                onsuccess();
-            else if (onerror)
-                onerror();
-        });
+    isJsDate(check) {
+        return check && Object.prototype.toString.call(check) === "[object Date]" && !isNaN(check);
     }
     /**
-     * Mostra un messaggio di success con richiesta di conferma e gestisce il risultato chiamato i callback **onconfirm** o **onabort**
+     * Helper che restituisce **true** qualora l'oggetto passato fosse un DayJs vero e proprio, **false** altrimenti
      *
-     * @param {string} title Titolo del messaggio
-     * @param {string} text Contenuto del messaggio
-     * @param {Function} onconfirm Callback da chimare su conferma
-     * @param {Function} onabort Callback da chimare su annullamento
-     * @param {string} confirmtext Testo del pulsante di azione
-     * @param {string} aborttext Testo del pulsante di annullamento
+     * @param {any} check Oggetto da controllare
+     * @returns {boolean} Indicazione se l'oggetto è un vero DayJs o no
      */
-    simpleSuccessWithChoice(title, text, onconfirm = null, onabort = null, confirmtext = "", aborttext = '') {
-        var configuration = {
-            title: title,
-            html: text
-        };
-        if (confirmtext)
-            configuration["confirmButtonText"] = confirmtext;
-        if (aborttext)
-            configuration["cancelButtonText"] = aborttext;
-        this.successSwalWithCancel.fire(configuration).then((result) => {
-            if (result.value && onconfirm)
-                onconfirm();
-            else if (onabort)
-                onabort();
-        });
+    isDayJs(check) {
+        // Non uso instanceof perché sarebbe estremamente più lento
+        // Non uso nemmeno isDayjs() della libreria Dayjs dato che ha lo stesso problema: https://github.com/iamkun/dayjs/blob/06f88f425828b1ce96b737332d25145a95a4ee9d/src/index.js#L9
+        return check.$D !== undefined && check.$M !== undefined && check.$y !== undefined;
     }
     /**
-     * Mostra un messaggio di avviso con richiesta di conferma e gestisce il risultato chiamato i callback **onsuccess** o **onerror**
+     * Ottiene la formattazione di una data in base alla versione richiesta "small" o "long" e a se stampare o meno i secondi
      *
-     * @param {string} title Titolo del messaggio
-     * @param {string} text Contenuto del messaggio
-     */
-    observableSimpleWarningWithChoice(title, text) {
-        return of(this.warningSwalWithCancel.fire(title, text)).pipe(map(t => !!t.value));
-    }
-    /**
-     * Mostra un messaggio di avviso che la sessione corrente è scaduta e propone all'utente di navigare al login. Qualora l'utente decidesse di farlo
-     * verrà chiamata la funzione di callback **onnavigate
+     * @param {any} date Oggetto rappresentante una data. Potrebbe essere una stringa, un Date o già un DayJs
+     * @param {boolean} small Indica se formattarla con un formato breve (se **true**) o un formato più lungo (se **false**)
      *
-     * @param {string} title Titolo del messaggio
-     * @param {string} text Contenuto del messaggio
-     * @param {Function} onnavigate Callback da chimare su navigazione in corso
+     * @returns {string} Data formattata nel formato richiesto
      */
-    expiredSessionMessage(title, text, onnavigate = null) {
-        this.expiredSessionSwal.fire(title, text).then((result) => {
-            if (result.value && onnavigate)
-                onnavigate();
-        });
+    getFormatted(date, small, seconds) {
+        var date = this.getDateConvertion(date);
+        if (!date)
+            return null;
+        return date.format(small ? this.cfg.smallDate : seconds ? this.cfg.fulldateDisplay : this.cfg.fulldateDisplayNoSS);
     }
+}
+DateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DateService, deps: [{ token: i1.BaseLocalization, optional: true }, { token: EXT_ALLOW_UTC, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+DateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DateService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DateService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: function () { return [{ type: i1.BaseLocalization, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [EXT_ALLOW_UTC]
+                }] }]; } });
+
+// Angular
+/**
+ * Pipe che permette di formattare una data in base al formato specificato. Utilizza il **DateService** di **@esfaenza/extensions** per ricondurre l'input a una data valida
+ */
+class LocDatePipe {
     /**
-     * Metodo helper per gestire in maniera standardizzata una risposta di tipo **CallResult**
-     *
-     * @param {CallResult} response Risposta ricevuta dal server
-     * @param {string} successMsg Messaggio da visualizzare in caso di successo
-     * @param {string} errorMsg Messaggio da visualizzare in caso di fallimento
-     * @param {Function} postSuccess Callback da chimare in caso di successo
-     * @param {Function} postFailure Callback da chimare in caso di fallimento
+     * @ignore
      */
-    manageCallResultResponse(response, successMsg, errorMsg, postSuccess = null, postFailure = null) {
-        if (response.success) {
-            if (response.haswarning)
-                this.simpleWarning(response.warning);
-            else if (successMsg)
-                this.simpleSuccess(successMsg);
-            if (postSuccess)
-                postSuccess();
-        }
-        else {
-            this.simpleError((errorMsg ? errorMsg + ": " : "") + response.haserror ? response.error : '[NO ERR.]');
-            if (postFailure)
-                postFailure();
-        }
+    constructor(dts) {
+        this.dts = dts;
     }
     /**
-     * Metodo helper per gestire in maniera standardizzata una risposta di tipo **string**, considerando che:
-     *
-     * Stringa vuota --> Tutto bene
-     *
-     * Stringa piena --> Questo è il messaggio d'errore per cui la chiamata è fallita
+     * Trasformazione della data in input in base al formato richiesto
      *
-     * @param {string} response Risposta ricevuta dal server
-     * @param {string} successMsg Messaggio da visualizzare in caso di successo
-     * @param {string} errorMsg Messaggio da visualizzare in caso di fallimento
-     * @param {Function} postSuccess Callback da chimare in caso di successo
-     * @param {Function} postFailure Callback da chimare in caso di fallimento
-     */
-    manageStringResponse(response, successMsg, errorMsg, postSuccess = null, postFailure = null) {
-        if (!response) {
-            if (successMsg)
-                this.simpleSuccess(successMsg);
-            if (postSuccess)
-                postSuccess();
-        }
-        else {
-            if (errorMsg)
-                this.simpleError(errorMsg + ": " + response);
-            if (postFailure)
-                postFailure();
-        }
-    }
-    /**
-     * Metodo helper per gestire in maniera standardizzata una risposta di tipo **boolean**
+     * @param {any} value Valore da ricondurre ad una data e formattare
+     * @param {string} format Formato in output della data da visualizzare
      *
-     * @param {string} response Risposta ricevuta dal server
-     * @param {string} successMsg Messaggio da visualizzare in caso di successo
-     * @param {string} errorMsg Messaggio da visualizzare in caso di fallimento
-     * @param {Function} postSuccess Callback da chimare in caso di successo
-     * @param {Function} postFailure Callback da chimare in caso di fallimento
+     * @returns {string} Data formattata in base al formato
      */
-    manageStringResponseBool(response, successMsg, errorMsg, postSuccess = null, postFailure = null) {
-        if (response) {
-            if (successMsg)
-                this.simpleSuccess(successMsg);
-            if (postSuccess)
-                postSuccess();
-        }
-        else {
-            if (errorMsg)
-                this.simpleError(errorMsg);
-            if (postFailure)
-                postFailure();
-        }
+    transform(value, format = "DD/MM/YYYY") {
+        if (value == null || value === "")
+            return null;
+        var detatchedValue = JSON.parse(JSON.stringify(value));
+        var dt = this.dts.getDateConvertion(detatchedValue);
+        return dt.format(format);
     }
 }
-MessageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: MessageService, deps: [{ token: Injector }, { token: i1.BaseLocalization, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-MessageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: MessageService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: MessageService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: i0.Injector, decorators: [{
-                    type: Inject,
-                    args: [Injector]
-                }] }, { type: i1.BaseLocalization, decorators: [{
-                    type: Optional
-                }] }]; } });
+LocDatePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LocDatePipe, deps: [{ token: DateService }], target: i0.ɵɵFactoryTarget.Pipe });
+LocDatePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: LocDatePipe, name: "loc_date" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: LocDatePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: "loc_date", pure: true }]
+        }], ctorParameters: function () { return [{ type: DateService }]; } });
 
 // Angular
-/**
- * Service che fornisce un accesso base in lettura/scrittura sulla clipboard
- */
-class ClipboardService {
-    /**
-     * Costruttore
-     *
+class ExtensionsModule {
+    static forRoot(config) {
+        return {
+            ngModule: ExtensionsModule,
+            providers: [
+                { provide: APPSEARCH_PREFIX, useValue: config?.appsearch_prefix || 'Hot' },
+                { provide: EXT_ALLOW_UTC, useValue: config?.allow_utc == null ? false : config?.allow_utc }
+            ]
+        };
+    }
+}
+ExtensionsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ExtensionsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ExtensionsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: ExtensionsModule, declarations: [LocDatePipe], imports: [LocalizationModule], exports: [LocDatePipe] });
+ExtensionsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ExtensionsModule, imports: [LocalizationModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ExtensionsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [LocalizationModule],
+                    declarations: [LocDatePipe],
+                    exports: [LocDatePipe]
+                }]
+        }] });
+
+/**
+ * Suffisso della proprietà da generare in cui salvare il navigatore
+ * utilizzato dal servizio di esportazione per prendere il valore delle proprietà di un oggetto
+ */
+const csvValueNavigator = "_csvnav";
+/**
+ * Suffisso della proprietà da generare in cui salvare l'ordine di esportazione
+ */
+const csvOrdPrefix = "_csvord";
+/**
+ * Suffisso della proprietà da generare in cui salvare la visibilità di questa proprietà
+ */
+const csvVisPrefix = "_csvvis";
+/**
+ * Suffisso della proprietà da generare in cui salvare il nome della colonna in cui salvare questa proprietà
+ */
+const csvHdrPrefix = "_csvhdr";
+/**
+ * Suffisso della proprietà da generare in cui salvare il codice del th a cui si riferisce questo campo
+ */
+const csvPropKey = "_csvkey";
+/**
+ * Suffisso della proprietà da generare in cui salvare il valore da prendere per una proprietà di tipo Lista
+ */
+const listCsvValPrefix = "_listcsvval";
+/**
+ * Suffisso della proprietà da generare in cui salvare l'Header della proprietà di tipo Lista relativo al valore esportato nella proprietà con suffisso **listCsvValPrefix**
+ */
+const listCsvHdrPrefix = "_listcsvhdr";
+/**
+ * Suffisso della proprietà da generare in cui salvare il formato della proprietà di tipo Lista relativo al valore esportato nella proprietà con suffisso **listCsvValPrefix**
+ */
+const listCsvValFormat = "_listcsvvalformat";
+/**
+ * Suffisso della proprietà da generare in cui salvare il valore da prendere per una proprietà di tipo Dizionario
+ */
+const dictionaryCsvValPrefix = "_flatlistcsvval";
+/**
+ * Suffisso della proprietà da generare in cui salvare l'Header della proprietà di un Dizionario relativo al valore esportato nella proprietà con suffisso **dictionaryCsvValPrefix**
+ */
+const dictionaryCsvHdrPrefix = "_flatlistcsvhdr";
+/**
+ * Suffisso della proprietà da generare in cui salvare il formato della proprietà che si sta esportando
+ */
+const csvFormatPrefix = "_csvfmt";
+/**
+* Nome della proprietà che contiene tutti i nomi di tutte le proprietà da esportare
+*/
+const exportList = "__export_list__";
+
+// Angular
+/**
+ * Decoratore di esportazione utilizzabile su una proprietà singola.
+ * Verranno generate 3 proprietà che gestiranno l'esportazione: (prop, prop_csvvis, prop_csvhdr).
+ *
+ * Ad esempio, da questa configurazione:
+ *
+ * @example
+ * ```
+ * @Export(true, "MyHeader")
+ * ciao: string;
+ * ```
+ *
+ * Nasceranno le seguenti proprietà nell'oggetto esportabile:
+ *
+ * @example
+ * ```
+ * ciao_csvvis: string; => true
+ * ciao: string;
+ * ciao_csvhdr: string => "MyHeader"
+ * ```
+ *
+ * @param {number} order Ordine di esportazione. Più piccolo è, prima appare il valore
+ * @param {string} header Titolo della colonna nel file CSV esportato
+ * @param {string} format Formato di esportazione. Può essere un formato data per i campi data o 'F' per i campi floating point
+ */
+const Export = (order, header, format = null, tableid = null) => (target, propertyKey) => {
+    if (format)
+        Object.defineProperty(target, propertyKey + csvFormatPrefix, { value: format, writable: false });
+    Object.defineProperty(target, propertyKey + csvOrdPrefix, { value: order, writable: false });
+    Object.defineProperty(target, propertyKey + csvVisPrefix, { value: !!header, writable: false });
+    Object.defineProperty(target, propertyKey + csvHdrPrefix, { value: header, writable: false });
+    if (tableid)
+        Object.defineProperty(target, propertyKey + csvPropKey, { value: tableid, writable: false });
+    if (target[exportList])
+        target[exportList].push(propertyKey + csvVisPrefix);
+    else
+        target[exportList] = [propertyKey + csvVisPrefix];
+};
+/**
+ * Decoratore di esportazione utilizzabile su un oggetto.
+ * Per ogni proprietà dell'oggetto verranno generate 3 proprietà che gestiranno l'esportazione: (prop, prop_csvvis, prop_csvhdr).
+ * Per essere esportate, le proprietà dell'oggetto devono essere marcate con i Decoratori di esportazione
+ *
+ * Ad esempio, da questa configurazione:
+ *
+ * @example
+ * ```
+ * MyObj {
+ *     @Export(true, "MyHeader")
+ *     ciao: string;
+ * }
+ *
+ * @ExportObject(true, "MyHeader")
+ * test: MyObj;
+ * ```
+ *
+ * Nasceranno le seguenti proprietà nell'oggetto esportabile:
+ *
+ * @example
+ * ```
+ * testciao: string; => Valore di MyObj.ciao
+ * testciao_csvvis: string; => true
+ * testciao_csvhdr: string => "MyHeader"
+ * ```
+ *
+ * @param {number} order Ordine di esportazione. Più piccolo è, prima appare il valore
+ * @param {any} type Tipo da esportare
+ */
+const ExportAs = (order, type, prefix) => (target, propertyKey) => {
+    var t = new type();
+    var props = t[exportList];
+    for (let i = 0; i < props.length; i++) {
+        let prop = props[i].replace(csvVisPrefix, '');
+        if (typeof t[prop + csvVisPrefix] !== "undefined") {
+            var toEmit = t[prop + csvVisPrefix];
+            var lbl = t[prop + csvHdrPrefix];
+            var format = t[prop + csvFormatPrefix];
+            var orderProp = t[prop + csvOrdPrefix];
+            if (format)
+                Object.defineProperty(target, propertyKey + prop + csvFormatPrefix, { value: format, writable: false });
+            Object.defineProperty(target, propertyKey + prop + csvOrdPrefix, { value: orderProp + order, writable: false });
+            Object.defineProperty(target, propertyKey + prop, { value: null, writable: true, enumerable: true });
+            Object.defineProperty(target, propertyKey + prop + csvValueNavigator, { value: propertyKey + "." + prop, writable: false });
+            Object.defineProperty(target, propertyKey + prop + csvVisPrefix, { value: toEmit, writable: false });
+            Object.defineProperty(target, propertyKey + prop + csvHdrPrefix, { value: (prefix ? prefix + ' ' : '') + lbl, writable: false });
+            if (target[exportList])
+                target[exportList].push(propertyKey + prop + csvVisPrefix);
+            else
+                target[exportList] = [propertyKey + prop + csvVisPrefix];
+        }
+    }
+};
+/**
+ * Decoratore di esportazione utilizzabile su una lista,
+ * si utilizzano 2 navigator rispettivamente per la valorizzazione dell'Header e del Valore e
+ * per ogni elemento dell'array verranno generate 3 proprietà che gestiranno l'esportazione: (prop, prop_csvvis, prop_csvhdr)
+ *
+ * ATTENZIONE: Gli oggetti esportati in questa modalità non devono presentare altri tag di tipo @Export{...} all'interno. Fa tutto questo decoratore
+ *
+ * I navigator hanno questa convenzione:
+ *
+ * . --> divide due proprietà da richiamare consecutivamente: "a.b" richiamerà "obj.a.b";
+ *
+ * | --> divide più proprietà per le concatenazioni con uno spazio fra una e l'altra: "regdesc|slice.slicename" diventerà obj.regdesc + " " + obj.slice.slicename
+ *
+ * @param {number} order Ordine di esportazione. Più piccolo è, prima appare il valore
+ * @param {string} headernavigator Navigator col compito di selezionare il titolo per la colonna
+ * @param {string} valuenavigator Navigator col compito di selezionare il valore per la colonna
+ * @param {string} valueformat Formato di esportazione per i valori selezionati dal **valuenavigator**. Può essere un formato data per i campi data o 'F' per i campi floating point
+ */
+const ExportList = (order, headernavigator, valuenavigator, valueformat = null) => (target, propertyKey) => {
+    Object.defineProperty(target, propertyKey + csvOrdPrefix, { value: order, writable: false });
+    Object.defineProperty(target, propertyKey + listCsvValPrefix, { value: valuenavigator, writable: false });
+    Object.defineProperty(target, propertyKey + listCsvHdrPrefix, { value: headernavigator, writable: false });
+    Object.defineProperty(target, propertyKey + listCsvValFormat, { value: valueformat, writable: false });
+    if (target[exportList])
+        target[exportList].push(propertyKey + listCsvHdrPrefix);
+    else
+        target[exportList] = [propertyKey + listCsvHdrPrefix];
+};
+/**
+ * Decoratore di esportazione utilizzabile su un dizionario. Se ad esempio si vogliono generare le colonne
+ *
+ * Valore A = 1
+ *
+ * Valore B = 2
+ *
+ * Valore C = 3
+ *
+ * partendo da un oggetto iniziale { Valore { A: 1, B: 2, C: 3 } }
+ *
+ * @param {number} order Ordine di esportazione. Più piccolo è, prima appare il valore
+ * @param {string} headernavigator Navigator col compito di selezionare il titolo per la colonna
+ * @param {string} valuenavigator Navigator col compito di selezionare il valore per la colonna
+ */
+const ExportDictionary = (order, headernavigator, valuenavigator) => (target, propertyKey) => {
+    Object.defineProperty(target, propertyKey + csvOrdPrefix, { value: order, writable: false });
+    Object.defineProperty(target, propertyKey + dictionaryCsvValPrefix, { value: valuenavigator, writable: false });
+    Object.defineProperty(target, propertyKey + dictionaryCsvHdrPrefix, { value: headernavigator, writable: false });
+    if (target[exportList])
+        target[exportList].push(propertyKey + dictionaryCsvHdrPrefix);
+    else
+        target[exportList] = [propertyKey + dictionaryCsvHdrPrefix];
+};
+/**
+ * Service che si occupa dell'esportazione degli oggetti marcati dai Decoratori **ExportDictionary**, **ExportList**, **ExportAs** o **Export**
+ */
+class ExportService {
+    /**
+     * Costruttore
+     *
      * @ignore
      */
-    constructor(msgService, locProvider) {
-        this.msgService = msgService;
-        this.locProvider = locProvider;
-        /**
-         * Oggetto statico di localizzazione per i messaggi di questa Service
-         */
-        this.loc = {
-            "Unfortunately Firefox doesn't yet support direct Clipboard access if not via extensions, Please use Chrome to do this operation": {
-                'en-US': "Unfortunately Firefox doesn't yet support direct Clipboard access if not via extensions, Please use Chrome to do this operation",
-                'it-IT': "Mi dispiace ma Firefox non supporta l'accesso diretto alla Clipboard, se non attraverso le estensioni. Si prega di usare Chrome"
-            },
-            "Generic error during 'copy' command execution": {
-                'en-US': "Generic error during 'copy' command execution",
-                'it-IT': "Errore generico durante l'esecuzione del comando 'copy'"
-            },
-            "Error during Clipboard content read operation": {
-                'en-US': "Error during Clipboard content read operation",
-                'it-IT': "Errore nella lettura del contenuto della Clipboard"
-            },
-            "Error during Clipboard content copy operation": {
-                'en-US': "Error during Clipboard content copy operation",
-                'it-IT': "Errore nella scrittura del contenuto nella Clipboard"
-            },
-            "Please insert your clipboard content": {
-                'en-US': "Please insert your clipboard content",
-                'it-IT': "Si prega di incollare il contenuto della Clipboard"
-            },
-            "User input required": {
-                'en-US': "User input required",
-                'it-IT': "Richiesto Input utente"
-            },
-            "Your current browser does not support reading from the clipboard directly. Please paste your clipboard's content in this Input field and confirm the operation": {
-                'en-US': "Your current browser does not support reading from the clipboard directly. Please paste your clipboard's content in this Input field and confirm the operation",
-                'it-IT': "Il browser corrente non supporta la lettura diretta dei dati della Clipboard, si prega di effettuare un'incolla (CTRL + V) nella casella di testo e confermare l'operazione"
-            },
-            "Confirm": {
-                'en-US': "Confirm",
-                'it-IT': "Conferma"
-            },
-            "Cancel": {
-                'en-US': "Cancel",
-                'it-IT': "Annulla"
-            },
-        };
+    constructor(dates) {
+        this.dates = dates;
     }
     /**
-     * Prende il valore della clipboard.
-     * Si può specificare se ci si aspetta una lista o una matrice di valori in modo da ricevere già un risultato utilizzabile
+     * Data una lista di oggetti genera gli header per l'esportazione e integra ogni oggetto con le proprietà esportabili dalla libreria **@ctrl/ngx-csv**
      *
-     * @param {'array' | 'matrix'} style Stile dell'output desiderato, se array o matrice
-     * @param {Function} valueFoundCallback Callback che questa funzione chiamerà una volta ottenuto i valori richiesti dalla clipboard
+     * @param {any[]} objs Oggetti da esportare
+     *
+     * @returns {CsvHeaders[]} Header di esportazione già ordinati correttamente
      */
-    async getClipboard(style, valueFoundCallback) {
-        let LOCALE = this.locProvider ? await this.locProvider.Locale.pipe(first()).toPromise() : 'it-IT';
-        if (navigator.userAgent.indexOf("Firefox") != -1) {
-            swal.fire({
-                title: this.loc["User input required"][LOCALE],
-                text: this.loc["Your current browser does not support reading from the clipboard directly. Please paste your clipboard's content in this Input field and confirm the operation"][LOCALE],
-                input: 'textarea',
-                icon: "warning",
-                confirmButtonText: this.loc["Confirm"][LOCALE],
-                cancelButtonText: this.loc["Cancel"][LOCALE],
-                showCancelButton: true,
-                customClass: {
-                    confirmButton: "btn btn-primary",
-                    cancelButton: "btn btn-secondary app-margin-right-15",
-                    container: "app-wrap",
-                },
-                reverseButtons: true,
-                allowOutsideClick: false,
-                inputValidator: (value) => {
-                    if (!value)
-                        return this.loc["Please insert your clipboard content"][LOCALE];
+    setupForExport(objs, columns = []) {
+        let headers = [];
+        let headersCache = {};
+        if (!objs || objs.length == 0)
+            return headers;
+        // Devo per forza farlo per tutti gli oggetti dato che devo esporre le proprietà che mi servono da esportare
+        // Gli header li raccolgo tutti poi faccio uan distinct in modo da esportare tutte le proprietà per bene
+        let columnSelectionDictionary = {};
+        if (columns?.length > 0)
+            for (let i = 0; i < columns?.length; i++)
+                columnSelectionDictionary[columns[i]] = true;
+        for (let i = 0; i < objs.length; i++) {
+            let hds = this.parseAndGetHeaders(objs[i], columnSelectionDictionary);
+            // Aggiungo gli header facendo in modo di non aggiungerne mai due uguali per non dover fare una distinct dopo
+            // che costerebbe comunque risorse. Utilizzo un dizionario d'appoggio per lookup istantanei
+            for (let k = 0; k < hds.length; k++) {
+                if (!headersCache[hds[k].key]) {
+                    headersCache[hds[k].key] = true;
+                    headers.push(hds[k]);
                 }
-            }).then(t => {
-                if (t.isConfirmed) {
-                    console.log("[@esfaenza/extensions] Retrieving input data from user input");
-                    this.doClipboardDataGet(t.value, style, valueFoundCallback);
+            }
+        }
+        if (!columns || columns.length == 0)
+            return headers.sort((a, b) => a.order - b.order);
+        else {
+            // Se mi arriva la lista di colonne non mi dà solo la visibilità, ma anche l'ordinamento
+            // le esporto di conseguenza
+            let orderedHeaders = [];
+            for (let i = 0; i < columns.length; i++) {
+                let thisId = columns[i];
+                for (let i = 0; i < headers.length; i++) {
+                    if (headers[i].propKey == thisId) {
+                        orderedHeaders.push(headers[i]);
+                        break;
+                    }
                 }
-            });
-            return;
+            }
+            return orderedHeaders;
+        }
+    }
+    /**
+     * Data una lista di oggetti generici genera gli header per l'esportazione e integra ogni oggetto con le proprietà esportabili dalla libreria **@ctrl/ngx-csv**
+     *
+     * @param {GenericItem[]} objs Oggetti generici da esportare
+     * @param {CsvHeaders[]} columns Colonne richieste dall'esportazione
+     *
+     * @returns {CsvHeaders[]} Header di esportazione già ordinati correttamente
+     */
+    setupForGenericExport(objs, columns) {
+        let headers = [];
+        if (!objs || objs.length == 0)
+            return headers;
+        // Devo per forza farlo per tutti gli oggetti dato che devo esporre le proprietà che mi servono da esportare
+        objs.forEach((obj, index) => {
+            if (index == 0)
+                headers = this.parseAndGetGenericHeaders(obj, columns);
+            else
+                this.parseAndGetGenericHeaders(obj, columns);
+        });
+        return headers;
+    }
+    /**
+     * Dato un oggetto generico genera gli header per l'esportazione e lo integra con le proprietà esportabili dalla libreria **@ctrl/ngx-csv**
+     *
+     * Metodo interno richiamato da **setupForGenericExport**
+     *
+     * @param {GenericItem} obj Oggetto generico da esportare
+     * @param {CsvColumn[]} columns Colonne richieste dall'esportazione
+     *
+     * @returns {CsvHeaders[]} Header di esportazione già ordinati correttamente
+     */
+    parseAndGetGenericHeaders(obj, columns) {
+        if (!obj.properties)
+            return null;
+        var headers = [];
+        //Miracle incoming
+        columns.forEach(t => {
+            var propValue = obj.properties[t.key];
+            Object.defineProperty(obj, t.key + "_exp", { value: propValue, writable: false, enumerable: true });
+            headers.push({ label: t.label, key: t.key + "_exp", order: t.order, type: t.type, propKey: null });
+        });
+        //Tirati fuori tutti gli header faccio sort sull'ordinamento
+        return headers.sort((a, b) => { return a.order - b.order; });
+    }
+    /**
+     * Dato un oggetto genera gli header per l'esportazione e lo integra con le proprietà esportabili dalla libreria **@ctrl/ngx-csv**
+     *
+     * Metodo interno richiamato da **setupForExport**
+     *
+     * @param {any} obj Oggetto generico da esportare
+     *
+     * @returns {CsvHeaders[]} Header di esportazione già ordinati correttamente
+     */
+    parseAndGetHeaders(obj, columnsSelection) {
+        var headers = [];
+        // Miracle incoming
+        let exportProps = obj[exportList] || [];
+        if (exportProps.length == 0)
+            console.warn("[@esfaenza/extensions] Nessuna colonna configurata da esportare!");
+        for (let i = 0; i < exportProps.length; i++) {
+            let prop = exportProps[i];
+            let propBase = "";
+            let toCall;
+            if (prop.endsWith(listCsvHdrPrefix)) {
+                propBase = prop.replace(listCsvHdrPrefix, '');
+                toCall = this.parseList.bind(this);
+            }
+            else if (prop.endsWith(dictionaryCsvHdrPrefix)) {
+                toCall = this.parseDictionary.bind(this);
+                propBase = prop.replace(dictionaryCsvHdrPrefix, '');
+            }
+            else if (prop.endsWith(csvVisPrefix)) {
+                propBase = prop.replace(csvVisPrefix, '');
+                if (typeof obj[propBase + csvValueNavigator] !== "undefined")
+                    toCall = this.parseObject.bind(this);
+                else
+                    toCall = this.parseProperty.bind(this);
+            }
+            if (toCall)
+                toCall(obj, propBase, headers, columnsSelection);
         }
-        if (window.clipboardData) {
-            console.log("[@esfaenza/extensions] Found clipboardData");
-            let data = window.clipboardData.getData("Text");
-            this.doClipboardDataGet(data, style, valueFoundCallback);
+        return headers;
+    }
+    /**
+     * Setup per l'esportazione di una singola proprietà.
+     * Viene generato l'header e la proprietà relativa al valore formattato o no
+     *
+     * @param {any} obj Oggetto di cui esportare la proprietà **prop**
+     * @param {string} prop Proprietà da esportare
+     * @param {CsvHeaders} headers Contenitore degli header, verrà riempito da questa funzione
+     */
+    parseProperty(obj, prop, headers, columnsSelection) {
+        let toEmit = obj[prop + csvVisPrefix];
+        let format = obj[prop + csvFormatPrefix];
+        let propKey = obj[prop + csvPropKey];
+        if (propKey && !columnsSelection[propKey] && Object.keys(columnsSelection).length > 0) {
+            console.log("[@esfaenza/extensions] Colonna da non esportare: " + propKey);
+            return;
         }
-        else if (window.navigator.clipboard) {
-            console.log("[@esfaenza/extensions] Found navigator clipboard");
-            window.navigator.permissions.query({ name: 'clipboard-read' }).then(result => {
-                if (!(result.state === 'granted' || result.state === 'prompt')) {
-                    console.error("[@esfaenza/extensions] Clipboard permission not granted");
-                    if (valueFoundCallback)
-                        valueFoundCallback([]);
-                    return;
+        let lbl = obj[prop + csvHdrPrefix];
+        let order = obj[prop + csvOrdPrefix];
+        if (toEmit && lbl !== "undefined") {
+            // Se non ho un formato esporto direttamente
+            if (!format) {
+                // Se è un formato data mi assicuro di non stampare mai una data 00:00:00 altrimenti in esportazione viene uno schifo
+                var val = obj[prop] ? this.dates.trimSeconds(obj[prop].toString()) : "";
+                Object.defineProperty(obj, prop + "_nofmt", { value: val, writable: false, enumerable: true });
+                headers.push({ label: lbl ? lbl : prop + "_nofmt", key: prop + "_nofmt", order: order, type: "string", propKey: propKey });
+            }
+            else {
+                // Caso formato numerico
+                if (format == "F") {
+                    // Check considerando la possibilità di zeri
+                    let val = obj[prop] != null ? obj[prop].toString() : "";
+                    // Elimino tutte le virgole (indicatori di migliaia per la culture default en-US)
+                    val = val.replace(/,/, "");
+                    // Il singolo punto che c'è, se presente (separatore decimali) lo trasformo in virgola
+                    let valConverted = val.replace(".", ",");
+                    Object.defineProperty(obj, prop + "_fmt", { value: valConverted, writable: false, enumerable: true });
+                    headers.push({ label: lbl ? lbl : prop + "_fmt", key: prop + "_fmt", order: order, type: "number", propKey: propKey });
                 }
-                console.log("[@esfaenza/extensions] Clipboard permission granted, retrieving values");
-                window.navigator.clipboard.readText()
-                    .then((t) => this.doClipboardDataGet(t, style, valueFoundCallback))
-                    .catch((err) => this.msgService.simpleError(this.loc["Error during Clipboard content read operation"][LOCALE] + ": " + err));
-            });
+                else {
+                    // Se ho un formato data trasformo in dayjs, formatto ed esporto
+                    // Per la trasformazione in dayjs provo prima a passargli la stringa di netto, sperando la riconosca
+                    // Se non funziona provo a definirgli la formattazione standard del metering per quel linguaggio
+                    let val = this.dates.getFormatted(obj[prop], format.length <= 10, format.length > 16);
+                    Object.defineProperty(obj, prop + "_fmt", { value: val ?? "", writable: false, enumerable: true });
+                    headers.push({ label: lbl ? lbl : prop + "_fmt", key: prop + "_fmt", order: order, type: "date", propKey: propKey });
+                }
+            }
         }
     }
-    /** @ignore */
-    doClipboardDataGet(clipboardText, style, valueFoundCallback) {
-        console.log("[@esfaenza/extensions] Retrieved clipboard values: " + clipboardText);
-        let value = style == "array" ? this.getClipboardLines(clipboardText) :
-            style == "matrix" ? this.getClipboardMatrix(clipboardText) : [];
-        console.log(`[@esfaenza/extensions] Adapted for ${style}: ${JSON.stringify(value)}`);
-        if (valueFoundCallback)
-            valueFoundCallback(value);
-    }
     /**
-     * Ottiene il contenuto della clipboard diviso per righe (separate da newline)
+     * Setup per l'esportazione di una singola proprietà da un oggetto.
+     * Viene generato l'header e la proprietà relativa al valore formattato o no.
      *
-     * @param {string} data contenuto letto dalla clipboard
+     * Per ottenere il valore e l'header della proprietà vengono utilizzati i navigatori auto-generati nel decoratore **ExportAs**
      *
-     * @returns {string[]} Array contenente il testo preso dalla clipboard diviso per riga
+     * @param {any} obj Oggetto di cui esportare la proprietà **prop**
+     * @param {string} prop Proprietà da esportare
+     * @param {CsvHeaders} headers Contenitore degli header, verrà riempito da questa funzione
      */
-    getClipboardLines(data) {
-        let trimmedData = data.trim();
-        if (!trimmedData.includes("\r\n") && trimmedData.includes("\n"))
-            return trimmedData.split("\n");
-        return trimmedData.split("\r\n");
+    parseObject(obj, prop, headers) {
+        //se questa proprietà ha un navigator significa che deriva da un oggetto interno, recupero il valore in questa fase dato che prima non ce l'ho
+        let valuenavigator = obj[prop + csvValueNavigator];
+        //Es. di valuenavigator obj.subobj.subsubobj.property
+        let jmps = valuenavigator.split(".");
+        //Mi clono l'oggetto originale per non uccidergli i riferimenti
+        let clone = JSON.parse(JSON.stringify(obj));
+        //Salto ricorsivamente su me stesso per arrivare alla proprietà
+        //Salto 1 > diventa obj
+        //Salto 2 > diventa obj.subobj
+        //ecc...
+        jmps.forEach(pp => { clone = clone[pp]; });
+        //Valore finale :D
+        let value = clone;
+        let lbl = obj[prop + csvHdrPrefix];
+        let order = obj[prop + csvOrdPrefix];
+        //Se per questa proprietà ho un formato lo applico
+        let format = obj[prop + csvFormatPrefix];
+        let type = "string";
+        if (format == "F") {
+            let val = value.toString();
+            val = val.replace(/,/, "");
+            value = val.replace(".", ",");
+            type = "number";
+        }
+        else if (format) {
+            value = this.dates.getFormatted(value, format.length <= 10, format.length > 16);
+            type = "date";
+        }
+        Object.defineProperty(obj, prop, { value: value ?? "", writable: false, enumerable: true });
+        headers.push({ label: lbl ? lbl : prop, key: prop, order: order, type: type, propKey: null });
     }
     /**
-     * Ottiene il contenuto della clipboard diviso per righe (separate da newline) e colonne (separate da tab)
+     * Setup per l'esportazione di una lista di valori pivottati dinamicamente:
      *
-     * @param {string} data contenuto letto dalla clipboard
+     * => Recupero il valore utilizzando i navigatori
      *
-     * @returns {string[][]} Matrice contenente il testo preso dalla clipboard diviso per riga e colonna
+     * => Recupero l'header utilizzando i navigatori
+     *
+     * => Con il valore ci creo la property
+     *
+     * => Con l'header e il riferimento alla property appena creata creo un record negli header da esportare
+     *
+     * @param {any} obj Oggetto di cui esportare la proprietà **prop**
+     * @param {string} prop Proprietà da esportare
+     * @param {CsvHeaders} headers Contenitore degli header, verrà riempito da questa funzione
      */
-    getClipboardMatrix(data) {
-        var ret = [];
-        var rows = !data.includes("\r\n") && data.includes("\n") ? data.split("\n") : data.split("\r\n");
-        // A quanto pare ogni valore è separato da un \t... spero che sia uno standard di quando si copia da excel altrimenti ciao
-        for (let i = 0; i < rows.length; i++)
-            ret.push(rows[i].split('\t').map(t => t.trim()));
-        return ret;
+    parseList(obj, prop, headers) {
+        let headernavigator = obj[prop + listCsvHdrPrefix];
+        let valuenavigator = obj[prop + listCsvValPrefix];
+        let valueformat = obj[prop + listCsvValFormat];
+        let order = obj[prop + csvOrdPrefix];
+        var jumps, tmpRes;
+        var objs = obj[prop];
+        for (let idx = 0; idx < objs.length; idx++) {
+            let listitem = objs[idx];
+            var headersplit = headernavigator.split(" ");
+            var header = "";
+            // Per l'header si considera a se stante ogni pezzo separato da spazio per fare le concatenazioni
+            headersplit.forEach(pr => {
+                jumps = pr.split(".");
+                tmpRes = JSON.parse(JSON.stringify(listitem));
+                jumps.forEach(pp => { tmpRes = tmpRes[pp]; });
+                if (!header)
+                    header = tmpRes;
+                else
+                    header += " " + tmpRes;
+            });
+            jumps = valuenavigator.split(".");
+            tmpRes = JSON.parse(JSON.stringify(listitem));
+            jumps.forEach(pp => { tmpRes = tmpRes[pp]; });
+            let value = tmpRes;
+            let type = "string";
+            if (valueformat == "F") {
+                let val = value != null ? value.toString() : "";
+                val = val.replace(/,/, "");
+                value = val.replace(".", ",");
+                type = "number";
+            }
+            else if (valueformat) {
+                value = this.dates.getFormatted(obj[prop], valueformat.length <= 10, valueformat.length > 16);
+                type = "date";
+            }
+            Object.defineProperty(obj, prop + idx, { value: value ?? "", writable: false });
+            headers.push({ label: header, key: prop + idx, order: order + idx, type: type, propKey: null });
+        }
     }
     /**
-     * Metodo che copia un testo all'interno della clipboard
+     * Setup per l'esportazione di una lista di valori pivottati dinamicamente:
      *
-     * @param {string} text Testo da inserire nella clipboard
+     * => Recupero il valore utilizzando i navigatori
+     *
+     * => Recupero l'header utilizzando i navigatori
+     *
+     * => Con il valore ci creo la property
+     *
+     * => Con l'header e il riferimento alla property appena creata creo un record negli header da esportare
+     *
+     * @param {any} obj Oggetto di cui esportare la proprietà **prop**
+     * @param {string} prop Proprietà da esportare
+     * @param {CsvHeaders} headers Contenitore degli header, verrà riempito da questa funzione
      */
-    async copyTextToClipboard(text) {
-        let LOCALE = this.locProvider ? await this.locProvider.Locale.pipe(first()).toPromise() : 'it-IT';
-        var textArea = document.createElement("textarea");
-        //
-        // *** This styling is an extra step which is likely not required. ***
-        //
-        // Why is it here? To ensure:
-        // 1. the element is able to have focus and selection.
-        // 2. if element was to flash render it has minimal visual impact.
-        // 3. less flakyness with selection and copying which **might** occur if
-        //    the textarea element is not visible.
-        //
-        // The likelihood is the element won't even render, not even a flash,
-        // so some of these are just precautions. However in IE the element
-        // is visible whilst the popup box asking the user for permission for
-        // the web page to copy to the clipboard.
-        //
-        // Place in top-left corner of screen regardless of scroll position.
-        textArea.style.position = "fixed";
-        textArea.style.top = "0";
-        textArea.style.left = "0";
-        // Ensure it has a small width and height. Setting to 1px / 1em
-        // doesn't work as this gives a negative w/h on some browsers.
-        textArea.style.width = "2em";
-        textArea.style.height = "2em";
-        // We don't need padding, reducing the size if it does flash render.
-        textArea.style.padding = "0";
-        // Clean up any borders.
-        textArea.style.border = "none";
-        textArea.style.outline = "none";
-        textArea.style.boxShadow = "none";
-        // Avoid flash of white box if rendered for any reason.
-        textArea.style.background = "transparent";
-        textArea.value = text;
-        document.body.appendChild(textArea);
-        textArea.focus();
-        textArea.select();
-        try {
-            var successful = document.execCommand("copy");
-            if (!successful)
-                this.msgService.simpleError(this.loc["Generic error during 'copy' command execution"][LOCALE]);
-        }
-        catch (err) {
-            this.msgService.simpleError(this.loc["Error during Clipboard content copy operation"][LOCALE] + ": " + err);
+    parseDictionary(obj, prop, headers) {
+        let headernavigator = obj[prop + dictionaryCsvHdrPrefix];
+        let valuenavigator = obj[prop + dictionaryCsvValPrefix];
+        let order = obj[prop + csvOrdPrefix];
+        var jumps, tmpRes;
+        var objs = obj[prop];
+        for (let idx = 0; idx < objs.length; idx++) {
+            let listitem = objs[idx];
+            var headersplit = headernavigator.split(" ");
+            var header = "";
+            headersplit.forEach(pr => {
+                jumps = pr.split(".");
+                tmpRes = JSON.parse(JSON.stringify(listitem));
+                jumps.forEach(pp => { tmpRes = tmpRes[pp]; });
+                if (!header)
+                    header = tmpRes;
+                else
+                    header += " " + tmpRes;
+            });
+            var valuesplit = valuenavigator.split(",");
+            valuesplit.forEach((t, idxinternal) => {
+                var navig = t.split("-")[1];
+                var desc = t.split("-")[0];
+                jumps = navig.split(".");
+                tmpRes = JSON.parse(JSON.stringify(listitem));
+                jumps.forEach(pp => { tmpRes = tmpRes[pp]; });
+                let value = tmpRes;
+                let propname = prop + idx.toString() + idxinternal.toString();
+                Object.defineProperty(obj, propname, { value: value ?? "", writable: false });
+                headers.push({ label: header + " " + desc, key: propname, order: order + idx, type: 'string', propKey: null });
+            });
         }
-        document.body.removeChild(textArea);
+    }
+    /**
+     * Metodo che si occupa della deserializzazione degli oggetti da esportare. Messo a livello di libreria in modo che qualora ci fosse da cambiare libreria
+     * tutte le manutenzioni siano concentrate qui
+     *
+     * @param {any[]} items Oggetti da deserializzare
+     * @param {any} type Tipo da usare come prototipo per la deserializzazione
+     *
+     * @returns {any} Oggetti deserializzati
+     */
+    deserializeForExport(items, type) {
+        return Deserialize(items, type);
     }
 }
-ClipboardService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ClipboardService, deps: [{ token: MessageService }, { token: i1.BaseLocalization, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-ClipboardService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ClipboardService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ClipboardService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: MessageService }, { type: i1.BaseLocalization, decorators: [{
-                    type: Optional
-                }] }]; } });
+ExportService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ExportService, deps: [{ token: DateService }], target: i0.ɵɵFactoryTarget.Injectable });
+ExportService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ExportService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ExportService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: function () { return [{ type: DateService }]; } });
 
 // Angular
 /**
-* Service che fornisce dei metodi di estensione per la gestione/manipolazione delle date
-*/
-class DateService {
+ * Service che fornisce funzionalità di alert nei tipi fondamentali: success, info, warning e danger
+ */
+class MessageService {
     /**
      * Costruttore
      *
      * @ignore
      */
-    constructor(locProvider, allowUtc) {
+    constructor(injector, locProvider) {
+        this.injector = injector;
         this.locProvider = locProvider;
-        this.allowUtc = allowUtc;
         /**
-         * Oggetto statico di localizzazione per i messaggi di questa Service
+         * Oggetto statico in supporto alla localizzazione
          */
         this.loc = {
-            "SMALL_DATE_FORMAT": { 'en-US': "MM/DD/YYYY", 'it-IT': "DD/MM/YYYY" },
-            "FULL_DATE_FORMAT": { 'en-US': "MM/DD/YYYY HH:mm:ss", 'it-IT': "DD/MM/YYYY HH:mm:ss" },
-            "FULL_DATE_FORMAT_NO_SS": { 'en-US': "MM/DD/YYYY HH:mm", 'it-IT': "DD/MM/YYYY HH:mm" },
-            "SMALL_DATE_DISPLAY_FORMAT": { 'en-US': "DD/MM/YYYY", 'it-IT': "DD/MM/YYYY" },
-            "SMALL_DATE_DISPLAY_FORMAT_WITH_HOUR": { 'en-US': "DD/MM/YYYY HH", 'it-IT': "DD/MM/YYYY HH" },
-            "SMALL_DATE_DISPLAY_FORMAT_WITH_MINUTE": { 'en-US': "DD/MM/YYYY HH:mm", 'it-IT': "DD/MM/YYYY HH:mm" },
-            "FULL_DATE_DISPLAY_FORMAT": { 'en-US': "DD/MM/YYYY HH:mm:ss", 'it-IT': "DD/MM/YYYY HH:mm:ss" },
-            "FULL_DATE_DISPLAY_FORMAT_NO_SS": { 'en-US': "DD/MM/YYYY HH:mm", 'it-IT': "DD/MM/YYYY HH:mm" }
-        };
-        /**
-         * Oggetto di configurazione per tenere da conto le informazioni sui formati
-         */
-        this.cfg = {
-            fulldate: "",
-            fulldateDisplay: "",
-            smallDate: "",
-            fulldateNoSS: "",
-            smallDateWithH: "",
-            smallDateWithM: "",
-            fulldateDisplayNoSS: ""
+            'Confirm': { 'en-US': "Confirm", 'it-IT': "Conferma", },
+            'Cancel': { 'en-US': "Cancel", 'it-IT': "Annulla", },
+            'Close': { 'en-US': "Close", 'it-IT': "Chiudi", },
+            'Error': { 'en-US': "Error", 'it-IT': "Errore", },
+            'Info': { 'en-US': "Info", 'it-IT': "Informazione", },
+            'Success': { 'en-US': "Success", 'it-IT': "Successo", },
+            'Warning': { 'en-US': "Warning", 'it-IT': "Attenzione", }
         };
         this.init();
     }
+    get toastr() {
+        return this.injector.get(ToastrService);
+    }
     async init() {
         let LOCALE = this.locProvider ? await this.locProvider.Locale.pipe(first()).toPromise() : 'it-IT';
-        this.cfg.smallDate = this.loc["SMALL_DATE_FORMAT"][LOCALE];
-        this.cfg.fulldate = this.loc["FULL_DATE_FORMAT"][LOCALE];
-        this.cfg.fulldateNoSS = this.loc["FULL_DATE_FORMAT_NO_SS"][LOCALE];
-        this.cfg.fulldateDisplay = this.loc["FULL_DATE_DISPLAY_FORMAT"][LOCALE];
-        this.cfg.fulldateDisplayNoSS = this.loc["FULL_DATE_DISPLAY_FORMAT_NO_SS"][LOCALE];
-        this.cfg.smallDate = this.loc["SMALL_DATE_DISPLAY_FORMAT"][LOCALE];
-        this.cfg.smallDateWithH = this.loc["SMALL_DATE_DISPLAY_FORMAT_WITH_HOUR"][LOCALE];
-        this.cfg.smallDateWithM = this.loc["SMALL_DATE_DISPLAY_FORMAT_WITH_MINUTE"][LOCALE];
-    }
-    /**
-     * Aggiusta una data in "istante finale" in base a qual è la parte di data significativa.
-     *
-     * Es. Istante finale delle ore: 05/10/1992 --> 04/10/1992 24:00(:00)
-     *
-     * @param {any} date Data qualsiasi (Date, stringa, dayjs...), verrà ricondotta ad un oggetto dayJs
-     * @param {'day' | 'hour' | 'minute'} timepart Parte significativa della data
-     * @param {boolean} printSeconds Indica se effettuare la stampa dei secondi o no
-     */
-    adjustDateToFinalInstant(date, timepart, printSeconds = true) {
-        let mydt = this.getDateConvertion(date);
-        if (mydt == null)
-            return "FE: Not a Date";
-        let isZeroTime = mydt.startOf(timepart).valueOf() === mydt.valueOf();
-        if (!isZeroTime) {
-            if (timepart == "day" && mydt.subtract(1, "hour").hour() == mydt.hour()) {
-                // Se l'ora precedente è lo stesso orario dell'ora attuale l'istante finale dev'essere mandato avanti di 1
-                mydt = mydt.add(1, "hour");
-            }
-            return printSeconds ? mydt.format(this.cfg.fulldateDisplay) : mydt.format(this.cfg.fulldateDisplayNoSS);
-        }
-        let tmpValue = mydt.subtract(1, timepart);
-        let value = "";
-        // Istante finale delle ore: 05/10/1992 --> 04/10/1992 24:00(:00)
-        if (timepart == 'day')
-            value = tmpValue.format(this.cfg.smallDate) + " 24:00" + (printSeconds ? ':00' : '');
-        // Istante finale dei minuti: giorno 05/10/1992 04:00:00 --> 05/10/1992 03:60(:00)
-        else if (timepart == 'hour')
-            value = tmpValue.format(this.cfg.smallDateWithH) + ":60" + (printSeconds ? ':00' : '');
-        // Istante finale dei secondi: giorno 05/10/1992 04:10:00 --> 05/10/1992 04:09:60
-        else if (timepart == 'minute')
-            value = tmpValue.format(this.cfg.smallDateWithM) + ":60";
-        return value;
-    }
-    /**
-     * Funzione che effettua l'ordinamento fra 2 date in base alla direzione specificata
-     *
-     * @param {any} a Prima data per il confronto
-     * @param {any} b Seconda data per il confronto
-     * @param {'asc' | 'desc'} direction Direzione rispetto a cui ordinare le due date
-     *
-     * @returns {number} 0 se le date sono uguali, 1 se la data A deve venire logicamente prima della data B, -1 altrimenti
-     */
-    dateSort(a, b, direction) {
-        if (a < b)
-            return direction == 'asc' ? 1 : -1;
-        else if (a > b)
-            return direction == 'asc' ? -1 : 1;
-        // con a uguale a b
-        return 0;
-    }
-    /**
-     * Effettua il trim dei secondi da una data espressa come stringa
-     *
-     * @param {string} value Data espressa come stringa
-     *
-     * @returns {string} Data senza i secondi
-     */
-    trimSeconds(value) {
-        //I numeri mangiati da dayjs spesso vengono ricondotti a date vere. Mi assicuro che se ci sono solo numeri proseguo
-        if (!isNaN(value))
-            return value;
-        //Se non ho qualcosa del tipo XX/YY/ZZZZ aa:bb:cc di sicuro non è una data che mi interessa
-        if (!/^\d\d\/\d\d\/\d\d\d\d \d\d:\d\d:\d\d$/g.test(value))
-            return value;
-        //In questo caso mi arrivano valori che devono essere stampati as-is, solo tagliando i secondi
-        return "'" + value.substr(0, value.length - 3);
-    }
-    /**
-     * Data una lista di date Da e una lista di date A restituisce un oggetto rappresentante il range che include tutte le date passate
-     *
-     * @param {any[]} fromDates Lista dei Da
-     * @param {any[]} toDates Lista dei A
-     *
-     * @returns {{ from: any, to: any }} Range di date Da - A che include tutti i valori di **fromDates** e **toDates**
-     */
-    getMinMaxDatesRange(fromDates, toDates) {
-        let datesFroms = [];
-        let datesTo = [];
-        for (let i = 0; i < fromDates.length; i++) {
-            let d = fromDates[i];
-            var convertion = this.getDateConvertion(d);
-            if (convertion)
-                datesFroms.push(convertion);
-        }
-        for (let i = 0; i < toDates.length; i++) {
-            let d = toDates[i];
-            var convertion = this.getDateConvertion(d);
-            if (convertion)
-                datesTo.push(convertion);
-        }
-        return { from: dayjs.min(datesFroms), to: dayjs.max(datesTo) };
+        this.expiredSessionSwal = swal.mixin({
+            showCancelButton: false,
+            confirmButtonText: 'Login',
+            customClass: {
+                confirmButton: "btn btn-primary",
+                container: "app-wrap",
+            },
+            buttonsStyling: false,
+            reverseButtons: false,
+            allowOutsideClick: false,
+            icon: "warning"
+        });
+        this.successSwalWithCancel = swal.mixin({
+            title: this.loc["Success"][LOCALE],
+            customClass: {
+                confirmButton: "btn btn-primary",
+                cancelButton: "btn btn-secondary app-margin-right-10",
+                container: "app-wrap",
+            },
+            buttonsStyling: false,
+            reverseButtons: true,
+            showCancelButton: true,
+            confirmButtonText: this.loc["Confirm"][LOCALE],
+            cancelButtonText: this.loc["Cancel"][LOCALE],
+            icon: "success"
+        });
+        this.warningSwalWithCancel = swal.mixin({
+            title: this.loc["Warning"][LOCALE],
+            customClass: {
+                confirmButton: "btn btn-primary",
+                cancelButton: "btn btn-secondary app-margin-right-10",
+                container: "app-wrap",
+            },
+            buttonsStyling: false,
+            reverseButtons: true,
+            showCancelButton: true,
+            confirmButtonText: this.loc["Confirm"][LOCALE],
+            cancelButtonText: this.loc["Cancel"][LOCALE],
+            icon: "warning"
+        });
+        this.warningSwal = swal.mixin({
+            title: this.loc["Warning"][LOCALE],
+            customClass: {
+                confirmButton: "btn btn-primary",
+                container: "app-wrap",
+            },
+            buttonsStyling: false,
+            reverseButtons: true,
+            showCancelButton: false,
+            confirmButtonText: this.loc["Close"][LOCALE],
+            icon: "warning"
+        });
+        this.successSwal = swal.mixin({
+            title: this.loc["Success"][LOCALE],
+            customClass: {
+                confirmButton: "btn btn-primary",
+                container: "app-wrap",
+            },
+            buttonsStyling: false,
+            reverseButtons: true,
+            showCancelButton: false,
+            confirmButtonText: this.loc["Close"][LOCALE],
+            icon: "success"
+        });
+        this.errorSwal = swal.mixin({
+            title: this.loc["Error"][LOCALE],
+            customClass: {
+                confirmButton: "btn btn-primary",
+                container: "app-wrap",
+            },
+            buttonsStyling: false,
+            reverseButtons: true,
+            showCancelButton: false,
+            confirmButtonText: this.loc["Close"][LOCALE],
+            icon: "error"
+        });
+        this.infoSwal = swal.mixin({
+            title: this.loc["Info"][LOCALE],
+            customClass: {
+                confirmButton: "btn btn-primary",
+                container: "app-wrap",
+            },
+            buttonsStyling: false,
+            reverseButtons: true,
+            showCancelButton: false,
+            confirmButtonText: this.loc["Close"][LOCALE],
+            icon: "info"
+        });
     }
     /**
-     * Ottiene la conversione di una data in qualsiasi formato al formato standard DayJs
+     * Presentazione di un semplice messaggio di successo
      *
-     * @param {any} date Oggetto rappresentante una data. Potrebbe essere una stringa, un Date o già un DayJs
-     * @param {boolean} useUtc Indica se usare l'estensione utc di Dayjs per parsare la data o no
+     * Se viene chiamato con le impostazioni di default e toastr è abilitato, viene mostrato al centro
+     * Se viene chiamato con override su toastr vuol dire che è una notifica secondaria e appare in alto a destra
      *
-     * @returns {any} Data in modalità DayJs
+     * @param {string} text Testo da mostrare
+     * @param {"toastr" | "swal" | null} secondaryNotificationType Qualora sia una notifica secondaria, ne indica il tipo
      */
-    getDateConvertion(date, useUtc = false) {
-        if (!date)
-            return null;
-        if (this.isDayJs(date))
-            return date;
-        if (this.isJsDate(date))
-            return useUtc ? dayjs.utc(date) : dayjs(date);
-        // Se non c'è la proprietà length vuol dire che non è una stringa e a questo punto non ho idea di che minchia sia
-        let length = date.length;
-        if (!length)
-            return null;
-        if (useUtc && !this.allowUtc)
-            throw "@esfaenza/extensions: Richiesta data UTC ma da configurazione la libreria non lo supporta";
-        // Per risparmiare chiamate a tentoni, in base alla lunghezza della stringa chiamo direttamente il metodo giusto, 
-        // controllando poi che mi generi una data come me la aspetto io
-        let tryThis = null;
-        let toCall = useUtc ? dayjs.utc : dayjs;
-        // Se la data contiene la lettera "T" vuol dire che è una data del tipo 2020-10-15T00:00:00, direttamente parsabile dal dayjs col locale corretto.
-        // Per il resto mi baso sulla lunghezza della stringa
-        if (date.includes("T"))
-            tryThis = toCall(date);
-        else if (length == this.cfg.fulldate.length)
-            tryThis = toCall(date, this.cfg.fulldate);
-        else if (length == this.cfg.smallDate.length)
-            tryThis = toCall(date, this.cfg.smallDate);
-        else if (length == this.cfg.fulldateNoSS.length)
-            tryThis = toCall(date, this.cfg.fulldateNoSS);
-        if (tryThis && tryThis.isValid && tryThis.isValid())
-            return tryThis;
-        // Se niente funziona, null. 
-        // Ricondurre l'Input ad una data non è possibile.
-        return null;
+    simpleSuccess(text, secondaryNotificationType = null, secondaryNotificationTimeout = null) {
+        let tos = this.toastrOrSwal(secondaryNotificationType);
+        if (tos == "swal")
+            this.successSwal.fire("", text);
+        else
+            this.toastr.success(text, null, { positionClass: tos == "toastr" ? "toast-top-right" : "toast-top-center", timeOut: secondaryNotificationTimeout || (tos == "toastr" ? 0 : 5000), extendedTimeOut: tos == "toastr" ? 0 : 1000 });
     }
     /**
-     * Helper che restituisce **true** qualora l'oggetto passato fosse una data vera e propria, **false** altrimenti
-     *
-     * @param {any} check Oggetto da controllare
+     * Presentazione di un semplice messaggio di informazione
      *
-     * @returns {boolean} Indicazione se l'oggetto è un vero Date di Javascript o no
-     */
-    isJsDate(check) {
-        return check && Object.prototype.toString.call(check) === "[object Date]" && !isNaN(check);
-    }
-    /**
-     * Helper che restituisce **true** qualora l'oggetto passato fosse un DayJs vero e proprio, **false** altrimenti
+     * Se viene chiamato con le impostazioni di default e toastr è abilitato, viene mostrato al centro
+     * Se viene chiamato con override su toastr vuol dire che è una notifica secondaria e appare in alto a destra
      *
-     * @param {any} check Oggetto da controllare
-     * @returns {boolean} Indicazione se l'oggetto è un vero DayJs o no
+     * @param {string} text Testo da mostrare
+     * @param {"toastr" | "swal" | null} secondaryNotificationType Qualora sia una notifica secondaria, ne indica il tipo
      */
-    isDayJs(check) {
-        // Non uso instanceof perché sarebbe estremamente più lento
-        // Non uso nemmeno isDayjs() della libreria Dayjs dato che ha lo stesso problema: https://github.com/iamkun/dayjs/blob/06f88f425828b1ce96b737332d25145a95a4ee9d/src/index.js#L9
-        return check.$D !== undefined && check.$M !== undefined && check.$y !== undefined;
+    simpleInfo(text, secondaryNotificationType = null, secondaryNotificationTimeout = null) {
+        let tos = this.toastrOrSwal(secondaryNotificationType);
+        if (tos == "swal")
+            this.infoSwal.fire("", text);
+        else
+            this.toastr.info(text, null, { positionClass: tos == "toastr" ? "toast-top-right" : "toast-top-center", timeOut: secondaryNotificationTimeout || (tos == "toastr" ? 0 : 5000), extendedTimeOut: tos == "toastr" ? 0 : 1000 });
     }
     /**
-     * Ottiene la formattazione di una data in base alla versione richiesta "small" o "long" e a se stampare o meno i secondi
+     * Presentazione di un semplice messaggio di errore
      *
-     * @param {any} date Oggetto rappresentante una data. Potrebbe essere una stringa, un Date o già un DayJs
-     * @param {boolean} small Indica se formattarla con un formato breve (se **true**) o un formato più lungo (se **false**)
+     * Se viene chiamato con le impostazioni di default e toastr è abilitato, viene mostrato al centro
+     * Se viene chiamato con override su toastr vuol dire che è una notifica secondaria e appare in alto a destra
      *
-     * @returns {string} Data formattata nel formato richiesto
+     * @param {string} text Testo da mostrare
+     * @param {"toastr" | "swal" | null} secondaryNotificationType Qualora sia una notifica secondaria, ne indica il tipo
      */
-    getFormatted(date, small, seconds) {
-        var date = this.getDateConvertion(date);
-        if (!date)
-            return null;
-        return date.format(small ? this.cfg.smallDate : seconds ? this.cfg.fulldateDisplay : this.cfg.fulldateDisplayNoSS);
-    }
-}
-DateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DateService, deps: [{ token: i1.BaseLocalization, optional: true }, { token: EXT_ALLOW_UTC, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-DateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DateService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: DateService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: i1.BaseLocalization, decorators: [{
-                    type: Optional
-                }] }, { type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [EXT_ALLOW_UTC]
-                }] }]; } });
-
-/**
- * Suffisso della proprietà da generare in cui salvare il navigatore
- * utilizzato dal servizio di esportazione per prendere il valore delle proprietà di un oggetto
- */
-const csvValueNavigator = "_csvnav";
-/**
- * Suffisso della proprietà da generare in cui salvare l'ordine di esportazione
- */
-const csvOrdPrefix = "_csvord";
-/**
- * Suffisso della proprietà da generare in cui salvare la visibilità di questa proprietà
- */
-const csvVisPrefix = "_csvvis";
-/**
- * Suffisso della proprietà da generare in cui salvare il nome della colonna in cui salvare questa proprietà
- */
-const csvHdrPrefix = "_csvhdr";
-/**
- * Suffisso della proprietà da generare in cui salvare il codice del th a cui si riferisce questo campo
- */
-const csvPropKey = "_csvkey";
-/**
- * Suffisso della proprietà da generare in cui salvare il valore da prendere per una proprietà di tipo Lista
- */
-const listCsvValPrefix = "_listcsvval";
-/**
- * Suffisso della proprietà da generare in cui salvare l'Header della proprietà di tipo Lista relativo al valore esportato nella proprietà con suffisso **listCsvValPrefix**
- */
-const listCsvHdrPrefix = "_listcsvhdr";
-/**
- * Suffisso della proprietà da generare in cui salvare il formato della proprietà di tipo Lista relativo al valore esportato nella proprietà con suffisso **listCsvValPrefix**
- */
-const listCsvValFormat = "_listcsvvalformat";
-/**
- * Suffisso della proprietà da generare in cui salvare il valore da prendere per una proprietà di tipo Dizionario
- */
-const dictionaryCsvValPrefix = "_flatlistcsvval";
-/**
- * Suffisso della proprietà da generare in cui salvare l'Header della proprietà di un Dizionario relativo al valore esportato nella proprietà con suffisso **dictionaryCsvValPrefix**
- */
-const dictionaryCsvHdrPrefix = "_flatlistcsvhdr";
-/**
- * Suffisso della proprietà da generare in cui salvare il formato della proprietà che si sta esportando
- */
-const csvFormatPrefix = "_csvfmt";
-/**
-* Nome della proprietà che contiene tutti i nomi di tutte le proprietà da esportare
-*/
-const exportList = "__export_list__";
-
-// Angular
-/**
- * Decoratore di esportazione utilizzabile su una proprietà singola.
- * Verranno generate 3 proprietà che gestiranno l'esportazione: (prop, prop_csvvis, prop_csvhdr).
- *
- * Ad esempio, da questa configurazione:
- *
- * @example
- * ```
- * @Export(true, "MyHeader")
- * ciao: string;
- * ```
- *
- * Nasceranno le seguenti proprietà nell'oggetto esportabile:
- *
- * @example
- * ```
- * ciao_csvvis: string; => true
- * ciao: string;
- * ciao_csvhdr: string => "MyHeader"
- * ```
- *
- * @param {number} order Ordine di esportazione. Più piccolo è, prima appare il valore
- * @param {string} header Titolo della colonna nel file CSV esportato
- * @param {string} format Formato di esportazione. Può essere un formato data per i campi data o 'F' per i campi floating point
- */
-const Export = (order, header, format = null, tableid = null) => (target, propertyKey) => {
-    if (format)
-        Object.defineProperty(target, propertyKey + csvFormatPrefix, { value: format, writable: false });
-    Object.defineProperty(target, propertyKey + csvOrdPrefix, { value: order, writable: false });
-    Object.defineProperty(target, propertyKey + csvVisPrefix, { value: !!header, writable: false });
-    Object.defineProperty(target, propertyKey + csvHdrPrefix, { value: header, writable: false });
-    if (tableid)
-        Object.defineProperty(target, propertyKey + csvPropKey, { value: tableid, writable: false });
-    if (target[exportList])
-        target[exportList].push(propertyKey + csvVisPrefix);
-    else
-        target[exportList] = [propertyKey + csvVisPrefix];
-};
-/**
- * Decoratore di esportazione utilizzabile su un oggetto.
- * Per ogni proprietà dell'oggetto verranno generate 3 proprietà che gestiranno l'esportazione: (prop, prop_csvvis, prop_csvhdr).
- * Per essere esportate, le proprietà dell'oggetto devono essere marcate con i Decoratori di esportazione
- *
- * Ad esempio, da questa configurazione:
- *
- * @example
- * ```
- * MyObj {
- *     @Export(true, "MyHeader")
- *     ciao: string;
- * }
- *
- * @ExportObject(true, "MyHeader")
- * test: MyObj;
- * ```
- *
- * Nasceranno le seguenti proprietà nell'oggetto esportabile:
- *
- * @example
- * ```
- * testciao: string; => Valore di MyObj.ciao
- * testciao_csvvis: string; => true
- * testciao_csvhdr: string => "MyHeader"
- * ```
- *
- * @param {number} order Ordine di esportazione. Più piccolo è, prima appare il valore
- * @param {any} type Tipo da esportare
- */
-const ExportAs = (order, type, prefix) => (target, propertyKey) => {
-    var t = new type();
-    var props = t[exportList];
-    for (let i = 0; i < props.length; i++) {
-        let prop = props[i].replace(csvVisPrefix, '');
-        if (typeof t[prop + csvVisPrefix] !== "undefined") {
-            var toEmit = t[prop + csvVisPrefix];
-            var lbl = t[prop + csvHdrPrefix];
-            var format = t[prop + csvFormatPrefix];
-            var orderProp = t[prop + csvOrdPrefix];
-            if (format)
-                Object.defineProperty(target, propertyKey + prop + csvFormatPrefix, { value: format, writable: false });
-            Object.defineProperty(target, propertyKey + prop + csvOrdPrefix, { value: orderProp + order, writable: false });
-            Object.defineProperty(target, propertyKey + prop, { value: null, writable: true, enumerable: true });
-            Object.defineProperty(target, propertyKey + prop + csvValueNavigator, { value: propertyKey + "." + prop, writable: false });
-            Object.defineProperty(target, propertyKey + prop + csvVisPrefix, { value: toEmit, writable: false });
-            Object.defineProperty(target, propertyKey + prop + csvHdrPrefix, { value: (prefix ? prefix + ' ' : '') + lbl, writable: false });
-            if (target[exportList])
-                target[exportList].push(propertyKey + prop + csvVisPrefix);
-            else
-                target[exportList] = [propertyKey + prop + csvVisPrefix];
-        }
+    simpleError(text, secondaryNotificationType = null, secondaryNotificationTimeout = null) {
+        let tos = this.toastrOrSwal(secondaryNotificationType);
+        if (tos == "swal")
+            this.errorSwal.fire("", text);
+        else
+            this.toastr.error(text, null, { positionClass: tos == "toastr" ? "toast-top-right" : "toast-top-center", timeOut: secondaryNotificationTimeout || (tos == "toastr" ? 0 : 5000), extendedTimeOut: tos == "toastr" ? 0 : 1000 });
     }
-};
-/**
- * Decoratore di esportazione utilizzabile su una lista,
- * si utilizzano 2 navigator rispettivamente per la valorizzazione dell'Header e del Valore e
- * per ogni elemento dell'array verranno generate 3 proprietà che gestiranno l'esportazione: (prop, prop_csvvis, prop_csvhdr)
- *
- * ATTENZIONE: Gli oggetti esportati in questa modalità non devono presentare altri tag di tipo @Export{...} all'interno. Fa tutto questo decoratore
- *
- * I navigator hanno questa convenzione:
- *
- * . --> divide due proprietà da richiamare consecutivamente: "a.b" richiamerà "obj.a.b";
- *
- * | --> divide più proprietà per le concatenazioni con uno spazio fra una e l'altra: "regdesc|slice.slicename" diventerà obj.regdesc + " " + obj.slice.slicename
- *
- * @param {number} order Ordine di esportazione. Più piccolo è, prima appare il valore
- * @param {string} headernavigator Navigator col compito di selezionare il titolo per la colonna
- * @param {string} valuenavigator Navigator col compito di selezionare il valore per la colonna
- * @param {string} valueformat Formato di esportazione per i valori selezionati dal **valuenavigator**. Può essere un formato data per i campi data o 'F' per i campi floating point
- */
-const ExportList = (order, headernavigator, valuenavigator, valueformat = null) => (target, propertyKey) => {
-    Object.defineProperty(target, propertyKey + csvOrdPrefix, { value: order, writable: false });
-    Object.defineProperty(target, propertyKey + listCsvValPrefix, { value: valuenavigator, writable: false });
-    Object.defineProperty(target, propertyKey + listCsvHdrPrefix, { value: headernavigator, writable: false });
-    Object.defineProperty(target, propertyKey + listCsvValFormat, { value: valueformat, writable: false });
-    if (target[exportList])
-        target[exportList].push(propertyKey + listCsvHdrPrefix);
-    else
-        target[exportList] = [propertyKey + listCsvHdrPrefix];
-};
-/**
- * Decoratore di esportazione utilizzabile su un dizionario. Se ad esempio si vogliono generare le colonne
- *
- * Valore A = 1
- *
- * Valore B = 2
- *
- * Valore C = 3
- *
- * partendo da un oggetto iniziale { Valore { A: 1, B: 2, C: 3 } }
- *
- * @param {number} order Ordine di esportazione. Più piccolo è, prima appare il valore
- * @param {string} headernavigator Navigator col compito di selezionare il titolo per la colonna
- * @param {string} valuenavigator Navigator col compito di selezionare il valore per la colonna
- */
-const ExportDictionary = (order, headernavigator, valuenavigator) => (target, propertyKey) => {
-    Object.defineProperty(target, propertyKey + csvOrdPrefix, { value: order, writable: false });
-    Object.defineProperty(target, propertyKey + dictionaryCsvValPrefix, { value: valuenavigator, writable: false });
-    Object.defineProperty(target, propertyKey + dictionaryCsvHdrPrefix, { value: headernavigator, writable: false });
-    if (target[exportList])
-        target[exportList].push(propertyKey + dictionaryCsvHdrPrefix);
-    else
-        target[exportList] = [propertyKey + dictionaryCsvHdrPrefix];
-};
-/**
- * Service che si occupa dell'esportazione degli oggetti marcati dai Decoratori **ExportDictionary**, **ExportList**, **ExportAs** o **Export**
- */
-class ExportService {
     /**
-     * Costruttore
+     * Presentazione di un semplice messaggio di avviso
      *
-     * @ignore
+     * Se viene chiamato con le impostazioni di default e toastr è abilitato, viene mostrato al centro
+     * Se viene chiamato con override su toastr vuol dire che è una notifica secondaria e appare in alto a destra
+     *
+     * @param {string} text Testo da mostrare
+     * @param {"toastr" | "swal" | null} secondaryNotificationType Qualora sia una notifica secondaria, ne indica il tipo
      */
-    constructor(dates) {
-        this.dates = dates;
+    simpleWarning(text, secondaryNotificationType = null, secondaryNotificationTimeout = null) {
+        let tos = this.toastrOrSwal(secondaryNotificationType);
+        if (tos == "swal")
+            this.warningSwal.fire("", text);
+        else
+            this.toastr.warning(text, null, { positionClass: tos == "toastr" ? "toast-top-right" : "toast-top-center", timeOut: secondaryNotificationTimeout || (tos == "toastr" ? 0 : 5000), extendedTimeOut: tos == "toastr" ? 0 : 1000 });
     }
     /**
-     * Data una lista di oggetti genera gli header per l'esportazione e integra ogni oggetto con le proprietà esportabili dalla libreria **@ctrl/ngx-csv**
+     * Ripulisce tutti i messaggi presenti in un dato momento sullo schermo
+     */
+    clearMessages() {
+        this.toastr.clear();
+        swal.close();
+    }
+    /**
+     * Mostra un messaggio di avviso con richiesta di conferma
      *
-     * @param {any[]} objs Oggetti da esportare
+     * @param {string} title Titolo del messaggio
+     * @param {string} text Contenuto del messaggio
      *
-     * @returns {CsvHeaders[]} Header di esportazione già ordinati correttamente
+     * @returns {Promise} Restituisce una Promise col risultato scelto dall'utente (conferma o no)
      */
-    setupForExport(objs, columns = []) {
-        let headers = [];
-        let headersCache = {};
-        if (!objs || objs.length == 0)
-            return headers;
-        // Devo per forza farlo per tutti gli oggetti dato che devo esporre le proprietà che mi servono da esportare
-        // Gli header li raccolgo tutti poi faccio uan distinct in modo da esportare tutte le proprietà per bene
-        let columnSelectionDictionary = {};
-        if (columns?.length > 0)
-            for (let i = 0; i < columns?.length; i++)
-                columnSelectionDictionary[columns[i]] = true;
-        for (let i = 0; i < objs.length; i++) {
-            let hds = this.parseAndGetHeaders(objs[i], columnSelectionDictionary);
-            // Aggiungo gli header facendo in modo di non aggiungerne mai due uguali per non dover fare una distinct dopo
-            // che costerebbe comunque risorse. Utilizzo un dizionario d'appoggio per lookup istantanei
-            for (let k = 0; k < hds.length; k++) {
-                if (!headersCache[hds[k].key]) {
-                    headersCache[hds[k].key] = true;
-                    headers.push(hds[k]);
-                }
-            }
-        }
-        if (!columns || columns.length == 0)
-            return headers.sort((a, b) => a.order - b.order);
-        else {
-            // Se mi arriva la lista di colonne non mi dà solo la visibilità, ma anche l'ordinamento
-            // le esporto di conseguenza
-            let orderedHeaders = [];
-            for (let i = 0; i < columns.length; i++) {
-                let thisId = columns[i];
-                for (let i = 0; i < headers.length; i++) {
-                    if (headers[i].propKey == thisId) {
-                        orderedHeaders.push(headers[i]);
-                        break;
-                    }
-                }
-            }
-            return orderedHeaders;
-        }
+    promiseWarningWithChoice(title, text) {
+        return this.warningSwalWithCancel.fire(title, text);
     }
     /**
-     * Data una lista di oggetti generici genera gli header per l'esportazione e integra ogni oggetto con le proprietà esportabili dalla libreria **@ctrl/ngx-csv**
+     * In base alla configurazione attuale e all'eventuale override per la chiamata del caso indica se bisogna utilizzare toastr o sweetalert
      *
-     * @param {GenericItem[]} objs Oggetti generici da esportare
-     * @param {CsvHeaders[]} columns Colonne richieste dall'esportazione
+     * @param {"toastr" | "swal" | null} providerOverride Override alla modalità configurata
      *
-     * @returns {CsvHeaders[]} Header di esportazione già ordinati correttamente
+     * @returns {"toastr" | "swal"} Indicazione su che provider di messaggi di avviso debba essere utilizzato
      */
-    setupForGenericExport(objs, columns) {
-        let headers = [];
-        if (!objs || objs.length == 0)
-            return headers;
-        // Devo per forza farlo per tutti gli oggetti dato che devo esporre le proprietà che mi servono da esportare
-        objs.forEach((obj, index) => {
-            if (index == 0)
-                headers = this.parseAndGetGenericHeaders(obj, columns);
-            else
-                this.parseAndGetGenericHeaders(obj, columns);
+    toastrOrSwal(providerOverride) {
+        if (providerOverride != null)
+            return providerOverride;
+        return "swal";
+    }
+    /**
+     * Mostra un messaggio di avviso con richiesta di conferma e gestisce il risultato chiamato i callback **onsuccess** o **onerror**
+     *
+     * @param {string} title Titolo del messaggio
+     * @param {string} text Contenuto del messaggio
+     * @param {Function} onsuccess Callback da chimare su conferma
+     * @param {Function} onerror Callback da chimare su errori
+     */
+    simpleWarningWithChoice(title, text, onsuccess = null, onerror = null) {
+        this.warningSwalWithCancel.fire(title, text).then((result) => {
+            if (result.value && onsuccess)
+                onsuccess();
+            else if (onerror)
+                onerror();
         });
-        return headers;
     }
     /**
-     * Dato un oggetto generico genera gli header per l'esportazione e lo integra con le proprietà esportabili dalla libreria **@ctrl/ngx-csv**
+     * Mostra un messaggio di success con richiesta di conferma e gestisce il risultato chiamato i callback **onconfirm** o **onabort**
      *
-     * Metodo interno richiamato da **setupForGenericExport**
+     * @param {string} title Titolo del messaggio
+     * @param {string} text Contenuto del messaggio
+     * @param {Function} onconfirm Callback da chimare su conferma
+     * @param {Function} onabort Callback da chimare su annullamento
+     * @param {string} confirmtext Testo del pulsante di azione
+     * @param {string} aborttext Testo del pulsante di annullamento
+     */
+    simpleSuccessWithChoice(title, text, onconfirm = null, onabort = null, confirmtext = "", aborttext = '') {
+        var configuration = {
+            title: title,
+            html: text
+        };
+        if (confirmtext)
+            configuration["confirmButtonText"] = confirmtext;
+        if (aborttext)
+            configuration["cancelButtonText"] = aborttext;
+        this.successSwalWithCancel.fire(configuration).then((result) => {
+            if (result.value && onconfirm)
+                onconfirm();
+            else if (onabort)
+                onabort();
+        });
+    }
+    /**
+     * Mostra un messaggio di avviso con richiesta di conferma e gestisce il risultato chiamato i callback **onsuccess** o **onerror**
      *
-     * @param {GenericItem} obj Oggetto generico da esportare
-     * @param {CsvColumn[]} columns Colonne richieste dall'esportazione
+     * @param {string} title Titolo del messaggio
+     * @param {string} text Contenuto del messaggio
+     */
+    observableSimpleWarningWithChoice(title, text) {
+        return of(this.warningSwalWithCancel.fire(title, text)).pipe(map(t => !!t.value));
+    }
+    /**
+     * Mostra un messaggio di avviso che la sessione corrente è scaduta e propone all'utente di navigare al login. Qualora l'utente decidesse di farlo
+     * verrà chiamata la funzione di callback **onnavigate
      *
-     * @returns {CsvHeaders[]} Header di esportazione già ordinati correttamente
+     * @param {string} title Titolo del messaggio
+     * @param {string} text Contenuto del messaggio
+     * @param {Function} onnavigate Callback da chimare su navigazione in corso
      */
-    parseAndGetGenericHeaders(obj, columns) {
-        if (!obj.properties)
-            return null;
-        var headers = [];
-        //Miracle incoming
-        columns.forEach(t => {
-            var propValue = obj.properties[t.key];
-            Object.defineProperty(obj, t.key + "_exp", { value: propValue, writable: false, enumerable: true });
-            headers.push({ label: t.label, key: t.key + "_exp", order: t.order, type: t.type, propKey: null });
+    expiredSessionMessage(title, text, onnavigate = null) {
+        this.expiredSessionSwal.fire(title, text).then((result) => {
+            if (result.value && onnavigate)
+                onnavigate();
         });
-        //Tirati fuori tutti gli header faccio sort sull'ordinamento
-        return headers.sort((a, b) => { return a.order - b.order; });
     }
     /**
-     * Dato un oggetto genera gli header per l'esportazione e lo integra con le proprietà esportabili dalla libreria **@ctrl/ngx-csv**
+     * Metodo helper per gestire in maniera standardizzata una risposta di tipo **CallResult**
      *
-     * Metodo interno richiamato da **setupForExport**
+     * @param {CallResult} response Risposta ricevuta dal server
+     * @param {string} successMsg Messaggio da visualizzare in caso di successo
+     * @param {string} errorMsg Messaggio da visualizzare in caso di fallimento
+     * @param {Function} postSuccess Callback da chimare in caso di successo
+     * @param {Function} postFailure Callback da chimare in caso di fallimento
+     */
+    manageCallResultResponse(response, successMsg, errorMsg, postSuccess = null, postFailure = null) {
+        if (response.success) {
+            if (response.haswarning)
+                this.simpleWarning(response.warning);
+            else if (successMsg)
+                this.simpleSuccess(successMsg);
+            if (postSuccess)
+                postSuccess();
+        }
+        else {
+            this.simpleError((errorMsg ? errorMsg + ": " : "") + response.haserror ? response.error : '[NO ERR.]');
+            if (postFailure)
+                postFailure();
+        }
+    }
+    /**
+     * Metodo helper per gestire in maniera standardizzata una risposta di tipo **string**, considerando che:
+     *
+     * Stringa vuota --> Tutto bene
      *
-     * @param {any} obj Oggetto generico da esportare
+     * Stringa piena --> Questo è il messaggio d'errore per cui la chiamata è fallita
      *
-     * @returns {CsvHeaders[]} Header di esportazione già ordinati correttamente
+     * @param {string} response Risposta ricevuta dal server
+     * @param {string} successMsg Messaggio da visualizzare in caso di successo
+     * @param {string} errorMsg Messaggio da visualizzare in caso di fallimento
+     * @param {Function} postSuccess Callback da chimare in caso di successo
+     * @param {Function} postFailure Callback da chimare in caso di fallimento
      */
-    parseAndGetHeaders(obj, columnsSelection) {
-        var headers = [];
-        // Miracle incoming
-        let exportProps = obj[exportList] || [];
-        if (exportProps.length == 0)
-            console.warn("[@esfaenza/extensions] Nessuna colonna configurata da esportare!");
-        for (let i = 0; i < exportProps.length; i++) {
-            let prop = exportProps[i];
-            let propBase = "";
-            let toCall;
-            if (prop.endsWith(listCsvHdrPrefix)) {
-                propBase = prop.replace(listCsvHdrPrefix, '');
-                toCall = this.parseList.bind(this);
-            }
-            else if (prop.endsWith(dictionaryCsvHdrPrefix)) {
-                toCall = this.parseDictionary.bind(this);
-                propBase = prop.replace(dictionaryCsvHdrPrefix, '');
-            }
-            else if (prop.endsWith(csvVisPrefix)) {
-                propBase = prop.replace(csvVisPrefix, '');
-                if (typeof obj[propBase + csvValueNavigator] !== "undefined")
-                    toCall = this.parseObject.bind(this);
-                else
-                    toCall = this.parseProperty.bind(this);
-            }
-            if (toCall)
-                toCall(obj, propBase, headers, columnsSelection);
+    manageStringResponse(response, successMsg, errorMsg, postSuccess = null, postFailure = null) {
+        if (!response) {
+            if (successMsg)
+                this.simpleSuccess(successMsg);
+            if (postSuccess)
+                postSuccess();
+        }
+        else {
+            if (errorMsg)
+                this.simpleError(errorMsg + ": " + response);
+            if (postFailure)
+                postFailure();
         }
-        return headers;
     }
     /**
-     * Setup per l'esportazione di una singola proprietà.
-     * Viene generato l'header e la proprietà relativa al valore formattato o no
+     * Metodo helper per gestire in maniera standardizzata una risposta di tipo **boolean**
      *
-     * @param {any} obj Oggetto di cui esportare la proprietà **prop**
-     * @param {string} prop Proprietà da esportare
-     * @param {CsvHeaders} headers Contenitore degli header, verrà riempito da questa funzione
+     * @param {string} response Risposta ricevuta dal server
+     * @param {string} successMsg Messaggio da visualizzare in caso di successo
+     * @param {string} errorMsg Messaggio da visualizzare in caso di fallimento
+     * @param {Function} postSuccess Callback da chimare in caso di successo
+     * @param {Function} postFailure Callback da chimare in caso di fallimento
      */
-    parseProperty(obj, prop, headers, columnsSelection) {
-        let toEmit = obj[prop + csvVisPrefix];
-        let format = obj[prop + csvFormatPrefix];
-        let propKey = obj[prop + csvPropKey];
-        if (propKey && !columnsSelection[propKey] && Object.keys(columnsSelection).length > 0) {
-            console.log("[@esfaenza/extensions] Colonna da non esportare: " + propKey);
-            return;
+    manageStringResponseBool(response, successMsg, errorMsg, postSuccess = null, postFailure = null) {
+        if (response) {
+            if (successMsg)
+                this.simpleSuccess(successMsg);
+            if (postSuccess)
+                postSuccess();
         }
-        let lbl = obj[prop + csvHdrPrefix];
-        let order = obj[prop + csvOrdPrefix];
-        if (toEmit && lbl !== "undefined") {
-            // Se non ho un formato esporto direttamente
-            if (!format) {
-                // Se è un formato data mi assicuro di non stampare mai una data 00:00:00 altrimenti in esportazione viene uno schifo
-                var val = obj[prop] ? this.dates.trimSeconds(obj[prop].toString()) : "";
-                Object.defineProperty(obj, prop + "_nofmt", { value: val, writable: false, enumerable: true });
-                headers.push({ label: lbl ? lbl : prop + "_nofmt", key: prop + "_nofmt", order: order, type: "string", propKey: propKey });
-            }
-            else {
-                // Caso formato numerico
-                if (format == "F") {
-                    // Check considerando la possibilità di zeri
-                    let val = obj[prop] != null ? obj[prop].toString() : "";
-                    // Elimino tutte le virgole (indicatori di migliaia per la culture default en-US)
-                    val = val.replace(/,/, "");
-                    // Il singolo punto che c'è, se presente (separatore decimali) lo trasformo in virgola
-                    let valConverted = val.replace(".", ",");
-                    Object.defineProperty(obj, prop + "_fmt", { value: valConverted, writable: false, enumerable: true });
-                    headers.push({ label: lbl ? lbl : prop + "_fmt", key: prop + "_fmt", order: order, type: "number", propKey: propKey });
-                }
-                else {
-                    // Se ho un formato data trasformo in dayjs, formatto ed esporto
-                    // Per la trasformazione in dayjs provo prima a passargli la stringa di netto, sperando la riconosca
-                    // Se non funziona provo a definirgli la formattazione standard del metering per quel linguaggio
-                    let val = this.dates.getFormatted(obj[prop], format.length <= 10, format.length > 16);
-                    Object.defineProperty(obj, prop + "_fmt", { value: val ?? "", writable: false, enumerable: true });
-                    headers.push({ label: lbl ? lbl : prop + "_fmt", key: prop + "_fmt", order: order, type: "date", propKey: propKey });
-                }
-            }
+        else {
+            if (errorMsg)
+                this.simpleError(errorMsg);
+            if (postFailure)
+                postFailure();
         }
     }
+}
+MessageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: MessageService, deps: [{ token: Injector }, { token: i1.BaseLocalization, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+MessageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: MessageService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: MessageService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: function () { return [{ type: i0.Injector, decorators: [{
+                    type: Inject,
+                    args: [Injector]
+                }] }, { type: i1.BaseLocalization, decorators: [{
+                    type: Optional
+                }] }]; } });
+
+// Angular
+/**
+ * Service che fornisce un accesso base in lettura/scrittura sulla clipboard
+ */
+class ClipboardService {
     /**
-     * Setup per l'esportazione di una singola proprietà da un oggetto.
-     * Viene generato l'header e la proprietà relativa al valore formattato o no.
+     * Costruttore
      *
-     * Per ottenere il valore e l'header della proprietà vengono utilizzati i navigatori auto-generati nel decoratore **ExportAs**
+     * @ignore
+     */
+    constructor(msgService, locProvider) {
+        this.msgService = msgService;
+        this.locProvider = locProvider;
+        /**
+         * Oggetto statico di localizzazione per i messaggi di questa Service
+         */
+        this.loc = {
+            "Unfortunately Firefox doesn't yet support direct Clipboard access if not via extensions, Please use Chrome to do this operation": {
+                'en-US': "Unfortunately Firefox doesn't yet support direct Clipboard access if not via extensions, Please use Chrome to do this operation",
+                'it-IT': "Mi dispiace ma Firefox non supporta l'accesso diretto alla Clipboard, se non attraverso le estensioni. Si prega di usare Chrome"
+            },
+            "Generic error during 'copy' command execution": {
+                'en-US': "Generic error during 'copy' command execution",
+                'it-IT': "Errore generico durante l'esecuzione del comando 'copy'"
+            },
+            "Error during Clipboard content read operation": {
+                'en-US': "Error during Clipboard content read operation",
+                'it-IT': "Errore nella lettura del contenuto della Clipboard"
+            },
+            "Error during Clipboard content copy operation": {
+                'en-US': "Error during Clipboard content copy operation",
+                'it-IT': "Errore nella scrittura del contenuto nella Clipboard"
+            },
+            "Please insert your clipboard content": {
+                'en-US': "Please insert your clipboard content",
+                'it-IT': "Si prega di incollare il contenuto della Clipboard"
+            },
+            "User input required": {
+                'en-US': "User input required",
+                'it-IT': "Richiesto Input utente"
+            },
+            "Your current browser does not support reading from the clipboard directly. Please paste your clipboard's content in this Input field and confirm the operation": {
+                'en-US': "Your current browser does not support reading from the clipboard directly. Please paste your clipboard's content in this Input field and confirm the operation",
+                'it-IT': "Il browser corrente non supporta la lettura diretta dei dati della Clipboard, si prega di effettuare un'incolla (CTRL + V) nella casella di testo e confermare l'operazione"
+            },
+            "Confirm": {
+                'en-US': "Confirm",
+                'it-IT': "Conferma"
+            },
+            "Cancel": {
+                'en-US': "Cancel",
+                'it-IT': "Annulla"
+            },
+        };
+    }
+    /**
+     * Prende il valore della clipboard.
+     * Si può specificare se ci si aspetta una lista o una matrice di valori in modo da ricevere già un risultato utilizzabile
      *
-     * @param {any} obj Oggetto di cui esportare la proprietà **prop**
-     * @param {string} prop Proprietà da esportare
-     * @param {CsvHeaders} headers Contenitore degli header, verrà riempito da questa funzione
+     * @param {'array' | 'matrix'} style Stile dell'output desiderato, se array o matrice
+     * @param {Function} valueFoundCallback Callback che questa funzione chiamerà una volta ottenuto i valori richiesti dalla clipboard
      */
-    parseObject(obj, prop, headers) {
-        //se questa proprietà ha un navigator significa che deriva da un oggetto interno, recupero il valore in questa fase dato che prima non ce l'ho
-        let valuenavigator = obj[prop + csvValueNavigator];
-        //Es. di valuenavigator obj.subobj.subsubobj.property
-        let jmps = valuenavigator.split(".");
-        //Mi clono l'oggetto originale per non uccidergli i riferimenti
-        let clone = JSON.parse(JSON.stringify(obj));
-        //Salto ricorsivamente su me stesso per arrivare alla proprietà
-        //Salto 1 > diventa obj
-        //Salto 2 > diventa obj.subobj
-        //ecc...
-        jmps.forEach(pp => { clone = clone[pp]; });
-        //Valore finale :D
-        let value = clone;
-        let lbl = obj[prop + csvHdrPrefix];
-        let order = obj[prop + csvOrdPrefix];
-        //Se per questa proprietà ho un formato lo applico
-        let format = obj[prop + csvFormatPrefix];
-        let type = "string";
-        if (format == "F") {
-            let val = value.toString();
-            val = val.replace(/,/, "");
-            value = val.replace(".", ",");
-            type = "number";
+    async getClipboard(style, valueFoundCallback) {
+        let LOCALE = this.locProvider ? await this.locProvider.Locale.pipe(first()).toPromise() : 'it-IT';
+        if (navigator.userAgent.indexOf("Firefox") != -1) {
+            swal.fire({
+                title: this.loc["User input required"][LOCALE],
+                text: this.loc["Your current browser does not support reading from the clipboard directly. Please paste your clipboard's content in this Input field and confirm the operation"][LOCALE],
+                input: 'textarea',
+                icon: "warning",
+                confirmButtonText: this.loc["Confirm"][LOCALE],
+                cancelButtonText: this.loc["Cancel"][LOCALE],
+                showCancelButton: true,
+                customClass: {
+                    confirmButton: "btn btn-primary",
+                    cancelButton: "btn btn-secondary app-margin-right-15",
+                    container: "app-wrap",
+                },
+                reverseButtons: true,
+                allowOutsideClick: false,
+                inputValidator: (value) => {
+                    if (!value)
+                        return this.loc["Please insert your clipboard content"][LOCALE];
+                }
+            }).then(t => {
+                if (t.isConfirmed) {
+                    console.log("[@esfaenza/extensions] Retrieving input data from user input");
+                    this.doClipboardDataGet(t.value, style, valueFoundCallback);
+                }
+            });
+            return;
         }
-        else if (format) {
-            value = this.dates.getFormatted(value, format.length <= 10, format.length > 16);
-            type = "date";
+        if (window.clipboardData) {
+            console.log("[@esfaenza/extensions] Found clipboardData");
+            let data = window.clipboardData.getData("Text");
+            this.doClipboardDataGet(data, style, valueFoundCallback);
+        }
+        else if (window.navigator.clipboard) {
+            console.log("[@esfaenza/extensions] Found navigator clipboard");
+            window.navigator.permissions.query({ name: 'clipboard-read' }).then(result => {
+                if (!(result.state === 'granted' || result.state === 'prompt')) {
+                    console.error("[@esfaenza/extensions] Clipboard permission not granted");
+                    if (valueFoundCallback)
+                        valueFoundCallback([]);
+                    return;
+                }
+                console.log("[@esfaenza/extensions] Clipboard permission granted, retrieving values");
+                window.navigator.clipboard.readText()
+                    .then((t) => this.doClipboardDataGet(t, style, valueFoundCallback))
+                    .catch((err) => this.msgService.simpleError(this.loc["Error during Clipboard content read operation"][LOCALE] + ": " + err));
+            });
         }
-        Object.defineProperty(obj, prop, { value: value ?? "", writable: false, enumerable: true });
-        headers.push({ label: lbl ? lbl : prop, key: prop, order: order, type: type, propKey: null });
+    }
+    /** @ignore */
+    doClipboardDataGet(clipboardText, style, valueFoundCallback) {
+        console.log("[@esfaenza/extensions] Retrieved clipboard values: " + clipboardText);
+        let value = style == "array" ? this.getClipboardLines(clipboardText) :
+            style == "matrix" ? this.getClipboardMatrix(clipboardText) : [];
+        console.log(`[@esfaenza/extensions] Adapted for ${style}: ${JSON.stringify(value)}`);
+        if (valueFoundCallback)
+            valueFoundCallback(value);
     }
     /**
-     * Setup per l'esportazione di una lista di valori pivottati dinamicamente:
-     *
-     * => Recupero il valore utilizzando i navigatori
-     *
-     * => Recupero l'header utilizzando i navigatori
-     *
-     * => Con il valore ci creo la property
+     * Ottiene il contenuto della clipboard diviso per righe (separate da newline)
      *
-     * => Con l'header e il riferimento alla property appena creata creo un record negli header da esportare
+     * @param {string} data contenuto letto dalla clipboard
      *
-     * @param {any} obj Oggetto di cui esportare la proprietà **prop**
-     * @param {string} prop Proprietà da esportare
-     * @param {CsvHeaders} headers Contenitore degli header, verrà riempito da questa funzione
+     * @returns {string[]} Array contenente il testo preso dalla clipboard diviso per riga
      */
-    parseList(obj, prop, headers) {
-        let headernavigator = obj[prop + listCsvHdrPrefix];
-        let valuenavigator = obj[prop + listCsvValPrefix];
-        let valueformat = obj[prop + listCsvValFormat];
-        let order = obj[prop + csvOrdPrefix];
-        var jumps, tmpRes;
-        var objs = obj[prop];
-        for (let idx = 0; idx < objs.length; idx++) {
-            let listitem = objs[idx];
-            var headersplit = headernavigator.split(" ");
-            var header = "";
-            // Per l'header si considera a se stante ogni pezzo separato da spazio per fare le concatenazioni
-            headersplit.forEach(pr => {
-                jumps = pr.split(".");
-                tmpRes = JSON.parse(JSON.stringify(listitem));
-                jumps.forEach(pp => { tmpRes = tmpRes[pp]; });
-                if (!header)
-                    header = tmpRes;
-                else
-                    header += " " + tmpRes;
-            });
-            jumps = valuenavigator.split(".");
-            tmpRes = JSON.parse(JSON.stringify(listitem));
-            jumps.forEach(pp => { tmpRes = tmpRes[pp]; });
-            let value = tmpRes;
-            let type = "string";
-            if (valueformat == "F") {
-                let val = value != null ? value.toString() : "";
-                val = val.replace(/,/, "");
-                value = val.replace(".", ",");
-                type = "number";
-            }
-            else if (valueformat) {
-                value = this.dates.getFormatted(obj[prop], valueformat.length <= 10, valueformat.length > 16);
-                type = "date";
-            }
-            Object.defineProperty(obj, prop + idx, { value: value ?? "", writable: false });
-            headers.push({ label: header, key: prop + idx, order: order + idx, type: type, propKey: null });
-        }
+    getClipboardLines(data) {
+        let trimmedData = data.trim();
+        if (!trimmedData.includes("\r\n") && trimmedData.includes("\n"))
+            return trimmedData.split("\n");
+        return trimmedData.split("\r\n");
     }
     /**
-     * Setup per l'esportazione di una lista di valori pivottati dinamicamente:
-     *
-     * => Recupero il valore utilizzando i navigatori
-     *
-     * => Recupero l'header utilizzando i navigatori
-     *
-     * => Con il valore ci creo la property
+     * Ottiene il contenuto della clipboard diviso per righe (separate da newline) e colonne (separate da tab)
      *
-     * => Con l'header e il riferimento alla property appena creata creo un record negli header da esportare
+     * @param {string} data contenuto letto dalla clipboard
      *
-     * @param {any} obj Oggetto di cui esportare la proprietà **prop**
-     * @param {string} prop Proprietà da esportare
-     * @param {CsvHeaders} headers Contenitore degli header, verrà riempito da questa funzione
+     * @returns {string[][]} Matrice contenente il testo preso dalla clipboard diviso per riga e colonna
      */
-    parseDictionary(obj, prop, headers) {
-        let headernavigator = obj[prop + dictionaryCsvHdrPrefix];
-        let valuenavigator = obj[prop + dictionaryCsvValPrefix];
-        let order = obj[prop + csvOrdPrefix];
-        var jumps, tmpRes;
-        var objs = obj[prop];
-        for (let idx = 0; idx < objs.length; idx++) {
-            let listitem = objs[idx];
-            var headersplit = headernavigator.split(" ");
-            var header = "";
-            headersplit.forEach(pr => {
-                jumps = pr.split(".");
-                tmpRes = JSON.parse(JSON.stringify(listitem));
-                jumps.forEach(pp => { tmpRes = tmpRes[pp]; });
-                if (!header)
-                    header = tmpRes;
-                else
-                    header += " " + tmpRes;
-            });
-            var valuesplit = valuenavigator.split(",");
-            valuesplit.forEach((t, idxinternal) => {
-                var navig = t.split("-")[1];
-                var desc = t.split("-")[0];
-                jumps = navig.split(".");
-                tmpRes = JSON.parse(JSON.stringify(listitem));
-                jumps.forEach(pp => { tmpRes = tmpRes[pp]; });
-                let value = tmpRes;
-                let propname = prop + idx.toString() + idxinternal.toString();
-                Object.defineProperty(obj, propname, { value: value ?? "", writable: false });
-                headers.push({ label: header + " " + desc, key: propname, order: order + idx, type: 'string', propKey: null });
-            });
-        }
+    getClipboardMatrix(data) {
+        var ret = [];
+        var rows = !data.includes("\r\n") && data.includes("\n") ? data.split("\n") : data.split("\r\n");
+        // A quanto pare ogni valore è separato da un \t... spero che sia uno standard di quando si copia da excel altrimenti ciao
+        for (let i = 0; i < rows.length; i++)
+            ret.push(rows[i].split('\t').map(t => t.trim()));
+        return ret;
     }
     /**
-     * Metodo che si occupa della deserializzazione degli oggetti da esportare. Messo a livello di libreria in modo che qualora ci fosse da cambiare libreria
-     * tutte le manutenzioni siano concentrate qui
-     *
-     * @param {any[]} items Oggetti da deserializzare
-     * @param {any} type Tipo da usare come prototipo per la deserializzazione
+     * Metodo che copia un testo all'interno della clipboard
      *
-     * @returns {any} Oggetti deserializzati
+     * @param {string} text Testo da inserire nella clipboard
      */
-    deserializeForExport(items, type) {
-        return Deserialize(items, type);
+    async copyTextToClipboard(text) {
+        let LOCALE = this.locProvider ? await this.locProvider.Locale.pipe(first()).toPromise() : 'it-IT';
+        var textArea = document.createElement("textarea");
+        //
+        // *** This styling is an extra step which is likely not required. ***
+        //
+        // Why is it here? To ensure:
+        // 1. the element is able to have focus and selection.
+        // 2. if element was to flash render it has minimal visual impact.
+        // 3. less flakyness with selection and copying which **might** occur if
+        //    the textarea element is not visible.
+        //
+        // The likelihood is the element won't even render, not even a flash,
+        // so some of these are just precautions. However in IE the element
+        // is visible whilst the popup box asking the user for permission for
+        // the web page to copy to the clipboard.
+        //
+        // Place in top-left corner of screen regardless of scroll position.
+        textArea.style.position = "fixed";
+        textArea.style.top = "0";
+        textArea.style.left = "0";
+        // Ensure it has a small width and height. Setting to 1px / 1em
+        // doesn't work as this gives a negative w/h on some browsers.
+        textArea.style.width = "2em";
+        textArea.style.height = "2em";
+        // We don't need padding, reducing the size if it does flash render.
+        textArea.style.padding = "0";
+        // Clean up any borders.
+        textArea.style.border = "none";
+        textArea.style.outline = "none";
+        textArea.style.boxShadow = "none";
+        // Avoid flash of white box if rendered for any reason.
+        textArea.style.background = "transparent";
+        textArea.value = text;
+        document.body.appendChild(textArea);
+        textArea.focus();
+        textArea.select();
+        try {
+            var successful = document.execCommand("copy");
+            if (!successful)
+                this.msgService.simpleError(this.loc["Generic error during 'copy' command execution"][LOCALE]);
+        }
+        catch (err) {
+            this.msgService.simpleError(this.loc["Error during Clipboard content copy operation"][LOCALE] + ": " + err);
+        }
+        document.body.removeChild(textArea);
     }
 }
-ExportService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ExportService, deps: [{ token: DateService }], target: i0.ɵɵFactoryTarget.Injectable });
-ExportService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ExportService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ExportService, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: DateService }]; } });
+ClipboardService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ClipboardService, deps: [{ token: MessageService }, { token: i1.BaseLocalization, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+ClipboardService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ClipboardService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ClipboardService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: function () { return [{ type: MessageService }, { type: i1.BaseLocalization, decorators: [{
+                    type: Optional
+                }] }]; } });
 
 // Angular
 /**
@@ -1705,9 +1742,10 @@ class HashingService {
     }
 }
 HashingService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HashingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-HashingService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HashingService });
+HashingService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HashingService, providedIn: "root" });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: HashingService, decorators: [{
-            type: Injectable
+            type: Injectable,
+            args: [{ providedIn: "root" }]
         }] });
 
 /**
@@ -1956,11 +1994,37 @@ class UtilityService {
     }
 }
 UtilityService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: UtilityService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-UtilityService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: UtilityService });
+UtilityService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: UtilityService, providedIn: "root" });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: UtilityService, decorators: [{
-            type: Injectable
+            type: Injectable,
+            args: [{ providedIn: "root" }]
         }] });
 
+/**
+ * Classe che rappresenta una risposta ricevuta da un Backend
+ */
+class CallResult {
+}
+
+/**
+ * Header per il file CSV che sta venendo generato
+ */
+class CsvHeaders {
+}
+
+/**
+ * Rappresentazione di un oggetto generico
+ */
+class GenericItem {
+}
+
+/** Enumeratore dei tipi di messaggio che i moduli esterni possono contattare sull'applicazione principale */
+var InboundMessageTypes;
+(function (InboundMessageTypes) {
+    /** Evento di navigazione */
+    InboundMessageTypes[InboundMessageTypes["Navigation"] = 0] = "Navigation";
+})(InboundMessageTypes || (InboundMessageTypes = {}));
+
 /** Classe che rappresenta un generico messaggio scambiato fra applicazione e moduli */
 class InterComMessage {
     /**
@@ -2017,77 +2081,12 @@ class InterComService {
     }
 }
 InterComService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: InterComService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-InterComService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: InterComService });
+InterComService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: InterComService, providedIn: "root" });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: InterComService, decorators: [{
-            type: Injectable
-        }] });
-
-// Angular
-/**
- * Modulo di estensione che registra autonomamente **TUTTI** i servizi di estensione:
- * ClipboardService,
- * DateService,
- * ExportService,
- * HashingService,
- * MessageService,
- * UtilityService
- * InterComService
- *
- * con eventuali provider che utilizzano
- */
-class FullExtensionsModule {
-    static forRoot(config) {
-        return {
-            ngModule: FullExtensionsModule,
-            providers: [
-                ClipboardService,
-                DateService,
-                ExportService,
-                HashingService,
-                MessageService,
-                UtilityService,
-                InterComService,
-                { provide: APPSEARCH_PREFIX, useValue: config?.appsearch_prefix || 'Hot' },
-                { provide: EXT_ALLOW_UTC, useValue: config?.allow_utc == null ? false : config?.allow_utc }
-            ]
-        };
-    }
-}
-FullExtensionsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FullExtensionsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-FullExtensionsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: FullExtensionsModule });
-FullExtensionsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FullExtensionsModule, providers: [BaseLocalization] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FullExtensionsModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    providers: [BaseLocalization]
-                }]
+            type: Injectable,
+            args: [{ providedIn: "root" }]
         }] });
 
-/**
- * Classe che rappresenta una risposta ricevuta da un Backend
- */
-class CallResult {
-}
-
-/**
- * Header per il file CSV che sta venendo generato
- */
-class CsvHeaders {
-}
-
-/**
- * Rappresentazione di un oggetto generico
- */
-class GenericItem {
-}
-
-/** Enumeratore dei tipi di messaggio che i moduli esterni possono contattare sull'applicazione principale */
-var InboundMessageTypes;
-(function (InboundMessageTypes) {
-    /** Evento di navigazione */
-    InboundMessageTypes[InboundMessageTypes["Navigation"] = 0] = "Navigation";
-})(InboundMessageTypes || (InboundMessageTypes = {}));
-
 /*
  * Public API Surface of extensions
  */
@@ -2096,5 +2095,5 @@ var InboundMessageTypes;
  * Generated bundle index. Do not edit.
  */
 
-export { APPSEARCH_PREFIX, CallResult, ClipboardService, CsvHeaders, DateService, EXT_ALLOW_UTC, Export, ExportAs, ExportDictionary, ExportList, ExportService, ExtensionsModule, FullExtensionsModule, GenericItem, HashingService, InboundMessageTypes, InterComMessage, InterComService, MessageService, UtilityService };
+export { APPSEARCH_PREFIX, CallResult, ClipboardService, CsvHeaders, DateService, EXT_ALLOW_UTC, Export, ExportAs, ExportDictionary, ExportList, ExportService, ExtensionsModule, GenericItem, HashingService, InboundMessageTypes, InterComMessage, InterComService, LocDatePipe, MessageService, UtilityService };
 //# sourceMappingURL=esfaenza-extensions.mjs.map