@zeedhi/teknisa-components-common 1.106.0 → 1.107.1

package/dist/tek-components-common.esm.js

@@ -1,5 +1,5 @@
 import { KeyMap, I18n, FormatterParserProvider, Messages, Metadata, DatasourceFactory, MemoryDatasource, URL, Utils, RestDatasource, Config, Accessor, Loader, DateHelper, Http, Singleton, VersionService } from '@zeedhi/core';
-import { Form, Button, Tooltip, GridEditable, Grid, ComponentRender, Iterable, Carousel, IterableComponentRender as IterableComponentRender$1, Loading as Loading$1, GridColumnEditable, Report, ColumnNotFoundError, IterableColumnsButtonController, IterableColumnsButton, ModalService, SelectMultiple, TreeGridEditable, List } from '@zeedhi/common';
+import { Form, Button, Tooltip, GridEditable, Grid, ComponentRender, Iterable, Carousel, IterableComponentRender as IterableComponentRender$1, Loading as Loading$1, GridColumnEditable, Report, EmptyDataError, AlertService, ColumnNotFoundError, IterableColumnsButtonController, IterableColumnsButton, ModalService, SelectMultiple, TreeGridEditable, List } from '@zeedhi/common';
 import debounce from 'lodash.debounce';
 import merge from 'lodash.merge';
 import { UserInfo } from '@zeedhi/zd-user-info-common';
@@ -1254,6 +1254,7 @@ Messages.add({
             TEKGRID_HELPERVALUE_CURRENT_YEAR: 'Ano Atual',
             TEKGRID_WITH_GROUPS: '(Com grupos)',
             TEKGRID_GRID_MIRROR: '(Espelho do grid)',
+            TEKGRID_NO_DATA: 'Não há dados para gerar o relatório',
         },
     },
     'en-US': {
@@ -1326,6 +1327,7 @@ Messages.add({
             TEKGRID_HELPERVALUE_CURRENT_YEAR: 'Current Year',
             TEKGRID_WITH_GROUPS: '(With groups)',
             TEKGRID_GRID_MIRROR: '(Grid mirror)',
+            TEKGRID_NO_DATA: 'There is no data to generate the report',
         },
     },
     'es-CL': {
@@ -1398,6 +1400,7 @@ Messages.add({
             TEKGRID_HELPERVALUE_CURRENT_YEAR: 'Año actual',
             TEKGRID_WITH_GROUPS: '(Con grupos)',
             TEKGRID_GRID_MIRROR: '(Espejo de grid)',
+            TEKGRID_NO_DATA: 'No hay datos para generar el reporte',
         },
     },
 });
@@ -1505,6 +1508,22 @@ class GridController {
     }
 }
 
+/**
+ * Extracts properties from an object based on a list of properties
+ * @param obj object whose properties will be extracted
+ * @param props array of strings with the properties to be extracted
+ * @returns object containing the extracted properties
+ */
+const extractProperties = (obj, props) => {
+    const result = {};
+    props.forEach((prop) => {
+        if (obj[prop] !== undefined) {
+            result[prop] = obj[prop];
+        }
+    });
+    return result;
+};
+
 const DynamicFilterOperations = {
     CONTAINS: true,
     NOT_CONTAINS: true,
@@ -1594,6 +1613,14 @@ class TekMemoryDatasource extends MemoryDatasource {
         }
         return superQueryString + dynamicFilterQuerystring + searchJoinQuerystring;
     }
+    /**
+     * Allows the comunication between the base filter and the dynamic filter
+     * @param filtroDinamico
+     * @returns
+     */
+    setBaseFilter(filtroDinamico) {
+        return this.setDynamicFilter(filtroDinamico);
+    }
     /**
      * Adds a new dynamic filter position or replace if exists
      * @param column Dynamic Filter column name
@@ -1671,12 +1698,15 @@ class TekMemoryDatasource extends MemoryDatasource {
      * @returns Is valid filter value
      */
     isValidDynamicFilterValue(column, value) {
+        if (!Array.isArray(value))
+            return false;
         return !this.reservedKeys[column]
-            && value
             && value.length > 0
-            && value.every((filterValue) => this.dynamicFilterOperations[filterValue.operation]
+            && value.every((filterValue) => filterValue
+                && this.dynamicFilterOperations[filterValue.operation]
                 && this.dynamicFilterRelations[filterValue.relation]
-                && filterValue.value !== '' && filterValue.value !== null);
+                && filterValue.value !== ''
+                && filterValue.value !== null);
     }
     clone() {
         return Object.assign(Object.assign({}, super.clone()), { dynamicFilter: this.dynamicFilter, searchJoin: this.searchJoin, type: 'tek-memory' });
@@ -1863,6 +1893,14 @@ class TekRestDatasource extends RestDatasource {
         }
         return superQueryString + dynamicFilterQuerystring + searchJoinQuerystring;
     }
+    /**
+     * Allows the comunication between the base filter and the dynamic filter
+     * @param filtroDinamico
+     * @returns
+     */
+    setBaseFilter(filtroDinamico) {
+        return this.setDynamicFilter(filtroDinamico);
+    }
     /**
      * Adds a new dynamic filter position or replace if exists
      * @param column Dynamic Filter column name
@@ -1940,12 +1978,15 @@ class TekRestDatasource extends RestDatasource {
      * @returns Is valid filter value
      */
     isValidDynamicFilterValue(column, value) {
+        if (!Array.isArray(value))
+            return false;
         return !this.reservedKeys[column]
-            && value
             && value.length > 0
-            && value.every((filterValue) => this.dynamicFilterOperations[filterValue.operation]
+            && value.every((filterValue) => filterValue
+                && this.dynamicFilterOperations[filterValue.operation]
                 && this.dynamicFilterRelations[filterValue.relation]
-                && filterValue.value !== '' && filterValue.value !== null);
+                && filterValue.value !== ''
+                && filterValue.value !== null);
     }
     /**
      * Retrieves request params
@@ -2154,6 +2195,19 @@ class TekGridColumn extends GridColumnEditable {
     }
 }
 
+/**
+ * Thrown when a row has incomplete group information.
+ * Provides details about the missing groups and the problematic row.
+ */
+class IncompleteGroupsError extends Error {
+    constructor(row, missingGroups) {
+        const rowPreview = JSON.stringify(row);
+        const message = `Row groups are incomplete. Missing groups: ${missingGroups.join(', ')}.\nRow data:\n${rowPreview}`;
+        super(message);
+        this.name = 'IncompleteGroupsError';
+    }
+}
+
 /* TekGrid Class */
 class TekGrid extends GridEditable {
     /**
@@ -2490,16 +2544,25 @@ class TekGrid extends GridEditable {
             if (typeof this.events.beforeOpenReport === 'function') {
                 beforeOpen = this.events.beforeOpenReport;
             }
-            return report
-                .getReport(typeValue, portrait, {
-                metaData: merge(rowObj, {
-                    filter,
-                    groups: reportGroups,
-                    columns: reportAggregations,
-                    xlsDefaultType: this.xlsDefaultType,
-                }),
-            }, beforeOpen)
-                .then((reportUrl) => window.open(reportUrl));
+            try {
+                const reportUrl = yield report
+                    .getReport(typeValue, portrait, {
+                    metaData: merge(rowObj, {
+                        filter,
+                        groups: reportGroups,
+                        columns: reportAggregations,
+                        xlsDefaultType: this.xlsDefaultType,
+                    }),
+                }, beforeOpen);
+                window.open(reportUrl);
+            }
+            catch (e) {
+                if (e instanceof EmptyDataError) {
+                    AlertService.show({ name: 'no-data-warning', text: I18n.translate('TEKGRID_NO_DATA'), color: 'warning' });
+                    return;
+                }
+                throw e;
+            }
         });
     }
     registerTask(task) {
@@ -2590,9 +2653,10 @@ class TekGrid extends GridEditable {
             this.groups.forEach((group) => {
                 group.lastGroupHeaderRow.children.push(row);
             });
-            this.groupedData.push(Object.assign(Object.assign({}, row), { groupHeaders: this.groups
-                    .map((group) => group.lastGroupHeaderRow)
-                    .filter(Boolean) }));
+            const groupHeaders = this.groups
+                .map((group) => group.lastGroupHeaderRow)
+                .filter(Boolean);
+            this.groupedData.push(Object.assign(Object.assign({}, row), { groupHeaders }));
             this.calcSummary(row);
         });
         if (this.groupedData.length > 0) {
@@ -2648,14 +2712,14 @@ class TekGrid extends GridEditable {
             return;
         }
         for (let i = this.groups.length - 1; i >= groupIndex; i -= 1) {
-            if (this.groups[i].initialized) {
-                const groupFooterRow = Object.assign({ groupFooter: true, groupIndex: i, groupHeaders: [], groupLabel: this.groups[i].lastGroupHeaderRow.groupLabel, groupValue: this.groups[i].lastGroupHeaderRow.groupValue }, this.summaryData(this.groups[i].footer));
-                // add header for outer groups
-                for (let g = 0; g < i; g += 1) {
-                    groupFooterRow.groupHeaders.push(this.groups[g].lastGroupHeaderRow);
-                }
-                this.groupedData.push(groupFooterRow);
+            if (!this.groups[i].initialized)
+                return;
+            const groupFooterRow = Object.assign({ groupFooter: true, groupIndex: i, groupHeaders: [], groupLabel: this.groups[i].lastGroupHeaderRow.groupLabel, groupValue: this.groups[i].lastGroupHeaderRow.groupValue }, this.summaryData(this.groups[i].footer));
+            // add header for outer groups
+            for (let g = 0; g < i; g += 1) {
+                groupFooterRow.groupHeaders.push(this.groups[g].lastGroupHeaderRow);
             }
+            this.groupedData.push(groupFooterRow);
         }
     }
     resetFooterVariables(group) {
@@ -2905,6 +2969,7 @@ class TekGrid extends GridEditable {
      */
     groupRowClick(row, event, element) {
         if (!this.preventRowClick) {
+            this.datasource.currentRow = row;
             this.callEvent('groupRowClick', {
                 event,
                 element,
@@ -2917,6 +2982,7 @@ class TekGrid extends GridEditable {
     }
     groupRowDoubleClick(row, event, element) {
         if (!this.preventRowDoubleClick) {
+            this.datasource.currentRow = row;
             this.callEvent('groupRowDoubleClick', {
                 event,
                 element,
@@ -2966,6 +3032,157 @@ class TekGrid extends GridEditable {
     getColumn(name) {
         return super.getColumn(name);
     }
+    /**
+     * Adds new row to the datasource data and pushes it to the editedRows
+     * @param row Row
+     * @param position whether the new Row will be inserted at the beginning or end of the data array
+     */
+    addNewRow(row, position = 'end') {
+        const _super = Object.create(null, {
+            addNewRow: { get: () => super.addNewRow }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.groupColumns.length) {
+                yield _super.addNewRow.call(this, row, position);
+                return;
+            }
+            this.insertRowInDatasource(row, position);
+            this.saveRowReference(row);
+            this.addGroupedRow(row, position);
+            this.editing = true;
+        });
+    }
+    /**
+     * Takes a row and adds it to the selected group (datasource.currentRow)
+     * @param row the new row to be added
+     * @param position the position, at the beginning of the group or at the end
+     */
+    addToSelection(row, position = 'end') {
+        const { currentRow } = this.datasource;
+        // if the currentRow is a group, use the groupRow as reference
+        const referenceRow = this.isGroupHeader(currentRow) ? currentRow.groupRow : currentRow;
+        // extract the group properties from the referenceRow to add to the new row
+        const groupProperties = extractProperties(referenceRow, this.groupColumnNames);
+        const rowWithGroups = Object.assign(Object.assign({}, row), groupProperties);
+        return this.addNewRow(rowWithGroups, position);
+    }
+    /**
+     * Adds a new row to the groupedData array
+     * @param row the new row to be added
+     * @param position the position, at the beginning of the group or at the end
+     */
+    addGroupedRow(row, position) {
+        const missingGroups = this.findMissingGroups(row);
+        if (missingGroups.length > 0) {
+            throw new IncompleteGroupsError(row, missingGroups);
+        }
+        const { index, group } = this.findLastGroupingIndex(row);
+        const groupHeaders = [...group.groupHeaders, group];
+        const newGroupedRow = Object.assign(Object.assign({}, row), { groupHeaders });
+        if (position === 'end') {
+            const childrenLength = group.children.length;
+            this.groupedData.splice(index + childrenLength + 1, 0, newGroupedRow);
+        }
+        else {
+            this.groupedData.splice(index + 1, 0, newGroupedRow);
+        }
+        groupHeaders.forEach((groupHeader) => {
+            // open all groups, making the new row visible to the user
+            groupHeader.groupOpened = true;
+            this.addRowToGroupChildren(row, groupHeader, position);
+        });
+    }
+    findMissingGroups(row) {
+        return this.groupColumnNames.filter((group) => row[group] === undefined);
+    }
+    /**
+     * Finds the last group (most internal group) where a row should be inserted
+     * @param row to be inserted
+     * @returns the index and the group where the row should be inserted
+     */
+    findLastGroupingIndex(row) {
+        const index = this.groupedData.findIndex((groupRow) => {
+            // ignore rows that are not headers or not the last grouping (most internal groping)
+            if (!this.isGroupHeader(groupRow) || !this.isLastGrouping(groupRow))
+                return false;
+            // if the new added row is not part of the group, ignore it
+            if (groupRow.groupValue !== row[groupRow.groupColumnName])
+                return false;
+            if (this.groupColumns.length === 1)
+                return true;
+            const matchHeaders = groupRow.groupHeaders.every((groupHeader) => (groupHeader.groupValue === row[groupHeader.groupColumnName]));
+            return matchHeaders;
+        });
+        if (index === -1) {
+            // No existing group found, so we create the full group hierarchy
+            return this.createGroupHierarchyForRow(row);
+        }
+        const group = this.groupedData[index];
+        return { index, group };
+    }
+    /**
+     * Creates a group hierarchy for a new row, creating intermediate groups if needed
+     * @param row to be inserted
+     * @returns the index and the group where the row should be inserted
+     */
+    createGroupHierarchyForRow(row) {
+        let groupHeaders = [];
+        let insertionIndex = this.groupedData.length; // default to end
+        this.groups.forEach((column) => {
+            const groupValue = row[column.name];
+            const existingGroupIndex = this.groupedData.findIndex((groupRow) => this.isGroupHeader(groupRow)
+                && groupRow.groupColumnName === column.name
+                && groupRow.groupValue === groupValue
+                && groupRow.groupHeaders.every((h, j) => h.groupValue === groupHeaders[j].groupValue));
+            if (existingGroupIndex !== -1) {
+                const existingGroup = this.groupedData[existingGroupIndex];
+                groupHeaders = [...existingGroup.groupHeaders, existingGroup];
+                insertionIndex = existingGroupIndex;
+                return;
+            }
+            // Create new group header
+            const newGroup = {
+                group: true,
+                groupHeader: true,
+                groupValue,
+                groupColumnName: column.name,
+                groupHeaders: [...groupHeaders],
+                children: [],
+                groupRow: row,
+                groupIndex: groupHeaders.length,
+                groupLabel: I18n.translate(column.label),
+                groupOpened: true,
+            };
+            // Insert right after last insertionIndex
+            insertionIndex += 1;
+            this.groupedData.splice(insertionIndex, 0, newGroup);
+            groupHeaders.push(newGroup);
+        });
+        const group = groupHeaders[groupHeaders.length - 1]; // the most inner group
+        return { index: insertionIndex, group };
+    }
+    /**
+     * Adds a row to the children of a group
+     */
+    addRowToGroupChildren(row, group, position) {
+        if (position === 'end') {
+            group.children.push(row);
+            return;
+        }
+        group.children.unshift(row);
+    }
+    /**
+     * Checks if a row is a group header, adding typescript type-checking
+     */
+    isGroupHeader(row) {
+        return row.groupHeader;
+    }
+    /**
+     * Checks if a row is the last grouping of the grid (the most internal grouping)
+     */
+    isLastGrouping(group) {
+        return group.groupColumnName === this.groupColumns[this.groupColumns.length - 1].name;
+    }
 }
 
 class TekGridColumnsButtonController extends IterableColumnsButtonController {
@@ -3309,7 +3526,7 @@ class TekGridFilterButton extends Button {
                     }
                 });
                 datasource.dynamicFilter = filter;
-                this.setFilter(filter, event, datasource.setDynamicFilter.bind(datasource));
+                this.setFilter(filter, event, datasource.setBaseFilter.bind(datasource));
             }
             else {
                 Object.keys(formValue).forEach((item) => {
@@ -3320,7 +3537,7 @@ class TekGridFilterButton extends Button {
                     }
                 });
                 datasource.filter = filter;
-                this.setFilter(filter, event, datasource.setFilter.bind(datasource));
+                this.setFilter(filter, event, datasource.setBaseFilter.bind(datasource));
             }
             this.grid.changeLayout(event);
         }