tuain-form-manager 1.3.0 → 1.4.2

package/lib/form.js

@@ -29,6 +29,11 @@ const FIELD_ASSIGN_ATTRIBUTES = [
   'options', 'editable',
 ];
 
+const TABLE_CONSTRAINTS = [
+  'visible', 'currentPage', 'requestedPage', 'recordsPerPage', 'sortingColumn', 'sortingDirection',
+  'totalRecordsNumber', 'recordsNumber', 'currentFilter', 'tableRecords',
+];
+
 const SESSION_ATTRIBUTES = {
   sessionCode: 'sessionCode',
   profileCode: 'profileCode',
@@ -194,6 +199,9 @@ class Form {
     return (this.state === newState);
   }
 
+  /**
+   * @deprecated Use changeState
+   */
   changeFormMode(newState) { return this.changeState(newState); }
 
   getActionDefinition(code) { return this._formDefinition?.actions?.find(act => act.actionCode === code) ?? null; }
@@ -334,16 +342,16 @@ class Form {
   }
 
   showTable(code) {
-    const tblDef = this.getTableDefinition(code);
-    if (tblDef) {
-      tblDef.constraints.visible = true;
+    const responseTable = this.getResponseTable(code);
+    if (responseTable) {
+      responseTable.visible = true;
     }
   }
 
   hideTable(code) {
-    const tblDef = this.getTableDefinition(code);
-    if (tblDef) {
-      tblDef.constraints.visible = false;
+    const responseTable = this.getResponseTable(code);
+    if (responseTable) {
+      responseTable.visible = false;
     }
   }
 
@@ -358,7 +366,6 @@ class Form {
   }
 
   getTableDefinition(code) { return this._formDefinition?.tables.find(tbl => tbl.tableCode === code) ?? null; }
-  getTableConstraints(tableCode) { return this.getTableDefinition(tableCode)?.constraints ?? null; }
   onTableRowSelection(code, callback) { this.onTableAction(code, ROWSELECTION, callback); }
   onTablePopulate(code, callback) { this._tablePopulate[code] = callback; }
   onTableAction(tableCode, actionCode, callback) {
@@ -477,85 +484,106 @@ class Form {
   }
 
   async executeFieldValidation() {
+    let message;
     const fieldCode = this.actionSubject;
     const fieldValue = this.getFieldValue(fieldCode);
     const callback = this._fieldValidations[fieldCode];
     if (!callback) {
-      this.logger.log({
-        level: 'debug',
-        label: 'fieldValidation',
-        action: fieldCode,
-        message: `No existe función de validación de ${fieldCode}`,
-      });
+      message = `No existe función de validación de ${fieldCode}`;
+      this.logger.log({ level: 'debug', label: 'fieldValidation', action: fieldCode, message });
       return this.errMgr.get(modErrs.fieldValidation.NoValidationCallback);
     }
     let errorObj = null;
     try {
       errorObj = await callback(fieldCode, fieldValue);
     } catch (err) {
-      const errorDetail = `Excepción en validación de ${fieldCode}: ${err.message} / ${err.stack}`;
-      this.logger.log({
-        level: 'error',
-        label: 'fieldValidation',
-        action: fieldCode,
-        message: errorDetail,
-      });
-      errorObj = this.errMgr.get(modErrs.fieldValidation.exceptionNotHandled, errorDetail);
+      message = `Excepción en validación de ${fieldCode}: ${err.message} / ${err.stack}`;
+      this.logger.log({ level: 'error', label: 'fieldValidation', action: fieldCode, message });
+      errorObj = this.errMgr.get(modErrs.fieldValidation.exceptionNotHandled, message);
     }
     return errorObj;
   }
 
   async executeFormAction(actionCode) {
     let errorObj = null;
+    let message;
     const callback = this._formActions[actionCode];
     if (!callback) {
-      const errorDetail = `No existe función de atención de ${actionCode} para ${this.formCode}`;
-      this.logger.log({
-        level: 'debug',
-        label: 'executeFormAction',
-        message: errorDetail,
-      });
-      errorObj = this.errMgr.get(modErrs.formActionExec.actionNotDefined, errorDetail);
+      message = `No existe función de atención de ${actionCode} para ${this.formCode}`;
+      this.logger.log({ level: 'debug', label: 'executeFormAction', message });
+      errorObj = this.errMgr.get(modErrs.formActionExec.actionNotDefined, message);
       return [errorObj, this.getExportData()];
     }
     if (!this.actionAllowed(actionCode)) {
-      const errorDetail = `Usuario sin privilegios para la acción ${actionCode} en ${this.formCode}`;
-      this.logger.log({
-        level: 'debug',
-        label: 'executeFormAction',
-        message: errorDetail,
-      });
-      errorObj = this.errMgr.get(modErrs.formActionExec.actionNotDefined, errorDetail);
+      message = `Usuario sin privilegios para la acción ${actionCode} en ${this.formCode}`;
+      this.logger.log({ level: 'debug', label: 'executeFormAction', message });
+      errorObj = this.errMgr.get(modErrs.formActionExec.actionNotDefined, message);
       return [errorObj, this.getExportData()];
     }
-    this.logger.log({
-      level: 'debug',
-      label: 'executeFormAction',
-      message: `START FORM ACTION ${actionCode} / ${this.formCode}/${this.formSubject ?? ''}`,
-    });
+    message = `START FORM ACTION ${actionCode} / ${this.formCode}/${this.formSubject ?? ''}`;
+    this.logger.log({ level: 'debug', label: 'executeFormAction', message });
     try {
       errorObj = await callback(actionCode);
     } catch (err) {
-      const errorDetail = `Excepción en acción de ${actionCode}: ${err.message} / ${err.stack}`;
-      this.logger.log({
-        level: 'error',
-        label: 'executeFormAction',
-        action: actionCode,
-        message: errorDetail,
-      });
-      errorObj = this.errMgr.get(modErrs.formActionExec.exceptionNotHandled, errorDetail);
+      message = `Excepción en acción de ${actionCode}: ${err.message} / ${err.stack}`;
+      this.logger.log({ level: 'error', label: 'executeFormAction', action: actionCode, message });
+      errorObj = this.errMgr.get(modErrs.formActionExec.exceptionNotHandled, message);
     }
     return [errorObj, this.getExportData()];
   }
 
+  getResponseTable(tableCode) {
+    let message;
+    let responseTable = this._responseData.recordTables[tableCode];
+    if (!responseTable) {
+      const tableDefinition = this.getTableDefinition(tableCode);
+      if (!tableDefinition) {
+        message = `La tabla a ${tableCode} no está en la definición del formulario`;
+        this.logger.log({ level: 'error', message });
+        return null;
+      }
+      const {
+        visible = true, currentPage = 1, requestedPage = 1, totalRecordsNumber = 0, recordsNumber = 0,
+        recordsPerPage = 10, sortingColumn = null, sortingDirection = null,
+      } = tableDefinition?.constraints ?? {};
+      responseTable = {
+        tableCode,
+        visible,
+        currentPage,
+        requestedPage,
+        totalRecordsNumber,
+        recordsNumber,
+        recordsPerPage,
+        sortingColumn,
+        sortingDirection,
+      };
+      this._responseData.recordTables[tableCode] = responseTable;
+    }
+    return responseTable;
+  }
+
+  getResponseTableAction(tableCode, actionCode) {
+    const responseTable = this.getResponseTable(tableCode);
+    if (!responseTable) { return null; }
+    if (!responseTable?.actions) {
+      responseTable.actions = { [actionCode]: {} };
+    }
+    return responseTable.actions[actionCode];
+  }
+
+  getResponseTableField(tableCode, fieldCode) {
+    const responseTable = this.getResponseTable(tableCode);
+    if (!responseTable) { return null; }
+    if (!responseTable?.fields) {
+      responseTable.fields = { [fieldCode]: {} };
+    }
+    return responseTable.fields[fieldCode];
+  }
+
   fillTable(records, mapping) {
     const { tableCode, recordIdField, recordColumnsNames, recordItemAttributes } = mapping;
-    const tableDefinition = this.getTableDefinition(tableCode);
-    if (!tableDefinition) {
-      this.logger.log({
-        level: 'error',
-        message: `La tabla a ${tableCode} no está en la definición del formulario`,
-      });
+    const responseTable = this.getResponseTable(tableCode);
+    if (!responseTable) {
       return;
     }
     const tableRecords = [];
@@ -573,57 +601,159 @@ class Form {
       }
       tableRecords.push(tableRecord);
     }
-    const { constraints } = tableDefinition;
-    this._responseData.recordTables[tableCode] = {
-      tableCode,
-      tableRecords,
-      visible: constraints?.visible ?? true,
-      currentPage: constraints?.currentPage ?? 1,
-      requestedPage: constraints?.requestedPage ?? 1,
-      totalRecordsNumber: constraints?.totalRecordsNumber ?? 0,
-      recordsNumber: constraints?.recordsNumber ?? 0,
-      recordsPerPage: constraints?.recordsPerPage ?? 10,
-      sortingColumn: constraints?.sortingColumn ?? null,
-      sortingDirection: constraints?.sortingDirection ?? null,
-    };
+    Object.assign(responseTable, { tableRecords });
+  }
+
+  showTableField(tableCode, fieldCode) {
+    const tableField = this.getResponseTableField(tableCode, fieldCode);
+    if (tableField) {
+      Object.assign(tableField, { visible: true });
+    }
+  }
+
+  hideTableField(tableCode, fieldCode) {
+    const tableField = this.getResponseTableField(tableCode, fieldCode);
+    if (tableField) {
+      Object.assign(tableField, { visible: false });
+    }
+  }
+
+  enableTableAction(tableCode, actionCode) {
+    const tableAction = this.getResponseTableAction(tableCode, actionCode);
+    if (tableAction) {
+      Object.assign(tableAction, { enabled: true });
+    }
+  }
+
+  disableTableAction(tableCode, actionCode) {
+    const tableAction = this.getResponseTableAction(tableCode, actionCode);
+    if (tableAction) {
+      Object.assign(tableAction, { enabled: false });
+    }
+  }
+
+  showTableAction(tableCode, actionCode) {
+    const tableAction = this.getResponseTableAction(tableCode, actionCode);
+    if (tableAction) {
+      Object.assign(tableAction, { visible: true });
+    }
+  }
+
+  hideTableAction(tableCode, actionCode) {
+    const tableAction = this.getResponseTableAction(tableCode, actionCode);
+    if (tableAction) {
+      Object.assign(tableAction, { visible: false });
+    }
+  }
+
+  showOnStateTableAction(tableCode, actionCode, state) {
+    const tableAction = this.getResponseTableAction(tableCode, actionCode);
+    if (tableAction) {
+      if (!tableAction.showOnStates) {
+        tableAction.showOnStates = [];
+      }
+      const currentlyVisible = tableAction.showOnStates.findIndex(item => item === state);
+      const correntlyHidden = tableAction.hideOnStates?.findIndex(item => item === state);
+      if (currentlyVisible < 0) {
+        tableAction.showOnStates.push(state);
+      }
+      if (correntlyHidden >= 0) {
+        tableAction.hideOnStates.splice(correntlyHidden, 1);
+        if (tableAction.hideOnStates.length === 0) {
+          delete tableAction.hideOnStates;
+        }
+      }
+    }
+  }
+
+  hideOnStateTableAction(tableCode, actionCode, state) {
+    const tableAction = this.getResponseTableAction(tableCode, actionCode);
+    if (tableAction) {
+      if (!tableAction.hideOnStates) {
+        tableAction.hideOnStates = [];
+      }
+      const currentlyVisible = tableAction.showOnStates.findIndex(item => item === state);
+      const correntlyHidden = tableAction.hideOnStates?.findIndex(item => item === state);
+      if (correntlyHidden < 0) {
+        tableAction.hideOnStates.push(state);
+      }
+      if (currentlyVisible >= 0) {
+        tableAction.showOnStates.splice(currentlyVisible, 1);
+        if (tableAction.showOnStates.length === 0) {
+          delete tableAction.showOnStates;
+        }
+      }
+    }
+  }
+
+  enableOnStateTableAction(tableCode, actionCode, state) {
+    const tableAction = this.getResponseTableAction(tableCode, actionCode);
+    if (tableAction) {
+      if (!tableAction.enableOnStates) {
+        tableAction.enableOnStates = [];
+      }
+      const currentlyEnabled = tableAction.enableOnStates.findIndex(item => item === state);
+      const correntlyDisabled = tableAction.disableOnStates?.findIndex(item => item === state);
+      if (currentlyEnabled < 0) {
+        tableAction.enableOnStates.push(state);
+      }
+      if (correntlyDisabled >= 0) {
+        tableAction.disableOnStates.splice(correntlyDisabled, 1);
+        if (tableAction.disableOnStates.length === 0) {
+          delete tableAction.disableOnStates;
+        }
+      }
+    }
+  }
+
+  disableOnStateTableAction(tableCode, actionCode, state) {
+    const tableAction = this.getResponseTableAction(tableCode, actionCode);
+    if (tableAction) {
+      if (!tableAction.disableOnStates) {
+        tableAction.disableOnStates = [];
+      }
+      const currentlyEnabled = tableAction.enableOnStates.findIndex(item => item === state);
+      const correntlyDisabled = tableAction.disableOnStates?.findIndex(item => item === state);
+      if (correntlyDisabled < 0) {
+        tableAction.disableOnStates.push(state);
+      }
+      if (currentlyEnabled >= 0) {
+        tableAction.enableOnStates.splice(currentlyEnabled, 1);
+        if (tableAction.enableOnStates.length === 0) {
+          delete tableAction.enableOnStates;
+        }
+      }
+    }
   }
 
   async executeTableAction() {
-    let errorDetail = '';
+    let message = '';
     if (!this.actionSubject || typeof this.actionSubject !== 'object') {
-      errorDetail = 'Acción de tabla requiere actionSubject';
-      this.logger.log({
-        level: 'error',
-        label: 'executeTableAction',
-        message: errorDetail,
-      });
-      return this.errMgr.get(modErrs.tableActionExec.subjectIncomplete, errorDetail);
+      message = 'Acción de tabla requiere actionSubject';
+      this.logger.log({ level: 'error', label: 'executeTableAction', message });
+      return this.errMgr.get(modErrs.tableActionExec.subjectIncomplete, message);
     }
     const { tableCode, actionType = INLINE, tableRecordId, tableRecordData } = this.actionSubject;
     if (!tableCode) {
-      errorDetail = 'Acción de tabla requiere tableCode';
-      this.logger.log({
-        level: 'error',
-        label: 'executeTableAction',
-        message: errorDetail,
-      });
-      return this.errMgr.get(modErrs.tableActionExec.subjectIncomplete, errorDetail);
+      message = 'Acción de tabla requiere tableCode';
+      this.logger.log({ level: 'error', label: 'executeTableAction', message });
+      return this.errMgr.get(modErrs.tableActionExec.subjectIncomplete, message);
     }
     let { actionCode } = this.actionSubject;
     if (actionType === INLINE) {
       if (!actionCode) {
-        errorDetail = 'Acción inline requiere actionCode';
-        return this.errMgr.get(modErrs.tableActionExec.subjectIncomplete, errorDetail);
+        message = 'Acción inline requiere actionCode';
+        return this.errMgr.get(modErrs.tableActionExec.subjectIncomplete, message);
       }
       if (!tableRecordId) {
-        errorDetail = 'Acción inline requiere identificador del registro tableRecordId';
-        return this.errMgr.get(modErrs.tableActionExec.noRecordId, errorDetail);
+        message = 'Acción inline requiere identificador del registro tableRecordId';
+        return this.errMgr.get(modErrs.tableActionExec.noRecordId, message);
       }
     } else if (actionType === ROWSELECTION) {
       actionCode = ROWSELECTION;
       if (!tableRecordId) {
-        errorDetail = 'Acción sobre tabla requiere identificador del registro tableRecordId';
-        return this.errMgr.get(modErrs.tableActionExec.noRecordId, errorDetail);
+        message = 'Acción sobre tabla requiere identificador del registro tableRecordId';
+        return this.errMgr.get(modErrs.tableActionExec.noRecordId, message);
       }
     } else {
       // Cualquier otro tipo de acción sobre tabla no involucra tableRecordId!!!
@@ -649,38 +779,25 @@ class Form {
       });
       errorObject = await tableActionCallback(tableCode, actionCode, tableRecordId, tableRecordData ?? {});
     } catch (err) {
-      errorDetail = `Excepción no soportada en acción ${actionCode} sobre la tabla ${tableCode} : ${err.message} / ${err.stack}`;
-      this.logger.log({
-        level: 'error',
-        label: 'tableAction',
-        action: actionCode,
-        message: errorDetail,
-      });
-      errorObject = this.errMgr.get(modErrs.tableActionExec.noCallback, errorDetail);
+      message = `Excepción no soportada en acción ${actionCode} sobre la tabla ${tableCode} : ${err.message} / ${err.stack}`;
+      this.logger.log({ level: 'error', label: 'tableAction', action: actionCode, message });
+      errorObject = this.errMgr.get(modErrs.tableActionExec.noCallback, message);
     }
     return errorObject;
   }
 
   async executeTablePopulate() {
-    let errorDetail = '';
+    let message = '';
     if (!this.actionSubject || typeof this.actionSubject !== 'object') {
-      errorDetail = 'Acción de poblamiento de tabla requiere actionSubject';
-      this.logger.log({
-        level: 'error',
-        label: 'executeTablePopulate',
-        message: errorDetail,
-      });
-      return this.errMgr.get(modErrs.tableActionExec.subjectIncomplete, errorDetail);
+      message = 'Acción de poblamiento de tabla requiere actionSubject';
+      this.logger.log({ level: 'error', label: 'executeTablePopulate', message });
+      return this.errMgr.get(modErrs.tableActionExec.subjectIncomplete, message);
     }
     const { tableCode } = this.actionSubject;
     if (!tableCode) {
-      errorDetail = 'Acción de poblamiento de tabla requiere tableCode';
-      this.logger.log({
-        level: 'error',
-        label: 'executeTablePopulate',
-        message: errorDetail,
-      });
-      return this.errMgr.get(modErrs.tableActionExec.subjectIncomplete, errorDetail);
+      message = 'Acción de poblamiento de tabla requiere tableCode';
+      this.logger.log({ level: 'error', label: 'executeTablePopulate', message });
+      return this.errMgr.get(modErrs.tableActionExec.subjectIncomplete, message);
     }
     let errorObject = null;
     try {
@@ -695,14 +812,9 @@ class Form {
       }
       errorObject = await tablePopulateCallback(tableCode, this.actionSubject);
     } catch (err) {
-      errorDetail = `Excepción no soportada en el poblamiento de la tabla ${tableCode} en ${this.formCode}: ${err} / ${err.stack}`;
-      this.logger.log({
-        level: 'error',
-        label: 'executeTablePopulate',
-        action: tableCode,
-        message: errorDetail,
-      });
-      errorObject = this.errMgr.get(modErrs.tablePopulate.exceptionNotHandled, errorDetail);
+      message = `Excepción no soportada en el poblamiento de la tabla ${tableCode} en ${this.formCode}: ${err} / ${err.stack}`;
+      this.logger.log({ level: 'error', label: 'executeTablePopulate', action: tableCode, message });
+      errorObject = this.errMgr.get(modErrs.tablePopulate.exceptionNotHandled, message);
     }
     return errorObject;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tuain-form-manager",
-  "version": "1.3.0",
+  "version": "1.4.2",
   "description": "Component library to perform operations on Tuain Development Framework forms to interchange information on web or mobile applications based on the data interchange of abstract forms making trnasformation on the data upon actions required on both sides (front and back)",
   "main": "index.js",
   "scripts": {