@esfaenza/es-table 11.2.22-beta2 → 11.2.22-beta23

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

@@ -0,0 +1,64 @@
+// Dominio
+import { EsTableColumnsDefinition } from "../../../domain";
+/** Classe contenente le gestioni particolari della modalità dinamica dell'es-table */
+export class DynamicModeHandler {
+    /** @ignore Costruttore*/
+    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,43 @@
+/** Classe contenente la gestione delle importazioni */
+export class ExportHandler {
+    /** @ignore Costruttore*/
+    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,136 @@
+/** Classe contenente la gestione della modalità gerarchica */
+export class HierarchyModeHandler {
+    /** @ignore Costruttore*/
+    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\n/** Classe contenente la gestione della modalità gerarchica */\r\nexport class HierarchyModeHandler {\r\n\r\n    /** @ignore Costruttore*/\r\n    constructor(private est: EsTableComponent) { }\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,121 @@
+// Modelli
+import { AppSearch } from "../../../domain";
+/** 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;
+                // 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":["// Componenti\r\nimport { EsTableComponent } from \"../../../components/es-table/es_table.component\"\r\n\r\n// Modelli\r\nimport { AppSearch } from \"../../../domain\";\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                    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\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    /** Se in modalità array applica gli ordinamenti ASC-DESC delle colonne */\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,70 @@
+// Modelli
+import { ReportDefinition, ReportOrder } from "../../../domain";
+/** 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;
+    }
+    /**
+     * 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":"AAMA,UAAU;AACV,OAAO,EAAgB,gBAAgB,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAE9E,mFAAmF;AACnF,MAAM,OAAO,iBAAiB;IAE1B,0BAA0B;IAC1B,YAAoB,GAAqB,EAAU,SAA2B;QAA1D,QAAG,GAAH,GAAG,CAAkB;QAAU,cAAS,GAAT,SAAS,CAAkB;IAAI,CAAC;IAEnF;;;;;;;OAOG;IACI,uBAAuB,CAAC,GAAiB;QAC5C,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,YAAY,gBAAgB,CAAC,EAAE;YAC9C,OAAO,CAAC,KAAK,CAAC,6EAA6E,CAAC,CAAC;YAC7F,OAAO;SACV;QAED,IAAI,SAAS,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC;QACzD,IAAI,SAAS,GAAG,SAAS,CAAC,GAAG,CAAC,KAAK,IAAI,MAAM,CAAC,CAAC;QAC/C,GAAG,CAAC,KAAK,GAAG,SAAS,CAAC;QAEtB,IAAI,KAAkB,CAAC;QACvB,IAAI,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,IAAI,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAChG,IAAI,QAAQ,CAAC,MAAM,IAAI,CAAC,IAAI,GAAG,CAAC,KAAK,EAAE;YACnC,KAAK,GAAG,IAAI,WAAW,EAAE,CAAC;YAC1B,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC,EAAE,CAAC;YACtB,KAAK,CAAC,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC;YACxB,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM;gBACrB,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;YAE9B,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SACpC;aACI,IAAI,QAAQ,CAAC,MAAM,IAAI,CAAC,EAAE;YAC3B,wDAAwD;YACxD,IAAI,CAAC,GAAG,CAAC,KAAK;gBACV,QAAQ,GAAG,EAAE,CAAC;;gBAGd,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC;SACrC;;YAGG,OAAO,CAAC,IAAI,CAAC,2CAA2C,GAAG,GAAG,CAAC,EAAE,GAAG,4BAA4B,GAAG,QAAQ,CAAC,MAAM,GAAG,sBAAsB,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC;QAE7J,yDAAyD;QACzD,IAAI,CAAC,GAAG,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;IACtC,CAAC;IAED,oJAAoJ;IAC7I,oBAAoB;QACvB,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,YAAY,gBAAgB,CAAC,EAAE;YAC9C,OAAO,CAAC,KAAK,CAAC,0EAA0E,CAAC,CAAC;YAC1F,OAAO;SACV;QAED,yEAAyE;QACzE,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;YACzD,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;gBAC7B,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC;YACnF,CAAC,CAAC,CAAC;SACN;QAED,wCAAwC;QACxC,IAAI,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,KAAK,IAAI,CAAC,CAAC;YACjC,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,KAAK,CAAC;aACpD,IAAI,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,KAAK,IAAI,CAAC,CAAC;YACtC,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC;QAEzD,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,oBAAoB,IAAI,EAAE,CAAC,CAAC;QACrD,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC;QACnE,IAAI,CAAC,GAAG,CAAC,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACtG,CAAC;CACJ","sourcesContent":["// Handlers\r\nimport { UtilitiesHandler } from \"./UtilitiesHandler\";\r\n\r\n// Componenti\r\nimport { EsTableComponent } from \"../../../components/es-table/es_table.component\"\r\n\r\n// Modelli\r\nimport { ReportColumn, ReportDefinition, ReportOrder } from \"../../../domain\";\r\n\r\n/** Classe che gestisce la modalità Report dell'es-table utilizzata nel Metering */\r\nexport class ReportModeHandler {\r\n\r\n    /** @ignore Costruttore */\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"]}