@zeedhi/teknisa-components-common 1.106.0 → 1.107.1

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

@@ -1258,6 +1258,7 @@
               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': {
@@ -1330,6 +1331,7 @@
               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': {
@@ -1402,6 +1404,7 @@
               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',
           },
       },
   });
@@ -1509,6 +1512,22 @@
       }
   }
 
+  /**
+   * 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,
@@ -1598,6 +1617,14 @@
           }
           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
@@ -1675,12 +1702,15 @@
        * @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' });
@@ -1867,6 +1897,14 @@
           }
           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
@@ -1944,12 +1982,15 @@
        * @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
@@ -2158,6 +2199,19 @@
       }
   }
 
+  /**
+   * 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 common.GridEditable {
       /**
@@ -2494,16 +2548,25 @@
               if (typeof this.events.beforeOpenReport === 'function') {
                   beforeOpen = this.events.beforeOpenReport;
               }
-              return report
-                  .getReport(typeValue, portrait, {
-                  metaData: merge__default["default"](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__default["default"](rowObj, {
+                          filter,
+                          groups: reportGroups,
+                          columns: reportAggregations,
+                          xlsDefaultType: this.xlsDefaultType,
+                      }),
+                  }, beforeOpen);
+                  window.open(reportUrl);
+              }
+              catch (e) {
+                  if (e instanceof common.EmptyDataError) {
+                      common.AlertService.show({ name: 'no-data-warning', text: core.I18n.translate('TEKGRID_NO_DATA'), color: 'warning' });
+                      return;
+                  }
+                  throw e;
+              }
           });
       }
       registerTask(task) {
@@ -2594,9 +2657,10 @@
               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) {
@@ -2652,14 +2716,14 @@
               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) {
@@ -2909,6 +2973,7 @@
        */
       groupRowClick(row, event, element) {
           if (!this.preventRowClick) {
+              this.datasource.currentRow = row;
               this.callEvent('groupRowClick', {
                   event,
                   element,
@@ -2921,6 +2986,7 @@
       }
       groupRowDoubleClick(row, event, element) {
           if (!this.preventRowDoubleClick) {
+              this.datasource.currentRow = row;
               this.callEvent('groupRowDoubleClick', {
                   event,
                   element,
@@ -2970,6 +3036,157 @@
       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: core.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 common.IterableColumnsButtonController {
@@ -3313,7 +3530,7 @@
                       }
                   });
                   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) => {
@@ -3324,7 +3541,7 @@
                       }
                   });
                   datasource.filter = filter;
-                  this.setFilter(filter, event, datasource.setFilter.bind(datasource));
+                  this.setFilter(filter, event, datasource.setBaseFilter.bind(datasource));
               }
               this.grid.changeLayout(event);
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeedhi/teknisa-components-common",
-  "version": "1.106.0",
+  "version": "1.107.1",
   "description": "Teknisa Components Common",
   "author": "Zeedhi <zeedhi@teknisa.com>",
   "license": "ISC",
@@ -32,5 +32,5 @@
   "peerDependencies": {
     "@zeedhi/core": "^1.97.0"
   },
-  "gitHead": "665962544705695986852f9d8719e6e6716e6587"
+  "gitHead": "ce6aeb7a4ebfca43f9ecb85ed411037f6032d214"
 }

package/tests/unit/components/tek-datasource/memory-datasource.spec.ts

@@ -390,6 +390,16 @@ describe('TekMemoryDatasource', () => {
       expect(instance.dynamicFilter).toEqual({ name: [{ operation: 'EQUALS', relation: 'AND', value: '2' }] });
       urlSpy.mockClear();
     });
+
+    it('deve chamar setDynamicFilter ao usar setBaseFilter', () => {
+      const ds = new TekMemoryDatasource({ uniqueKey: 'id', data: [] });
+      const filtro = { ativo: true };
+      const spy = jest.spyOn(ds, 'setDynamicFilter');
+
+      ds.setBaseFilter(filtro);
+
+      expect(spy).toHaveBeenCalledWith(filtro);
+    });
   });
 
   describe('clearDynamicFilter()', () => {

package/tests/unit/components/tek-datasource/rest-datasource.spec.ts

@@ -306,7 +306,9 @@ describe('TekRestDatasource', () => {
 
       await instance.get();
 
-      expect(httpSpy).toHaveBeenCalledWith('/zeedhi', expect.objectContaining({
+      const callArgs = httpSpy.mock.calls[0]; // Captura a primeira chamada ao mock
+      expect(callArgs[0]).toBe('/zeedhi'); // Verifica o primeiro argumento
+      expect(callArgs[1]).toMatchObject({
         params: {
           in: [],
           order: [],
@@ -314,9 +316,9 @@ describe('TekRestDatasource', () => {
           search_in: [],
           page: 1,
           limit: 10,
-          search_in_params: "{}",
+          search_in_params: '{}',
         },
-      }));
+      });
     });
   });
 

package/tests/unit/components/tek-grid/grid-filter-button.spec.ts

@@ -318,9 +318,7 @@ describe('TekGridFilterButton', () => {
       formObject.value['grid_filterClick5-filter-AND-CONTAINS-id-0'] = ['example'];
       setClick(applyButtonObject);
 
-      expect(instance.datasource.filter).toEqual({
-        id: ['example'],
-      });
+      expect(instance.datasource.filter).toEqual({});
 
       selectObject.checkboxAll = true;
       setClick(applyButtonObject);
@@ -329,7 +327,7 @@ describe('TekGridFilterButton', () => {
 
       (Config as any).set({ selectAllCompatibilityMode: true });
       setClick(applyButtonObject);
-      expect(instance.datasource.filter).toEqual({ id: 'T' });
+      expect(instance.datasource.filter).toEqual({});
 
       spy.mockReset();
     });
@@ -954,14 +952,10 @@ describe('TekGridFilterButton', () => {
       };
       const applyButtonObject = new Button(applyButton);
       setClick(applyButtonObject);
-      expect(instance.datasource.filter).toEqual({
-        id: '1;2;3',
-        name: 'teste',
-        salary: '1000',
-      });
+      expect(instance.datasource.filter).toEqual({});
       expect(beforeApplyFilterCalled).toBeTruthy();
       expect(changeLayoutCalled).toBeTruthy();
-      expect(instance.columnHasFilterData({ name: 'name' } as TekGridColumn)).toBeTruthy();
+      expect(instance.columnHasFilterData({ name: 'name' } as TekGridColumn)).toBe(undefined);
 
       setClick(applyButtonObject, { defaultPrevented: true });
       expect(spyDatasourceGet).toBeCalledTimes(1);