@esfaenza/es-table 16.2.29 → 17.3.16

package/esm2022/lib/core/handlers/ItemsHandler.mjs

@@ -1,119 +1,119 @@
-// Modelli
-import { AppSearch } from "../../domain/externals/appsearch/AppSearch";
-/** Classe che si occupa della gestione del recupero degli oggetti, paginazione e tutto ciò in cui gli elementi caricati vengono manipolati direttamente */
-export class ItemsHandler {
-    /** @ignore Costruttore */
-    constructor(est, utilities) {
-        this.est = est;
-        this.utilities = utilities;
-    }
-    /**
-     * In base alla modalità specificata (ArrayMode, ViewMode, ecc...) questo metodo recupera l'array di oggetti da bindare ad interfaccia
-     *
-     * @param {boolean} onlyselected [false] Indica di prendere solo gli oggetti selezionati
-     * @param {boolean} refreshPaging [false] Indica se aggiornare le informazioni di paginazione o meno
-     * @param {boolean} allIfPossible [false] Indica se prendere tutti gli oggetti quaora possibile, usato solo in ArrayMode
-     *
-     * @returns {any[]} Lista degli oggetti su cui effettuare il bind lato interfaccia
-     */
-    getItemsByMode(onlyselected = false, refreshPaging = false, allIfPossible = false) {
-        let items = [];
-        if ((this.est.viewMode && this.est.View instanceof AppSearch)) {
-            items = this.getViewItemsBySource();
-        }
-        else if (this.est.arrayMode) {
-            this.est.View.forEach(itm => { itm._item = true; });
-            // Se faccio dei raggruppamenti ignoro la paginazione
-            if (this.est.UseArrayModePaging && !allIfPossible) {
-                // Se sono in modalità array ma la ricerca dipende da una view devo riallineare gli itemperpage
-                if (this.est.SearchView) {
-                    this.est.ArraymodeItemsPerPage = this.est.SearchView.itemsperpageoverride;
-                    this.est.arraymodePage = this.est.SearchView.page;
-                    this.est.arraymodePages = this.est.SearchView.pages;
-                }
-                // Devo chiamare il refresh page solo se vengo richiamato da un binding esterno
-                else if (refreshPaging)
-                    this.refreshPaging(this.est.ArraymodeItemsPerPage);
-                items = this.adaptViewToPaging();
-            }
-            else {
-                items = this.est.View;
-            }
-        }
-        // Se voglio solo i selezionati filtro
-        if (onlyselected)
-            return items.filter(t => t._selected);
-        return items;
-    }
-    /**
-     * Metodo per effettuare il refresh della paginazione sul cambiamento degli oggetti da visualizzare in una singola pagina.
-     *
-     * Vale solo per la modalità Array
-     *
-     * @param {number} pageSize Dimensione della pagina
-     */
-    refreshPaging(pageSize) {
-        this.est.ArraymodeItemsPerPage = pageSize;
-        this.est.arraymodePages = Math.ceil(this.est.View.length / this.est.ArraymodeItemsPerPage);
-        this.est.arraymodePage = 1;
-        // Riforzo il writevalue in modo che il codice passi dalla gestione come se fosse fatta ripartire una ricerca
-        this.est.internalWriteValue();
-    }
-    /**
-     * Ottiene gli oggetti in base alla sorgente
-     */
-    getViewItemsBySource() {
-        let castedView = this.est.View;
-        let groupKeys = castedView.groupings ? castedView.groupings.filter(t => !t.aggregation).length : 0;
-        //Gruppi intermedi
-        if ((castedView.requestedgroups?.length != groupKeys || castedView.requestedgroups?.length == 0) && groupKeys > 0) {
-            let ret = castedView.groups;
-            ret.forEach(itm => {
-                // Setto variabile interna per capire che questo è in realtà un gruppo
-                itm._group = true;
-                // Le informazioni passate come lista le metto dentro a una cache per velocizzarne l'accesso quando devo tirare fuori il display della proprietà
-                this.utilities.cacheAggregations(itm);
-            });
-            return ret;
-        }
-        else {
-            let ret = this.est.ItemSourceProperty ? this.est.View[this.est.ItemSourceProperty] : this.est.View.items;
-            if (!ret)
-                ret = [];
-            // Setto variabile interna per specificare che questo è un elemento normale, non un gruppo o altro
-            ret.forEach(itm => { itm._item = true; });
-            return ret;
-        }
-    }
-    /** Genera le informazioni di paginazione e taglia la View in modalità array per mostrare solo gli oggetti della pagina specificata */
-    adaptViewToPaging() {
-        let tmpItems = [];
-        // Se ho una search view l'array pulsanti viene calcolato da lei, non devo prendere quello della modalità array,
-        // inoltre non ho bisogno di fare ragionamenti su quanti elementi ci sono e sulla pagina, dato che viene tutto gestito esternamente, 
-        // unendo al risultato della view tutti gli oggetti addizionali
-        if (!this.est.SearchView)
-            this.est.arrayPulsanti = this.utilities.getPagesArray(6, this.est.arraymodePage, this.est.arraymodePages);
-        else
-            return this.est.View;
-        // Applico eventuali oridnamenti lato Array prima di tirare fuori la pagina selezionata
-        let items = this.est.View;
-        if (this.est)
-            items = this.arrayModeReviewOrderings(items);
-        // Poi per tutti i valori dopo compresi fra la pagina - 1 e la pagina
-        for (let i = ((this.est.arraymodePage - 1) * this.est.ArraymodeItemsPerPage); i < this.est.arraymodePage * this.est.ArraymodeItemsPerPage; i++) {
-            if (i <= items.length - 1)
-                tmpItems.push(items[i]);
-        }
-        return tmpItems;
-    }
-    /** Se in modalità array applica gli ordinamenti ASC-DESC delle colonne */
-    arrayModeReviewOrderings(items) {
-        let tmp = items;
-        if (this.est.arrayOrders.length > 0)
-            this.est.arrayOrders.forEach(t => {
-                tmp = tmp.sort((a, b) => (a[t.id] > b[t.id] ? 1 : -1) * (t.order == 'DESC' ? -1 : 1));
-            });
-        return tmp;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ItemsHandler.js","sourceRoot":"","sources":["../../../../../../projects/es-table/src/lib/core/handlers/ItemsHandler.ts"],"names":[],"mappings":"AAGA,UAAU;AACV,OAAO,EAAE,SAAS,EAAE,MAAM,4CAA4C,CAAC;AAKvE,2JAA2J;AAC3J,MAAM,OAAO,YAAY;IAErB,0BAA0B;IAC1B,YAAoB,GAAqB,EAAU,SAA2B;QAA1D,QAAG,GAAH,GAAG,CAAkB;QAAU,cAAS,GAAT,SAAS,CAAkB;IAAI,CAAC;IAEnF;;;;;;;;OAQG;IACI,cAAc,CAAC,eAAwB,KAAK,EAAE,gBAAyB,KAAK,EAAE,gBAAyB,KAAK;QAC/G,IAAI,KAAK,GAAU,EAAE,CAAC;QAEtB,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,YAAY,SAAS,CAAC,EAAE;YAC3D,KAAK,GAAG,IAAI,CAAC,oBAAoB,EAAE,CAAC;SACvC;aACI,IAAI,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE;YACzB,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;YAEpD,qDAAqD;YACrD,IAAI,IAAI,CAAC,GAAG,CAAC,kBAAkB,IAAI,CAAC,aAAa,EAAE;gBAE/C,+FAA+F;gBAC/F,IAAI,IAAI,CAAC,GAAG,CAAC,UAAU,EACvB;oBACI,IAAI,CAAC,GAAG,CAAC,qBAAqB,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,oBAAoB,CAAC;oBAC1E,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC;oBAClD,IAAI,CAAC,GAAG,CAAC,cAAc,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC;iBACvD;gBACD,+EAA+E;qBAC1E,IAAI,aAAa;oBAClB,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;gBAEvD,KAAK,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;aACpC;iBAAM;gBACH,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,IAAa,CAAC;aAClC;SACJ;QAED,sCAAsC;QACtC,IAAI,YAAY;YACZ,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;QAE1C,OAAO,KAAK,CAAC;IACjB,CAAC;IAED;;;;;;OAMG;IACI,aAAa,CAAC,QAAgB;QACjC,IAAI,CAAC,GAAG,CAAC,qBAAqB,GAAG,QAAQ,CAAC;QAC1C,IAAI,CAAC,GAAG,CAAC,cAAc,GAAG,IAAI,CAAC,IAAI,CAAE,IAAI,CAAC,GAAG,CAAC,IAAc,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;QACtG,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,CAAC,CAAC;QAE3B,6GAA6G;QAC7G,IAAI,CAAC,GAAG,CAAC,kBAAkB,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACK,oBAAoB;QACxB,IAAI,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,IAAsB,CAAC;QACjD,IAAI,SAAS,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QAEnG,kBAAkB;QAClB,IAAI,CAAC,UAAU,CAAC,eAAe,EAAE,MAAM,IAAI,SAAS,IAAI,UAAU,CAAC,eAAe,EAAE,MAAM,IAAI,CAAC,CAAC,IAAI,SAAS,GAAG,CAAC,EAAE;YAC/G,IAAI,GAAG,GAAG,UAAU,CAAC,MAAM,CAAC;YAC5B,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;gBAEd,sEAAsE;gBAChE,GAAI,CAAC,MAAM,GAAG,IAAI,CAAC;gBAEzB,gJAAgJ;gBAChJ,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;YAC1C,CAAC,CAAC,CAAC;YACH,OAAO,GAAG,CAAC;SACd;aACI;YACD,IAAI,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC,CAAE,IAAI,CAAC,GAAG,CAAC,IAAY,CAAC,IAAI,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAE,IAAI,CAAC,GAAG,CAAC,IAAY,CAAC,KAAK,CAAC;YAC3H,IAAI,CAAC,GAAG;gBAAE,GAAG,GAAG,EAAE,CAAC;YACnB,kGAAkG;YAClG,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,GAAS,GAAI,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;YACjD,OAAO,GAAG,CAAC;SACd;IACL,CAAC;IAED,sIAAsI;IAC9H,iBAAiB;QACrB,IAAI,QAAQ,GAAU,EAAE,CAAC;QAEzB,gHAAgH;QAChH,qIAAqI;QACrI,+DAA+D;QAC/D,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU;YACpB,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;;YAE1G,OAAO,IAAI,CAAC,GAAG,CAAC,IAAa,CAAC;QAElC,uFAAuF;QACvF,IAAI,KAAK,GAAI,IAAI,CAAC,GAAG,CAAC,IAAc,CAAC;QACrC,IAAI,IAAI,CAAC,GAAG;YACR,KAAK,GAAG,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC,CAAC;QAEjD,qEAAqE;QACrE,KAAK,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,qBAAqB,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,IAAI,CAAC,GAAG,CAAC,qBAAqB,EAAE,CAAC,EAAE,EAAE;YAC5I,IAAI,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;gBACrB,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;SAC/B;QAED,OAAO,QAAQ,CAAC;IACpB,CAAC;IAED,0EAA0E;IACnE,wBAAwB,CAAC,KAAY;QACxC,IAAI,GAAG,GAAG,KAAK,CAAC;QAChB,IAAI,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC;YAC/B,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;gBAC7B,GAAG,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC1F,CAAC,CAAC,CAAC;QACP,OAAO,GAAG,CAAC;IACf,CAAC;CACJ","sourcesContent":["// Componenti\r\nimport { EsTableComponent } from \"../../components/es-table/es_table.component\"\r\n\r\n// Modelli\r\nimport { AppSearch } from \"../../domain/externals/appsearch/AppSearch\";\r\n\r\n// Utilities\r\nimport { UtilitiesHandler } from \"./UtilitiesHandler\";\r\n\r\n/** Classe che si occupa della gestione del recupero degli oggetti, paginazione e tutto ciò in cui gli elementi caricati vengono manipolati direttamente */\r\nexport class ItemsHandler {\r\n\r\n    /** @ignore Costruttore */\r\n    constructor(private est: EsTableComponent, private utilities: UtilitiesHandler) { }\r\n\r\n    /**\r\n     * In base alla modalità specificata (ArrayMode, ViewMode, ecc...) questo metodo recupera l'array di oggetti da bindare ad interfaccia\r\n     *\r\n     * @param {boolean} onlyselected [false] Indica di prendere solo gli oggetti selezionati\r\n     * @param {boolean} refreshPaging [false] Indica se aggiornare le informazioni di paginazione o meno\r\n     * @param {boolean} allIfPossible [false] Indica se prendere tutti gli oggetti quaora possibile, usato solo in ArrayMode\r\n     *\r\n     * @returns {any[]} Lista degli oggetti su cui effettuare il bind lato interfaccia\r\n     */\r\n    public getItemsByMode(onlyselected: boolean = false, refreshPaging: boolean = false, allIfPossible: boolean = false): any[] {\r\n        let items: any[] = [];\r\n\r\n        if ((this.est.viewMode && this.est.View instanceof AppSearch)) {\r\n            items = this.getViewItemsBySource();\r\n        }\r\n        else if (this.est.arrayMode) {\r\n            this.est.View.forEach(itm => { itm._item = true; });\r\n\r\n            // Se faccio dei raggruppamenti ignoro la paginazione\r\n            if (this.est.UseArrayModePaging && !allIfPossible) {\r\n\r\n                // Se sono in modalità array ma la ricerca dipende da una view devo riallineare gli itemperpage\r\n                if (this.est.SearchView)\r\n                {\r\n                    this.est.ArraymodeItemsPerPage = this.est.SearchView.itemsperpageoverride;\r\n                    this.est.arraymodePage = this.est.SearchView.page;\r\n                    this.est.arraymodePages = this.est.SearchView.pages;\r\n                }\r\n                // Devo chiamare il refresh page solo se vengo richiamato da un binding esterno\r\n                else if (refreshPaging)\r\n                    this.refreshPaging(this.est.ArraymodeItemsPerPage);\r\n\r\n                items = this.adaptViewToPaging();\r\n            } else {\r\n                items = this.est.View as any[];\r\n            }\r\n        }\r\n\r\n        // Se voglio solo i selezionati filtro\r\n        if (onlyselected)\r\n            return items.filter(t => t._selected);\r\n\r\n        return items;\r\n    }\r\n\r\n    /**\r\n     * Metodo per effettuare il refresh della paginazione sul cambiamento degli oggetti da visualizzare in una singola pagina.\r\n     *\r\n     * Vale solo per la modalità Array\r\n     *\r\n     * @param {number} pageSize Dimensione della pagina\r\n     */\r\n    public refreshPaging(pageSize: number) {\r\n        this.est.ArraymodeItemsPerPage = pageSize;\r\n        this.est.arraymodePages = Math.ceil((this.est.View as any[]).length / this.est.ArraymodeItemsPerPage);\r\n        this.est.arraymodePage = 1;\r\n\r\n        // Riforzo il writevalue in modo che il codice passi dalla gestione come se fosse fatta ripartire una ricerca\r\n        this.est.internalWriteValue();\r\n    }\r\n\r\n    /**\r\n     * Ottiene gli oggetti in base alla sorgente\r\n     */\r\n    private getViewItemsBySource(): any[] {\r\n        let castedView = this.est.View as AppSearch<any>;\r\n        let groupKeys = castedView.groupings ? castedView.groupings.filter(t => !t.aggregation).length : 0;\r\n\r\n        //Gruppi intermedi\r\n        if ((castedView.requestedgroups?.length != groupKeys || castedView.requestedgroups?.length == 0) && groupKeys > 0) {\r\n            let ret = castedView.groups;\r\n            ret.forEach(itm => {\r\n\r\n                // Setto variabile interna per capire che questo è in realtà un gruppo\r\n                (<any>itm)._group = true;\r\n\r\n                // Le informazioni passate come lista le metto dentro a una cache per velocizzarne l'accesso quando devo tirare fuori il display della proprietà\r\n                this.utilities.cacheAggregations(itm);\r\n            });\r\n            return ret;\r\n        }\r\n        else {\r\n            let ret = this.est.ItemSourceProperty ? (this.est.View as any)[this.est.ItemSourceProperty] : (this.est.View as any).items;\r\n            if (!ret) ret = [];\r\n            // Setto variabile interna per specificare che questo è un elemento normale, non un gruppo o altro\r\n            ret.forEach(itm => { (<any>itm)._item = true; });\r\n            return ret;\r\n        }\r\n    }\r\n\r\n    /** Genera le informazioni di paginazione e taglia la View in modalità array per mostrare solo gli oggetti della pagina specificata */\r\n    private adaptViewToPaging() {\r\n        let tmpItems: any[] = [];\r\n\r\n        // Se ho una search view l'array pulsanti viene calcolato da lei, non devo prendere quello della modalità array,\r\n        // inoltre non ho bisogno di fare ragionamenti su quanti elementi ci sono e sulla pagina, dato che viene tutto gestito esternamente, \r\n        // unendo al risultato della view tutti gli oggetti addizionali\r\n        if (!this.est.SearchView)\r\n            this.est.arrayPulsanti = this.utilities.getPagesArray(6, this.est.arraymodePage, this.est.arraymodePages);\r\n        else\r\n            return this.est.View as any[];\r\n\r\n        // Applico eventuali oridnamenti lato Array prima di tirare fuori la pagina selezionata\r\n        let items = (this.est.View as any[]);\r\n        if (this.est)\r\n            items = this.arrayModeReviewOrderings(items);\r\n\r\n        // Poi per tutti i valori dopo compresi fra la pagina - 1 e la pagina\r\n        for (let i = ((this.est.arraymodePage - 1) * this.est.ArraymodeItemsPerPage); i < this.est.arraymodePage * this.est.ArraymodeItemsPerPage; i++) {\r\n            if (i <= items.length - 1)\r\n                tmpItems.push(items[i]);\r\n        }\r\n\r\n        return tmpItems;\r\n    }\r\n\r\n    /** Se in modalità array applica gli ordinamenti ASC-DESC delle colonne */\r\n    public arrayModeReviewOrderings(items: any[]): any[] {\r\n        let tmp = items;\r\n        if (this.est.arrayOrders.length > 0)\r\n            this.est.arrayOrders.forEach(t => {\r\n                tmp = tmp.sort((a, b) => (a[t.id] > b[t.id] ? 1 : -1) * (t.order == 'DESC' ? -1 : 1));\r\n            });\r\n        return tmp;\r\n    }\r\n}\r\n"]}
+// Modelli
+import { AppSearch } from "../../domain/externals/appsearch/AppSearch";
+/** Classe che si occupa della gestione del recupero degli oggetti, paginazione e tutto ciò in cui gli elementi caricati vengono manipolati direttamente */
+export class ItemsHandler {
+    /** @ignore Costruttore */
+    constructor(est, utilities) {
+        this.est = est;
+        this.utilities = utilities;
+    }
+    /**
+     * In base alla modalità specificata (ArrayMode, ViewMode, ecc...) questo metodo recupera l'array di oggetti da bindare ad interfaccia
+     *
+     * @param {boolean} onlyselected [false] Indica di prendere solo gli oggetti selezionati
+     * @param {boolean} refreshPaging [false] Indica se aggiornare le informazioni di paginazione o meno
+     * @param {boolean} allIfPossible [false] Indica se prendere tutti gli oggetti quaora possibile, usato solo in ArrayMode
+     *
+     * @returns {any[]} Lista degli oggetti su cui effettuare il bind lato interfaccia
+     */
+    getItemsByMode(onlyselected = false, refreshPaging = false, allIfPossible = false) {
+        let items = [];
+        if ((this.est.viewMode && this.est.View instanceof AppSearch)) {
+            items = this.getViewItemsBySource();
+        }
+        else if (this.est.arrayMode) {
+            this.est.View.forEach(itm => { itm._item = true; });
+            // Se faccio dei raggruppamenti ignoro la paginazione
+            if (this.est.UseArrayModePaging && !allIfPossible) {
+                // Se sono in modalità array ma la ricerca dipende da una view devo riallineare gli itemperpage
+                if (this.est.SearchView) {
+                    this.est.ArraymodeItemsPerPage = this.est.SearchView.itemsperpageoverride;
+                    this.est.arraymodePage = this.est.SearchView.page;
+                    this.est.arraymodePages = this.est.SearchView.pages;
+                }
+                // Devo chiamare il refresh page solo se vengo richiamato da un binding esterno
+                else if (refreshPaging)
+                    this.refreshPaging(this.est.ArraymodeItemsPerPage);
+                items = this.adaptViewToPaging();
+            }
+            else {
+                items = this.est.View;
+            }
+        }
+        // Se voglio solo i selezionati filtro
+        if (onlyselected)
+            return items.filter(t => t._selected);
+        return items;
+    }
+    /**
+     * Metodo per effettuare il refresh della paginazione sul cambiamento degli oggetti da visualizzare in una singola pagina.
+     *
+     * Vale solo per la modalità Array
+     *
+     * @param {number} pageSize Dimensione della pagina
+     */
+    refreshPaging(pageSize) {
+        this.est.ArraymodeItemsPerPage = pageSize;
+        this.est.arraymodePages = Math.ceil(this.est.View.length / this.est.ArraymodeItemsPerPage);
+        this.est.arraymodePage = 1;
+        // Riforzo il writevalue in modo che il codice passi dalla gestione come se fosse fatta ripartire una ricerca
+        this.est.internalWriteValue();
+    }
+    /**
+     * Ottiene gli oggetti in base alla sorgente
+     */
+    getViewItemsBySource() {
+        let castedView = this.est.View;
+        let groupKeys = castedView.groupings ? castedView.groupings.filter(t => !t.aggregation).length : 0;
+        //Gruppi intermedi
+        if ((castedView.requestedgroups?.length != groupKeys || castedView.requestedgroups?.length == 0) && groupKeys > 0) {
+            let ret = castedView.groups;
+            ret.forEach(itm => {
+                // Setto variabile interna per capire che questo è in realtà un gruppo
+                itm._group = true;
+                // Le informazioni passate come lista le metto dentro a una cache per velocizzarne l'accesso quando devo tirare fuori il display della proprietà
+                this.utilities.cacheAggregations(itm);
+            });
+            return ret;
+        }
+        else {
+            let ret = this.est.ItemSourceProperty ? this.est.View[this.est.ItemSourceProperty] : this.est.View.items;
+            if (!ret)
+                ret = [];
+            // Setto variabile interna per specificare che questo è un elemento normale, non un gruppo o altro
+            ret.forEach(itm => { itm._item = true; });
+            return ret;
+        }
+    }
+    /** Genera le informazioni di paginazione e taglia la View in modalità array per mostrare solo gli oggetti della pagina specificata */
+    adaptViewToPaging() {
+        let tmpItems = [];
+        // Se ho una search view l'array pulsanti viene calcolato da lei, non devo prendere quello della modalità array,
+        // inoltre non ho bisogno di fare ragionamenti su quanti elementi ci sono e sulla pagina, dato che viene tutto gestito esternamente, 
+        // unendo al risultato della view tutti gli oggetti addizionali
+        if (!this.est.SearchView)
+            this.est.arrayPulsanti = this.utilities.getPagesArray(6, this.est.arraymodePage, this.est.arraymodePages);
+        else
+            return this.est.View;
+        // Applico eventuali oridnamenti lato Array prima di tirare fuori la pagina selezionata
+        let items = this.est.View;
+        if (this.est)
+            items = this.arrayModeReviewOrderings(items);
+        // Poi per tutti i valori dopo compresi fra la pagina - 1 e la pagina
+        for (let i = ((this.est.arraymodePage - 1) * this.est.ArraymodeItemsPerPage); i < this.est.arraymodePage * this.est.ArraymodeItemsPerPage; i++) {
+            if (i <= items.length - 1)
+                tmpItems.push(items[i]);
+        }
+        return tmpItems;
+    }
+    /** Se in modalità array applica gli ordinamenti ASC-DESC delle colonne */
+    arrayModeReviewOrderings(items) {
+        let tmp = items;
+        if (this.est.arrayOrders.length > 0)
+            this.est.arrayOrders.forEach(t => {
+                tmp = tmp.sort((a, b) => (a[t.id] > b[t.id] ? 1 : -1) * (t.order == 'DESC' ? -1 : 1));
+            });
+        return tmp;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ItemsHandler.js","sourceRoot":"","sources":["../../../../../../projects/es-table/src/lib/core/handlers/ItemsHandler.ts"],"names":[],"mappings":"AAGA,UAAU;AACV,OAAO,EAAE,SAAS,EAAE,MAAM,4CAA4C,CAAC;AAKvE,2JAA2J;AAC3J,MAAM,OAAO,YAAY;IAErB,0BAA0B;IAC1B,YAAoB,GAAqB,EAAU,SAA2B;QAA1D,QAAG,GAAH,GAAG,CAAkB;QAAU,cAAS,GAAT,SAAS,CAAkB;IAAI,CAAC;IAEnF;;;;;;;;OAQG;IACI,cAAc,CAAC,eAAwB,KAAK,EAAE,gBAAyB,KAAK,EAAE,gBAAyB,KAAK;QAC/G,IAAI,KAAK,GAAU,EAAE,CAAC;QAEtB,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,YAAY,SAAS,CAAC,EAAE,CAAC;YAC5D,KAAK,GAAG,IAAI,CAAC,oBAAoB,EAAE,CAAC;QACxC,CAAC;aACI,IAAI,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC;YAC1B,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;YAEpD,qDAAqD;YACrD,IAAI,IAAI,CAAC,GAAG,CAAC,kBAAkB,IAAI,CAAC,aAAa,EAAE,CAAC;gBAEhD,+FAA+F;gBAC/F,IAAI,IAAI,CAAC,GAAG,CAAC,UAAU,EACvB,CAAC;oBACG,IAAI,CAAC,GAAG,CAAC,qBAAqB,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,oBAAoB,CAAC;oBAC1E,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC;oBAClD,IAAI,CAAC,GAAG,CAAC,cAAc,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC;gBACxD,CAAC;gBACD,+EAA+E;qBAC1E,IAAI,aAAa;oBAClB,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;gBAEvD,KAAK,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACrC,CAAC;iBAAM,CAAC;gBACJ,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,IAAa,CAAC;YACnC,CAAC;QACL,CAAC;QAED,sCAAsC;QACtC,IAAI,YAAY;YACZ,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;QAE1C,OAAO,KAAK,CAAC;IACjB,CAAC;IAED;;;;;;OAMG;IACI,aAAa,CAAC,QAAgB;QACjC,IAAI,CAAC,GAAG,CAAC,qBAAqB,GAAG,QAAQ,CAAC;QAC1C,IAAI,CAAC,GAAG,CAAC,cAAc,GAAG,IAAI,CAAC,IAAI,CAAE,IAAI,CAAC,GAAG,CAAC,IAAc,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;QACtG,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,CAAC,CAAC;QAE3B,6GAA6G;QAC7G,IAAI,CAAC,GAAG,CAAC,kBAAkB,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACK,oBAAoB;QACxB,IAAI,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,IAAsB,CAAC;QACjD,IAAI,SAAS,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QAEnG,kBAAkB;QAClB,IAAI,CAAC,UAAU,CAAC,eAAe,EAAE,MAAM,IAAI,SAAS,IAAI,UAAU,CAAC,eAAe,EAAE,MAAM,IAAI,CAAC,CAAC,IAAI,SAAS,GAAG,CAAC,EAAE,CAAC;YAChH,IAAI,GAAG,GAAG,UAAU,CAAC,MAAM,CAAC;YAC5B,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;gBAEd,sEAAsE;gBAChE,GAAI,CAAC,MAAM,GAAG,IAAI,CAAC;gBAEzB,gJAAgJ;gBAChJ,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;YAC1C,CAAC,CAAC,CAAC;YACH,OAAO,GAAG,CAAC;QACf,CAAC;aACI,CAAC;YACF,IAAI,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC,CAAE,IAAI,CAAC,GAAG,CAAC,IAAY,CAAC,IAAI,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAE,IAAI,CAAC,GAAG,CAAC,IAAY,CAAC,KAAK,CAAC;YAC3H,IAAI,CAAC,GAAG;gBAAE,GAAG,GAAG,EAAE,CAAC;YACnB,kGAAkG;YAClG,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,GAAS,GAAI,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;YACjD,OAAO,GAAG,CAAC;QACf,CAAC;IACL,CAAC;IAED,sIAAsI;IAC9H,iBAAiB;QACrB,IAAI,QAAQ,GAAU,EAAE,CAAC;QAEzB,gHAAgH;QAChH,qIAAqI;QACrI,+DAA+D;QAC/D,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU;YACpB,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;;YAE1G,OAAO,IAAI,CAAC,GAAG,CAAC,IAAa,CAAC;QAElC,uFAAuF;QACvF,IAAI,KAAK,GAAI,IAAI,CAAC,GAAG,CAAC,IAAc,CAAC;QACrC,IAAI,IAAI,CAAC,GAAG;YACR,KAAK,GAAG,IAAI,CAAC,wBAAwB,CAAC,KAAK,CAAC,CAAC;QAEjD,qEAAqE;QACrE,KAAK,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,qBAAqB,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,IAAI,CAAC,GAAG,CAAC,qBAAqB,EAAE,CAAC,EAAE,EAAE,CAAC;YAC7I,IAAI,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;gBACrB,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAChC,CAAC;QAED,OAAO,QAAQ,CAAC;IACpB,CAAC;IAED,0EAA0E;IACnE,wBAAwB,CAAC,KAAY;QACxC,IAAI,GAAG,GAAG,KAAK,CAAC;QAChB,IAAI,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC;YAC/B,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;gBAC7B,GAAG,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC1F,CAAC,CAAC,CAAC;QACP,OAAO,GAAG,CAAC;IACf,CAAC;CACJ","sourcesContent":["// Componenti\r\nimport { EsTableComponent } from \"../../components/es-table/es_table.component\"\r\n\r\n// Modelli\r\nimport { AppSearch } from \"../../domain/externals/appsearch/AppSearch\";\r\n\r\n// Utilities\r\nimport { UtilitiesHandler } from \"./UtilitiesHandler\";\r\n\r\n/** Classe che si occupa della gestione del recupero degli oggetti, paginazione e tutto ciò in cui gli elementi caricati vengono manipolati direttamente */\r\nexport class ItemsHandler {\r\n\r\n    /** @ignore Costruttore */\r\n    constructor(private est: EsTableComponent, private utilities: UtilitiesHandler) { }\r\n\r\n    /**\r\n     * In base alla modalità specificata (ArrayMode, ViewMode, ecc...) questo metodo recupera l'array di oggetti da bindare ad interfaccia\r\n     *\r\n     * @param {boolean} onlyselected [false] Indica di prendere solo gli oggetti selezionati\r\n     * @param {boolean} refreshPaging [false] Indica se aggiornare le informazioni di paginazione o meno\r\n     * @param {boolean} allIfPossible [false] Indica se prendere tutti gli oggetti quaora possibile, usato solo in ArrayMode\r\n     *\r\n     * @returns {any[]} Lista degli oggetti su cui effettuare il bind lato interfaccia\r\n     */\r\n    public getItemsByMode(onlyselected: boolean = false, refreshPaging: boolean = false, allIfPossible: boolean = false): any[] {\r\n        let items: any[] = [];\r\n\r\n        if ((this.est.viewMode && this.est.View instanceof AppSearch)) {\r\n            items = this.getViewItemsBySource();\r\n        }\r\n        else if (this.est.arrayMode) {\r\n            this.est.View.forEach(itm => { itm._item = true; });\r\n\r\n            // Se faccio dei raggruppamenti ignoro la paginazione\r\n            if (this.est.UseArrayModePaging && !allIfPossible) {\r\n\r\n                // Se sono in modalità array ma la ricerca dipende da una view devo riallineare gli itemperpage\r\n                if (this.est.SearchView)\r\n                {\r\n                    this.est.ArraymodeItemsPerPage = this.est.SearchView.itemsperpageoverride;\r\n                    this.est.arraymodePage = this.est.SearchView.page;\r\n                    this.est.arraymodePages = this.est.SearchView.pages;\r\n                }\r\n                // Devo chiamare il refresh page solo se vengo richiamato da un binding esterno\r\n                else if (refreshPaging)\r\n                    this.refreshPaging(this.est.ArraymodeItemsPerPage);\r\n\r\n                items = this.adaptViewToPaging();\r\n            } else {\r\n                items = this.est.View as any[];\r\n            }\r\n        }\r\n\r\n        // Se voglio solo i selezionati filtro\r\n        if (onlyselected)\r\n            return items.filter(t => t._selected);\r\n\r\n        return items;\r\n    }\r\n\r\n    /**\r\n     * Metodo per effettuare il refresh della paginazione sul cambiamento degli oggetti da visualizzare in una singola pagina.\r\n     *\r\n     * Vale solo per la modalità Array\r\n     *\r\n     * @param {number} pageSize Dimensione della pagina\r\n     */\r\n    public refreshPaging(pageSize: number) {\r\n        this.est.ArraymodeItemsPerPage = pageSize;\r\n        this.est.arraymodePages = Math.ceil((this.est.View as any[]).length / this.est.ArraymodeItemsPerPage);\r\n        this.est.arraymodePage = 1;\r\n\r\n        // Riforzo il writevalue in modo che il codice passi dalla gestione come se fosse fatta ripartire una ricerca\r\n        this.est.internalWriteValue();\r\n    }\r\n\r\n    /**\r\n     * Ottiene gli oggetti in base alla sorgente\r\n     */\r\n    private getViewItemsBySource(): any[] {\r\n        let castedView = this.est.View as AppSearch<any>;\r\n        let groupKeys = castedView.groupings ? castedView.groupings.filter(t => !t.aggregation).length : 0;\r\n\r\n        //Gruppi intermedi\r\n        if ((castedView.requestedgroups?.length != groupKeys || castedView.requestedgroups?.length == 0) && groupKeys > 0) {\r\n            let ret = castedView.groups;\r\n            ret.forEach(itm => {\r\n\r\n                // Setto variabile interna per capire che questo è in realtà un gruppo\r\n                (<any>itm)._group = true;\r\n\r\n                // Le informazioni passate come lista le metto dentro a una cache per velocizzarne l'accesso quando devo tirare fuori il display della proprietà\r\n                this.utilities.cacheAggregations(itm);\r\n            });\r\n            return ret;\r\n        }\r\n        else {\r\n            let ret = this.est.ItemSourceProperty ? (this.est.View as any)[this.est.ItemSourceProperty] : (this.est.View as any).items;\r\n            if (!ret) ret = [];\r\n            // Setto variabile interna per specificare che questo è un elemento normale, non un gruppo o altro\r\n            ret.forEach(itm => { (<any>itm)._item = true; });\r\n            return ret;\r\n        }\r\n    }\r\n\r\n    /** Genera le informazioni di paginazione e taglia la View in modalità array per mostrare solo gli oggetti della pagina specificata */\r\n    private adaptViewToPaging() {\r\n        let tmpItems: any[] = [];\r\n\r\n        // Se ho una search view l'array pulsanti viene calcolato da lei, non devo prendere quello della modalità array,\r\n        // inoltre non ho bisogno di fare ragionamenti su quanti elementi ci sono e sulla pagina, dato che viene tutto gestito esternamente, \r\n        // unendo al risultato della view tutti gli oggetti addizionali\r\n        if (!this.est.SearchView)\r\n            this.est.arrayPulsanti = this.utilities.getPagesArray(6, this.est.arraymodePage, this.est.arraymodePages);\r\n        else\r\n            return this.est.View as any[];\r\n\r\n        // Applico eventuali oridnamenti lato Array prima di tirare fuori la pagina selezionata\r\n        let items = (this.est.View as any[]);\r\n        if (this.est)\r\n            items = this.arrayModeReviewOrderings(items);\r\n\r\n        // Poi per tutti i valori dopo compresi fra la pagina - 1 e la pagina\r\n        for (let i = ((this.est.arraymodePage - 1) * this.est.ArraymodeItemsPerPage); i < this.est.arraymodePage * this.est.ArraymodeItemsPerPage; i++) {\r\n            if (i <= items.length - 1)\r\n                tmpItems.push(items[i]);\r\n        }\r\n\r\n        return tmpItems;\r\n    }\r\n\r\n    /** Se in modalità array applica gli ordinamenti ASC-DESC delle colonne */\r\n    public arrayModeReviewOrderings(items: any[]): any[] {\r\n        let tmp = items;\r\n        if (this.est.arrayOrders.length > 0)\r\n            this.est.arrayOrders.forEach(t => {\r\n                tmp = tmp.sort((a, b) => (a[t.id] > b[t.id] ? 1 : -1) * (t.order == 'DESC' ? -1 : 1));\r\n            });\r\n        return tmp;\r\n    }\r\n}\r\n"]}

package/esm2022/lib/core/handlers/ReportModeHandler.mjs

@@ -1,60 +1,60 @@
-import { EsThDirective } from "../../directives/es_th.directive";
-import { EsTdDirective } from "../../directives/es_td.directive";
-/** Classe che gestisce la modalità Report dell'es-table utilizzata nel Metering */
-export class ReportModeHandler {
-    /** @ignore Costruttore */
-    constructor(est, utilities) {
-        this.est = est;
-        this.utilities = utilities;
-    }
-    /** Metodo che si occupa di gestire la grafica della tabella in base alle informazioni di ordinamento colonne e paginazione contenuti nel modello */
-    reviewReportBindings() {
-        // Allineo le informazioni su eventuali ordinamenti fatti precedentemente
-        if (this.est.View.orders && this.est.View.orders.length > 0) {
-            this.est.View.orders.forEach(t => {
-                this.est.View.report_columns.filter(c => c.id == t.column)[0].order = t.order;
-            });
-        }
-        // Recupero il count precedente se serve
-        let count = this.est.View.objectcount;
-        if (count != -2)
-            this.est.previousCount = count;
-        else if (count == -2)
-            count = this.est.previousCount;
-        let ipp = (this.est.View.itemsperpageoverride || 15);
-        this.est.View.pages = Math.ceil(count / ipp);
-        this.est.arrayPulsanti = this.utilities.getPagesArray(6, this.est.View.page, this.est.View.pages);
-    }
-    /**
-     * Data una AppSearch questo metodo genera la lista di th e td che si possono collegare al giro standard.
-     * Se non ci fosse questo passaggio intermedio la gestione della modalità report sarebbe 100% custom,
-     * come poi lo era prima che la facessi passare dal giro che fanno tutte le altre modalità
-     *
-     * @param {AppSearch<any>} view View in modalità report contenente le informazioni sulle colonne
-     *
-     * @returns {{ ths: EsThDirective[], tds: EsTdDirective[] }} Lista di direttive per gli header e per il body
-     */
-    generateThsAndTdsFromView(view) {
-        var ret = { ths: [], tds: [] };
-        // Ordinamento per ora commentato... non vorrebbe mi fuckappasse tutto
-        //view.report_columns.sort((c1, c2) => c1.seq || 0 - c2.seq || 0);
-        for (let i = 0; i < view.report_columns.length; i++) {
-            let clm = view.report_columns[i];
-            var th = new EsThDirective(null);
-            th.th = clm.id;
-            th.thStaticContent = clm.description || null;
-            th.thBackgroundColor = clm.color;
-            th.thAlignment = clm.alignment;
-            th.thFormat = clm.format;
-            var td = new EsTdDirective(null);
-            td.td = clm.id;
-            td.tdPropertyAccessor = i.toString();
-            td.tdAlignment = clm.alignment;
-            td.tdFormat = clm.format;
-            ret.ths.push(th);
-            ret.tds.push(td);
-        }
-        return ret;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,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
+import { EsThDirective } from "../../directives/es_th.directive";
+import { EsTdDirective } from "../../directives/es_td.directive";
+/** Classe che gestisce la modalità Report dell'es-table utilizzata nel Metering */
+export class ReportModeHandler {
+    /** @ignore Costruttore */
+    constructor(est, utilities) {
+        this.est = est;
+        this.utilities = utilities;
+    }
+    /** Metodo che si occupa di gestire la grafica della tabella in base alle informazioni di ordinamento colonne e paginazione contenuti nel modello */
+    reviewReportBindings() {
+        // Allineo le informazioni su eventuali ordinamenti fatti precedentemente
+        if (this.est.View.orders && this.est.View.orders.length > 0) {
+            this.est.View.orders.forEach(t => {
+                this.est.View.report_columns.filter(c => c.id == t.column)[0].order = t.order;
+            });
+        }
+        // Recupero il count precedente se serve
+        let count = this.est.View.objectcount;
+        if (count != -2)
+            this.est.previousCount = count;
+        else if (count == -2)
+            count = this.est.previousCount;
+        let ipp = (this.est.View.itemsperpageoverride || 15);
+        this.est.View.pages = Math.ceil(count / ipp);
+        this.est.arrayPulsanti = this.utilities.getPagesArray(6, this.est.View.page, this.est.View.pages);
+    }
+    /**
+     * Data una AppSearch questo metodo genera la lista di th e td che si possono collegare al giro standard.
+     * Se non ci fosse questo passaggio intermedio la gestione della modalità report sarebbe 100% custom,
+     * come poi lo era prima che la facessi passare dal giro che fanno tutte le altre modalità
+     *
+     * @param {AppSearch<any>} view View in modalità report contenente le informazioni sulle colonne
+     *
+     * @returns {{ ths: EsThDirective[], tds: EsTdDirective[] }} Lista di direttive per gli header e per il body
+     */
+    generateThsAndTdsFromView(view) {
+        var ret = { ths: [], tds: [] };
+        // Ordinamento per ora commentato... non vorrebbe mi fuckappasse tutto
+        //view.report_columns.sort((c1, c2) => c1.seq || 0 - c2.seq || 0);
+        for (let i = 0; i < view.report_columns.length; i++) {
+            let clm = view.report_columns[i];
+            var th = new EsThDirective(null);
+            th.th = clm.id;
+            th.thStaticContent = clm.description || null;
+            th.thBackgroundColor = clm.color;
+            th.thAlignment = clm.alignment;
+            th.thFormat = clm.format;
+            var td = new EsTdDirective(null);
+            td.td = clm.id;
+            td.tdPropertyAccessor = i.toString();
+            td.tdAlignment = clm.alignment;
+            td.tdFormat = clm.format;
+            ret.ths.push(th);
+            ret.tds.push(td);
+        }
+        return ret;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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