tuain-ng-forms-lib 17.2.20 → 17.2.22

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

@@ -0,0 +1,692 @@
+import { Subject } from 'rxjs';
+import { FormAction } from './action';
+import { FieldDescriptor, FieldOption } from './field';
+import { RecordTable } from './table/table';
+import { RecordFormSection } from './section';
+import { RecordFormSubSection } from './subsection';
+import { NO_ERROR, HEADER } from './form.constants';
+import { TableRecordData } from './table/row-data';
+
+const ACTIVE = 'active';
+const SHOW = 'show';
+const HIDE = 'hide';
+const ENABLE = 'enable';
+const DISABLE = 'disable';
+const CLEAN = 'clean';
+
+const alwaysVisible = 'ALWAYS';
+const neverVisible = 'NONE';
+const onStatesVisible = 'ONSTATES';
+interface Transition {
+  name: string;
+  source: string;
+  destination: string;
+}
+
+interface StateFlow {
+  defaultState: string;
+  states: string[];
+  stateDescriptions: string[];
+  transitions: Transition[];
+}
+
+export interface FieldPayload {
+  fieldCode: string;
+  fieldValue: any;
+  editable: boolean;
+  visible: boolean;
+  required: boolean;
+  fieldOptions: string,
+}
+
+export interface TablePayload {
+  tableCode: string;
+  visible: boolean;
+  currentPage: number;
+  requestedPage: number;
+  recordsPerPage: number;
+  currentFilter: any,
+  sortingColumn: string;
+  sortingDirection: string;
+}
+
+interface FormPayload {
+  fields: FieldPayload[],
+  tables: TablePayload[],
+}
+
+export class FormStructureAndData {
+  private readonly _stateChange = new Subject<any>();
+  private _immutableData = {};
+  private _extraInfo = {};
+  private _exclusiveSectionsByAttr = {};
+
+  protected loadInitialData: boolean = true;
+  protected subject: string | null = null;
+  protected stateFlow: StateFlow;
+  protected fields = {};
+  protected actions = {};
+  protected tables = {};
+  protected sections = {};
+  protected fieldArray: FieldDescriptor[];
+  protected actionArray: FormAction[];
+  protected tableArray: RecordTable[];
+  protected sectionArray: RecordFormSection[];
+
+  public customAttributes: any = {};
+  formConfig: any;
+  state: string;
+  name: string = '';
+  title: string = '';
+
+  constructor() {
+    this.state = '';
+    this.actionArray = [];
+    this.fieldArray = [];
+    this.tableArray = [];
+    this.sectionArray = [];
+    this.stateFlow = {
+      defaultState: '',
+      states: [],
+      stateDescriptions: [],
+      transitions: [],
+    };
+  }
+
+  setConfig(formConfig) {
+    this.formConfig = formConfig;
+  }
+
+  cleanForm() {
+    this.actionArray = [];
+    this.fieldArray = [];
+    this.tableArray = [];
+    this.sectionArray = [];
+    this.stateFlow = {
+      defaultState: '',
+      states: [],
+      stateDescriptions: [],
+      transitions: [],
+    };
+  }
+
+  loadDefinition(definitionReceived) {
+    this.state = '';
+    let allStates = [];
+    this.cleanForm();
+    if (!definitionReceived) { return; }
+    const { form = {} } = definitionReceived;
+    this.name = this.name ?? form.formCode;
+    this.title = form.formTitle ?? this.name;
+    this.loadInitialData = form.loadInitialData ?? true;
+    allStates = definitionReceived?.states;
+    this.setStateFlow(definitionReceived?.states, definitionReceived?.transitions,
+      definitionReceived?.defaultState, definitionReceived?.stateDescriptions);
+    this.immutableData = definitionReceived.immutableData;
+    this.extraInfo = definitionReceived.extraInfo;
+    this.customAttributes = {};
+    if (definitionReceived?.customAttributes) {
+      this.setCustomAttributes(definitionReceived?.customAttributes);
+    }
+    if (definitionReceived.actions) {
+      const formActions = definitionReceived.actions.map(objDef => {
+        let visibleStates = objDef.visibleStates
+          ?? (objDef.actionModes?.split(',')?.map(state => state.trim())?.filter(state => state))
+          ?? [];
+        let enabledStates = objDef.enabledStates ?? objDef.editableStates ?? [];
+        if (!Array.isArray(visibleStates) && typeof visibleStates === 'string') {
+          visibleStates = (visibleStates === neverVisible) ? [] : allStates;
+        }
+        if (!Array.isArray(enabledStates) && typeof enabledStates === 'string') {
+          enabledStates = (enabledStates === neverVisible) ? [] : visibleStates;
+        }
+        enabledStates = enabledStates.filter(state => visibleStates.includes(state));
+        return { ...objDef, visibleStates, enabledStates };
+      });
+      for (const actionReceived of formActions) {
+        const globalAction = new FormAction(actionReceived, this.formConfig);
+        const globalActionCode = globalAction.actionCode;
+        if (globalActionCode) {
+          this.actionArray.push(globalAction);
+          this.actions[globalActionCode] = globalAction;
+        }
+      }
+    }
+
+    if (definitionReceived.fields) {
+      const formFields = definitionReceived.fields.map(objDef => {
+        let visibleStates = objDef.visibleStates
+          ?? (objDef.fieldModes?.split(',')?.map(state => state.trim())?.filter(state => state))
+          ?? [];
+        let enabledStates = objDef.enabledStates ?? objDef.editableStates ?? [];
+        if (!Array.isArray(visibleStates) && typeof visibleStates === 'string') {
+          visibleStates = (visibleStates === neverVisible) ? [] : allStates;
+        }
+        if (!Array.isArray(enabledStates) && typeof enabledStates === 'string') {
+          enabledStates = (enabledStates === neverVisible) ? [] : visibleStates;
+        }
+        enabledStates = enabledStates.filter(state => visibleStates.includes(state));
+        return { ...objDef, visibleStates, enabledStates };
+      });
+      for (const fieldReceived of formFields) {
+        const fieldToAdd = new FieldDescriptor(fieldReceived, this.formConfig);
+        const fieldCode = fieldToAdd.code;
+        if (fieldCode) {
+          this.fieldArray.push(fieldToAdd);
+          this.fields[fieldCode] = fieldToAdd;
+        }
+      }
+    }
+
+    if (definitionReceived.tables) {
+      const tables = definitionReceived.tables.map(objDef => {
+        let visibleStates = objDef.visibleStates
+          ?? (objDef.tableModes?.split(',')?.map(state => state.trim())?.filter(state => state))
+          ?? [];
+        let enabledStates = objDef.enabledStates ?? objDef.editableStates ?? [];
+        if (!Array.isArray(visibleStates) && typeof visibleStates === 'string') {
+          visibleStates = (visibleStates === neverVisible) ? [] : allStates;
+        }
+        if (!Array.isArray(enabledStates) && typeof enabledStates === 'string') {
+          enabledStates = (enabledStates === neverVisible) ? [] : visibleStates;
+        }
+        enabledStates = enabledStates.filter(state => visibleStates.includes(state));
+        return { ...objDef, visibleStates, enabledStates };
+      });
+      for (const tableReceived of tables) {
+        const tableToAdd = new RecordTable(tableReceived, this.formConfig);
+        const tableCode = tableToAdd.tableCode;
+        if (tableCode) {
+          this.tableArray.push(tableToAdd);
+          this.tables[tableCode] = tableToAdd;
+        }
+      }
+    }
+
+    if (definitionReceived.sections) {
+      const formSections = definitionReceived.sections.map(objDef => {
+        let visibleStates = objDef.visibleStates
+          ?? (objDef.sectionModes?.split(',')?.map(state => state.trim())?.filter(state => state))
+          ?? [];
+        if (!Array.isArray(visibleStates) && typeof visibleStates === 'string') {
+          visibleStates = (visibleStates === neverVisible) ? [] : allStates;
+        }
+        const subsections = objDef.subsections.map(subSecDef => {
+          let subSecVisibleStates = subSecDef.visibleStates ?? [];
+          if (!Array.isArray(subSecVisibleStates) && typeof subSecVisibleStates === 'string') {
+            subSecVisibleStates = (subSecVisibleStates === neverVisible) ? [] : allStates;
+          }
+          return { ...subSecDef, visibleStates: subSecVisibleStates };
+        });
+        return { ...objDef, subsections, visibleStates };
+      });
+      for (const sectionReceived of formSections) {
+        const sectionToAdd = new RecordFormSection(sectionReceived, this, this.formConfig);
+        const sectionCode = sectionToAdd.sectionCode;
+        if (sectionCode) {
+          this.sectionArray.push(sectionToAdd);
+          this.sections[sectionCode] = sectionToAdd;
+        }
+      }
+    }
+  }
+
+  // Estados
+  get defaultState(): string { return this.stateFlow.defaultState; }
+  get states(): any[] { return this.stateFlow.states; }
+  get stateDescriptions(): any[] { return this.stateFlow.stateDescriptions; }
+  supportState(state: string = ''): boolean { return (!!state && this.stateFlow.states?.includes(state)); }
+
+  getNextStates(): string[] {
+    return this.stateFlow.transitions.filter(trns => trns.source === this.state)
+      .map(trns => trns.destination);
+  }
+
+  changeState(newState: string): boolean {
+    const currentState = this.state;
+    if (!newState || !this.supportState(newState) || currentState === newState) {
+      return false;
+    }
+    if (!this.state) {
+      this.state = newState;
+    } else {
+      const transitionToChange = this.stateFlow.transitions.find(trns =>
+        trns.source === this.state && trns.destination === newState);
+      if (transitionToChange) {
+        this.state = newState;
+      }
+    }
+    this._stateChange.next({ state: this.state });
+    return (this.state === newState);
+  }
+
+  get stateChange() { return this._stateChange.asObservable(); }
+
+  setStateFlow(states?, transitions?, defaultState?: string, stateDescriptions = []): void {
+    this.stateFlow.states = states;
+    this.stateFlow.stateDescriptions = stateDescriptions;
+    this.stateFlow.defaultState = defaultState || this.stateFlow.states[0];
+    this.stateFlow.transitions = transitions.map(transition => {
+      const name = transition.name;
+      const source = (this.stateFlow.states.includes(transition.source)) ? transition.source : '';
+      const destination = (this.stateFlow.states.includes(transition.destination)) ? transition.destination : '';
+      return { name, source, destination };
+    }).filter(item => item.name && item.source && item.destination);
+  }
+
+  // immutable Data
+  getImmutableElement(name: string): any { return this._immutableData?.[name]?.value ?? null; }
+  set immutableData(immutableData) { Object.assign(this._immutableData, immutableData); }
+  get immutableData(): any { return JSON.parse(JSON.stringify(this._immutableData)); }
+
+  // extra Info
+  getExtraInfo(name: string): any { return this._extraInfo?.[name]?.value ?? null; }
+  set extraInfo(extraInfo) { Object.assign(this._extraInfo, extraInfo); }
+  get extraInfo(): any { return JSON.parse(JSON.stringify(this._extraInfo)); }
+
+  // Custom Attributes
+  getCustomAttribute(name: string): any { return this.customAttributes?.[name] ?? null; }
+  setCustomAttribute(name: string, value: any): void { if (name) { this.customAttributes[name] = value; } }
+  setCustomAttributes(attributes: any): FormStructureAndData {
+    if (attributes && typeof attributes === 'object') {
+      Object.entries(attributes).forEach(([name, value]) => {
+        this.setCustomAttribute(name, value);
+      });
+    }
+    return this;
+  }
+
+  // Fields
+  get fieldNames(): string[] { return this.getFieldNames(); }
+  getFields(): FieldDescriptor[] { return this.fieldArray; }
+  getFieldNames(): string[] { return this.fieldArray.map(field => field.code); }
+  getField(code: string): FieldDescriptor { return (code && this.fields?.[code]) ? this.fields[code] : null; }
+  enableField(code: string): void { this.getField(code)?.enable(); }
+  disableField(code: string): void { this.getField(code)?.disable(); }
+  getFieldValue(code: string): any { return this.getField(code)?.value; }
+  getFieldOptionText(code: string): any { return this.getField(code)?.optionText; }
+  getFieldOptions(code: string): FieldOption[] | null { return this.getField(code)?.options ?? null; }
+  setFieldValue(code: string, value: any): any { this.getField(code)?.setValue(value); }
+  setFieldError(code: string, errorCode: string, message: string, type: string = 'error'): any { this.getField(code)?.setError(errorCode, message, type); }
+  setFieldIntrinsicErrorMessage(code: string, message: string): any { this.getField(code)?.setIntrinsicErrorMessage(message); }
+
+  setFieldRequired(inputCodes: string[] | string | null, required: boolean): any {
+    const codes = this.getFieldSet(null, inputCodes ?? null);
+    for (const code of codes) {
+      try {
+        const field = this.getField(code) ?? null;
+        field && (field.required = required);
+      } catch (e) {
+        console.log(`Error modificando campo ${code}: ${e}`);
+      }
+    }
+  }
+
+  setFieldErrorMessage(code: string, message: string): any { this.getField(code)?.setErrorMessage(message); }
+
+  setFieldOptions(code: string, optionsArray: any[], idAttribute: string, valueAttribute: string | string[], saparator = '-'): any {
+    const field = this.getField(code);
+    if (!field) { return; }
+    const newOptions: any[] = [];
+    const numSeparators = (Array.isArray(valueAttribute)) ? (valueAttribute.length - 1) : 0;
+    for (let i = 0; i < optionsArray?.length; i++) {
+      const optionItem = optionsArray[i];
+      const fieldOptionId = optionItem?.[idAttribute];
+      let fieldOptionText = '';
+      if (Array.isArray(valueAttribute)) {
+        for (let index = 0; index < valueAttribute.length; index++) {
+          const textPart = valueAttribute[index];
+          fieldOptionText += (index < numSeparators)
+            ? `${optionItem?.[textPart]} ${saparator} ` : optionItem?.[textPart];
+        }
+      } else {
+        fieldOptionText = optionItem?.[valueAttribute];
+      }
+      if (fieldOptionId !== undefined && fieldOptionId !== null
+        && fieldOptionText !== undefined && fieldOptionText !== null) {
+        newOptions.push({ fieldOptionId, fieldOptionValue: fieldOptionText });
+      }
+    }
+    field.options = newOptions;
+  }
+
+  getFieldSet(filter, inputCodes: string[] | string | null, secCode?: string | null, subCode?: string | null): string[] {
+    let codes: any[] = [];
+    if (inputCodes) {
+      if (typeof inputCodes === 'string') {
+        codes = [inputCodes];
+      } else if (Array.isArray(inputCodes) && inputCodes.length > 0) {
+        codes = inputCodes ?? [];
+      }
+    } else if (secCode && !subCode) {
+      codes = this.getSection(secCode)?.getFieldNames() ?? [];
+    } else if (secCode && subCode) {
+      codes = this.getSubSection(secCode, subCode)?.getFieldNames() ?? [];
+    } else {
+      codes = this.getFieldNames() ?? [];
+    }
+    return (filter) ? codes.filter(fld => filter(this.getField(fld))) : codes;
+  }
+
+  applyOnFields(processFunc, inputCodes?: string[] | string | null, secCode?: string, subCode?: string): number {
+    if (!processFunc) { return 0; }
+    const codes = this.getFieldSet(null, inputCodes ?? null, secCode, subCode);
+    let processedFields = 0;
+    for (const code of codes) {
+      const field = this.getField(code);
+      if (field) {
+        try {
+          processFunc(field);
+          processedFields += 1;
+        } catch (e) {
+          console.log(`Error procesando funcion en campo ${field}: ${e}`);
+        }
+      }
+    }
+    return processedFields;
+  }
+
+  applyProcessToAllFields(processFunc) {
+    return this.applyOnFields(processFunc);
+  }
+
+  enableFields(codes?: string[] | string | null, secCode?: string, subCode?: string): number {
+    return this.applyOnFields(fld => fld?.enable(), codes, secCode, subCode);
+  }
+
+  showFields(codes?: string[] | string | null, secCode?: string, subCode?: string): number {
+    return this.applyOnFields(fld => fld?.show(), codes, secCode, subCode);
+  }
+
+  hideFields(codes?: string[] | string | null, secCode?: string, subCode?: string): number {
+    return this.applyOnFields(fld => fld?.hide(), codes, secCode, subCode);
+  }
+
+  showLabelFields(codes?: string[] | string | null, secCode?: string, subCode?: string): number {
+    return this.applyOnFields(fld => fld?.showLablel(), codes, secCode, subCode);
+  }
+
+  hideLabelFields(codes?: string[] | string | null, secCode?: string, subCode?: string): number {
+    return this.applyOnFields(fld => fld?.hideLabel(), codes, secCode, subCode);
+  }
+
+  disableFields(codes?: string[] | string | null, secCode?: string, subCode?: string): number {
+    return this.applyOnFields(fld => fld?.disable(), codes, secCode, subCode);
+  }
+
+  cleanFields(codes?: string[] | string | null, secCode?: string, subCode?: string): number {
+    return this.applyOnFields(fld => fld?.clean(), codes, secCode, subCode);
+  }
+
+  tagFieldsWithError(message: string, codes?: string[] | string | null, secCode?: string, subCode?: string): number {
+    return this.applyOnFields(fld => fld?.setErrorMessage(message), codes, secCode, subCode);
+  }
+
+  cleanErrorFields(codes?: string[] | string | null, secCode?: string, subCode?: string): number {
+    return this.tagFieldsWithError('', codes, secCode, subCode);
+  }
+
+  tagEmptyRequiredFields(message: string, codes = null, secCode?: string, subCode?: string): boolean {
+    return this.tagFieldsWithError(message, this.getRequiredEmptyFields(codes, secCode, subCode)) > 0;
+  }
+
+  getRequiredFields(codes?: string[] | string | null, secCode?: string, subCode?: string): string[] {
+    return this.getFieldSet(fld => fld?.required, codes ?? null, secCode, subCode);
+  }
+
+  getRequiredEmptyFields(codes?: string[] | string | null, secCode?: string, subCode?: string, onlyVisible?: boolean): string[] {
+    if (onlyVisible) {
+      return this.getFieldSet(fld => fld?.required && fld?.visible && fld?.empty, codes ?? null, secCode, subCode);
+    }
+    return this.getFieldSet(fld => fld?.required && fld?.empty, codes ?? null, secCode, subCode);
+  }
+
+  getChangedFields(codes?: string[] | string | null, secCode?: string, subCode?: string): string[] {
+    return this.getFieldSet(fld => !fld?.outputOnly && fld?.hasChanged, codes ?? null, secCode, subCode);
+  }
+
+  getFieldsWithValidationIssues(codes?: string[] | string | null, secCode?: string, subCode?: string, onlyVisible?: boolean): string[] {
+    if (onlyVisible) {
+      return this.getFieldSet(fld => (fld?.hasError() && fld?.visible), codes ?? null, secCode, subCode);
+    }
+    return this.getFieldSet(fld => fld?.hasError(), codes ?? null, secCode, subCode);
+  }
+
+  getFieldsValues(inputCodes?: string[] | string | null, secCode?: string, subCode?: string): any {
+    const codes = this.getFieldSet(null, inputCodes ?? null, secCode, subCode);
+    const resultObject = {};
+    for (let index = 0; index < codes.length; index++) {
+      const code = codes[index];
+      if (code) {
+        resultObject[code] = this.fields?.[code]?.getValue() ?? null;
+      }
+    }
+    return resultObject;
+  }
+
+  // Acciones
+  getActions(): FormAction[] { return this.actionArray; }
+  getAction(code: string): FormAction { return (code && this.actions?.[code]) ? this.actions[code] : null; }
+  showActions(codes: string[] | string): void { return this.execOnActions(codes, SHOW); }
+  hideActions(codes: string[] | string): void { return this.execOnActions(codes, HIDE); }
+  enableActions(codes: string[] | string): void { return this.execOnActions(codes, ENABLE); }
+  disableActions(codes: string[] | string): void { return this.execOnActions(codes, DISABLE); }
+  enableAction(code: string): void { return this.enableActions(code); }
+  disableAction(code: string): void { return this.disableActions(code); }
+  showAction(code: string): void { return this.showActions(code); }
+  hideAction(code: string): void { return this.hideActions(code); }
+  getHeaderActions() { return this.getActionsByAttribute('location', HEADER); }
+
+  getActionsByAttribute(name: string, value): FormAction[] {
+    return this.actionArray.filter(actionItem => actionItem.matchAttribute(name, value));
+  }
+
+  execOnActions(codes: string[] | string | null, functionName: string): void {
+    const actionCodes = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
+    if (!functionName || actionCodes.length === 0) { return; }
+    actionCodes.forEach(code => {
+      const action = this.getAction(code);
+      action?.[functionName]?.();
+    });
+  }
+
+  // Tablas
+  getTables(): RecordTable[] { return this.tableArray; }
+  getTable(code: string): RecordTable { return (code && this.tables?.[code]) ? this.tables[code] : null; }
+  getTableRecord(code: string, id: string): TableRecordData { return this.getTable(code)?.getTableRecord(id) }
+  enableTables(codes: string[] | string): void { return this.execOnTables(codes, ENABLE); }
+  disableTables(codes: string[] | string): void { return this.execOnTables(codes, DISABLE); }
+  showTables(codes: string[] | string): void { return this.execOnTables(codes, SHOW); }
+  hideTables(codes: string[] | string): void { return this.execOnTables(codes, HIDE); }
+  cleanTables(codes: string[] | string): void { return this.execOnTables(codes, CLEAN); }
+  showTable(code: string) { return this.showTables(code); }
+  hideTable(code: string) { return this.hideTables(code); }
+  cleanTable(code: string) { return this.getTable(code)?.clean(); }
+
+  execOnTables(codes: string[] | string | null, functionName: string) {
+    const tableCodes = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
+    if (!functionName || tableCodes.length === 0) { return; }
+    tableCodes.forEach(code => {
+      const table = this.getTable(code);
+      table?.[functionName]?.();
+    });
+  }
+
+  // Secciones
+  getSections(): RecordFormSection[] { return this.sectionArray; }
+  getSectionsTitles(): string[] { return this.getSections()?.filter(sec => sec?.title).map(sec => sec?.title ?? ''); }
+  numSections(): number { return this.sectionArray.length; }
+  getSectionsByAttribute(name, value): RecordFormSection[] { return this.sectionArray.filter(item => item.matchAttribute(name, value)); }
+  get sectionTitles(): string[] { return this.getSectionsTitles(); }
+  get visibleSections(): RecordFormSection[] { return this.sectionArray.filter(sec => sec.absoluteVisible); }
+  getSection(code: string): RecordFormSection { return (code && this.sections?.[code]) ? this.sections[code] : null; }
+  showSections(codes: string[] | string): void { this.execOnSections(codes, SHOW); }
+  hideSections(codes: string[] | string): void { this.execOnSections(codes, HIDE); }
+  showSection(code: string): void { return this.showSections(code); }
+  hideSection(code: string): void { return this.hideSections(code); }
+  activeSection(): string { return this._exclusiveSectionsByAttr[ACTIVE]; }
+  getSubSection(code: string, subCode): RecordFormSubSection { return this.getSection(code)?.getSubsection(subCode) ?? null; }
+  showSubSections(code: string, subCodes: string[] | string): void { return this.execOnSubSections(code, subCodes, SHOW); }
+  showSubSection(code: string, subCode: string): void { return this.showSubSections(code, subCode); }
+  hideSubSection(code: string, subCode: string): void { return this.hideSubSections(code, subCode); }
+  hideSubSections(code: string, subCodes: string[] | string): void { return this.execOnSubSections(code, subCodes, HIDE); }
+  getSectionActions(code): FormAction[] { return this.getSection(code)?.getActions() ?? null; }
+  getSectionActionNames(code): string[] { return this.getSection(code)?.getActionNames() ?? null; }
+
+  activateSection(code: string): void {
+    if (code === this._exclusiveSectionsByAttr[ACTIVE]) { return; }
+    this.getSection(this.activeSection())?.inactivate();
+    this.getSection(code)?.activate();
+    this._exclusiveSectionsByAttr[ACTIVE] = code;
+  }
+
+  execOnSections(codes: string[] | string | null, functionName: string): void {
+    const sectionCodes = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
+    if (!functionName || sectionCodes.length === 0) { return; }
+    sectionCodes.forEach(code => {
+      const section = this.getSection(code);
+      section?.[functionName]?.();
+    });
+  }
+
+  execOnSubSections(code: string, subNames: string[] | string | null, functionName: string): void {
+    const subCodes = (Array.isArray(subNames)) ? subNames : (subNames ? [subNames] : []);
+    const section = this.getSection(code);
+    if (!functionName || !section || subCodes.length === 0) { return; }
+    for (const subCode of subCodes) {
+      const subSection = this.getSubSection(code, subCode);
+      subSection?.[functionName]?.();
+    }
+  }
+
+  /**
+   * Métodos propios de gestión del formulario
+   */
+
+  cleanData(): void {
+    for (const field of this.fieldArray) {
+      field.setValue(field.defaultValue);
+    }
+    for (const table of this.tableArray) {
+      table.clean();
+    }
+  }
+
+  getPayload(): any {
+    const formData: FormPayload = { fields: [], tables: [] };
+    formData.fields = this.getFields().filter(fld => !fld?.outputOnly)
+      .map(fld => {
+        const fieldPayload: FieldPayload = {
+          fieldCode: fld?.code,
+          fieldValue: fld?.value,
+          editable: !fld?.absoluteDisabled,
+          visible: fld?.absoluteVisible,
+          required: fld?.required,
+          fieldOptions: '',
+        }
+        return fieldPayload;
+      });
+
+    formData.tables = this.getTables().map(tbl => {
+      const tablePayload: TablePayload = {
+        tableCode: tbl.tableCode,
+        visible: tbl.absoluteVisible,
+        currentPage: tbl.currentPage,
+        requestedPage: tbl.requestedPage,
+        recordsPerPage: tbl.recordsPerPage,
+        currentFilter: tbl.currentFilter,
+        sortingColumn: tbl.sorting.columnName,
+        sortingDirection: tbl.sorting.direction,
+      };
+      return tablePayload
+    })
+    return formData;
+  }
+
+  /**
+   * @deprecated Use subject
+   */
+  get formSubject() { return this.subject; }
+
+  /**
+   * @deprecated Use subject
+   */
+  set formSubject(subject) { this.subject = subject; }
+
+  /**
+   * @deprecated Use states
+   */
+  getStates() { return this.states; }
+
+  /**
+   * @deprecated Use state
+   */
+  getCurrentState(): string { return this.state; }
+
+  /**
+   * @deprecated Use title
+   */
+  getTitle(): string { return this.title; }
+
+  /**
+   * @deprecated Use title
+   */
+  setTitle(title: string): void { this.title = title; }
+
+  /**
+   * @deprecated Use supportState
+   */
+  supportMode(state: string): boolean { return this.supportState(state); }
+
+  /**
+   * @deprecated Use enableFields
+   */
+  enableEditFields(codes?: string[] | string | null, secCode?: string, subCode?: string) {
+    return this.enableFields(codes, secCode, subCode);
+  }
+  /**
+   * @deprecated Use disableFields
+   */
+  disableEditFields(codes?: string[] | string | null, secCode?: string, subCode?: string) {
+    return this.disableFields(codes, secCode, subCode);
+  }
+
+  /**
+   * @deprecated Use getField
+   */
+  getFieldObject(code: string): FieldDescriptor | null { return this.getField(code); }
+
+  /**
+   * @deprecated Use getAction
+   */
+  getActionObject(code: string): FormAction | null { return this.getAction(code); }
+
+  /**
+   * @deprecated Use getTable
+   */
+  getTableObject(code: string): RecordTable | null { return this.getTable(code); }
+
+  /**
+   * @deprecated Use getSection
+   */
+  getSectionObject(code: string): RecordFormSection | null { return this.getSection(code); }
+
+  /**
+   * @deprecated Use changeState
+   */
+  changeFormMode(state: string): boolean { return this.changeState(state); }
+
+  /**
+   * @deprecated Use subject
+   */
+  getFormSubject(): string { return this.subject; }
+  /**
+   * @deprecated Use subject
+   */
+  getSubject(): string { return this.subject ?? ''; }
+  /**
+   * @deprecated Use subject
+   */
+  getformSubject(): string { return this.subject ?? ''; }
+
+}