newportsite 1.1.3

package/src/lib/services/global.service.ts

@@ -0,0 +1,724 @@
+import { Injectable, inject, signal } from '@angular/core';
+import { Location } from '@angular/common';
+import { Router } from '@angular/router';
+import { HttpHeaders } from '@angular/common/http';
+import { User } from '../auth/models/index';
+import { Subject, Observable } from 'rxjs';
+import { NEWPORT_CONFIG } from '../config';
+import { AuthStateService } from './auth-state.service';
+import { CacheService } from './cache.service';
+
+import {
+  ItemInterface,
+  ItemFieldChangedInterface,
+  ItemLinkInterface,
+  UserLicenses,
+  ItemCommandInterface,
+  ItemDialogInterface,
+  ItemCurrentFocusInterface,
+  ViewListInterface,
+  ManagmentInterface,
+  LookupFieldInterface,
+  DialogFieldInterface,
+  EntitiesData,
+  Entities,
+  Member,
+  SchedulerInterface,
+} from '../interfaces/index';
+
+export enum Languages {
+  IT = 'IT',
+  EN = 'EN',
+}
+
+@Injectable({ providedIn: 'root' })
+export class GlobalService {
+  private router = inject(Router);
+  private location = inject(Location);
+  private authState = inject(AuthStateService);
+  private cache = inject(CacheService);
+  private config = inject(NEWPORT_CONFIG);
+
+  private loaderSubject = new Subject<boolean>();
+  private loadedSubject = new Subject<boolean>();
+  private modelSubject = new Subject<ItemInterface>();
+  private commandsSubject = new Subject<ItemCommandInterface[]>();
+  private currentFieldSubject = new Subject<Member>();
+  private fieldChangedSubject = new Subject<ItemFieldChangedInterface>();
+  private lookupSubject = new Subject<ViewListInterface>();
+  private projectChangedSubject = new Subject<string>(); // NEW: Project changed
+  private stateChangedSubject = new Subject<void>(); // language or year changed
+  private lookupFieldSubject = new Subject<LookupFieldInterface>();
+  private dialogFieldSubject = new Subject<DialogFieldInterface>();
+  private gridRefreshSubject = new Subject<void>();
+  private itemStateSubject = new Subject<void>();
+  private readonly _isLoading = signal(false);
+  private readonly _isModalActive = signal(false);
+  private modalActiveSubject = new Subject<boolean>();
+  private isDialog: ItemDialogInterface | null = null;
+  private currentFocus: ItemCurrentFocusInterface = { id: '', value: '' };
+  private currentKeys: string = '';
+  private active = '/auth/login';
+  private lng = '';
+  private years!: number[];
+  private year!: number;
+  private projects!: UserLicenses[][];
+  private project!: UserLicenses;
+  private decimalChar = ',';
+  private thousandChar = '.';
+  private keyId = '';
+
+  private inactivityTime: number = 0;
+  private sessionTime: number = 0;
+
+  private currentLinkItem!: ItemLinkInterface;
+
+  private extendedDescription = '';
+  private scale: number = 1;
+
+  private view: string = 'Dashboard';
+
+  constructor() {
+    this.lng = Languages.IT;
+    this.sessionTime = new Date().getTime();
+    this.inactivityTime = new Date().getTime();
+    this.logOff();
+  }
+
+  /** Normalizes a URL using Angular Location, ensuring correct hash routing. */
+  public sanitizeurl(url: string) {
+    return this.location.normalize(url);
+  }
+
+  /** Navigates to the given URL and updates the active link tracker. */
+  public navigate(url: string) {
+    this.setActiveLink(url);
+    return this.router.navigateByUrl(this.location.normalize(url));
+  }
+
+  /** Clears user session, resets dialog/focus state and redirects to login. */
+  public logOff(): void {
+    this.setCurrentUser(null);
+    this.isDialog = { target: '', state: false };
+    this.currentFocus = { id: '', value: '' };
+    this.view = 'Dashboard';
+    this.setView(this.view);
+    this.navigate('auth/login');
+  }
+
+  /** Redirects to the default login page. */
+  public navigateToDefault() {
+    this.navigate('/auth/login');
+  }
+
+  /** Returns true if a valid, non-expired user session is present in localStorage. */
+  public isLogged(): boolean {
+    return this.authState.isLogged();
+  }
+
+  /** Sets the currently active route URL and returns it. */
+  public setActiveLink(url: string) {
+    this.active = url;
+    return this.active;
+  }
+
+  /** Returns the currently active route URL. */
+  public getActiveLink(): string {
+    return this.active;
+  }
+
+  /** Reads and parses the current user from localStorage. Returns null on failure. */
+  public getCurrentUser(): User | null {
+    return this.authState.getCurrentUser();
+  }
+
+  /** Persists the current user to localStorage, or removes it if null. */
+  public setCurrentUser(currentUser: User | null): void {
+    this.authState.setCurrentUser(currentUser);
+  }
+
+  /** Builds the HTTP options object containing the JWT Authorization header. */
+  public jwt(): { headers: HttpHeaders };
+  public jwt(fileType: string): { headers: HttpHeaders; reportProgress: boolean; responseType: 'blob' };
+  public jwt(fileType?: string): { headers: HttpHeaders; reportProgress?: boolean; responseType?: 'blob' } {
+    return fileType ? this.authState.jwt(fileType) : this.authState.jwt();
+  }
+
+  /** Constructs HttpHeaders with Content-Type and the Bearer token (if logged in). */
+  public getHeaders(user: User | null): HttpHeaders {
+    return this.authState.getHeaders(user);
+  }
+
+  /** Returns the display name of the currently logged-in user, or an empty string. */
+  public loggedUser(): string {
+    return this.authState.loggedUser();
+  }
+
+  /** Returns the base API URL from the current environment configuration. */
+  public restService(): string {
+    return this.config.apiUrl;
+  }
+
+  /** Navigates to the view associated with the given view name (Dashboard, Calendar, etc.). */
+  public setView(view: string): void {
+    this.view = view;
+    if (view === 'Calendario' || view === 'Calendar') {
+      this.navigate('/scheduler');
+    } else if (view === 'Dashboard') {
+      this.navigate('/home');
+    } else if (view === 'Informazioni' || view === 'Information') {
+      this.navigate('/home/info');
+    }
+  }
+
+  /** Returns the current view name. */
+  public getView() {
+    return this.view;
+  }
+
+  /** Sets the application language, updates decimal/thousand separators and notifies subscribers. */
+  public setLng(lng: string) {
+    if (lng === Languages.IT) {
+      this.setDecimalChar(',');
+      this.setThousandChar('.');
+    } else if (lng === Languages.EN) {
+      this.setDecimalChar('.');
+      this.setThousandChar(',');
+    }
+    this.lng = lng;
+    // Clear cached project items so navigation reloads with new language
+    this.cache.clearProjectItems();
+    this.stateChangedSubject.next();
+    // Fire projectChanged so NavigationComponent reinitializes
+    if (this.project) {
+      this.projectChangedSubject.next(this.project.project + '.' + this.year);
+    }
+  }
+
+  /** Returns the active locale code ('IT' or 'EN'). */
+  public getLng() {
+    return this.lng;
+  }
+
+  /** Sets the active project; fires projectChangedSubject when the project changes. */
+  public setProject(project: UserLicenses | null): void {
+    const previousProject = this.project?.project;
+    this.project = project!;
+    const newProject = project?.project + '.' + project?.year;
+    if (previousProject !== project?.project) {
+      this.projectChangedSubject.next(newProject);
+    }
+  }
+
+  /** Returns the currently active project license. */
+  public getProject(): UserLicenses {
+    return this.project;
+  }
+
+  /** Stores the full matrix of available project licenses. */
+  public setProjects(projects: UserLicenses[][]) {
+    this.projects = projects;
+  }
+
+  /** Returns the full matrix of available project licenses. */
+  public getProjects(): UserLicenses[][] {
+    return this.projects;
+  }
+
+  /** Stores the list of available fiscal years. */
+  public setYears(years: number[]) {
+    this.years = years;
+  }
+
+  /** Returns the list of available fiscal years. */
+  public getYears(): number[] {
+    return this.years;
+  }
+
+  /** Sets the active fiscal year, clears item cache and notifies subscribers. */
+  public setYear(year: number) {
+    this.year = year;
+    // Clear cached items for new year; fire projectChanged to reload navigation
+    this.cache.clearProjectItems();
+    this.stateChangedSubject.next();
+    if (this.project) {
+      this.projectChangedSubject.next(this.project.project + '.' + year);
+    }
+  }
+
+  /** Returns the active fiscal year. */
+  public getYear(): number {
+    return this.year;
+  }
+
+  /** Sets the primary key identifier used for record navigation. */
+  public setKeyId(keyId: string) {
+    this.keyId = keyId;
+  }
+
+  /** Returns the primary key identifier used for record navigation. */
+  public getKeyId(): string {
+    return this.keyId;
+  }
+
+  /** Emits a field-focus change event to all CurrentField subscribers. */
+  public setCurrentField(field: Member) {
+    this.currentFieldSubject.next(field);
+  }
+
+  /** Returns an Observable that emits whenever the focused field changes. */
+  public getCurrentField(): Observable<Member> {
+    return this.currentFieldSubject.asObservable();
+  }
+
+  /** Completes the CurrentField subject (called on teardown). */
+  public completeCurrentField() {
+    this.currentFieldSubject.complete();
+  }
+
+  /** Emits a field-value/state change event to all FieldChanged subscribers. */
+  public setFieldChanged(field: ItemFieldChangedInterface) {
+    this.fieldChangedSubject.next(field);
+  }
+
+  /** Returns an Observable that emits on every field value or state change. */
+  public getFieldChanged(): Observable<ItemFieldChangedInterface> {
+    return this.fieldChangedSubject.asObservable();
+  }
+
+  /** Completes the FieldChanged subject (called on teardown). */
+  public completeFieldChanged() {
+    this.fieldChangedSubject.complete();
+  }
+
+  /** Emits the newly selected model item, or signals deselection when undefined. */
+  public setCurrentItem(model: ItemInterface | undefined): void {
+    if (model) {
+      this.modelSubject.next(model);
+    }
+  }
+
+  /** Returns an Observable that emits the currently selected model item. */
+  public getCurrentItem(): Observable<ItemInterface> {
+    return this.modelSubject.asObservable();
+  }
+
+  /** Completes the CurrentItem subject (called on teardown). */
+  public completeCurrentItem() {
+    this.modelSubject.complete();
+  }
+
+  /** Signals the grid to refresh its data (e.g. after a record mutation). */
+  public emitGridRefresh(): void {
+    this.gridRefreshSubject.next();
+  }
+
+  /** Returns an Observable that emits a void signal on each grid refresh request. */
+  public getGridRefresh(): Observable<void> {
+    return this.gridRefreshSubject.asObservable();
+  }
+
+  /** Signals that item validation states (ItemState) have been updated by updateState(). */
+  public emitItemState(): void {
+    this.itemStateSubject.next();
+  }
+
+  /** Returns an Observable that emits whenever item states are recalculated. */
+  public getItemState(): Observable<void> {
+    return this.itemStateSubject.asObservable();
+  }
+
+  /** Returns an Observable that emits the new project key ('APP.YEAR') on project change. */
+  public getProjectChanged(): Observable<string> {
+    return this.projectChangedSubject.asObservable();
+  }
+
+  /** Returns an Observable that emits when the locale or fiscal year changes. */
+  public getStateChanged(): Observable<void> {
+    return this.stateChangedSubject.asObservable();
+  }
+
+  /** Shows or hides the global loader overlay; also updates the loading signal. */
+  public setLoaderState(state: boolean) {
+    this.loaderSubject.next(state);
+    this.setLoading(state);
+  }
+
+  /** Returns an Observable that emits whenever the loader visibility changes. */
+  public getLoaderState(): Observable<boolean> {
+    return this.loaderSubject.asObservable();
+  }
+
+  /** Updates the reactive loading signal directly (without emitting the subject). */
+  public setLoading(loading: boolean) {
+    this._isLoading.set(loading);
+  }
+
+  /** Returns the current loading state synchronously via the signal. */
+  public getLoading(): boolean {
+    return this._isLoading();
+  }
+
+  /** Marks a modal (dialog or lookup) as active/inactive; updates signal and emits event. */
+  public setModalActive(active: boolean) {
+    this._isModalActive.set(active);
+    this.modalActiveSubject.next(active);
+  }
+
+  /** Returns whether a modal overlay is currently active (synchronous signal). */
+  public getModalActive(): boolean {
+    return this._isModalActive();
+  }
+
+  /** Returns an Observable that emits on every modal active/inactive transition. */
+  public getModalActiveChanges(): Observable<boolean> {
+    return this.modalActiveSubject.asObservable();
+  }
+
+  /** Emits a loaded-state event (used by components that need to know data is ready). */
+  public setLoadedState(state: boolean) {
+    this.loadedSubject.next(state);
+  }
+
+  /** Returns an Observable that emits when the loaded state changes. */
+  public getLoadedState(): Observable<boolean> {
+    return this.loadedSubject.asObservable();
+  }
+
+  /** Completes the loader subject (called on teardown). */
+  public completeLoaderState() {
+    this.loaderSubject.complete();
+  }
+
+  /** Emits the updated toolbar command-state array to all toolbar subscribers. */
+  public setItemCommands(commands: ItemCommandInterface[]) {
+    this.commandsSubject.next(commands);
+  }
+
+  /** Returns an Observable that emits the command-state array on each toolbar update. */
+  public getItemCommands(): Observable<ItemCommandInterface[]> {
+    return this.commandsSubject.asObservable();
+  }
+
+  /** Completes the commands subject (called on teardown). */
+  public completeItemCommands() {
+    this.commandsSubject.complete();
+  }
+
+  /** Emits a lookup-result event (selected row from lookup popup). */
+  public setLookup(lookup: ViewListInterface) {
+    this.lookupSubject.next(lookup);
+  }
+
+  /** Returns an Observable that emits when a lookup row is selected. */
+  public getLookup(): Observable<ViewListInterface> {
+    return this.lookupSubject.asObservable();
+  }
+
+  /** Completes the lookup subject (called on teardown). */
+  public completeLookup() {
+    this.lookupSubject.complete();
+  }
+
+  /** Broadcasts lookup-panel display state (visibility, size, position, data) to listeners. */
+  public setLookupField(lookup: LookupFieldInterface) {
+    this.lookupFieldSubject.next(lookup);
+  }
+
+  /** Returns an Observable that emits whenever the lookup panel state changes. */
+  public getLookupField(): Observable<LookupFieldInterface> {
+    return this.lookupFieldSubject.asObservable();
+  }
+
+  /** Broadcasts dialog-panel display state (visibility, size, position, message) to listeners. */
+  public setDialogField(dialog: DialogFieldInterface) {
+    this.dialogFieldSubject.next(dialog);
+  }
+
+  /** Returns an Observable that emits whenever the dialog panel state changes. */
+  public getDialogField(): Observable<DialogFieldInterface> {
+    return this.dialogFieldSubject.asObservable();
+  }
+
+  /** Completes the lookupField subject (called on teardown). */
+  public completeLookupField() {
+    this.lookupFieldSubject.complete();
+  }
+
+  /** Sets the decimal separator character for the active locale. */
+  public setDecimalChar(char: string) {
+    this.decimalChar = char;
+  }
+
+  /** Returns the decimal separator character for the active locale. */
+  public getDecimalChar() {
+    return this.decimalChar;
+  }
+
+  /** Sets the thousands-separator character for the active locale. */
+  public setThousandChar(char: string) {
+    this.thousandChar = char;
+  }
+
+  /** Returns the thousands-separator character for the active locale. */
+  public getThousandChar() {
+    return this.thousandChar;
+  }
+
+  /** Sets the dialog interaction state (target field, open/closed). */
+  public setDialog(dialog: ItemDialogInterface | null) {
+    this.isDialog = dialog;
+  }
+
+  /** Returns the current dialog interaction state, or null if no dialog is open. */
+  public getDialog(): ItemDialogInterface | null {
+    return this.isDialog;
+  }
+
+  /** Stores the field that should receive focus after the current interaction completes. */
+  public setCurrentFocus(currentFocus: ItemCurrentFocusInterface) {
+    this.currentFocus = currentFocus;
+  }
+
+  /** Returns the field scheduled to receive focus next. */
+  public getCurrentFocus() {
+    return this.currentFocus;
+  }
+
+  /** Stores the composite key string used to restore record position. */
+  public setCurrentKeys(currentKeys: string) {
+    this.currentKeys = currentKeys;
+  }
+
+  /** Returns the composite key string used to restore record position. */
+  public getCurrentKeys() {
+    return this.currentKeys;
+  }
+
+  /** Opens an external URL in the same window without leaving a history entry in the SPA router. */
+  public externalnavigate(url: string) {
+    window.location.href = url;
+    window.history.pushState('', '', '');
+  }
+
+  /** Retrieves the cached entity data for the given composite key (APP.ENT.YEAR). */
+  public getData(id: string): EntitiesData | undefined {
+    return this.cache.getData(id);
+  }
+
+  /** Stores entity data in the in-memory cache under the given composite key. */
+  public setData(id: string, data: EntitiesData) {
+    this.cache.setData(id, data);
+  }
+
+  /** Removes the cached entity data for the given composite key. */
+  public removeData(id: string) {
+    this.cache.removeData(id);
+  }
+
+  /** Returns the cached schema field definitions for the given entity key. */
+  public getFields(id: string): Member[] {
+    return this.cache.getFields(id);
+  }
+
+  /** Stores schema field definitions in the cache under the given entity key. */
+  public setFields(id: string, fields: Member[]) {
+    this.cache.setFields(id, fields);
+  }
+
+  /** Returns the cached navigation item list for the given project key (APP.YEAR). */
+  public getProjectItems(id: string) {
+    return this.cache.getProjectItems(id);
+  }
+
+  /** Stores the navigation item list in the cache for the given project key. */
+  public setProjectItems(id: string, projectItems: ItemInterface[]) {
+    this.cache.setProjectItems(id, projectItems);
+  }
+
+  /** Stores the link context of the currently navigated record for cross-entity navigation. */
+  public setCurrentLinkItem(item: ItemLinkInterface) {
+    this.currentLinkItem = item;
+  }
+
+  /** Returns the link context of the currently navigated record. */
+  public getCurrentLinkItem(): ItemLinkInterface {
+    return this.currentLinkItem;
+  }
+
+  /** Sorts an array by a dot-notation property path (e.g. 'address.city'). */
+  public sortArray<T>(p: string, array: T[]) {
+    const property: string[] = p.split('.');
+    const l: number = property.length;
+    return array.sort((a: T, b: T) => {
+      let va: any = a;
+      let vb: any = b;
+      let i = 0;
+      while (i < l) {
+        va = va[property[i]];
+        vb = vb[property[i]];
+        i++;
+      }
+      return va < vb ? -1 : 1;
+    });
+  }
+
+  /** Left-pads a number with zeros to reach the given total length. */
+  public padNumber(num: number, size: number): string {
+    let s = num + '';
+    while (s.length < size) {
+      s = '0' + s;
+    }
+    return s;
+  }
+
+  /** Normalizes a [dd, mm, yyyy] array into a zero-padded 'dd/mm/yyyy' string. */
+  public normalizeDate(dt: string[]): string {
+    const dd: string = dt[0];
+    const mm: string = dt[1];
+    const yyyy: string = dt[2];
+    return (
+      this.padNumber(parseInt(dd, 10), 2) +
+      '/' +
+      this.padNumber(parseInt(mm, 10), 2) +
+      '/' +
+      yyyy
+    );
+  }
+
+  /** Builds a sortable composite key string by zero-padding each key segment to 7 digits. */
+  public getKey(keys: string[]): string {
+    let retValue = '';
+    for (const key of keys) {
+      retValue += this.padNumber(parseInt(key, 10), 7);
+    }
+    return retValue;
+  }
+
+  /** Sets the extended description shown in the model title bar. */
+  public setExtendedDescription(description: string) {
+    this.extendedDescription = description;
+  }
+
+  /** Returns the extended description currently shown in the model title bar. */
+  public getExtendedDescription(): string {
+    return this.extendedDescription;
+  }
+
+  /** Sets the total render scale factor (SVG + form combined). */
+  public setScale(scale: number) {
+    this.scale = scale;
+  }
+
+  /** Returns the current total render scale factor. */
+  public getScale(): number {
+    return this.scale;
+  }
+
+  /** Returns the cached data JSON (runtime entity data) for the given project key. */
+  public getDataJson(id: string): EntitiesData {
+    return this.cache.getDataJson(id);
+  }
+
+  /** Stores the data JSON for the given project key in the session cache. */
+  public setDataJson(id: string, dataJson: EntitiesData) {
+    this.cache.setDataJson(id, dataJson);
+  }
+
+  /** Returns the cached schema JSON (entity structure) for the given project key. */
+  public getSchemaJson(id: string): Entities {
+    return this.cache.getSchemaJson(id);
+  }
+
+  /** Stores the schema JSON for the given project key in the session cache. */
+  public setSchemaJson(id: string, schemaJson: Entities) {
+    this.cache.setSchemaJson(id, schemaJson);
+  }
+
+  /** Returns a fresh, zeroed-out ManagmentInterface instance ready for an API call. */
+  public getManagmentInterface(): ManagmentInterface {
+    const managment: ManagmentInterface = {
+      functionId: '',
+      appId: '',
+      entId: '',
+      year: 0,
+      keys: '',
+      fields: [],
+      states: [],
+      entIds: [],
+      keyId: '1',
+      filterId: '',
+      page: 1,
+      data: '',
+    };
+    return managment;
+  }
+
+  /** Returns a fresh, zeroed-out SchedulerInterface instance ready for a scheduler API call. */
+  public getSchedulerInterface(): SchedulerInterface {
+    const scheduler: SchedulerInterface = {
+      year: 0,
+      id: '',
+      start: null,
+      end: null,
+      assigned: 0,
+      description: '',
+      allday: false,
+    };
+    return scheduler;
+  }
+
+  /**
+   * Activates a project: sets project/key-id, lazy-loads its data/schema JSON and
+   * navigates to the appropriate route (Calendar, Search list, or Model form).
+   */
+  public activateProject(prj: UserLicenses) {
+    this.setProject(prj);
+    this.setCurrentItem(undefined);
+    this.setKeyId('1');
+    if (prj.type === 'C') {
+      if (this.getLng() === Languages.IT) {
+        this.setView('Calendario');
+      } else if (this.getLng() === Languages.EN) {
+        this.setView('Calendar');
+      }
+      return;
+    }
+    this.config.projectsInfoLoader(prj.year, prj.project).then(prj_Info => {
+      const id = prj.project + '.' + prj.year;
+      if (!this.getDataJson(id)) {
+        this.setDataJson(id, prj_Info.getData());
+      }
+      if (!this.getSchemaJson(id)) {
+        this.setSchemaJson(id, prj_Info.getSchema());
+      }
+      if (prj.type === 'D' || prj.type === 'G') {
+        this.setActiveLink('/home/modelsearch');
+        this.navigate('/home/modelsearch');
+      } else {
+        this.setActiveLink('/home/model');
+        this.navigate('/home/model');
+      }
+    });
+  }
+
+  /** Parses a pixel-value string (e.g. '120px') and returns the integer part. */
+  public getInt(value: string): number {
+    return parseInt(value);
+  }
+
+  /** Parses a string and returns the floating-point number. */
+  public getFloat(value: string): number {
+    return parseFloat(value);
+  }
+
+  public makeId(length: number): string {
+    let result = '';
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+    const charactersLength = characters.length;
+    for (let i = 0; i < length; i++) {
+      result += characters.charAt(Math.floor(Math.random() * charactersLength));
+    }
+    return result;
+  }
+}