emilsoftware-utilities 2.0.0-dev.22 → 2.0.0-dev.24

package/dist/accessi-module/Services/PermissionService/PermissionService.d.ts

@@ -1,28 +1,99 @@
-import { AccessiOptions } from "../../AccessiModule";
+import type { AccessiOptions } from "../../AccessiModule";
 import { Permission } from "../../Dtos";
 import { AbilitazioneMenu } from "../../Dtos/AbilitazioneMenu";
 import { GroupWithMenusEntity } from "../../Dtos/GetGroupsWithMenusResponse";
 import { MenuEntity } from "../../Dtos/GetMenusResponse";
 import { Role } from "../../Dtos/Role";
+import { CreateMenuGroupRequest, CreateMenuRequest, CreateMenuTypeRequest, MenuTypeEntity, UpdateMenuGroupRequest, UpdateMenuRequest, UpdateMenuTypeRequest } from "../../Dtos/CatalogDtos";
+/** Struttura storica menu/gruppi accettata dall'API legacy `addAbilitazioni`. */
+type LegacyMenuGroup = {
+    menu?: Array<{
+        flgChk?: unknown;
+        codiceMenu?: unknown;
+        tipoAbilitazione?: unknown;
+    }>;
+};
 export declare class PermissionService {
     private readonly accessiOptions;
     constructor(accessiOptions: AccessiOptions);
     private getCountFromResult;
+    private extractIntegerColumn;
     private getAllActiveMenusAsGrants;
     private getUserDirectPermissions;
     private getUserRoles;
-    addAbilitazioni(codiceUtente: number, menuAbilitazioni: any[]): Promise<void>;
+    /** Costruisce l'albero ruoli/menu a partire dalle righe (riusato da lettura singola e batch). */
+    private assembleRoles;
+    /** Regola di composizione storica: grant diretti prevalgono, i ruoli si sommano per livello massimo. */
+    private composeGrants;
+    /**
+     * API legacy per salvare grant dalla struttura storica menu/gruppi.
+     * Sostituisce tutti i grant diretti dell'utente; per le nuove integrazioni preferire `assignPermissionsToUser`.
+     */
+    addAbilitazioni(codiceUtente: number, menuAbilitazioni: LegacyMenuGroup[]): Promise<void>;
+    /** Rimuove tutti i grant diretti, senza toccare ruoli o menu ereditati dai ruoli. */
     resetAbilitazioni(codiceUtente: number): Promise<void>;
+    /**
+     * Crea o aggiorna un ruolo. In aggiornamento la lista `role.menu` sostituisce integralmente i menu del ruolo.
+     * Validare i codici menu nel chiamante quando si usano dati non provenienti dalla console o dalle API Accessi.
+     */
     updateOrInsertRole(role: Role, codiceRuolo?: number | null): Promise<void>;
+    /** Restituisce il catalogo ruoli con ogni associazione menu e livello, inclusi ruoli senza menu. */
     getRolesWithMenus(): Promise<Role[]>;
+    /**
+     * Sostituisce l'intera lista di ruoli dell'utente con codici univoci e verificati.
+     * Non modifica i grant diretti: il calcolo effettivo li unisce in `getUserRolesAndGrants`.
+     */
     assignRolesToUser(codiceUtente: number, roles: number[]): Promise<void>;
+    /**
+     * Sostituisce tutti i grant diretti dell'utente. I ruoli rimangono invariati e i loro grant sono aggiunti
+     * solo nel risultato effettivo; un grant diretto dello stesso menu ha precedenza nella composizione.
+     */
     assignPermissionsToUser(codiceUtente: number, permissions: Permission[]): Promise<void>;
+    /** Elimina fisicamente ruolo, associazioni menu e assegnazioni utente. Operazione amministrativa irreversibile. */
     deleteRole(codiceRuolo: number): Promise<void>;
+    /** Restituisce solo menu abilitati; per il catalogo amministrativo usare `getGroupsWithMenus(true)`. */
     getMenus(): Promise<MenuEntity[]>;
+    /**
+     * Restituisce il catalogo ordinato per gruppo e menu. `includeDisabled` e riservato a console e amministrazione:
+     * i flussi applicativi di autorizzazione devono usare il comportamento predefinito, che nasconde voci disabilitate.
+     */
     getGroupsWithMenus(includeDisabled?: boolean): Promise<GroupWithMenusEntity[]>;
+    private countWhere;
+    private assertMenuGroupExists;
+    private assertMenuTypeExists;
+    /** Catalogo completo dei tipi menu, usato dagli editor di configurazione. */
+    getMenuTypes(): Promise<MenuTypeEntity[]>;
+    createMenuType(input: CreateMenuTypeRequest): Promise<void>;
+    updateMenuType(codiceTipo: string, input: UpdateMenuTypeRequest): Promise<void>;
+    /** Elimina un tipo menu solo se nessun menu lo utilizza (la FK lo impedirebbe comunque). */
+    deleteMenuType(codiceTipo: string): Promise<void>;
+    createMenuGroup(input: CreateMenuGroupRequest): Promise<void>;
+    updateMenuGroup(codiceGruppo: string, input: UpdateMenuGroupRequest): Promise<void>;
+    /** Elimina un gruppo solo se non contiene menu, per non lasciare menu orfani. */
+    deleteMenuGroup(codiceGruppo: string): Promise<void>;
+    createMenu(input: CreateMenuRequest): Promise<void>;
+    updateMenu(codiceMenu: string, input: UpdateMenuRequest): Promise<void>;
+    /** Elimina menu, grant utente e associazioni ruolo in un'unica transazione. */
+    deleteMenu(codiceMenu: string): Promise<void>;
+    /**
+     * Calcola l'autorizzazione effettiva: grant diretti e grant dei ruoli sono uniti per codice menu.
+     * Per compatibilita storica un grant diretto prevale su quello del ruolo; i superutenti ricevono tutti i menu attivi.
+     */
     getUserRolesAndGrants(codiceUtente: number): Promise<{
         abilitazioni: AbilitazioneMenu[];
         ruoli: Role[];
         grants: AbilitazioneMenu[];
     }>;
+    private isSuperFlag;
+    /**
+     * Versione batch di `getUserRolesAndGrants`: esegue un numero costante di query per N utenti
+     * (invece di N set di query) e restituisce mappa per codice utente. Stessa composizione della
+     * lettura singola.
+     */
+    getUsersRolesAndGrants(codiciUtente: number[]): Promise<Map<number, {
+        abilitazioni: AbilitazioneMenu[];
+        ruoli: Role[];
+        grants: AbilitazioneMenu[];
+    }>>;
 }
+export {};