tuain-ng-forms-lib 17.2.21 → 17.2.22

package/src/lib/classes/forms/table/row-data.ts

@@ -0,0 +1,121 @@
+import { RecordTableColumn } from './column';
+import { operators } from '../form.constants';
+
+export class TableRecordData {
+  recordId: string | null = null;
+  selected: boolean = false;
+  recordData: any = {};
+
+  constructor(recordReceived, recordDefinition: RecordTableColumn[], selectionFieldName: string | null = null) {
+    const { tableRecordId, recordData } = recordReceived;
+    this.recordId = tableRecordId;
+    if (!recordDefinition || recordDefinition.length === 0 || !recordData || recordData.length === 0) {
+      return;
+    }
+    const fieldNames = recordDefinition.map(column => column.fieldCode);
+    if (Array.isArray(recordData)) {
+      const rawRecordData = recordData.filter(fieldData => fieldData.fieldCode && fieldNames.includes(fieldData.fieldCode));
+      rawRecordData.forEach(fieldData => {
+        const { fieldCode, fieldValue } = fieldData;
+        const fieldDef = recordDefinition.find(column => column.fieldCode === fieldCode);
+        this.recordData[fieldCode] = fieldValue ?? '';
+        if (fieldCode === selectionFieldName) {
+          this.selected = fieldValue;
+        }
+      });
+    } else {
+      const fields = Object.keys(recordData);
+      fields.forEach(fieldCode => {
+        const fieldValue = recordData[fieldCode];
+        const fieldDef = recordDefinition.find(column => column.fieldCode === fieldCode);
+        this.recordData[fieldCode] = fieldValue ?? '';
+      });
+    }
+  }
+
+  toggleSelect() { this.selected = !this.selected; }
+  select() { this.selected = true; }
+  unselect() { this.selected = false; }
+
+  get recordIdKey() {
+    return (typeof this.recordId === 'object')
+      ? JSON.stringify(this.recordId) : this.recordId;
+  }
+
+  getFieldValue(fieldCode): any {
+    return (fieldCode && this.recordData) ? this.recordData[fieldCode] : null;
+  }
+
+  hasPattern(words, columnObj) {
+    if (!words || words.length === 0) {
+      return true;
+    }
+    for (const word of words) {
+      let wordIsPresent = false;
+      for (const fieldCode in this.recordData) {
+        const columnDef = columnObj?.[fieldCode];
+        if (columnDef?.searchable && this.recordData.hasOwnProperty(fieldCode)) {
+          const term = word.toUpperCase();
+          let fieldValue;
+          if (columnDef.fieldType.toUpperCase().includes('DATE')) {
+            fieldValue = this.recordData[fieldCode].substring(0, 16);
+          } else {
+            fieldValue = this.recordData[fieldCode];
+          }
+          if (fieldValue.toString().toUpperCase().includes(term)) {
+            wordIsPresent = true;
+            break;
+          }
+        }
+      }
+      if (!wordIsPresent) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  hasCondition(columnFilters) {
+    if (!columnFilters || columnFilters.length === 0) {
+      return true;
+    }
+    for (const condition of columnFilters) {
+      const { fieldCode, operator, values } = condition;
+      if (this.recordData.hasOwnProperty(fieldCode)) {
+        const fieldValue = this.recordData[fieldCode];
+        const stringValue = fieldValue.toString().toUpperCase();
+        if (operator === operators.G && fieldValue <= values[0]) {
+          return false;
+        }
+        if (operator === operators.L && fieldValue >= values[0]) {
+          return false;
+        }
+        if (operator === operators.GE && fieldValue < values[0]) {
+          return false;
+        }
+        if (operator === operators.LE && fieldValue > values[0]) {
+          return false;
+        }
+        if (operator === operators.IN && !values.includes(fieldValue)) {
+          return false;
+        }
+        if (operator === operators.EQ) {
+          return fieldValue === values[0];
+        }
+        if (operator === operators.NEQ && fieldValue === values[0]) {
+          return false;
+        }
+        if (operator === operators.HAS && !stringValue.includes(values[0].toString().toUpperCase())) {
+          return false;
+        }
+        if (operator === operators.NOTHAS && stringValue.includes(values[0].toString().toUpperCase())) {
+          return false;
+        }
+        if (operator === operators.BETWEEN && (fieldValue < values[0] || fieldValue > values[1])) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+}

package/src/lib/classes/forms/table/table.ts

@@ -0,0 +1,582 @@
+import { Subject } from 'rxjs';
+import { elementTypes } from '../form.constants';
+import { FormElement } from '../element';
+import { RecordTableColumn } from './column';
+import { TableAction } from './action';
+import { TableRecordData } from './row-data';
+
+const TABLE_SORT_ASCENDING = 'asc';
+const TABLE_SORT_DESCENDING = 'desc';
+
+const attrs = {
+  allSelected: { name: 'allSelected', propagate: 'allSelected' },
+  tableCode: { name: 'tableCode', propagate: 'code' },
+  clientPaging: { name: 'clientPaging', propagate: null },
+  globalSearch: { name: 'globalSearch', propagate: 'globalSearch' },
+  globalFilterString: { name: '_globalFilterString', propagate: 'globalFilterString' },
+  sorting: { name: 'sorting', propagate: null },
+  recordsPerPage: { name: 'recordsPerPage', propagate: 'recordsPerPage' },
+  layout: { name: 'layout', propagate: 'layout' },
+  columns: { name: 'columns', propagate: 'columns' },
+  selectedRecords: { name: 'selectedRecords', propagate: 'selectedRecords' },
+  currentPage: { name: 'currentPage', propagate: 'currentPage' },
+  totalRecordsNumber: { name: 'totalRecordsNumber', propagate: 'totalRecordsNumber' },
+  visibleRecords: { name: '_visibleRecords', propagate: 'visibleRecords' },
+  waiting: { name: '_waiting', propagate: 'waiting' },
+};
+
+export interface TableActionEvent {
+  actionCode: string;
+  recordId: any;
+  recordData: any;
+}
+
+export interface TableEvent {
+  tableCode: string;
+  actionCode: string | null;
+  actionDetail: any;
+}
+
+export class RecordTable extends FormElement {
+  private readonly _inlineActionTrigger = new Subject<TableEvent>();
+  private readonly _globalActionTrigger = new Subject<TableEvent>();
+  private readonly _recordSelectionTrigger = new Subject<TableEvent>();
+  private readonly _selectionActionTrigger = new Subject<TableEvent>();
+  private readonly _getDataTrigger = new Subject<TableEvent>();
+  private _tableColumnObj = {};
+  private _appendPages: boolean;
+  private _actions: TableAction[];
+  private _actionsObj = {};
+
+  // Mecanismos de filtrado nueva versión
+  private _globalFilterString: string = '';
+  private globalFilterStrings: string[] = [];
+  private selectedRecords: any;
+  private restrictedId: any;
+  private layout: string | null = null;
+  private _globalSearch: boolean;
+  private _tableRecords: TableRecordData[];
+  private _tableRecordObj = {};
+  private _visibleRecords: TableRecordData[] = [];
+  private _columns: RecordTableColumn[];
+  private _selectable: boolean;
+  private _selectionBackend: boolean;
+  private _selectionField: string;
+  private _allSelected = false;
+  private _tableCode: string = '';
+  private _tableTitle: string;
+  private _currentPage: number;
+  private _totalPages: number;
+  private _requestedPage: number;
+  private _recordsPerPage: number = 10;
+  private _totalRecordsNumber: number = 0;
+  private _recordsNumber: number = 0;
+  private _sorting: any;
+  private _waiting: boolean;
+  private _clientPaging: boolean = true;
+  private _sortable: boolean;
+
+  constructor(tableReceived, formConfig) {
+    super(tableReceived, formConfig);
+    this.propagationCustomAttributes = this._formConfig?.propagationCustomAttributes?.tables ?? [];
+    this.elementType = elementTypes.table;
+    this._waiting = false;
+    this._currentPage = 1;
+    this._totalPages = 1;
+    this._requestedPage = 1;
+    this._columns = [];
+    this._tableColumnObj = {};
+    this._actions = [];
+    this._actionsObj = {};
+    this._tableRecords = [];
+    this._globalSearch = false;
+    this.restrictedId = null;
+
+    this._tableTitle = tableReceived.tableTitle;
+    this._appendPages = tableReceived?.append ?? false;
+    this._selectable = tableReceived?.selectable ?? false;
+    this._selectionBackend = tableReceived?.selectionBackend ?? false;
+    this._sortable = tableReceived?.sortable ?? false;
+
+    this.setAttr(attrs.allSelected, false);
+    this.setAttr(attrs.tableCode, tableReceived.tableCode);
+    this.setAttr(attrs.clientPaging, tableReceived?.clientPaging ?? true);
+    this.setAttr(attrs.globalSearch, tableReceived?.simpleFilter ?? false);
+    this.setAttr(attrs.globalFilterString, '');
+    this.setAttr(attrs.sorting, { columnName: '', direction: '' });
+    this.setAttr(attrs.recordsPerPage, formConfig.defaultRecordsPerPage);
+    this.setAttr(attrs.layout, '');
+
+    if (tableReceived.fields) {
+      const columns: RecordTableColumn[] = [];
+      for (const columnReceived of tableReceived.fields) {
+        const columnEnriched = {
+          ...columnReceived,
+          visibleStates: this.visibleStates,
+          enabledStates: this.enabledStates
+        };
+        const columnDefinition: RecordTableColumn = new RecordTableColumn(columnEnriched, this._formConfig);
+        columns.push(columnDefinition);
+        this._tableColumnObj[columnDefinition.fieldCode] = columnDefinition;
+      }
+      this.setAttr(attrs.columns, columns);
+    }
+    if (tableReceived.actions) {
+      const tableActions = tableReceived.actions.map(objDef => {
+        let visibleStates = objDef.visibleStates;
+        let enabledStates = objDef.enabledStates;
+        if (!visibleStates) {
+          visibleStates = (objDef.actionModes || '').split(',')
+            .map(state => state.trim())
+            .filter(state => state.length > 0);
+          enabledStates = (objDef.actionModes || '').split(',')
+            .map(state => state.trim())
+            .filter(state => state.length > 0);
+        }
+        return { ...objDef, visibleStates, enabledStates };
+      });
+      for (const actionReceived of tableActions) {
+        const inlineAction = new TableAction(actionReceived, this._formConfig);
+        this._actions.push(inlineAction);
+        this._actionsObj[inlineAction.actionCode] = inlineAction;
+      }
+    }
+    this._selectionField = (this._selectable) ? tableReceived?.selectionField : null;
+    // Filtros predefinidos en el formulario
+    if (tableReceived.filters) {
+      for (let index = 0; index < tableReceived.filters.length; index++) {
+        this.addFilterDefinition(tableReceived.filters[index].fieldCode, tableReceived.filters[index]);
+      }
+    }
+  }
+
+  get columnNames() { return Object.keys(this._tableColumnObj); }
+  get inlineActionTrigger() { return this._inlineActionTrigger.asObservable(); }
+  get globalActionTrigger() { return this._globalActionTrigger.asObservable(); }
+  get selectionActionTrigger() { return this._selectionActionTrigger.asObservable(); }
+  get recordSelectionTrigger() { return this._recordSelectionTrigger.asObservable(); }
+  get getDataTrigger() { return this._getDataTrigger.asObservable(); }
+
+  get globalSearch() { return this._globalSearch; }
+  get tableRecords() { return this._tableRecords; }
+  get tableRecordObj() { return this._tableRecordObj; }
+  get visibleRecords() { return this._visibleRecords; }
+  get columns() { return this._columns; }
+  get selectable() { return this._selectable; }
+  get selectionBackend() { return this._selectionBackend; }
+  get selectionField() { return this._selectionField; }
+  get allSelected() { return this._allSelected; }
+  get tableCode() { return this._tableCode; }
+  get tableTitle() { return this._tableTitle; }
+  get currentPage() { return this._currentPage; }
+  get totalPages() { return this._totalPages; }
+  get requestedPage() { return this._requestedPage; }
+  get recordsPerPage() { return this._recordsPerPage; }
+  get totalRecordsNumber() { return this._totalRecordsNumber; }
+  get recordsNumber() { return this._recordsNumber; }
+  get sorting() { return this._sorting; }
+  get waiting() { return this._waiting; }
+  get clientPaging() { return this._clientPaging; }
+  get sortable() { return this._sortable; }
+
+  get globalFilterString() { return this._globalFilterString; }
+  set globalFilterString(globalFilterString) { this._globalFilterString = globalFilterString; }
+
+  set globalSearch(globalSearch) { this._globalSearch = globalSearch; }
+  set tableRecords(tableRecords) { this._tableRecords = tableRecords; }
+  set tableRecordObj(tableRecordObj) { this._tableRecordObj = tableRecordObj; }
+  set visibleRecords(visibleRecords) { this._visibleRecords = visibleRecords ?? []; }
+  set columns(columns) { this._columns = columns; }
+  set selectable(selectable) { this._selectable = selectable; }
+  set selectionBackend(selectionBackend) { this._selectionBackend = selectionBackend; }
+  set selectionField(selectionField) { this._selectionField = selectionField; }
+  set allSelected(allSelected) { this._allSelected = allSelected; }
+  set tableCode(tableCode) { this._tableCode = tableCode; }
+  set tableTitle(tableTitle) { this._tableTitle = tableTitle; }
+  set currentPage(currentPage) { this._currentPage = currentPage; }
+  set totalPages(totalPages) { this._totalPages = totalPages; }
+  set requestedPage(requestedPage) { this._requestedPage = requestedPage; }
+  set recordsPerPage(recordsPerPage) { this._recordsPerPage = recordsPerPage; }
+  set totalRecordsNumber(totalRecordsNumber) { this._totalRecordsNumber = totalRecordsNumber; }
+  set recordsNumber(recordsNumber) { this._recordsNumber = recordsNumber; }
+  set sorting(sorting) { this._sorting = sorting; }
+  set waiting(waiting) { this.setAttr(attrs.waiting, waiting) }
+  set clientPaging(clientPaging) { this._clientPaging = clientPaging; }
+  set sortable(sortable) { this._sortable = sortable; }
+
+  getLayout() { return this.layout; }
+  setLayout(layout) { this.setAttr(attrs.layout, layout); }
+  hasActions() { return (this._actions.length > 0); }
+  getSelectedRecords() { return this._tableRecords.filter(rec => rec.selected).map(rec => rec.recordId); }
+  activateGlobalSearch() { this._globalSearch = true; }
+  inactivateGlobalSearch() { this._globalSearch = false; }
+  columnDefinition(fieldCode): RecordTableColumn { return this._tableColumnObj[fieldCode]; }
+  putOnWait() { this.waiting = true; }
+  freeWaiting() { this.waiting = false; }
+  setWidget(widget) { this.widget = widget; }
+
+  notifyGlobalAction(actionCode) {
+    const tableEvent: TableEvent = {
+      tableCode: this._tableCode,
+      actionCode,
+      actionDetail: null
+    };
+    this._globalActionTrigger.next(tableEvent);
+  }
+
+  notifyInlineAction(tableActionEvent: TableActionEvent) {
+    const tableEvent: TableEvent = {
+      tableCode: this._tableCode,
+      actionCode: tableActionEvent.actionCode,
+      actionDetail: {
+        recordId: tableActionEvent.recordId,
+        recordData: tableActionEvent.recordData
+      }
+    };
+    this._inlineActionTrigger.next(tableEvent);
+  }
+
+  notifyRecordSelection(recordId) {
+    const record = this.getTableRecord(recordId);
+    if (!record) { return; }
+    record.toggleSelect();
+    this._requestedPage = this._currentPage ?? 1;
+    const tableEvent: TableEvent = {
+      tableCode: this._tableCode,
+      actionCode: null,
+      actionDetail: {
+        recordId: record.recordId,
+        recordData: record.recordData
+      }
+    };
+    this._recordSelectionTrigger.next(tableEvent);
+  }
+
+  notifySelectionAction(actionCode) {
+    const tableEvent: TableEvent = {
+      tableCode: this._tableCode,
+      actionCode,
+      actionDetail: {
+        selectedRecords: this.selectedRecords
+      }
+    };
+    this._selectionActionTrigger.next(tableEvent);
+  }
+
+  notifyGetDataAction(requestedPage = null) {
+    this.updateVisibleRecords();
+    this._requestedPage = requestedPage || this._currentPage || 1;
+    const tableEvent: TableEvent = {
+      tableCode: this._tableCode,
+      actionCode: null,
+      actionDetail: null,
+    };
+    this._getDataTrigger.next(tableEvent);
+    return null;
+  }
+
+  clean() {
+    this._tableRecords = [];
+    this.unSelectAll();
+    this._tableRecordObj = {};
+    this.updateVisibleRecords();
+  }
+
+  selectAll() {
+    this.setAttr(attrs.allSelected, true);
+    this._tableRecords.forEach(record => record.select());
+    this.setAttr(attrs.selectedRecords, this.getSelectedRecords());
+    return true;
+
+  }
+
+  unSelectAll() {
+    this.setAttr(attrs.allSelected, false);
+    this._tableRecords.forEach(record => record.unselect());
+    this.setAttr(attrs.selectedRecords, this.getSelectedRecords());
+    return true;
+  }
+
+  setTableRecords(tableRecords, append = false, prepend = false) {
+    if (!append) {
+      this._tableRecords = [];
+      this._tableRecordObj = {};
+      this.setAttr(attrs.allSelected, false);
+      this.setAttr(attrs.selectedRecords, []);
+    }
+    const newRecordsObj = { ...this._tableRecordObj };
+    const newRecords = [...this._tableRecords];
+    for (const tableRecord of tableRecords) {
+      tableRecord.tableRecordId = tableRecord.tableRecordId ?? tableRecord.recordId ?? tableRecord.recordIdKey;
+      const recordReceived: TableRecordData = new TableRecordData(tableRecord, this._columns, this._selectionField);
+      const recordIdKey = recordReceived.recordIdKey ?? recordReceived.recordIdKey;
+      if (newRecordsObj[recordIdKey]) {
+        continue;
+      }
+      if (prepend) {
+        newRecords.unshift(recordReceived);
+      } else {
+        newRecords.push(recordReceived);
+      }
+      newRecordsObj[recordIdKey] = recordReceived;
+    }
+    this._tableRecords = newRecords;
+    this._tableRecordObj = newRecordsObj;
+  }
+
+  appendRecords(records) { this.setTableRecords(records, true); }
+  prependRecords(records) { this.setTableRecords(records, true, true); }
+  replaceRecords(records) { this.setTableRecords(records, false); }
+
+  setTableAppend(append: boolean) { this._appendPages = append }
+
+  changePage(requestedPage) {
+    if (this._clientPaging) {
+      this.setAttr(attrs.currentPage, requestedPage);
+      this.updateVisibleRecords();
+    } else {
+      this.notifyGetDataAction(requestedPage);
+    }
+  }
+
+  updateVisibleRecords() {
+    let visibleRecords: any[];
+    if (this._clientPaging) {
+      visibleRecords = this.getFilteredRecords();
+      // Se valida si la página actual sigue siendo válida
+      const totalRecords = visibleRecords.length;
+      const recordsLastPage = totalRecords % this._recordsPerPage;
+      const totalPages = Math.trunc(totalRecords / this._recordsPerPage + (recordsLastPage ? 1 : 0));
+      if (this._currentPage > totalPages) {
+        this._currentPage = totalPages || 1;
+      }
+      const sliceNumber1 = (this._currentPage - 1) * this._recordsPerPage;
+      const sliceNumber2 = (this._currentPage - 1) * this._recordsPerPage + this._recordsPerPage
+      visibleRecords = visibleRecords.slice(sliceNumber1, sliceNumber2);
+      this.setAttr(attrs.totalRecordsNumber, totalRecords);
+    } else {
+      visibleRecords = this._tableRecords;
+    }
+    this.setAttr(attrs.visibleRecords, visibleRecords ?? []);
+  }
+
+  updateFromServer(tableReceived) {
+    this._requestedPage = 1;
+    const { visible = true, totalPages = 1, recordsNumber, currentPage = 1, recordsPerPage,
+      totalRecordsNumber, sortingColumn, sortingDirection, tableRecords,
+      actions, fields,
+    } = tableReceived;
+    this.visible = visible;
+    if (actions) {
+      Object.keys(actions).forEach(actionCode => {
+        const tblAction = this.getAction(actionCode);
+        const actionReceived = actions[actionCode];
+        if (actionReceived.visible === true || actionReceived.visible === false) {
+          (actionReceived.visible === true) && tblAction.show();
+          (actionReceived.visible === false) && tblAction.hide();
+        }
+        if (actionReceived.enabled === true || actionReceived.enabled === false) {
+          (actionReceived.enabled === true) && tblAction.enable();
+          (actionReceived.enabled === false) && tblAction.disable();
+        }
+        if (actionReceived.showOnStates) {
+          actionReceived.showOnStates?.forEach(newState => {
+            tblAction.addVisibleState(newState);
+          });
+        }
+        if (actionReceived.hideOnStates) {
+          actionReceived.hideOnStates?.forEach(newState => {
+            tblAction.removeVisibleState(newState);
+          });
+        }
+        if (actionReceived.enableOnStates) {
+          actionReceived.enableOnStates?.forEach(newState => {
+            tblAction.addEnabledState(newState);
+          });
+        }
+        if (actionReceived.disableOnStates) {
+          actionReceived.disableOnStates?.forEach(newState => {
+            tblAction.removeEnabledState(newState);
+          });
+        }
+      });
+    }
+    if (fields) {
+      Object.keys(fields).forEach(fieldCode => {
+        const tblField = this.columnDefinition(fieldCode);
+        const fieldReceived = fields[fieldCode];
+        if (fieldReceived.visible === true || fieldReceived.visible === false) {
+          (fieldReceived.visible === true) && tblField.show();
+          (fieldReceived.visible === false) && tblField.hide();
+        }
+      });
+    }
+    if (tableRecords) {
+      this._totalPages = totalPages;
+      this._recordsNumber = recordsNumber;
+      this.setAttr(attrs.currentPage, +currentPage);
+      this.setAttr(attrs.recordsPerPage, +recordsPerPage);
+      this.setAttr(attrs.totalRecordsNumber, (this._clientPaging) ? tableRecords.length : +totalRecordsNumber);
+      this.setAttr(attrs.sorting, {
+        columnName: sortingColumn || '',
+        direction: sortingDirection || ''
+      });
+      if (!this._appendPages) {
+        this.replaceRecords(tableRecords);
+      } else {
+        this.appendRecords(tableRecords);
+      }
+    }
+    this.freeWaiting();
+    this.updateVisibleRecords();
+  }
+
+  getTableRecord(recordId) {
+    const recordIdKey = (typeof recordId === 'object') ? JSON.stringify(recordId) : recordId;
+    return (this._tableRecordObj && recordId && this._tableRecordObj[recordId])
+      ? this._tableRecordObj[recordId] : null;
+  }
+
+  getAction(actionCode) {
+    return (this._actionsObj && actionCode && this._actionsObj[actionCode])
+      ? this._actionsObj[actionCode] : null;
+  }
+
+  getActions(actionClass: string = this._formConfig.tableActions.inline, actionTypes: string[] = null) {
+    return this._actions.filter(actionDef => {
+      const typeIncluded = (actionTypes) ? actionTypes.includes(actionDef.actionType) : true;
+      return actionDef.actionClass === actionClass && typeIncluded;
+    });
+  }
+
+  // Filtros
+
+  setFilterById(id) {
+    if (this.restrictedId === id) { return; }
+    this.restrictedId = id;
+    this.updateVisibleRecords();
+  }
+
+  cleanIdFilter() {
+    if (this.restrictedId === null) { return; }
+    this.restrictedId = null;
+    this.updateVisibleRecords();
+  }
+
+  setGlobalFilterString(text, notifyComponent = true) {
+    this.globalFilterStrings = text.split(' ').filter(t => t && t.trim().length > 0).map(t => t.trim()) ?? [];
+    if (this._clientPaging) {
+      this.changePage(1);
+    }
+    if (notifyComponent) {
+      this.setAttr(attrs.globalFilterString, text.trim());
+    }
+  }
+
+  addFilterDefinition(columnName, filterDefinition) {
+    const tableColumn = this.columnDefinition(columnName);
+    tableColumn && tableColumn.addFilterDefinition(filterDefinition);
+  }
+
+  getFilteredRecords() {
+    let filteredRecords = this._tableRecords;
+    if (this.restrictedId) {
+      filteredRecords = filteredRecords.filter(record => record.recordId === this.restrictedId);
+    }
+    if (this.globalFilterStrings.length > 0) {
+      filteredRecords = filteredRecords.filter(record => record.hasPattern(this.globalFilterStrings, this._tableColumnObj));
+    }
+    const columnFilters = this._columns.filter(column => column.filter).map(column => column.filter);
+    if (columnFilters.length > 0) {
+      filteredRecords = filteredRecords.filter(record => record.hasCondition(columnFilters));
+    }
+    return filteredRecords;
+  }
+
+  getColumnFilter(columnName: string) {
+    const tableColumn = this.columnDefinition(columnName);
+    return tableColumn?.filter ?? null;
+  }
+
+  addColumnFilter(columnName: string, columnValues: any | any[], operator: string | null = null) {
+    const tableColumn = this.columnDefinition(columnName);
+    const columnFilterDefinition = tableColumn?.filterDefinition ?? null;
+    if (!columnFilterDefinition) {
+      return;
+    }
+    tableColumn && tableColumn.addFilter(columnValues, operator);
+    this.updateVisibleRecords();
+  }
+
+  removeColumnFilter(columnName: string) {
+    const tableColumn = this.columnDefinition(columnName);
+    tableColumn && tableColumn.removeFilter();
+    this.updateVisibleRecords();
+  }
+
+  get currentFilter() {
+    const compactFilter: any = {
+      simpleFilterWords: this.globalFilterStrings,
+      advancedFilter: [],
+    };
+    const columnFilters = this._columns.filter(column => column.filter).map(column => column.filter);
+    for (let index = 0; index < columnFilters.length; index++) {
+      const columnFilter = columnFilters[index];
+      compactFilter.advancedFilter.push({
+        fieldCode: columnFilter?.fieldCode,
+        operator: columnFilter?.operator,
+        fieldValue1: columnFilter?.values[0],
+        fieldValue2: columnFilter?.values[1],
+      });
+    }
+    return compactFilter;
+  }
+
+  // Ordenamiento de registros local
+
+  sort(columnName, direction) {
+    this.setRequiredOrder(columnName, direction);
+    if (this._clientPaging) {
+      this.localSortData()
+    } else {
+      this.notifyGetDataAction();
+    }
+  }
+
+  setRequiredOrder(columnField, direction = null) {
+    this.setAttr(attrs.sorting, {
+      columnName: columnField,
+      direction: (direction === 'ascend') ? TABLE_SORT_ASCENDING : TABLE_SORT_DESCENDING,
+    });
+  }
+
+  localSortData() {
+    if (!this._sorting.columnName || !this._sorting.direction) { return; }
+    this._tableRecords.sort((a, b) => this.recordCompare(a, b, this._sorting.columnName, this._sorting.direction));
+    //this.unSelectAll();
+    this.updateVisibleRecords();
+  }
+
+  recordCompare(recordA: TableRecordData, recordB: TableRecordData, columnCompare, direction) {
+    const recordAValue = recordA.getFieldValue(columnCompare);
+    const recordBValue = recordB.getFieldValue(columnCompare);
+    const recordAColumn = isNaN(recordAValue) ? recordAValue.toLocaleLowerCase() : +recordAValue;
+    const recordBColumn = isNaN(recordBValue) ? recordBValue.toLocaleLowerCase() : +recordBValue;
+    let result = 0;
+    if (recordAColumn < recordBColumn) {
+      result = -1;
+    } else if (recordAColumn > recordBColumn) {
+      result = 1;
+    }
+    return direction === TABLE_SORT_ASCENDING ? result : -result;
+  }
+
+  override formStateChangeCustomSubscribe(form, formChangeSubject) {
+    this._columns?.forEach(column => {
+      column?.connectWithParentForm(form, formChangeSubject);
+    });
+    this._actions?.forEach(action => {
+      action?.connectWithParentForm(form, formChangeSubject);
+    });
+  }
+}