newportsite 1.1.3

package/src/lib/players/model/model.item.component.ts

@@ -0,0 +1,3457 @@
+import {
+  ChangeDetectorRef,
+  Component,
+  viewChild,
+  ElementRef,
+  HostListener,
+  OnDestroy,
+  AfterViewInit,
+  DestroyRef,
+  inject,
+  signal,
+} from '@angular/core';
+
+import {
+  ItemInterface,
+  Member,
+  ItemComponentInterface,
+  FieldType,
+  TransportInterface,
+  ItemLinkInterface,
+  FieldState,
+  FieldAttr,
+  ItemState,
+  ItemFieldChangedInterface,
+  DialogType,
+  ItemCommandInterface,
+  PadType,
+  ManagmentInterface,
+  EntitiesData,
+  Entities,
+  Entity,
+  EntityData,
+  ModuleData,
+  LabelAction,
+  Functions,
+  MemberData,
+  LookupResultEvent,
+  DialogResultEvent,
+  FixedField,
+  FieldFontSize,
+  FieldPaddingTop,
+} from '../../interfaces/index';
+
+import { GlobalService, Languages } from '../../services/global.service';
+
+import { AppMessageService } from '../../services/message.service';
+
+import { NEWPORT_CONFIG } from '../../config';
+
+import { ManagmentService } from '../../home/model/services/index';
+
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { firstValueFrom } from 'rxjs';
+
+import CodiceFiscale from 'codice-fiscale-js';
+
+import { PartitaIVA } from '../../utils/piva';
+import { v4 as uuidv4 } from 'uuid';
+
+import { saveAs } from 'file-saver';
+
+import { HttpEventType } from '@angular/common/http';
+
+import { CommandsComponent } from '../../common/commands.component';
+import { NgClass } from '@angular/common';
+import { InputDirective } from '../../directives/input.directive';
+import { BarChartComponent } from '../../home/model/barchart.component';
+import { TooltipDirective } from 'ngx-bootstrap/tooltip';
+
+@Component({
+  selector: 'app-model-item',
+  template: `
+    <div class="position-absolute" #innercontainer>
+      <div>
+        <commands
+          [(show)]="showcommands"
+          [(text)]="textcommands"
+          [(title)]="texttitle"
+          (commandsResult)="commandsResult($event)"
+          [(width)]="commandsWidth"
+          [(height)]="commandsHeight"
+          [(top)]="commandsTop"
+          [(left)]="commandsLeft"></commands>
+
+        <img
+          [class.field-loading]="!loaded"
+          [class.field-cache]="model?.cache"
+          [class.pe-none]="showlookup || showdialog || model?.cache"
+          id="bkgwhite"
+          [hidden]="entity.svg === null || entity.svg.length === 0"
+          [src]="svg"
+          [style.width]="entity.width"
+          [style.height]="entity.height"
+          />
+
+        @for (
+          field of entity.members;
+          track trackByField($index, field);
+          let i = $index
+        ) {
+          @switch (field.type) {
+            @case (fieldType.Label) {
+              <div
+                [hidden]="field.graphic !== 'label'"
+                [ngClass]="labelClasses(field)"
+                [class.field-loading]="!loaded"
+                [class.field-cache]="model?.cache"
+                [class.pe-none]="showlookup || showdialog || model?.cache"
+                nvg
+                [id]="field.name"
+                [style.line-height]="field.height"
+                [style.left]="field.x"
+                [style.top]="field.y"
+                [style.width]="field.width"
+                class="position-absolute text-capitalize field-z0"
+                [attr.data-type]="field.type"
+                [attr.data-state]="field.state">
+                {{ defaultLanguage() ? field.caption : field.captiongb }}
+              </div>
+            }
+            @case (fieldType.Image) {
+              <input
+                type="image"
+                [ngClass]="{
+                  'has-hidden': field?.state === fieldState.Hidden,
+                }"
+                [class.field-loading]="!loaded"
+                [class.field-cache]="model?.cache"
+                [class.pe-none]="showlookup || showdialog || model?.cache"
+                [id]="field.name"
+                [style.line-height]="field.height"
+                [style.left]="field.x"
+                [style.top]="field.y"
+                [style.width]="field.width"
+                class="position-absolute field-z0"
+                [attr.data-type]="field.type"
+                [attr.data-state]="field.state"
+                [src]="field.value.toLowerCase()"
+                disabled="true" />
+            }
+            @case (fieldType.Video) {
+              <video
+                playsinline
+                autoplay
+                controls
+                #video
+                [ngClass]="{
+                  'has-hidden': field?.state === fieldState.Hidden,
+                }"
+                [class.field-loading]="!loaded"
+                [class.field-cache]="model?.cache"
+                [class.pe-none]="showlookup || showdialog || model?.cache"
+                [id]="field.name"
+                [style.line-height]="field.height"
+                [style.left]="field.x"
+                [style.top]="field.y"
+                [style.width]="field.width"
+                class="position-absolute field-z0"
+                [attr.data-type]="field.type"
+                [attr.data-state]="field.state">
+                <source [src]="field.value.toLowerCase()" type="video/mp4" />
+              </video>
+            }
+            @case (fieldType.Map) {
+              <input
+                type="image"
+                [ngClass]="{
+                  'has-hidden': field?.state === fieldState.Hidden,
+                }"
+                [class.field-loading]="!loaded"
+                [class.field-cache]="model?.cache"
+                [class.pe-none]="showlookup || showdialog || model?.cache"
+                [id]="field.name"
+                [style.line-height]="field.height"
+                [style.left]="field.x"
+                [style.top]="field.y"
+                [style.width]="field.width"
+                class="position-absolute field-z0"
+                [attr.data-type]="field.type"
+                [attr.data-state]="field.state"
+                [src]="field.value.toLowerCase()"
+                disabled="true" />
+            }
+            @case (fieldType.Button) {
+              <input
+                type="button"
+                (click)="buttonClick(field.name, field.action)"
+                [ngClass]="buttonClasses(field)"
+                [class.field-loading]="!loaded"
+                [class.field-cache]="model?.cache"
+                [class.pe-none]="showlookup || showdialog || model?.cache"
+                nvg
+                [id]="field.name"
+                [style.line-height]="field.height"
+                [style.left]="field.x"
+                [style.top]="field.y"
+                [style.width]="field.width"
+                class="position-absolute text-capitalize p-0 m-0 field-z0"
+                [attr.data-type]="field.type"
+                [attr.data-state]="field.state"
+                value="{{
+                  defaultLanguage() ? field.caption : field.captiongb
+                }}" />
+            }
+            @case (fieldType.Combo) {
+              <select
+                [ngClass]="fieldClasses(field)"
+                [class.field-loading]="!loaded"
+                [class.field-cache]="model?.cache"
+                [class.pe-none]="showlookup || showdialog || model?.cache"
+                nvg
+                [id]="field.name"
+                [style.left]="field.x"
+                [style.top]="field.y"
+                [style.width]="field.width"
+                [style.height]="field.height"
+                class="position-absolute"
+                [class.field-border-svg]="entity.svg.length > 0"
+                [class.field-border-left]="
+                  field.state !== 0 || entity.svg.length === 0
+                "
+                [tabindex]="field.tabindex"
+                [attr.data-type]="field.type"
+                [attr.data-state]="field.state"
+                [attr.data-mandatory]="field.mandatory">
+                @for (
+                  c of field.combo.split(',');
+                  track trackByCombo($index, c)
+                ) {
+                  <option
+                    selected="{{
+                      c === field.value.toLocaleLowerCase() ? 'selected' : ''
+                    }}">
+                    {{ c.toUpperCase() }}
+                  </option>
+                }
+              </select>
+            }
+            @case (fieldType.Chart) {
+              <barchart
+                [dataChart]="
+                  gV(field.id.replace('barchart', '')).toLocaleLowerCase()
+                "
+                [ngClass]="{
+                  'has-hidden': field?.state === fieldState.Hidden,
+                }"
+                [class.field-loading]="!loaded"
+                [id]="field.name"
+                [style.line-height]="field.height"
+                [style.left]="field.x"
+                [style.top]="field.y"
+                [style.width]="field.width"
+                class="position-absolute field-z0"
+                [attr.data-type]="field.type"
+                [attr.data-state]="field.state"></barchart>
+            }
+            @case (fieldType.Date) {
+              <input
+                type="text"
+                autocomplete="off"
+                [ngClass]="fieldClasses(field)"
+                [class.field-loading]="!loaded"
+                [class.field-cache]="model?.cache"
+                [class.pe-none]="showlookup || showdialog || model?.cache"
+                [style.paddingTop]="
+                  entity.svg.length === 0
+                    ? fieldPaddingTop.none
+                    : gsv.getInt(field.height) > fieldPaddingTop.tallThreshold
+                      ? fieldPaddingTop.tall
+                      : fieldPaddingTop.short
+                "
+                nvg
+                [id]="field.name"
+                [style.left]="field.x"
+                [style.top]="field.y"
+                [style.width]="field.width"
+                [style.height]="field.height"
+                class="position-absolute"
+                [class.field-border-svg]="entity.svg.length > 0"
+                [class.field-border-left]="
+                  field.state !== 0 || entity.svg.length === 0
+                "
+                [tabindex]="field.tabindex"
+                [attr.data-type]="field.type"
+                [attr.data-state]="field.state"
+                tooltip="{{ field.title }}"
+                [containerClass]="tooltipClass(field)"
+                [value]="field.value"
+                [disabled]="
+                  !field.enabled &&
+                  field?.state !== fieldState.Error &&
+                  field?.state !== fieldState.Warning
+                "
+                [hidden]="field.state === fieldState.Hidden || !field.visible"
+                [attr.data-initialvalue]="field.initialvalue"
+                [attr.data-match]="field.match"
+                [attr.data-replace]="field.replace"
+                [attr.data-tag]="field.tag"
+                [attr.data-autoformatter]="field.autoformatter"
+                [attr.data-state]="field.state"
+                [attr.data-min]="field.min"
+                [attr.data-max]="field.max"
+                [attr.data-mandatory]="field.mandatory"
+                [attr.data-viewlist]="field.viewlist"
+                [attr.data-lookup]="field.lookup" />
+            }
+            @case (fieldType.Number) {
+              <input
+                type="text"
+                autocomplete="off"
+                placement="right"
+                container="innercontainer"
+                adaptivePosition="true"
+                [ngClass]="fieldClasses(field)"
+                [class.field-loading]="!loaded"
+                [class.field-cache]="model?.cache"
+                [class.pe-none]="showlookup || showdialog || model?.cache"
+                [style.fontSize]="
+                  field.value.length * fieldFontSize.compactPx > parseWidth(field.width) &&
+                  !field.autoformatter
+                    ? fieldFontSize.compact
+                    : fieldFontSize.default
+                "
+                [style.paddingTop]="
+                  entity.svg.length === 0
+                    ? fieldPaddingTop.none
+                    : gsv.getInt(field.height) > fieldPaddingTop.tallThreshold
+                      ? fieldPaddingTop.tall
+                      : fieldPaddingTop.short
+                "
+                nvg
+                [id]="field.name"
+                [style.left]="field.x"
+                [style.top]="field.y"
+                [style.width]="field.width"
+                [style.height]="field.height"
+                class="position-absolute"
+                [class.field-border-svg]="entity.svg.length > 0"
+                [class.field-border-left]="
+                  field.state !== 0 || entity.svg.length === 0
+                "
+                [tabindex]="field.tabindex"
+                [attr.data-type]="field.type"
+                [value]="field.value === 0 ? '' : field.value"
+                tooltip="{{ field.title }}"
+                [containerClass]="tooltipClass(field)"
+                [disabled]="
+                  !field.enabled &&
+                  field?.state !== fieldState.Error &&
+                  field?.state !== fieldState.Warning
+                "
+                [hidden]="field.state === fieldState.Hidden || !field.visible"
+                [attr.data-initialvalue]="field.initialvalue"
+                [attr.data-length]="field.precision"
+                [attr.data-decimal]="field.scale"
+                [attr.data-sign]="field.sign"
+                [attr.data-thousandseparator]="field.thousandseparator"
+                [attr.data-match]="field.match"
+                [attr.data-replace]="field.replace"
+                [attr.data-tag]="field.tag"
+                [attr.data-state]="field.state"
+                [attr.data-min]="field.min"
+                [attr.data-max]="field.max"
+                [attr.data-mandatory]="field.mandatory"
+                [attr.data-viewlist]="field.viewlist"
+                [attr.data-lookup]="field.lookup" />
+            }
+            @case (fieldType.TextualCheck) {
+              @if (field.graphic === 'text') {
+                <div>
+                  <input
+                    type="text"
+                    autocomplete="off"
+                    placement="right"
+                    container="innercontainer"
+                    adaptivePosition="true"
+                    [ngClass]="fieldClasses(field)"
+                    [class.field-loading]="!loaded"
+                    [class.field-cache]="model?.cache"
+                    [class.pe-none]="showlookup || showdialog || model?.cache"
+                    [style.paddingTop]="
+                      entity.svg.length === 0
+                        ? fieldPaddingTop.none
+                        : gsv.getInt(field.height) > fieldPaddingTop.tallThreshold
+                          ? fieldPaddingTop.tall
+                          : fieldPaddingTop.short
+                    "
+                    nvg
+                    [id]="field.name"
+                    [style.left]="field.x"
+                    [style.top]="field.y"
+                    [style.width]="field.width"
+                    [style.height]="field.height"
+                    class="position-absolute"
+                    [class.field-border-svg]="entity.svg.length > 0"
+                    [class.field-border-left]="
+                      field.state !== 0 || entity.svg.length === 0
+                    "
+                    [tabindex]="field.tabindex"
+                    [attr.data-type]="field.type"
+                    [value]="field.value"
+                    tooltip="{{ field.title }}"
+                    [containerClass]="tooltipClass(field)"
+                    [disabled]="
+                      !field.enabled &&
+                      field?.state !== fieldState.Error &&
+                      field?.state !== fieldState.Warning
+                    "
+                    [hidden]="
+                      field.state === fieldState.Hidden || !field.visible
+                    "
+                    [attr.data-allowedchars]="field.allowedchars"
+                    [attr.data-autoformatter]="field.autoformatter"
+                    [attr.data-padleftchar]="field.padleftchar"
+                    [attr.data-padrightchar]="field.padrightchar"
+                    [attr.data-initialvalue]="field.initialvalue"
+                    [attr.data-state]="field.state"
+                    [attr.data-mandatory]="field.mandatory"
+                    [attr.data-viewlist]="field.viewlist"
+                    [attr.data-lookup]="field.lookup" />
+                </div>
+              }
+              @if (field.graphic === 'check') {
+                <div>
+                  <input
+                    type="checkbox"
+                    autocomplete="off"
+                    placement="right"
+                    container="innercontainer"
+                    adaptivePosition="true"
+                    [ngClass]="fieldClasses(field)"
+                    [class.field-loading]="!loaded"
+                    [class.field-cache]="model?.cache"
+                    [class.pe-none]="showlookup || showdialog || model?.cache"
+                    [class.field-appearance-auto]="field.tag === 'X'"
+                    [class.field-appearance-none]="field.tag !== 'X'"
+                    nvg
+                    [id]="field.name"
+                    [style.left]="field.x"
+                    [style.top]="field.y"
+                    [style.width]="field.width"
+                    [style.height]="field.height"
+                    class="position-absolute"
+                    [class.field-border-svg]="entity.svg.length > 0"
+                    [class.field-border-left]="
+                      field.state !== 0 || entity.svg.length === 0
+                    "
+                    [tabindex]="field.tabindex"
+                    [attr.data-type]="field.type"
+                    [value]="field.value"
+                    [checked]="field.value === 'X' ? 'checked' : ''"
+                    tooltip="{{ field.title }}"
+                    [containerClass]="tooltipClass(field)"
+                    [disabled]="
+                      (!field.enabled &&
+                        field?.state !== fieldState.Error &&
+                        field?.state !== fieldState.Warning) ||
+                      field?.state === fieldState.ReadOnly
+                    "
+                    [hidden]="
+                      field.state === fieldState.Hidden || !field.visible
+                    "
+                    [attr.data-allowedchars]="field.allowedchars"
+                    [attr.data-autoformatter]="field.autoformatter"
+                    [attr.data-padleftchar]="field.padleftchar"
+                    [attr.data-padrightchar]="field.padrightchar"
+                    [attr.data-initialvalue]="field.initialvalue"
+                    [attr.data-state]="field.state"
+                    [attr.data-mandatory]="field.mandatory"
+                    [attr.data-viewlist]="field.viewlist"
+                    [attr.data-lookup]="field.lookup" />
+                </div>
+              }
+              @if (field.graphic === 'radio') {
+                <div>
+                  <input
+                    type="radio"
+                    autocomplete="off"
+                    placement="right"
+                    container="innercontainer"
+                    adaptivePosition="true"
+                    [ngClass]="fieldClasses(field)"
+                    [class.field-loading]="!loaded"
+                    [class.field-cache]="model?.cache"
+                    [class.pe-none]="showlookup || showdialog || model?.cache"
+                    nvg
+                    [id]="field.name"
+                    [style.left]="field.x"
+                    [style.top]="field.y"
+                    [style.width]="field.width"
+                    [style.height]="field.height"
+                    class="position-absolute"
+                    [class.field-border-svg]="entity.svg.length > 0"
+                    [class.field-border-left]="
+                      field.state !== 0 || entity.svg.length === 0
+                    "
+                    [tabindex]="field.tabindex"
+                    [attr.data-type]="field.type"
+                    [value]="field.value"
+                    [checked]="field.value === 'X' ? 'checked' : ''"
+                    tooltip="{{ field.title }}"
+                    [containerClass]="tooltipClass(field)"
+                    [disabled]="
+                      (!field.enabled &&
+                        field?.state !== fieldState.Error &&
+                        field?.state !== fieldState.Warning) ||
+                      field?.state === fieldState.ReadOnly
+                    "
+                    [hidden]="
+                      field.state === fieldState.Hidden || !field.visible
+                    "
+                    [attr.data-allowedchars]="field.allowedchars"
+                    [attr.data-autoformatter]="field.autoformatter"
+                    [attr.data-padleftchar]="field.padleftchar"
+                    [attr.data-padrightchar]="field.padrightchar"
+                    [attr.data-initialvalue]="field.initialvalue"
+                    [attr.data-state]="field.state"
+                    [attr.data-mandatory]="field.mandatory"
+                    [attr.data-viewlist]="field.viewlist"
+                    [attr.data-lookup]="field.lookup" />
+                </div>
+              }
+            }
+            @case (fieldType.Text) {
+              <input
+                type="text"
+                autocomplete="off"
+                placement="right"
+                container="innercontainer"
+                adaptivePosition="true"
+                [ngClass]="fieldClasses(field)"
+                [class.field-loading]="!loaded"
+                [class.field-cache]="model?.cache"
+                [class.pe-none]="showlookup || showdialog || model?.cache"
+                [style.fontSize]="
+                  field.value.length * fieldFontSize.compactPx > parseWidth(field.width) &&
+                  !field.autoformatter
+                    ? fieldFontSize.compact
+                    : fieldFontSize.default
+                "
+                [style.paddingTop]="
+                  entity.svg.length === 0
+                    ? fieldPaddingTop.none
+                    : gsv.getInt(field.height) > fieldPaddingTop.tallThreshold
+                      ? fieldPaddingTop.tall
+                      : fieldPaddingTop.short
+                "
+                nvg
+                [id]="field.name"
+                [style.left]="field.x"
+                [style.top]="field.y"
+                [style.width]="field.width"
+                [style.height]="field.height"
+                class="position-absolute"
+                [class.field-border-svg]="entity.svg.length > 0"
+                [class.field-border-left]="
+                  field.state !== 0 || entity.svg.length === 0
+                "
+                [tabindex]="field.tabindex"
+                [attr.data-type]="field.type"
+                [value]="field.value"
+                tooltip="{{ field.title }}"
+                [containerClass]="tooltipClass(field)"
+                [disabled]="
+                  !field.enabled &&
+                  field?.state !== fieldState.Error &&
+                  field?.state !== fieldState.Warning
+                "
+                [hidden]="field.state === fieldState.Hidden || !field.visible"
+                [attr.data-initialvalue]="field.initialvalue"
+                [attr.data-length]="field.length"
+                [attr.data-match]="field.match"
+                [attr.data-replace]="field.replace"
+                [attr.data-tag]="field.tag"
+                [attr.data-allowedchars]="field.allowedchars"
+                [attr.data-autoformatter]="field.autoformatter"
+                [attr.data-padleftchar]="field.padleftchar"
+                [attr.data-padrightchar]="field.padrightchar"
+                [attr.data-state]="field.state"
+                [attr.data-mandatory]="field.mandatory"
+                [attr.data-viewlist]="field.viewlist"
+                [attr.data-lookup]="field.lookup" />
+            }
+          }
+        }
+      </div>
+    </div>
+  `,
+  imports: [
+    CommandsComponent,
+    InputDirective,
+    NgClass,
+    BarChartComponent,
+    TooltipDirective,
+  ],
+})
+export class ModelItemComponent
+  implements AfterViewInit, ItemComponentInterface, OnDestroy
+{
+  gsv = inject(GlobalService);
+  msg = inject(AppMessageService);
+  msv = inject(ManagmentService);
+  private config = inject(NEWPORT_CONFIG);
+  private cdr = inject(ChangeDetectorRef);
+
+  public model!: ItemInterface;
+  public managment!: ManagmentInterface;
+  public insertMode!: boolean;
+  public fieldType = FieldType;
+  public fieldState = FieldState;
+  public fieldFontSize = FieldFontSize;
+  public fieldPaddingTop = FieldPaddingTop;
+  public logic!: any;
+  public titledialog = '';
+  public textdialog = '';
+  public showconfirm = false;
+  public dialogHeight = 0;
+  public dialogWidth = 0;
+  public dialogTop = 0;
+  public dialogLeft = 0;
+  public dialogType: DialogType = 0;
+  public showdialog = false;
+  private _dialogTarget = '';
+  public titlelookup = '';
+  public textlookup = '';
+  public lookupHeight = 0;
+  public lookupWidth = 0;
+  public lookupTop = 0;
+  public lookupLeft = 0;
+  public lookup = '';
+  public lookupfilter = '';
+  public showlookup = false;  
+  //
+  // Commands
+  public showcommands = false;
+  public textcommands = '';
+  public texttitle = '';
+  public commandsHeight = 0;
+  public commandsWidth = 0;
+  public commandsTop = 0;
+  public commandsLeft = 0;
+  //
+  public currentFieldId: string = '';
+  private destroyRef = inject(DestroyRef);
+
+  public viewList!: boolean;
+  public lookupField!: Member;
+
+  public bplus = true;
+  public bminus = true;
+  public bfirst = true;
+  public bprevious = true;
+  public bnext = true;
+  public blast = true;
+  public bdetail = true;
+  public bintodetail = true;
+  public bdownload = true;
+  public bupload = true;
+  public bprint = true;
+  public btable = true;
+  public save = true;
+  public refreshgrid = true;
+  public svg: string = '';
+  public data!: EntitiesData;
+  public loaded = false;
+  public entity!: Entity;
+  private _memberMap: Map<string, Member> | null = null;
+  private _readonlySet = new Set<string>();
+  private _cachedKeyArray: number[] | null = null;
+  private _cachedKeyString = '';
+  public lastKey!: number;
+  public fieldsId = '';
+  public closing = false;
+  public resetData = true;
+  public root!: Entities;
+
+  readonly container = viewChild.required<ElementRef>('innercontainer');
+  private readonly video = viewChild<ElementRef<HTMLVideoElement>>('video');
+  constructor() {
+    this.managment = this.gsv.getManagmentInterface();
+
+    this.gsv
+      .getFieldChanged()
+      .pipe(takeUntilDestroyed(this.destroyRef))
+      .subscribe(async currentFieldChanged => {
+        if (currentFieldChanged.function === 'setForced') {
+          if (this.gS(currentFieldChanged.id) === FieldState.Forced) {
+            this.sS(currentFieldChanged.id, FieldState.None);
+          } else {
+            this.sS(currentFieldChanged.id, FieldState.Forced);
+          }
+        }
+        await this.fieldChanged({
+          id: currentFieldChanged.id,
+          value: currentFieldChanged.value,
+          function: currentFieldChanged.function,
+        });
+      });
+
+    this.gsv
+      .getCurrentField()
+      .pipe(takeUntilDestroyed(this.destroyRef))
+      .subscribe(currentFieldChanged => {
+        this.logic.function(
+          Functions.lostfocus,
+          this.getIndex(),
+          this.getKeyArray(),
+          this.currentFieldId
+        );
+        this.currentField(currentFieldChanged);
+        this.setFocus(currentFieldChanged.id);
+      });
+  }
+
+  /** Lifecycle: fetches entity data on first render. */
+  async ngAfterViewInit() {
+    await this.getData(this.model.id);
+  }
+
+  /** Lifecycle: saves cached data and calls close() on component teardown. */
+  public async ngOnDestroy() {
+    if (this.data && this.data.entities) {
+      this.svg = null!;
+      this.gsv.setData(this.fieldsId, this.data);
+      if (
+        this.gsv.getProject().type !== 'D' &&
+        !this.closing &&
+        !this.model.preview
+      ) {
+        await this.close();
+      }
+    }
+  }
+
+  /**
+   * Persists any unsaved changes via putDataPromise (save) before the component is
+   * removed from the view, and optionally resets the in-memory data cache.
+   */
+  public async close() {
+    const idSchemaJson = this.managment.appId + '.' + this.managment.year;
+    this.closing = true;
+    // const root: Entities = this.gsv.getSchemaJson(idSchemaJson);
+    if (this.data && this.data.entities) {
+      this.data.entities.forEach(entity => {
+        this.fieldsId =
+          this.managment.appId +
+          '.' +
+          entity.name.toUpperCase() +
+          '.' +
+          this.managment.year;
+        const schemaEntity = this.root.entities.find(
+          e => e.name == entity.name.toLocaleLowerCase()
+        );
+        if (schemaEntity && !schemaEntity.cache && this.resetData) {
+          this.gsv.removeData(this.fieldsId);
+        }
+      });
+      this.gsv.setExtendedDescription('');
+      const json = this.getJsonData();
+      if (this.model.cache || !json) {
+        return;
+      } else {
+        return await this.throwSave(json).then(e => {
+          if (this.resetData) {
+            this.data.entities = [];
+            this.data = null!;
+            this.entity = null!;
+            this._memberMap = null;
+            this.root = null!;
+            this.gsv.setData(this.fieldsId, null!);
+          }
+        });
+      }
+    } else {
+      return;
+    }
+  }
+
+  /** Sends a PUT request to persist the given JSON payload; shows a dialog on failure. */
+  public async throwSave(json: string) {
+    if (!json || json === '') return;
+    this.managment.data = json;
+    this.managment.functionId = 'save';
+    await this.msv.putDataPromise(this.managment).then(
+      (data: TransportInterface) => {
+        this.save = true;
+        this.sendCommands();
+      },
+      error => {
+        this.showMessage(
+          this.msg.get('app.saveerror') || this.msg.get('app.unabletosave')
+        );
+      }
+    );
+  }
+
+  @HostListener('document:keydown.escape', ['$event']) onKeydownHandlerEscape(
+    event: KeyboardEvent
+  ) {
+    if (this.gsv.getModalActive()) {
+      return;
+    }
+    event.stopImmediatePropagation();
+    this.sendCommand({ id: 'exit', state: true });
+  }
+
+  @HostListener('window:keydown', ['$event']) onKeydownHandler(
+    event: KeyboardEvent
+  ) {
+    if (event.shiftKey && event.key === 'N') {
+      event.preventDefault();
+      event.stopImmediatePropagation();
+      this.sendCommand({ id: 'plus', state: true });
+    }
+  }
+
+  /** Returns true if the active locale is Italian. Used in template bindings. */
+  public defaultLanguage(): boolean {
+    return this.gsv?.getLng() === Languages.IT;
+  }
+
+  /** Returns the EntityData for the given entity name and optional entity index. */
+  public getDataEntity(name: string, entity: number = 0): EntityData {
+    return this.data?.entities.find(e => e.name === name)!;
+  }
+
+  /**
+   * Navigates to the MemberData for a field within the currently active module,
+   * using the same modulefiltered logic as commandData/fieldBusiness.
+   * Returns undefined if the entity or module cannot be resolved.
+   */
+  private getModuleMemberData(
+    fieldId: string,
+    entityName?: string
+  ): MemberData | undefined {
+    const entName = entityName ?? this.managment.entId.toLocaleLowerCase();
+    const entity = this.getDataEntity(entName);
+    if (!entity?.modules?.length) return undefined;
+    const prgLength = entity.modules[0].prg.length - 1;
+    const modulefiltered =
+      prgLength > 0
+        ? entity.modules.filter(
+            e => e.prg[0] === this.getKeyArray()[0] && e.state === 1
+          )
+        : entity.modules;
+    const index = entity.modules.indexOf(modulefiltered[this.lastKey]);
+    if (index < 0) return undefined;
+    return entity.modules[index].members.find(m => m.name === fieldId);
+  }
+
+  /** Returns the first ModuleData matching key and keyElement within the given EntityData. */
+  public getDataModule(
+    data: EntityData,
+    key: number,
+    keyElement: number,
+    module: number = 0
+  ): ModuleData {
+    return data.modules.filter(e => e.prg[keyElement] === key && e.state === 1)[
+      module
+    ];
+  }
+
+  /** Returns a nested ModuleData by entity name, key, and keyElement indices (utility for logic classes). */
+  public getDataEntityModule(
+    name: string,
+    key: number,
+    keyElement: number,
+    entity: number = 0,
+    module: number = 0
+  ): ModuleData {
+    let data = this.data.entities.filter(e => e.name === name)[entity];
+    return data.modules.filter(e => e.prg[keyElement] === key && e.state === 1)[
+      module
+    ];
+  }
+
+  /** Propagates the global UI scale factor to GlobalService. */
+  public setScale(scale: number) {
+    this.gsv.setScale(scale);
+  }
+
+  /** Handles a row selected in the lookup popup: maps output fields and resets the panel. */
+  public lookupResult(rsp: LookupResultEvent) {
+    // Parse lookup definition before clearing this.lookup below.
+    let output: string[] = [];
+    let input: string[] = [];
+    if (rsp.value !== null) {
+      const lookupdata = this.lookup.split('#');
+      output = lookupdata[4].split(',');
+      input = lookupdata[3].split(',');
+      for (let i = 0; i < input.length; i++) {
+        if (rsp.value[0][input[i]] === undefined) {
+          rsp.value[0][input[i]] = '';
+        }
+      }
+    }
+
+    // Dismiss the modal FIRST so that pe-none is lifted immediately.
+    // Also required: showlookup=false lets the lookup block inside fieldChanged
+    // run when the user next blurs a field (it checks !this.showlookup).
+    this.titlelookup = '';
+    this.textlookup = '';
+    this.lookupHeight = 0;
+    this.lookupWidth = 0;
+    this.lookupTop = 0;
+    this.lookupLeft = 0;
+    this.lookup = '';
+    this.lookupfilter = '';
+    this.textcommands = '...';
+    this.showcommands = true;
+    this.bdetail = false;
+    this.showlookup = false;
+    this.sendCommands();
+
+    if (
+      rsp.value !== null &&
+      this.lookupField &&
+      this.lookupField.state !== FieldState.ReadOnly
+    ) {
+      for (let i = 0; i < input.length; i++) {
+        // Skip only Forced (server-immutable) fields.
+        // ReadOnly = lookupoutput; a lookup selection must be able to fill these.
+        if (this.gS(output[i]) !== FieldState.Forced) {
+          this.sV(output[i], rsp.value[0][input[i]]);
+          // 'lookupCheck' is in the exclusion list of the lookup block inside
+          // fieldChanged, so this call is entirely synchronous (no HTTP fetch,
+          // no recursive lookupCheck). Do NOT await — there is nothing to await,
+          // and awaiting would schedule microtasks that interleave with the
+          // still-pending blur-triggered fieldChanged subscribers.
+          this.fieldChanged({
+            id: output[i],
+            value: rsp.value[0][input[i]],
+            function: 'lookupCheck',
+          });
+        }
+      }
+      // Run business logic for the primary output field so that computed
+      // fields (e.g. MMAG_RIG: imp/tot/rim calculations, Forced states on
+      // prz/codiva) are applied immediately after the lookup fills the fields.
+      // fieldBusiness calls updateState() internally, so we skip the separate call.
+      if (output.length > 0) {
+        this.fieldBusiness(output[0]);
+      } else {
+        // No output fields — still update navigation badge states.
+        this.updateState();
+      }
+    }
+
+    // For masterDetail entities the grid must be refreshed so that the newly
+    // populated lookup values (and any computed members set by fieldBusiness)
+    // are visible in the grid immediately after lookup selection.
+    if (this.entity?.masterdetail !== 0) {
+      this.refreshData();
+    }
+
+    if (this.lookupField) {
+      this.setFocus(this.lookupField.id);
+    }
+  }
+
+  /** Opens the lookup popup for the currently focused field, computing position and filter. */
+  public commandsResult(rsp: unknown) {
+    const field: Member = this.entity.members.find(
+      item => item.id === this.currentFieldId
+    )!;
+    if (!field) {
+      return;
+    }
+    this.titlelookup = field.lookup !== '' ? field.lookup.split('#')[6] : '';
+    this.textlookup = '';
+    this.lookupHeight = 500;
+    this.lookupWidth = 700;
+
+    const scrollTop =
+      this.container().nativeElement.parentElement.parentElement.parentElement
+        .parentElement.scrollTop;
+    const scrollLeft =
+      this.container().nativeElement.parentElement.parentElement.parentElement
+        .parentElement.scrollLeft;
+
+    if (
+      parseInt(field.y, 10) + parseInt(field.height, 10) + this.lookupHeight >
+        this.container().nativeElement.parentElement.parentElement.parentElement
+          .parentElement.clientHeight +
+          scrollTop &&
+      this.model.masterDetail == 0
+    ) {
+      this.lookupTop =
+        parseInt(field.y, 10) + parseInt(field.height, 10) - this.lookupHeight;
+    } else {
+      this.lookupTop = parseInt(field.y, 10) + parseInt(field.height, 10);
+    }
+
+    this.lookupField = field;
+    this.lookupfilter = field.lookup !== '' ? field.lookup.split('#')[5] : '';
+    if (this.lookupfilter !== '') {
+      const lkf: string[] = this.lookupfilter.split(',');
+      // tslint:disable-next-line:prefer-for-of
+      for (let i = 0; i < lkf.length; i++) {
+        const lkfe: string[] = lkf[i].split(';');
+        this.lookupfilter = this.lookupfilter.replace(
+          lkfe[1],
+          String(this.entity.members.find(item => item.id === lkfe[1].substring(1))?.value ?? '')
+        );
+      }
+    }
+
+    this.lookupLeft = parseInt(field.x, 10);
+
+    this.lookupTop -= scrollTop - 2;
+    this.lookupLeft -= scrollLeft;
+
+    let isCentered = false;
+    if (this.lookupTop < 0) {
+      const _scale = this.gsv.getScale();
+      this.lookupTop = Math.max(
+        0,
+        (window.innerHeight / _scale - this.lookupHeight) / 2
+      );
+      this.lookupLeft = Math.max(
+        0,
+        (window.innerWidth / _scale - this.lookupWidth) / 2
+      );
+      isCentered = true;
+    }
+
+    if (!isCentered) {
+      if (
+        this.lookupLeft + this.lookupWidth >
+        this.container().nativeElement.scrollWidth
+      ) {
+        this.lookupLeft = this.lookupLeft - this.lookupWidth;
+      }
+
+      if (this.lookupLeft < 0) {
+        this.lookupLeft = 0;
+      }
+    }
+
+    this.lookup = field.lookup;
+    this.textcommands = '';
+    this.texttitle = '';
+    this.showcommands = false;
+    this.bdetail = true;
+    this.showlookup = true;
+    this.sendLookup();
+  }
+
+  /** Resets all member fields to blank/default values (called when entering insert mode). */
+  public setupFields(data: Member[]) {
+    for (const input of data) {
+      if (input.id !== undefined) {
+        input.value = '';
+        input.tag = '';
+        input.initialvalue = '';
+        // Use sS() so: DOM attribute, schema member AND backing data-module state
+        // are all reset synchronously. executeCommand runs immediately after and
+        // re-applies correct states via awaited fieldChanged calls, avoiding the
+        // race condition that was caused by the old non-awaited fieldChanged here.
+        this.sS(input.id, FieldState.None);
+      }
+    }
+  }
+
+  /**
+   * Sets the visual state of a field (setState). Also updates the underlying MemberData
+   * in the data cache so that business logic and JSON serialisation remain in sync.
+   */
+  public sS(id: string, state: FieldState, message = '', dialog = false) {
+    const field: Member = this.gF(id);
+    if (field && !this.model.preview) {
+      if (this.entity.members.length > 0) {
+        if (
+          this.gE(id) &&
+          this.gE(id)!.getAttribute(FieldAttr.get('state')!) !== null
+        ) {
+          field.state = state;
+          if (state === FieldState.ReadOnly) {
+            this._readonlySet.add(id);
+          } else if (state === FieldState.None) {
+            this._readonlySet.delete(id);
+          }
+          this.gE(id)!.setAttribute(FieldAttr.get('state')!, state.toString());
+          field.title = message;
+          if (dialog && message !== '') {
+            this.showMessage(message);
+          } else {
+            this.gsv.setDialog({ target: '', state: false });
+          }
+          if (this.data) {
+            const member = this.getModuleMemberData(
+              field.id,
+              this.model.name.toLocaleLowerCase()
+            );
+            if (member) {
+              member.state = state;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  /** Returns the FieldType of the given field (getType). Defaults to Text if not found. */
+  public gT(id: string): FieldType {
+    return this.gF(id)?.type ?? FieldType.Text;
+  }
+
+  /** Returns the current FieldState of the given field (getState). Defaults to None. */
+  public gS(id: string): FieldState {
+    return this.gF(id)?.state ?? FieldState.None;
+  }
+
+  /**
+   * Sets the display value of a field (setValue). Handles type-specific formatting
+   * (dates, numbers, text) and keeps the backing MemberData and logic function in sync.
+   */
+  public sV(id: string, value: any) {
+    const field: Member = this.gF(id);
+    if (field !== undefined) {
+      switch (this.gT(id)) {
+        case FieldType.Date:
+          field.value = value;
+          if (value === '' || value === null) {
+            field.value = '';
+            field.tag = '';
+          } else {
+            value = value.replaceAll(' ', '');
+            // If the value is in ISO format (YYYY-MM-DD or YYYY-MM-DDTHH:mm:ss),
+            // convert it to locale display format before further processing.
+            const isoMatch =
+              typeof value === 'string' &&
+              value.match(/^(\d{4})-(\d{2})-(\d{2})/);
+            if (isoMatch) {
+              const fmt =
+                this.gsv.getLng() === Languages.IT
+                  ? 'DD/MM/YYYY'
+                  : 'MM/DD/YYYY';
+              value = this.formatDateFromISO(value.substr(0, 10), fmt);
+            } else if (value.indexOf('/') === -1 && value.length > 0) {
+              // User typed DDMMYYYY without separators — insert slashes.
+              value =
+                value.toString().substr(0, 2) +
+                '/' +
+                value.toString().substr(2, 2) +
+                '/' +
+                value.toString().substr(4);
+            }
+            const fmt =
+              this.gsv.getLng() === Languages.IT ? 'DD/MM/YYYY' : 'MM/DD/YYYY';
+            if (this.isValidDateString(value, fmt)) {
+              field.value = value;
+            } else {
+              field.value = '';
+            }
+            field.tag = field.value;
+          }
+          break;
+        case FieldType.Number:
+          if (value === '' || value === '0') {
+            field.value = '';
+            field.tag = '';
+          } else {
+            const isIT = this.gsv.getLng() === Languages.IT;
+            if (typeof value === 'string') {
+              value = isIT
+                ? value.replace(/\./g, '').replace(',', '.')
+                : value.replace(/,/g, '');
+            }
+            const numVal =
+              typeof value === 'number'
+                ? value
+                : parseFloat(String(value).replace(',', '.'));
+            const fixed = numVal.toFixed(field.scale);
+            field.tag = isIT ? fixed.replace('.', ',') : fixed;
+            if (field.thousandseparator) {
+              field.value = isIT
+                ? numVal.toLocaleString('it-it', {
+                    minimumFractionDigits: field.scale,
+                  })
+                : numVal.toLocaleString('en-us', {
+                    minimumFractionDigits: field.scale,
+                  });
+            } else {
+              field.value = field.tag;
+            }
+          }
+          break;
+        default:
+          if (value !== null) {
+            field.value = value.toString().toUpperCase();
+            field.tag = value.toString().toUpperCase();
+          } else {
+            field.value = '';
+            field.tag = '';
+          }
+          break;
+      }
+      if (this.data) {
+        const member = this.getModuleMemberData(field.id);
+        if (member) {
+          if (
+            member.initialvalue !== null &&
+            member.initialvalue === member.value &&
+            member.type === FieldType.Date &&
+            typeof member.initialvalue === 'string' &&
+            /^\d{4}-\d{2}-\d{2}/.test(member.initialvalue)
+          ) {
+            // Server returned an ISO date (with or without time); normalise
+            // initialvalue to the display format so dirty-detection is correct.
+            member.initialvalue = this.gV(id);
+          }
+          member.state = this.gS(id);
+          member.value = this.gV(id);
+          if (member.type === FieldType.Number && member.value === '') {
+            member.value = 0;
+          }
+          this.logic.function(
+            id + Functions.changed,
+            this.lastKey,
+            this.getKeyArray(),
+            this.currentFieldId
+          );
+          if (id === FixedField.cfpiva || id === FixedField.modnum) {
+            this.paddingFormattingRegEx(id);
+          }
+        }
+      }
+    }
+  }
+
+  /** Converts an ISO date string to DD/MM/YYYY or MM/DD/YYYY depending on locale. */
+  private formatDateFromISO(
+    isoDate: string,
+    format: 'DD/MM/YYYY' | 'MM/DD/YYYY'
+  ): string {
+    const d = new Date(isoDate);
+    if (isNaN(d.getTime())) return '';
+    const pad = (n: number) => String(n).padStart(2, '0');
+    const day = pad(d.getUTCDate());
+    const month = pad(d.getUTCMonth() + 1);
+    const year = d.getUTCFullYear();
+    return format === 'DD/MM/YYYY'
+      ? `${day}/${month}/${year}`
+      : `${month}/${day}/${year}`;
+  }
+
+  /**
+   * Converts a locale display date string (DD/MM/YYYY or MM/DD/YYYY) to ISO YYYY-MM-DD.
+   * Returns an empty string if the value is empty or not a valid display date.
+   */
+  private displayDateToISO(value: string): string {
+    if (!value || value.length !== 10) return value;
+    const fmt =
+      this.gsv.getLng() === Languages.IT ? 'DD/MM/YYYY' : 'MM/DD/YYYY';
+    if (!this.isValidDateString(value, fmt)) return value;
+    const parts = value.split('/');
+    const [p1, p2, p3] = parts.map(Number);
+    const [day, month, year] =
+      fmt === 'DD/MM/YYYY' ? [p1, p2, p3] : [p2, p1, p3];
+    const pad = (n: number) => String(n).padStart(2, '0');
+    return `${year}-${pad(month)}-${pad(day)}`;
+  }
+
+  /** Returns true if the given string is a valid date in the specified format. */
+  private isValidDateString(
+    value: string,
+    format: 'DD/MM/YYYY' | 'MM/DD/YYYY'
+  ): boolean {
+    if (!value || value.length !== 10) return false;
+    const parts = value.split('/');
+    if (parts.length !== 3) return false;
+    const [p1, p2, p3] = parts.map(Number);
+    const [day, month, year] =
+      format === 'DD/MM/YYYY' ? [p1, p2, p3] : [p2, p1, p3];
+    if (isNaN(day) || isNaN(month) || isNaN(year)) return false;
+    const d = new Date(year, month - 1, day);
+    return (
+      d.getFullYear() === year &&
+      d.getMonth() === month - 1 &&
+      d.getDate() === day
+    );
+  }
+
+  /** Returns the formatted string value (tag) of the given field (getValue). */
+  public gV(id: string): any {
+    const field: Member = this.gF(id);
+    let retValue: any = '';
+    if (field) {
+      if (field.tag) {
+        switch (this.gT(id)) {
+          case FieldType.Number:
+            retValue =
+              String(field.value ?? '').trim().length === 0 ||
+              String(field.value ?? '') === '0'
+                ? 0
+                : parseFloat(field.tag.toString().replace(',', '.'));
+            break;
+          case FieldType.Date:
+            retValue = field.value;
+            break;
+          default:
+            retValue = field.value;
+            break;
+        }
+      }
+    }
+    return retValue === null ? '' : retValue;
+  }
+
+  /** Returns the native DOM input element for the given field id (getElement). */
+  public gE(id: string): HTMLInputElement {
+    return document.getElementById(id) as HTMLInputElement;
+  }
+
+  /** Returns the schema Member definition for the given field id (getField). */
+  public gF(id: string): Member {
+    if (this.entity !== null && this.entity.members !== undefined) {
+      if (!this._memberMap) {
+        this._memberMap = new Map(this.entity.members.map(m => [m.id, m]));
+      }
+      return this._memberMap.get(id)!;
+    }
+    return undefined!;
+  }
+
+  /**
+   * Validates whether the key field value is non-empty and unique within loaded modules.
+   * On success marks the field ReadOnly and triggers commandData('create').
+   */
+  public checkKey(id: string) {
+    if (this.gV(id) === '' || this.gV(id) === 0) {
+      this.sS(id, FieldState.Fatal, this.getMessage('app.requiredkey'));
+      this.showMessage(this.getMessage('app.requiredkey'));
+      this.resetCommands();
+    } else {
+      this.sS(id, FieldState.None);
+      const entity = this.getDataEntity(
+        this.managment.entId.toLocaleLowerCase()
+      );
+      const prgLength = Math.max(0, entity.modules[0].prg.length - 1);
+      let modulefiltered: ModuleData[];
+      if (prgLength > 0) {
+        modulefiltered = entity.modules.filter(
+          e => e.prg[0] === this.getKeyArray()[0] && e.state === 1
+        );
+      } else {
+        modulefiltered = entity.modules.filter(e => e.state === 1);
+      }
+      let count = 0;
+      for (let i = 0; i < modulefiltered.length; i++) {
+        const v = modulefiltered[i].members.find(
+          e => e.name === id && e.value === this.gV(id)
+        );
+        if (v) {
+          count++;
+        }
+        if (count > 1) {
+          this.sS(id, FieldState.Fatal, this.getMessage('app.existskey'));
+          this.showMessage(this.getMessage('app.existskey'));
+          break;
+        }
+      }
+    }
+    if (this.gS(id) !== FieldState.Fatal) {
+      this.sS(id, FieldState.ReadOnly);
+      if (this.insertMode) {
+        this.sendCommands();
+      }
+    }
+    return false;
+  }
+
+  /** Performs a server-side constraint check before deleting a module record. */
+  public async checkConstraint(): Promise<boolean> {
+    let retData: boolean = true;
+    this.managment.functionId = 'checkconstraint';
+    await this.msv.putDataPromise(this.managment).then(
+      (data: TransportInterface) => {
+        retData = data.booleanResult;
+      },
+      error => {}
+    );
+    return retData;
+  }
+
+  /** Returns the localised message string for the given message key. */
+  public getMessage(id: string): string {
+    return this.msg.get(id);
+  }
+
+  /** Displays the snackbar/dialog message overlay; optionally shows a confirm button. */
+  public showMessage(
+    message: string,
+    confirm?: boolean,
+    dialogType?: DialogType
+  ) {
+    const field: Member = this.entity.members.find(
+      item => item.id === this.currentFieldId
+    )!;
+    this._dialogTarget = this.currentFieldId;
+    this.gsv.setDialog({ target: this.currentFieldId, state: true });
+    this.textdialog = message;
+    this.dialogType = dialogType!;
+    this.titledialog = this.msg.get('app.notify');
+    this.dialogHeight = 200;
+    this.dialogWidth = 400;
+    const _scale = this.gsv.getScale();
+    this.dialogTop = Math.max(0, (window.innerHeight / _scale - 200) / 2);
+    this.dialogLeft = Math.max(0, (window.innerWidth / _scale - 400) / 2);
+    this.showconfirm = confirm ?? false;
+    this.showdialog = true;
+    this.sendDialog();
+  }
+
+  /**
+   * Executes a navigation command (create, plus, minus, first, previous, next, last,
+   * table, readed, print, …) on the entity module list and then calls executeCommand.
+   */
+  public async commandData(functionId: string): Promise<void> {
+    const entity = this.getDataEntity(this.managment.entId.toLocaleLowerCase());
+    const prgLength = Math.max(0, entity.modules[0].prg.length - 1);
+
+    if (functionId !== 'table') {
+      const currentLinkItem: ItemLinkInterface = this.gsv.getCurrentLinkItem();
+      if (
+        currentLinkItem !== undefined &&
+        currentLinkItem !== null &&
+        this.entity.groupname !== '' &&
+        this.entity.groupname === currentLinkItem.groupName
+      ) {
+        for (let i = 0; i < this.entity.prgdim; i++) {
+          if (this.managment.keys !== '') {
+            this.managment.keys += ';';
+          }
+          if (i === 0) {
+            this.managment.keys = 'prg=' + currentLinkItem.prg[i];
+          } else {
+            this.managment.keys += 'prg=1';
+          }
+        }
+      }
+    }
+
+    let modulefiltered = this.getFilteredModules(entity);
+
+    switch (functionId) {
+      case 'create':
+        this.insertMode = false;
+        this.btable = this.viewList || modulefiltered.length <= 1;
+        this.bplus = !this.entity.allowadd;
+        this.bminus = this.entity.allowdelete === 'none';
+        if (!this.bplus) {
+          this.updateNavButtons(modulefiltered.length);
+        } else {
+          this.updateNavButtons(0);
+        }
+        this.lastKey = modulefiltered.length - 1;
+        this.setLastKey(
+          this.getLastKeyFromModule(modulefiltered, prgLength) +
+            modulefiltered.filter(m => m.state === 0).length
+        );
+        modulefiltered[modulefiltered.length - 1].prg = this.getKeyArray();
+        modulefiltered[modulefiltered.length - 1].insert = true;
+        break;
+      case 'readed':
+        if (!this.viewList || this.model.loaded) {
+          this.insertMode =
+            modulefiltered.length === 0 ||
+            modulefiltered[this.lastKey]!.prg.length === 0 ||
+            modulefiltered[this.lastKey]!.members[0]!.state ===
+              FieldState.Fatal;
+          this.btable =
+            this.viewList ||
+            this.insertMode ||
+            modulefiltered.length === 0 ||
+            this.model.masterDetail! > 0;
+          this.bprint = !this.entity.printable;
+          this.bplus = !this.entity.allowadd || this.insertMode;
+          this.bminus = this.entity.allowdelete === 'none' || this.insertMode;
+          if (modulefiltered.length === 0) {
+            entity.modules.push(this.getEmptyModule());
+            modulefiltered.push(entity.modules[entity.modules.length - 1]);
+            this.lastKey = modulefiltered.length - 1;
+            modulefiltered[modulefiltered.length - 1].prg = this.getKeyArray();
+          } else {
+            this.lastKey = Math.max(
+              0,
+              modulefiltered.indexOf(
+                modulefiltered.find(
+                  e => e.prg[prgLength] === this.getLastKey()
+                )!
+              )
+            );
+          }
+          this.updateNavButtons(modulefiltered.length);
+          if (modulefiltered[modulefiltered.length - 1].prg.length === 0) {
+            modulefiltered[modulefiltered.length - 1].prg = this.getKeyArray();
+          }
+          this.btable = this.model.loaded && this.model.viewList ? false : true;
+          await this.executeCommand(modulefiltered, functionId);
+        } else {
+          this.bplus = !this.entity.allowadd || this.insertMode;
+          this.bprint = false;
+          // Even in list view, run executeCommand so that updateState() fires
+          // (nav-badge states) and lookupChecks validate the loaded data.
+          if (modulefiltered.length === 0) {
+            entity.modules.push(this.getEmptyModule());
+            modulefiltered.push(entity.modules[entity.modules.length - 1]);
+            this.lastKey = modulefiltered.length - 1;
+            modulefiltered[modulefiltered.length - 1].prg = this.getKeyArray();
+          } else {
+            this.lastKey = 0;
+          }
+          await this.executeCommand(modulefiltered, functionId);
+        }
+        this.model.loaded = false;
+        modulefiltered[modulefiltered.length - 1].insert = false;
+        break;
+      case 'plus':
+        this.btable = true;
+        this.updateNavButtons(0);
+        this.bplus = true;
+        this.bminus = true;
+        this.insertMode = true;
+        this.viewList = false;
+        if (entity.modules[0].prg.length === 0) {
+          entity.modules.splice(0, 1);
+        }
+        const newModule = this.getEmptyModule();
+        if (prgLength > 0) {
+          entity.modules.push(newModule);
+        }
+        modulefiltered.push(newModule);
+        this.lastKey = modulefiltered.length - 1;
+        this.setLastKey(
+          this.getLastKeyFromModule(modulefiltered, prgLength) +
+            modulefiltered.filter(m => m.state === 0).length
+        );
+        modulefiltered[modulefiltered.length - 1].prg = this.getKeyArray();
+        modulefiltered[modulefiltered.length - 1].insert = true;
+        this.setupFields(this.entity.members);
+        await this.executeCommand(modulefiltered, functionId);
+        break;
+      case 'minus':
+        modulefiltered[this.lastKey].state = 0;
+        // Delete linkeds
+        this.model.linkedItems?.forEach(linkedItemValue => {
+          if (linkedItemValue !== '') {
+            const linkedItem = this.data.entities.filter(
+              e => e.name === linkedItemValue.toLocaleLowerCase()
+            )[0];
+            const linkedElements = linkedItem.modules.filter(
+              e => e.prg[0] === this.getKeyArray()[0]
+            );
+            linkedElements.forEach(linkedElement => {
+              linkedElement.state = 0;
+            });
+          }
+        });
+        if (
+          (this.model.linkedItems ?? []).indexOf(
+            this.model.name.toUpperCase()
+          ) < 0
+        ) {
+          modulefiltered[this.lastKey]!.state = 0;
+        }
+        this.insertMode = true;
+        modulefiltered = modulefiltered.filter(m => m.state === 1);
+        const deleted = entity.modules.filter(
+          e => e.prg[0] === this.getKeyArray()[0] && e.state === 0
+        ).length;
+        if (modulefiltered.length > 0) {
+          this.lastKey = modulefiltered.length - 1;
+        } else {
+          await this.commandData('plus');
+        }
+        this.insertMode =
+          modulefiltered.length === 0 ||
+          modulefiltered[this.lastKey].prg.length === 0 ||
+          modulefiltered[this.lastKey].members[0].state === FieldState.Fatal;
+        this.btable = modulefiltered.length <= 1;
+        this.bprint = !this.entity.printable;
+        this.bplus = !this.entity.allowadd || this.insertMode;
+        this.bminus = this.entity.allowdelete === 'none' || this.insertMode;
+        this.updateNavButtons(modulefiltered.length);
+        await this.executeCommand(modulefiltered, functionId);
+        break;
+      case 'table':
+        this.lastKey = modulefiltered.indexOf(
+          modulefiltered.find(e => e.prg[prgLength] === this.getLastKey())!
+        );
+        this.updateNavButtons(modulefiltered.length);
+        this.bplus = !this.entity.allowadd || this.insertMode;
+        this.bminus = this.entity.allowdelete === 'none' || this.insertMode;
+        this.btable = false;
+        this.bprint = this.viewList;
+        await this.executeCommand(modulefiltered, functionId);
+        break;
+      case 'first':
+        this.lastKey = 0;
+        this.updateNavButtons(modulefiltered.length);
+        await this.executeCommand(modulefiltered, functionId);
+        break;
+      case 'previous':
+        this.lastKey--;
+        this.updateNavButtons(modulefiltered.length);
+        await this.executeCommand(modulefiltered, functionId);
+        break;
+      case 'next':
+        this.lastKey++;
+        this.updateNavButtons(modulefiltered.length);
+        await this.executeCommand(modulefiltered, functionId);
+        break;
+      case 'last':
+        this.lastKey = modulefiltered.length - 1;
+        this.updateNavButtons(modulefiltered.length);
+        await this.executeCommand(modulefiltered, functionId);
+        break;
+      default:
+        this.resetData = false;
+        await this.close().then(_ => {
+          this.msv.putDataPromise(this.managment).then(
+            (data: TransportInterface) => {
+              this.insertMode = false;
+              if (functionId === 'print') {
+                this.gsv.setLoaderState(true);
+                this.managment.fields = [];
+                this.managment.functionId = 'print';
+                this.msv.downloadFile(this.managment).pipe(takeUntilDestroyed(this.destroyRef)).subscribe({
+                  next: data => {
+                    switch (data.type) {
+                      case HttpEventType.DownloadProgress:
+                        break;
+                      case HttpEventType.Response:
+                        const blob = new Blob([data.body!], {
+                          type: data.body!.type,
+                        });
+                        saveAs(blob, uuidv4() + '.pdf');
+                        break;
+                    }
+                  },
+                  error: error => {},
+                });
+                this.gsv.setLoaderState(false);
+              }
+              this.setFocus(
+                this.insertMode
+                  ? this.model.focusOnInsert
+                  : this.model.focusOnUpdate
+              );
+              this.managment.fields = [];
+              this.managment.states = [];
+            },
+            error => {}
+          );
+        });
+        break;
+    }
+
+    this.gsv.setCurrentLinkItem({
+      id: this.entity.name,
+      groupName: this.entity.groupname,
+      prg: this.getKeyArray(),
+    });
+  }
+
+  /**
+   * Sets the four directional navigation buttons (first/prev/next/last) based on
+   * the current `lastKey` position within the filtered module array.
+   */
+  private updateNavButtons(totalItems: number) {
+    this.bfirst = true;
+    this.bprevious = true;
+    this.bnext = true;
+    this.blast = true;
+    if (totalItems > 1) {
+      if (this.lastKey > 0) {
+        this.bfirst = false;
+        this.bprevious = false;
+      }
+      if (this.lastKey < totalItems - 1) {
+        this.bnext = false;
+        this.blast = false;
+      }
+    }
+  }
+
+  /** Returns the filtered module list for the current entity, scoped to the active key. */
+  private getFilteredModules(entity: EntityData): ModuleData[] {
+    const prgLength = Math.max(0, entity.modules[0].prg.length - 1);
+    if (prgLength > 0) {
+      return entity.modules.filter(
+        e => e.prg[0] === this.getKeyArray()[0] && e.state === 1
+      );
+    }
+    return entity.modules;
+  }
+
+  /** Pushes updated entity data to GlobalService and optionally triggers a grid refresh. */
+  refreshData(force: boolean = false) {
+    if (this.entity.masterdetail !== 0 || force) {
+      this.gsv.setData(this.fieldsId, this.data);
+      this.gsv.setData(
+        this.managment.appId +
+          '.' +
+          this.managment.entId +
+          '.' +
+          this.managment.year,
+        this.data
+      );
+      this.refreshgrid = !this.refreshgrid;
+      this.gsv.emitGridRefresh();
+    }
+    this.sendCommands();
+  }
+
+  /** Computes the next PRG key start index for a new module record. */
+  getLastKeyFromModule(
+    modulefiltered: ModuleData[],
+    prgLength: number
+  ): number {
+    let startKey = 0;
+    this.lastKey = modulefiltered.length - 1;
+    if (this.lastKey > 0) {
+      startKey = modulefiltered[this.lastKey - 1].prg[prgLength] + 1;
+    } else {
+      startKey = modulefiltered.length;
+    }
+    return startKey;
+  }
+
+  /** Clones the first module record from the schema JSON to use as a blank template. */
+  getEmptyModule(): ModuleData {
+    const entity = this.gsv
+      .getDataJson(this.getIdModel())
+      .entities.filter(
+        e => e.name === this.managment.entId.toLocaleLowerCase()
+      )[0];
+    return JSON.parse(JSON.stringify(entity.modules[0]));
+  }
+
+  /** Returns the composite project key 'PROJECT.YEAR' used to look up schema/data caches. */
+  getIdModel(): string {
+    return this.gsv.getProject().project + '.' + this.gsv.getProject().year;
+  }
+
+  /** Returns the composite entity cache key 'APP.ENT.YEAR'. */
+  getEntIdModel(): string {
+    return (
+      this.managment.appId +
+      '.' +
+      this.managment.entId +
+      '.' +
+      this.managment.year
+    );
+  }
+
+  /**
+   * Populates entity member fields from the given module, fires fieldChanged for each,
+   * syncs initialvalue/initialstate after insert to avoid false-dirty detection, and
+   * applies any pending logic refresh flags before moving focus.
+   */
+  async executeCommand(
+    module: ModuleData[],
+    functionId: string
+  ): Promise<void> {
+    this._readonlySet.clear();
+    let entity = module[this.lastKey];
+    for (let fld of entity.members) {
+      const field: Member = this.entity.members.find(
+        item => item.name === fld.name
+      )!;
+      if (field) {
+        if (!field.visible) {
+          this.sS(field.id, FieldState.Hidden);
+        }
+        switch (field.type) {
+          case FieldType.Date:
+            if (fld.value !== null && fld.value !== '' && typeof fld.value === 'string') {
+              field.value =
+                fld.value.length > 10
+                  ? this.formatDateFromISO(
+                      fld.value.substring(0, 10),
+                      this.gsv.getLng() === Languages.IT
+                        ? 'DD/MM/YYYY'
+                        : 'MM/DD/YYYY'
+                    )
+                  : fld.value;
+              field.tag = new Date(fld.value);
+            } else {
+              field.value = null;
+              field.tag = null;
+            }
+            break;
+          case FieldType.Number:
+            if (fld.value === 0) {
+              field.value = '';
+              field.tag = '';
+            } else {
+              field.value = fld.value;
+              field.tag = parseFloat(String(fld.value));
+            }
+            break;
+          case FieldType.Text:
+          case FieldType.TextualCheck:
+          case FieldType.Combo:
+            field.value = fld.value;
+            field.tag = fld.value;
+            break;
+          default:
+            field.value = fld.value;
+            field.tag = fld.value;
+            break;
+        }
+        await this.fieldChanged({
+          id: fld.name,
+          value: String(field.value ?? ''),
+          function: 'executeCommand',
+        });
+      }
+    }
+    if (!this.insertMode) {
+      this.setLastKey(
+        module[this.lastKey].prg[module[this.lastKey].prg.length - 1]
+      );
+    }
+
+    let fieldFocus =
+      this.insertMode || !this.entity.members.find(_ => _.value !== '')
+        ? this.entity.focusoninsert
+        : this.entity.focusonupdate;
+
+    if (
+      this.gsv.getCurrentFocus().id &&
+      this.gsv.getCurrentFocus().id.length > 0
+    ) {
+      fieldFocus = this.gsv.getCurrentFocus().id;
+      this.gsv.setCurrentFocus({ id: '', value: '' });
+    }
+
+    this.logic.function(
+      Functions.executedCommand + functionId,
+      this.lastKey,
+      this.getKeyArray(),
+      this.currentFieldId
+    );
+
+    // After all auto-fills/calculations on a new module, sync initialvalue so
+    // that logic-auto-filled defaults are not treated as user changes. Without
+    // this, close() → getJsonData() would detect value !== initialvalue and
+    // send an empty record to the server even if the user never typed anything.
+    // Exception: non-empty Date fields are intentionally excluded from the sync
+    // so that mandatory today-filled dates are always serialised in the save
+    // payload (member.initialvalue stays null → value !== initialvalue).
+    if (module[this.lastKey]?.insert) {
+      module[this.lastKey].members.forEach(m => {
+        if (m.type === FieldType.Date && m.value !== null && m.value !== '') {
+          return;
+        }
+        m.initialvalue = m.value;
+      });
+    }
+
+    // Apply any state/value changes queued via refresh flags (e.g. dynamicView
+    // triggered by logic.function above). Sync initialstate so getJsonData()
+    // does not mistake structural visibility changes for user edits.
+    try {
+      const _eDyn = this.getDataEntity(this.model.name.toLocaleLowerCase());
+      const _idxDyn = this.getIndex();
+      const _dynModule = _eDyn?.modules.filter(e => e.state === 1)[_idxDyn];
+      const _isInsert = !!_dynModule?.insert;
+      const _toRefresh = _dynModule?.members.filter(m => m.refresh) ?? [];
+      _toRefresh.forEach(m => {
+        m.initialstate = m.state;
+        // Do not sync initialvalue for Date fields whose value is non-empty but
+        // whose initialvalue is still null. This means the date was set by the
+        // mandatory-today logic over a null server value and must remain dirty
+        // so that getJsonData() includes it in the save payload.
+        if (
+          !(
+            m.type === FieldType.Date &&
+            m.value !== null &&
+            m.value !== '' &&
+            m.initialvalue === null
+          )
+        ) {
+          m.initialvalue = m.value;
+        }
+        this.sS(m.name, m.state);
+        this.sV(m.name, m.value);
+        if (m.message) this.gF(m.name).title = m.message;
+        m.refresh = false;
+      });
+    } catch (e) {
+      console.error('executeCommand refresh-flags error:', e);
+    }
+
+    // General logic.calc() pass: run calc for every field in the loaded module so
+    // that state changes expressed in calc() (ReadOnly, Error, Warning, Hidden…)
+    // are applied on initial load for ALL models — not only those that use the
+    // logic.function(executedCommand*) / refresh-flag mechanism.
+    try {
+      const _calcIdx = this.getIndex();
+      for (const fld of entity.members) {
+        this.logic.calc(fld.name, _calcIdx, this.getKeyArray());
+      }
+      // Apply refresh flags accumulated by the calc pass above.
+      const _eCalc = this.getDataEntity(this.model.name.toLocaleLowerCase());
+      const _calcModule = _eCalc?.modules.filter(e => e.state === 1)[_calcIdx];
+      if (_calcModule) {
+        _calcModule.members
+          .filter(m => m.refresh)
+          .forEach(m => {
+            m.initialstate = m.state;
+            // Do not sync initialvalue for Date fields whose value is non-empty but
+            // whose initialvalue is still null. This means the date was set by the
+            // mandatory-today logic over a null server value (either new insert or
+            // existing record that never had a date) and must remain dirty so that
+            // getJsonData() includes it in the save payload.
+            if (
+              !(
+                m.type === FieldType.Date &&
+                m.value !== null &&
+                m.value !== '' &&
+                m.initialvalue === null
+              )
+            ) {
+              m.initialvalue = m.value;
+            }
+            this.sS(m.name, m.state);
+            this.sV(m.name, m.value);
+            if (m.message) this.gF(m.name).title = m.message;
+            m.refresh = false;
+          });
+      }
+    } catch (e) {
+      console.error('executeCommand calc-pass error:', e);
+    }
+
+    // Re-apply business-logic states (Error/Warning) that were wiped by the
+    // fieldChanged('executeCommand') loop above, which resets any Error state
+    // to None before logic.calc has a chance to re-set it.
+    if (functionId === 'create' && this.currentFieldId) {
+      this.fieldBusiness(this.currentFieldId);
+    }
+
+    this.save = true;
+    this.updateState();
+    this.refreshData(true);
+    this.setFocus(fieldFocus);
+    this.gsv.setLoaderState(false);
+  }
+
+  /**
+   * Serialises only changed (or deleted) members and modules to a JSON string
+   * suitable for PUT /managment. Returns an empty string when there is nothing to save.
+   */
+  getJsonData(): string {
+    if (this.data) {
+      let hasData = false;
+      let json = '{"entities":[';
+      this.data.entities.forEach(entity => {
+        let modules = 0;
+        let hasModule = false;
+        entity.modules.forEach((module, mi) => {
+          let members = 0;
+          const fatalMember = module.members.find(
+            i => i.state === FieldState.Fatal
+          );
+          if (fatalMember) {
+            // Only mark as deleted if the module has actual server data
+            // (at least one member whose value differs from initialvalue).
+            // Template modules created locally but never committed should not
+            // generate @deleted markers that trigger spurious save requests.
+            const hasServerData = module.members.some(
+              m =>
+                m.value !== m.initialvalue ||
+                (m.state !== m.initialstate && m.state !== FieldState.Fatal)
+            );
+            if (hasServerData) {
+              module.state = 0;
+            } else {
+              return;
+            }
+          }
+          if (module.state === 0) {
+            module.members = [];
+          }
+          if (module.members.length === 0) {
+            if (modules === 0 && members == 0) {
+              if (json !== '{"entities":[') {
+                json += ',';
+              }
+              json += '{"name":"' + entity.name + '","modules":[';
+            }
+            if (modules > 0 && members === 0) {
+              json += ',';
+            }
+            if (members === 0) {
+              json += '{ "members": [';
+            }
+            if (members > 0) {
+              json += ',';
+            }
+            json += '{"name":"@deleted"}';
+            hasData = true;
+            members++;
+          }
+          module.members.forEach(member => {
+            if (
+              (member?.value !== member?.initialvalue ||
+                member?.initialstate !== member?.state) &&
+              member.type !== FieldType.Label &&
+              member.type !== FieldType.Button &&
+              member.type !== FieldType.Video &&
+              member.type !== FieldType.Image &&
+              member.type !== FieldType.Map &&
+              member.type !== FieldType.Chart
+            ) {
+              if (modules === 0 && members == 0) {
+                if (json !== '{"entities":[') {
+                  json += ',';
+                }
+                json += '{"name":"' + entity.name + '","modules":[';
+              }
+              if (modules > 0 && members === 0) {
+                json += ',';
+              }
+              if (members === 0) {
+                json += '{ "members": [';
+              }
+              if (members > 0) {
+                json += ',';
+              }
+              const _serializedValue =
+                member.type === FieldType.Date && member.value
+                  ? this.displayDateToISO(member.value.toString())
+                  : member.value
+                    ? member.value.toString().toUpperCase()
+                    : '';
+              json +=
+                '{"name":"' +
+                member.name +
+                '", "value":' +
+                '"' +
+                _serializedValue +
+                '"' +
+                ',"state":' +
+                member.state +
+                ',"initialstate":' +
+                member.initialstate +
+                '}';
+              member.initialvalue = member.value;
+              member.initialstate = member.state;
+              members++;
+              hasData = true;
+            }
+          });
+          if (module.prg.length === 0) {
+            module.prg = this.getKeyArray();
+          }
+          if (members > 0) {
+            json += '],"prg":[' + module.prg + ']}';
+            modules++;
+            hasModule = true;
+          }
+        });
+        if (hasModule) {
+          json += ']}';
+        }
+      });
+      json += ']}';
+      return hasData ? json : '';
+    }
+    return '';
+  }
+
+  /** Parses the composite PRG key string into a numeric array (e.g. 'prg=1;prg=2' → [1,2]). */
+  public getKeyArray(): number[] {
+    if (
+      this._cachedKeyArray === null ||
+      this._cachedKeyString !== this.managment.keys
+    ) {
+      this._cachedKeyString = this.managment.keys;
+      this._cachedKeyArray = this.managment.keys
+        .split(';')
+        .map(e => parseInt(e.replace('prg=', ''), 10));
+    }
+    return this._cachedKeyArray;
+  }
+
+  /** Returns the last (innermost) PRG key from the composite key string. */
+  public getLastKey(): number {
+    const keys = this.managment.keys.split(';');
+    return parseInt(keys[keys.length - 1].replace('prg=', ''));
+  }
+
+  /** Replaces the last PRG segment in the composite key string with the given value. */
+  public setLastKey(lastKey: number) {
+    const keyElements = this.managment.keys.split(';');
+    keyElements[keyElements.length - 1] = 'prg=' + lastKey;
+    this.managment.keys = keyElements.join(';');
+  }
+
+  /** Resets the dialog overlay state and restores focus after the user dismisses the dialog. */
+  public dialogResult(rsp: DialogResultEvent) {
+    this.textdialog = '';
+    this.titledialog = '';
+    this.showconfirm = false;
+    this.showdialog = false;
+    const target = this._dialogTarget;
+    this._dialogTarget = '';
+    if (target !== '') {
+      if (this.gS(target) === FieldState.Fatal) {
+        this.sV(target, '');
+        this.sS(target, FieldState.None);
+      }
+      this.setFocus(target);
+    } else {
+      this.setFocus(
+        this.insertMode ? this.entity.focusoninsert : this.entity.focusonupdate
+      );
+    }
+    this.gsv.setDialog({ target: '', state: false });
+  }
+
+  /**
+   * Updates the active field ID and shows/hides the lookup trigger button
+   * when the focused field has an associated lookup entity.
+   */
+  private currentField(currentField: Member) {
+    if (
+      currentField &&
+      this.entity &&
+      this.entity.members &&
+      currentField.id !== this.currentFieldId
+    ) {
+      this.currentFieldId = currentField.id;
+      const field: Member = this.entity.members.find(
+        item => item.id === currentField.id
+      )!;
+      this.textcommands = '';
+      this.texttitle = '';
+      this.showcommands = false;
+      this.bdetail = true;
+      this.bintodetail = true;
+      if (field && field.lookup !== '') {
+        this.lookupField = currentField;
+        this.commandsHeight = parseInt(field.height, 10);
+        this.commandsWidth = 12;
+        this.commandsTop = parseInt(field.y, 10);
+        this.commandsLeft =
+          parseInt(field.x, 10) + parseInt(field.width, 10) - 12;
+        this.textcommands = '...';
+        this.texttitle = field.lookup.split('#')[6];
+        this.showcommands = true;
+        this.bdetail = false;
+        this.bintodetail = false;
+      }
+      field.value = field?.tag;
+      if (field?.autoformatter) {
+        const domEl = this.gE(field.id);
+        if (domEl) domEl.value = String(field.tag ?? '');
+      }
+      this.sendCommands();
+    }
+  }
+
+  /**
+   * Core field-change pipeline: normalises the input value (padding, regex, lookup),
+   * persists it to MemberData, runs business logic, and schedules DOM updates.
+   */
+  private async fieldChanged(currentFieldChanged: ItemFieldChangedInterface) {
+    if (
+      currentFieldChanged.function === 'asyncRefresh' ||
+      (this.showdialog && currentFieldChanged.function === 'sendChanged') ||
+      (currentFieldChanged.function === 'sendChanged' &&
+        this.gF(currentFieldChanged.id)?.lookupoutput &&
+        !this.gF(currentFieldChanged.id)?.lookup &&
+        this.gS(currentFieldChanged.id) === FieldState.ReadOnly)
+    ) {
+      if (currentFieldChanged.function === 'asyncRefresh') {
+        this.cdr.detectChanges();
+      }
+      return;
+    }
+    if (this.entity) {
+      const id = currentFieldChanged.id;
+      const field: Member = this.entity?.members?.find(item => item.id === id)!;
+      if (field) {
+        if (
+          (this.gS(currentFieldChanged.id) === FieldState.Error ||
+            field.function !== 'none') &&
+          this.gS(currentFieldChanged.id) !== FieldState.Forced &&
+          this.gS(currentFieldChanged.id) !== FieldState.ReadOnly
+        ) {
+          this.sS(currentFieldChanged.id, FieldState.None);
+        }
+        if (this.gE(field.id)) {
+          this.sV(id, currentFieldChanged.value);
+          switch (field.type) {
+            case FieldType.Text:
+              if (field.generateuid && field.value === '') {
+                this.sV(field.id, uuidv4());
+              }
+              break;
+            case FieldType.Number:
+              if (field.generateuid && field.value === '') {
+                this.sV(
+                  field.id,
+                  parseInt(this.managment.keys.replace('prg=', ''), 0)
+                );
+              }
+              break;
+          }
+          if (
+            field.groupname !== '' &&
+            field.value !== '' &&
+            field.groupname !== undefined
+          ) {
+            for (let i = 0; i < this.entity.members.length; i++) {
+              if (
+                this.entity.members[i].groupname === field.groupname &&
+                this.entity.members[i].id !== field.id
+              ) {
+                this.sV(this.entity.members[i].id, '');
+              }
+            }
+          }
+          // Controlli di livello generale
+          switch (field.type) {
+            case FieldType.Date:
+              if (
+                field.mandatory === true &&
+                this.gV(id) === '' &&
+                this.gS(id) !== FieldState.Forced
+              ) {
+                if (this.gS(currentFieldChanged.id) === FieldState.Error) {
+                  this.sS(currentFieldChanged.id, FieldState.None);
+                }
+                if (field.today) {
+                  const d = new Date();
+                  const dd = String(d.getDate()).padStart(2, '0');
+                  const mm = String(d.getMonth() + 1).padStart(2, '0');
+                  const yyyy = d.getFullYear();
+                  const dataStr = this.gsv.getLng() === Languages.IT
+                    ? `${dd}/${mm}/${yyyy}`
+                    : `${mm}/${dd}/${yyyy}`;
+                  this.sV(id, dataStr);
+                } else {
+                  this.sS(id, FieldState.Error, this.msg.get('app.required'));
+                }
+              } else if (this.gV(id).length < 10 && this.gV(id).length > 0) {
+                this.sS(id, FieldState.Error, this.msg.get('app.dateerror'));
+              } else if (
+                this.gV(id) &&
+                !this.isValidDateString(
+                  this.gV(id),
+                  this.gsv.getLng() === Languages.IT
+                    ? 'DD/MM/YYYY'
+                    : 'MM/DD/YYYY'
+                )
+              ) {
+                this.sS(id, FieldState.Error, this.msg.get('app.dateerror'));
+              }
+              break;
+            case FieldType.Text:
+              if (
+                field.mandatory === true &&
+                this.gV(id) === '' &&
+                this.gS(id) !== FieldState.Forced
+              ) {
+                this.sS(id, FieldState.Error, this.msg.get('app.required'));
+              }
+              if (
+                field.function === 'cf' &&
+                this.gS(id) !== FieldState.Forced
+              ) {
+                if (field.value !== '') {
+                  // Strip autoformatter spaces before structural validation so
+                  // that a spaced display value (e.g. "R S S M ...") validates
+                  // correctly against the raw 16-char CF string.
+                  const cfRaw = String(field.value ?? '').replace(/\s/g, '');
+                  try {
+                    const cf = new CodiceFiscale(cfRaw);
+                  } catch (err) {
+                    // BUG-FIX: was `if (this.gS(id))` — FieldState.None === 0 is
+                    // falsy, so the error was never set after the reset-to-None
+                    // that always runs at the top of fieldChanged. Only skip if
+                    // the field is already in a Fatal state (key field).
+                    if (this.gS(id) !== FieldState.Fatal) {
+                      this.sS(id, FieldState.Error, this.msg.get('app.cferr'));
+                    }
+                  }
+                }
+              }
+              if (
+                field.function === 'piva' &&
+                this.gS(id) !== FieldState.Forced
+              ) {
+                // Strip autoformatter spaces before validation.
+                const pivaRaw = String(field.value ?? '').replace(/\s/g, '');
+                const piva: PartitaIVA = new PartitaIVA(pivaRaw);
+                if (piva.Check().length !== 0) {
+                  this.sS(id, FieldState.Error, this.msg.get('app.pivaerr'));
+                }
+              }
+              if (
+                field.function === 'cfpiva' &&
+                this.gS(id) !== FieldState.Forced
+              ) {
+                if (field.value !== '') {
+                  // Strip autoformatter spaces so the raw value is validated.
+                  // A 16-char CF with spacing:1 becomes 31 chars in the DOM;
+                  // without stripping, it would incorrectly fall into the PIVA
+                  // branch and get flagged as an error.
+                  const cfpivaRaw = String(field.value ?? '').replace(/\s/g, '');
+                  let error = false;
+                  try {
+                    if (cfpivaRaw.length === 16) {
+                      const cf = new CodiceFiscale(cfpivaRaw);
+                      error = false;
+                    } else {
+                      const piva: PartitaIVA = new PartitaIVA(cfpivaRaw);
+                      const cfpiva = piva.Check().length !== 0;
+                      if (cfpiva) {
+                        error = true;
+                      }
+                    }
+                  } catch (err) {
+                    error = true;
+                  }
+                  if (error) {
+                    this.sS(
+                      id,
+                      FieldState.Error,
+                      this.msg.get('app.cfpivaerr')
+                    );
+                  } else {
+                    this.sS(id, FieldState.None, '');
+                  }
+                }
+              }
+              if (
+                field.function === 'mail' &&
+                this.gS(id) !== FieldState.Forced
+              ) {
+                if (field.value != '') {
+                  // Strip spaces (autoformatter artefacts) before regex check.
+                  const mailRaw = String(field.value ?? '').replace(/\s/g, '');
+                  if (!mailRaw.match('[^s@]+@[^s@]+.[^s@]+$')) {
+                    this.sS(id, FieldState.Error, this.msg.get('app.emailerr'));
+                  }
+                }
+              }
+              break;
+            case FieldType.Number:
+              if (
+                field.mandatory === true &&
+                this.gV(id) === 0 &&
+                this.gS(id) !== FieldState.Forced
+              ) {
+                this.sS(id, FieldState.Error, this.msg.get('app.required'));
+              }
+              if (field.min !== '' && this.gS(id) !== FieldState.Forced) {
+                const minV = parseFloat(String(field.min));
+                if (minV !== 0) {
+                  if (this.gV(id) < minV) {
+                    this.sS(id, FieldState.Error, this.msg.get('app.rangemin'));
+                  }
+                }
+              }
+              if (field.max !== '' && this.gS(id) !== FieldState.Forced) {
+                const maxV = parseFloat(String(field.max));
+                if (maxV !== 0) {
+                  if (this.gV(id) > maxV) {
+                    this.sS(id, FieldState.Error, this.msg.get('app.rangemax'));
+                  }
+                }
+              }
+              break;
+          }
+          if (
+            field.lookup !== '' &&
+            !this.showlookup &&
+            currentFieldChanged.function !== 'noBusiness' &&
+            currentFieldChanged.function !== 'lookupCheck'
+          ) {
+            const lkmanagment: ManagmentInterface =
+              this.gsv.getManagmentInterface();
+            const lkinfo: string[] = field.lookup.split('#');
+            const input: string[] = lkinfo[3].split(',');
+            const output: string[] = lkinfo[4].split(',');
+            const extern: string[] = lkinfo[5].split(',');
+            lkmanagment.fields = [];
+            lkmanagment.functionId = 'read';
+            lkmanagment.appId = lkinfo[0].toUpperCase();
+            lkmanagment.year = parseInt(lkinfo[1], 10);
+            lkmanagment.entId = lkinfo[2].toUpperCase();
+            lkmanagment.keys = 'prg=0';
+            const lkFieldsId =
+              lkmanagment.appId +
+              '.' +
+              lkmanagment.entId +
+              '.' +
+              lkmanagment.year;
+            const lkdata = this.gsv.getData(lkFieldsId);
+            let resolvedData = lkdata;
+            // During executeCommand (initial data load from server), skip the
+            // expensive HTTP fetch — values are already valid. If lookup data is
+            // cached we still run lookupCheck to set ReadOnly states; if not
+            // cached we just apply ReadOnly to lookupoutput fields directly.
+            if (currentFieldChanged.function === 'executeCommand' && !lkdata) {
+              for (let i = 1; i < output.length; i++) {
+                if (this.gF(output[i])?.lookupoutput) {
+                  this.sS(
+                    output[i],
+                    this.gS(output[i]) !== this.fieldState.Hidden
+                      ? this.fieldState.ReadOnly
+                      : this.fieldState.Hidden
+                  );
+                }
+              }
+            } else {
+              if (
+                !lkdata ||
+                (this.gsv.getSchemaJson(
+                  lkmanagment.appId + '.' + lkmanagment.year
+                ) !== undefined &&
+                  !this.gsv
+                    .getSchemaJson(lkmanagment.appId + '.' + lkmanagment.year)
+                    .entities.find(
+                      e => e.name == lkmanagment.entId.toLocaleLowerCase()
+                    )!.cache)
+              ) {
+                if (currentFieldChanged.function !== 'executeCommand') {
+                  const data = await firstValueFrom(
+                    this.msv.getData(lkmanagment)
+                  );
+                  const dataFile = JSON.parse(data.dataFile as string);
+                  this.gsv.setData(lkFieldsId, dataFile);
+                  resolvedData = dataFile;
+                }
+              }
+              if (resolvedData) {
+                const module = resolvedData!.entities.filter(
+                  (e: any) => e.name === lkmanagment.entId.toLocaleLowerCase()
+                )[0];
+                await this.lookupCheck(
+                  module.modules,
+                  field,
+                  input,
+                  output,
+                  extern,
+                  currentFieldChanged.function
+                );
+              } else if (currentFieldChanged.function === 'executeCommand') {
+                // No cached data and fetch was skipped — still mark lookupoutput fields ReadOnly.
+                for (let i = 1; i < output.length; i++) {
+                  if (this.gF(output[i])?.lookupoutput) {
+                    this.sS(
+                      output[i],
+                      this.gS(output[i]) !== this.fieldState.Hidden
+                        ? this.fieldState.ReadOnly
+                        : this.fieldState.Hidden
+                    );
+                  }
+                }
+              }
+              this.cdr.detectChanges();
+            }
+          }
+        }
+        this.paddingFormattingRegEx(id);
+        if (
+          this.gF(id).tabindex == 0 &&
+          this.model.rootModel &&
+          currentFieldChanged.function === 'sendChanged' &&
+          !this.viewList
+        ) {
+          this.checkKey(id);
+        }
+        if (currentFieldChanged.function === 'sendChanged') {
+          if (this.insertMode && this.gS(id) !== FieldState.Fatal) {
+            if (!this.insertMode) {
+              this.commandData('create');
+              this.sendCommands();
+            }
+          }
+          const preBusinessState = this.gS(id);
+          const preBusinessMsg = this.gF(id)?.title ?? '';
+          this.fieldBusiness(id);
+          // Preserve validation Error/Warning that dynamicView/calc may have
+          // overridden back to None via refresh flags.
+          if (
+            (preBusinessState === FieldState.Error ||
+              preBusinessState === FieldState.Warning) &&
+            this.gS(id) === FieldState.None
+          ) {
+            this.sS(id, preBusinessState, preBusinessMsg);
+          }
+        }
+      }
+    }
+  }
+
+  /** Padding, formatting, regex */
+  private paddingFormattingRegEx(id: string) {
+    this.PadSpacing(id);
+    const regExpRet = this.regExpression(id);
+    if (!regExpRet) {
+      this.sS(id, FieldState.Error, this.msg.get('app.regexpnotmatch'));
+    }
+  } 
+
+  /** Computes the flat module index accounting for multi-dimensional PRG arrays. */
+  private getIndex(): number {
+    let index = this.lastKey;
+    const entity = this.getDataEntity(this.model.name.toLocaleLowerCase());
+    if (entity && this.model.prgDim > 1) {
+      index = Math.max(
+        0,
+        entity.modules.indexOf(
+          entity.modules.filter(e => e.prg[0] === this.getKeyArray()[0])[
+            this.lastKey
+          ]
+        )
+      );
+    }
+    return index;
+  }
+
+  /**
+   * Runs logic.calc for the current field, then applies any member refresh flags
+   * (state/value/message) marked by the logic layer in the active module.
+   */
+  private fieldBusiness(id: string, calc: boolean = true) {
+    let index = this.getIndex();
+    if (calc) {
+      this.logic.calc(id, index, this.getKeyArray());
+    }
+    const entity = this.getDataEntity(this.model.name.toLocaleLowerCase());
+    if (!entity?.modules?.length) return;
+    const modulefiltered = this.getFilteredModules(entity);
+    const currentModule = modulefiltered[this.lastKey];
+    if (!currentModule) return;
+    const membersToRefresh = currentModule.members.filter(m => m.refresh);
+    if (membersToRefresh?.length > 0) {
+      membersToRefresh.forEach(member => {
+        this.sS(member.name, member.state);
+        this.sV(member.name, member.value);
+        if (member.message && member.message !== '') {
+          this.gF(member.name).title = member.message;
+        }
+        member.refresh = false;
+        this.video()?.nativeElement?.load();
+        this.dataChanged(member);
+      });
+    }
+    this.dataChanged(currentModule.members.find(m => m.name === id)!);
+    this.updateState();
+  }
+
+  /**
+   * Returns true if the given member has unsaved changes (value or state differ from
+   * initial values), updating `this.save` as a side-effect.
+   */
+  private dataChanged(member: MemberData): boolean {
+    if (this.loaded) {
+      if (
+        ((member?.initialvalue !== null &&
+          member?.value !== member?.initialvalue) ||
+          member?.initialstate !== member?.state) &&
+        member.type !== FieldType.Label &&
+        member.type !== FieldType.Button &&
+        member.type !== FieldType.Video &&
+        member.type !== FieldType.Image &&
+        member.type !== FieldType.Map &&
+        member.type !== FieldType.Chart
+      ) {
+        this.save = false;
+      }
+    }
+    return !this.save;
+  }
+
+  /**
+   * Validates the current field value against the referenced lookup entity.
+   * On match, propagates output field values; on mismatch, sets Error state.
+   */
+  private async lookupCheck(
+    lkdata: ModuleData[],
+    field: Member,
+    input: string[],
+    output: string[],
+    extern: string[],
+    functionId: string
+  ) {
+    for (let i = 1; i < input.length; i++) {
+      if (
+        this.gS(output[i]) !== FieldState.Forced ||
+        this.gV(output[0]) === ''
+      ) {
+        this.sV(output[i], '');
+      } else {
+        if (this.gV(output[i])) {
+          output[i] = '';
+          input[i] = '';
+        }
+      }
+    }
+    if (field.value !== '' && lkdata) {
+      let elem = lkdata.find(item =>
+        item.members?.find(
+          e => e.name === input[0] && e.value === this.gV(field.id)
+        )
+      );
+      if (!elem) {
+        this.sS(field.id, FieldState.Error, this.msg.get('app.itemerror'));
+        for (let i = 0; i < input.length; i++) {
+          if (i > 0) {
+            this.sS(
+              output[i],
+              this.gF(output[i])?.lookupoutput
+                ? FieldState.ReadOnly
+                : this.gS(output[i]),
+              ''
+            );
+            const fld = this.entity?.members?.find(
+              item => item.id === output[i]
+            );
+            if (fld?.lookup !== '') {
+              this.fieldChanged({
+                id: fld?.id ?? '',
+                value: String(fld?.value ?? ''),
+                function: 'lookupCheck',
+              });
+            }
+          }
+        }
+      } else {
+        if (this.gS(field.id) === FieldState.Error) {
+          this.sS(field.id, FieldState.None);
+        }
+        for (let i = 0; i < input.length; i++) {
+          if (i === 0) {
+            for (let x = 0; x < extern.length; x++) {
+              const ext: string[] = extern[x].split(';');
+              if (ext[0] !== '') {
+                const extField = ext[1].substring(1).toString();
+                if (!this.gF(extField).readonly) {
+                  this.sS(field.id, FieldState.None);
+                }
+                const fldValue = this.gV(extField);
+                if (x < extern.length - 1) {
+                  lkdata = lkdata.filter(item =>
+                    item.members?.find(
+                      e => e.name === ext[0] && e.value === fldValue
+                    )
+                  );
+                  continue;
+                }
+                elem = lkdata.find(item =>
+                  item.members?.find(
+                    e => e.name === ext[0] && e.value === fldValue
+                  )
+                );
+                if (
+                  !elem ||
+                  elem.members
+                    ?.filter(e => e.name === input[0])[0]
+                    ?.value?.toString() !== String(field.value ?? '')
+                ) {
+                  this.sS(
+                    field.id,
+                    FieldState.Error,
+                    this.msg.get('app.itemerror')
+                  );
+                  return;
+                }
+              }
+            }
+          } else {
+            if (elem) {
+              const member = elem.members?.find(e => e.name === input[i]);
+              if (member?.value) {
+                if (
+                  !this.gV(output[i]) ||
+                  (this.gV(output[i]) &&
+                    this.gS(output[i]) !== this.fieldState.Forced)
+                ) {
+                  this.sV(output[i], member.value);
+                  if (functionId !== 'noBusiness') {
+                    this.fieldChanged({
+                      id: output[i],
+                      value: String(member.value ?? ''),
+                      function: '',
+                    });
+                  }
+                }
+              }
+              this.sS(
+                output[i],
+                this.gF(output[i])?.lookupoutput
+                  ? this.gS(output[i]) !== this.fieldState.Hidden
+                    ? this.fieldState.ReadOnly
+                    : this.fieldState.Hidden
+                  : this.gS(output[i])
+              );
+            }
+          }
+        }
+      }
+    } else {
+      for (let i = 0; i < input.length; i++) {
+        if (i > 0) {
+          // Output fields that serve as lookup outputs should always be ReadOnly:
+          // the user cannot type them directly — they auto-fill from the lookup popup.
+          if (this.gF(output[i])?.lookupoutput) {
+            this.sS(
+              output[i],
+              this.gS(output[i]) !== this.fieldState.Hidden
+                ? this.fieldState.ReadOnly
+                : this.fieldState.Hidden
+            );
+          }
+          const fld = this.entity?.members?.find(item => item.id === output[i]);
+          if (fld?.lookup !== '') {
+            this.fieldChanged({
+              id: fld?.id ?? '',
+              value: String(fld?.value ?? ''),
+              function: 'lookupCheck',
+            });
+          }
+        }
+      }
+    }
+  }
+
+  /** Schedules a select() call on the given field's DOM input element on the next tick. */
+  private setFocus(id: string) {
+    if (this.model && !this.model.cache) {
+      if (id && id !== '') {
+        const tm = setTimeout(() => {
+          const el = this.gE(id);
+          if (el) el.select();
+          clearTimeout(tm);
+        }, 100);
+      }
+    }
+  }
+
+  /** Resolves cached entity data or fetches from the API; calls backData when ready. */
+  private async getData(id: string) {
+    await new Promise<void>(r =>
+      requestAnimationFrame(() => requestAnimationFrame(() => r()))
+    );
+    if (!this.model.rootModel) {
+      this.fieldsId =
+        this.managment.appId +
+        '.' +
+        this.root.entities[0].name.toUpperCase() +
+        '.' +
+        this.managment.year;
+    }
+    const data = this.gsv.getData(this.fieldsId);
+    if (data && !this.model.preview && this.model.masterDetail === 0) {
+      this.insertMode = false;
+      await this.backDataFromCache(data);
+      this.loaded = true;
+      this.model.loaded = true;
+    } else {
+      await this.performGetData();
+    }
+  }
+
+  /** Performs a GET /managment read request and populates the component via backData. */
+  async performGetData(): Promise<void> {
+    this.managment.fields = [];
+    this.managment.functionId = 'read';
+    this.msv.getData(this.managment).pipe(takeUntilDestroyed(this.destroyRef)).subscribe({
+      next: async (data: TransportInterface) => {
+        this.insertMode = false;
+        await this.backData(data);
+        this.loaded = true;
+        this.model.loaded = true;
+      },
+      error: err => {
+        console.error('getData HTTP error:', err);
+      },
+    });
+  }
+
+  /** Broadcasts the current dialog state to the model shell (model.component). */
+  private sendDialog() {
+    this.gsv.setDialogField({
+      showdialog: this.showdialog,
+      titledialog: this.titledialog,
+      textdialog: this.textdialog,
+      showconfirm: this.showconfirm,
+      dialogHeight: this.dialogHeight,
+      dialogWidth: this.dialogWidth,
+      dialogTop: this.dialogTop,
+      dialogLeft: this.dialogLeft,
+    });
+  }
+
+  /** Broadcasts the current lookup panel state to the model shell (model.component). */
+  private sendLookup() {
+    this.gsv.setLookupField({
+      showlookup: this.showlookup,
+      titlelookup: this.titlelookup,
+      textlookup: this.textlookup,
+      lookupHeight: this.lookupHeight,
+      lookupWidth: this.lookupWidth,
+      lookupTop: this.lookupTop,
+      lookupLeft: this.lookupLeft,
+      lookup: this.lookup,
+      lookupfilter: this.lookupfilter,
+    });
+  }
+
+  /** Broadcasts the current toolbar command states to ModelToolbarComponent. */
+  private sendCommands() {
+    if (this.entity?.viewlist) {
+      // In list-view-only entities, disable all directional navigation.
+      this.updateNavButtons(0);
+    }
+    this.gsv.setItemCommands([
+      { id: 'exit', state: false },
+      { id: 'insertmode', state: this.insertMode },
+      { id: 'plus', state: this.bplus },
+      { id: 'minus', state: this.bminus },
+      { id: 'first', state: this.bfirst },
+      { id: 'previous', state: this.bprevious },
+      { id: 'next', state: this.bnext },
+      { id: 'last', state: this.blast },
+      { id: 'detail', state: this.bdetail },
+      { id: 'intodetail', state: this.bintodetail },
+      { id: 'download', state: this.bdownload },
+      { id: 'upload', state: this.bupload },
+      { id: 'print', state: this.bprint },
+      { id: 'table', state: this.btable },
+      { id: 'save', state: this.save },
+      { id: 'refreshgrid', state: this.refreshgrid },
+    ]);
+    const actionStates: [string, boolean][] = [
+      ['plus', this.bplus],
+      ['minus', this.bminus],
+      ['next', this.bnext],
+      ['previous', this.bprevious],
+      ['first', this.bfirst],
+      ['last', this.blast],
+      ['table', this.btable],
+      ['detail', this.bdetail],
+      ['download', this.bdownload],
+      ['upload', this.bupload],
+      ['save', this.save],
+    ];
+    for (const [name, state] of actionStates) {
+      if (this.gE('action_' + name)) {
+        this.gF('action_' + name).enabled = !state;
+      }
+    }
+  }
+
+  /** Resets all toolbar button states to their default (all disabled) values. */
+  private resetCommands() {
+    this.bplus = true;
+    this.bminus = true;
+    this.updateNavButtons(0);
+    this.bdetail = true;
+    this.bintodetail = true;
+    this.bdownload = true;
+    this.bupload = true;
+    this.bprint = this.viewList;
+    this.btable = true;
+    this.save = true;
+    this.refreshgrid = false;
+    this.sendCommands();
+  }
+
+  /**
+   * Parses the server response (JSON + SVG), instantiates the BASELogic layer,
+   * and triggers commandData('readed') to populate the first/last record.
+   */
+  private async backDataFromCache(cached: EntitiesData) {
+    this.data = cached;
+    await this.initLogicAndReady();
+  }
+
+  private async backData(data: TransportInterface) {
+    if (data.dataFile) {
+      this.data = JSON.parse(data.dataFile as string);
+      await this.initLogicAndReady();
+    }
+  }
+
+  private async initLogicAndReady() {
+    this.logic = await this.config.logicFactory(
+      this.gsv, this.msv, this.msg, this.managment.entId, this.data
+    );
+    this.lastKey = 0;
+    await this.logic.init();
+    await this.commandData('readed');
+  }
+
+  /** Left- or right-pads a string value with the given character up to the target size. */
+  private padding(
+    direction: PadType,
+    value: string,
+    char: string,
+    size: number
+  ): string {
+    let s = value.toString();
+    if (char.charCodeAt(0) !== 0 && s !== '' && s !== '0') {
+      while (s.length < size) {
+        if (direction === PadType.Right) {
+          s = s + char;
+        } else {
+          s = char + s;
+        }
+      }
+    }
+    return s;
+  }
+
+  /** Applies the field's match/replace regular expression to the DOM input and the Member value. */
+  private regExpression(id: string): boolean {
+    const element = this.gE(id);
+    if (element !== null) {
+      if (
+        element.getAttribute(FieldAttr.get('match')!) !== null &&
+        element.getAttribute(FieldAttr.get('replace')!) !== null
+      ) {
+        const rem = element.getAttribute(FieldAttr.get('match')!)!;
+        const rep = element.getAttribute(FieldAttr.get('replace')!)!;
+        if (rem !== '' && rep !== '') {
+          const regExp = new RegExp(rem);
+          this.gE(id).value = this.gV(id)
+            .toString()
+            .toUpperCase()
+            .replace(regExp, rep);
+          this.gF(id).value = this.gE(id).value;
+          const fld = this.gE(id).value;
+          const ret = this.gE(id).value.match(rem.toUpperCase());
+          return ret || fld.length === 0 ? true : false;
+        }
+      }
+    }
+    return true;
+  }
+
+  /** Pads or trims a field value based on padleftchar / padrightchar / autoformatter attributes. */
+  private PadSpacing(id: string) {
+    let value: string = this.gV(id);
+    if (value?.toString().length > 0) {
+      if (this.gE(id) && this.gF(id).padleftchar !== '') {
+        this.gE(id).value = this.padding(
+          PadType.Left,
+          this.gV(id),
+          this.gF(id).padleftchar,
+          this.gF(id).length ?? this.gF(id).precision ?? 0
+        );
+        this.gF(id).value = this.gE(id)!.value;
+      }
+      if (this.gE(id) && this.gF(id).padrightchar !== '') {
+        this.gE(id)!.value = this.padding(
+          PadType.Right,
+          this.gV(id),
+          this.gF(id).padrightchar,
+          this.gF(id).length ?? this.gF(id).precision ?? 0
+        );
+        this.gF(id).value = this.gE(id)!.value;
+      }
+      if (this.gF(id).autoformatter && this.gF(id).match === '') {
+        const spacing = ' ';
+        let ret = '';
+        if (this.gT(id) === FieldType.Date) {
+          this.gF(id).value = String(this.gF(id).value ?? '').replace(/\//g, ' ');
+        }
+        const strVal = String(this.gF(id).value ?? '');
+        for (let i = 0; i < strVal.length; i++) {
+          if (i > 0) {
+            ret += spacing.repeat(this.gF(id).spacing ?? 1);
+          }
+          ret += strVal[i];
+        }
+        this.gE(id).value = ret;
+        this.gF(id).value = this.gE(id).value;
+      }
+    }
+  }
+
+  /** Initialises the component from the given ItemInterface (model config). */
+  private initItem(model: ItemInterface) {
+    this.model = model;
+    if (model.svg !== null && model.svg !== '') {
+      this.svg = this.gsv.sanitizeurl(
+        'assets/svg/' +
+          this.gsv.getProject().year +
+          '/' +
+          this.gsv.getProject().project +
+          '/' +
+          model.svg +
+          '.svg'
+      );
+    }
+    this.managment.appId = this.gsv.getProject().project;
+    this.managment.year = this.gsv.getYear();
+    this.managment.entId = this.model.name;
+    this.managment.keyId = this.gsv.getKeyId();
+    this.managment.name = model.title;
+    for (let i = 0; i < model.prgDim; i++) {
+      if (this.managment.keys !== '') {
+        this.managment.keys += ';';
+      }
+      if (i === 0 && this.gsv.getCurrentLinkItem().groupName !== '') {
+        this.managment.keys += 'prg=' + this.gsv.getCurrentLinkItem().prg[0];
+      } else {
+        this.managment.keys += 'prg=1';
+      }
+    }
+
+    this.fieldsId =
+      this.managment.appId +
+      '.' +
+      this.managment.entId +
+      '.' +
+      this.managment.year;
+
+    this.insertMode = true;
+
+    this.root = this.gsv.getSchemaJson(
+      this.managment.appId + '.' + this.managment.year
+    );
+
+    this.entity = this.root.entities.find(
+      e => e.name == this.managment.entId.toLocaleLowerCase()
+    )!;
+    this._memberMap = null;
+
+    this.setViewList(this.entity.viewlist);
+
+    if (this.gsv.getCurrentKeys().length > 0) {
+      this.managment.keys = this.gsv.getCurrentKeys();
+      this.gsv.setCurrentKeys('');
+    }
+
+    this.closing = false;
+  }
+
+  /**
+   * Handles the main toolbar command dispatch (exit, save, plus, minus, table, print,
+   * go:<keys>, etc.) and updates entity state after each operation.
+   */
+  public async sendCommand(command: ItemCommandInterface) {
+    if (command.id === 'exit') {
+      // Check for a saved intodetail state BEFORE navigating, so we can
+      // decide the correct destination and avoid a spurious intermediate navigation.
+      let restoredManagment: ManagmentInterface | null = null;
+      let managmentKey: string | null = null;
+
+      if (localStorage.length > 0) {
+        const allKeys: string[] = [];
+        for (let i = 0; i < localStorage.length; i++) {
+          const key = localStorage.key(i);
+          if (key && /^\d+\./.test(key)) {
+            allKeys.push(key);
+          }
+        }
+        // Sort descending by numeric prefix so [0] is the most-recently saved
+        // intodetail entry (LIFO order: last pushed = first to pop on exit).
+        allKeys.sort((a, b) => parseInt(b, 10) - parseInt(a, 10));
+        managmentKey = allKeys[0] ?? null;
+
+        if (managmentKey && localStorage.getItem(managmentKey) !== null) {
+          const storedValue = localStorage.getItem(managmentKey);
+          restoredManagment = JSON.parse(storedValue!);
+        }
+      }
+
+      await this.close();
+
+      if (restoredManagment !== null && restoredManagment.appId) {
+        // --- Back navigation: return to the component that launched intodetail ---
+        localStorage.removeItem(managmentKey!);
+
+        if (restoredManagment?.keyId?.length === 36) {
+          localStorage.setItem('search', restoredManagment?.keyId);
+        }
+        const originKey =
+          restoredManagment?.appId +
+          '.' +
+          restoredManagment?.year +
+          '.' +
+          restoredManagment?.entId +
+          '.' +
+          restoredManagment.currentFieldId +
+          '.' +
+          restoredManagment.keys;
+        localStorage.setItem('origin', originKey);
+
+        localStorage.setItem(
+          'targetModel',
+          restoredManagment?.entId?.toUpperCase()
+        );
+
+        // Await navigation so that NavigationComponent is fully mounted and
+        // subscribed to projectChanged before we fire activateProject.
+        // This mirrors the same pattern used in handleIntoDetail (forward direction).
+        await this.gsv.navigate('/home');
+
+        const projectName = this.gsv
+          .getProjects()
+          [
+            this.gsv.getYear()
+          ]?.find(e => e.project === restoredManagment?.appId?.toUpperCase());
+
+        if (projectName) {
+          this.gsv.activateProject(projectName);
+        } else {
+          console.error(
+            'Project not found for appId:',
+            restoredManagment?.appId
+          );
+        }
+      } else {
+        // --- Normal exit: no saved intodetail state ---
+        if (
+          this.gsv.getProject().type === 'D' ||
+          this.gsv.getProject().type === 'G'
+        ) {
+          this.gsv.setActiveLink('/home/modelsearch');
+          this.gsv.navigate('/home/modelsearch');
+        } else {
+          this.gsv.setActiveLink('/home/dashboard');
+          this.gsv.navigate('/home/dashboard');
+        }
+      }
+      return;
+    } else if (command.id === 'print') {
+      if (!this.viewList) {
+        this.logic.function(
+          'save',
+          this.lastKey,
+          this.getKeyArray(),
+          this.currentFieldId
+        );
+        this.commandData('print');
+        return;
+      } else {
+        this.sendCommand({ id: 'print', state: false });
+      }
+    } else if (command.id === 'table') {
+      if (this.gS(this.currentFieldId) !== FieldState.Fatal) {
+        const json = this.getJsonData();
+        await this.throwSave(json).then(async e => {
+          await this.commandData(command.id).then(e => {
+            this.resetCommands();
+            this.bplus = !this.model.allowAdd;
+            this.bprint = false;
+            this.refreshData(true);
+          });
+        });
+      }
+    } else if (command.id === 'save') {
+      this.logic.function(
+        command.id,
+        this.lastKey,
+        this.getKeyArray(),
+        this.currentFieldId
+      );
+      const json = this.getJsonData();
+      await this.throwSave(json).then(async e => {
+        await this.commandData('readed');
+      });
+    } else if (command.id === 'minus') {
+      this.checkConstraint().then(ret => {
+        if (ret) {
+          this.logic.function(
+            command.id,
+            this.lastKey,
+            this.getKeyArray(),
+            this.currentFieldId
+          );
+          this.commandData(command.id);
+        } else {
+          this.showMessage(this.msg.get('app.unabletodelete'));
+          this.setFocus(this.currentFieldId);
+        }
+      });
+    } else if (command.id === 'detail') {
+      this.commandsResult({});
+    } else if (command.id === 'intodetail') {
+      // Defer heavy operations to avoid blocking main thread
+      Promise.resolve()
+        .then(() => this.handleIntoDetail())
+        .catch(error => {
+          console.error('Error in intodetail command:', error);
+          this.showMessage("Errore durante l'accesso al dettaglio");
+        });
+      return;
+    } else {
+      if (command.id.startsWith('go:')) {
+        this.managment.keys = '';
+        const keys: string[] = command.id.substring(3).split(';');
+        // tslint:disable-next-line:prefer-for-of
+        for (let i = 0; i < keys.length; i++) {
+          if (this.managment.keys !== '') {
+            this.managment.keys += ';';
+          }
+          this.managment.keys += 'prg=' + keys[i];
+        }
+        command.id = 'table';
+        this.setLastKey(this.getLastKey());
+      }
+      if (!this.insertMode) {
+        if (command.id === 'table') {
+          this.checkKey(this.model.focusOnInsert);
+        }
+        await this.commandData(command.id);
+      }
+    }
+    if (command.id === 'plus') {
+      this.gsv.setExtendedDescription('');
+    }
+  }
+
+  /** Toggles the viewList flag and updates related navigation button states. */
+  private setViewList(state: boolean) {
+    this.viewList = state;
+  }
+
+  /**
+   * Handles the "intodetail" toolbar action: persists the current managment context
+   * to localStorage, navigates to the home route, and activates the target project.
+   */
+  private async handleIntoDetail() {
+    const progressState =
+      this.managment.year +
+      '.' +
+      this.managment.appId +
+      '.' +
+      this.managment.entId +
+      '.' +
+      this.model.title;
+
+    if (localStorage.getItem(progressState) !== null) {
+      localStorage.removeItem(progressState);
+    }
+
+    this.managment.currentFieldId = this.currentFieldId;
+    const fieldLookup = this.gF(this.currentFieldId).lookup;
+
+    if (!fieldLookup || !fieldLookup.includes('#')) {
+      console.error('Invalid fieldLookup format:', fieldLookup);
+      this.showMessage('Errore: configurazione campo non valida');
+      return;
+    }
+
+    const parts = fieldLookup.split('#');
+
+    localStorage.setItem(
+      localStorage.length + '.' + progressState,
+      JSON.stringify(this.managment)
+    );
+
+    const originKey =
+      parts[0].toUpperCase() +
+      '.' +
+      parts[1].toUpperCase() +
+      '.' +
+      parts[2].toUpperCase();
+
+    localStorage.setItem('origin', originKey);
+
+    // Save target model name for navigation component to load it after project activation
+    const modelName = parts[2].toUpperCase();
+    localStorage.setItem('targetModel', modelName);
+
+    await this.gsv.navigate('/home');
+
+    const projectYear = this.gsv.getYear();
+    const projects = this.gsv.getProjects()[projectYear];
+    const projectName = parts[0].toUpperCase();
+
+    const project = projects?.find(e => e.project === projectName);
+
+    if (!project) {
+      console.error('Project not found:', projectName);
+      console.error('Available projects:', projects);
+      this.showMessage('Errore: progetto non trovato');
+      return;
+    }
+
+    this.gsv.activateProject(project);
+    this.resetCommands();
+  }
+
+  /** Iterates all project items and recomputes each entity's aggregated Error/Warning/Valid state. */
+  private updateState() {
+    if (this.data) {
+      const projectId =
+        this.gsv.getProject().project + '.' + this.gsv.getYear();
+      this.gsv.getProjectItems(projectId).forEach(item => {
+        // Only update state for entities owned by this component's data.
+        // Other components manage their own entities; overwriting their states
+        // here would reset Error/Warning badges set by a sibling component.
+        const entityName = item.name.toLocaleLowerCase();
+        if (this.data.entities.find(e => e.name === entityName)) {
+          item.state = this.updateEntityState(entityName);
+        }
+      });
+      this.gsv.emitItemState();
+    }
+  }
+
+  /** Returns the aggregated ItemState (Error / Warning / Valid / Empty) for the given entity name. */
+  updateEntityState(name: string): ItemState {
+    const p1 = this.data.entities.find(m => m.name === name);
+    if (p1) {
+      let state = p1.modules.filter(e =>
+        e.members?.find(m => m.state === ItemState.Error)
+      );
+      if (state.length > 0) {
+        return ItemState.Error;
+      } else {
+        state = p1.modules.filter(e =>
+          e.members?.find(m => m.state === ItemState.Warning)
+        );
+        if (state.length > 0) {
+          return ItemState.Warning;
+        } else {
+          return ItemState.Valid;
+        }
+      }
+    }
+    return ItemState.Empty;
+  }
+
+  /** Handles a button-type field click: delegates to sendCommand or fires a logic click_ function. */
+  public buttonClick(field: string, action: string) {
+    this.setFocus(this.currentFieldId);
+    if (action !== LabelAction.Field.toLocaleString()) {
+      if (this.gE('action_' + action) && this.gF('action_' + action).enabled) {
+        this.sendCommand({ id: action.toLocaleLowerCase(), state: true });
+      }
+    } else {
+      this.logic.function(
+        'click_' + field,
+        this.lastKey,
+        this.getKeyArray(),
+        this.currentFieldId
+      );
+    }
+  }
+
+  /** TrackBy function for the entity member field loop. Returns the field name or index. */
+  public trackByField(index: number, field: Member): string {
+    return field.name || index.toString();
+  }
+
+  /** Returns the ngClass map for standard input/select fields (Combo, Date, Number, Text, TextualCheck). */
+  tooltipClass(field: Member): string {
+    switch (field?.state) {
+      case this.fieldState.Error:
+        return 'tooltip-error';
+      case this.fieldState.Fatal:
+        return 'tooltip-fatal';
+      case this.fieldState.Warning:
+        return 'tooltip-warning';
+      default:
+        return '';
+    }
+  }
+
+  fieldClasses(field: Member): Record<string, boolean> {
+    const hasSvg = this.entity.svg.length > 0;
+    return {
+      field: !hasSvg,
+      'field-mod': hasSvg,
+      'text-right': field.alignment === 'right',
+      'text-left': field.alignment === 'left',
+      'text-center': field.alignment === 'center',
+      'has-error': field?.state === this.fieldState.Error,
+      'has-fatal': field?.state === this.fieldState.Fatal,
+      'has-warning': field?.state === this.fieldState.Warning,
+      'has-readonly':
+        ((field?.state === this.fieldState.ReadOnly || !field.enabled) &&
+        field?.state !== this.fieldState.Error &&
+        field?.state !== this.fieldState.Warning) ||
+        this._readonlySet.has(field.id),
+      'has-detail': field?.state === this.fieldState.Detail,
+      'has-forced': field?.state === this.fieldState.Forced,
+      'has-hidden': field?.state === this.fieldState.Hidden,
+    };
+  }
+
+  /** Returns the ngClass map for Label fields. */
+  labelClasses(field: Member): Record<string, boolean> {
+    return {
+      label: this.entity.svg.length > 0,
+      'text-right': field.alignment === 'right',
+      'text-left': field.alignment === 'left',
+      'text-center': field.alignment === 'center',
+      'has-error': field?.state === this.fieldState.Error,
+      'has-fatal': field?.state === this.fieldState.Fatal,
+      'has-warning': field?.state === this.fieldState.Warning,
+      'has-readonly':
+        ((field?.state === this.fieldState.ReadOnly || !field.enabled) &&
+        field?.state !== this.fieldState.Error &&
+        field?.state !== this.fieldState.Warning) ||
+        this._readonlySet.has(field.id),
+      'has-detail': field?.state === this.fieldState.Detail,
+      'has-forced': field?.state === this.fieldState.Forced,
+      'has-hidden': field?.state === this.fieldState.Hidden,
+    };
+  }
+
+  /** Returns the ngClass map for Button fields. */
+  buttonClasses(field: Member): Record<string, boolean> {
+    return {
+      label: this.entity.svg.length > 0,
+      btn: true,
+      'bg-primary': field.id === 'action_exit',
+      'bg-secondary': field.id !== 'action_exit',
+      'bg-success': field.id === 'action_save',
+      'text-white': true,
+      'text-right': field.alignment === 'right',
+      'text-left': field.alignment === 'left',
+      'text-center': field.alignment === 'center',
+      'has-error': field?.state === this.fieldState.Error,
+      'has-fatal': field?.state === this.fieldState.Fatal,
+      'has-warning': field?.state === this.fieldState.Warning,
+      'has-readonly':
+        ((field?.state === this.fieldState.ReadOnly || !field.enabled) &&
+        field?.state !== this.fieldState.Error &&
+        field?.state !== this.fieldState.Warning) ||
+        this._readonlySet.has(field.id),
+      'has-detail': field?.state === this.fieldState.Detail,
+      'has-forced': field?.state === this.fieldState.Forced,
+      'has-hidden': field?.state === this.fieldState.Hidden,
+    };
+  }
+
+  /** TrackBy function for combo option lists. Returns the item string or its index. */
+  public trackByCombo(index: number, item: string): string {
+    return item || index.toString();
+  }
+
+  /** Parses a CSS pixel width string and returns the numeric value. */
+  public parseWidth(width: string): number {
+    return parseInt(width.replace('px', ''), 10);
+  }
+}