tuain-ng-forms-lib 14.4.93 → 14.4.95

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

@@ -1,28 +0,0 @@
-export const NO_ERROR = '00';
-export const HEADER = 'HEADER';
-
-export const elementTypes = {
-  action: 'ACTION',
-  field: 'FIELD',
-  table: 'TABLE',
-};
-
-export const formActions = {
-  tableAction: 'TABLEACTION',
-  getData: 'GETDATA',
-  getTableData: 'GETTABLEDATA',
-  validate: 'VALIDATE',
-};
-
-export const operators = {
-  G: 'G',
-  L: 'L',
-  GE: 'GE',
-  LE: 'LE',
-  EQ: 'EQ',
-  NEQ: 'NEQ',
-  HAS: 'HAS',
-  NOTHAS: 'NOTHAS',
-  BETWEEN: 'BETWEEN',
-  IN: 'IN',
-};

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

@@ -1,508 +0,0 @@
-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';
-interface Transition {
-  name: string;
-  source: string;
-  destination: string;
-}
-
-interface StateFlow {
-  defaultState: string;
-  states: 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>();
-
-  state: string;
-  _name: string = '';
-  _formConfig: any;
-  private _title: string = '';
-  private _stateFlow: StateFlow;
-  private _fieldArray: FieldDescriptor[];
-  private _fields = {};
-  private _actionArray: FormAction[];
-  private _actions = {};
-  private _tableArray: RecordTable[];
-  private _tables = {};
-  private _sectionArray: RecordFormSection[];
-  private _sections = {};
-  private _immutableData = {};
-  private _extraInfo = {};
-  private _exclusiveSectionsByAttr = {};
-
-  constructor(definitionReceived, formConfig) {
-    this._formConfig = formConfig;
-    this.state = '';
-    this._actionArray = [];
-    this._fieldArray = [];
-    this._tableArray = [];
-    this._sectionArray = [];
-    this._stateFlow = {
-      defaultState: '',
-      states: [],
-      transitions: [],
-    };
-    if (!definitionReceived) { return; }
-    this._name = (definitionReceived.form && definitionReceived.form.formCode)
-      ? definitionReceived.form.formCode : this._name;
-    this._title = (definitionReceived.form && definitionReceived.form.formTitle)
-      ? definitionReceived.form.formTitle : '';
-    this.setStateFlow(definitionReceived?.states, definitionReceived?.transitions,
-      definitionReceived?.defaultState);
-    this.immutableData = definitionReceived.immutableData;
-    this.extraInfo = definitionReceived.extraInfo;
-
-    if (definitionReceived.actions) {
-      const formActions = definitionReceived.actions.map(objDef => {
-        let visibleStates = objDef.visibleStates;
-        let enabledStates = objDef.enabledStates ?? objDef.editableStates;
-        if (!visibleStates) {
-          visibleStates = (objDef.actionModes || '').split(',')
-            .map(state => state.trim())
-            .filter(state => state.length > 0) || [];
-          enabledStates = [...visibleStates];
-        }
-        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;
-        let enabledStates = objDef.enabledStates ?? objDef.editableStates;
-        if (!visibleStates) {
-          visibleStates = (objDef.fieldModes || '').split(',')
-            .map(state => state.trim())
-            .filter(state => state.length > 0) || [];
-          enabledStates = [...visibleStates];
-        }
-        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;
-        let enabledStates = objDef.enabledStates || objDef.editableStates;
-        if (!visibleStates) {
-          visibleStates = (objDef.tableModes || '').split(',')
-            .map(state => state.trim())
-            .filter(state => state.length > 0) || [];
-          enabledStates = [...visibleStates];
-        }
-        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;
-        if (!visibleStates) {
-          visibleStates = (objDef.sectionModes || '').split(',')
-            .map(state => state.trim())
-            .filter(state => state.length > 0) || [];
-        }
-        return { ...objDef, 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;
-        }
-      }
-    }
-  }
-
-  getTitle(): string { return this._title; }
-  setTitle(title: string): void { this._title = title; }
-  get name(): string { return this._name; }
-  set name(name) { this._name = name; }
-
-  // Estados
-  get defaultState(): string { return this._stateFlow.defaultState; }
-  supportState(state: string): boolean { return this._stateFlow.states?.includes(state); }
-  supportMode(state: string): boolean { return this.supportState(state); }
-  get states(): any[] { return this._stateFlow.states; }
-
-  getCurrentState(): string { return this.state; }
-
-  changeState(newState: string): boolean {
-    if (!newState || !this.supportState(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; }
-
-  setStateFlow(states?, transitions?, defaultState?: string): void {
-    this._stateFlow.states = states;
-    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)); }
-
-  // Fields
-  get fields(): any { 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, nameAttribute: string): any {
-    const field = this.getField(code);
-    if (field && optionsArray?.length > 0) {
-      const fieldOptions = optionsArray.map(item => ({
-        fieldOptionId: item[idAttribute],
-        fieldOptionValue: item[nameAttribute]
-      }));
-      field.setFieldOptions(fieldOptions);
-    }
-  }
-
-  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;
-  }
-
-  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): string[] {
-    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): string[] {
-    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
-  get actions() { return this._actions; }
-
-  getActionsByAttribute(name: string, value): FormAction[] { return this._actionArray.filter(actionItem => actionItem.matchAttribute(name, value)); }
-  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); }
-
-  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
-  get tables(): any { return this.tables; }
-  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); }
-
-  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
-  get sections(): any { return this._sections; }
-  getSections(): RecordFormSection[] { return this._sectionArray; }
-  getSectionsByAttribute(name, value): RecordFormSection[] { return this._sectionArray.filter(item => item.matchAttribute(name, value)); }
-  get sectionTitles(): string[] { return this._sectionArray.map(formSection => formSection.sectionTitle); }
-  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); }
-  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); }
-  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;
-  }
-}

package/src/lib/classes/forms/piece-propagate.ts

@@ -1,46 +0,0 @@
-import { BehaviorSubject } from 'rxjs';
-import { FormPiece } from './piece';
-
-const VISIBLE = 'visible';
-const DISABLED = 'disabled';
-
-export class FormPiecePropagate extends FormPiece {
-  protected propagationCustomAttributes: string[] = [];
-  protected _attributeChange: BehaviorSubject<any>;
-
-  constructor(pieceDefinition: any, formConfig: any) {
-    super(pieceDefinition, formConfig);
-    this._attributeChange = new BehaviorSubject<any>(null);
-  }
-
-  get attributeChange() { return this._attributeChange; }
-
-  propagateAttribute(name, value) {
-    this._attributeChange?.next({ name, value });
-  }
-
-  override setCustomAttribute(name: string, value: any): void {
-    super.setCustomAttribute(name, value);
-    if (this.propagationCustomAttributes?.includes(name)) {
-      this.propagateAttribute(name, value);
-    } 
-  }
-
-  override setVisibility(visible: boolean, forced: boolean | null = null): void {
-    super.setVisibility(visible, forced);
-    this.propagateAttribute(VISIBLE, this._visible);
-  }
-
-  override set enabled(enabled) {
-    super.enabled = enabled;
-    this.propagateAttribute(DISABLED, this._disabled);
-  }
-
-  override formStateChange(state) {
-    super.formStateChange(state);
-    if (state) {
-      this.propagateAttribute(VISIBLE, this._visible);
-      this.propagateAttribute(DISABLED, this._disabled);
-    }
-  }
-}