emilsoftware-utilities 2.0.0-dev.7 → 2.0.0-dev.71

package/dist/accessi-module/Services/PermissionService/PermissionService.js

@@ -41,205 +41,464 @@ 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 deleteQuery = `DELETE FROM ABILITAZIONI WHERE CODUTE = ?`;
-            yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, deleteQuery, [codiceUtente]);
             const abilitazioniToInsert = menuAbilitazioni
-                .flatMap(menuGrp => menuGrp.menu)
+                .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 (?, ?, ?)`;
-            for (const params of abilitazioniToInsert) {
-                yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, insertQuery, params);
-            }
+            // 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) {
-            var _a, _b, _c;
-            // creazione nuovo ruolo
-            if (codiceRuolo == null) {
-                const createRoleQuery = `INSERT INTO RUOLI (DESRUO) VALUES (?)`;
-                yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, createRoleQuery, [role.descrizioneRuolo]);
-                const createdRoleResult = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, 'SELECT FIRST 1 CODRUO FROM RUOLI WHERE DESRUO = ? ORDER BY CODRUO DESC', [role.descrizioneRuolo]);
-                const rawCodiceRuolo = (_b = (_a = createdRoleResult === null || createdRoleResult === void 0 ? void 0 : createdRoleResult[0]) === null || _a === void 0 ? void 0 : _a.CODRUO) !== null && _b !== void 0 ? _b : (_c = createdRoleResult === null || createdRoleResult === void 0 ? void 0 : createdRoleResult[0]) === null || _c === void 0 ? void 0 : _c.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.');
+            // 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;
                 }
-                codiceRuolo = parsedCodiceRuolo;
-            }
-            else 
-            // aggiornamento ruolo esistente
-            {
-                let updateRoleQuery = `UPDATE RUOLI SET DESRUO = ? WHERE CODRUO = ?`;
-                yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, updateRoleQuery, [role.descrizioneRuolo, codiceRuolo]);
-                let deleteRoleMenuQuery = `DELETE FROM RUOLI_MNU WHERE CODRUO = ?`;
-                yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, deleteRoleMenuQuery, [codiceRuolo]);
-            }
-            if (codiceRuolo === null) {
-                throw new Error('Operazione ruolo non riuscita: codice ruolo non valorizzato.');
-            }
-            let createRoleMenuQuery = `INSERT INTO RUOLI_MNU (CODRUO, CODMNU, TIPABI) VALUES (?, ?, ?)`;
-            for (let menu of role.menu) {
-                yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, createRoleMenuQuery, [codiceRuolo, menu.codiceMenu, menu.tipoAbilitazione]);
-            }
+                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 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
             `;
-            let result = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, query, []);
-            result = result.map(Utilities_1.RestUtilities.convertKeysToCamelCase);
+            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, descrizioneRuolo, codiceMenu, descrizioneMenu, tipoAbilitazione } = row;
+                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: descrizioneRuolo === null || descrizioneRuolo === void 0 ? void 0 : descrizioneRuolo.trim(),
+                        descrizioneRuolo,
                         menu: []
                     });
                 }
-                const abilitationValue = typeof tipoAbilitazione === 'number'
-                    ? tipoAbilitazione
-                    : Number.parseInt(`${tipoAbilitazione !== null && tipoAbilitazione !== void 0 ? tipoAbilitazione : ''}`, 10);
+                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: codiceRuolo,
-                    codiceMenu: codiceMenu.trim(),
+                    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 (result[0].COUNT === 0) {
+            if (this.getCountFromResult(result) === 0) {
                 throw new Error(`L'utente con codice ${codiceUtente} non esiste.`);
             }
-            const deleteQuery = `DELETE FROM UTENTI_RUOLI WHERE CODUTE = ?`;
-            yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, deleteQuery, [codiceUtente]);
-            const insertQuery = `INSERT INTO UTENTI_RUOLI (CODUTE, CODRUO) VALUES (?, ?)`;
-            for (const codiceRuolo of roles) {
-                yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, insertQuery, [codiceUtente, codiceRuolo]);
+            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 (result[0].COUNT === 0) {
+            if (this.getCountFromResult(result) === 0) {
                 throw new Error(`L'utente con codice ${codiceUtente} non esiste.`);
             }
-            const deleteQuery = `DELETE FROM ABILITAZIONI WHERE CODUTE = ?`;
-            yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, deleteQuery, [codiceUtente]);
-            const insertQuery = `INSERT INTO ABILITAZIONI (CODUTE, CODMNU, TIPABI) VALUES (?, ?, ?)`;
-            for (const permission of permissions) {
-                yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, insertQuery, [codiceUtente, permission.codiceMenu, permission.tipoAbilitazione]);
+            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 = ?`;
-            let result = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, existsQuery, [codiceRuolo]);
-            if (result[0].COUNT === 0) {
+            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.`);
             }
-            const deleteRoleMenusQuery = `DELETE FROM RUOLI_MNU WHERE CODRUO = ?`;
-            yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, deleteRoleMenusQuery, [codiceRuolo]);
-            const deleteRoleUsersQuery = `DELETE FROM UTENTI_RUOLI WHERE CODRUO = ?`;
-            yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, deleteRoleUsersQuery, [codiceRuolo]);
-            const deleteRoleQuery = `DELETE FROM RUOLI WHERE CODRUO = ?`;
-            yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, deleteRoleQuery, [codiceRuolo]);
-        });
-    }
-    getMenus() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const query = `
-                SELECT 
-                    M.CODMNU AS codiceMenu, 
-                    M.DESMNU AS descrizioneMenu,
-                    M.CODGRP AS codiceGruppo,
-                    G.DESGRP AS descrizioneGruppo,
-                    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 M.CODGRP = G.CODGRP
-                WHERE M.FLGENABLED = 1
-                ORDER BY G.CODGRP, M.CODMNU
+            // 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, []);
+            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) {
-            const filtersClause = includeDisabled
+        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)';
-            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
+            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, []);
+            const result = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, query, scopeFilter.params);
             const groupMap = new Map();
-            result.forEach(row => {
-                var _a, _b;
+            result.forEach((row) => {
+                var _a, _b, _c;
                 const converted = Utilities_1.RestUtilities.convertKeysToCamelCase(row);
-                const _c = converted, { menuEnabled, groupEnabled } = _c, menuBase = __rest(_c, ["menuEnabled", "groupEnabled"]);
+                const { menuEnabled, groupEnabled } = converted, menuBase = __rest(converted, ["menuEnabled", "groupEnabled"]);
                 const normalizedGroupKey = (_a = menuBase.codiceGruppo) !== null && _a !== void 0 ? _a : '__UNGROUPED__';
-                const groupEnabledFlag = groupEnabled === undefined ? true : Number(groupEnabled) === 1 || groupEnabled === true;
+                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: menuBase.descrizioneGruppo,
+                        descrizioneGruppo: (_c = menuBase.descrizioneGruppo) !== null && _c !== void 0 ? _c : '',
                         ordineGruppo: menuBase.ordineGruppo,
                         enabled: groupEnabledFlag,
                         menus: [],
@@ -258,107 +517,421 @@ let PermissionService = class PermissionService {
             return groupsArray;
         });
     }
-    getUserRolesAndGrants(codiceUtente) {
+    // -----------------------------------------------------------------------
+    // 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 = ?";
-            let result = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, codiceUtenteQuery, [codiceUtente]);
+            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);
-            result = result.map(Utilities_1.RestUtilities.convertKeysToCamelCase);
-            const isSuperAdmin = result[0].flagSuper;
-            let abilitazioni = [];
-            let ruoli = [];
-            if (isSuperAdmin) {
-                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
-                    INNER JOIN MENU_GRP G ON G.CODGRP = M.CODGRP
-                    WHERE M.FLGENABLED = 1 AND G.FLGENABLED = 1
-                `;
-                abilitazioni = (yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, query, [])
-                    .then(results => results.map(Utilities_1.RestUtilities.convertKeysToCamelCase)));
-            }
-            else {
-                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
-                    INNER JOIN MENU_GRP G ON G.CODGRP = M.CODGRP
-                    WHERE A.CODUTE = ? AND M.FLGENABLED = 1 AND G.FLGENABLED = 1
-                `;
-                abilitazioni = (yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, queryAbilitazioni, [codiceUtente])
-                    .then(results => results.map(Utilities_1.RestUtilities.convertKeysToCamelCase)));
-                const queryRuoli = `
-                    SELECT
-                        R.CODRUO AS codice_ruolo,
-                        R.DESRUO AS descrizione_ruolo,
-                        RM.CODMNU 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
-                    INNER JOIN RUOLI_MNU RM ON R.CODRUO = RM.CODRUO
-                    INNER JOIN MENU M ON RM.CODMNU = M.CODMNU
-                    INNER JOIN MENU_GRP G ON G.CODGRP = M.CODGRP
-                    WHERE RU.CODUTE = ? AND M.FLGENABLED = 1 AND G.FLGENABLED = 1
-                `;
-                let ruoliResult = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, queryRuoli, [codiceUtente]);
-                ruoliResult = ruoliResult.map(Utilities_1.RestUtilities.convertKeysToCamelCase);
-                const ruoliMap = new Map();
-                for (const row of ruoliResult) {
-                    const { codiceRuolo, descrizioneRuolo, codiceMenu, descrizioneMenu, tipoAbilitazione } = row;
-                    if (!ruoliMap.has(codiceRuolo)) {
-                        ruoliMap.set(codiceRuolo, {
-                            codiceRuolo,
-                            descrizioneRuolo: descrizioneRuolo === null || descrizioneRuolo === void 0 ? void 0 : descrizioneRuolo.trim(),
-                            menu: []
-                        });
-                    }
-                    if (codiceMenu) {
-                        ruoliMap.get(codiceRuolo).menu.push({
-                            codiceRuolo: codiceRuolo,
-                            codiceMenu: codiceMenu.trim(),
-                            tipoAbilitazione,
-                        });
-                    }
+            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));
                 }
-                ruoli = Array.from(ruoliMap.values());
-            }
-            // Merge user-specific and role-based permissions
-            const grantsMap = new Map();
-            // Add user-specific permissions
-            for (const abilitazione of abilitazioni) {
-                grantsMap.set(abilitazione.codiceMenu, abilitazione);
-            }
-            // Add role-based permissions if not already present
-            for (const ruolo of ruoli) {
-                for (const menu of ruolo.menu) {
-                    if (!grantsMap.has(menu.codiceMenu)) {
-                        grantsMap.set(menu.codiceMenu, menu);
-                    }
+            }
+            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 grants = Array.from(grantsMap.values());
-            return { abilitazioni, ruoli, grants };
+            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);
         });
     }
 };