tuain-ng-forms-lib 13.0.15 → 14.0.1

package/src/lib/components/forms/basic-form.ts

@@ -0,0 +1,1496 @@
+import { Component } from '@angular/core';
+import { FormStructureAndData } from '../../classes/forms/form';
+import { LibFormManagerService } from '../../services/form-manager.service';
+import { LibEventManagerService } from '../../services/event-manager.service';
+import { LibFileManagementService } from '../../services/file-manager.service';
+import { formActions, NO_ERROR, HEADER } from '../../classes/forms/form.constants';
+import { FormAction } from '../../classes/forms/action';
+import { FieldDescriptor, FieldOption } from '../../classes/forms/field';
+import { RecordTable } from '../../classes/forms/table/table';
+import { RecordFormSection } from '../../classes/forms/section';
+import { RecordFormSubSection } from '../../classes/forms/subsection';
+
+const PAYLOAD_VERSION = 'TUAINEXCHANGE_1.0';
+const INLINE_ACTION = 'INLINE';
+const GLOBAL_ACTION = 'GLOBAL';
+const GET_DATA_ACTION = 'GETDATA';
+
+const SUBJECT = 'subject';
+const TOKEN = 'token';
+
+@Component({
+  template: `<ng-content></ng-content>`
+})
+export class BasicFormComponent {
+  private _formStructure: FormStructureAndData | null = null;
+  private _controlToken: string | null = null;
+  private _originToken: string | null = null;
+  private _formRoute: string | null = null;
+  private _definitionObtained: boolean = false;
+  // Eventos de acciones y campos
+  private _formSectionsActivate: any = {};
+  private _formSectionsInactivate: any = {};
+  private _formActionsStart: any = {};
+  private _formActionsFinish: any = {};
+  private _fieldInputValidation: any = {};
+  private _fieldValidationsStart: any = {};
+  private _fieldValidationsFinish: any = {};
+  // Callback de acciones de tablas
+  private _tableSelectionsStart: any = {};
+  private _tableSelectionsFinish: any = {};
+  private _tableActionsStart: any = {};
+  private _tableActionsFinish: any = {};
+  private _tableGetDataStart: any = {};
+  private _tableGetDataFinish: any = {};
+
+  private _actionServerError: any[] = [];
+  private _fieldServerError: any[] = [];
+  private _tableServerError: any[] = [];
+
+  protected inputDataFields: any = {};
+  protected extraData: any = {};
+  protected _eventEmiter: LibEventManagerService;
+  protected enabledSections: RecordFormSection[] = [];
+
+  formConfig: any;
+  name: string | null = null;
+  formSubject: string | null = null;
+  _errorType: string = '';
+  errorCode: string = '';
+  errorFullCode: string = '';
+  errorName: string = '';
+  errorMessage: string = '';
+  errorDetail: string = '';
+  visible: boolean = false;
+
+  fields: any;
+  actions: any;
+  sections: any;
+  busy: boolean = false;
+
+  getTitle() { return this._formStructure?.getTitle(); }
+  setTitle(title: string) { return this._formStructure?.setTitle(title); }
+  cleanData() { return this._formStructure?.cleanData(); }
+  getCurrentState() { return this._formStructure?.getCurrentState(); }
+  supportState(state: string | null) { return this._formStructure?.supportState(state ?? '') ?? false; }
+  changeState(state): boolean { return this._formStructure?.changeState(state) ?? false; }
+  getStates() { return this._formStructure?.states; }
+  getImmutableElement(name: string) { return this._formStructure?.getImmutableElement(name); }
+  getExtraInfo(name: string) { return this._formStructure?.getExtraInfo(name); }
+  getFields() { return this._formStructure?.getFields() ?? null; }
+  getFieldNames() { return this._formStructure?.getFieldNames() ?? null; }
+  getField(code: string) { return this._formStructure?.getField(code) ?? null; }
+  enableField(code: string) { return this._formStructure?.enableField(code); }
+  disableField(code: string) { return this._formStructure?.disableField(code); }
+  getFieldValue(code: string): any { return this._formStructure?.getFieldValue(code) ?? null; }
+  getFieldOptionText(code: string): any { return this._formStructure?.getFieldOptionText(code); }
+  getFieldsValues(codes: string[]) { return this._formStructure?.getFieldsValues(codes) ?? null; }
+  getFieldOptions(code: string): FieldOption[] | null { return this._formStructure?.getFieldOptions(code) ?? null; }
+  setFieldValue(code: string, value: any) { return this._formStructure?.setFieldValue(code, value); }
+  setFieldRequired(code: string, required: boolean) { return this._formStructure?.setFieldRequired(code, required); }
+  setFieldErrorMessage(code: string, errorMessage: string) { return this._formStructure?.setFieldErrorMessage(code, errorMessage); }
+  setFieldError(code: string, errorCode: string, message: string, type?: string) { return this._formStructure?.setFieldError(code, errorCode, message, type); }
+  setFieldIntrinsicErrorMessage(code: string, message: string) {
+    return this._formStructure?.setFieldIntrinsicErrorMessage(code, message);
+  }
+  setFieldOptions(code, optionsArray, idAttribute, nameAttribute) {
+    return this._formStructure?.setFieldOptions(code, optionsArray, idAttribute, nameAttribute);
+  }
+  getFieldSet(filterFunc?, codes?: string[] | string | null, secCode?: string | null, subCode?: string | null) {
+    return this._formStructure?.getFieldSet(filterFunc, codes ?? null, secCode ?? null, subCode ?? null);
+  }
+  applyOnFields(processFunc, codes?: string[] | string | null, secCode?: string, subCode?: string) {
+    return this._formStructure?.applyOnFields(processFunc, codes, secCode, subCode);
+  }
+  applyProcessToAllFields(processFunc) {
+    return this._formStructure?.applyOnFields(processFunc);
+  }
+  cleanFields(codes?: string[] | string | null, secCode?: string, subCode?: string) {
+    return this._formStructure?.cleanFields(codes, secCode, subCode);
+  }
+  getRequiredFields(codes?: string[] | string | null, secCode?: string, subCode?: string) {
+    return this._formStructure?.getRequiredFields(codes, secCode, subCode);
+  }
+  getRequiredEmptyFields(codes?: string[] | string | null, secCode?: string, subCode?: string) {
+    return this._formStructure?.getRequiredEmptyFields(codes, secCode, subCode) ?? null;
+  }
+  getChangedFields(codes?: string[] | string | null, secCode?: string, subCode?: string) {
+    return this._formStructure?.getChangedFields(codes, secCode, subCode);
+  }
+  getFieldsWithValidationIssues(codes?: string[] | string | null, secCode?: string, subCode?: string) {
+    return this._formStructure?.getFieldsWithValidationIssues(codes, secCode, subCode);
+  }
+  tagFieldsWithError(errorMessage: string, codes?: string[] | string | null, secCode?: string, subCode?: string) {
+    return this._formStructure?.tagFieldsWithError(errorMessage, codes, secCode, subCode);
+  }
+  cleanErrorFields(codes?: string[] | string | null, secCode?: string, subCode?: string) {
+    return this._formStructure?.cleanErrorFields(codes, secCode, subCode);
+  }
+  showLabelFields(codes?: string[] | string | null, secCode?: string, subCode?: string) {
+    return this._formStructure?.showLabelFields(codes, secCode, subCode);
+  }
+  hideLabelFields(codes?: string[] | string | null, secCode?: string, subCode?: string) {
+    return this._formStructure?.hideLabelFields(codes, secCode, subCode);
+  }
+  enableFields(codes?: string[] | string | null, secCode?: string, subCode?: string) {
+    return this._formStructure?.enableFields(codes, secCode, subCode);
+  }
+  disableFields(codes?: string[] | string | null, secCode?: string, subCode?: string) {
+    return this._formStructure?.disableFields(codes, secCode, subCode);
+  }
+  /**
+   * @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);
+  }
+  showFields(codes?: string[] | string | null, secCode?: string, subCode?: string) {
+    return this._formStructure?.showFields(codes, secCode, subCode);
+  }
+  hideFields(codes?: string[] | string | null, secCode?: string, subCode?: string) {
+    return this._formStructure?.hideFields(codes, secCode, subCode);
+  }
+  getActionsByAttribute(name: string, value) {
+    return this._formStructure?.getActionsByAttribute(name, value);
+  }
+  getHeaderActions() {
+    return this._formStructure?.getActionsByAttribute('location', HEADER);
+  }
+  getAction(actionCode: string): FormAction | null {
+    return this._formStructure?.getAction(actionCode) ?? null;
+  }
+  showActions(actionArray): void {
+    return this._formStructure?.showActions(actionArray);
+  }
+  hideActions(actionArray): void {
+    return this._formStructure?.hideActions(actionArray);
+  }
+  enableActions(actionArray): void {
+    return this._formStructure?.enableActions(actionArray);
+  }
+  disableActions(actionArray): void {
+    return this._formStructure?.disableActions(actionArray);
+  }
+  showAction(code: string): void {
+    return this._formStructure?.showActions(code);
+  }
+  hideAction(code: string): void {
+    return this._formStructure?.hideActions(code);
+  }
+  enableAction(code: string): void {
+    return this._formStructure?.enableActions(code);
+  }
+  disableAction(code: string): void {
+    return this._formStructure?.disableActions(code);
+  }
+  getSections(): RecordFormSection[] | null {
+    return this._formStructure?.getSections() ?? null;
+  }
+  activateSection(code): void {
+    return this._formStructure?.activateSection(code);
+  }
+  getSectionsTitles(): string[] | null {
+    return this._formStructure?.getSections().map(sec => sec.title) ?? null;
+  }
+  getSection(code: string): RecordFormSection | null {
+    return this._formStructure?.getSection(code) ?? null;
+  }
+  showSection(code: string): void {
+    return this._formStructure?.showSections(code);
+  }
+  hideSection(code: string): void {
+    return this._formStructure?.hideSections(code);
+  }
+  showSections(codes: string[] | string): void {
+    return this._formStructure?.showSections(codes);
+  }
+  hideSections(codes: string[] | string): void {
+    return this._formStructure?.hideSections(codes);
+  }
+  getSubSection(code: string, subCode: string): RecordFormSubSection | null {
+    return this._formStructure?.getSubSection(code, subCode) ?? null;
+  }
+  showSubSection(code: string, subCode: string): void {
+    return this._formStructure?.showSubSections(code, subCode);
+  }
+  hideSubSection(code: string, subCode: string): void {
+    return this._formStructure?.hideSubSections(code, subCode);
+  }
+  showSubSections(code: string, subCodes: string[] | string): void {
+    return this._formStructure?.showSubSections(code, subCodes);
+  }
+  hideSubSections(code: string, subCodes: string[] | string): void {
+    return this._formStructure?.hideSubSections(code, subCodes);
+  }
+  getSectionActions(code: string): FormAction[] | null {
+    return this._formStructure?.getSectionActions(code) ?? null;
+  }
+  getSectionActionNames(code: string): string[] | null {
+    return this._formStructure?.getSectionActionNames(code) ?? null;
+  }
+
+  getTables() {
+    return this._formStructure?.getTables();
+  }
+  showTables(codes: string[] | string) {
+    return this._formStructure?.showTables(codes);
+  }
+  hideTables(codes: string[] | string) {
+    return this._formStructure?.hideTables(codes);
+  }
+  cleanTables(codes: string[] | string) {
+    return this._formStructure?.cleanTables(codes);
+  }
+  getTable(code: string) {
+    return this._formStructure?.getTable(code) ?? null;
+  }
+  showTable(code: string) {
+    return this._formStructure?.showTables(code);
+  }
+  hideTable(code: string) {
+    return this._formStructure?.hideTables(code);
+  }
+  cleanTable(code: string) {
+    return this._formStructure?.getTable(code)?.clean();
+  }
+  getTableRecord(code: string, recordId: any) {
+    return this._formStructure?.getTableRecord(code, recordId);
+  }
+
+  constructor(
+    protected formManagerService: LibFormManagerService,
+    protected _eventManager: LibEventManagerService,
+    protected fileMgmtServices: LibFileManagementService) {
+    this._eventEmiter = this._eventManager;
+    this.cleanStart();
+    this.customPreProcessing();
+  }
+
+  setConfig(formConfig) {
+    this.formConfig = formConfig;
+  }
+
+  cleanStart() {
+    this._errorType = '';
+    this.errorCode = '';
+    this.errorFullCode = '';
+    this.errorName = '';
+    this.errorMessage = '';
+    this.errorDetail = '';
+    this._formStructure = null;
+    this.fields = null;
+    this.actions = null;
+    this.sections = null;
+    this._controlToken = null;
+    this.inputDataFields = {};
+    this._definitionObtained = false;
+    // Se limpian los manejadores de eventos
+    this.visible = false;
+    this.busy = false;
+    this._formSectionsActivate = {};
+    this._formSectionsInactivate = {};
+    this._formActionsStart = {};
+    this._formActionsFinish = {};
+    this._fieldInputValidation = {};
+    this._fieldValidationsStart = {};
+    this._fieldValidationsFinish = {};
+    this._tableSelectionsStart = {};
+    this._tableSelectionsFinish = {};
+    this._tableActionsStart = {};
+    this._tableActionsFinish = {};
+    this._tableGetDataStart = {};
+    this._tableGetDataFinish = {};
+
+    this._actionServerError = [];
+    this._fieldServerError = [];
+    this._tableServerError = [];
+
+    this.onActionServerError(() => this.displayActionServerError());
+    this.onValidationServerError(() => this.displayValidationServerError());
+    this.onTableServerError(() => this.displayTableServerError());
+  }
+
+  get formVisible(): boolean { return this.visible; }
+  get formManager() { return this; }
+  get formCode(): string { return this.name ?? ''; }
+  set formCode(name: string) { this.name = name; }
+  get inServerProcess() { return this.busy; }
+  get form(): FormStructureAndData | null { return this._formStructure; }
+
+  get state(): string | null { return this._formStructure?.state ?? null; }
+  get currentState(): string { return this._formStructure?.state ?? ''; }
+  set currentState(state: string) { this?._formStructure?.changeState(state); }
+  get immutableData(): any { return this._formStructure?.immutableData }
+  get extraInfo(): any { return this._formStructure?.extraInfo }
+  get visibleSections(): RecordFormSection[] | null { return this._formStructure?.visibleSections ?? null; }
+
+  get formRoute(): string { return this._formRoute ?? ''; }
+  set formRoute(route: string) { this._formRoute = route; }
+
+  get subject(): string { return this.formSubject ?? ''; }
+
+  // Métodos virtuales
+  customPreProcessing() { }
+  customFormStart() { }
+  displayActionServerError() { }
+  displayValidationServerError() { }
+  displayTableServerError() { }
+  showFieldInfo(fieldCode?: string, detail?: any) { }
+  showModalDialog(title, body, options, callback?, params?) { }
+  openUploadDialog(title, body, options, callback?, params?) { }
+
+  /**
+   * @deprecated Use supportState
+   */
+  supportMode(state: string): boolean { return this.supportState(state); }
+
+  /**
+   * @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.formSubject ?? ''; }
+  /**
+   * @deprecated Use subject
+   */
+  getformSubject(): string { return this.formSubject ?? ''; }
+
+
+  numSections(): number { return this._formStructure?.sections.length; }
+
+  subscribeAppEvent(eventName: string, callback): void {
+    this._eventEmiter.subscribe(eventName, callback);
+  }
+
+  openForm(name: string, data: any = null, backData: any = null, cleanStack = false): void {
+    let origin: any = null;
+    if (!cleanStack) {
+      origin = { ...backData, name: this.name, url: this._formRoute, token: this._controlToken };
+      origin.subject = origin?.subject ?? this.formSubject;
+      origin.state = origin?.state ?? this.state;
+      origin.fields = origin?.fields ?? {};
+      origin.extra = origin?.extra ?? {};
+    }
+    const target = { ...data, name };
+    target.subject = target?.subject ?? null;
+    target.state = target?.state ?? null;
+    target.fields = target?.fields ?? {};
+    target.extra = target?.extra ?? {};
+    this.formManagerService.openForm(origin, target);
+  }
+
+  canGoBack(): boolean { return this._originToken !== null }
+  goBack(): void { return this.formManagerService.backTo(); }
+  goBackForm(): void { return this.goBack(); }
+  getOriginDetail(): any { return this.formManagerService?.getFormInfo(this._originToken ?? ''); }
+
+  setError(errorType: string | null, errorMessage: string | null, errorDetail: string | null): void {
+    this._errorType = errorType || '';
+    this.errorMessage = errorMessage || '';
+    this.errorDetail = errorDetail || '';
+  }
+
+  resetError(): void {
+    this.errorCode = NO_ERROR;
+    this.errorFullCode = '';
+    this.errorName = '';
+    this.errorMessage = '';
+    this.errorDetail = '';
+  }
+
+  getErrorType(): string { return this._errorType; }
+  getErrorMessage(): string { return this.errorMessage; }
+  getErrorDetail(): string { return this.errorDetail; }
+  getErrorName(): string { return this.errorName; }
+  getErrorFullCode(): string { return this.errorFullCode; }
+  getErrorCode(): string { return this.errorCode; }
+
+  getFormParameter(name: string): string {
+    return (name) ? (this.extraData?.[name] ?? null) : null;
+  }
+
+  preocessInputParams(params: any): string | null {
+    this._controlToken = params?.[TOKEN] ?? null;
+    this.formSubject = params?.[SUBJECT] ?? null;
+    const tokenInfo: any = (this._controlToken) ? this.formManagerService.getFormInfo(this._controlToken) : {};
+    const { token, subject, state, fields, extra, originToken } = tokenInfo;
+    if (token && this._controlToken === token) {
+      this.formSubject = this.formSubject ?? subject ?? null;
+      this.inputDataFields = fields;
+      this.extraData = extra;
+      this._originToken = originToken;
+      return state;
+    }
+    return null;
+  }
+
+  subscribeSectionActivation(): void {
+    const formSections = this._formStructure?.sections;
+    const sectionNames = Object.keys(formSections);
+    for (let index = 0; index < sectionNames.length; index++) {
+      const sectionName = sectionNames[index];
+      const section = formSections[sectionName];
+      section.activation.subscribe((code: string) => this.launchSectionActivation(code));
+      section.inactivation.subscribe((code: string) => this.launchSectionInactivation(code));
+    }
+  }
+
+  subscribeFieldsSubjects(): void {
+    const formFields = this._formStructure?.getFields();
+    if (Array.isArray(formFields)) {
+      formFields.forEach(field => {
+        field.editionFinish.subscribe(event => {
+          const { code, intrinsicValidation } = event;
+          this.startFieldValidation(code, intrinsicValidation);
+        });
+        field.editionPartial.subscribe(event => {
+          const { code, intrinsicValidation } = event;
+          this.startFieldInputValidation(code, intrinsicValidation);
+        });
+        field.detailRequest.subscribe(event => this.showFieldInfo(event.code, event.detail));
+      });
+    }
+  }
+
+  subscribeActionSubjects(): void {
+    const formActions = this._formStructure?.getActions();
+    if (Array.isArray(formActions)) {
+      formActions.forEach(action => {
+        action.actionActivated.subscribe(code => this.startAction(code));
+      });
+    }
+  }
+
+  subscribeTableSubjects(): void {
+    const formTables = this._formStructure?.getTables();
+    if (Array.isArray(formTables)) {
+      formTables.forEach(table => {
+        table.inlineActionTrigger.subscribe(event => this.startTableAction(event));
+        table.globalActionTrigger.subscribe(event => this.startTableGlobalAction(event));
+        table.recordSelectionTrigger.subscribe(event => this.startTableRecordSelection(event));
+        table.selectionActionTrigger.subscribe(event => this.startTableSelectionAction(event));
+        table.getDataTrigger.subscribe(event => this.startTableGetData(event));
+      });
+    }
+  }
+
+  async formInit(params): Promise<void> {
+    let initialState: string | null = this.preocessInputParams(params);
+    if (!this.name) { return; }
+    if (!this._definitionObtained) {
+      this.busy = true;
+      const formDefinition = await this.formManagerService.getFormDefinition(this.name);
+      this.busy = false;
+      this._formStructure = new FormStructureAndData(formDefinition, this.formConfig);
+      this.fields = this._formStructure?.fields;
+      this.actions = this._formStructure?.actions;
+      this.sections = this._formStructure?.sections;
+      this._definitionObtained = true;
+    } else {
+      this.cleanData();
+    }
+    if (!this.supportState(initialState)) {
+      initialState = this._formStructure?.defaultState ?? null;
+    }
+    this._formStructure?.changeState(initialState || this._formStructure?.defaultState);
+    const inputFieldNames = Object.keys(this.inputDataFields);
+    for (let index = 0; index < inputFieldNames.length; index++) {
+      const fieldCode = inputFieldNames[index];
+      const fieldValue = this.inputDataFields[fieldCode];
+      this.setFieldValue(fieldCode, fieldValue);
+    }
+    const recordResponse = await this.requestFormAction(formActions.getData);
+    this.checkErrorRecordReceived(recordResponse);
+    this.visible = true;
+    this.enabledSections = this._formStructure?.visibleSections ?? [];
+    this.subscribeSectionActivation();
+    this.subscribeFieldsSubjects();
+    this.subscribeActionSubjects();
+    this.subscribeTableSubjects();
+    this.customFormStart();
+  }
+
+  checkErrorRecordReceived(recordResponse: any): boolean {
+    const { error } = recordResponse;
+    if (!error) { return false; }
+    this.errorCode = recordResponse.errorCode;
+    this.errorFullCode = recordResponse.errorFullCode;
+    this.errorName = recordResponse.errorName;
+    this.errorMessage = recordResponse.errorMessage;
+    this.errorDetail = recordResponse.errorDetail;
+    return true;
+  }
+
+  errorOccured(): boolean {
+    return (this.errorCode !== NO_ERROR);
+  }
+
+  /**
+   * Soporte manejo de eventos de formulario
+   */
+
+  async requestFormAction(actionCode: string, actionSubject: any = {}): Promise<any> {
+    const actionDetail = {
+      formCode: this.name,
+      formSubject: this.formSubject,
+      currentMode: this._formStructure?.state,
+      actionCode,
+      actionSubject,
+      version: PAYLOAD_VERSION,
+      formData: this._formStructure?.getPayload(),
+      immutableData: this._formStructure?.immutableData,
+    };
+    this.errorCode = NO_ERROR;
+    this.errorFullCode = '';
+    this.errorName = '';
+    this.errorMessage = '';
+    this.errorDetail = '';
+    this.busy = true;
+    const formActionResponse: any = await this.formManagerService.execServerAction(actionDetail);
+    this.busy = false;
+    if (formActionResponse.hasError()) {
+      const error = formActionResponse.error;
+      this.errorCode = error.errorCode;
+      this.errorFullCode = error.errorFullCode;
+      this.errorName = error.errorName;
+      this.errorMessage = error.errorMessage;
+      this.errorDetail = error.errorDetail;
+    }
+    const formResponseData = formActionResponse.getData();
+    this.updateFormWithServerData(formResponseData);
+    return formResponseData;
+  }
+
+  updateFormWithServerData(formContent: any) {
+    const {
+      currentMode, formSubject, actions, fields, recordTables,
+      returnedFile, immutableData, extraInfo,
+    } = formContent;
+    currentMode && this.changeState(currentMode);
+    if (formSubject) { this.formSubject = formSubject; }
+    if (actions && actions.length > 0) {
+      for (const changedAction of actions) {
+        const actionObject = this.getAction(changedAction.actionCode);
+        if (actionObject) { actionObject.updateFromServer(changedAction); }
+      }
+    }
+    if (fields && fields.length > 0) {
+      for (const changedField of fields) {
+        const fieldObject = this.getField(changedField.fieldCode);
+        if (fieldObject) {
+          fieldObject.updateFromServer(changedField);
+        }
+      }
+    }
+    if (recordTables && recordTables.length > 0) {
+      for (const changedTable of recordTables) {
+        const tableObject = this.getTable(changedTable.tableCode);
+        if (tableObject) {
+          tableObject.updateFromServer(changedTable);
+        }
+      }
+    }
+    if (returnedFile && returnedFile.file) {
+      this.fileMgmtServices.saveFile(returnedFile.file, returnedFile.name, returnedFile.type);
+    }
+    if (this._formStructure) {
+      this._formStructure.immutableData = immutableData;
+      this._formStructure.extraInfo = extraInfo;
+    }
+  }
+
+  /**
+   * Manejo de event handlers para errores Server del formulario
+   */
+
+  cleanActionServerError() {
+    this._actionServerError = [];
+  }
+
+  cleanFieldServerError() {
+    this._fieldServerError = [];
+  }
+
+  cleanTableServerError() {
+    this._tableServerError = [];
+  }
+
+  onActionServerError(callback, properties = null) {
+    this._actionServerError.push({ callback, properties });
+  }
+
+  onValidationServerError(callback, properties = null) {
+    this._fieldServerError.push({ callback, properties });
+  }
+
+  onTableServerError(callback, properties = null) {
+    this._tableServerError.push({ callback, properties });
+  }
+
+  /**
+   * Manejo de event handlers para acciones sobre el formulario
+   */
+
+  onSectionActivation(codes: string[] | string | null, callback, properties = null) {
+    const sectionSet = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
+    sectionSet.forEach((sectionName) => {
+      if (!this._formSectionsActivate[sectionName]) {
+        this._formSectionsActivate[sectionName] = [];
+      }
+      this._formSectionsActivate[sectionName].push({ callback, properties });
+    });
+  }
+
+  onSectionInactivation(codes: string[] | string | null, callback, properties = null) {
+    const sectionSet = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
+    sectionSet.forEach((sectionName) => {
+      if (!this._formSectionsInactivate[sectionName]) {
+        this._formSectionsInactivate[sectionName] = [];
+      }
+      this._formSectionsInactivate[sectionName].push({ callback, properties });
+    });
+  }
+
+  onActionStart(codes: string[] | string | null, callback, properties = null) {
+    const actionSet = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
+    actionSet.forEach((actionName) => {
+      if (!this._formActionsStart[actionName]) {
+        this._formActionsStart[actionName] = [];
+      }
+      this._formActionsStart[actionName].push({ callback, properties });
+    });
+  }
+
+  onActionFinish(codes: string[] | string | null, callback, properties = null) {
+    const actionSet = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
+    actionSet.forEach((actionName) => {
+      if (!this._formActionsFinish[actionName]) {
+        this._formActionsFinish[actionName] = [];
+      }
+      this._formActionsFinish[actionName].push({ callback, properties });
+    });
+  }
+
+  async launchSectionActivation(code: string) {
+    const sectionObject = this._formStructure?.getSection(code);
+    if (!sectionObject) { return; }
+    const clientSectionMethods = this._formSectionsActivate[code];
+    if (clientSectionMethods) {
+      for (const clientSectionMethod of clientSectionMethods) {
+        const { callback, properties } = clientSectionMethod;
+        callback(sectionObject);
+      }
+    }
+  }
+
+  async launchSectionInactivation(code: string) {
+    const sectionObject = this._formStructure?.getSection(code);
+    if (!sectionObject) { return; }
+    const clientSectionMethods = this._formSectionsInactivate[code];
+    if (clientSectionMethods) {
+      for (const clientSectionMethod of clientSectionMethods) {
+        const { callback, properties } = clientSectionMethod;
+        callback(sectionObject);
+      }
+    }
+  }
+
+  async startAction(code: string) {
+    const actionObject = this.getAction(code);
+    if (!actionObject) { return; }
+    this.resetError();
+    actionObject.start();
+    const clientActionMethods = this._formActionsStart[code];
+    if (clientActionMethods) {
+      const clientActionPromises: any[] = [];
+      for (const clientActionMethod of clientActionMethods) {
+        const { callback, properties } = clientActionMethod;
+        const continueActionPromise = callback(actionObject);
+        clientActionPromises.push(continueActionPromise);
+      }
+      const clientActionResults = await Promise.all(clientActionPromises);
+      const continueAction = clientActionResults.reduce((total, curr) => (total && (curr !== false)), true);
+      if (!continueAction) {
+        actionObject.stop();
+        return;
+      }
+    }
+    this.startServerAction(actionObject);
+  }
+
+  async startServerAction(actionInput) {
+    const action = (typeof actionInput === 'string')
+      ? this.getAction(actionInput) : actionInput;
+    let serverError = false;
+    let actionResult = null;
+    if (action.backend) {
+      actionResult = await this.requestFormAction(action.actionCode);
+      serverError = !!this.errorOccured();
+    }
+    await this.finishAction(action, actionResult, serverError);
+    if (!serverError) {
+      action.newState && this.changeState(action.newState);
+    } else {
+      for (let index = 0; index < this._actionServerError.length; index++) {
+        const { callback, properties } = this._actionServerError[index];
+        callback(action);
+      }
+    }
+    action.stop();
+  }
+
+  async finishAction(action, actionResult, serverError = false) {
+    const finishActionMethods = this._formActionsFinish[action.actionCode];
+    if (finishActionMethods) {
+      const clientActionPromises: any[] = [];
+      for (const clientActionMethod of finishActionMethods) {
+        const { callback, properties } = clientActionMethod;
+        const continueOnError = properties?.continueOnError ?? false;
+        if (!serverError || continueOnError) {
+          clientActionPromises.push(callback(action, actionResult));
+        }
+      }
+      await Promise.all(clientActionPromises);
+    }
+  }
+
+  completeGlobalAction(action: any) {
+    return this.startServerAction(action);
+  }
+
+  /**
+   * Manejadores de eventos para validaciones sobre campos
+   */
+
+  onFieldInput(codes: string[] | string | null, callback, properties = null) {
+    const fieldSet = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
+    fieldSet.forEach((fieldCode) => {
+      if (!this._fieldInputValidation[fieldCode]) {
+        this._fieldInputValidation[fieldCode] = [];
+      }
+      this._fieldInputValidation[fieldCode].push({ callback, properties });
+    });
+  }
+
+  onFieldValidationStart(codes: string[] | string | null, callback, properties = null) {
+    const fieldSet = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
+    fieldSet.forEach((fieldCode) => {
+      if (!this._fieldValidationsStart[fieldCode]) {
+        this._fieldValidationsStart[fieldCode] = [];
+      }
+      this._fieldValidationsStart[fieldCode].push({ callback, properties });
+    });
+  }
+
+  onFieldValidationFinish(codes: string[] | string | null, callback, properties = null) {
+    const fieldSet = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
+    fieldSet.forEach((fieldCode) => {
+      if (!this._fieldValidationsFinish[fieldCode]) {
+        this._fieldValidationsFinish[fieldCode] = [];
+      }
+      this._fieldValidationsFinish[fieldCode].push({ callback, properties });
+    });
+  }
+
+  async startFieldInputValidation(fieldCode: string, intrinsicValidation: boolean = true) {
+    const fieldToValidate = this.getField(fieldCode);
+    if (!fieldToValidate) { return false; }
+    fieldToValidate.resetError();
+    const validationCallbacks = this._fieldInputValidation[fieldCode];
+    if (validationCallbacks) {
+      const clientValidationPromises: any[] = [];
+      for (const validationMethod of validationCallbacks) {
+        const { callback, properties } = validationMethod;
+        const continueValidationPromise = callback(fieldToValidate);
+        clientValidationPromises.push(continueValidationPromise);
+      }
+      await Promise.all(clientValidationPromises);
+    }
+    return true;
+  }
+
+  async startFieldValidation(fieldCode: string, intrinsicValidation: boolean = true) {
+    const fieldToValidate = this.getField(fieldCode);
+    if (!fieldToValidate) { return; }
+    fieldToValidate.resetError();
+    const validationCallbacks = this._fieldValidationsStart[fieldCode];
+    if (validationCallbacks) {
+      const clientValidationPromises: any[] = [];
+      for (const validationMethod of validationCallbacks) {
+        const { callback, properties } = validationMethod;
+        const clientValidationPromise = callback(fieldToValidate);
+        clientValidationPromises.push(clientValidationPromise);
+      }
+      const clientValidationResults = await Promise.all(clientValidationPromises);
+      const continueValidation = clientValidationResults.reduce((total, curr) => (total && (curr !== false)), true);
+      if (!continueValidation) {
+        return;
+      }
+    }
+    if (intrinsicValidation) {
+      this.startServerFieldValidation(fieldToValidate);
+    }
+  }
+
+  async startServerFieldValidation(inputField: string | FieldDescriptor) {
+    const fieldObj: FieldDescriptor | null = (typeof inputField === 'string')
+      ? this.getField(inputField) : inputField;
+    let serverError = false;
+    let validationResult: boolean = true;
+    if (!fieldObj) {
+      return;
+    }
+    if (fieldObj.backend) {
+      fieldObj.validating = true;
+      validationResult = await this
+        .requestFormAction(formActions.validate, fieldObj.fieldCode);
+      serverError = !!this.errorOccured();
+    }
+    await this.finishFieldValidation(fieldObj, validationResult, serverError);
+    if (serverError) {
+      fieldObj?.setErrorCode(this.errorCode);
+      fieldObj?.setErrorMessage(this.errorMessage);
+      for (let index = 0; index < this._fieldServerError.length; index++) {
+        const { callback, properties } = this._fieldServerError[index];
+        callback(fieldObj);
+      }
+    }
+    fieldObj.validating = false;
+  }
+
+  async finishFieldValidation(fieldObject: any, validationResult: boolean, serverError = false) {
+    const validationCallbacks = this._fieldValidationsFinish[fieldObject.fieldCode];
+    if (validationCallbacks) {
+      const clientActionPromises: any[] = [];
+      for (const validationMethod of validationCallbacks) {
+        const { callback, properties } = validationMethod;
+        const continueOnError = properties?.continueOnError ?? false;
+        if (!serverError || continueOnError) {
+          clientActionPromises.push(callback(fieldObject, validationResult));
+        }
+      }
+      await Promise.all(clientActionPromises);
+    }
+  }
+
+  async continueFieldValidation(fieldCode: string) {
+    return this.startServerFieldValidation(fieldCode);
+  }
+
+  /**
+   * Manejadores de eventos para acciones sobre Tablas
+   */
+
+  onTableActionStart(code: string, actionCode: string, callback, properties = null) {
+    const tableObject = this.getTable(code);
+    if (!tableObject) {
+      return;
+    }
+    const inlineActionObject = tableObject.getAction(actionCode);
+    if (!inlineActionObject) {
+      return;
+    }
+    let tableEventHandlers: any;
+    if (this._tableActionsStart[code]) {
+      tableEventHandlers = this._tableActionsStart[code];
+    } else {
+      tableEventHandlers = {};
+      this._tableActionsStart[code] = tableEventHandlers;
+    }
+    if (!tableEventHandlers[actionCode]) {
+      tableEventHandlers[actionCode] = [];
+    }
+    tableEventHandlers[actionCode].push({ callback, properties });
+  }
+
+  onTableActionFinish(code: string, actionCode: string, callback, properties = null) {
+    const tableObject = this.getTable(code);
+    if (!tableObject) {
+      return;
+    }
+    const inlineActionObject = tableObject.getAction(actionCode);
+    if (!inlineActionObject) {
+      return;
+    }
+    let tableEventHandlers: any;
+    if (this._tableActionsFinish[code]) {
+      tableEventHandlers = this._tableActionsFinish[code];
+    } else {
+      tableEventHandlers = {};
+      this._tableActionsFinish[code] = tableEventHandlers;
+    }
+    if (!tableEventHandlers[actionCode]) {
+      tableEventHandlers[actionCode] = [];
+    }
+    tableEventHandlers[actionCode].push({ callback, properties });
+  }
+
+  onTableSelectionStart(code: string, callback, properties = null) {
+    const tableObject = this.getTable(code);
+    if (!tableObject) { return; }
+    let tableEventHandlers: any[];
+    if (this._tableSelectionsStart[code]) {
+      tableEventHandlers = this._tableSelectionsStart[code];
+    } else {
+      tableEventHandlers = [];
+      this._tableSelectionsStart[code] = tableEventHandlers;
+    }
+    tableEventHandlers.push({ callback, properties });
+  }
+
+  onTableSelectionFinish(code: string, callback, properties = null) {
+    const tableObject = this.getTable(code);
+    if (!tableObject) { return; }
+    let tableEventHandlers: any[];
+    if (this._tableSelectionsFinish[code]) {
+      tableEventHandlers = this._tableSelectionsFinish[code];
+    } else {
+      tableEventHandlers = [];
+      this._tableSelectionsFinish[code] = tableEventHandlers;
+    }
+    tableEventHandlers.push({ callback, properties });
+  }
+
+  onTableGetDataStart(code: string, callback, properties = null) {
+    const tableObject = this.getTable(code);
+    if (!tableObject) {
+      return;
+    }
+    let tableEventHandlers: any[];
+    if (this._tableGetDataStart[code]) {
+      tableEventHandlers = this._tableGetDataStart[code];
+    } else {
+      tableEventHandlers = [];
+      this._tableGetDataStart[code] = tableEventHandlers;
+    }
+    tableEventHandlers.push({ callback, properties });
+  }
+
+  onTableGetDataFinish(code: string, callback, properties = null) {
+    const tableObject = this.getTable(code);
+    if (!tableObject) {
+      return;
+    }
+    let tableEventHandlers: any;
+    if (this._tableGetDataFinish[code]) {
+      tableEventHandlers = this._tableGetDataFinish[code];
+    } else {
+      tableEventHandlers = {};
+      this._tableGetDataFinish[code] = tableEventHandlers;
+    }
+    tableEventHandlers[GET_DATA_ACTION] = { callback, properties };
+  }
+
+  async startTableGlobalAction(tableActionEvent: any) {
+    const { tableCode, actionCode } = tableActionEvent;
+    const tableObject = this.getTable(tableCode);
+    if (!tableObject || !actionCode) { return; }
+    this.resetError();
+    const action = tableObject.getAction(actionCode);
+    if (!action) { return; }
+    const tableActionDetail = {
+      tableObject,
+      action,
+      tableCode,
+      actionCode,
+    };
+    const tableEventHandlers = this._tableActionsStart[tableCode];
+    const tableActionMethods = (tableEventHandlers) ? tableEventHandlers[actionCode] : null;
+    if (tableActionMethods) {
+      const clientActionPromises: any[] = [];
+      for (const tableActionMethod of tableActionMethods) {
+        const { callback, properties } = tableActionMethod;
+        const clientActionPromise = callback(tableActionDetail);
+        clientActionPromises.push(clientActionPromise);
+      }
+      const clientActionResults = await Promise.all(clientActionPromises);
+      const continueAction = clientActionResults.reduce((total, curr) => (total && (curr !== false)), true);
+      if (!continueAction) {
+        return;
+      }
+    }
+    this.startTableServerGlobalAction(tableActionDetail);
+  }
+
+  async startTableServerGlobalAction(tableActionDetail: any) {
+    const { tableObject, action, tableCode, actionCode } = tableActionDetail;
+    if (!tableObject || !action) { return; }
+    tableObject.putOnWait();
+    let serverError = false;
+    let actionResult = null;
+    if (action.backend) {
+      const actionSubject = {
+        tableCode,
+        actionType: GLOBAL_ACTION,
+        actionCode
+      };
+      actionResult = await this
+        .requestFormAction(formActions.tableAction, actionSubject);
+      serverError = !!this.errorOccured();
+    }
+    await this.finishTableGlobalAction(tableActionDetail, actionResult, serverError);
+    if (!serverError) {
+      action.newState && this.changeState(action.newState);
+    } else {
+      for (let index = 0; index < this._tableServerError.length; index++) {
+        const { callback, properties } = this._tableServerError[index];
+        callback(tableObject);
+      }
+    }
+    tableObject.freeWaiting();
+  }
+
+  async finishTableGlobalAction(tableActionDetail: any, actionResult, serverError = false) {
+    const { tableCode, actionCode } = tableActionDetail;
+    const tableEventHandlers = this._tableActionsFinish[tableCode];
+    const tableActionMethods = (tableEventHandlers) ? tableEventHandlers[actionCode] : null;
+    if (tableActionMethods) {
+      const clientActionPromises: any[] = [];
+      for (const tableActionMethod of tableActionMethods) {
+        const { callback, properties } = tableActionMethod;
+        const continueOnError = properties?.continueOnError ?? false;
+        if (!serverError || continueOnError) {
+          clientActionPromises.push(callback(tableActionDetail, actionResult));
+        }
+      }
+      await Promise.all(clientActionPromises);
+    }
+  }
+
+  async startTableAction(tableActionEvent: any) {
+    const { tableCode, actionCode, actionDetail } = tableActionEvent;
+    const tableObject = this.getTable(tableCode);
+    if (!tableObject || !actionCode) { return; }
+    this.resetError();
+    const { recordId, recordData } = actionDetail;
+    const action = tableObject.getAction(actionCode);
+    if (!action) { return; }
+    const tableActionDetail = {
+      tableObject,
+      action,
+      tableCode,
+      actionCode,
+      recordId,
+      recordData
+    };
+    const tableEventHandlers = this._tableActionsStart[tableCode];
+    const tableActionMethods = (tableEventHandlers) ? tableEventHandlers[actionCode] : null;
+    if (tableActionMethods) {
+      const clientActionPromises: any[] = [];
+      for (const tableActionMethod of tableActionMethods) {
+        const { callback, properties } = tableActionMethod;
+        const clientActionPromise = callback(tableActionDetail);
+        clientActionPromises.push(clientActionPromise);
+      }
+      const clientActionResults = await Promise.all(clientActionPromises);
+      const continueAction = clientActionResults.reduce((total, curr) => (total && (curr !== false)), true);
+      if (!continueAction) {
+        return;
+      }
+    }
+    this.startTableServerAction(tableActionDetail);
+  }
+
+  async startTableServerAction(tableActionDetail: any) {
+    const { tableObject, action, tableCode, actionCode, recordId, recordData } = tableActionDetail;
+    if (!tableObject || !action) { return; }
+    tableObject.putOnWait();
+    let serverError = false;
+    let actionResult = null;
+    if (action.backend) {
+      const actionSubject = {
+        tableCode,
+        actionType: this.formConfig.tableActions.inline,
+        actionCode,
+        tableRecordId: recordId,
+        tableRecordData: recordData
+      };
+      actionResult = await this
+        .requestFormAction(formActions.tableAction, actionSubject);
+      serverError = !!this.errorOccured();
+    }
+    await this.finishTableAction(tableActionDetail, actionResult, serverError);
+    if (!serverError) {
+      action.newState && this.changeState(action.newState);
+    } else {
+      this.displayTableServerError();
+    }
+    tableObject.freeWaiting();
+  }
+
+  completeInlineAction(tableAction: any) {
+    return this.startTableServerAction(tableAction);
+  }
+
+  async finishTableAction(tableActionDetail: any, actionResult, serverError = false) {
+    const { tableCode, actionCode } = tableActionDetail;
+    const tableEventHandlers = this._tableActionsFinish[tableCode];
+    const tableActionMethods = (tableEventHandlers) ? tableEventHandlers[actionCode] : null;
+    if (tableActionMethods) {
+      const clientActionPromises: any[] = [];
+      for (const tableActionMethod of tableActionMethods) {
+        const { callback, properties } = tableActionMethod;
+        const continueOnError = properties?.continueOnError ?? false;
+        if (!serverError || continueOnError) {
+          clientActionPromises.push(callback(tableActionDetail, actionResult));
+        }
+      }
+      await Promise.all(clientActionPromises);
+    }
+  }
+
+  async startTableRecordSelection(tableActionEvent: any) {
+    const { tableCode, actionDetail } = tableActionEvent;
+    const tableObject = this.getTable(tableCode);
+    if (!tableObject) { return; }
+    this.resetError();
+    const { recordId, recordData } = actionDetail;
+    const tableSelectionDetail = {
+      tableObject,
+      tableCode,
+      recordId,
+      recordData
+    };
+    const tableEventHandlers = this._tableSelectionsStart[tableCode];
+    if (tableEventHandlers) {
+      const clientActionPromises: any[] = [];
+      for (const tableSelectionMethod of tableEventHandlers) {
+        const { callback, properties } = tableSelectionMethod;
+        const clientActionPromise = callback(tableSelectionDetail);
+        clientActionPromises.push(clientActionPromise);
+      }
+      const clientActionResults = await Promise.all(clientActionPromises);
+      const continueAction = clientActionResults.reduce((total, curr) => (total && (curr !== false)), true);
+      if (!continueAction) {
+        return;
+      }
+    }
+    this.startTableServerRecordSelection(tableSelectionDetail);
+  }
+
+  async startTableServerRecordSelection(tableSelectionDetail: any) {
+    const { tableObject, tableCode, recordId, recordData } = tableSelectionDetail;
+    if (!tableObject) { return; }
+    tableObject.putOnWait();
+    let serverError = false;
+    let actionResult = null;
+    if (tableObject.selectionBackend) {
+      const actionSubject: any = {
+        tableCode,
+        actionType: this.formConfig.tableActions.rowSelection,
+        actionCode: null,
+        tableRecordId: recordId,
+        tableRecordData: recordData
+      };
+      actionResult = await this
+        .requestFormAction(formActions.tableAction, actionSubject);
+      serverError = !!this.errorOccured();
+    }
+    await this.finishTableRecordSelection(tableSelectionDetail, actionResult, serverError);
+    if (serverError) {
+      this.displayTableServerError();
+    }
+    tableObject.freeWaiting();
+  }
+
+  async finishTableRecordSelection(tableSelectionDetail: any, actionResult, serverError = false) {
+    const { tableCode } = tableSelectionDetail;
+    const tableEventHandlers = this._tableSelectionsFinish[tableCode];
+    if (tableEventHandlers) {
+      const clientActionPromises: any[] = [];
+      for (const tableSelectionMethod of tableEventHandlers) {
+        const { callback, properties } = tableSelectionMethod;
+        const continueOnError = properties?.continueOnError ?? false;
+        if (!serverError || continueOnError) {
+          clientActionPromises.push(callback(tableSelectionDetail, actionResult));
+        }
+      }
+      await Promise.all(clientActionPromises);
+    }
+  }
+
+  async startTableSelectionAction(tableActionEvent: any) {
+    const { tableCode, actionCode, actionDetail } = tableActionEvent;
+    const tableObject = this.getTable(tableCode);
+    if (!tableObject || !actionCode) { return; }
+    this.resetError();
+    const { selectedRecords } = actionDetail;
+    const action = tableObject.getAction(actionCode);
+    if (!action) { return; }
+    const tableActionDetail = {
+      tableObject,
+      action,
+      tableCode,
+      actionCode,
+      selectedRecords
+    };
+    const tableEventHandlers = this._tableActionsStart[tableCode];
+    const tableActionMethods = (tableEventHandlers) ? tableEventHandlers[actionCode] : null;
+    if (tableActionMethods) {
+      const clientActionPromises: any[] = [];
+      for (const tableActionMethod of tableActionMethods) {
+        const { callback, properties } = tableActionMethod;
+        const clientActionPromise = callback(tableActionDetail);
+        clientActionPromises.push(clientActionPromise);
+      }
+      const clientActionResults = await Promise.all(clientActionPromises);
+      const continueAction = clientActionResults.reduce((total, curr) => (total && (curr !== false)), true);
+      if (!continueAction) {
+        return;
+      }
+    }
+    this.startTableServerSelectionAction(tableActionDetail);
+  }
+
+  async startTableServerSelectionAction(tableActionDetail: any) {
+    const { tableObject, action, tableCode, actionCode, selectedRecords } = tableActionDetail;
+    if (!tableObject || !action) { return; }
+    tableObject.putOnWait();
+    let serverError = false;
+    let actionResult = null;
+    if (action.backend) {
+      const actionSubject = {
+        tableCode,
+        actionType: this.formConfig.tableActions.selection,
+        actionCode,
+        selectedRecords
+      };
+      actionResult = await this
+        .requestFormAction(formActions.tableAction, actionSubject);
+      serverError = !!this.errorOccured();
+    }
+    await this.finishTableSelectionAction(tableActionDetail, actionResult, serverError);
+    if (!serverError) {
+      action.newState && this.changeState(action.newState);
+    } else {
+      this.displayTableServerError();
+    }
+    tableObject.freeWaiting();
+  }
+
+  async finishTableSelectionAction(tableActionDetail: any, actionResult, serverError = false) {
+    const { tableCode, actionCode } = tableActionDetail;
+    const tableEventHandlers = this._tableActionsFinish[tableCode];
+    const tableActionMethods = (tableEventHandlers) ? tableEventHandlers[actionCode] : null;
+    if (tableActionMethods) {
+      const clientActionPromises: any[] = [];
+      for (const tableActionMethod of tableActionMethods) {
+        const { callback, properties } = tableActionMethod;
+        const continueOnError = properties?.continueOnError ?? false;
+        if (!serverError || continueOnError) {
+          clientActionPromises.push(callback(tableActionDetail, actionResult));
+        }
+      }
+      await Promise.all(clientActionPromises);
+    }
+  }
+
+  async startTableGetData(tableActionEvent: any) {
+    const { tableCode } = tableActionEvent;
+    const tableObject = this.getTable(tableCode);
+    const tableActionDetail = {
+      tableObject,
+      tableCode
+    };
+    this.resetError();
+    const tableEventHandlers = this._tableGetDataStart[tableCode];
+    if (tableEventHandlers) {
+      const clientActionPromises: any[] = [];
+      for (const tableActionMethod of tableEventHandlers) {
+        const { callback, properties } = tableActionMethod;
+        const clientActionPromise = callback(tableActionDetail);
+        clientActionPromises.push(clientActionPromise);
+      }
+      const clientActionResults = await Promise.all(clientActionPromises);
+      const continueAction = clientActionResults.reduce((total, curr) => (total && (curr !== false)), true);
+      if (!continueAction) {
+        return;
+      }
+    }
+    this.startTableServerGetData(tableActionDetail);
+  }
+
+  async startTableServerGetData(tableActionDetail: any) {
+    const { tableObject, tableCode } = tableActionDetail;
+    tableObject.putOnWait();
+    let serverError = false;
+    const actionSubject = { tableCode };
+    const actionResult = await this
+      .requestFormAction(formActions.getTableData, actionSubject);
+    serverError = !!this.errorOccured();
+    await this.finishTableGetData(tableActionDetail, actionResult, serverError);
+    if (serverError) {
+      this.displayTableServerError();
+    }
+    tableObject.freeWaiting();
+  }
+
+  async finishTableGetData(tableActionDetail: any, actionResult, serverError = false) {
+    const { tableCode, tableActionCode } = tableActionDetail;
+    const tableEventHandlers = this._tableActionsFinish[tableCode];
+    const tableActionMethods = (tableEventHandlers) ? tableEventHandlers[tableActionCode] : null;
+    if (tableActionMethods) {
+      const clientActionPromises: any[] = [];
+      for (const tableActionMethod of tableActionMethods) {
+        const { callback, properties } = tableActionMethod;
+        const continueOnError = properties?.continueOnError ?? false;
+        if (!serverError || continueOnError) {
+          clientActionPromises.push(callback(tableActionDetail, actionResult));
+        }
+      }
+      await Promise.all(clientActionPromises);
+    }
+  }
+
+  checkSectionRequiredFields(sectionCode: string, reqFieldMessage?: string) {
+    this.cleanErrorFields(null, sectionCode);
+    const requiredFieldMessage = reqFieldMessage ?? this.formConfig.formStandardErrors.requiredField
+    const numErrors = this.tagFieldsWithError(requiredFieldMessage, this.getRequiredEmptyFields(null, sectionCode));
+    return (numErrors === 0);
+  }
+
+  validateSectionConsistency(sectionCode: string, reqFieldMessage?: string) {
+    this.resetError();
+    const completeFields = this.checkSectionRequiredFields(sectionCode, reqFieldMessage);
+    if (!completeFields) {
+      this.setError(this.formConfig.formStandardErrors.typeWarning,
+        this.formConfig.formStandardErrors.validationTitle,
+        this.formConfig.formStandardErrors.requiredFields);
+      return false;
+    }
+    let validationError = false;
+    const requiredEmptyFields: any[] = this.getRequiredEmptyFields(null, sectionCode) ?? [];
+    if (requiredEmptyFields?.length > 0) {
+      validationError = true;
+      this.setError(this.formConfig.formStandardErrors.typeWarning,
+        this.formConfig.formStandardErrors.validationTitle,
+        this.formConfig.formStandardErrors.requiredFields);
+      this.tagFieldsWithError(this.formConfig.formStandardErrors.requiredField, requiredEmptyFields);
+      for (const fieldCode of requiredEmptyFields) {
+        const requiredEmptyField = this.getField(fieldCode);
+        requiredEmptyField?.focus();
+        break;
+      }
+    }
+    const validationIssueFields: any[] = this.getFieldsWithValidationIssues(null,
+      sectionCode) ?? [];
+    if (!validationError && validationIssueFields.length > 0) {
+      validationError = true;
+      this.setError(this.formConfig.formStandardErrors.typeWarning,
+        this.formConfig.formStandardErrors.validationTitle,
+        this.formConfig.formStandardErrors.validationFields);
+      for (const fieldCode of validationIssueFields) {
+        const validationIssueField = this.getField(fieldCode);
+        if (validationIssueField) {
+          validationIssueField.focus();
+        }
+        break;
+      }
+    }
+    return validationError;
+  }
+
+  copyTableRecordToFields(tableObj: any, mappingTable: any = null) {
+    const tableObject = this.getTable(tableObj.tableCode);
+    const tableRecord = tableObject?.getTableRecord(tableObj.recordId);
+    const columnNames = tableObject?.columnNames;
+    if (tableRecord && columnNames) {
+      for (const columnName of columnNames) {
+        const columnValue = tableRecord.getFieldValue(columnName) ?? '';
+        const fieldCode = mappingTable?.[columnName] ?? columnName;
+        this.setFieldValue(fieldCode, columnValue);
+      }
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Métodos Legacy de compatibilidad hacia atrás
+   */
+
+  addSectionActivation(codes: string[] | string | null, callback, properties = null) {
+    return this.onSectionActivation(codes, callback, properties);
+  }
+
+  addSectionInactivation(codes: string[] | string | null, callback, properties = null) {
+    return this.onSectionInactivation(codes, callback, properties);
+  }
+
+  addActionMethodStart(codes: string[] | string | null, callback, properties = null) {
+    return this.onActionStart(codes, callback, properties);
+  }
+
+  addActionMethodFinish(codes: string[] | string | null, callback, properties = null) {
+    return this.onActionFinish(codes, callback, properties);
+  }
+
+  addFieldInputValidation(codes: string[] | string | null, callback, properties = null) {
+    return this.onFieldInput(codes, callback, properties);
+  }
+
+  addFieldValidationStart(codes: string[] | string | null, callback, properties = null) {
+    return this.onFieldValidationStart(codes, callback, properties);
+  }
+
+  addFieldValidationFinish(codes: string[] | string | null, callback, properties = null) {
+    return this.onFieldValidationFinish(codes, callback, properties);
+  }
+
+  addTableActionStart(code: string, actionCode: string, callback, properties = null) {
+    return this.onTableActionStart(code, actionCode, callback, properties);
+  }
+
+  addTableActionFinish(code: string, actionCode: string, callback, properties = null) {
+    return this.onTableActionFinish(code, actionCode, callback, properties);
+  }
+
+  addTableSelectionStart(code: string, callback, properties = null) {
+    return this.onTableSelectionStart(code, callback, properties);
+  }
+
+  addTableSelectionFinish(code: string, callback, properties = null) {
+    return this.onTableSelectionFinish(code, callback, properties);
+  }
+
+  addTableGetDataStart(code: string, callback, properties = null) {
+    return this.onTableGetDataStart(code, callback, properties);
+  }
+
+  addTableGetDataFinish(code: string, callback, properties = null) {
+    return this.onTableGetDataFinish(code, callback, properties);
+  }
+}