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

package/dist/accessi-service/services/user-service/UserService.js

@@ -0,0 +1,837 @@
+"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;
+};
+var UserService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserService = void 0;
+const common_1 = require("@nestjs/common");
+const optionalColumns_1 = require("../../database-updates/optionalColumns");
+const autobind_1 = require("../../../autobind");
+const Orm_1 = require("../../../Orm");
+const Utilities_1 = require("../../../Utilities");
+const Logger_1 = require("../../../Logger");
+const FiltriUtente_1 = require("../../dtos/FiltriUtente");
+const StatoRegistrazione_1 = require("../../dtos/StatoRegistrazione");
+const emailConfiguration_1 = require("../../security/emailConfiguration");
+const sessionRevocation_1 = require("../../security/sessionRevocation");
+const EmailService_1 = require("../email-service/EmailService");
+const FiltriService_1 = require("../filtri-service/FiltriService");
+const PermissionService_1 = require("../permission-service/PermissionService");
+/**
+ * I filtri sono deprecati: tocca la tabella FILTRI solo quando il chiamante invia
+ * esplicitamente almeno uno dei campi legacy. La console non li invia più.
+ */
+function hasFilterPayload(dto) {
+    const values = dto;
+    return Object.keys(FiltriUtente_1.FILTRI_UTENTE_DB_MAPPING).some((key) => values[key] !== undefined);
+}
+let UserService = UserService_1 = class UserService {
+    constructor(accessiOptions, emailService, permissionService, filtriService) {
+        this.accessiOptions = accessiOptions;
+        this.emailService = emailService;
+        this.permissionService = permissionService;
+        this.filtriService = filtriService;
+    }
+    normalizeDatabaseBoolean(value) {
+        return value === true || value === 1 || value === '1';
+    }
+    /**
+     * Revoca best effort delle sessioni dopo un evento che deve invalidare i
+     * token gia emessi. Lo store e opzionale: se non configurato (o non
+     * raggiungibile) l'operazione principale non deve fallire.
+     */
+    revokeSessionsBestEffort(codiceUtente, reason) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield (0, sessionRevocation_1.revokeAccessiUserSessionsIfConfigured)(this.accessiOptions, codiceUtente, reason);
+            }
+            catch (error) {
+                new Logger_1.Logger(UserService_1.name).error(`Revoca sessioni fallita per l'utente ${codiceUtente} (${reason}): ${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
+    }
+    normalizeUserFlags(user) {
+        const normalized = Object.assign(Object.assign({}, user), { flagSuper: this.normalizeDatabaseBoolean(user.flagSuper), flagAdmin: this.normalizeDatabaseBoolean(user.flagAdmin), flagDueFattori: this.normalizeDatabaseBoolean(user.flagDueFattori), passwordlessLoginEnabled: this.normalizeDatabaseBoolean(user.passwordlessLoginEnabled), passwordLoginEnabled: user.passwordLoginEnabled == null || this.normalizeDatabaseBoolean(user.passwordLoginEnabled) });
+        return normalized;
+    }
+    normalizeEmail(email) {
+        if (typeof email !== 'string' || email.trim() === '') {
+            throw new common_1.BadRequestException({ code: 'ACCESSI_EMAIL_REQUIRED', message: "L'email è obbligatoria." });
+        }
+        return email.trim().toLowerCase();
+    }
+    ensureEmailIsAvailable(email, currentUserCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, 'SELECT FIRST 1 CODUTE as codice_utente FROM UTENTI WHERE LOWER(USRNAME) = ?', [email]);
+            const existingUser = result.map(Utilities_1.RestUtilities.convertKeysToCamelCase)[0];
+            if ((existingUser === null || existingUser === void 0 ? void 0 : existingUser.codiceUtente) &&
+                (!currentUserCode || existingUser.codiceUtente !== currentUserCode)) {
+                throw new common_1.ConflictException({ code: 'ACCESSI_EMAIL_ALREADY_EXISTS', message: "L'email è già associata a un utente Accessi." });
+            }
+        });
+    }
+    /**
+     * Legge il minimo profilo autorevole usato da JWT e middleware. Restituisce `null` per utenti inesistenti.
+     * Non usare `UserDto` dal token per decisioni di sicurezza: i flag vengono sempre riletti qui.
+     */
+    getAuthenticatedUserSnapshot(codiceUtente) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!codiceUtente || codiceUtente <= 0) {
+                return null;
+            }
+            const result = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, `
+        SELECT
+          U.CODUTE AS codice_utente,
+          U.USRNAME AS email,
+          U.STAREG AS stato_registrazione,
+          C.FLGSUPER AS flag_super,
+          C.FLGADMIN AS flag_admin
+          , C.FLG2FATT AS flag_due_fattori
+          , C.FLGPWDLESS AS passwordless_login_enabled
+          , COALESCE(C.FLGPASSWORD, 1) AS password_login_enabled
+        FROM UTENTI U
+        LEFT JOIN UTENTI_CONFIG C ON C.CODUTE = U.CODUTE
+        WHERE U.CODUTE = ?
+      `, [codiceUtente]);
+            const user = result.map(Utilities_1.RestUtilities.convertKeysToCamelCase)[0];
+            if (!(user === null || user === void 0 ? void 0 : user.codiceUtente)) {
+                return null;
+            }
+            return {
+                codiceUtente: Number(user.codiceUtente),
+                email: typeof user.email === 'string' ? user.email : undefined,
+                statoRegistrazione: Number(user.statoRegistrazione),
+                flagSuper: this.normalizeDatabaseBoolean(user.flagSuper),
+                flagAdmin: this.normalizeDatabaseBoolean(user.flagAdmin),
+                flagDueFattori: this.normalizeDatabaseBoolean(user.flagDueFattori),
+                passwordlessLoginEnabled: this.normalizeDatabaseBoolean(user.passwordlessLoginEnabled),
+                passwordLoginEnabled: this.normalizeDatabaseBoolean(user.passwordLoginEnabled),
+            };
+        });
+    }
+    /**
+     * True se l'utente indicato e' un admin attivo e nessun altro admin attivo
+     * esiste: rimuovergli il flag admin, bloccarlo o eliminarlo lascerebbe la
+     * console senza amministratori.
+     */
+    isLastActiveAdmin(codiceUtente) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            const snapshot = yield this.getAuthenticatedUserSnapshot(codiceUtente);
+            if (!(snapshot === null || snapshot === void 0 ? void 0 : snapshot.flagAdmin))
+                return false;
+            const rows = (yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, `SELECT COUNT(*) AS TOTAL
+       FROM UTENTI U
+       JOIN UTENTI_CONFIG C ON C.CODUTE = U.CODUTE
+       WHERE COALESCE(C.FLGADMIN, 0) = 1
+         AND COALESCE(U.STAREG, 0) NOT IN (?, ?)`, [StatoRegistrazione_1.StatoRegistrazione.DELETE, StatoRegistrazione_1.StatoRegistrazione.BLOCC], false));
+            const total = Number((_d = (_b = (_a = rows[0]) === null || _a === void 0 ? void 0 : _a.TOTAL) !== null && _b !== void 0 ? _b : (_c = rows[0]) === null || _c === void 0 ? void 0 : _c.total) !== null && _d !== void 0 ? _d : 0) || 0;
+            return total <= 1;
+        });
+    }
+    /** Impedisce di disattivare/eliminare l'ultimo admin attivo (lockout della console). */
+    assertNotLastActiveAdmin(codiceUtente) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (yield this.isLastActiveAdmin(codiceUtente)) {
+                throw new common_1.BadRequestException('Operazione bloccata: questo e l ultimo admin attivo. Promuovi un altro admin prima di disattivarlo o eliminarlo.');
+            }
+        });
+    }
+    /**
+     * Elenca gli utenti con filtri opzionali. Grant e campi estesi sono costosi e vengono caricati soltanto
+     * quando richiesti esplicitamente nelle opzioni; usare filtri puntuali nei flussi di autenticazione.
+     */
+    getUsers(filters, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e;
+            try {
+                const filterColumns = yield (0, optionalColumns_1.getTableColumns)(this.accessiOptions, 'FILTRI');
+                // Paginazione opzionale con limiti sani: il default resta "tutti gli utenti".
+                const limit = Number.isInteger(filters === null || filters === void 0 ? void 0 : filters.limit) && ((_a = filters === null || filters === void 0 ? void 0 : filters.limit) !== null && _a !== void 0 ? _a : 0) > 0
+                    ? Math.min(filters === null || filters === void 0 ? void 0 : filters.limit, 1000)
+                    : undefined;
+                const offset = Number.isInteger(filters === null || filters === void 0 ? void 0 : filters.offset) && ((_b = filters === null || filters === void 0 ? void 0 : filters.offset) !== null && _b !== void 0 ? _b : 0) > 0
+                    ? Math.trunc(filters === null || filters === void 0 ? void 0 : filters.offset)
+                    : 0;
+                const pagination = `${limit !== undefined ? ` FIRST ${limit}` : ''}${offset > 0 ? ` SKIP ${offset}` : ''}`;
+                let query = ` 
+            SELECT${pagination}  
+                U.CODUTE as codice_utente, 
+                U.USRNAME as email, 
+                U.FLGGDPR as flag_gdpr, 
+                U.DATGDPR as data_gdpr, 
+                U.DATINS as data_inserimento, 
+                U.DATSCAPWD as data_scadenza_password, 
+                U.DATLASTLOGIN as data_last_login, 
+                U.STAREG as stato_registrazione, 
+                G.COGNOME as cognome, 
+                G.NOME as nome, 
+                G.AVATAR as avatar, 
+                G.FLG2FATT as flag_due_fattori,
+                G.FLGPWDLESS as passwordless_login_enabled,
+                G.CODLINGUA as codice_lingua,
+                G.CELLULARE as cellulare,
+                G.PAGDEF as pagina_default,
+                G.FLGSUPER as flag_super, 
+                G.FLGADMIN as flag_admin,
+                COALESCE(G.FLGPASSWORD, 1) as password_login_enabled,
+                G.JSON_METADATA as json_metadata,
+                ${(0, optionalColumns_1.optionalColumn)(filterColumns, 'CODDIP', 'F', 'cod_dipendente')},
+                ${(0, optionalColumns_1.optionalColumn)(filterColumns, 'NUMREP', 'F', 'num_rep', true)},
+                ${(0, optionalColumns_1.optionalColumn)(filterColumns, 'IDXPERS', 'F', 'idx_pers', true)},
+                ${(0, optionalColumns_1.optionalColumn)(filterColumns, 'CODCLISUPER', 'F', 'cod_cli_super', true)},
+                ${(0, optionalColumns_1.optionalColumn)(filterColumns, 'CODAGE', 'F', 'cod_age', true)},
+                ${(0, optionalColumns_1.optionalColumn)(filterColumns, 'CODCLICOL', 'F', 'cod_cli_col', true)},
+                ${(0, optionalColumns_1.optionalColumn)(filterColumns, 'CODCLIENTI', 'F', 'cod_clienti', false)},
+                F.TIPFIL AS tip_fil,
+                ${(0, optionalColumns_1.optionalColumn)(filterColumns, 'IDXPOS', 'F', 'idx_postazione', true)}
+            FROM UTENTI U 
+            INNER JOIN UTENTI_CONFIG G ON U.CODUTE = G.CODUTE
+            LEFT JOIN FILTRI F ON F.CODUTE = U.CODUTE
+            WHERE 1=1
+            `;
+                const queryParams = [];
+                if (filters === null || filters === void 0 ? void 0 : filters.email) {
+                    query += ` AND LOWER(U.USRNAME) = ? `;
+                    queryParams.push(filters.email.trim().toLowerCase());
+                }
+                if ((filters === null || filters === void 0 ? void 0 : filters.codiceUtente) !== undefined) {
+                    const codes = (Array.isArray(filters.codiceUtente) ? filters.codiceUtente : [filters.codiceUtente])
+                        .map((value) => Number(value))
+                        .filter((value) => Number.isFinite(value) && value > 0);
+                    if (codes.length === 0) {
+                        return [];
+                    }
+                    query += ` AND U.CODUTE IN (${codes.map(() => '?').join(', ')}) `;
+                    queryParams.push(...codes);
+                }
+                if ((filters === null || filters === void 0 ? void 0 : filters.numRep) !== undefined) {
+                    const reparti = (Array.isArray(filters.numRep) ? filters.numRep : [filters.numRep])
+                        .map((value) => Number(value))
+                        .filter((value) => Number.isFinite(value));
+                    if (reparti.length === 0) {
+                        return [];
+                    }
+                    query += ` AND F.NUMREP IN (${reparti.map(() => '?').join(', ')}) `;
+                    queryParams.push(...reparti);
+                }
+                if ((filters === null || filters === void 0 ? void 0 : filters.codDipendente) !== undefined) {
+                    query += ` AND F.CODDIP = ? `;
+                    queryParams.push(Number(filters.codDipendente));
+                }
+                if ((filters === null || filters === void 0 ? void 0 : filters.tipFil) !== undefined) {
+                    query += ` AND F.TIPFIL = ? `;
+                    queryParams.push(Number(filters.tipFil));
+                }
+                if (filters === null || filters === void 0 ? void 0 : filters.cellulare) {
+                    query += ` AND TRIM(G.CELLULARE) = ? `;
+                    queryParams.push(String(filters.cellulare).trim());
+                }
+                if ((filters === null || filters === void 0 ? void 0 : filters.flagSuper) !== undefined) {
+                    query += filters.flagSuper ? ` AND COALESCE(G.FLGSUPER, 0) <> 0 ` : ` AND COALESCE(G.FLGSUPER, 0) = 0 `;
+                }
+                query += ` ORDER BY U.CODUTE DESC `;
+                let users = (yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, query, queryParams));
+                users = users.map(Utilities_1.RestUtilities.convertKeysToCamelCase).map(user => this.normalizeUserFlags(user));
+                const usersResponse = [];
+                // I campi estensione sono caricati una volta per tabella (non una per utente) in query IN
+                // suddivise in blocchi per non superare i limiti di parametri del driver.
+                const extensionFieldsByUser = (options === null || options === void 0 ? void 0 : options.includeExtensionFields)
+                    ? yield this.loadExtensionFieldsForUsers(users.map((user) => user.codiceUtente))
+                    : undefined;
+                // I grant sono caricati in batch (query IN) invece che utente per utente.
+                const grantsByUser = (options === null || options === void 0 ? void 0 : options.includeGrants)
+                    ? yield this.permissionService.getUsersRolesAndGrants(users.map((user) => user.codiceUtente), options === null || options === void 0 ? void 0 : options.scope)
+                    : undefined;
+                for (const user of users) {
+                    let userGrants;
+                    if (options === null || options === void 0 ? void 0 : options.includeGrants) {
+                        userGrants = grantsByUser === null || grantsByUser === void 0 ? void 0 : grantsByUser.get(user.codiceUtente);
+                    }
+                    let extensionFields;
+                    if (options === null || options === void 0 ? void 0 : options.includeExtensionFields) {
+                        extensionFields = {};
+                        for (const ext of (_c = this.accessiOptions.extensionFieldsOptions) !== null && _c !== void 0 ? _c : []) {
+                            extensionFields[ext.objectKey] = (_e = (_d = extensionFieldsByUser === null || extensionFieldsByUser === void 0 ? void 0 : extensionFieldsByUser.get(ext.objectKey)) === null || _d === void 0 ? void 0 : _d.get(user.codiceUtente)) !== null && _e !== void 0 ? _e : [];
+                        }
+                    }
+                    usersResponse.push({
+                        utente: user,
+                        userGrants,
+                        extensionFields,
+                    });
+                }
+                return usersResponse;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    /** Conteggio utenti con gli stessi filtri di `getUsers`, per la paginazione (header X-Total-Count). */
+    countUsers(filters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const conditions = [];
+            const params = [];
+            if (filters === null || filters === void 0 ? void 0 : filters.email) {
+                conditions.push('LOWER(U.USRNAME) = ?');
+                params.push(filters.email.trim().toLowerCase());
+            }
+            if (filters === null || filters === void 0 ? void 0 : filters.codiceUtente) {
+                conditions.push('U.CODUTE = ?');
+                params.push(filters.codiceUtente);
+            }
+            const query = `SELECT COUNT(*) AS TOTAL FROM UTENTI U INNER JOIN UTENTI_CONFIG G ON U.CODUTE = G.CODUTE WHERE 1=1 ${conditions.map((condition) => `AND ${condition}`).join(' ')}`;
+            const rows = (yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, query, params, false));
+            const row = rows[0];
+            return Number((_b = (_a = row === null || row === void 0 ? void 0 : row.TOTAL) !== null && _a !== void 0 ? _a : row === null || row === void 0 ? void 0 : row.total) !== null && _b !== void 0 ? _b : 0) || 0;
+        });
+    }
+    loadExtensionFieldsForUsers(codiceUtenti) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const byObjectKey = new Map();
+            const extensions = (_a = this.accessiOptions.extensionFieldsOptions) !== null && _a !== void 0 ? _a : [];
+            const uniqueCodes = Array.from(new Set(codiceUtenti));
+            for (const ext of extensions) {
+                const grouped = new Map();
+                for (const chunk of this.chunkArray(uniqueCodes, 500)) {
+                    if (chunk.length === 0) {
+                        continue;
+                    }
+                    const placeholders = chunk.map(() => '?').join(', ');
+                    const rows = (yield Orm_1.Orm.query(ext.databaseOptions, `SELECT ${ext.tableJoinFieldName} AS __joinkey, ${ext.tableFields.join(', ')} FROM ${ext.tableName} WHERE ${ext.tableJoinFieldName} IN (${placeholders})`, chunk)).map(Utilities_1.RestUtilities.convertKeysToCamelCase);
+                    for (const row of rows) {
+                        const { __joinkey } = row, rest = __rest(row, ["__joinkey"]);
+                        const key = Number(__joinkey);
+                        if (!Number.isFinite(key)) {
+                            continue;
+                        }
+                        const bucket = grouped.get(key);
+                        if (bucket) {
+                            bucket.push(rest);
+                        }
+                        else {
+                            grouped.set(key, [rest]);
+                        }
+                    }
+                }
+                byObjectKey.set(ext.objectKey, grouped);
+            }
+            return byObjectKey;
+        });
+    }
+    chunkArray(items, size) {
+        const chunks = [];
+        for (let index = 0; index < items.length; index += size) {
+            chunks.push(items.slice(index, index + size));
+        }
+        return chunks;
+    }
+    /** Cerca il codice interno per email normalizzata. Il chiamante deve gestire il caso senza righe. */
+    getCodiceUtenteByEmail(email) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const query = `SELECT CODUTE as codice_utente FROM UTENTI WHERE LOWER(USRNAME) = ?`;
+                const result = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, query, [
+                    email.trim().toLowerCase(),
+                ]);
+                return result.map(Utilities_1.RestUtilities.convertKeysToCamelCase)[0];
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    /** Recupera il profilo locale usato dal login, compresi filtri Accessi eventualmente presenti. */
+    getUserByEmail(email) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = `
+            SELECT 
+                U.CODUTE AS codice_utente, 
+                U.USRNAME AS email, 
+                U.FLGGDPR AS flag_gdpr,
+                U.DATSCAPWD as data_scadenza_password,
+                U.STAREG AS stato_registrazione, 
+                C.COGNOME AS cognome, 
+                C.NOME AS nome, 
+                C.AVATAR AS avatar, 
+                C.FLG2FATT AS flag_due_fattori,
+                C.FLGPWDLESS AS passwordless_login_enabled,
+                C.CODLINGUA AS codice_lingua, 
+                C.CELLULARE AS cellulare, 
+                C.PAGDEF AS pagina_default,
+                C.FLGSUPER AS flag_super,
+                C.FLGADMIN AS flag_admin,
+                COALESCE(C.FLGPASSWORD, 1) AS password_login_enabled
+            FROM UTENTI U
+            INNER JOIN UTENTI_CONFIG C ON C.CODUTE = U.CODUTE
+            WHERE LOWER(U.USRNAME) = ?
+        `;
+            const utenti = (yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, query, [email]).then((results) => results.map(Utilities_1.RestUtilities.convertKeysToCamelCase)));
+            const user = utenti[0];
+            if (!user)
+                return null;
+            const filtro = (yield this.filtriService.getFiltriUser(user.codiceUtente))[0];
+            if (filtro) {
+                const filterValues = {};
+                Object.entries(FiltriUtente_1.FILTRI_UTENTE_DB_MAPPING).forEach(([key]) => {
+                    if (key in filtro) {
+                        filterValues[key] = filtro[key];
+                    }
+                });
+                Object.assign(user, filterValues);
+            }
+            return this.normalizeUserFlags(user);
+        });
+    }
+    insertUserFilters(codiceUtente, filterData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.filtriService.upsertFiltriUtente(codiceUtente, filterData);
+        });
+    }
+    /**
+     * Crea utente, configurazione e filtri. La registrazione pubblica resta in stato `INVIO` e non puo
+     * impostare privilegi, ruoli o grant; soltanto flussi backend fidati possono usare `allowPrivilegedFields`.
+     */
+    register(registrationData, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const allowPrivilegedFields = (options === null || options === void 0 ? void 0 : options.allowPrivilegedFields) === true;
+                const normalizedEmail = this.normalizeEmail(registrationData.email);
+                if (registrationData.flagDueFattori !== undefined && typeof registrationData.flagDueFattori !== 'boolean') {
+                    throw new common_1.BadRequestException('Il flag due fattori deve essere booleano.');
+                }
+                if (registrationData.flagDueFattori && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(normalizedEmail)) {
+                    throw new common_1.BadRequestException('Per attivare i codici di accesso serve un indirizzo email valido.');
+                }
+                if (!allowPrivilegedFields &&
+                    (registrationData.flagSuper !== undefined ||
+                        registrationData.flagAdmin !== undefined ||
+                        registrationData.flagDueFattori !== undefined ||
+                        registrationData.roles !== undefined ||
+                        registrationData.permissions !== undefined)) {
+                    throw new Error('I campi privilegiati non sono consentiti nella registrazione pubblica.');
+                }
+                yield this.ensureEmailIsAvailable(normalizedEmail);
+                const queryUtenti = `INSERT INTO UTENTI (USRNAME, STAREG) VALUES (?,?) RETURNING CODUTE`;
+                // Public/local registrations keep the historic INVIO state; trusted master or SSO flows may opt into CONF.
+                const paramsUtenti = [normalizedEmail, (_a = options === null || options === void 0 ? void 0 : options.initialState) !== null && _a !== void 0 ? _a : StatoRegistrazione_1.StatoRegistrazione.INVIO];
+                // Utente e configurazione sono creati in un'unica transazione; filtri e assegnazioni restano
+                // fuori perché delegati a servizi dedicati.
+                const codiceUtente = yield Orm_1.Orm.withTransaction(this.accessiOptions.databaseOptions, (transaction) => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    const insertedUsers = yield Orm_1.Orm.transactionQuery(transaction, queryUtenti, paramsUtenti);
+                    const insertedUser = (Array.isArray(insertedUsers) ? insertedUsers[0] : insertedUsers);
+                    const newCodiceUtente = Number((_a = insertedUser === null || insertedUser === void 0 ? void 0 : insertedUser.CODUTE) !== null && _a !== void 0 ? _a : insertedUser === null || insertedUser === void 0 ? void 0 : insertedUser.codute);
+                    if (!newCodiceUtente) {
+                        throw new Error('Creazione utente non riuscita: impossibile recuperare CODUTE.');
+                    }
+                    const utentiConfigFields = ['CODUTE', 'COGNOME', 'NOME'];
+                    const utentiConfigPlaceholders = ['?', '?', '?'];
+                    const utentiConfigParams = [newCodiceUtente, registrationData.cognome, registrationData.nome];
+                    const optionalFields = [
+                        {
+                            key: 'cellulare',
+                            dbField: 'CELLULARE',
+                            transform: (v) => String(v),
+                        },
+                        {
+                            key: 'avatar',
+                            dbField: 'AVATAR',
+                            transform: (v) => String(v),
+                        },
+                        {
+                            key: 'paginaDefault',
+                            dbField: 'PAGDEF',
+                            transform: (v) => String(v),
+                        },
+                        {
+                            key: 'flagDueFattori',
+                            dbField: 'FLG2FATT',
+                            transform: (v) => (v ? 1 : 0),
+                        },
+                    ];
+                    if (allowPrivilegedFields) {
+                        optionalFields.push({
+                            key: 'flagSuper',
+                            dbField: 'FLGSUPER',
+                            transform: (v) => (v ? 1 : 0),
+                        }, {
+                            key: 'flagAdmin',
+                            dbField: 'FLGADMIN',
+                            transform: (v) => (v ? 1 : 0),
+                        });
+                    }
+                    for (const field of optionalFields) {
+                        const value = registrationData[field.key];
+                        if (value !== undefined && value !== null) {
+                            utentiConfigFields.push(field.dbField);
+                            utentiConfigPlaceholders.push('?');
+                            utentiConfigParams.push(field.transform ? field.transform(value) : value);
+                        }
+                    }
+                    const queryUtentiConfig = `INSERT INTO UTENTI_CONFIG (${utentiConfigFields.join(', ')}) VALUES (${utentiConfigPlaceholders.join(', ')})`;
+                    yield Orm_1.Orm.transactionQuery(transaction, queryUtentiConfig, utentiConfigParams);
+                    return newCodiceUtente;
+                }));
+                if (hasFilterPayload(registrationData)) {
+                    yield this.filtriService.upsertFiltriUtente(codiceUtente, registrationData);
+                }
+                if (allowPrivilegedFields && !!registrationData.roles && registrationData.roles.length > 0) {
+                    yield this.permissionService.assignRolesToUser(codiceUtente, registrationData.roles);
+                }
+                if (allowPrivilegedFields &&
+                    !!registrationData.permissions &&
+                    registrationData.permissions.length > 0) {
+                    yield this.permissionService.assignPermissionsToUser(codiceUtente, registrationData.permissions);
+                }
+                return codiceUtente;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    /**
+     * Aggiorna il profilo utente e i filtri. Le modifiche a stato, ruoli, grant e flag amministrativi richiedono
+     * `allowPrivilegedChanges`; gli array ruolo/grant passati in un flusso fidato sostituiscono le assegnazioni.
+     */
+    updateUser(codiceUtente, user, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            try {
+                if (!codiceUtente)
+                    throw new Error('Impossibile aggiornare senza codice utente.');
+                const allowPrivilegedChanges = (options === null || options === void 0 ? void 0 : options.allowPrivilegedChanges) === true;
+                for (const value of [user.flagDueFattori, user.passwordlessLoginEnabled]) {
+                    if (value !== undefined && typeof value !== 'boolean')
+                        throw new common_1.BadRequestException('Le policy di autenticazione devono essere booleane.');
+                }
+                if (!allowPrivilegedChanges &&
+                    (user.statoRegistrazione !== undefined ||
+                        user.flagSuper !== undefined ||
+                        user.flagAdmin !== undefined ||
+                        user.passwordLoginEnabled !== undefined ||
+                        user.passwordlessLoginEnabled !== undefined ||
+                        user.flagDueFattori !== undefined ||
+                        user.roles !== undefined ||
+                        user.permissions !== undefined)) {
+                    throw new Error('Non e consentito modificare campi privilegiati.');
+                }
+                let currentSnapshot;
+                const getCurrentSnapshot = () => __awaiter(this, void 0, void 0, function* () {
+                    if (currentSnapshot === undefined) {
+                        currentSnapshot = yield this.getAuthenticatedUserSnapshot(codiceUtente);
+                    }
+                    if (!currentSnapshot)
+                        throw new common_1.BadRequestException('Utente non trovato.');
+                    return currentSnapshot;
+                });
+                if (user.flagDueFattori !== undefined || user.passwordlessLoginEnabled !== undefined || user.email !== undefined) {
+                    const current = yield getCurrentSnapshot();
+                    const twoFactor = (_a = user.flagDueFattori) !== null && _a !== void 0 ? _a : current.flagDueFattori;
+                    const passwordless = (_b = user.passwordlessLoginEnabled) !== null && _b !== void 0 ? _b : current.passwordlessLoginEnabled;
+                    if (passwordless && !twoFactor)
+                        throw new common_1.BadRequestException('Il login senza password richiede il codice di accesso attivo.');
+                    if (twoFactor && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(((_d = (_c = user.email) !== null && _c !== void 0 ? _c : current.email) !== null && _d !== void 0 ? _d : '').trim())) {
+                        throw new common_1.BadRequestException('Per attivare i codici di accesso serve un indirizzo email valido.');
+                    }
+                }
+                // Ogni modifica a stato o policy di autenticazione deve invalidare i token emessi.
+                let revocationReason;
+                if (user.statoRegistrazione !== undefined
+                    || user.flagDueFattori !== undefined
+                    || user.passwordlessLoginEnabled !== undefined
+                    || user.passwordLoginEnabled !== undefined) {
+                    const before = yield getCurrentSnapshot();
+                    if (user.statoRegistrazione !== undefined && Number(before.statoRegistrazione) !== Number(user.statoRegistrazione)) {
+                        revocationReason = 'user_state_change';
+                    }
+                    else if (user.flagDueFattori !== undefined && Boolean(before.flagDueFattori) !== user.flagDueFattori) {
+                        revocationReason = 'two_factor_policy_change';
+                    }
+                    else if (user.passwordlessLoginEnabled !== undefined
+                        && Boolean(before.passwordlessLoginEnabled) !== user.passwordlessLoginEnabled) {
+                        revocationReason = 'login_policy_change';
+                    }
+                    else if (user.passwordLoginEnabled !== undefined
+                        && Boolean(before.passwordLoginEnabled) !== user.passwordLoginEnabled) {
+                        revocationReason = 'login_policy_change';
+                    }
+                }
+                const utentiUpdates = [];
+                const utentiParams = [];
+                if (user.email !== undefined) {
+                    const normalizedEmail = this.normalizeEmail(user.email);
+                    yield this.ensureEmailIsAvailable(normalizedEmail, codiceUtente);
+                    utentiUpdates.push('usrname = ?');
+                    utentiParams.push(normalizedEmail);
+                }
+                if (user.flagGdpr !== undefined) {
+                    utentiUpdates.push('flggdpr = ?');
+                    utentiParams.push(user.flagGdpr ? 1 : 0);
+                    // Coerenza con set-gdpr: flag e data di accettazione restano allineati.
+                    utentiUpdates.push(user.flagGdpr ? 'datgdpr = CURRENT_DATE' : 'datgdpr = NULL');
+                }
+                if (allowPrivilegedChanges && user.statoRegistrazione !== undefined) {
+                    utentiUpdates.push('stareg = ?');
+                    utentiParams.push(user.statoRegistrazione);
+                }
+                if (allowPrivilegedChanges && user.keyRegistrazione !== undefined) {
+                    utentiUpdates.push('keyreg = ?');
+                    utentiParams.push(user.keyRegistrazione);
+                }
+                if (allowPrivilegedChanges && user.dataScadenzaPassword !== undefined) {
+                    utentiUpdates.push('DATSCAPWD = CAST(? AS DATE)');
+                    utentiParams.push(user.dataScadenzaPassword);
+                }
+                if (utentiUpdates.length > 0) {
+                    const queryUtenti = `UPDATE UTENTI SET ${utentiUpdates.join(', ')} WHERE CODUTE = ?`;
+                    utentiParams.push(codiceUtente);
+                    yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, queryUtenti, utentiParams);
+                }
+                // Completa il processo GDPR: oltre ai flag, registra la riga storica di accettazione
+                // (stessa semantica di set-gdpr). Il trigger UTENTI_GDPR_BI0 riallinea i flag.
+                if (user.flagGdpr === true) {
+                    yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, 'UPDATE OR INSERT INTO UTENTI_GDPR (CODUTE, DATACC, GDPR) VALUES (?, CURRENT_DATE, ?) MATCHING (CODUTE, DATACC)', [codiceUtente, 'true']);
+                }
+                // UPDATE OR INSERT mantiene la scrittura idempotente anche se la riga UTENTI_CONFIG
+                // non esiste ancora: aggiorna solo le colonne fornite, altrimenti la crea.
+                const utentiConfigAssignments = [];
+                const assignConfig = (column, value) => {
+                    utentiConfigAssignments.push({ column, value });
+                };
+                if (user.cognome !== undefined)
+                    assignConfig('cognome', user.cognome);
+                if (user.nome !== undefined)
+                    assignConfig('nome', user.nome);
+                if (user.avatar !== undefined)
+                    assignConfig('avatar', user.avatar);
+                if (user.flagDueFattori !== undefined)
+                    assignConfig('flg2fatt', user.flagDueFattori ? 1 : 0);
+                if (user.passwordlessLoginEnabled !== undefined)
+                    assignConfig('flgpwdless', user.passwordlessLoginEnabled ? 1 : 0);
+                if (user.codiceLingua !== undefined)
+                    assignConfig('codlingua', user.codiceLingua);
+                if (user.cellulare !== undefined)
+                    assignConfig('cellulare', user.cellulare);
+                if (user.paginaDefault !== undefined)
+                    assignConfig('PAGDEF', user.paginaDefault);
+                if (allowPrivilegedChanges && user.flagSuper !== undefined)
+                    assignConfig('flgsuper', user.flagSuper ? 1 : 0);
+                if (allowPrivilegedChanges && user.flagAdmin !== undefined)
+                    assignConfig('FLGADMIN', user.flagAdmin ? 1 : 0);
+                if (allowPrivilegedChanges && user.passwordLoginEnabled !== undefined)
+                    assignConfig('flgpassword', user.passwordLoginEnabled ? 1 : 0);
+                if (user.jsonMetadata !== undefined)
+                    assignConfig('json_metadata', user.jsonMetadata);
+                if (utentiConfigAssignments.length > 0) {
+                    const columns = ['CODUTE', ...utentiConfigAssignments.map((assignment) => assignment.column)];
+                    const values = [codiceUtente, ...utentiConfigAssignments.map((assignment) => assignment.value)];
+                    const queryUtentiConfig = `UPDATE OR INSERT INTO UTENTI_CONFIG (${columns.join(', ')}) VALUES (${columns.map(() => '?').join(', ')}) MATCHING (CODUTE)`;
+                    yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, queryUtentiConfig, values);
+                }
+                if (allowPrivilegedChanges && Array.isArray(user.roles)) {
+                    yield this.permissionService.assignRolesToUser(codiceUtente, user.roles);
+                }
+                if (allowPrivilegedChanges && Array.isArray(user.permissions)) {
+                    yield this.permissionService.assignPermissionsToUser(codiceUtente, user.permissions);
+                }
+                if (hasFilterPayload(user)) {
+                    yield this.filtriService.upsertFiltriUtente(codiceUtente, user);
+                }
+                if (revocationReason) {
+                    yield this.revokeSessionsBestEffort(codiceUtente, revocationReason);
+                }
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    updateUserFilters(codiceUtente, user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.filtriService.upsertFiltriUtente(codiceUtente, user);
+        });
+    }
+    /** Eliminazione logica: imposta lo stato `DELETE` senza cancellare lo storico o i collegamenti SSO. */
+    deleteUser(codiceCliente) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const query = `UPDATE UTENTI SET STAREG = ? WHERE CODUTE = ?`;
+                yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, query, [
+                    StatoRegistrazione_1.StatoRegistrazione.DELETE,
+                    codiceCliente,
+                ]);
+                yield this.revokeSessionsBestEffort(codiceCliente, 'user_soft_delete');
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    /**
+     * Eliminazione definitiva: rimuove l'utente e tutti i record collegati in un'unica
+     * transazione. Operazione distruttiva riservata agli admin (il superutente usa il soft delete).
+     */
+    deleteUserPermanently(codiceUtente) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!codiceUtente)
+                throw new common_1.BadRequestException('Impossibile eliminare senza codice utente.');
+            const rows = yield this.getUsers({ codiceUtente }, { includeExtensionFields: false, includeGrants: false });
+            if (rows.length === 0) {
+                throw new common_1.NotFoundException(`Nessun utente con codice ${codiceUtente}.`);
+            }
+            const params = [codiceUtente];
+            try {
+                yield Orm_1.Orm.executeMultiple(this.accessiOptions.databaseOptions, [
+                    { query: 'DELETE FROM ABILITAZIONI WHERE CODUTE = ?', params },
+                    { query: 'DELETE FROM UTENTI_RUOLI WHERE CODUTE = ?', params },
+                    { query: 'DELETE FROM UTENTI_IDENTITA_EXT WHERE CODUTE = ?', params },
+                    { query: 'DELETE FROM ACCESSI_2FA WHERE CODUTE = ?', params },
+                    { query: 'DELETE FROM FILTRI WHERE CODUTE = ?', params },
+                    { query: 'DELETE FROM UTENTI_CONFIG WHERE CODUTE = ?', params },
+                    { query: 'DELETE FROM UTENTI_PWD WHERE CODUTE = ?', params },
+                    { query: 'DELETE FROM UTENTI_OLDPWD WHERE CODUTE = ?', params },
+                    { query: 'DELETE FROM UTENTI_GDPR WHERE CODUTE = ?', params },
+                    { query: 'DELETE FROM UTENTI WHERE CODUTE = ?', params },
+                ]);
+                yield this.revokeSessionsBestEffort(codiceUtente, 'user_delete');
+            }
+            catch (error) {
+                if (this.isForeignKeyViolation(error)) {
+                    throw new common_1.BadRequestException({
+                        code: 'ACCESSI_USER_DELETE_HAS_REFERENCES',
+                        message: 'L utente ha dati collegati in altre tabelle (per esempio campi estesi del backend): non e possibile eliminarlo definitivamente. Usa "Imposta stato eliminato" (soft delete).',
+                    });
+                }
+                throw error;
+            }
+        });
+    }
+    /** Riconosce una violazione di chiave esterna Firebird (SQLCODE -530/-531 o messaggio) senza esporre SQL. */
+    isForeignKeyViolation(error) {
+        const record = error;
+        const sqlcode = Number(record === null || record === void 0 ? void 0 : record.sqlcode);
+        if (Number.isFinite(sqlcode) && (sqlcode === -530 || sqlcode === -531))
+            return true;
+        const text = `${typeof (record === null || record === void 0 ? void 0 : record.message) === 'string' ? record.message : ''} ${typeof (record === null || record === void 0 ? void 0 : record.code) === 'string' ? record.code : ''}`;
+        return /foreign key|isc_foreign_key|violation of .*constraint|-530/i.test(text);
+    }
+    /** Cambia esplicitamente lo stato di registrazione; usare questa API per blocco, conferma o eliminazione logica. */
+    setStato(codiceCliente, statoRegistrazione) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const query = `UPDATE UTENTI SET STAREG = ? WHERE CODUTE = ?`;
+                yield Orm_1.Orm.execute(this.accessiOptions.databaseOptions, query, [
+                    statoRegistrazione,
+                    codiceCliente,
+                ]);
+                if (statoRegistrazione === StatoRegistrazione_1.StatoRegistrazione.BLOCC
+                    || statoRegistrazione === StatoRegistrazione_1.StatoRegistrazione.DELETE) {
+                    yield this.revokeSessionsBestEffort(codiceCliente, 'user_disabled');
+                }
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    setGdpr(codiceUtente) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield Orm_1.Orm.executeMultiple(this.accessiOptions.databaseOptions, [
+                    { query: 'UPDATE OR INSERT INTO UTENTI_GDPR (CODUTE, DATACC, GDPR) VALUES (?, CURRENT_DATE, ?) MATCHING (CODUTE, DATACC)', params: [codiceUtente, 'true'] },
+                    { query: 'UPDATE UTENTI SET FLGGDPR = 1, DATGDPR = CURRENT_DATE WHERE CODUTE = ?', params: [codiceUtente] },
+                ]);
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    /**
+     * Forza l'invio dell'email di reset password per un utente. Operazione amministrativa.
+     * Richiede un servizio email configurato: altrimenti solleva ACCESSI_EMAIL_NOT_CONFIGURED.
+     */
+    forcePasswordReset(codiceUtente) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            (0, emailConfiguration_1.assertEmailConfigured)(this.accessiOptions);
+            const rows = yield this.getUsers({ codiceUtente });
+            const email = (_b = (_a = rows[0]) === null || _a === void 0 ? void 0 : _a.utente) === null || _b === void 0 ? void 0 : _b.email;
+            if (typeof email !== 'string' || email.trim() === '') {
+                throw new common_1.NotFoundException(`Nessun utente con email per il codice ${codiceUtente}.`);
+            }
+            yield this.emailService.sendPasswordResetEmail(email);
+        });
+    }
+    /**
+     * Forza l'invio dell'email di reset a tutti gli utenti la cui password non e ancora nel formato
+     * moderno (`scrypt$...`), cioe' legacy grezza o `scrypt-legacy` non piu verificabile. Utile quando
+     * la `encryptionKey` storica e perduta. Richiede email configurata. Ritorna quanti utenti hanno
+     * ricevuto l'email.
+     */
+    forcePasswordResetForLegacyPasswords() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, emailConfiguration_1.assertEmailConfigured)(this.accessiOptions);
+            const rows = yield Orm_1.Orm.query(this.accessiOptions.databaseOptions, `SELECT U.CODUTE AS codice_utente, U.USRNAME AS email
+       FROM UTENTI U
+       JOIN UTENTI_PWD P ON P.CODUTE = U.CODUTE
+       WHERE P.PWD IS NOT NULL AND P.PWD NOT STARTING WITH 'scrypt$'`, [], false);
+            let sent = 0;
+            for (const row of rows) {
+                const raw = Utilities_1.RestUtilities.convertKeysToCamelCase(row);
+                const email = typeof raw.email === 'string' ? raw.email.trim() : '';
+                if (email === '')
+                    continue;
+                yield this.emailService.sendPasswordResetEmail(email);
+                sent += 1;
+            }
+            return sent;
+        });
+    }
+};
+exports.UserService = UserService;
+exports.UserService = UserService = UserService_1 = __decorate([
+    autobind_1.autobind,
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)('ACCESSI_OPTIONS')),
+    __metadata("design:paramtypes", [Object, EmailService_1.EmailService,
+        PermissionService_1.PermissionService,
+        FiltriService_1.FiltriService])
+], UserService);
+//# sourceMappingURL=UserService.js.map