@esfaenza/es-table 11.2.22-beta3 → 11.2.22-beta7

package/esm2015/lib/core/handlers/classes/DynamicModeHandler.js

@@ -0,0 +1,63 @@
+// Dominio
+import { EsTableColumnsDefinition } from "../../../domain";
+/** Classe contenente le gestioni particolari della modalità dinamica dell'es-table */
+export class DynamicModeHandler {
+    constructor(est) {
+        this.est = est;
+    }
+    /**
+     * Metodo di supporto alla creazione di un router link parametrizzato all'oggetto corrente utilizzato nella modalità dinamica
+     *
+     * @param {string} path Path su cui navigare con eventuali parametri riferiti all'oggetto cotnestuale come {0}, {1}, ecc...
+     * @param {string[]} parameterProps Lista posizionale delle proprietà a cui bindare i riferimenti del parametro **path**
+     * Es. Il valore dela proprietà all'indice 0 di questo array verrà sostituita al valore {0} del parametro **path**
+     * @param {GenericItem} item Oggetto generico collegato a questo contesto
+     *
+     * @returns {any} Router link generato in base al parametri
+     */
+    generateRouterLink(path, parameterProps, item) {
+        if (this.est.DynamicTableRouterLinkCache[item._hash + path]) {
+            return this.est.DynamicTableRouterLinkCache[item._hash + path];
+        }
+        else {
+            let link = this.getRouterLink(path, parameterProps, item);
+            this.est.DynamicTableRouterLinkCache[item._hash + path] = link;
+            return link;
+        }
+    }
+    /**
+     * Crea un router link
+     *
+     * @param {string} path Path su cui navigare con eventuali parametri riferiti all'oggetto cotnestuale come {0}, {1}, ecc...
+     * @param {string[]} pars Lista posizionale delle proprietà a cui bindare i riferimenti del parametro **path**
+     * Es. Il valore dela proprietà all'indice 0 di questo array verrà sostituita al valore {0} del parametro **path**
+     * @param {GenericItem} item Oggetto generico collegato a questo contesto
+     *
+     * @returns {any} Router link generato in base al parametri
+     */
+    getRouterLink(path, pars, item) {
+        for (let i = 0; i < pars.length; i++)
+            path = path.replace('{' + i + '}', item.properties[pars[i]]);
+        path = path.replace(/'/g, '"').replace(/ /g, '');
+        return JSON.parse(path);
+    }
+    /** Se non ho l'Input **DynamicRowColumnsDefinition** in modalità dinamica lo riempio con il default nome della colonna = testo della colonna */
+    eventuallyReviewDynamicColumns() {
+        // Senza oggetti esco
+        if (!this.est.TMPBoundSource || this.est.TMPBoundSource.length == 0)
+            return;
+        var useGenericItems = !!this.est.TMPBoundSource[0]["properties"];
+        if (!useGenericItems || (!this.est.FirstBind && this.est.DynamicRowColumnsDefinition && this.est.DynamicRowColumnsDefinition.length > 0))
+            return;
+        if ((!this.est.DynamicRowColumnsDefinition || this.est.DynamicRowColumnsDefinition.length == 0)) {
+            var props = this.est.TMPBoundSource[0]["properties"];
+            this.est.DynamicRowColumnsDefinition = [];
+            for (let key in props)
+                this.est.DynamicRowColumnsDefinition.push(new EsTableColumnsDefinition(key, key));
+            this.est.UserDefinedDynamicCols = false;
+        }
+        else
+            this.est.UserDefinedDynamicCols = true;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/core/handlers/classes/ExportHandler.js

@@ -0,0 +1,41 @@
+export class ExportHandler {
+    constructor(est, expExts, msgExts) {
+        this.est = est;
+        this.expExts = expExts;
+        this.msgExts = msgExts;
+    }
+    /**
+     * Effettua l'esportazione dei dati
+     *
+     * @param {string} format Formato di esportazione. Letto solo in modalità Report della tabella
+     */
+    tryExport(format) {
+        if (!this.est.ExportFunction)
+            return;
+        if (this.est.reportMode)
+            this.est.ExportFunction(format);
+        else
+            this.est.ExportFunction((data, cancel = false) => {
+                if (cancel)
+                    return;
+                if (data.length == 0) {
+                    this.msgExts.simpleWarning(this.est.lc.loc("Cannot export an empty dataset"));
+                    return;
+                }
+                this.setupExport(data);
+                this.est.cdr.detectChanges();
+                setTimeout(() => { this.est.exportDownloader.nativeElement.click(); });
+            });
+    }
+    /**
+     * Metodo che effettivamente genera gli header e i dati per l'esportazione con **ngx-csv**
+     *
+     * @param {any[]} items Oggetti da esportare
+     */
+    setupExport(items) {
+        let drcd = this.est.DynamicRowColumnsDefinition;
+        this.est.headers = drcd && drcd.length > 0 ? this.expExts.setupForGenericExport(items, drcd.map(t => { return { label: t.description, key: t.propertyName, order: t.columnOrder }; })) : this.expExts.setupForExport(items);
+        this.est.data = items;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/core/handlers/classes/HierarchyModeHandler.js

@@ -0,0 +1,134 @@
+export class HierarchyModeHandler {
+    constructor(est) {
+        this.est = est;
+    }
+    /**
+     * Data una lista di oggetti assegno il livello gerarchico rispetto alla lista di oggetti passata
+     *
+     * @param {any[]} objs Lista di oggetti a cui aggiungere l'informazione del livello gerarchico
+     */
+    assignHierarchyLevels(objs) {
+        // Casistica input nullo
+        if (!objs || !objs.length)
+            return;
+        //Se mancano entrambe le info le cerco di valorizzare in automatico coi default "parentid" e "id" (posto che le props esistano nell'oggetto)
+        if (!this.est.ParentKey && !this.est.OwnKey) {
+            if (objs[0]['parentid'] !== undefined)
+                this.est.ParentKey = 'parentid';
+            if (objs[0]['id'] !== undefined)
+                this.est.OwnKey = 'id';
+        }
+        //Check finale per assicurarmi che le props ci siano
+        if (!this.est.ParentKey || !this.est.OwnKey) {
+            console.error('Per utilizzare il sistema in modalità gerarchica è obbligatorio specificare sia ParentKey che OwnKey. Fallback a sistema non gerarchico');
+            return;
+        }
+        // Valorizzazione campi level, expanded, e visible per ogni item
+        let currentLevel = 1;
+        let assigned = 0;
+        do {
+            assigned = this.assignLevel(objs, currentLevel);
+            currentLevel++;
+        } while (assigned > 0);
+        // butto su lato html e poi me la gioco là con padding = 20 * (level - 1) per far capire il diverso livello
+    }
+    /**
+     * Per ognuno degli oggetti passati gli assegna un livello di gerarchia in base a **ParentKey** e **OwnKey**
+     *
+     * @param {any[]} objs Oggetti a cui assegnare il livello di gerarchia
+     * @param {number} levelToAssign Livello che sta assegnando attualmente questa iterazione (dato che è ricorsiva)
+     *
+     * @returns {number} Numero di oggetti a cui è stato assegnato un livello gerarchico
+     */
+    assignLevel(objs, levelToAssign) {
+        let assigned = 0;
+        for (let i = 0; i < objs.length; i++) {
+            let obj = objs[i];
+            // Se la parentKey non è valorizzata, questo è il livello 0 (1... perché gli 0 son perciolosi)
+            if (!obj[this.est.ParentKey] && levelToAssign == 1) {
+                obj._level = 1;
+                obj._visible = true;
+                obj._expanded = this.est.StartsExpanded;
+                assigned++;
+                continue;
+            }
+            // Per i livelli superiore al primo
+            if (obj[this.est.ParentKey] && levelToAssign > 1) {
+                // trovo il parent
+                for (let p = 0; p < objs.length; p++) {
+                    let possibleParent = objs[p];
+                    // Trovato il parent dell'item, assegno all'item il livello giusto
+                    if (possibleParent[this.est.OwnKey] == obj[this.est.ParentKey] && possibleParent._level == levelToAssign - 1) {
+                        obj._level = levelToAssign;
+                        // So che questo item ha un parent. Ribadisco che il parent è espanso in base alle impostazione e stessa logica
+                        // per la visibilità del figlio
+                        possibleParent._expanded = this.est.StartsExpanded;
+                        possibleParent.parent = true;
+                        obj._visible = this.est.StartsExpanded;
+                        assigned++;
+                        break;
+                    }
+                }
+            }
+        }
+        return assigned;
+    }
+    /**
+     * Funzione che permette di effettuare l'espansione di un parent quando la tabella funziona in modalità gerarchica
+     *
+     * @param {string} key Chiave del parent da espandere
+     */
+    expandParent(key) {
+        for (let i = 0; i < this.est.boundSource.length; i++) {
+            let obj = this.est.boundSource[i];
+            // Trovo il parent con quell'id e lo espando
+            if (obj[this.est.OwnKey] == key) {
+                obj._expanded = true;
+                for (let ic = 0; ic < this.est.boundSource.length; ic++) {
+                    let child = this.est.boundSource[ic];
+                    // Trovo tutti i child di quel parent e li rendo visibili
+                    if (child[this.est.ParentKey] == key)
+                        child._visible = true;
+                }
+                return;
+            }
+        }
+    }
+    /**
+     * Funzione che permette di effettuare il collapse di un parent quando la tabella funziona in modalità gerarchica
+     *
+     * @param {string} key Chiave del parent da collassare
+     */
+    collapseParent(key) {
+        for (let i = 0; i < this.est.boundSource.length; i++) {
+            let obj = this.est.boundSource[i];
+            // Trovo il parent con quell'id e lo collasso
+            if (obj[this.est.OwnKey] == key) {
+                obj._expanded = false;
+                // Collasso/nascondo tutti i child del parent
+                this.collapseChildOfParent(key);
+                return;
+            }
+        }
+    }
+    /**
+     * Collassa ricorsivamente tutti i figli di un parent identificato dalla **parentKey**
+     *
+     * @param {string} parentKey Chiave del parent di cui collassare i figli
+     */
+    collapseChildOfParent(parentKey) {
+        for (let ic = 0; ic < this.est.boundSource.length; ic++) {
+            let child = this.est.boundSource[ic];
+            // Trovo tutti i child di quel parent e li rendo invisibili. Se il child trovato è a sua volta un parent,
+            // lo collasso e vado in ricorsione sui figli
+            if (child[this.est.ParentKey] == parentKey && !child.parent)
+                child._visible = false;
+            else if (child[this.est.ParentKey] == parentKey && child.parent) {
+                child._expanded = false;
+                child._visible = false;
+                this.collapseChildOfParent(child[this.est.OwnKey]);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"HierarchyModeHandler.js","sourceRoot":"","sources":["../../../../../../../projects/es-table/src/lib/core/handlers/classes/HierarchyModeHandler.ts"],"names":[],"mappings":"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","sourcesContent":["import { EsTableComponent } from \"../../../components/es-table/es_table.component\"\r\n\r\nexport class HierarchyModeHandler {\r\n    constructor(private est: EsTableComponent) { }\r\n\r\n\r\n    /**\r\n     * Data una lista di oggetti assegno il livello gerarchico rispetto alla lista di oggetti passata\r\n     *\r\n     * @param {any[]} objs Lista di oggetti a cui aggiungere l'informazione del livello gerarchico\r\n     */\r\n    public assignHierarchyLevels(objs: any[]) {\r\n        // Casistica input nullo\r\n        if (!objs || !objs.length)\r\n            return;\r\n\r\n        //Se mancano entrambe le info le cerco di valorizzare in automatico coi default \"parentid\" e \"id\" (posto che le props esistano nell'oggetto)\r\n        if (!this.est.ParentKey && !this.est.OwnKey) {\r\n            if (objs[0]['parentid'] !== undefined)\r\n                this.est.ParentKey = 'parentid';\r\n            if (objs[0]['id'] !== undefined)\r\n                this.est.OwnKey = 'id';\r\n        }\r\n\r\n        //Check finale per assicurarmi che le props ci siano\r\n        if (!this.est.ParentKey || !this.est.OwnKey) {\r\n            console.error('Per utilizzare il sistema in modalità gerarchica è obbligatorio specificare sia ParentKey che OwnKey. Fallback a sistema non gerarchico');\r\n            return;\r\n        }\r\n\r\n        // Valorizzazione campi level, expanded, e visible per ogni item\r\n        let currentLevel = 1;\r\n        let assigned = 0;\r\n        do {\r\n            assigned = this.assignLevel(objs, currentLevel);\r\n            currentLevel++;\r\n        } while (assigned > 0);\r\n        // butto su lato html e poi me la gioco là con padding = 20 * (level - 1) per far capire il diverso livello\r\n    }\r\n\r\n    /**\r\n     * Per ognuno degli oggetti passati gli assegna un livello di gerarchia in base a **ParentKey** e **OwnKey**\r\n     *\r\n     * @param {any[]} objs Oggetti a cui assegnare il livello di gerarchia\r\n     * @param {number} levelToAssign Livello che sta assegnando attualmente questa iterazione (dato che è ricorsiva)\r\n     *\r\n     * @returns {number} Numero di oggetti a cui è stato assegnato un livello gerarchico\r\n     */\r\n    private assignLevel(objs: any[], levelToAssign: number): number {\r\n        let assigned = 0;\r\n        for (let i = 0; i < objs.length; i++) {\r\n            let obj = objs[i];\r\n\r\n            // Se la parentKey non è valorizzata, questo è il livello 0 (1... perché gli 0 son perciolosi)\r\n            if (!obj[this.est.ParentKey] && levelToAssign == 1) {\r\n                obj._level = 1;\r\n                obj._visible = true;\r\n                obj._expanded = this.est.StartsExpanded;\r\n                assigned++;\r\n                continue;\r\n            }\r\n\r\n            // Per i livelli superiore al primo\r\n            if (obj[this.est.ParentKey] && levelToAssign > 1) {\r\n                // trovo il parent\r\n                for (let p = 0; p < objs.length; p++) {\r\n                    let possibleParent = objs[p];\r\n\r\n                    // Trovato il parent dell'item, assegno all'item il livello giusto\r\n                    if (possibleParent[this.est.OwnKey] == obj[this.est.ParentKey] && possibleParent._level == levelToAssign - 1) {\r\n                        obj._level = levelToAssign;\r\n\r\n                        // So che questo item ha un parent. Ribadisco che il parent è espanso in base alle impostazione e stessa logica\r\n                        // per la visibilità del figlio\r\n                        possibleParent._expanded = this.est.StartsExpanded;\r\n                        possibleParent.parent = true;\r\n                        obj._visible = this.est.StartsExpanded;\r\n                        assigned++;\r\n                        break;\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        return assigned;\r\n    }\r\n\r\n    /**\r\n     * Funzione che permette di effettuare l'espansione di un parent quando la tabella funziona in modalità gerarchica\r\n     *\r\n     * @param {string} key Chiave del parent da espandere\r\n     */\r\n    public expandParent(key: string) {\r\n        for (let i = 0; i < this.est.boundSource.length; i++) {\r\n            let obj = this.est.boundSource[i];\r\n\r\n            // Trovo il parent con quell'id e lo espando\r\n            if (obj[this.est.OwnKey] == key) {\r\n                obj._expanded = true;\r\n\r\n                for (let ic = 0; ic < this.est.boundSource.length; ic++) {\r\n                    let child = this.est.boundSource[ic];\r\n\r\n                    // Trovo tutti i child di quel parent e li rendo visibili\r\n                    if (child[this.est.ParentKey] == key)\r\n                        child._visible = true;\r\n                }\r\n                return;\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Funzione che permette di effettuare il collapse di un parent quando la tabella funziona in modalità gerarchica\r\n     *\r\n     * @param {string} key Chiave del parent da collassare\r\n     */\r\n    public collapseParent(key: string) {\r\n        for (let i = 0; i < this.est.boundSource.length; i++) {\r\n            let obj = this.est.boundSource[i];\r\n\r\n            // Trovo il parent con quell'id e lo collasso\r\n            if (obj[this.est.OwnKey] == key) {\r\n                obj._expanded = false;\r\n\r\n                // Collasso/nascondo tutti i child del parent\r\n                this.collapseChildOfParent(key);\r\n                return;\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Collassa ricorsivamente tutti i figli di un parent identificato dalla **parentKey**\r\n     *\r\n     * @param {string} parentKey Chiave del parent di cui collassare i figli\r\n     */\r\n    private collapseChildOfParent(parentKey: string) {\r\n        for (let ic = 0; ic < this.est.boundSource.length; ic++) {\r\n            let child = this.est.boundSource[ic];\r\n\r\n            // Trovo tutti i child di quel parent e li rendo invisibili. Se il child trovato è a sua volta un parent,\r\n            // lo collasso e vado in ricorsione sui figli\r\n            if (child[this.est.ParentKey] == parentKey && !child.parent)\r\n                child._visible = false;\r\n            else if (child[this.est.ParentKey] == parentKey && child.parent) {\r\n                child._expanded = false;\r\n                child._visible = false;\r\n                this.collapseChildOfParent(child[this.est.OwnKey]);\r\n            }\r\n        }\r\n    }\r\n}\r\n"]}

package/esm2015/lib/core/handlers/classes/ItemsHandler.js

@@ -0,0 +1,120 @@
+import { AppSearch } from "../../../domain";
+export class ItemsHandler {
+    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;
+                // Devo chiamare il refresh page solo se vengo richiamato da un binding esterno
+                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() {
+        var _a, _b;
+        let castedView = this.est.View;
+        let groupKeys = castedView.groupings ? castedView.groupings.filter(t => !t.aggregation).length : 0;
+        //Gruppi intermedi
+        if ((((_a = castedView.requestedgroups) === null || _a === void 0 ? void 0 : _a.length) != groupKeys || ((_b = castedView.requestedgroups) === null || _b === void 0 ? void 0 : _b.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.SecondarySource ? this.est.View.items2 : this.est.TertiarySource ? this.est.View.items3 : this.est.View.items;
+            // 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
+        if (!this.est.SearchView)
+            this.est.arrayPulsanti = this.utilities.getPagesArray(6, this.est.arraymodePage, this.est.arraymodePages);
+        // 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 <= this.est.View.length - 1)
+                tmpItems.push(this.est.View[i]);
+        }
+        return tmpItems;
+    }
+    /**
+     * Metodo che prende tutti gli oggetti di cui dispone divisi in bucket da 100 elementi
+     *
+     * @returns {any[][]} Matrice di array Nx100
+     */
+    getItemSlices() {
+        // Se sono qui di sicuro non ho rowgrouping
+        let items = this.getItemsByMode();
+        if (!items)
+            return [];
+        let arrayBy100 = [];
+        let slices = Math.ceil(items.length / this.est.SliceSize);
+        for (let i = 0; i < slices; i++) {
+            let arraySlice = items.slice(i * this.est.SliceSize, i * this.est.SliceSize + this.est.SliceSize);
+            arrayBy100.push(arraySlice);
+        }
+        return arrayBy100;
+    }
+    /**
+     * Se in modalità array applica gli ordinamenti ASC-DESC delle colonne
+     */
+    arrayModeReviewOrderings() {
+        if (this.est.arrayOrders.length > 0)
+            this.est.arrayOrders.forEach(t => { this.est.boundSource = this.est.boundSource.sort((a, b) => (a[t.id] > b[t.id] ? 1 : -1) * (t.order == 'DESC' ? -1 : 1)); });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ItemsHandler.js","sourceRoot":"","sources":["../../../../../../../projects/es-table/src/lib/core/handlers/classes/ItemsHandler.ts"],"names":[],"mappings":"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","sourcesContent":["import { AppSearch } from \"../../../domain\";\r\nimport { UtilitiesHandler } from \"./UtilitiesHandler\";\r\n\r\nimport { EsTableComponent } from \"../../../components/es-table/es_table.component\"\r\n\r\nexport class ItemsHandler {\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                    this.est.ArraymodeItemsPerPage = this.est.SearchView.itemsperpageoverride;\r\n\r\n                // Devo chiamare il refresh page solo se vengo richiamato da un binding esterno\r\n                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.SecondarySource ? (this.est.View as any).items2 : this.est.TertiarySource ? (this.est.View as any).items3 : (this.est.View as any).items;\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        if (!this.est.SearchView)\r\n            this.est.arrayPulsanti = this.utilities.getPagesArray(6, this.est.arraymodePage, this.est.arraymodePages);\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 <= (this.est.View as any[]).length - 1)\r\n                tmpItems.push((this.est.View as any[])[i]);\r\n        }\r\n        return tmpItems;\r\n    }\r\n\r\n    /**\r\n     * Metodo che prende tutti gli oggetti di cui dispone divisi in bucket da 100 elementi\r\n     *\r\n     * @returns {any[][]} Matrice di array Nx100\r\n     */\r\n    public getItemSlices(): any[][] {\r\n        // Se sono qui di sicuro non ho rowgrouping\r\n        let items = this.getItemsByMode();\r\n        if (!items)\r\n            return [];\r\n\r\n        let arrayBy100 = [];\r\n        let slices = Math.ceil(items.length / this.est.SliceSize);\r\n        for (let i = 0; i < slices; i++) {\r\n            let arraySlice = items.slice(i * this.est.SliceSize, i * this.est.SliceSize + this.est.SliceSize);\r\n            arrayBy100.push(arraySlice);\r\n        }\r\n        return arrayBy100;\r\n    }\r\n\r\n    /**\r\n     * Se in modalità array applica gli ordinamenti ASC-DESC delle colonne\r\n     */\r\n    public arrayModeReviewOrderings() {\r\n        if (this.est.arrayOrders.length > 0)\r\n            this.est.arrayOrders.forEach(t => { this.est.boundSource = this.est.boundSource.sort((a, b) => (a[t.id] > b[t.id] ? 1 : -1) * (t.order == 'DESC' ? -1 : 1)); });\r\n    }\r\n}\r\n"]}

package/esm2015/lib/core/handlers/classes/ReportModeHandler.js

@@ -0,0 +1,67 @@
+import { ReportDefinition, ReportOrder } from "../../../domain";
+export class ReportModeHandler {
+    constructor(est, utilities) {
+        this.est = est;
+        this.utilities = utilities;
+    }
+    /**
+     * Sul click dell'Header di una colonna questo metodo si occupa di applicare l'ordinamento successivo e di notificare con **emitSearchRequest**
+     * il bisogno di aggiornare i dati da parte del componente che utilizza la tabella
+     *
+     * Utilizzato solo in modalità REport
+     *
+     * @param {ReportColumn} clm Colonna del report per cui ordinare
+     */
+    setupNextOrderAndSearch(clm) {
+        if (!(this.est.View instanceof ReportDefinition)) {
+            console.error('View diversa da reportdefinition entrata nel metodo setupNextOrderAndSearch');
+            return;
+        }
+        let orderNext = { NONE: 'DESC', DESC: 'ASC', ASC: null };
+        let nextOrder = orderNext[clm.order || 'NONE'];
+        clm.order = nextOrder;
+        let order;
+        let clmOrder = this.est.View.orders ? this.est.View.orders.filter(t => t.column == clm.id) : [];
+        if (clmOrder.length == 0 && clm.order) {
+            order = new ReportOrder();
+            order.column = clm.id;
+            order.order = clm.order;
+            if (!this.est.View.orders)
+                this.est.View.orders = [];
+            this.est.View.orders.push(order);
+        }
+        else if (clmOrder.length == 1) {
+            // Rimuovo l'ordinamento o aggiorno quello già esistente
+            if (!clm.order)
+                clmOrder = [];
+            else
+                clmOrder[0].order = clm.order;
+        }
+        else
+            console.warn('Impossibile settare ordinamento. Colonna ' + clm.id + ' direttive di ordinamento ' + clmOrder.length + ' ordinamento scelto ' + clm.order);
+        // Dopo aver aggiornato l'ordinamento rilancio la ricerca
+        this.est.emitSearchRequest(false);
+    }
+    /** Metodo che si occupa di gestire la grafica della tabella in base alle informazioni di ordinamento colonne e paginazione contenuti nel modello */
+    reviewReportBindings() {
+        if (!(this.est.View instanceof ReportDefinition)) {
+            console.error('View diversa da reportdefinition entrata nel metodo reviewReportBindings');
+            return;
+        }
+        // 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.ReportValues.columns.filter(c => c.id == t.column)[0].order = t.order;
+            });
+        }
+        // Recupero il count precedente se serve
+        if (this.est.ReportValues.count != -2)
+            this.est.previousCount = this.est.ReportValues.count;
+        else if (this.est.ReportValues.count == -2)
+            this.est.ReportValues.count = this.est.previousCount;
+        let ipp = (this.est.View.itemsperpageoverride || 15);
+        this.est.View.pages = Math.ceil(this.est.ReportValues.count / ipp);
+        this.est.arrayPulsanti = this.utilities.getPagesArray(6, this.est.View.page, this.est.View.pages);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ReportModeHandler.js","sourceRoot":"","sources":["../../../../../../../projects/es-table/src/lib/core/handlers/classes/ReportModeHandler.ts"],"names":[],"mappings":"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","sourcesContent":["import { UtilitiesHandler } from \"./UtilitiesHandler\";\r\nimport { EsTableComponent } from \"../../../components/es-table/es_table.component\"\r\nimport { ReportColumn, ReportDefinition, ReportOrder } from \"../../../domain\";\r\n\r\nexport class ReportModeHandler {\r\n    constructor(private est: EsTableComponent, private utilities: UtilitiesHandler) { }\r\n\r\n    /**\r\n     * Sul click dell'Header di una colonna questo metodo si occupa di applicare l'ordinamento successivo e di notificare con **emitSearchRequest**\r\n     * il bisogno di aggiornare i dati da parte del componente che utilizza la tabella\r\n     *\r\n     * Utilizzato solo in modalità REport\r\n     *\r\n     * @param {ReportColumn} clm Colonna del report per cui ordinare\r\n     */\r\n    public setupNextOrderAndSearch(clm: ReportColumn) {\r\n        if (!(this.est.View instanceof ReportDefinition)) {\r\n            console.error('View diversa da reportdefinition entrata nel metodo setupNextOrderAndSearch');\r\n            return;\r\n        }\r\n\r\n        let orderNext = { NONE: 'DESC', DESC: 'ASC', ASC: null };\r\n        let nextOrder = orderNext[clm.order || 'NONE'];\r\n        clm.order = nextOrder;\r\n\r\n        let order: ReportOrder;\r\n        let clmOrder = this.est.View.orders ? this.est.View.orders.filter(t => t.column == clm.id) : [];\r\n        if (clmOrder.length == 0 && clm.order) {\r\n            order = new ReportOrder();\r\n            order.column = clm.id;\r\n            order.order = clm.order;\r\n            if (!this.est.View.orders)\r\n                this.est.View.orders = [];\r\n\r\n            this.est.View.orders.push(order);\r\n        }\r\n        else if (clmOrder.length == 1) {\r\n            // Rimuovo l'ordinamento o aggiorno quello già esistente\r\n            if (!clm.order)\r\n                clmOrder = [];\r\n\r\n            else\r\n                clmOrder[0].order = clm.order;\r\n        }\r\n\r\n        else\r\n            console.warn('Impossibile settare ordinamento. Colonna ' + clm.id + ' direttive di ordinamento ' + clmOrder.length + ' ordinamento scelto ' + clm.order);\r\n\r\n        // Dopo aver aggiornato l'ordinamento rilancio la ricerca\r\n        this.est.emitSearchRequest(false);\r\n    }\r\n\r\n    /** Metodo che si occupa di gestire la grafica della tabella in base alle informazioni di ordinamento colonne e paginazione contenuti nel modello */\r\n    public reviewReportBindings() {\r\n        if (!(this.est.View instanceof ReportDefinition)) {\r\n            console.error('View diversa da reportdefinition entrata nel metodo reviewReportBindings');\r\n            return;\r\n        }\r\n\r\n        // Allineo le informazioni su eventuali ordinamenti fatti precedentemente\r\n        if (this.est.View.orders && this.est.View.orders.length > 0) {\r\n            this.est.View.orders.forEach(t => {\r\n                this.est.ReportValues.columns.filter(c => c.id == t.column)[0].order = t.order;\r\n            });\r\n        }\r\n\r\n        // Recupero il count precedente se serve\r\n        if (this.est.ReportValues.count != -2)\r\n            this.est.previousCount = this.est.ReportValues.count;\r\n        else if (this.est.ReportValues.count == -2)\r\n            this.est.ReportValues.count = this.est.previousCount;\r\n\r\n        let ipp = (this.est.View.itemsperpageoverride || 15);\r\n        this.est.View.pages = Math.ceil(this.est.ReportValues.count / ipp);\r\n        this.est.arrayPulsanti = this.utilities.getPagesArray(6, this.est.View.page, this.est.View.pages);\r\n    }\r\n}\r\n"]}