@esfaenza/es-table 12.2.28 → 13.1.2

package/esm2020/lib/core/handlers/classes/RowGroupingHandler.mjs

@@ -0,0 +1,474 @@
+// Modelli
+import { Group, GroupAggregation, GroupOrAggregation, GroupPager, GroupRouteFragment } from "../../../domain";
+/** Classe che gestisce la modalità Row Grouping dell'es-table */
+export class RowGroupingHandler {
+    /** @ignore Costruttore */
+    constructor(est, utilities, dateExts) {
+        this.est = est;
+        this.utilities = utilities;
+        this.dateExts = dateExts;
+        /** Cache per salvare per ogni chiave di ogni gruppo chi è il gruppo rappresentato */
+        this.rgGroupCache = new Map();
+        /** Cache per salvare per ogni chiave di ogni gruppo chi sono gli oggetti sottostanti, non dei sottogruppi */
+        this.rgItemCache = new Map();
+        /** Cache per salvare per ogni chiave di ogni gruppo chi sono gli oggetti sottostanti, non dei sottogruppi */
+        this.rgChildGroupsCache = new Map();
+    }
+    /**
+     * In modalità rowgrouping quando mi arriva un nuovo blocco di oggetti devo aggiungerlo alla vista attuale:
+     *
+     * 1) Se non viene richiesto il dettaglio di alcun gruppo significa che devo considerare mi siano arrivati tutti i gruppi principali
+     * 2) Se viene richiesto il dettaglio di un gruppo diverso dall'ultimo devo aggiungere dopo al gruppo cliccato la lista dei sottogruppi
+     * 2) Se viene richiesto il dettaglio dell'ultimo gruppo devo aggiungere dopo al gruppo cliccato la lista degli oggetti
+     *
+     * @param {any} view AppSearch<T> da cui sono arrivati gli oggetti
+     * @param {number} groupingKeys Livelli di raggruppamento da aspettarsi sui dati
+     */
+    handleNewDataOnRowGrouping(view, groupingKeys) {
+        // 1) Se non viene richiesto il dettaglio di alcun gruppo significa che la chiamata restituisce la lista paginata dei gruppi principali.
+        //    Li tratto come se fosse una qualsiasi altra query paginata su N elementi
+        if ((view.requestedgroups?.length || 0) == 0) {
+            this.est.boundSource = this.est.TMPBoundSource;
+            this.rgGroupCache = new Map();
+            this.rgItemCache = new Map();
+            this.rgChildGroupsCache = new Map();
+            this.est.TMPBoundSource.forEach(itm => {
+                itm._thisRoute = itm._group ? [{ column: itm.column, value: itm.value }] : [];
+                itm._thisKey = itm._group ? itm.value : null;
+                itm._grouplevel = 0;
+                this.rgGroupCache.set(itm._thisKey, itm);
+            });
+            // Resetto la ricerca alla cache di questa "sessione"
+            let firstItem = this.est.TMPBoundSource[0];
+            this.est.MainGroupView = Object.assign({}, view);
+            this.est.groupSearchRequestsCache = [{ path: '', route: [{ column: firstItem.column, value: firstItem.value }], view: this.est.MainGroupView, group_column: this.est.TMPBoundSource[0].column }];
+            this.est.BaseItemsCount = view.objectcount;
+        }
+        else {
+            // 2) Se viene richiesto il dettaglio di un qualsiasi gruppo diverso dall'ultimo vuol dire che devo aggiungere 
+            //    dopo al gruppo che ho cliccato la lista dei gruppi tirata fuori questa volta (intermediateGroup = true)
+            /*
+            *   GruppoA                      GruppoA
+            *   GruppoB                      GruppoB
+            *   GruppoC <- Clicco qui        GruppoC
+            *   GruppoD                          GruppoC1
+            *   GruppoE                          GruppoC2
+            *                                GruppoD
+            *                                GruppoE
+            */
+            // 3) se i gruppi richiesti dalla view sono uguali ai gruppi presenti vuol dire che sto prendendo gli oggetti veri e propri, sono in 
+            // view.items e quindi in TMPBoundSource, ho inoltre le informazioni di paginazione **per il singolo sottogruppo** (intermediateGroup = false)
+            /*
+            *   GruppoA                         GruppoA
+            *       GruppoC1                        GruppoC1
+            *   GruppoB                         GruppoB
+            *   GruppoC                         GruppoC
+            *       GruppoC1 <-- Clicco qui         GruppoC1
+            *                                           Oggetto1
+            *                                           Oggetto2
+            *                                           Oggetto3
+            *       GruppoC2                        GruppoC2
+            *   GruppoD                         GruppoD
+            *   GruppoE                         GruppoE
+            */
+            let intermediateGroup = view.requestedgroups.length != groupingKeys;
+            let items = this.est.boundSource;
+            let insertIndex = 0;
+            let insertGroup = null;
+            let groupKey = "";
+            let groupRoute = [];
+            // Navigo la stuttura dei gruppi ignorando ricorsivamente tutti gli indici fino ai gruppi che mi interessano in modo da non beccare il primo "GruppoC1" del caso sopra
+            for (let i = 0; i < view.requestedgroups.length; i++) {
+                let rg = view.requestedgroups[i];
+                groupKey += rg.value;
+                groupRoute.push({ column: rg.column, value: rg.value });
+                for (let i = insertIndex; i < items.length; i++) {
+                    let t = items[i];
+                    if (i >= insertIndex && t._group && t.column == rg.column && t.value == rg.value) {
+                        insertIndex = i;
+                        insertGroup = t;
+                        // Lo marco expanded dato che questo click sul gruppo potrebbe non essere stato fatto
+                        insertGroup._expanded = true;
+                        break;
+                    }
+                }
+            }
+            let itemsCacheReference;
+            let childGroupsCacheReference;
+            // Se non è un gruppo intermedio devo ripulire la cache del gruppo su cui ho attualmente cliccato. Gli oggetti saranno riaggiunti dopo
+            if (!intermediateGroup) {
+                this.rgItemCache.set(groupKey, []);
+                itemsCacheReference = this.rgItemCache.get(groupKey);
+            }
+            else {
+                // Se invece è un gruppo intermedio devo ripulire sia tutti i child group ricorsivamente, sia tutti gli item
+                for (let key of this.rgChildGroupsCache.keys())
+                    if (key.startsWith(groupKey))
+                        this.rgChildGroupsCache.delete(key);
+                for (let key of this.rgItemCache.keys())
+                    if (key.startsWith(groupKey))
+                        this.rgItemCache.delete(key);
+                this.rgChildGroupsCache.set(groupKey, []);
+                childGroupsCacheReference = this.rgChildGroupsCache.get(groupKey);
+            }
+            // Assegno un livello ai valori che arrivano da usare per formattare la parte grafica. Il primo gruppo cliccato sarà a livello 1,
+            // il secondo sarà a livello 2 e così via...
+            // Li marco inoltre con il parent in modo da poter eliminare i vecchi qualora servisse
+            this.est.TMPBoundSource.forEach(itm => {
+                itm._parent = groupKey;
+                itm._parentRoute = groupRoute;
+                itm._thisRoute = itm._group ? [...groupRoute, new GroupRouteFragment(itm.column, itm.value)] : [];
+                itm._thisKey = itm._group ? groupKey + itm.value : groupKey;
+                // Per le ricerca intermedie metto i gruppi nella cache dei gruppi
+                if (intermediateGroup) {
+                    itm._grouplevel = view.requestedgroups.length;
+                    this.rgGroupCache.set(itm._thisKey, itm);
+                    childGroupsCacheReference.push(itm);
+                }
+                else {
+                    // Metto anche gli oggetti nella cache non ricorsiva
+                    itemsCacheReference.push(itm);
+                }
+            });
+            // Elimino gli oggetti vecchi 
+            // 1) Ricerca intermedia, stato salvato - Elimino tutti gli item e tutti i gruppi la cui route è più lunga della corrente, tutti gli item relativi alla path corrente, e tutte
+            //    le cache di ricerca effettuate su una path più profonda dell'attuale
+            // 2) Ricerca finale o ricerca intermedia senza stato salvato - Elimino tutti gli item relativi alla path corrente
+            // Per "stato salvato" si intendono ricerche vecchie salvate per poter essere rieffettuate in caso di ordinamenti su colonne di interesse 
+            if (intermediateGroup && view.savedstate) {
+                this.est.boundSource = this.est.boundSource.filter(t => !(t._item || t._thisRoute.length > groupRoute.length));
+                this.est.groupSearchRequestsCache = this.est.groupSearchRequestsCache.filter(t => !(t.route.length > groupRoute.length));
+            }
+            this.est.boundSource = this.est.boundSource.filter(t => !(t._parent == groupKey));
+            let thisGroup = this.est.boundSource[insertIndex];
+            if (intermediateGroup)
+                thisGroup._groupscount = this.est.View?.groupcount;
+            // Li sostituisco coi nuovi di questa ricerca
+            this.est.boundSource.splice(insertIndex + 1, 0, ...this.est.TMPBoundSource);
+            // Aggiungo un separatore alla fine o all'inizio di questi gruppi che dovrà occuparsi di caricare ALTRI gruppi o oggetti (se sono all'ultimo gruppo)
+            let addLast = false;
+            this.est.boundSource.splice(insertIndex + 1 + (addLast ? this.est.TMPBoundSource.length : 0), 0, this.getGroupSeparator(view, groupKey, groupRoute, view.requestedgroups.length, intermediateGroup ? 'groups' : 'items'));
+            // Aggiungo la ricerca alla cache di questa "sessione"
+            let toAdd = { path: groupKey, route: groupRoute, view: Object.assign({}, view), group_column: intermediateGroup ? this.est.TMPBoundSource[0].column : '' };
+            let prev = this.est.groupSearchRequestsCache.findIndex(t => t.path == toAdd.path && t.group_column == toAdd.group_column);
+            if (prev == -1)
+                this.est.groupSearchRequestsCache.push(toAdd);
+            else
+                this.est.groupSearchRequestsCache.splice(prev, 1, toAdd);
+        }
+    }
+    /**
+     * Se in modalità array applica i raggruppamenti definiti lato row-grouping
+     *
+     * @param {ths: EsTh[] | EsThDirective[]} ths Header
+     */
+    arrayModeReviewGroupings(ths) {
+        if (ths.length == 0)
+            return;
+        if (this.utilities.isEsTh(ths[0]))
+            return;
+        let headerGroups = [];
+        let headerAggregations = [];
+        for (let i = 0; i < ths.length; i++) {
+            let th = ths[i];
+            if (th.thGroup)
+                headerGroups.push(new Group(th.th, 0, ""));
+            else if (th.thAggregation)
+                headerAggregations = [...headerAggregations, ...this.getGroupAggregations(th)];
+        }
+        if (headerGroups.length > 0) {
+            // Pulizia delle cache
+            this.rgGroupCache.clear();
+            this.rgItemCache.clear();
+            this.rgChildGroupsCache.clear();
+            this.est.ArrayGrouping = true;
+            this.est.boundSource = this.getGroupsRecursive(headerGroups, 0, this.est.boundSource, headerAggregations, null);
+        }
+    }
+    /**
+     * Data una direttiva EsTh restituisce la lista delle aggregazioni richiesta per questa colonna o il gruppo che rappresenta
+     *
+     * @param {EsThDirective} th Direttiva
+     *
+     * @returns {GroupOrAggregation[]} Lista dei gruppi o aggregazioni relativi alla Direttiva passata
+     */
+    getGroupAggregations(th) {
+        let ret = [];
+        // Es: '{min:dd/MM/yyyy} - {max:dd/MM/yyyy}'
+        if (th.thAggregation) {
+            this.getEsThDirectiveListOfAggregations(th).forEach((agg) => {
+                let isdate = agg.format && ['small', 'long', 'verylong'].includes(agg.format);
+                let isnumber = agg.format && agg.format.startsWith("F") && !Number.isNaN(agg.format.charAt(1)) && agg.format.length == 2;
+                if (!isdate && !isnumber && agg.format)
+                    throw "Le aggergazioni supportate dall'es-table sono solo 'small', 'long', 'verylong' per le date e 'F0-9' per i numeri";
+                ret.push(new GroupOrAggregation(th.th, agg.func, isdate ? 'date' : isnumber ? 'number' : 'string'));
+            });
+        }
+        else if (th.thGroup)
+            ret.push(new GroupOrAggregation(th.th, null));
+        return ret;
+    }
+    /**
+    * Data una direttiva con un formato restituisce tutte le coppie Funzione di Aggregazione - Formato
+    *
+    * @param {EsThDirective} th Direttiva EsTh di cui calcolare le funzioni di aggregazione usate
+    *
+    * @returns {{ func: string, format: string }[]} Lista delle funzioni di aggregazione rilevate
+    */
+    getEsThDirectiveListOfAggregations(th) {
+        if (!th.thAggregation)
+            return [];
+        // Se ho già effettuato questo calcolo per questo th restituisco la versione in cache
+        if (th._thAggregations)
+            return th._thAggregations;
+        let ret = [];
+        let display = th.thAggregation;
+        var matches = display.match(/{[a-zA-Z0-9\/:]*}/gi);
+        if (!matches)
+            return [];
+        matches.forEach(m => {
+            let split = m.split(":");
+            let func = m, format = "";
+            if (split.length > 0) {
+                // Escludo primo e ultimo carattere (le graffe)
+                func = split[0].substr(1);
+                format = split[1].substr(0, split[1].length - 1);
+            }
+            ret.push({ func: func, format: format, match: m });
+        });
+        th._thAggregations = ret;
+        return ret;
+    }
+    /**
+     * Data la definizione dei gruppi da generare da una lista di oggetti, suddivide gli oggetti passati in gruppi e sottogruppi
+     *
+     * @param {Group[]} grps Definizione dei gruppi
+     * @param {number} currentIndex Indice di elaborazione. Al livello 0 ho tutti gli oggetti e devo generare i primi gruppi, a livello 1 ho tutti i gruppi principali e devo
+     * elaborare i sottogruppi, e così via ricorsivamente...
+     * @param {any[]} items Oggetti da raggruppare
+     * @param {GroupOrAggregation[]} aggregations Info di aggregazione
+     * @param {any} parent Riferimento al gruppo padre
+     */
+    getGroupsRecursive(grps, currentIndex, items, aggregations, parent) {
+        // Se l'indice è 0 devo sicuramente nascondere tutti gli oggetti. Solo i gruppi saranno visualizzati
+        if (currentIndex == 0)
+            items.forEach(i => i._visible = false);
+        let grp = grps[currentIndex];
+        let ret = [];
+        let last = grps.length == currentIndex + 1;
+        let groups = this.utilities.groupBy(items, grp.column);
+        for (let prop in groups) {
+            let itms = groups[prop];
+            let gp = new Group(grp.column, itms.length, prop);
+            gp.aggregations = this.generateAggregations(itms, aggregations);
+            let anygp = gp;
+            anygp._group = true;
+            anygp._expanded = false;
+            if (!parent) {
+                anygp._thisRoute = [{ column: gp.column, value: gp.value }];
+                anygp._thisKey = gp.value;
+                anygp._grouplevel = 0;
+            }
+            else {
+                anygp._parent = parent._thisKey;
+                anygp._parentRoute = parent._thisRoute;
+                anygp._thisRoute = [...parent._thisRoute, { column: gp.column, value: gp.value }];
+                anygp._thisKey = parent._thisKey + gp.value;
+                anygp._grouplevel = parent._grouplevel + 1;
+            }
+            // Pusho il gruppo, tutti i gruppi del livello sotto, o gli item se io sono l'ultimo gruppo. 
+            // La visibilità è solo per il gruppo a livello 0, tutti gli altri gruppi saranno mostrati o nascosti di conseguenza
+            if (currentIndex == 0)
+                anygp._visible = true;
+            this.utilities.calculateHash([anygp]);
+            this.utilities.cacheAggregations(anygp);
+            // Aggiungo il gruppo padre
+            ret.push(anygp);
+            this.rgGroupCache.set(anygp._thisKey, anygp);
+            if (!last) {
+                //Dal gruppo padre, se non è l'ultimo gruppo della catena, calcolo ricorsivamente tutta la catena sotto
+                let subGroupsAndItems = this.getGroupsRecursive(grps, currentIndex + 1, itms, aggregations, anygp);
+                let childgroups = subGroupsAndItems.filter(t => t._group && t._parent == anygp._thisKey);
+                anygp._groupscount = childgroups.length;
+                // Aggiungo la catena del gruppo sotto, aggiungendo alla cache solo i gruppi padre
+                ret.push(...subGroupsAndItems);
+                this.rgChildGroupsCache.set(anygp._thisKey, childgroups);
+            }
+            else {
+                // Al gruppo padre, se è l'ultimo assegno tutte le foglie assegnandogli anche la chiave del gruppo
+                itms.forEach(i => i._thisKey = anygp._thisKey);
+                ret.push(...itms);
+                this.rgItemCache.set(anygp._thisKey, itms);
+            }
+        }
+        return ret;
+    }
+    /**
+     * Data una lista di oggetti genera le aggregazioni specificate. Si considera di avere tutti gli oggetti
+     *
+     * @param {any[]} items Oggetti di cui calcolare le aggregazione
+     * @param {GroupOrAggregation[]} aggregations Aggergazioni da generare
+     */
+    generateAggregations(items, aggregations) {
+        let rets = [];
+        let aggregationValue = "", feField = null, stringAgg = null, dateAgg = null, numberAgg = null;
+        for (let i = 0; i < aggregations.length; i++) {
+            let agg = aggregations[i];
+            feField = agg.column;
+            if (!feField)
+                continue;
+            switch (agg.datatype) {
+                case 'string':
+                    stringAgg = items.map(i => i[feField].toString());
+                    break;
+                case 'date':
+                    dateAgg = items.map(i => new Date(i[feField]).getTime());
+                    break;
+                case 'number':
+                    numberAgg = items.map(i => parseFloat(i[feField]));
+                    break;
+            }
+            switch (agg.aggregation) {
+                case 'max':
+                    switch (agg.datatype) {
+                        case 'string':
+                            aggregationValue = stringAgg.sort().reverse()[0];
+                            break;
+                        case 'date':
+                            aggregationValue = new Date(Math.max(...dateAgg)).toString();
+                            break;
+                        case 'number':
+                            aggregationValue = Math.max(...numberAgg).toString();
+                            break;
+                    }
+                    break;
+                case 'min':
+                    switch (agg.datatype) {
+                        case 'string':
+                            aggregationValue = stringAgg.sort()[0];
+                            break;
+                        case 'date':
+                            aggregationValue = new Date(Math.min(...dateAgg)).toString();
+                            break;
+                        case 'number':
+                            aggregationValue = Math.min(...numberAgg).toString();
+                            break;
+                    }
+                    break;
+                case 'sum':
+                    switch (agg.datatype) {
+                        case 'string':
+                            aggregationValue = stringAgg.join(", ");
+                            break;
+                        case 'date':
+                            aggregationValue = "";
+                            break;
+                        case 'number':
+                            aggregationValue = numberAgg.reduce((pre, curr) => pre + curr, 0).toString();
+                            break;
+                    }
+                    break;
+            }
+            rets.push(new GroupAggregation(agg.column, agg.aggregation, aggregationValue));
+        }
+        return rets;
+    }
+    /**
+    * Ottiene un elemento di separazione fra Gruppi che serve per paginare le ricerche all'interno di ogni singolo gruppo
+    *
+    * @param {AppSearch<any>} view View utilizzata per la ricerca. Me ne salvo i parametri nel separatore attuale dato che ne ho bisogno per caricare altri elementi
+    * facenti riferimento allo stesso contesto
+    * @param {string} parent Parent path che rappresenta a quale gruppo è affibbiato questo separatore
+    * @param {GroupRouteFragment[]} route Route path che rappresenta a quale gruppo è affibbiato questo separatore
+    * @param {number} level Livello del gruppo di cui questo elemento è separatore, viene usato per applicare la classe "est-lvl-{{level}}"
+    *
+    * @returns {any} Elemento di separazione contenente tutti i bind per presentare una paginazione sotto questo gruppo lato interfaccia
+    */
+    getGroupSeparator(view, parent, route, level, searches) {
+        let item = new GroupPager(level, route, parent, Object.assign({}, view), searches);
+        item.buttons = this.utilities.getPagesArray(6, view.page, view.pages);
+        this.utilities.calculateHash([item]);
+        return item;
+    }
+    /**
+     * Data una colonna effettua la riemissione di tutte le ricerche relative.
+     *
+     * Es. Ho 2 campi di gruppo e ho espanso fino a vedere i valori fino ad un livello qualsiasi.
+     * Clicco l'ordinamento sul secondo gruppo.
+     * Tutte le ricerche relative ai primi gruppi devono essere rieseguite. Quando i risultati arriveranno ci penserà il metodo **bindDisplayToLoadedItemsOrGroups**
+     * a tagliare via gli oggetti non più visualizzati
+     *
+     * @param {string} column Colonna su cui si è effettuata un'operazione di ordinamento
+     * @param {AppOrdering[]} orderings Direttive di ordinamento da applicare alle varie sottoricerche
+     */
+    emitRowGroupingSearches(column, orderings) {
+        // Per tutte le ricerche intermedie che devo rivalutare le re-emitto in modo da aggiornargli i dati
+        var meaningfulAppSearches = this.est.groupSearchRequestsCache.filter(t => t.group_column == column).map(t => t.view);
+        // Se non ne trovo significa che ho fatto l'ordinamento o sugli item, o su colonne relative a un sottogruppo non caricato
+        if (!meaningfulAppSearches || meaningfulAppSearches.length == 0)
+            meaningfulAppSearches = this.est.groupSearchRequestsCache.filter(t => !t.group_column).map(t => t.view);
+        // Se non ne trovo qui significa che sto ordinando su colonne relative a un sottogruppo non caricato
+        if (!meaningfulAppSearches || meaningfulAppSearches.length == 0)
+            return;
+        meaningfulAppSearches.forEach(as => {
+            // Ovviamente gli oridnamenti devono essere quelli appena generati
+            as.orders = orderings;
+            as.savedstate = true;
+            this.est.emitSearchRequest(false, as);
+        });
+    }
+    /**
+     * Helper che calcola il contenuto di una cella relativa a un gruppo riga, tenendo conto del formato delle eventuali aggregazioni
+     *
+     * @param {Group} grp Gruppo di cui mostrare le celle
+     * @param {string} cell Cella attuale di cui calcolare il testo
+     * @param {EsThDirective} header Header relativo alla cella attuale, utilizzata per identificare le informazioni di aggregazione
+     *
+     * @returns {string} Testo finale calcolato per la **cell** corrente, in base alle aggregazioni di **header**
+     */
+    getGroupCellDisplay(grp, cell, header) {
+        if (grp._sep)
+            return "";
+        let display = header.thAggregation;
+        if (grp.column == cell) {
+            let groupsPart = grp._groupscount ? " - " + grp._groupscount + " " + this.est.lc.loc("Groups") : "";
+            return grp.value + " (" + grp.count + groupsPart + ")";
+        }
+        else {
+            let agg = grp._aggregationsCache.get(cell);
+            if (!agg)
+                return "";
+            this.getEsThDirectiveListOfAggregations(header).forEach((itm) => {
+                display = display.replace(itm.match, this.formatAggregationValue(agg.get(itm.func), itm.format));
+            });
+            return display;
+        }
+    }
+    /**
+     * Funzione che dato un valore lo formatta in base al tipo
+     *
+     * @param {string} value Valore che generalemnte può essere una data o un numero
+     * @param {string} fromat Formato su cui formattare il valore. Può essere ad esempio "small", "long" "verylong" per le date o F{0-9} per i numeri decimali
+     *
+     * @returns {string} Valore dell'aggregazione formattato come si deve
+     */
+    formatAggregationValue(value, format) {
+        if (!format)
+            return value;
+        let isNumber = !Number.isNaN(value) && (!format || format.startsWith("F"));
+        if (isNumber && format.startsWith("F") && !Number.isNaN(format.substr(1)))
+            return parseFloat(value).toFixed(parseInt(format.substr(1)));
+        let date = null;
+        // Alcune versione di extensions rischiano di crashare con cose non date... è stato risolto dopo quindi questo try - catch in realtà
+        // torna utile solo con versioni vecchie/deprecate della libreria @esfaenza/extensions
+        try {
+            date = this.dateExts.getDateConvertion(value);
+        }
+        catch { }
+        if (date)
+            return this.dateExts.getFormatted(date, format == 'small', format == 'verylong');
+        // Qui ci finisco sia per input che non sono né date né numeri, sia per formati non riconosciuti
+        return value;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RowGroupingHandler.js","sourceRoot":"","sources":["../../../../../../../projects/es-table/src/lib/core/handlers/classes/RowGroupingHandler.ts"],"names":[],"mappings":"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","sourcesContent":["// Librerie\r\nimport { DateService } from \"@esfaenza/extensions\";\r\n\r\n// Direttive / Componenti\r\nimport { EsTh } from \"../../../components/es-th/es_th.component\";\r\nimport { EsThDirective } from \"../../../directives/es_th.directive\";\r\nimport { EsTableComponent } from \"../../../components/es-table/es_table.component\"\r\n\r\n// Modelli\r\nimport { AppOrdering, AppSearch, Group, GroupAggregation, GroupOrAggregation, GroupPager, GroupRouteFragment, ThAggregation } from \"../../../domain\";\r\n\r\n// Utilities\r\nimport { UtilitiesHandler } from \"./UtilitiesHandler\";\r\n\r\n/** Classe che gestisce la modalità Row Grouping dell'es-table */\r\nexport class RowGroupingHandler {\r\n\r\n    /** Cache per salvare per ogni chiave di ogni gruppo chi è il gruppo rappresentato */\r\n    public rgGroupCache: Map<string, Group> = new Map<string, Group>();\r\n    /** Cache per salvare per ogni chiave di ogni gruppo chi sono gli oggetti sottostanti, non dei sottogruppi */\r\n    public rgItemCache: Map<string, any[]> = new Map<string, any[]>();\r\n    /** Cache per salvare per ogni chiave di ogni gruppo chi sono gli oggetti sottostanti, non dei sottogruppi */\r\n    public rgChildGroupsCache: Map<string, Group[]> = new Map<string, Group[]>();\r\n\r\n    /** @ignore Costruttore */\r\n    constructor(private est: EsTableComponent, private utilities: UtilitiesHandler, private dateExts: DateService) { }\r\n\r\n    /**\r\n     * In modalità rowgrouping quando mi arriva un nuovo blocco di oggetti devo aggiungerlo alla vista attuale:\r\n     *\r\n     * 1) Se non viene richiesto il dettaglio di alcun gruppo significa che devo considerare mi siano arrivati tutti i gruppi principali\r\n     * 2) Se viene richiesto il dettaglio di un gruppo diverso dall'ultimo devo aggiungere dopo al gruppo cliccato la lista dei sottogruppi\r\n     * 2) Se viene richiesto il dettaglio dell'ultimo gruppo devo aggiungere dopo al gruppo cliccato la lista degli oggetti\r\n     *\r\n     * @param {any} view AppSearch<T> da cui sono arrivati gli oggetti\r\n     * @param {number} groupingKeys Livelli di raggruppamento da aspettarsi sui dati\r\n     */\r\n    public handleNewDataOnRowGrouping(view: AppSearch<any>, groupingKeys: number) {\r\n        // 1) Se non viene richiesto il dettaglio di alcun gruppo significa che la chiamata restituisce la lista paginata dei gruppi principali.\r\n        //    Li tratto come se fosse una qualsiasi altra query paginata su N elementi\r\n        if ((view.requestedgroups?.length || 0) == 0) {\r\n            this.est.boundSource = this.est.TMPBoundSource;\r\n            this.rgGroupCache = new Map<string, Group>();\r\n            this.rgItemCache = new Map<string, any[]>();\r\n            this.rgChildGroupsCache = new Map<string, Group[]>();\r\n\r\n            this.est.TMPBoundSource.forEach(itm => {\r\n                itm._thisRoute = itm._group ? [{ column: (<Group>itm).column, value: (<Group>itm).value }] : [];\r\n                itm._thisKey = itm._group ? (<Group>itm).value : null;\r\n                itm._grouplevel = 0;\r\n\r\n                this.rgGroupCache.set(itm._thisKey, itm);\r\n            });\r\n\r\n            // Resetto la ricerca alla cache di questa \"sessione\"\r\n            let firstItem = this.est.TMPBoundSource[0];\r\n            this.est.MainGroupView = Object.assign({}, view);\r\n            this.est.groupSearchRequestsCache = [{ path: '', route: [{ column: (<Group>firstItem).column, value: (<Group>firstItem).value }], view: this.est.MainGroupView, group_column: (<Group>this.est.TMPBoundSource[0]).column }];\r\n            this.est.BaseItemsCount = view.objectcount;\r\n        }\r\n        else {\r\n            // 2) Se viene richiesto il dettaglio di un qualsiasi gruppo diverso dall'ultimo vuol dire che devo aggiungere \r\n            //    dopo al gruppo che ho cliccato la lista dei gruppi tirata fuori questa volta (intermediateGroup = true)\r\n            /*\r\n            *   GruppoA                      GruppoA\r\n            *   GruppoB                      GruppoB\r\n            *   GruppoC <- Clicco qui        GruppoC\r\n            *   GruppoD                          GruppoC1\r\n            *   GruppoE                          GruppoC2\r\n            *                                GruppoD\r\n            *                                GruppoE\r\n            */\r\n            // 3) se i gruppi richiesti dalla view sono uguali ai gruppi presenti vuol dire che sto prendendo gli oggetti veri e propri, sono in \r\n            // view.items e quindi in TMPBoundSource, ho inoltre le informazioni di paginazione **per il singolo sottogruppo** (intermediateGroup = false)\r\n            /*\r\n            *   GruppoA                         GruppoA\r\n            *       GruppoC1                        GruppoC1\r\n            *   GruppoB                         GruppoB\r\n            *   GruppoC                         GruppoC\r\n            *       GruppoC1 <-- Clicco qui         GruppoC1\r\n            *                                           Oggetto1\r\n            *                                           Oggetto2\r\n            *                                           Oggetto3\r\n            *       GruppoC2                        GruppoC2\r\n            *   GruppoD                         GruppoD\r\n            *   GruppoE                         GruppoE\r\n            */\r\n            let intermediateGroup = view.requestedgroups.length != groupingKeys;\r\n\r\n            let items = this.est.boundSource;\r\n            let insertIndex = 0;\r\n            let insertGroup = null;\r\n            let groupKey: string = \"\";\r\n            let groupRoute: GroupRouteFragment[] = [];\r\n\r\n            // Navigo la stuttura dei gruppi ignorando ricorsivamente tutti gli indici fino ai gruppi che mi interessano in modo da non beccare il primo \"GruppoC1\" del caso sopra\r\n            for (let i = 0; i < view.requestedgroups.length; i++) {\r\n                let rg = view.requestedgroups[i];\r\n                groupKey += rg.value;\r\n                groupRoute.push({ column: rg.column, value: rg.value });\r\n                for (let i = insertIndex; i < items.length; i++) {\r\n                    let t = items[i];\r\n                    if (i >= insertIndex && t._group && t.column == rg.column && t.value == rg.value) {\r\n                        insertIndex = i; insertGroup = t;\r\n                        // Lo marco expanded dato che questo click sul gruppo potrebbe non essere stato fatto\r\n                        insertGroup._expanded = true;\r\n                        break;\r\n                    }\r\n                }\r\n            }\r\n\r\n            let itemsCacheReference;\r\n            let childGroupsCacheReference;\r\n\r\n            // Se non è un gruppo intermedio devo ripulire la cache del gruppo su cui ho attualmente cliccato. Gli oggetti saranno riaggiunti dopo\r\n            if (!intermediateGroup) {\r\n                this.rgItemCache.set(groupKey, []);\r\n                itemsCacheReference = this.rgItemCache.get(groupKey);\r\n            }\r\n            else {\r\n                // Se invece è un gruppo intermedio devo ripulire sia tutti i child group ricorsivamente, sia tutti gli item\r\n                for (let key of this.rgChildGroupsCache.keys())\r\n                    if (key.startsWith(groupKey))\r\n                        this.rgChildGroupsCache.delete(key);\r\n\r\n                for (let key of this.rgItemCache.keys())\r\n                    if (key.startsWith(groupKey))\r\n                        this.rgItemCache.delete(key);\r\n\r\n                this.rgChildGroupsCache.set(groupKey, []);\r\n                childGroupsCacheReference = this.rgChildGroupsCache.get(groupKey);\r\n            }\r\n\r\n            // Assegno un livello ai valori che arrivano da usare per formattare la parte grafica. Il primo gruppo cliccato sarà a livello 1,\r\n            // il secondo sarà a livello 2 e così via...\r\n            // Li marco inoltre con il parent in modo da poter eliminare i vecchi qualora servisse\r\n            this.est.TMPBoundSource.forEach(itm => {\r\n                itm._parent = groupKey;\r\n                itm._parentRoute = groupRoute;\r\n                itm._thisRoute = itm._group ? [...groupRoute, new GroupRouteFragment((<Group>itm).column, (<Group>itm).value)] : [];\r\n                itm._thisKey = itm._group ? groupKey + (<Group>itm).value : groupKey;\r\n\r\n                // Per le ricerca intermedie metto i gruppi nella cache dei gruppi\r\n                if (intermediateGroup) {\r\n                    itm._grouplevel = view.requestedgroups.length;\r\n                    this.rgGroupCache.set(itm._thisKey, itm);\r\n                    childGroupsCacheReference.push(itm);\r\n                }\r\n                else {\r\n                    // Metto anche gli oggetti nella cache non ricorsiva\r\n                    itemsCacheReference.push(itm);\r\n                }\r\n            });\r\n\r\n            // Elimino gli oggetti vecchi \r\n            // 1) Ricerca intermedia, stato salvato - Elimino tutti gli item e tutti i gruppi la cui route è più lunga della corrente, tutti gli item relativi alla path corrente, e tutte\r\n            //    le cache di ricerca effettuate su una path più profonda dell'attuale\r\n            // 2) Ricerca finale o ricerca intermedia senza stato salvato - Elimino tutti gli item relativi alla path corrente\r\n            // Per \"stato salvato\" si intendono ricerche vecchie salvate per poter essere rieffettuate in caso di ordinamenti su colonne di interesse \r\n            if (intermediateGroup && view.savedstate) {\r\n                this.est.boundSource = this.est.boundSource.filter(t => !(t._item || t._thisRoute.length > groupRoute.length));\r\n                this.est.groupSearchRequestsCache = this.est.groupSearchRequestsCache.filter(t => !(t.route.length > groupRoute.length));\r\n            }\r\n\r\n            this.est.boundSource = this.est.boundSource.filter(t => !(t._parent == groupKey));\r\n\r\n            let thisGroup = this.est.boundSource[insertIndex];\r\n            if (intermediateGroup)\r\n                thisGroup._groupscount = (<AppSearch<any>>this.est.View)?.groupcount;\r\n\r\n            // Li sostituisco coi nuovi di questa ricerca\r\n            this.est.boundSource.splice(insertIndex + 1, 0, ...this.est.TMPBoundSource);\r\n\r\n            // Aggiungo un separatore alla fine o all'inizio di questi gruppi che dovrà occuparsi di caricare ALTRI gruppi o oggetti (se sono all'ultimo gruppo)\r\n            let addLast = false;\r\n            this.est.boundSource.splice(insertIndex + 1 + (addLast ? this.est.TMPBoundSource.length : 0), 0, this.getGroupSeparator(view, groupKey, groupRoute, view.requestedgroups.length, intermediateGroup ? 'groups' : 'items'));\r\n\r\n            // Aggiungo la ricerca alla cache di questa \"sessione\"\r\n            let toAdd = { path: groupKey, route: groupRoute, view: Object.assign({}, view), group_column: intermediateGroup ? (<Group>this.est.TMPBoundSource[0]).column : '' };\r\n            let prev = this.est.groupSearchRequestsCache.findIndex(t => t.path == toAdd.path && t.group_column == toAdd.group_column);\r\n            if (prev == -1)\r\n                this.est.groupSearchRequestsCache.push(toAdd);\r\n\r\n            else\r\n                this.est.groupSearchRequestsCache.splice(prev, 1, toAdd);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Se in modalità array applica i raggruppamenti definiti lato row-grouping\r\n     *\r\n     * @param {ths: EsTh[] | EsThDirective[]} ths Header\r\n     */\r\n    public arrayModeReviewGroupings(ths: EsTh[] | EsThDirective[]) {\r\n        if (ths.length == 0)\r\n            return;\r\n\r\n        if (this.utilities.isEsTh(ths[0]))\r\n            return;\r\n\r\n        let headerGroups: Group[] = [];\r\n        let headerAggregations: GroupOrAggregation[] = [];\r\n\r\n        for (let i = 0; i < ths.length; i++) {\r\n            let th = ths[i] as EsThDirective;\r\n\r\n            if (th.thGroup)\r\n                headerGroups.push(new Group(th.th, 0, \"\"));\r\n            else if (th.thAggregation)\r\n                headerAggregations = [...headerAggregations, ...this.getGroupAggregations(th)];\r\n        }\r\n\r\n        if (headerGroups.length > 0) {\r\n            // Pulizia delle cache\r\n            this.rgGroupCache.clear();\r\n            this.rgItemCache.clear();\r\n            this.rgChildGroupsCache.clear();\r\n\r\n            this.est.ArrayGrouping = true;\r\n            this.est.boundSource = this.getGroupsRecursive(headerGroups, 0, this.est.boundSource, headerAggregations, null);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Data una direttiva EsTh restituisce la lista delle aggregazioni richiesta per questa colonna o il gruppo che rappresenta\r\n     *\r\n     * @param {EsThDirective} th Direttiva\r\n     *\r\n     * @returns {GroupOrAggregation[]} Lista dei gruppi o aggregazioni relativi alla Direttiva passata\r\n     */\r\n    public getGroupAggregations(th: EsThDirective): GroupOrAggregation[] {\r\n        let ret = [];\r\n        // Es: '{min:dd/MM/yyyy} - {max:dd/MM/yyyy}'\r\n        if (th.thAggregation) {\r\n            this.getEsThDirectiveListOfAggregations(th).forEach((agg: ThAggregation) => {\r\n                let isdate = agg.format && ['small', 'long', 'verylong'].includes(agg.format);\r\n                let isnumber = agg.format && agg.format.startsWith(\"F\") && !Number.isNaN(agg.format.charAt(1)) && agg.format.length == 2;\r\n\r\n                if (!isdate && !isnumber && agg.format)\r\n                    throw \"Le aggergazioni supportate dall'es-table sono solo 'small', 'long', 'verylong' per le date e 'F0-9' per i numeri\";\r\n\r\n                ret.push(new GroupOrAggregation(th.th, agg.func, isdate ? 'date' : isnumber ? 'number' : 'string'));\r\n            });\r\n        }\r\n        else if (th.thGroup)\r\n            ret.push(new GroupOrAggregation(th.th, null));\r\n\r\n        return ret;\r\n    }\r\n\r\n\r\n    /**\r\n    * Data una direttiva con un formato restituisce tutte le coppie Funzione di Aggregazione - Formato\r\n    *\r\n    * @param {EsThDirective} th Direttiva EsTh di cui calcolare le funzioni di aggregazione usate\r\n    *\r\n    * @returns {{ func: string, format: string }[]} Lista delle funzioni di aggregazione rilevate\r\n    */\r\n    private getEsThDirectiveListOfAggregations(th: EsThDirective): ThAggregation[] {\r\n        if (!th.thAggregation)\r\n            return [];\r\n\r\n        // Se ho già effettuato questo calcolo per questo th restituisco la versione in cache\r\n        if (th._thAggregations)\r\n            return th._thAggregations;\r\n\r\n        let ret = [];\r\n        let display = th.thAggregation;\r\n        var matches = display.match(/{[a-zA-Z0-9\\/:]*}/gi);\r\n        if (!matches)\r\n            return [];\r\n        matches.forEach(m => {\r\n            let split = m.split(\":\");\r\n            let func = m, format = \"\";\r\n            if (split.length > 0) {\r\n                // Escludo primo e ultimo carattere (le graffe)\r\n                func = split[0].substr(1);\r\n                format = split[1].substr(0, split[1].length - 1);\r\n            }\r\n\r\n            ret.push({ func: <'min' | 'max' | 'sum'>func, format: format, match: m });\r\n        });\r\n\r\n        th._thAggregations = ret;\r\n        return ret;\r\n    }\r\n\r\n    /**\r\n     * Data la definizione dei gruppi da generare da una lista di oggetti, suddivide gli oggetti passati in gruppi e sottogruppi\r\n     *\r\n     * @param {Group[]} grps Definizione dei gruppi\r\n     * @param {number} currentIndex Indice di elaborazione. Al livello 0 ho tutti gli oggetti e devo generare i primi gruppi, a livello 1 ho tutti i gruppi principali e devo\r\n     * elaborare i sottogruppi, e così via ricorsivamente...\r\n     * @param {any[]} items Oggetti da raggruppare\r\n     * @param {GroupOrAggregation[]} aggregations Info di aggregazione\r\n     * @param {any} parent Riferimento al gruppo padre\r\n     */\r\n    private getGroupsRecursive(grps: Group[], currentIndex: number, items: any[], aggregations: GroupOrAggregation[], parent?: any): any[] {\r\n        // Se l'indice è 0 devo sicuramente nascondere tutti gli oggetti. Solo i gruppi saranno visualizzati\r\n        if (currentIndex == 0)\r\n            items.forEach(i => i._visible = false);\r\n\r\n        let grp = grps[currentIndex];\r\n        let ret: any[] = [];\r\n        let last = grps.length == currentIndex + 1;\r\n        let groups = this.utilities.groupBy(items, grp.column);\r\n        for (let prop in groups) {\r\n            let itms = groups[prop];\r\n            let gp = new Group(grp.column, itms.length, prop);\r\n            gp.aggregations = this.generateAggregations(itms, aggregations);\r\n\r\n            let anygp = (<any>gp);\r\n            anygp._group = true;\r\n            anygp._expanded = false;\r\n            if (!parent) {\r\n                anygp._thisRoute = [{ column: gp.column, value: gp.value }];\r\n                anygp._thisKey = gp.value;\r\n                anygp._grouplevel = 0;\r\n            }\r\n            else {\r\n                anygp._parent = parent._thisKey;\r\n                anygp._parentRoute = parent._thisRoute;\r\n                anygp._thisRoute = [...parent._thisRoute, { column: gp.column, value: gp.value }];\r\n                anygp._thisKey = parent._thisKey + gp.value;\r\n                anygp._grouplevel = parent._grouplevel + 1;\r\n            }\r\n\r\n            // Pusho il gruppo, tutti i gruppi del livello sotto, o gli item se io sono l'ultimo gruppo. \r\n            // La visibilità è solo per il gruppo a livello 0, tutti gli altri gruppi saranno mostrati o nascosti di conseguenza\r\n            if (currentIndex == 0)\r\n                anygp._visible = true;\r\n\r\n            this.utilities.calculateHash([anygp]);\r\n            this.utilities.cacheAggregations(anygp);\r\n\r\n            // Aggiungo il gruppo padre\r\n            ret.push(anygp);\r\n            this.rgGroupCache.set(anygp._thisKey, anygp);\r\n            if (!last) {\r\n\r\n                //Dal gruppo padre, se non è l'ultimo gruppo della catena, calcolo ricorsivamente tutta la catena sotto\r\n                let subGroupsAndItems = this.getGroupsRecursive(grps, currentIndex + 1, itms, aggregations, anygp);\r\n                let childgroups = subGroupsAndItems.filter(t => t._group && t._parent == anygp._thisKey);\r\n                anygp._groupscount = childgroups.length;\r\n\r\n                // Aggiungo la catena del gruppo sotto, aggiungendo alla cache solo i gruppi padre\r\n                ret.push(...subGroupsAndItems);\r\n                this.rgChildGroupsCache.set(anygp._thisKey, childgroups);\r\n            }\r\n            else {\r\n                // Al gruppo padre, se è l'ultimo assegno tutte le foglie assegnandogli anche la chiave del gruppo\r\n                itms.forEach(i => i._thisKey = anygp._thisKey);\r\n\r\n                ret.push(...itms);\r\n                this.rgItemCache.set(anygp._thisKey, itms);\r\n            }\r\n        }\r\n        return ret;\r\n    }\r\n\r\n    /**\r\n     * Data una lista di oggetti genera le aggregazioni specificate. Si considera di avere tutti gli oggetti\r\n     *\r\n     * @param {any[]} items Oggetti di cui calcolare le aggregazione\r\n     * @param {GroupOrAggregation[]} aggregations Aggergazioni da generare\r\n     */\r\n    private generateAggregations(items: any[], aggregations: GroupOrAggregation[]): GroupAggregation[] {\r\n        let rets: GroupAggregation[] = [];\r\n        let aggregationValue = \"\", feField = null, stringAgg = null, dateAgg = null, numberAgg = null;\r\n\r\n        for (let i = 0; i < aggregations.length; i++) {\r\n            let agg = aggregations[i];\r\n            feField = agg.column;\r\n            if (!feField)\r\n                continue;\r\n\r\n            switch (agg.datatype) {\r\n                case 'string': stringAgg = items.map(i => i[feField].toString()); break;\r\n                case 'date': dateAgg = items.map(i => new Date(i[feField]).getTime()); break;\r\n                case 'number': numberAgg = items.map(i => parseFloat(i[feField])); break;\r\n            }\r\n\r\n            switch (agg.aggregation) {\r\n                case 'max':\r\n                    switch (agg.datatype) {\r\n                        case 'string': aggregationValue = stringAgg.sort().reverse()[0]; break;\r\n                        case 'date': aggregationValue = new Date(Math.max(...dateAgg)).toString(); break;\r\n                        case 'number': aggregationValue = Math.max(...numberAgg).toString(); break;\r\n                    }\r\n                    break;\r\n                case 'min':\r\n                    switch (agg.datatype) {\r\n                        case 'string': aggregationValue = stringAgg.sort()[0]; break;\r\n                        case 'date': aggregationValue = new Date(Math.min(...dateAgg)).toString(); break;\r\n                        case 'number': aggregationValue = Math.min(...numberAgg).toString(); break;\r\n                    }\r\n                    break;\r\n                case 'sum':\r\n                    switch (agg.datatype) {\r\n                        case 'string': aggregationValue = stringAgg.join(\", \"); break;\r\n                        case 'date': aggregationValue = \"\"; break;\r\n                        case 'number': aggregationValue = numberAgg.reduce((pre, curr) => pre + curr, 0).toString(); break;\r\n                    }\r\n                    break;\r\n            }\r\n            rets.push(new GroupAggregation(agg.column, agg.aggregation, aggregationValue));\r\n        }\r\n\r\n        return rets;\r\n    }\r\n\r\n    /**\r\n    * Ottiene un elemento di separazione fra Gruppi che serve per paginare le ricerche all'interno di ogni singolo gruppo\r\n    *\r\n    * @param {AppSearch<any>} view View utilizzata per la ricerca. Me ne salvo i parametri nel separatore attuale dato che ne ho bisogno per caricare altri elementi\r\n    * facenti riferimento allo stesso contesto\r\n    * @param {string} parent Parent path che rappresenta a quale gruppo è affibbiato questo separatore\r\n    * @param {GroupRouteFragment[]} route Route path che rappresenta a quale gruppo è affibbiato questo separatore\r\n    * @param {number} level Livello del gruppo di cui questo elemento è separatore, viene usato per applicare la classe \"est-lvl-{{level}}\"\r\n    *\r\n    * @returns {any} Elemento di separazione contenente tutti i bind per presentare una paginazione sotto questo gruppo lato interfaccia\r\n    */\r\n    public getGroupSeparator(view: AppSearch<any>, parent: string, route: GroupRouteFragment[], level: number, searches: 'groups' | 'items'): GroupPager {\r\n        let item = new GroupPager(level, route, parent, Object.assign({}, view), searches);\r\n        item.buttons = this.utilities.getPagesArray(6, view.page, view.pages);\r\n        this.utilities.calculateHash([item]);\r\n        return item;\r\n    }\r\n\r\n\r\n    /**\r\n     * Data una colonna effettua la riemissione di tutte le ricerche relative.\r\n     *\r\n     * Es. Ho 2 campi di gruppo e ho espanso fino a vedere i valori fino ad un livello qualsiasi.\r\n     * Clicco l'ordinamento sul secondo gruppo.\r\n     * Tutte le ricerche relative ai primi gruppi devono essere rieseguite. Quando i risultati arriveranno ci penserà il metodo **bindDisplayToLoadedItemsOrGroups**\r\n     * a tagliare via gli oggetti non più visualizzati\r\n     *\r\n     * @param {string} column Colonna su cui si è effettuata un'operazione di ordinamento\r\n     * @param {AppOrdering[]} orderings Direttive di ordinamento da applicare alle varie sottoricerche\r\n     */\r\n    public emitRowGroupingSearches(column: string, orderings: AppOrdering[]) {\r\n        // Per tutte le ricerche intermedie che devo rivalutare le re-emitto in modo da aggiornargli i dati\r\n        var meaningfulAppSearches = this.est.groupSearchRequestsCache.filter(t => t.group_column == column).map(t => t.view);\r\n\r\n        // Se non ne trovo significa che ho fatto l'ordinamento o sugli item, o su colonne relative a un sottogruppo non caricato\r\n        if (!meaningfulAppSearches || meaningfulAppSearches.length == 0)\r\n            meaningfulAppSearches = this.est.groupSearchRequestsCache.filter(t => !t.group_column).map(t => t.view);\r\n\r\n        // Se non ne trovo qui significa che sto ordinando su colonne relative a un sottogruppo non caricato\r\n        if (!meaningfulAppSearches || meaningfulAppSearches.length == 0)\r\n            return;\r\n\r\n        meaningfulAppSearches.forEach(as => {\r\n            // Ovviamente gli oridnamenti devono essere quelli appena generati\r\n            as.orders = orderings;\r\n            as.savedstate = true;\r\n            this.est.emitSearchRequest(false, as);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Helper che calcola il contenuto di una cella relativa a un gruppo riga, tenendo conto del formato delle eventuali aggregazioni\r\n     *\r\n     * @param {Group} grp Gruppo di cui mostrare le celle\r\n     * @param {string} cell Cella attuale di cui calcolare il testo\r\n     * @param {EsThDirective} header Header relativo alla cella attuale, utilizzata per identificare le informazioni di aggregazione\r\n     *\r\n     * @returns {string} Testo finale calcolato per la **cell** corrente, in base alle aggregazioni di **header**\r\n     */\r\n    public getGroupCellDisplay(grp: Group, cell: string, header: EsThDirective): string {\r\n        if ((<any>grp)._sep)\r\n            return \"\";\r\n        let display = header.thAggregation;\r\n        if (grp.column == cell) {\r\n            let groupsPart = (<any>grp)._groupscount ? \" - \" + (<any>grp)._groupscount + \" \" + this.est.lc.loc(\"Groups\") : \"\";\r\n            return grp.value + \" (\" + grp.count + groupsPart + \")\";\r\n        }\r\n        else {\r\n\r\n            let agg = (<Map<string, Map<string, string>>>(<any>grp)._aggregationsCache).get(cell);\r\n            if (!agg)\r\n                return \"\";\r\n\r\n            this.getEsThDirectiveListOfAggregations(header).forEach((itm: ThAggregation) => {\r\n                display = display.replace(itm.match, this.formatAggregationValue(agg.get(itm.func), itm.format));\r\n            });\r\n\r\n            return display;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Funzione che dato un valore lo formatta in base al tipo\r\n     * \r\n     * @param {string} value Valore che generalemnte può essere una data o un numero\r\n     * @param {string} fromat Formato su cui formattare il valore. Può essere ad esempio \"small\", \"long\" \"verylong\" per le date o F{0-9} per i numeri decimali\r\n     * \r\n     * @returns {string} Valore dell'aggregazione formattato come si deve\r\n     */\r\n    private formatAggregationValue(value: string, format?: string): string {\r\n        if (!format)\r\n            return value;\r\n\r\n        let isNumber = !Number.isNaN(value) && (!format || format.startsWith(\"F\"));\r\n\r\n        if (isNumber && format.startsWith(\"F\") && !Number.isNaN(format.substr(1)))\r\n            return parseFloat(value).toFixed(parseInt(format.substr(1)));\r\n\r\n        let date = null;\r\n        // Alcune versione di extensions rischiano di crashare con cose non date... è stato risolto dopo quindi questo try - catch in realtà\r\n        // torna utile solo con versioni vecchie/deprecate della libreria @esfaenza/extensions\r\n        try { date = this.dateExts.getDateConvertion(value); } catch { }\r\n\r\n        if (date)\r\n            return this.dateExts.getFormatted(date, format == 'small', format == 'verylong');\r\n\r\n        // Qui ci finisco sia per input che non sono né date né numeri, sia per formati non riconosciuti\r\n        return value;\r\n    }\r\n}"]}