emilsoftware-utilities 2.0.0-dev.84 → 2.0.0-dev.85

package/dist/accessi-service/services/permission-service/PermissionService.js

@@ -0,0 +1,944 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PermissionService = void 0;
+const Orm_1 = require("../../../Orm");
+const Utilities_1 = require("../../../Utilities");
+const dtos_1 = require("../../dtos");
+const common_1 = require("@nestjs/common");
+let PermissionService = class PermissionService {
+    constructor(accessiOptions) {
+        this.accessiOptions = accessiOptions;
+    }
+    getCountFromResult(result, fieldName = 'COUNT') {
+        var _a, _b, _c, _d, _e;
+        const rawValue = (_d = (_b = (_a = result === null || result === void 0 ? void 0 : result[0]) === null || _a === void 0 ? void 0 : _a[fieldName]) !== null && _b !== void 0 ? _b : (_c = result === null || result === void 0 ? void 0 : result[0]) === null || _c === void 0 ? void 0 : _c[fieldName.toLowerCase()]) !== null && _d !== void 0 ? _d : (_e = result === null || result === void 0 ? void 0 : result[0]) === null || _e === void 0 ? void 0 : _e.count;
+        return typeof rawValue === 'number' ? rawValue : Number.parseInt(`${rawValue !== null && rawValue !== void 0 ? rawValue : '0'}`, 10);
+    }
+    extractIntegerColumn(result, fieldName) {
+        return new Set(result.map((row) => { var _a; return Number((_a = row[fieldName]) !== null && _a !== void 0 ? _a : row[fieldName.toLowerCase()]); }));
+    }
+    getAllActiveMenusAsGrants() {
+        return __awaiter(this, arguments, void 0, function* (scopeCodes = []) {
+            const scopeFilter = this.scopeFilter('M', scopeCodes);
+            const query = `
+                SELECT
+                    M.CODMNU AS codice_menu,
+                    30 AS tipo_abilitazione,
+                    M.DESMNU AS descrizione_menu,
+                    G.DESGRP AS descrizione_gruppo,
+                    G.CODGRP AS codice_gruppo,
+                    M.ICON AS icona,
+                    M.CODTIP AS tipo,
+                    M.PAGINA AS pagina,
+                    M.NOTE AS note
+                FROM MENU M
+                LEFT JOIN MENU_GRP G ON G.CODGRP = M.CODGRP
+                WHERE M.FLGENABLED = 1 AND COALESCE(G.FLGENABLED, 1) = 1${scopeFilter.sql}
+            `;
+            return yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, query, scopeFilter.params)
+                .then(results => results.map(Utilities_1.RestUtilities.convertKeysToCamelCase));
+        });
+    }
+    /**
+     * Normalizza e valida il filtro `scope` (CSV). Restituisce i codici in
+     * maiuscolo; lista vuota significa "nessun filtro" (comportamento storico).
+     */
+    resolveScopeCodes(scope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const codes = Array.from(new Set(String(scope !== null && scope !== void 0 ? scope : '')
+                .split(',')
+                .map((value) => value.trim().toUpperCase())
+                .filter((value) => value.length > 0)));
+            if (codes.length === 0) {
+                return [];
+            }
+            const placeholders = codes.map(() => '?').join(', ');
+            const rows = (yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, `SELECT CODICE FROM SCOPES WHERE CODICE IN (${placeholders})`, codes));
+            const known = new Set(rows.map((row) => { var _a, _b; return String((_b = (_a = row.CODICE) !== null && _a !== void 0 ? _a : row.codice) !== null && _b !== void 0 ? _b : '').trim().toUpperCase(); }));
+            const missing = codes.filter((code) => !known.has(code));
+            if (missing.length > 0) {
+                throw new common_1.BadRequestException(`Scope non validi: ${missing.join(', ')}.`);
+            }
+            return codes;
+        });
+    }
+    /** Clausola SQL EXISTS per filtrare i menu sugli scope richiesti. */
+    scopeFilter(alias, scopeCodes) {
+        if (scopeCodes.length === 0) {
+            return { sql: '', params: [] };
+        }
+        const placeholders = scopeCodes.map(() => '?').join(', ');
+        return {
+            sql: ` AND EXISTS (SELECT 1 FROM MENU_SCOPES MS WHERE MS.CODICE_MENU = ${alias}.CODMNU AND MS.CODICE_SCOPE IN (${placeholders}))`,
+            params: [...scopeCodes],
+        };
+    }
+    getUserDirectPermissions(codiceUtente_1) {
+        return __awaiter(this, arguments, void 0, function* (codiceUtente, scopeCodes = []) {
+            const scopeFilter = this.scopeFilter('M', scopeCodes);
+            const queryAbilitazioni = `
+                SELECT
+                    A.CODMNU AS codice_menu,
+                    A.TIPABI AS tipo_abilitazione,
+                    M.DESMNU AS descrizione_menu,
+                    G.DESGRP AS descrizione_gruppo,
+                    G.CODGRP AS codice_gruppo,
+                    M.ICON AS icona,
+                    M.CODTIP AS tipo,
+                    M.PAGINA AS pagina,
+                    M.NOTE AS note
+                FROM ABILITAZIONI A
+                INNER JOIN MENU M ON A.CODMNU = M.CODMNU
+                LEFT JOIN MENU_GRP G ON G.CODGRP = M.CODGRP
+                WHERE A.CODUTE = ? AND M.FLGENABLED = 1 AND COALESCE(G.FLGENABLED, 1) = 1${scopeFilter.sql}
+            `;
+            return yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, queryAbilitazioni, [codiceUtente, ...scopeFilter.params])
+                .then(results => results.map(Utilities_1.RestUtilities.convertKeysToCamelCase));
+        });
+    }
+    getUserRoles(codiceUtente_1) {
+        return __awaiter(this, arguments, void 0, function* (codiceUtente, scopeCodes = []) {
+            const scopeFilter = this.scopeFilter('M', scopeCodes);
+            const queryRuoli = `
+                SELECT
+                    R.CODRUO AS codice_ruolo,
+                    R.DESRUO AS descrizione_ruolo,
+                    CASE WHEN COALESCE(G.FLGENABLED, 1) = 1 THEN M.CODMNU END AS codice_menu,
+                    RM.TIPABI AS tipo_abilitazione,
+                    M.DESMNU AS descrizione_menu,
+                    M.NOTE AS note
+                FROM UTENTI_RUOLI RU
+                INNER JOIN RUOLI R ON RU.CODRUO = R.CODRUO
+                LEFT JOIN RUOLI_MNU RM ON R.CODRUO = RM.CODRUO
+                LEFT JOIN MENU M
+                    ON RM.CODMNU = M.CODMNU
+                    AND M.FLGENABLED = 1
+                LEFT JOIN MENU_GRP G
+                    ON G.CODGRP = M.CODGRP
+                WHERE RU.CODUTE = ?${scopeFilter.sql}
+            `;
+            const ruoliResult = (yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, queryRuoli, [codiceUtente, ...scopeFilter.params]))
+                .map(Utilities_1.RestUtilities.convertKeysToCamelCase);
+            return this.assembleRoles(ruoliResult);
+        });
+    }
+    /** Costruisce l'albero ruoli/menu a partire dalle righe (riusato da lettura singola e batch). */
+    assembleRoles(ruoliResult) {
+        const ruoliMap = new Map();
+        for (const row of ruoliResult) {
+            const codiceRuolo = Number(row.codiceRuolo);
+            const descrizioneRuolo = typeof row.descrizioneRuolo === 'string' ? row.descrizioneRuolo.trim() : '';
+            const codiceMenu = typeof row.codiceMenu === 'string' ? row.codiceMenu : undefined;
+            // RUOLI_MNU.TIPABI e MENU.DESMNU sono nullable nello schema storico: un livello
+            // mancante non deve far sparire il menu dal ruolo. Default prudente: lettura.
+            const rawTipoAbilitazione = row.tipoAbilitazione;
+            const parsedTipoAbilitazione = rawTipoAbilitazione === undefined || rawTipoAbilitazione === null || rawTipoAbilitazione === ''
+                ? dtos_1.TipoAbilitazione.LETTURA
+                : Number(rawTipoAbilitazione);
+            const tipoAbilitazione = (Number.isFinite(parsedTipoAbilitazione)
+                ? parsedTipoAbilitazione
+                : dtos_1.TipoAbilitazione.LETTURA);
+            if (!ruoliMap.has(codiceRuolo)) {
+                ruoliMap.set(codiceRuolo, {
+                    codiceRuolo,
+                    descrizioneRuolo,
+                    menu: []
+                });
+            }
+            if (codiceMenu) {
+                ruoliMap.get(codiceRuolo).menu.push({
+                    codiceRuolo,
+                    codiceMenu,
+                    tipoAbilitazione,
+                });
+            }
+        }
+        return Array.from(ruoliMap.values());
+    }
+    /**
+     * Compone i grant effettivi: permessi diretti e ruoli si sommano per codice menu
+     * prendendo il livello massimo. Un livello 0/non valido non rimuove un grant del ruolo.
+     * I superutenti ricevono tutti i menu attivi al livello massimo.
+     */
+    composeGrants(abilitazioni, ruoli, isSuperAdmin, allActiveMenus) {
+        if (isSuperAdmin)
+            return allActiveMenus;
+        const catalog = new Map(allActiveMenus.map((menu) => [menu.codiceMenu, menu]));
+        const grantsMap = new Map();
+        const addGrant = (grant) => {
+            var _a, _b;
+            const codiceMenu = typeof grant.codiceMenu === 'string' ? grant.codiceMenu.trim() : '';
+            const livello = Number((_a = grant.tipoAbilitazione) !== null && _a !== void 0 ? _a : 0);
+            if (!codiceMenu || !Number.isFinite(livello) || livello <= 0)
+                return;
+            const existing = grantsMap.get(codiceMenu);
+            if (!existing || livello > Number((_b = existing.tipoAbilitazione) !== null && _b !== void 0 ? _b : 0)) {
+                // I ruoli salvano solo codice e livello: completa i metadati di navigazione
+                // (pagina, icona, gruppo, tipo) dal catalogo dei menu attivi.
+                const metadata = catalog.get(codiceMenu);
+                grantsMap.set(codiceMenu, Object.assign(Object.assign(Object.assign({}, (metadata !== null && metadata !== void 0 ? metadata : {})), grant), { codiceMenu, tipoAbilitazione: livello }));
+            }
+        };
+        for (const abilitazione of abilitazioni)
+            addGrant(abilitazione);
+        for (const ruolo of ruoli) {
+            for (const menu of ruolo.menu)
+                addGrant(menu);
+        }
+        return Array.from(grantsMap.values());
+    }
+    /**
+     * 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, menuAbilitazioni) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const abilitazioniToInsert = menuAbilitazioni
+                .flatMap(menuGrp => { var _a; return (_a = menuGrp.menu) !== null && _a !== void 0 ? _a : []; })
+                .filter(menu => menu.flgChk)
+                .map(menu => [codiceUtente, menu.codiceMenu, menu.tipoAbilitazione]);
+            const insertQuery = `UPDATE OR INSERT INTO ABILITAZIONI (CODUTE, CODMNU, TIPABI) VALUES (?, ?, ?)`;
+            // Delete + insert atomici: un errore a metà non lascia l'utente senza abilitazioni.
+            yield Orm_1.Orm.executeMultiple(this.accessiOptions.databaseOptions, [
+                { query: `DELETE FROM ABILITAZIONI WHERE CODUTE = ?`, params: [codiceUtente] },
+                ...abilitazioniToInsert.map(params => ({ query: insertQuery, params })),
+            ]);
+        });
+    }
+    /** Rimuove tutti i grant diretti, senza toccare ruoli o menu ereditati dai ruoli. */
+    resetAbilitazioni(codiceUtente) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = "DELETE FROM ABILITAZIONI WHERE CODUTE = ?";
+            yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, query, [codiceUtente]);
+        });
+    }
+    /**
+     * 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_1) {
+        return __awaiter(this, arguments, void 0, function* (role, codiceRuolo = null) {
+            // Ruolo, sostituzione menu e inserimenti in un'unica transazione: niente ruoli senza menu in caso di errore.
+            yield Orm_1.Orm.withTransaction(this.accessiOptions.databaseOptions, (transaction) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                let resolvedCodiceRuolo = codiceRuolo;
+                if (resolvedCodiceRuolo == null) {
+                    const createdRoleResult = yield Orm_1.Orm.transactionQuery(transaction, `INSERT INTO RUOLI (DESRUO) VALUES (?) RETURNING CODRUO`, [role.descrizioneRuolo]);
+                    const createdRole = (Array.isArray(createdRoleResult) ? createdRoleResult[0] : createdRoleResult);
+                    const rawCodiceRuolo = (_a = createdRole === null || createdRole === void 0 ? void 0 : createdRole.CODRUO) !== null && _a !== void 0 ? _a : createdRole === null || createdRole === void 0 ? void 0 : createdRole.codruo;
+                    const parsedCodiceRuolo = typeof rawCodiceRuolo === 'number'
+                        ? rawCodiceRuolo
+                        : Number.parseInt(`${rawCodiceRuolo !== null && rawCodiceRuolo !== void 0 ? rawCodiceRuolo : ''}`, 10);
+                    if (Number.isNaN(parsedCodiceRuolo)) {
+                        throw new Error('Creazione ruolo non riuscita: impossibile recuperare CODRUO.');
+                    }
+                    resolvedCodiceRuolo = parsedCodiceRuolo;
+                }
+                else {
+                    yield Orm_1.Orm.transactionQuery(transaction, `UPDATE RUOLI SET DESRUO = ? WHERE CODRUO = ?`, [role.descrizioneRuolo, resolvedCodiceRuolo]);
+                    yield Orm_1.Orm.transactionQuery(transaction, `DELETE FROM RUOLI_MNU WHERE CODRUO = ?`, [resolvedCodiceRuolo]);
+                }
+                if (resolvedCodiceRuolo === null) {
+                    throw new Error('Operazione ruolo non riuscita: codice ruolo non valorizzato.');
+                }
+                for (const menu of role.menu) {
+                    yield Orm_1.Orm.transactionQuery(transaction, `INSERT INTO RUOLI_MNU (CODRUO, CODMNU, TIPABI) VALUES (?, ?, ?)`, [resolvedCodiceRuolo, menu.codiceMenu, menu.tipoAbilitazione]);
+                }
+            }));
+        });
+    }
+    /** Restituisce il catalogo ruoli con ogni associazione menu e livello, inclusi ruoli senza menu. */
+    getRolesWithMenus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = `
+                SELECT 
+                    R.CODRUO AS codice_ruolo, 
+                    R.DESRUO AS descrizione_ruolo, 
+                    M.CODMNU AS codice_menu, 
+                    M.DESMNU AS descrizione_menu,
+                    M.NOTE AS note,
+                    RM.TIPABI AS tipo_abilitazione
+                FROM RUOLI R
+                LEFT JOIN RUOLI_MNU RM ON R.CODRUO = RM.CODRUO
+                LEFT JOIN MENU M ON RM.CODMNU = M.CODMNU
+                ORDER BY R.CODRUO, M.CODMNU
+            `;
+            const result = (yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, query, []))
+                .map(Utilities_1.RestUtilities.convertKeysToCamelCase);
+            const ruoliMap = new Map();
+            for (const row of result) {
+                const codiceRuolo = Number(row.codiceRuolo);
+                const descrizioneRuolo = typeof row.descrizioneRuolo === 'string' ? row.descrizioneRuolo.trim() : '';
+                const codiceMenu = typeof row.codiceMenu === 'string' ? row.codiceMenu : undefined;
+                const rawTipoAbilitazione = row.tipoAbilitazione;
+                if (!ruoliMap.has(codiceRuolo)) {
+                    ruoliMap.set(codiceRuolo, {
+                        codiceRuolo,
+                        descrizioneRuolo,
+                        menu: []
+                    });
+                }
+                const abilitationValue = typeof rawTipoAbilitazione === 'number'
+                    ? rawTipoAbilitazione
+                    : Number.parseInt(`${rawTipoAbilitazione !== null && rawTipoAbilitazione !== void 0 ? rawTipoAbilitazione : ''}`, 10);
+                if (!codiceMenu || Number.isNaN(abilitationValue) || abilitationValue <= dtos_1.TipoAbilitazione.NESSUNA) {
+                    continue;
+                }
+                ruoliMap.get(codiceRuolo).menu.push({
+                    codiceRuolo,
+                    codiceMenu,
+                    tipoAbilitazione: abilitationValue,
+                });
+            }
+            return Array.from(ruoliMap.values());
+        });
+    }
+    /**
+     * 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, roles) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userExistsQuery = `SELECT COUNT(*) FROM UTENTI WHERE CODUTE = ?`;
+            let result = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, userExistsQuery, [codiceUtente]);
+            if (this.getCountFromResult(result) === 0) {
+                throw new Error(`L'utente con codice ${codiceUtente} non esiste.`);
+            }
+            const normalizedRoles = Array.from(new Set(roles
+                .map((role) => Number.parseInt(`${role !== null && role !== void 0 ? role : ''}`, 10))
+                .filter((role) => Number.isInteger(role) && role > 0)));
+            const queriesWithParams = [
+                { query: `DELETE FROM UTENTI_RUOLI WHERE CODUTE = ?`, params: [codiceUtente] },
+                ...normalizedRoles.map((codiceRuolo) => ({
+                    query: `INSERT INTO UTENTI_RUOLI (CODUTE, CODRUO) VALUES (?, ?)`,
+                    params: [codiceUtente, codiceRuolo],
+                })),
+            ];
+            if (normalizedRoles.length > 0) {
+                // Un'unica query IN invece di N count: stessa validazione, meno round-trip.
+                const placeholders = normalizedRoles.map(() => '?').join(', ');
+                const existingRolesResult = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, `SELECT CODRUO FROM RUOLI WHERE CODRUO IN (${placeholders})`, normalizedRoles);
+                const existingRoles = this.extractIntegerColumn(existingRolesResult, 'CODRUO');
+                const missingRole = normalizedRoles.find((codiceRuolo) => !existingRoles.has(codiceRuolo));
+                if (missingRole !== undefined) {
+                    throw new Error(`Il ruolo con codice ${missingRole} non esiste.`);
+                }
+            }
+            yield Orm_1.Orm.executeMultiple(this.accessiOptions.databaseOptions, queriesWithParams);
+            const assignedRolesResult = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, `SELECT COUNT(*) FROM UTENTI_RUOLI WHERE CODUTE = ?`, [codiceUtente]);
+            const assignedRolesCount = this.getCountFromResult(assignedRolesResult);
+            if (assignedRolesCount !== normalizedRoles.length) {
+                throw new Error(`Persistenza ruoli non coerente per utente ${codiceUtente}: attesi ${normalizedRoles.length}, trovati ${assignedRolesCount}.`);
+            }
+        });
+    }
+    /**
+     * Sostituisce tutti i grant diretti dell'utente. I ruoli rimangono invariati e i loro grant sono aggiunti
+     * solo nel risultato effettivo; per lo stesso menu vale il livello massimo tra diretto e ruoli.
+     */
+    assignPermissionsToUser(codiceUtente, permissions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userExistsQuery = `SELECT COUNT(*) FROM UTENTI WHERE CODUTE = ?`;
+            let result = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, userExistsQuery, [codiceUtente]);
+            if (this.getCountFromResult(result) === 0) {
+                throw new Error(`L'utente con codice ${codiceUtente} non esiste.`);
+            }
+            const normalizedPermissions = Array.from(new Map(permissions
+                .map((permission) => {
+                var _a, _b;
+                return ({
+                    codiceMenu: `${(_a = permission === null || permission === void 0 ? void 0 : permission.codiceMenu) !== null && _a !== void 0 ? _a : ''}`.trim(),
+                    tipoAbilitazione: Number.parseInt(`${(_b = permission === null || permission === void 0 ? void 0 : permission.tipoAbilitazione) !== null && _b !== void 0 ? _b : ''}`, 10),
+                });
+            })
+                .filter((permission) => permission.codiceMenu.length > 0 && Number.isInteger(permission.tipoAbilitazione))
+                .map((permission) => [permission.codiceMenu, permission])).values());
+            const queriesWithParams = [
+                { query: `DELETE FROM ABILITAZIONI WHERE CODUTE = ?`, params: [codiceUtente] },
+                ...normalizedPermissions.map((permission) => ({
+                    query: `INSERT INTO ABILITAZIONI (CODUTE, CODMNU, TIPABI) VALUES (?, ?, ?)`,
+                    params: [codiceUtente, permission.codiceMenu, permission.tipoAbilitazione],
+                })),
+            ];
+            if (normalizedPermissions.length > 0) {
+                // Un'unica query IN invece di N count: stessa validazione, meno round-trip.
+                const menuCodes = normalizedPermissions.map((permission) => permission.codiceMenu);
+                const placeholders = menuCodes.map(() => '?').join(', ');
+                const existingMenusResult = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, `SELECT CODMNU FROM MENU WHERE CODMNU IN (${placeholders})`, menuCodes);
+                const existingMenus = new Set(existingMenusResult.map((row) => { var _a, _b; return String((_b = (_a = row.CODMNU) !== null && _a !== void 0 ? _a : row.codmnu) !== null && _b !== void 0 ? _b : ''); }));
+                const missingMenu = menuCodes.find((codiceMenu) => !existingMenus.has(codiceMenu));
+                if (missingMenu !== undefined) {
+                    throw new Error(`Il menu con codice ${missingMenu} non esiste.`);
+                }
+            }
+            yield Orm_1.Orm.executeMultiple(this.accessiOptions.databaseOptions, queriesWithParams);
+            const assignedPermissionsResult = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, `SELECT COUNT(*) FROM ABILITAZIONI WHERE CODUTE = ?`, [codiceUtente]);
+            const assignedPermissionsCount = this.getCountFromResult(assignedPermissionsResult);
+            if (assignedPermissionsCount !== normalizedPermissions.length) {
+                throw new Error(`Persistenza abilitazioni non coerente per utente ${codiceUtente}: attese ${normalizedPermissions.length}, trovate ${assignedPermissionsCount}.`);
+            }
+        });
+    }
+    /** Elimina fisicamente ruolo, associazioni menu e assegnazioni utente. Operazione amministrativa irreversibile. */
+    deleteRole(codiceRuolo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const existsQuery = `SELECT COUNT(*) FROM RUOLI WHERE CODRUO = ?`;
+            const result = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, existsQuery, [codiceRuolo]);
+            if (this.getCountFromResult(result) === 0) {
+                throw new Error(`Il ruolo con codice ${codiceRuolo} non esiste.`);
+            }
+            // Le tre delete sono atomiche: nessun ruolo orfano se una fallisce.
+            yield Orm_1.Orm.executeMultiple(this.accessiOptions.databaseOptions, [
+                { query: `DELETE FROM RUOLI_MNU WHERE CODRUO = ?`, params: [codiceRuolo] },
+                { query: `DELETE FROM UTENTI_RUOLI WHERE CODRUO = ?`, params: [codiceRuolo] },
+                { query: `DELETE FROM RUOLI WHERE CODRUO = ?`, params: [codiceRuolo] },
+            ]);
+        });
+    }
+    /** Restituisce solo menu abilitati; per il catalogo amministrativo usare `getGroupsWithMenus(true)`. */
+    getMenus(scope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const scopeCodes = yield this.resolveScopeCodes(scope);
+            const scopeFilter = this.scopeFilter('M', scopeCodes);
+            const query = `
+                SELECT
+                    M.CODMNU AS codice_menu,
+                    M.DESMNU AS descrizione_menu,
+                    M.CODGRP AS codice_gruppo,
+                    G.DESGRP AS descrizione_gruppo,
+                    M.ICON AS icona,
+                    M.CODTIP AS tipo,
+                    M.PAGINA AS pagina,
+                    M.NOTE AS note,
+                    G.ORDINE AS ordine_gruppo,
+                    M.ORDINE AS ordine_menu
+                FROM MENU M
+                LEFT JOIN MENU_GRP G ON M.CODGRP = G.CODGRP
+                WHERE M.FLGENABLED = 1 AND COALESCE(G.FLGENABLED, 1) = 1${scopeFilter.sql}
+                ORDER BY G.CODGRP, M.CODMNU
+            `;
+            const result = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, query, scopeFilter.params);
+            return result.map(Utilities_1.RestUtilities.convertKeysToCamelCase);
+        });
+    }
+    /**
+     * 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() {
+        return __awaiter(this, arguments, void 0, function* (includeDisabled = false, scope) {
+            const scopeCodes = yield this.resolveScopeCodes(scope);
+            const scopeFilter = this.scopeFilter('M', scopeCodes);
+            let filtersClause = includeDisabled
+                ? ''
+                : 'WHERE M.FLGENABLED = 1 AND (G.FLGENABLED IS NULL OR G.FLGENABLED = 1)';
+            if (scopeFilter.sql) {
+                filtersClause = filtersClause ? `${filtersClause}${scopeFilter.sql}` : `WHERE 1 = 1${scopeFilter.sql}`;
+            }
+            const query = `
+                SELECT
+                    M.CODMNU AS codice_menu,
+                    M.DESMNU AS descrizione_menu,
+                    M.CODGRP AS codice_gruppo,
+                    G.DESGRP AS descrizione_gruppo,
+                    M.ICON AS icona,
+                    M.CODTIP AS tipo,
+                    M.PAGINA AS pagina,
+                    M.NOTE AS note,
+                    G.ORDINE AS ordine_gruppo,
+                    M.ORDINE as ordine_menu,
+                    M.FLGENABLED AS menu_enabled,
+                    G.FLGENABLED AS group_enabled
+                FROM MENU M
+                LEFT JOIN MENU_GRP G ON M.CODGRP = G.CODGRP
+                ${filtersClause}
+                ORDER BY G.CODGRP, M.CODMNU
+            `;
+            const result = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, query, scopeFilter.params);
+            const groupMap = new Map();
+            result.forEach((row) => {
+                var _a, _b, _c;
+                const converted = Utilities_1.RestUtilities.convertKeysToCamelCase(row);
+                const { menuEnabled, groupEnabled } = converted, menuBase = __rest(converted, ["menuEnabled", "groupEnabled"]);
+                const normalizedGroupKey = (_a = menuBase.codiceGruppo) !== null && _a !== void 0 ? _a : '__UNGROUPED__';
+                const groupEnabledFlag = groupEnabled == null ? true : Number(groupEnabled) === 1 || groupEnabled === true;
+                const menuEnabledFlag = menuEnabled === undefined ? true : Number(menuEnabled) === 1 || menuEnabled === true;
+                if (!groupMap.has(normalizedGroupKey)) {
+                    groupMap.set(normalizedGroupKey, {
+                        codiceGruppo: (_b = menuBase.codiceGruppo) !== null && _b !== void 0 ? _b : normalizedGroupKey,
+                        descrizioneGruppo: (_c = menuBase.descrizioneGruppo) !== null && _c !== void 0 ? _c : '',
+                        ordineGruppo: menuBase.ordineGruppo,
+                        enabled: groupEnabledFlag,
+                        menus: [],
+                    });
+                }
+                if (menuBase.codiceMenu) {
+                    groupMap.get(normalizedGroupKey).menus.push(Object.assign(Object.assign({}, menuBase), { enabled: menuEnabledFlag }));
+                }
+            });
+            const groupsArray = Array.from(groupMap.values())
+                .map(group => {
+                var _a;
+                return (Object.assign(Object.assign({}, group), { menus: ((_a = group.menus) !== null && _a !== void 0 ? _a : []).sort((a, b) => { var _a, _b; return ((_a = a.ordineMenu) !== null && _a !== void 0 ? _a : Number.MAX_SAFE_INTEGER) - ((_b = b.ordineMenu) !== null && _b !== void 0 ? _b : Number.MAX_SAFE_INTEGER); }) }));
+            })
+                .sort((a, b) => { var _a, _b; return ((_a = a.ordineGruppo) !== null && _a !== void 0 ? _a : Number.MAX_SAFE_INTEGER) - ((_b = b.ordineGruppo) !== null && _b !== void 0 ? _b : Number.MAX_SAFE_INTEGER); });
+            return groupsArray;
+        });
+    }
+    // -----------------------------------------------------------------------
+    // Cataloghi di configurazione: CRUD di menu, gruppi, tipi menu.
+    // `table` e `column` sono sempre costanti interne, mai input utente: i
+    // valori sono parametrizzati, quindi non esiste superficie di SQL injection.
+    // -----------------------------------------------------------------------
+    countWhere(table, column, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, `SELECT COUNT(*) FROM ${table} WHERE ${column} = ?`, [value]);
+            return this.getCountFromResult(result);
+        });
+    }
+    assertMenuGroupExists(codiceGruppo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((yield this.countWhere('MENU_GRP', 'CODGRP', codiceGruppo)) === 0) {
+                throw new common_1.BadRequestException(`Il gruppo menu ${codiceGruppo} non esiste.`);
+            }
+        });
+    }
+    assertMenuTypeExists(codiceTipo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((yield this.countWhere('MENU_TIPI', 'CODTIP', codiceTipo)) === 0) {
+                throw new common_1.BadRequestException(`Il tipo menu ${codiceTipo} non esiste.`);
+            }
+        });
+    }
+    /** Catalogo completo dei tipi menu, usato dagli editor di configurazione. */
+    getMenuTypes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = `SELECT CODTIP AS codice_tipo, DESTIP AS descrizione_tipo FROM MENU_TIPI ORDER BY CODTIP`;
+            const result = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, query, []);
+            return result.map(Utilities_1.RestUtilities.convertKeysToCamelCase);
+        });
+    }
+    createMenuType(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if ((yield this.countWhere('MENU_TIPI', 'CODTIP', input.codiceTipo)) > 0) {
+                throw new common_1.BadRequestException(`Il tipo menu ${input.codiceTipo} esiste gia.`);
+            }
+            yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, `INSERT INTO MENU_TIPI (CODTIP, DESTIP) VALUES (?, ?)`, [input.codiceTipo, (_a = input.descrizioneTipo) !== null && _a !== void 0 ? _a : null]);
+        });
+    }
+    updateMenuType(codiceTipo, input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.assertMenuTypeExists(codiceTipo);
+            if (input.descrizioneTipo === undefined)
+                return;
+            yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, `UPDATE MENU_TIPI SET DESTIP = ? WHERE CODTIP = ?`, [input.descrizioneTipo, codiceTipo]);
+        });
+    }
+    /** Elimina un tipo menu solo se nessun menu lo utilizza (la FK lo impedirebbe comunque). */
+    deleteMenuType(codiceTipo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.assertMenuTypeExists(codiceTipo);
+            const used = yield this.countWhere('MENU', 'CODTIP', codiceTipo);
+            if (used > 0) {
+                throw new common_1.BadRequestException(`Impossibile eliminare il tipo ${codiceTipo}: ${used} menu lo utilizzano.`);
+            }
+            yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, `DELETE FROM MENU_TIPI WHERE CODTIP = ?`, [codiceTipo]);
+        });
+    }
+    createMenuGroup(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if ((yield this.countWhere('MENU_GRP', 'CODGRP', input.codiceGruppo)) > 0) {
+                throw new common_1.BadRequestException(`Il gruppo menu ${input.codiceGruppo} esiste gia.`);
+            }
+            yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, `INSERT INTO MENU_GRP (CODGRP, DESGRP, FLGENABLED, ORDINE) VALUES (?, ?, ?, ?)`, [
+                input.codiceGruppo,
+                (_a = input.descrizioneGruppo) !== null && _a !== void 0 ? _a : null,
+                input.enabled === false ? 0 : 1,
+                (_b = input.ordineGruppo) !== null && _b !== void 0 ? _b : 0,
+            ]);
+        });
+    }
+    updateMenuGroup(codiceGruppo, input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.assertMenuGroupExists(codiceGruppo);
+            const sets = [];
+            const params = [];
+            if (input.descrizioneGruppo !== undefined) {
+                sets.push('DESGRP = ?');
+                params.push(input.descrizioneGruppo);
+            }
+            if (input.ordineGruppo !== undefined) {
+                sets.push('ORDINE = ?');
+                params.push(input.ordineGruppo);
+            }
+            if (input.enabled !== undefined) {
+                sets.push('FLGENABLED = ?');
+                params.push(input.enabled ? 1 : 0);
+            }
+            if (sets.length === 0)
+                return;
+            params.push(codiceGruppo);
+            yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, `UPDATE MENU_GRP SET ${sets.join(', ')} WHERE CODGRP = ?`, params);
+        });
+    }
+    /** Elimina un gruppo solo se non contiene menu, per non lasciare menu orfani. */
+    deleteMenuGroup(codiceGruppo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.assertMenuGroupExists(codiceGruppo);
+            const used = yield this.countWhere('MENU', 'CODGRP', codiceGruppo);
+            if (used > 0) {
+                throw new common_1.BadRequestException(`Impossibile eliminare il gruppo ${codiceGruppo}: contiene ${used} menu.`);
+            }
+            yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, `DELETE FROM MENU_GRP WHERE CODGRP = ?`, [codiceGruppo]);
+        });
+    }
+    createMenu(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g;
+            if ((yield this.countWhere('MENU', 'CODMNU', input.codiceMenu)) > 0) {
+                throw new common_1.BadRequestException(`Il menu ${input.codiceMenu} esiste gia.`);
+            }
+            yield this.assertMenuGroupExists(input.codiceGruppo);
+            if (input.tipo)
+                yield this.assertMenuTypeExists(input.tipo);
+            yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, `INSERT INTO MENU (CODMNU, DESMNU, CODGRP, FLGENABLED, ICON, ORDINE, CODTIP, PAGINA, RIFMENU, NOTE)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+                input.codiceMenu,
+                (_a = input.descrizioneMenu) !== null && _a !== void 0 ? _a : null,
+                input.codiceGruppo,
+                input.enabled === false ? 0 : 1,
+                (_b = input.icona) !== null && _b !== void 0 ? _b : null,
+                (_c = input.ordineMenu) !== null && _c !== void 0 ? _c : null,
+                (_d = input.tipo) !== null && _d !== void 0 ? _d : null,
+                (_e = input.pagina) !== null && _e !== void 0 ? _e : null,
+                (_f = input.rifMenu) !== null && _f !== void 0 ? _f : null,
+                (_g = input.note) !== null && _g !== void 0 ? _g : null,
+            ]);
+        });
+    }
+    updateMenu(codiceMenu, input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((yield this.countWhere('MENU', 'CODMNU', codiceMenu)) === 0) {
+                throw new common_1.BadRequestException(`Il menu ${codiceMenu} non esiste.`);
+            }
+            if (input.codiceGruppo !== undefined)
+                yield this.assertMenuGroupExists(input.codiceGruppo);
+            if (input.tipo)
+                yield this.assertMenuTypeExists(input.tipo);
+            const sets = [];
+            const params = [];
+            if (input.descrizioneMenu !== undefined) {
+                sets.push('DESMNU = ?');
+                params.push(input.descrizioneMenu);
+            }
+            if (input.codiceGruppo !== undefined) {
+                sets.push('CODGRP = ?');
+                params.push(input.codiceGruppo);
+            }
+            if (input.tipo !== undefined) {
+                sets.push('CODTIP = ?');
+                params.push(input.tipo || null);
+            }
+            if (input.icona !== undefined) {
+                sets.push('ICON = ?');
+                params.push(input.icona);
+            }
+            if (input.pagina !== undefined) {
+                sets.push('PAGINA = ?');
+                params.push(input.pagina);
+            }
+            if (input.ordineMenu !== undefined) {
+                sets.push('ORDINE = ?');
+                params.push(input.ordineMenu);
+            }
+            if (input.enabled !== undefined) {
+                sets.push('FLGENABLED = ?');
+                params.push(input.enabled ? 1 : 0);
+            }
+            if (input.rifMenu !== undefined) {
+                sets.push('RIFMENU = ?');
+                params.push(input.rifMenu);
+            }
+            if (input.note !== undefined) {
+                sets.push('NOTE = ?');
+                params.push(input.note);
+            }
+            if (sets.length === 0)
+                return;
+            params.push(codiceMenu);
+            yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, `UPDATE MENU SET ${sets.join(', ')} WHERE CODMNU = ?`, params);
+        });
+    }
+    /** Elimina menu, grant utente e associazioni ruolo in un'unica transazione. */
+    deleteMenu(codiceMenu) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((yield this.countWhere('MENU', 'CODMNU', codiceMenu)) === 0) {
+                throw new common_1.BadRequestException(`Il menu ${codiceMenu} non esiste.`);
+            }
+            yield Orm_1.Orm.executeMultiple(this.accessiOptions.databaseOptions, [
+                { query: `DELETE FROM ABILITAZIONI WHERE CODMNU = ?`, params: [codiceMenu] },
+                { query: `DELETE FROM RUOLI_MNU WHERE CODMNU = ?`, params: [codiceMenu] },
+                { query: `DELETE FROM MENU WHERE CODMNU = ?`, params: [codiceMenu] },
+            ]);
+        });
+    }
+    /**
+     * Calcola l'autorizzazione effettiva: grant diretti e grant dei ruoli sono uniti per codice menu
+     * prendendo il livello massimo. I superutenti ricevono tutti i menu attivi.
+     */
+    getUserRolesAndGrants(codiceUtente, scope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const scopeCodes = yield this.resolveScopeCodes(scope);
+            const codiceUtenteQuery = "SELECT FLGSUPER as flag_super FROM UTENTI_CONFIG WHERE CODUTE = ?";
+            const result = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, codiceUtenteQuery, [codiceUtente]);
+            if (!result || result.length == 0)
+                throw new Error("Nessun utente trovato con il codice utente " + codiceUtente);
+            const isSuperAdmin = this.isSuperFlag((_a = result.map(Utilities_1.RestUtilities.convertKeysToCamelCase)[0]) === null || _a === void 0 ? void 0 : _a.flagSuper);
+            const abilitazioni = yield this.getUserDirectPermissions(codiceUtente, scopeCodes);
+            const ruoli = yield this.getUserRoles(codiceUtente, scopeCodes);
+            const grants = this.composeGrants(abilitazioni, ruoli, isSuperAdmin, yield this.getAllActiveMenusAsGrants(scopeCodes));
+            return { abilitazioni, ruoli, grants };
+        });
+    }
+    isSuperFlag(value) {
+        return value === true || value === 1 || value === '1';
+    }
+    /**
+     * 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, scope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const scopeCodes = yield this.resolveScopeCodes(scope);
+            const scopeFilter = this.scopeFilter('M', scopeCodes);
+            const result = new Map();
+            const ids = Array.from(new Set(codiciUtente.filter((id) => Number.isInteger(id) && id > 0)));
+            if (ids.length === 0) {
+                return result;
+            }
+            const placeholders = ids.map(() => '?').join(', ');
+            const superRows = (yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, `SELECT CODUTE AS codice_utente, FLGSUPER AS flag_super FROM UTENTI_CONFIG WHERE CODUTE IN (${placeholders})`, ids)).map(Utilities_1.RestUtilities.convertKeysToCamelCase);
+            const superUsers = new Set();
+            for (const row of superRows) {
+                if (this.isSuperFlag(row.flagSuper)) {
+                    superUsers.add(Number(row.codiceUtente));
+                }
+            }
+            const permissionRows = (yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, `SELECT
+                A.CODUTE AS codice_utente,
+                A.CODMNU AS codice_menu,
+                A.TIPABI AS tipo_abilitazione,
+                M.DESMNU AS descrizione_menu,
+                G.DESGRP AS descrizione_gruppo,
+                G.CODGRP AS codice_gruppo,
+                M.ICON AS icona,
+                M.CODTIP AS tipo,
+                M.PAGINA AS pagina,
+                M.NOTE AS note
+            FROM ABILITAZIONI A
+            INNER JOIN MENU M ON A.CODMNU = M.CODMNU
+            LEFT JOIN MENU_GRP G ON G.CODGRP = M.CODGRP
+            WHERE A.CODUTE IN (${placeholders}) AND M.FLGENABLED = 1 AND COALESCE(G.FLGENABLED, 1) = 1${scopeFilter.sql}`, [...ids, ...scopeFilter.params])).map(Utilities_1.RestUtilities.convertKeysToCamelCase);
+            const roleRows = (yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, `SELECT
+                RU.CODUTE AS codice_utente,
+                R.CODRUO AS codice_ruolo,
+                R.DESRUO AS descrizione_ruolo,
+                CASE WHEN COALESCE(G.FLGENABLED, 1) = 1 THEN M.CODMNU END AS codice_menu,
+                RM.TIPABI AS tipo_abilitazione,
+                M.DESMNU AS descrizione_menu,
+                M.NOTE AS note
+            FROM UTENTI_RUOLI RU
+            INNER JOIN RUOLI R ON RU.CODRUO = R.CODRUO
+            LEFT JOIN RUOLI_MNU RM ON R.CODRUO = RM.CODRUO
+            LEFT JOIN MENU M ON RM.CODMNU = M.CODMNU AND M.FLGENABLED = 1
+            LEFT JOIN MENU_GRP G ON G.CODGRP = M.CODGRP
+            WHERE RU.CODUTE IN (${placeholders})${scopeFilter.sql}`, [...ids, ...scopeFilter.params])).map(Utilities_1.RestUtilities.convertKeysToCamelCase);
+            const allActiveMenus = yield this.getAllActiveMenusAsGrants(scopeCodes);
+            const permissionsByUser = new Map();
+            for (const row of permissionRows) {
+                const { codiceUtente } = row, grant = __rest(row, ["codiceUtente"]);
+                const key = Number(codiceUtente);
+                const bucket = permissionsByUser.get(key);
+                if (bucket) {
+                    bucket.push(grant);
+                }
+                else {
+                    permissionsByUser.set(key, [grant]);
+                }
+            }
+            const rolesByUser = new Map();
+            for (const row of roleRows) {
+                const { codiceUtente } = row, roleRow = __rest(row, ["codiceUtente"]);
+                const key = Number(codiceUtente);
+                const bucket = rolesByUser.get(key);
+                if (bucket) {
+                    bucket.push(roleRow);
+                }
+                else {
+                    rolesByUser.set(key, [roleRow]);
+                }
+            }
+            for (const id of ids) {
+                const abilitazioni = (_a = permissionsByUser.get(id)) !== null && _a !== void 0 ? _a : [];
+                const ruoli = this.assembleRoles((_b = rolesByUser.get(id)) !== null && _b !== void 0 ? _b : []);
+                const isSuperAdmin = superUsers.has(id);
+                result.set(id, {
+                    abilitazioni,
+                    ruoli,
+                    grants: this.composeGrants(abilitazioni, ruoli, isSuperAdmin, allActiveMenus),
+                });
+            }
+            return result;
+        });
+    }
+    // -----------------------------------------------------------------------
+    // Scope applicativi: catalogo e associazioni menu/scope.
+    // -----------------------------------------------------------------------
+    normalizeScopeCode(value) {
+        const code = String(value !== null && value !== void 0 ? value : '').trim().toUpperCase();
+        if (!/^[A-Z][A-Z0-9_]{0,19}$/.test(code)) {
+            throw new common_1.BadRequestException('Codice scope non valido: usa lettere maiuscole, cifre e underscore (max 20 caratteri).');
+        }
+        return code;
+    }
+    assertScopeExists(codiceScope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((yield this.countWhere('SCOPES', 'CODICE', codiceScope)) === 0) {
+                throw new common_1.BadRequestException(`Lo scope ${codiceScope} non esiste.`);
+            }
+        });
+    }
+    assertMenuExists(codiceMenu) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((yield this.countWhere('MENU', 'CODMNU', codiceMenu)) === 0) {
+                throw new common_1.BadRequestException(`Il menu ${codiceMenu} non esiste.`);
+            }
+        });
+    }
+    /** Catalogo degli scope applicativi (disponibile anche ai client per le etichette). */
+    getScopes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rows = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, 'SELECT CODICE AS codice, NOME AS nome FROM SCOPES ORDER BY CODICE', []);
+            return rows.map(Utilities_1.RestUtilities.convertKeysToCamelCase);
+        });
+    }
+    createScope(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const codice = this.normalizeScopeCode(input.codice);
+            if ((yield this.countWhere('SCOPES', 'CODICE', codice)) > 0) {
+                throw new common_1.BadRequestException(`Lo scope ${codice} esiste gia.`);
+            }
+            yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, 'INSERT INTO SCOPES (CODICE, NOME) VALUES (?, ?)', [codice, input.nome]);
+        });
+    }
+    updateScope(codiceScope, input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const codice = this.normalizeScopeCode(codiceScope);
+            yield this.assertScopeExists(codice);
+            if (input.nome === undefined)
+                return;
+            yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, 'UPDATE SCOPES SET NOME = ? WHERE CODICE = ?', [input.nome, codice]);
+        });
+    }
+    /** Elimina lo scope; le associazioni menu/scope spariscono per FK ON DELETE CASCADE. */
+    deleteScope(codiceScope) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const codice = this.normalizeScopeCode(codiceScope);
+            yield this.assertScopeExists(codice);
+            yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, 'DELETE FROM SCOPES WHERE CODICE = ?', [codice]);
+        });
+    }
+    /** Scope associati a un menu. */
+    getMenuScopes(codiceMenu) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const code = String(codiceMenu !== null && codiceMenu !== void 0 ? codiceMenu : '').trim().toUpperCase();
+            yield this.assertMenuExists(code);
+            const rows = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, 'SELECT CODICE_SCOPE FROM MENU_SCOPES WHERE CODICE_MENU = ? ORDER BY CODICE_SCOPE', [code]);
+            return rows
+                .map((row) => { var _a, _b; return String((_b = (_a = row.CODICE_SCOPE) !== null && _a !== void 0 ? _a : row.codiceScope) !== null && _b !== void 0 ? _b : '').trim(); })
+                .filter((value) => value.length > 0);
+        });
+    }
+    /** Sostituisce in modo atomico gli scope di un menu. */
+    setMenuScopes(codiceMenu, scopes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const code = String(codiceMenu !== null && codiceMenu !== void 0 ? codiceMenu : '').trim().toUpperCase();
+            yield this.assertMenuExists(code);
+            const normalized = Array.from(new Set((scopes !== null && scopes !== void 0 ? scopes : []).map((scope) => this.normalizeScopeCode(scope))));
+            for (const scope of normalized) {
+                yield this.assertScopeExists(scope);
+            }
+            const queries = [
+                { query: 'DELETE FROM MENU_SCOPES WHERE CODICE_MENU = ?', params: [code] },
+                ...normalized.map((scope) => ({
+                    query: 'INSERT INTO MENU_SCOPES (CODICE_MENU, CODICE_SCOPE) VALUES (?, ?)',
+                    params: [code, scope],
+                })),
+            ];
+            yield Orm_1.Orm.executeMultiple(this.accessiOptions.databaseOptions, queries);
+        });
+    }
+    /** Sostituisce in modo atomico i menu di uno scope (assegnazione massiva). */
+    setScopeMenus(codiceScope, menus) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const scope = this.normalizeScopeCode(codiceScope);
+            yield this.assertScopeExists(scope);
+            const normalized = Array.from(new Set((menus !== null && menus !== void 0 ? menus : []).map((menu) => String(menu !== null && menu !== void 0 ? menu : '').trim().toUpperCase()).filter(Boolean)));
+            for (const menu of normalized) {
+                yield this.assertMenuExists(menu);
+            }
+            const queries = [
+                { query: 'DELETE FROM MENU_SCOPES WHERE CODICE_SCOPE = ?', params: [scope] },
+                ...normalized.map((menu) => ({
+                    query: 'INSERT INTO MENU_SCOPES (CODICE_MENU, CODICE_SCOPE) VALUES (?, ?)',
+                    params: [menu, scope],
+                })),
+            ];
+            yield Orm_1.Orm.executeMultiple(this.accessiOptions.databaseOptions, queries);
+        });
+    }
+};
+exports.PermissionService = PermissionService;
+exports.PermissionService = PermissionService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)('ACCESSI_OPTIONS')),
+    __metadata("design:paramtypes", [Object])
+], PermissionService);
+//# sourceMappingURL=PermissionService.js.map