@esfaenza/extensions 15.2.48 → 15.2.51

package/esm2020/lib/services/extensions.exports.service.mjs

@@ -0,0 +1,615 @@
+// Angular
+import { Injectable } from "@angular/core";
+// Configurazioni
+import { exportList, csvFormatPrefix, csvHdrPrefix, csvOrdPrefix, csvValueNavigator, csvVisPrefix, dictionaryCsvHdrPrefix, dictionaryCsvValPrefix, listCsvHdrPrefix, listCsvValFormat, listCsvValPrefix, csvPropKey, locProperty, csvValueType } from "../models/ExportConsts";
+import * as i0 from "@angular/core";
+import * as i1 from "./extensions.dates.service";
+import * as i2 from "./extensions.utilities.service";
+import * as i3 from "@esfaenza/localizations";
+/**
+ * Decoratore che fornisce la classe di localizzazione per tutte le proprietà esportate con @Export e qualsiasi altro tag che richieda localizzazioni.
+ *
+ * Sostanzilamente aggiunge la proprietà **__loc__** all'oggetto creato dalla classe corrente assegnandogli come valore il tipo del LocalizationService da usare per la traduzione
+ *
+ * @param {Type<LocalizationService>} loc Tipo ereditato dal LocalizationService che può essere creato a runtime sotto contesto della DI di Angular
+ */
+export function ExportLocalization(loc) {
+    return function integrateLoc(constructor) {
+        return class extends constructor {
+            constructor() {
+                super(...arguments);
+                this.__loc__ = loc;
+            }
+        };
+    };
+}
+/**
+ * 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
+ */
+export 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
+ */
+export const ExportAs = (order, type, prefix) => (target, propertyKey) => {
+    var addedHere = {};
+    var t = new type();
+    var props = t[exportList];
+    for (let i = 0; i < props.length; i++) {
+        let prop = props[i].replace(csvVisPrefix, '');
+        if (addedHere[prop])
+            continue;
+        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];
+            var ppp = propertyKey + "$_$" + prop;
+            if (format)
+                Object.defineProperty(target, ppp + csvFormatPrefix, { value: format, writable: false });
+            Object.defineProperty(target, ppp + csvOrdPrefix, { value: orderProp + order, writable: false });
+            Object.defineProperty(target, ppp, { value: null, writable: true, enumerable: true });
+            Object.defineProperty(target, ppp + csvValueNavigator, { value: propertyKey + "." + prop.replace(/\$_\$/g, '.'), writable: false });
+            Object.defineProperty(target, ppp + csvVisPrefix, { value: toEmit, writable: false });
+            Object.defineProperty(target, ppp + csvHdrPrefix, { value: (prefix ? prefix + ' ' : '') + lbl, writable: false });
+            Object.defineProperty(target, ppp + csvValueType, { value: type, writable: false });
+            if (target[exportList])
+                target[exportList].push(ppp + csvVisPrefix);
+            else
+                target[exportList] = [ppp + csvVisPrefix];
+            addedHere[ppp] = true;
+        }
+    }
+};
+/**
+ * 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
+ */
+export 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} headerprefix Prefisso per l'header
+ * @param {string} valueprefix Prefisso per il valore
+ */
+export const ExportDictionary = (order, headerprefix, valueprefix) => (target, propertyKey) => {
+    Object.defineProperty(target, propertyKey + csvOrdPrefix, { value: order, writable: false });
+    Object.defineProperty(target, propertyKey + dictionaryCsvValPrefix, { value: valueprefix, writable: false });
+    Object.defineProperty(target, propertyKey + dictionaryCsvHdrPrefix, { value: headerprefix, 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**
+ */
+export class ExportService {
+    /**
+     * Costruttore
+     *
+     * @ignore
+     */
+    constructor(dates, utiExts, lc) {
+        this.dates = dates;
+        this.utiExts = utiExts;
+        this.lc = lc;
+    }
+    /**
+     * 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 {any[]} objs Oggetti da esportare
+     *
+     * @returns {CsvHeaders[]} Header di esportazione già ordinati correttamente
+     */
+    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;
+        }
+    }
+    /**
+     * 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] || [];
+        let loc = obj[locProperty] ? this.lc.generateFromType(obj[locProperty]) : null;
+        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)) {
+                propBase = prop.replace(dictionaryCsvHdrPrefix, '');
+                toCall = this.parseDictionary.bind(this);
+            }
+            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, loc);
+        }
+        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
+     * @param {LocalizationService} loc Servizio di localizzazione che traduce tutti i nomi che può
+     */
+    parseProperty(obj, prop, headers, columnsSelection, loc) {
+        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;
+        }
+        let text = obj[prop + csvHdrPrefix];
+        let label = loc && text ? loc.loc(text) : text || "";
+        let order = obj[prop + csvOrdPrefix];
+        if (!toEmit)
+            return;
+        // 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
+            let val = obj[prop] ? this.dates.trimSeconds(obj[prop].toString()) : "";
+            let key = prop + "_nofmt";
+            Object.defineProperty(obj, key, { value: val, writable: false, enumerable: true });
+            headers.push({ label, key, order, type: "string", propKey });
+        }
+        else {
+            let key = prop + "_fmt";
+            // 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, key, { value: valConverted, writable: false, enumerable: true });
+                headers.push({ label, key, order, type: "number", 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, key, { value: val ?? "", writable: false, enumerable: true });
+                headers.push({ label, key, order, type: "date", propKey });
+            }
+        }
+    }
+    /**
+     * Setup per l'esportazione di una singola proprietà da un oggetto.
+     * Viene generato l'header e la proprietà relativa al valore formattato o no.
+     *
+     * Per ottenere il valore e l'header della proprietà vengono utilizzati i navigatori auto-generati nel decoratore **ExportAs**
+     *
+     * @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 {LocalizationService} loc Servizio di localizzazione che traduce tutti i nomi che può
+     */
+    parseObject(obj, prop, headers, columnsSelection, loc) {
+        //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(".");
+        // Localizzazione presa dalla classe base se c'è, altrimenti dalla classe interna (cioè dal primo saltino)
+        if (!loc) {
+            let type = obj[prop + csvValueType];
+            let proto = new type();
+            loc = proto[locProperty] ? this.lc.generateFromType(proto[locProperty]) : null;
+        }
+        //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 text = obj[prop + csvHdrPrefix];
+        let label = loc && text ? loc.loc(text) : text || "";
+        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, key: prop, order, type, propKey: null });
+    }
+    /**
+     * 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
+     *
+     * => 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
+     * @param {LocalizationService} loc Servizio di localizzazione che traduce tutti i nomi che può
+     */
+    parseList(obj, prop, headers, columnsSelection, loc) {
+        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 label = "";
+            // 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]; });
+                let localized = !!loc ? loc.loc(tmpRes) : tmpRes;
+                if (!label)
+                    label = localized;
+                else
+                    label += " " + localized;
+            });
+            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, key: prop + idx, order: order + idx, type, propKey: null });
+        }
+    }
+    /**
+     * 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
+     *
+     * => 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
+     */
+    parseDictionary(obj, prop, headers, columnsSelection) {
+        let headerprefix = obj[prop + dictionaryCsvHdrPrefix];
+        let valueprefix = obj[prop + dictionaryCsvValPrefix];
+        let order = obj[prop + csvOrdPrefix];
+        var object = obj[prop];
+        let idx = 0;
+        for (const [key, val] of Object.entries(object)) {
+            // Ignoro tutti i cmapi che non fanno parte della selezione delle colonne
+            if (key && !columnsSelection[key] && Object.keys(columnsSelection).length > 0) {
+                console.log("[@esfaenza/extensions] Colonna da non esportare: " + key);
+                return;
+            }
+            let propname = prop + "_" + key;
+            let value = valueprefix ? valueprefix + " " + val : val;
+            let label = headerprefix ? headerprefix + " " + key : key;
+            Object.defineProperty(obj, propname, { value: value ?? "", writable: false });
+            headers.push({ label: label, key: propname, order: order + idx++, type: 'string', propKey: null });
+        }
+    }
+    /**
+     * Effettua l'esportazione in file CSV
+     */
+    exportCSV(fn, headers, data) {
+        let csvData = '', row = '', sep = ';';
+        for (let i = 0; i < headers.length; i++) {
+            let h = headers[i];
+            row += `${row != '' ? sep : ''}"${h.label}"`;
+        }
+        csvData += row + '\r\n';
+        for (let i = 0; i < data.length; i++) {
+            row = '';
+            let item = data[i];
+            for (let j = 0; j < headers.length; j++) {
+                let val = item[headers[j].key];
+                row += `${row != '' ? sep : ''}"${val}"`;
+            }
+            csvData += row + '\r\n';
+        }
+        var BOM = new Uint8Array([0xEF, 0xBB, 0xBF]);
+        var blob = new Blob([BOM, csvData], { type: 'text/csv' });
+        var objectUrl = URL.createObjectURL(blob);
+        this.utiExts.fileDownload(objectUrl, fn.endsWith('.xlsx') ? fn.replace('.xlsx', '.csv') : fn.endsWith('.csv') ? fn : fn + ".csv");
+    }
+    /** Effettua l'esportazione del file Excel basandosi sul modulo **ExcelJS**, sugli header **headers** e sui dati **data** */
+    async exportExcel(fn, headers, data) {
+        try {
+            this.ExcelJS = this.ExcelJS || await import("exceljs");
+        }
+        catch {
+            throw "Impossibile caricare la libreria per l'esportazione in Excel";
+        }
+        let iFix = 1;
+        let workbook = new this.ExcelJS.Workbook();
+        workbook.creator = "Ema's big Es-Table";
+        workbook.created = new Date();
+        let sheet = workbook.addWorksheet('Data');
+        let header = sheet.getRow(1);
+        header.font = { bold: true };
+        headers = headers.sort((a, b) => a.order - b.order);
+        for (let i = 0; i < headers.length; i++) {
+            let h = headers[i];
+            header.getCell(i + iFix).value = h.label;
+        }
+        for (let i = 0; i < data.length; i++) {
+            let row = sheet.getRow(i + iFix + 1);
+            let item = data[i];
+            for (let i = 0; i < headers.length; i++) {
+                let h = headers[i];
+                let cell = row.getCell(i + 1);
+                let val = item[h.key];
+                if (!val) {
+                    cell.value = "";
+                    continue;
+                }
+                switch (h.type) {
+                    case 'date':
+                        // ExcelJS va di default in UTC quindi rischierebbe di tirare giù 2 ore ad ogni esportazione
+                        // Bisogna aggiungere l'utc offset alla data attuale
+                        let date = this.dates.getDateConvertion(val);
+                        if (date) {
+                            let correctedDate = date.add(date.utcOffset(), 'minute');
+                            cell.value = correctedDate.toDate();
+                            cell.numFmt = val.length > 10 ? 'dd/mm/yyyy h:m:s' : '';
+                        }
+                        break;
+                    case 'number':
+                        let converted = parseFloat(val.replace(',', '.'));
+                        cell.value = isNaN(converted) ? "" : converted;
+                        break;
+                    default:
+                        cell.value = val;
+                        break;
+                }
+            }
+        }
+        let buffer = await workbook.xlsx.writeBuffer();
+        let blob = new Blob([buffer], { type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;" });
+        let objectUrl = URL.createObjectURL(blob);
+        this.utiExts.fileDownload(objectUrl, fn.endsWith('.csv') ? fn.replace('.csv', '.xlsx') : fn.endsWith('.xlsx') ? fn : fn + ".xlsx");
+    }
+    /**
+     * Metodo che effettivamente genera gli header e i dati per l'esportazione con **ngx-csv**
+     *
+     * @param {any[]} items Oggetti da esportare
+     */
+    export(items, format, fileName, type, columnsFilter, genericHeaders) {
+        // Deepclone con assegnatura del tipo
+        var createdItems = items.map(t => this.utiExts.deepClone(t, type));
+        let headers = genericHeaders ? this.setupForGenericExport(createdItems, genericHeaders) : this.setupForExport(createdItems, columnsFilter);
+        (format == "CSV" ? this.exportCSV : this.exportExcel).bind(this)(fileName, headers, createdItems);
+        return headers;
+    }
+}
+ExportService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ExportService, deps: [{ token: i1.DateService }, { token: i2.UtilityService }, { token: i3.LocalizationService }], 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: i1.DateService }, { type: i2.UtilityService }, { type: i3.LocalizationService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"extensions.exports.service.js","sourceRoot":"","sources":["../../../../../projects/extensions/src/lib/services/extensions.exports.service.ts"],"names":[],"mappings":"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","sourcesContent":["// Angular\r\nimport { Injectable, Type } from \"@angular/core\";\r\n\r\n// Esfaenza\r\nimport { LocalizationService } from \"@esfaenza/localizations\";\r\n\r\n// Configurazioni\r\n\r\nimport { exportList, csvFormatPrefix, csvHdrPrefix, csvOrdPrefix, csvValueNavigator, csvVisPrefix, dictionaryCsvHdrPrefix, dictionaryCsvValPrefix, listCsvHdrPrefix, listCsvValFormat, listCsvValPrefix, csvPropKey, locProperty, csvValueType } from \"../models/ExportConsts\";\r\nimport { DateService } from './extensions.dates.service';\r\nimport { UtilityService } from \"./extensions.utilities.service\";\r\n\r\n// Modelli\r\nimport { CsvHeaders } from \"../models/CsvHeaders\";\r\nimport { GenericItem } from \"../models/GenericItem\";\r\n\r\n/**\r\n * Decoratore che fornisce la classe di localizzazione per tutte le proprietà esportate con @Export e qualsiasi altro tag che richieda localizzazioni.\r\n * \r\n * Sostanzilamente aggiunge la proprietà **__loc__** all'oggetto creato dalla classe corrente assegnandogli come valore il tipo del LocalizationService da usare per la traduzione\r\n * \r\n * @param {Type<LocalizationService>} loc Tipo ereditato dal LocalizationService che può essere creato a runtime sotto contesto della DI di Angular\r\n */\r\nexport function ExportLocalization(loc: Type<LocalizationService>) {\r\n  return function integrateLoc<T extends { new(...args: any[]): {} }>(constructor: T) {\r\n    return class extends constructor { __loc__ = loc; };\r\n  }\r\n}\r\n\r\n/**\r\n * Decoratore di esportazione utilizzabile su una proprietà singola. \r\n * Verranno generate 3 proprietà che gestiranno l'esportazione: (prop, prop_csvvis, prop_csvhdr). \r\n * \r\n * Ad esempio, da questa configurazione:\r\n * \r\n * @example\r\n * ```\r\n * @Export(true, \"MyHeader\")\r\n * ciao: string;\r\n * ```\r\n * \r\n * Nasceranno le seguenti proprietà nell'oggetto esportabile:\r\n * \r\n * @example\r\n * ```\r\n * ciao_csvvis: string; => true\r\n * ciao: string;\r\n * ciao_csvhdr: string => \"MyHeader\"\r\n * ```\r\n * \r\n * @param {number} order Ordine di esportazione. Più piccolo è, prima appare il valore\r\n * @param {string} header Titolo della colonna nel file CSV esportato\r\n * @param {string} format Formato di esportazione. Può essere un formato data per i campi data o 'F' per i campi floating point\r\n */\r\nexport const Export = (order: number, header: string, format: string = null, tableid: string = null) =>\r\n  (target: Object, propertyKey: string) => {\r\n    if (format)\r\n      Object.defineProperty(target, propertyKey + csvFormatPrefix, { value: format, writable: false });\r\n    Object.defineProperty(target, propertyKey + csvOrdPrefix, { value: order, writable: false });\r\n    Object.defineProperty(target, propertyKey + csvVisPrefix, { value: !!header, writable: false });\r\n    Object.defineProperty(target, propertyKey + csvHdrPrefix, { value: header, writable: false });\r\n    if (tableid)\r\n      Object.defineProperty(target, propertyKey + csvPropKey, { value: tableid, writable: false });\r\n\r\n    if (target[exportList])\r\n      target[exportList].push(propertyKey + csvVisPrefix);\r\n    else\r\n      target[exportList] = [propertyKey + csvVisPrefix]\r\n  };\r\n\r\n/**\r\n * Decoratore di esportazione utilizzabile su un oggetto. \r\n * Per ogni proprietà dell'oggetto verranno generate 3 proprietà che gestiranno l'esportazione: (prop, prop_csvvis, prop_csvhdr). \r\n * Per essere esportate, le proprietà dell'oggetto devono essere marcate con i Decoratori di esportazione\r\n * \r\n * Ad esempio, da questa configurazione:\r\n * \r\n * @example\r\n * ```\r\n * MyObj {\r\n *     @Export(true, \"MyHeader\")\r\n *     ciao: string;\r\n * }\r\n * \r\n * @ExportObject(true, \"MyHeader\")\r\n * test: MyObj; \r\n * ```\r\n * \r\n * Nasceranno le seguenti proprietà nell'oggetto esportabile:\r\n * \r\n * @example\r\n * ```\r\n * testciao: string; => Valore di MyObj.ciao\r\n * testciao_csvvis: string; => true\r\n * testciao_csvhdr: string => \"MyHeader\" \r\n * ```\r\n *\r\n * @param {number} order Ordine di esportazione. Più piccolo è, prima appare il valore\r\n * @param {any} type Tipo da esportare\r\n */\r\nexport const ExportAs = (order: number, type: any, prefix?: string) =>\r\n  (target: Object, propertyKey: string) => {\r\n    var addedHere: {[id: string]: boolean} = {};\r\n\r\n    var t = new type();\r\n    var props = t[exportList];\r\n    for (let i = 0; i < props.length; i++) {\r\n      let prop = props[i].replace(csvVisPrefix, '');\r\n      \r\n      if(addedHere[prop]) continue;\r\n\r\n      if (typeof t[prop + csvVisPrefix] !== \"undefined\") {\r\n        var toEmit: boolean = t[prop + csvVisPrefix];\r\n        var lbl = t[prop + csvHdrPrefix];\r\n        var format = t[prop + csvFormatPrefix];\r\n        var orderProp = t[prop + csvOrdPrefix];\r\n        var ppp = propertyKey + \"$_$\" + prop;\r\n\r\n        if (format)\r\n          Object.defineProperty(target, ppp + csvFormatPrefix, { value: format, writable: false });\r\n        Object.defineProperty(target, ppp + csvOrdPrefix, { value: orderProp + order, writable: false });\r\n        Object.defineProperty(target, ppp, { value: null, writable: true, enumerable: true });\r\n        Object.defineProperty(target, ppp + csvValueNavigator, { value: propertyKey + \".\" + prop.replace(/\\$_\\$/g, '.'), writable: false });\r\n        Object.defineProperty(target, ppp + csvVisPrefix, { value: toEmit, writable: false });\r\n        Object.defineProperty(target, ppp + csvHdrPrefix, { value: (prefix ? prefix + ' ' : '') + lbl, writable: false });\r\n        Object.defineProperty(target, ppp + csvValueType, { value: type, writable: false });\r\n\r\n        if (target[exportList])\r\n          target[exportList].push(ppp + csvVisPrefix);\r\n        else\r\n          target[exportList] = [ppp + csvVisPrefix];\r\n\r\n        addedHere[ppp] = true;\r\n      }\r\n    }\r\n  };\r\n\r\n/**\r\n * Decoratore di esportazione utilizzabile su una lista, \r\n * si utilizzano 2 navigator rispettivamente per la valorizzazione dell'Header e del Valore e \r\n * per ogni elemento dell'array verranno generate 3 proprietà che gestiranno l'esportazione: (prop, prop_csvvis, prop_csvhdr)\r\n * \r\n * ATTENZIONE: Gli oggetti esportati in questa modalità non devono presentare altri tag di tipo @Export{...} all'interno. Fa tutto questo decoratore\r\n * \r\n * I navigator hanno questa convenzione:\r\n * \r\n * . --> divide due proprietà da richiamare consecutivamente: \"a.b\" richiamerà \"obj.a.b\";\r\n * \r\n * | --> divide più proprietà per le concatenazioni con uno spazio fra una e l'altra: \"regdesc|slice.slicename\" diventerà obj.regdesc + \" \" + obj.slice.slicename\r\n * \r\n * @param {number} order Ordine di esportazione. Più piccolo è, prima appare il valore\r\n * @param {string} headernavigator Navigator col compito di selezionare il titolo per la colonna\r\n * @param {string} valuenavigator Navigator col compito di selezionare il valore per la colonna\r\n * @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\r\n */\r\nexport const ExportList = (order: number, headernavigator: string, valuenavigator: string, valueformat: string = null) =>\r\n  (target: Object, propertyKey: string) => {\r\n    Object.defineProperty(target, propertyKey + csvOrdPrefix, { value: order, writable: false });\r\n    Object.defineProperty(target, propertyKey + listCsvValPrefix, { value: valuenavigator, writable: false });\r\n    Object.defineProperty(target, propertyKey + listCsvHdrPrefix, { value: headernavigator, writable: false });\r\n    Object.defineProperty(target, propertyKey + listCsvValFormat, { value: valueformat, writable: false });\r\n\r\n    if (target[exportList])\r\n      target[exportList].push(propertyKey + listCsvHdrPrefix);\r\n    else\r\n      target[exportList] = [propertyKey + listCsvHdrPrefix]\r\n  };\r\n\r\n/**\r\n * Decoratore di esportazione utilizzabile su un dizionario. Se ad esempio si vogliono generare le colonne\r\n * \r\n * Valore A = 1\r\n * \r\n * Valore B = 2\r\n * \r\n * Valore C = 3\r\n * \r\n * partendo da un oggetto iniziale { Valore { A: 1, B: 2, C: 3 } }\r\n * \r\n * @param {number} order Ordine di esportazione. Più piccolo è, prima appare il valore\r\n * @param {string} headerprefix Prefisso per l'header\r\n * @param {string} valueprefix Prefisso per il valore\r\n */\r\nexport const ExportDictionary = (order: number, headerprefix: string, valueprefix: string) =>\r\n  (target: Object, propertyKey: string) => {\r\n    Object.defineProperty(target, propertyKey + csvOrdPrefix, { value: order, writable: false });\r\n    Object.defineProperty(target, propertyKey + dictionaryCsvValPrefix, { value: valueprefix, writable: false });\r\n    Object.defineProperty(target, propertyKey + dictionaryCsvHdrPrefix, { value: headerprefix, writable: false });\r\n\r\n    if (target[exportList])\r\n      target[exportList].push(propertyKey + dictionaryCsvHdrPrefix);\r\n    else\r\n      target[exportList] = [propertyKey + dictionaryCsvHdrPrefix]\r\n  };\r\n\r\n/**\r\n * Service che si occupa dell'esportazione degli oggetti marcati dai Decoratori **ExportDictionary**, **ExportList**, **ExportAs** o **Export**\r\n */\r\n@Injectable({ providedIn: \"root\" })\r\nexport class ExportService {\r\n\r\n  /**\r\n   * Costruttore\r\n   * \r\n   * @ignore\r\n   */\r\n  public constructor(private dates: DateService, private utiExts: UtilityService, private lc: LocalizationService) { }\r\n\r\n  /**\r\n   * Data una lista di oggetti genera gli header per l'esportazione e integra ogni oggetto con le proprietà esportabili dalla libreria **@ctrl/ngx-csv**\r\n   * \r\n   * @param {any[]} objs Oggetti da esportare\r\n   * \r\n   * @returns {CsvHeaders[]} Header di esportazione già ordinati correttamente\r\n   */\r\n  public setupForExport(objs: any[], columns: string[] = []): CsvHeaders[] {\r\n    let headers: CsvHeaders[] = [];\r\n    let headersCache = {};\r\n\r\n    if (!objs || objs.length == 0)\r\n      return headers;\r\n\r\n    // Devo per forza farlo per tutti gli oggetti dato che devo esporre le proprietà che mi servono da esportare\r\n    // Gli header li raccolgo tutti poi faccio uan distinct in modo da esportare tutte le proprietà per bene\r\n    let columnSelectionDictionary: { [id: string]: true } = {};\r\n\r\n    if (columns?.length > 0)\r\n      for (let i = 0; i < columns?.length; i++)\r\n        columnSelectionDictionary[columns[i]] = true;\r\n\r\n    for (let i = 0; i < objs.length; i++) {\r\n      let hds = this.parseAndGetHeaders(objs[i], columnSelectionDictionary);\r\n      // Aggiungo gli header facendo in modo di non aggiungerne mai due uguali per non dover fare una distinct dopo\r\n      // che costerebbe comunque risorse. Utilizzo un dizionario d'appoggio per lookup istantanei\r\n      for (let k = 0; k < hds.length; k++) {\r\n        if (!headersCache[hds[k].key]) {\r\n          headersCache[hds[k].key] = true;\r\n          headers.push(hds[k]);\r\n        }\r\n      }\r\n    }\r\n\r\n    if (!columns || columns.length == 0)\r\n      return headers.sort((a, b) => a.order - b.order);\r\n    else {\r\n      // Se mi arriva la lista di colonne non mi dà solo la visibilità, ma anche l'ordinamento\r\n      // le esporto di conseguenza\r\n      let orderedHeaders = [];\r\n      for (let i = 0; i < columns.length; i++) {\r\n        let thisId = columns[i];\r\n        for (let i = 0; i < headers.length; i++) {\r\n          if (headers[i].propKey == thisId) {\r\n            orderedHeaders.push(headers[i]);\r\n            break;\r\n          }\r\n        }\r\n      }\r\n      return orderedHeaders;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * 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**\r\n   * \r\n   * @param {GenericItem[]} objs Oggetti generici da esportare\r\n   * @param {CsvHeaders[]} columns Colonne richieste dall'esportazione\r\n   * \r\n   * @returns {CsvHeaders[]} Header di esportazione già ordinati correttamente\r\n   */\r\n  public setupForGenericExport(objs: GenericItem[], columns: CsvHeaders[]): CsvHeaders[] {\r\n    let headers: CsvHeaders[] = [];\r\n    if (!objs || objs.length == 0)\r\n      return headers;\r\n\r\n    // Devo per forza farlo per tutti gli oggetti dato che devo esporre le proprietà che mi servono da esportare\r\n    objs.forEach((obj, index) => {\r\n      if (index == 0)\r\n        headers = this.parseAndGetGenericHeaders(obj, columns);\r\n      else\r\n        this.parseAndGetGenericHeaders(obj, columns);\r\n    });\r\n\r\n    return headers;\r\n  }\r\n\r\n  /**\r\n   * Dato un oggetto generico genera gli header per l'esportazione e lo integra con le proprietà esportabili dalla libreria **@ctrl/ngx-csv**\r\n   * \r\n   * Metodo interno richiamato da **setupForGenericExport**\r\n   * \r\n   * @param {GenericItem} obj Oggetto generico da esportare\r\n   * @param {CsvColumn[]} columns Colonne richieste dall'esportazione\r\n   * \r\n   * @returns {CsvHeaders[]} Header di esportazione già ordinati correttamente\r\n   */\r\n  private parseAndGetGenericHeaders(obj: GenericItem, columns: CsvHeaders[]): CsvHeaders[] {\r\n    if (!obj.properties)\r\n      return null;\r\n\r\n    var headers: CsvHeaders[] = [];\r\n\r\n    //Miracle incoming\r\n    columns.forEach(t => {\r\n      var propValue = obj.properties[t.key];\r\n      Object.defineProperty(obj, t.key + \"_exp\", { value: propValue, writable: false, enumerable: true });\r\n      headers.push({ label: t.label, key: t.key + \"_exp\", order: t.order, type: t.type, propKey: null });\r\n    });\r\n\r\n    //Tirati fuori tutti gli header faccio sort sull'ordinamento\r\n    return headers.sort((a, b) => { return a.order - b.order });\r\n  }\r\n\r\n  /**\r\n   * Dato un oggetto genera gli header per l'esportazione e lo integra con le proprietà esportabili dalla libreria **@ctrl/ngx-csv**\r\n   * \r\n   * Metodo interno richiamato da **setupForExport**\r\n   * \r\n   * @param {any} obj Oggetto generico da esportare\r\n   * \r\n   * @returns {CsvHeaders[]} Header di esportazione già ordinati correttamente\r\n   */\r\n  private parseAndGetHeaders(obj: any, columnsSelection?: { [id: string]: true }): CsvHeaders[] {\r\n    var headers: CsvHeaders[] = [];\r\n\r\n    // Miracle incoming\r\n    let exportProps = obj[exportList] || [];\r\n    let loc = obj[locProperty] ? this.lc.generateFromType(obj[locProperty]) : null;\r\n\r\n    if (exportProps.length == 0)\r\n      console.warn(\"[@esfaenza/extensions] Nessuna colonna configurata da esportare!\");\r\n\r\n    for (let i = 0; i < exportProps.length; i++) {\r\n      let prop = exportProps[i];\r\n      let propBase = \"\";\r\n      let toCall: Function;\r\n      if (prop.endsWith(listCsvHdrPrefix)) {\r\n        propBase = prop.replace(listCsvHdrPrefix, '');\r\n        toCall = this.parseList.bind(this);\r\n      }\r\n      else if (prop.endsWith(dictionaryCsvHdrPrefix)) {\r\n        propBase = prop.replace(dictionaryCsvHdrPrefix, '');\r\n        toCall = this.parseDictionary.bind(this);\r\n      }\r\n      else if (prop.endsWith(csvVisPrefix)) {\r\n        propBase = prop.replace(csvVisPrefix, '');\r\n        if (typeof obj[propBase + csvValueNavigator] !== \"undefined\")\r\n          toCall = this.parseObject.bind(this);\r\n        else\r\n          toCall = this.parseProperty.bind(this);\r\n      }\r\n\r\n      if (toCall)\r\n        toCall(obj, propBase, headers, columnsSelection, loc);\r\n    }\r\n\r\n    return headers;\r\n  }\r\n\r\n  /**\r\n   * Setup per l'esportazione di una singola proprietà. \r\n   * Viene generato l'header e la proprietà relativa al valore formattato o no\r\n   * \r\n   * @param {any} obj Oggetto di cui esportare la proprietà **prop**\r\n   * @param {string} prop Proprietà da esportare\r\n   * @param {CsvHeaders} headers Contenitore degli header, verrà riempito da questa funzione \r\n   * @param {LocalizationService} loc Servizio di localizzazione che traduce tutti i nomi che può\r\n   */\r\n  private parseProperty(obj: any, prop: string, headers: CsvHeaders[], columnsSelection?: { [id: string]: true }, loc?: LocalizationService) {\r\n    let toEmit: boolean = obj[prop + csvVisPrefix];\r\n    let format: string = obj[prop + csvFormatPrefix];\r\n    let propKey = obj[prop + csvPropKey];\r\n\r\n    if (propKey && !columnsSelection[propKey] && Object.keys(columnsSelection).length > 0) {\r\n      console.log(\"[@esfaenza/extensions] Colonna da non esportare: \" + propKey);\r\n      return;\r\n    }\r\n\r\n    let text = obj[prop + csvHdrPrefix];\r\n    let label = loc && text ? loc.loc(text) : text || \"\";\r\n    let order = obj[prop + csvOrdPrefix];\r\n\r\n    if (!toEmit)\r\n      return;\r\n\r\n    // Se non ho un formato esporto direttamente\r\n    if (!format) {\r\n      // Se è un formato data mi assicuro di non stampare mai una data 00:00:00 altrimenti in esportazione viene uno schifo\r\n      let val = obj[prop] ? this.dates.trimSeconds(obj[prop].toString()) : \"\";\r\n      let key = prop + \"_nofmt\";\r\n      Object.defineProperty(obj, key, { value: val, writable: false, enumerable: true });\r\n      headers.push({ label, key, order, type: \"string\", propKey });\r\n    } else {\r\n      let key = prop + \"_fmt\";\r\n\r\n      // Caso formato numerico\r\n      if (format == \"F\") {\r\n        // Check considerando la possibilità di zeri\r\n        let val = obj[prop] != null ? obj[prop].toString() : \"\";\r\n        // Elimino tutte le virgole (indicatori di migliaia per la culture default en-US)\r\n        val = val.replace(/,/, \"\");\r\n        // Il singolo punto che c'è, se presente (separatore decimali) lo trasformo in virgola\r\n        let valConverted = val.replace(\".\", \",\");\r\n\r\n        Object.defineProperty(obj, key, { value: valConverted, writable: false, enumerable: true });\r\n        headers.push({ label, key, order, type: \"number\", propKey });\r\n      } else {\r\n        // Se ho un formato data trasformo in dayjs, formatto ed esporto\r\n        // Per la trasformazione in dayjs provo prima a passargli la stringa di netto, sperando la riconosca\r\n        // Se non funziona provo a definirgli la formattazione standard del metering per quel linguaggio\r\n        let val = this.dates.getFormatted(obj[prop], format.length <= 10, format.length > 16);\r\n        Object.defineProperty(obj, key, { value: val ?? \"\", writable: false, enumerable: true });\r\n        headers.push({ label, key, order, type: \"date\", propKey });\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Setup per l'esportazione di una singola proprietà da un oggetto. \r\n   * Viene generato l'header e la proprietà relativa al valore formattato o no. \r\n   * \r\n   * Per ottenere il valore e l'header della proprietà vengono utilizzati i navigatori auto-generati nel decoratore **ExportAs**\r\n   * \r\n   * @param {any} obj Oggetto di cui esportare la proprietà **prop**\r\n   * @param {string} prop Proprietà da esportare\r\n   * @param {CsvHeaders} headers Contenitore degli header, verrà riempito da questa funzione\r\n   * @param {LocalizationService} loc Servizio di localizzazione che traduce tutti i nomi che può\r\n   */\r\n  private parseObject(obj: any, prop: string, headers: CsvHeaders[], columnsSelection?: { [id: string]: true }, loc?: LocalizationService) {\r\n    //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\r\n    let valuenavigator = obj[prop + csvValueNavigator];\r\n\r\n    //Es. di valuenavigator obj.subobj.subsubobj.property\r\n    let jmps = valuenavigator.split(\".\");\r\n\r\n    // Localizzazione presa dalla classe base se c'è, altrimenti dalla classe interna (cioè dal primo saltino)\r\n    if (!loc) {\r\n      let type = obj[prop + csvValueType];\r\n      let proto = new type();\r\n      loc = proto[locProperty] ? this.lc.generateFromType(proto[locProperty]) : null;\r\n    }\r\n\r\n    //Mi clono l'oggetto originale per non uccidergli i riferimenti\r\n    let clone = JSON.parse(JSON.stringify(obj));\r\n    //Salto ricorsivamente su me stesso per arrivare alla proprietà\r\n    //Salto 1 > diventa obj\r\n    //Salto 2 > diventa obj.subobj\r\n    //ecc...\r\n    jmps.forEach(pp => { clone = clone?.[pp]; });\r\n\r\n    //Valore finale :D\r\n    let value = clone;\r\n\r\n    let text = obj[prop + csvHdrPrefix];\r\n    let label = loc && text ? loc.loc(text) : text || \"\";\r\n    let order = obj[prop + csvOrdPrefix];\r\n\r\n    //Se per questa proprietà ho un formato lo applico\r\n    let format: string = obj[prop + csvFormatPrefix];\r\n    let type: 'string' | 'number' | 'date' = \"string\";\r\n    if (format == \"F\") {\r\n      let val = value.toString();\r\n      val = val.replace(/,/, \"\");\r\n      value = val.replace(\".\", \",\");\r\n      type = \"number\";\r\n    }\r\n    else if (format) {\r\n      value = this.dates.getFormatted(value, format.length <= 10, format.length > 16);\r\n      type = \"date\";\r\n    }\r\n\r\n    Object.defineProperty(obj, prop, { value: value ?? \"\", writable: false, enumerable: true });\r\n    headers.push({ label, key: prop, order, type, propKey: null });\r\n  }\r\n\r\n  /**\r\n   * Setup per l'esportazione di una lista di valori pivottati dinamicamente:\r\n   * \r\n   * => Recupero il valore utilizzando i navigatori\r\n   * \r\n   * => Recupero l'header utilizzando i navigatori\r\n   * \r\n   * => Con il valore ci creo la property\r\n   * \r\n   * => Con l'header e il riferimento alla property appena creata creo un record negli header da esportare\r\n   * \r\n   * @param {any} obj Oggetto di cui esportare la proprietà **prop**\r\n   * @param {string} prop Proprietà da esportare\r\n   * @param {CsvHeaders} headers Contenitore degli header, verrà riempito da questa funzione \r\n   * @param {LocalizationService} loc Servizio di localizzazione che traduce tutti i nomi che può\r\n   */\r\n  private parseList(obj: any, prop: string, headers: CsvHeaders[], columnsSelection?: { [id: string]: true } , loc?: LocalizationService) {\r\n    let headernavigator = obj[prop + listCsvHdrPrefix];\r\n    let valuenavigator = obj[prop + listCsvValPrefix];\r\n    let valueformat = obj[prop + listCsvValFormat];\r\n    let order = obj[prop + csvOrdPrefix];\r\n\r\n    var jumps: string[], tmpRes: any;\r\n    var objs: any[] = obj[prop];\r\n\r\n    for (let idx = 0; idx < objs.length; idx++) {\r\n      let listitem = objs[idx];\r\n\r\n      var headersplit = headernavigator.split(\" \");\r\n      var label = \"\";\r\n\r\n      // Per l'header si considera a se stante ogni pezzo separato da spazio per fare le concatenazioni\r\n      headersplit.forEach(pr => {\r\n        jumps = pr.split(\".\");\r\n        tmpRes = JSON.parse(JSON.stringify(listitem));\r\n        jumps.forEach(pp => { tmpRes = tmpRes[pp]; });\r\n\r\n        let localized = !!loc ? loc.loc(tmpRes) : tmpRes\r\n        if (!label) label = localized;\r\n        else label += \" \" + localized;\r\n      });\r\n\r\n      jumps = valuenavigator.split(\".\");\r\n      tmpRes = JSON.parse(JSON.stringify(listitem));\r\n      jumps.forEach(pp => { tmpRes = tmpRes[pp]; });\r\n      let value = tmpRes;\r\n\r\n      let type: 'string' | 'number' | 'date' = \"string\";\r\n      if (valueformat == \"F\") {\r\n        let val = value != null ? value.toString() : \"\";\r\n        val = val.replace(/,/, \"\");\r\n        value = val.replace(\".\", \",\");\r\n        type = \"number\";\r\n      }\r\n      else if (valueformat) {\r\n        value = this.dates.getFormatted(obj[prop], valueformat.length <= 10, valueformat.length > 16);\r\n        type = \"date\";\r\n      }\r\n\r\n      Object.defineProperty(obj, prop + idx, { value: value ?? \"\", writable: false });\r\n      headers.push({ label, key: prop + idx, order: order + idx, type, propKey: null });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Setup per l'esportazione di una lista di valori pivottati dinamicamente:\r\n   * \r\n   * => Recupero il valore utilizzando i navigatori\r\n   * \r\n   * => Recupero l'header utilizzando i navigatori\r\n   * \r\n   * => Con il valore ci creo la property\r\n   * \r\n   * => Con l'header e il riferimento alla property appena creata creo un record negli header da esportare\r\n   * \r\n   * @param {any} obj Oggetto di cui esportare la proprietà **prop**\r\n   * @param {string} prop Proprietà da esportare\r\n   * @param {CsvHeaders} headers Contenitore degli header, verrà riempito da questa funzione\r\n   */\r\n  private parseDictionary(obj: any, prop: string, headers: CsvHeaders[], columnsSelection?: { [id: string]: true }) {\r\n    let headerprefix = obj[prop + dictionaryCsvHdrPrefix];\r\n    let valueprefix = obj[prop + dictionaryCsvValPrefix];\r\n    let order = obj[prop + csvOrdPrefix];\r\n\r\n    var object: { [id: string]: string } = obj[prop];\r\n    let idx = 0;\r\n\r\n    for (const [key, val] of Object.entries(object)) {\r\n\r\n      // Ignoro tutti i cmapi che non fanno parte della selezione delle colonne\r\n      if (key && !columnsSelection[key] && Object.keys(columnsSelection).length > 0) {\r\n        console.log(\"[@esfaenza/extensions] Colonna da non esportare: \" + key);\r\n        return;\r\n      }\r\n\r\n      let propname = prop + \"_\" + key;\r\n      let value = valueprefix ? valueprefix + \" \" + val : val;\r\n      let label = headerprefix ? headerprefix + \" \" + key : key;\r\n\r\n      Object.defineProperty(obj, propname, { value: value ?? \"\", writable: false });\r\n      headers.push({ label: label, key: propname, order: order + idx++, type: 'string', propKey: null });\r\n    }\r\n  }\r\n\r\n  /** \r\n   * Effettua l'esportazione in file CSV \r\n   */\r\n  private exportCSV(fn: string, headers: CsvHeaders[], data: any[]) {\r\n    let csvData = '', row = '', sep = ';';\r\n\r\n    for (let i = 0; i < headers.length; i++) {\r\n      let h = headers[i];\r\n      row += `${row != '' ? sep : ''}\"${h.label}\"`;\r\n    }\r\n    csvData += row + '\\r\\n';\r\n\r\n    for (let i = 0; i < data.length; i++) {\r\n      row = '';\r\n      let item = data[i];\r\n      for (let j = 0; j < headers.length; j++) {\r\n        let val = item[headers[j].key];\r\n        row += `${row != '' ? sep : ''}\"${val}\"`;\r\n      }\r\n      csvData += row + '\\r\\n';\r\n    }\r\n\r\n    var BOM = new Uint8Array([0xEF,0xBB,0xBF]);\r\n    var blob = new Blob([BOM, csvData], { type: 'text/csv' });\r\n    var objectUrl = URL.createObjectURL(blob);\r\n    this.utiExts.fileDownload(objectUrl, fn.endsWith('.xlsx') ? fn.replace('.xlsx', '.csv') : fn.endsWith('.csv') ? fn : fn + \".csv\");\r\n  }\r\n\r\n\r\n  /** Cache del modulo per l'esportazione Excel */\r\n  private ExcelJS: any;\r\n\r\n  /** Effettua l'esportazione del file Excel basandosi sul modulo **ExcelJS**, sugli header **headers** e sui dati **data** */\r\n  private async exportExcel(fn: string, headers: CsvHeaders[], data: any[]) {\r\n\r\n    try {\r\n      this.ExcelJS = this.ExcelJS || await import(\"exceljs\");\r\n    }\r\n    catch {\r\n      throw \"Impossibile caricare la libreria per l'esportazione in Excel\";\r\n    }\r\n\r\n    let iFix = 1;\r\n    let workbook = new this.ExcelJS.Workbook();\r\n    workbook.creator = \"Ema's big Es-Table\";\r\n    workbook.created = new Date();\r\n\r\n    let sheet = workbook.addWorksheet('Data');\r\n    let header = sheet.getRow(1);\r\n    header.font = { bold: true };\r\n    headers = headers.sort((a: CsvHeaders, b: CsvHeaders) => a.order - b.order);\r\n\r\n    for (let i = 0; i < headers.length; i++) {\r\n      let h = headers[i];\r\n      header.getCell(i + iFix).value = h.label;\r\n    }\r\n\r\n    for (let i = 0; i < data.length; i++) {\r\n      let row = sheet.getRow(i + iFix + 1);\r\n      let item = data[i];\r\n      for (let i = 0; i < headers.length; i++) {\r\n        let h = headers[i];\r\n        let cell = row.getCell(i + 1);\r\n        let val = item[h.key];\r\n\r\n        if (!val) {\r\n          cell.value = \"\";\r\n          continue;\r\n        }\r\n\r\n        switch (h.type) {\r\n          case 'date':\r\n            // ExcelJS va di default in UTC quindi rischierebbe di tirare giù 2 ore ad ogni esportazione\r\n            // Bisogna aggiungere l'utc offset alla data attuale\r\n            let date = this.dates.getDateConvertion(val);\r\n            if (date) {\r\n              let correctedDate = date.add(date.utcOffset(), 'minute');\r\n              cell.value = correctedDate.toDate();\r\n              cell.numFmt = val.length > 10 ? 'dd/mm/yyyy h:m:s' : '';\r\n            }\r\n            break;\r\n          case 'number':\r\n            let converted = parseFloat(val.replace(',', '.'));\r\n            cell.value = isNaN(converted) ? \"\" : converted;\r\n            break;\r\n          default:\r\n            cell.value = val;\r\n            break;\r\n        }\r\n      }\r\n    }\r\n\r\n    let buffer = await workbook.xlsx.writeBuffer();\r\n    let blob = new Blob([buffer], { type: \"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;\" });\r\n    let objectUrl = URL.createObjectURL(blob);\r\n    this.utiExts.fileDownload(objectUrl, fn.endsWith('.csv') ? fn.replace('.csv', '.xlsx') : fn.endsWith('.xlsx') ? fn : fn + \".xlsx\");\r\n  }\r\n\r\n  /**\r\n   * Metodo che effettivamente genera gli header e i dati per l'esportazione con **ngx-csv**\r\n   *\r\n   * @param {any[]} items Oggetti da esportare\r\n   */\r\n  public export(items: any[], format: 'CSV' | 'XLSX', fileName: string, type: Type<any>, columnsFilter?: string[], genericHeaders?: CsvHeaders[]) : CsvHeaders[] {\r\n    // Deepclone con assegnatura del tipo\r\n    var createdItems = items.map(t => this.utiExts.deepClone(t, type));\r\n    let headers = genericHeaders ? this.setupForGenericExport(createdItems, genericHeaders) : this.setupForExport(createdItems, columnsFilter);\r\n    (format == \"CSV\" ? this.exportCSV : this.exportExcel).bind(this)(fileName, headers, createdItems);\r\n    return headers;\r\n  }\r\n}"]}