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

package/dist/accessi-service/controllers/UserController.js

@@ -0,0 +1,724 @@
+"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 UserController_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserController = void 0;
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const path_1 = require("path");
+const Logger_1 = require("../../Logger");
+const Utilities_1 = require("../../Utilities");
+const BaseResponse_1 = require("../dtos/BaseResponse");
+const GetUsersResponse_1 = require("../dtos/GetUsersResponse");
+const LoginAsDtos_1 = require("../dtos/LoginAsDtos");
+const PublicRegisterRequest_1 = require("../dtos/PublicRegisterRequest");
+const RegisterResponse_1 = require("../dtos/RegisterResponse");
+const RegisterRequest_1 = require("../dtos/RegisterRequest");
+const SetStatoRegistrazione_1 = require("../dtos/SetStatoRegistrazione");
+const SetUserPasswordRequest_1 = require("../dtos/SetUserPasswordRequest");
+const UserDto_1 = require("../dtos/UserDto");
+const AuthService_1 = require("../services/auth-service/AuthService");
+const EmailService_1 = require("../services/email-service/EmailService");
+const UserService_1 = require("../services/user-service/UserService");
+const JwtSimpleGuard_1 = require("../jwt/JwtSimpleGuard");
+const publicAuthRateLimit_1 = require("../security/publicAuthRateLimit");
+const accessControl_1 = require("../security/accessControl");
+const emailConfiguration_1 = require("../security/emailConfiguration");
+const loginAs_1 = require("../security/loginAs");
+const StatoRegistrazione_1 = require("../dtos/StatoRegistrazione");
+let UserController = UserController_1 = class UserController {
+    constructor(accessiOptions, userService, emailService, authService) {
+        this.accessiOptions = accessiOptions;
+        this.userService = userService;
+        this.emailService = emailService;
+        this.authService = authService;
+        this.logger = new Logger_1.Logger(UserController_1.name);
+    }
+    sendControllerError(res, error) {
+        // Lo status viene derivato centralmente da RestUtilities (HttpException o 500).
+        return Utilities_1.RestUtilities.sendErrorMessage(res, error, UserController_1.name);
+    }
+    /**
+     * Verifica che il target esista e che l'attore possa gestirlo (rango attore >=
+     * rango target: ADMIN > SUPER > utente). Restituisce lo snapshot corrente del
+     * target, così i chiamanti possono controllare se e' admin.
+     */
+    ensureManageableTarget(actor, codiceUtente) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const target = yield this.userService.getAuthenticatedUserSnapshot(codiceUtente);
+            if (!target) {
+                throw new common_1.NotFoundException(`Nessun utente con codice ${codiceUtente}.`);
+            }
+            (0, accessControl_1.ensureCanManageTargetUser)(actor, target);
+            return target;
+        });
+    }
+    serveResetPasswordPage(res, _token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return res.sendFile((0, path_1.join)(__dirname, '..', 'views', 'reset-password.html'));
+        });
+    }
+    getUsers(request, res, email, codiceUtente, includeExtensionFields, includeGrants, limit, offset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                (0, accessControl_1.ensureUserManagement)((0, accessControl_1.getAuthenticatedAccessiUser)(request), 'Solo gli amministratori possono consultare gli utenti.');
+                const filters = { email, codiceUtente, limit, offset };
+                const options = {
+                    includeExtensionFields: includeExtensionFields !== null && includeExtensionFields !== void 0 ? includeExtensionFields : true,
+                    includeGrants: includeGrants !== null && includeGrants !== void 0 ? includeGrants : true,
+                };
+                const users = yield this.userService.getUsers(filters, options);
+                const total = yield this.userService.countUsers({ email, codiceUtente });
+                res.setHeader('X-Total-Count', String(total));
+                return Utilities_1.RestUtilities.sendBaseResponse(res, users);
+            }
+            catch (error) {
+                this.logger.error('Errore durante il recupero degli utenti: ', error);
+                return this.sendControllerError(res, error);
+            }
+        });
+    }
+    deleteUser(request, codiceUtente, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const authenticatedUser = (0, accessControl_1.getAuthenticatedAccessiUser)(request);
+                (0, accessControl_1.ensureUserManagement)(authenticatedUser, 'Solo gli amministratori possono eliminare utenti.');
+                const target = yield this.ensureManageableTarget(authenticatedUser, codiceUtente);
+                if (target.flagAdmin) {
+                    yield this.userService.assertNotLastActiveAdmin(codiceUtente);
+                }
+                yield this.userService.deleteUser(codiceUtente);
+                return Utilities_1.RestUtilities.sendOKMessage(res, "L'utente e' stato eliminato con successo.");
+            }
+            catch (error) {
+                return this.sendControllerError(res, error);
+            }
+        });
+    }
+    deleteUserPermanently(request, codiceUtente, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const authenticatedUser = (0, accessControl_1.getAuthenticatedAccessiUser)(request);
+                (0, accessControl_1.ensureAdmin)(authenticatedUser, 'Solo gli admin possono eliminare definitivamente un utente.');
+                if (authenticatedUser.codiceUtente === codiceUtente) {
+                    throw new common_1.BadRequestException('Non puoi eliminare definitivamente il tuo stesso utente.');
+                }
+                const target = yield this.ensureManageableTarget(authenticatedUser, codiceUtente);
+                if (target.flagAdmin) {
+                    yield this.userService.assertNotLastActiveAdmin(codiceUtente);
+                }
+                yield this.userService.deleteUserPermanently(codiceUtente);
+                return Utilities_1.RestUtilities.sendOKMessage(res, "L'utente e' stato eliminato definitivamente.");
+            }
+            catch (error) {
+                return this.sendControllerError(res, error);
+            }
+        });
+    }
+    forcePasswordReset(request, codiceUtente, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const authenticatedUser = (0, accessControl_1.getAuthenticatedAccessiUser)(request);
+                (0, accessControl_1.ensureUserManagement)(authenticatedUser, 'Solo gli amministratori possono forzare il reset password.');
+                yield this.ensureManageableTarget(authenticatedUser, codiceUtente);
+                yield this.userService.forcePasswordReset(codiceUtente);
+                return Utilities_1.RestUtilities.sendOKMessage(res, `Email di reset inviata all utente ${codiceUtente}.`);
+            }
+            catch (error) {
+                return this.sendControllerError(res, error);
+            }
+        });
+    }
+    forcePasswordResetLegacy(request, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                (0, accessControl_1.ensureUserManagement)((0, accessControl_1.getAuthenticatedAccessiUser)(request), 'Solo gli amministratori possono forzare il reset password.');
+                const sent = yield this.userService.forcePasswordResetForLegacyPasswords();
+                return Utilities_1.RestUtilities.sendOKMessage(res, `Email di reset inviata a ${sent} utenti con password legacy.`);
+            }
+            catch (error) {
+                return this.sendControllerError(res, error);
+            }
+        });
+    }
+    createLoginAsUrl(request, codiceUtente, body, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const authenticatedUser = (0, accessControl_1.getAuthenticatedAccessiUser)(request);
+                (0, accessControl_1.ensureUserManagement)(authenticatedUser, 'Solo superutenti e admin possono generare un accesso temporaneo.');
+                // Stessa gerarchia della gestione utenti: un superutente non impersona un admin.
+                yield this.ensureManageableTarget(authenticatedUser, codiceUtente);
+                const loginResult = yield this.authService.getLoginResultForUser(codiceUtente);
+                const issued = this.authService.createLoginAsToken(loginResult.utente, authenticatedUser);
+                const loginUrl = (0, loginAs_1.buildLoginAsUrl)(body === null || body === void 0 ? void 0 : body.url, issued.value);
+                const expiresInSeconds = Number(issued.expiresIn);
+                if (!Number.isFinite(expiresInSeconds) || expiresInSeconds <= 0) {
+                    throw new Error('Token Login as emesso senza una scadenza valida.');
+                }
+                const expiresAt = new Date(Date.now() + expiresInSeconds * 1000).toISOString();
+                this.logger.info(`Login as generato: attore=${authenticatedUser.codiceUtente}, target=${codiceUtente}, host=${new URL(loginUrl).host}`);
+                return Utilities_1.RestUtilities.sendBaseResponse(res, {
+                    loginUrl,
+                    token: issued.value,
+                    expiresInSeconds,
+                    expiresAt,
+                });
+            }
+            catch (error) {
+                return this.sendControllerError(res, error);
+            }
+        });
+    }
+    setUserPassword(request, codiceUtente, body, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const authenticatedUser = (0, accessControl_1.getAuthenticatedAccessiUser)(request);
+                (0, accessControl_1.ensureUserManagement)(authenticatedUser, 'Solo gli amministratori possono impostare la password di un utente.');
+                yield this.ensureManageableTarget(authenticatedUser, codiceUtente);
+                yield this.authService.setPassword(codiceUtente, body.newPassword);
+                return Utilities_1.RestUtilities.sendOKMessage(res, `Password dell utente ${codiceUtente} aggiornata.`);
+            }
+            catch (error) {
+                return this.sendControllerError(res, error);
+            }
+        });
+    }
+    setStatoRegistrazione(request, body, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const authenticatedUser = (0, accessControl_1.getAuthenticatedAccessiUser)(request);
+                (0, accessControl_1.ensureUserManagement)(authenticatedUser, 'Solo gli amministratori possono modificare lo stato di registrazione.');
+                const { codiceUtente, statoRegistrazione } = body;
+                if (!codiceUtente)
+                    throw new common_1.BadRequestException('Il codice utente e\' obbligatorio.');
+                if (statoRegistrazione === undefined) {
+                    throw new common_1.BadRequestException('Lo stato registrazione e\' obbligatorio.');
+                }
+                const target = yield this.ensureManageableTarget(authenticatedUser, codiceUtente);
+                const disabling = statoRegistrazione === StatoRegistrazione_1.StatoRegistrazione.DELETE
+                    || statoRegistrazione === StatoRegistrazione_1.StatoRegistrazione.BLOCC;
+                if (target.flagAdmin && disabling) {
+                    yield this.userService.assertNotLastActiveAdmin(codiceUtente);
+                }
+                yield this.userService.setStato(codiceUtente, statoRegistrazione);
+                return Utilities_1.RestUtilities.sendOKMessage(res, `Lo stato dell'utente ${codiceUtente} e' stato aggiornato a ${statoRegistrazione}.`);
+            }
+            catch (error) {
+                return this.sendControllerError(res, error);
+            }
+        });
+    }
+    register(request, registrationData, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                if (((_a = this.accessiOptions.publicRegistration) === null || _a === void 0 ? void 0 : _a.enabled) !== true) {
+                    throw new common_1.HttpException('La registrazione pubblica e disabilitata. Un amministratore deve creare l utente.', common_1.HttpStatus.FORBIDDEN);
+                }
+                const rateLimitDecision = yield (0, publicAuthRateLimit_1.checkPublicAuthRateLimit)(this.accessiOptions, 'register', request, [registrationData === null || registrationData === void 0 ? void 0 : registrationData.email]);
+                if (!rateLimitDecision.allowed) {
+                    return (0, publicAuthRateLimit_1.sendPublicAuthRateLimitExceeded)(res, rateLimitDecision.retryAfterSeconds);
+                }
+                (0, emailConfiguration_1.assertEmailConfigured)(this.accessiOptions);
+                const codiceUtente = yield this.userService.register(registrationData, {
+                    allowPrivilegedFields: false,
+                });
+                try {
+                    yield this.emailService.sendPasswordResetEmail(registrationData.email);
+                }
+                catch (emailError) {
+                    try {
+                        yield this.userService.deleteUserPermanently(codiceUtente);
+                    }
+                    catch (rollbackError) {
+                        this.logger.error(`Rollback registrazione utente ${codiceUtente} non riuscita: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`);
+                    }
+                    throw new common_1.BadRequestException({
+                        code: 'ACCESSI_USER_INVITE_EMAIL_FAILED',
+                        message: `Registrazione non completata: invio email non riuscito (${emailError instanceof Error ? emailError.message : String(emailError)}). Riprova piu tardi.`,
+                    });
+                }
+                return Utilities_1.RestUtilities.sendBaseResponse(res, codiceUtente, common_1.HttpStatus.CREATED);
+            }
+            catch (error) {
+                const status = error instanceof common_1.HttpException ? error.getStatus() : common_1.HttpStatus.BAD_REQUEST;
+                return Utilities_1.RestUtilities.sendErrorMessage(res, error, UserController_1.name, status);
+            }
+        });
+    }
+    createManagedUser(request, registrationData, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const authenticatedUser = (0, accessControl_1.getAuthenticatedAccessiUser)(request);
+                (0, accessControl_1.ensureUserManagement)(authenticatedUser, 'Solo gli amministratori possono creare utenti.');
+                (0, accessControl_1.ensurePrivilegeFlagChanges)(authenticatedUser, registrationData);
+                // Fail-fast prima di scrivere: senza SMTP non si crea un utente orfano.
+                (0, emailConfiguration_1.assertEmailConfigured)(this.accessiOptions);
+                const codiceUtente = yield this.userService.register(registrationData, { allowPrivilegedFields: true });
+                try {
+                    yield this.emailService.sendPasswordResetEmail(registrationData.email, registrationData.htmlMail);
+                }
+                catch (emailError) {
+                    // L'invio e' esterno: se fallisce annulliamo la creazione per non lasciare un utente
+                    // senza password e senza email di invito (rollback best-effort).
+                    try {
+                        yield this.userService.deleteUserPermanently(codiceUtente);
+                    }
+                    catch (rollbackError) {
+                        this.logger.error(`Rollback creazione utente ${codiceUtente} non riuscita: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`);
+                    }
+                    throw new common_1.BadRequestException({
+                        code: 'ACCESSI_USER_INVITE_EMAIL_FAILED',
+                        message: `Utente non creato: invio email di invito non riuscito (${emailError instanceof Error ? emailError.message : String(emailError)}). Riprova oppure crea l utente e imposta la password manualmente.`,
+                    });
+                }
+                return Utilities_1.RestUtilities.sendBaseResponse(res, codiceUtente, common_1.HttpStatus.CREATED);
+            }
+            catch (error) {
+                return this.sendControllerError(res, error);
+            }
+        });
+    }
+    updateUtente(request, codiceUtente, user, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const authenticatedUser = (0, accessControl_1.getAuthenticatedAccessiUser)(request);
+                const isPrivilegedUpdate = (0, accessControl_1.hasPrivilegedUserChanges)(user);
+                const isSelf = authenticatedUser.codiceUtente === codiceUtente;
+                // ADMIN > SUPER: un superutente non puo' toccare un admin. Self sempre consentito.
+                if (!isSelf) {
+                    yield this.ensureManageableTarget(authenticatedUser, codiceUtente);
+                }
+                if (isPrivilegedUpdate) {
+                    (0, accessControl_1.ensureUserManagement)(authenticatedUser, 'Solo gli amministratori possono modificare ruoli, permessi o flag privilegiati.');
+                    (0, accessControl_1.ensurePrivilegeFlagChanges)(authenticatedUser, user);
+                    if (user.flagAdmin === false) {
+                        yield this.userService.assertNotLastActiveAdmin(codiceUtente);
+                    }
+                }
+                else {
+                    (0, accessControl_1.ensureSelfOrSuperUser)(authenticatedUser, codiceUtente, 'Puoi modificare solo il tuo profilo.');
+                }
+                if (user.codiceUtente !== undefined && user.codiceUtente !== codiceUtente) {
+                    throw new common_1.BadRequestException('Il codice utente nel body non coincide con quello del path.');
+                }
+                yield this.userService.updateUser(codiceUtente, user, {
+                    allowPrivilegedChanges: authenticatedUser.flagSuper || authenticatedUser.flagAdmin,
+                });
+                return Utilities_1.RestUtilities.sendOKMessage(res, `L'utente ${codiceUtente} e' stato aggiornato con successo.`);
+            }
+            catch (error) {
+                return this.sendControllerError(res, error);
+            }
+        });
+    }
+    setGdpr(request, codiceUtente, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const authenticatedUser = (0, accessControl_1.getAuthenticatedAccessiUser)(request);
+                (0, accessControl_1.ensureSelfOrSuperUser)(authenticatedUser, codiceUtente, 'Puoi impostare il GDPR solo sul tuo utente.');
+                if (authenticatedUser.codiceUtente !== codiceUtente) {
+                    yield this.ensureManageableTarget(authenticatedUser, codiceUtente);
+                }
+                yield this.userService.setGdpr(codiceUtente);
+                return Utilities_1.RestUtilities.sendOKMessage(res, `L'utente ${codiceUtente} ha accettato il GDPR.`);
+            }
+            catch (error) {
+                return this.sendControllerError(res, error);
+            }
+        });
+    }
+};
+exports.UserController = UserController;
+__decorate([
+    (0, swagger_1.ApiOperation)({
+        summary: 'Serve la pagina di reset password',
+        operationId: 'serveResetPasswordPageUser',
+    }),
+    (0, swagger_1.ApiParam)({
+        name: 'token',
+        description: 'Token per il reset della password',
+        required: true,
+    }),
+    (0, common_1.Get)('reset-password/:token'),
+    __param(0, (0, common_1.Res)()),
+    __param(1, (0, common_1.Param)('token')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
+], UserController.prototype, "serveResetPasswordPage", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({
+        summary: 'Recupera la lista degli utenti',
+        operationId: 'getUsers',
+    }),
+    (0, swagger_1.ApiResponse)({
+        status: 200,
+        description: 'Lista utenti recuperata con successo',
+        type: GetUsersResponse_1.GetUsersResponse,
+    }),
+    (0, swagger_1.ApiResponse)({ status: 401, description: 'Credenziali non valide', type: BaseResponse_1.ErrorResponse }),
+    (0, swagger_1.ApiResponse)({ status: 403, description: 'Operazione non autorizzata', type: BaseResponse_1.ErrorResponse }),
+    (0, swagger_1.ApiResponse)({ status: 500, description: 'Errore interno del server', type: BaseResponse_1.ErrorResponse }),
+    (0, swagger_1.ApiQuery)({
+        name: 'email',
+        required: false,
+        description: "Email dell'utente da cercare",
+        type: String,
+    }),
+    (0, swagger_1.ApiQuery)({
+        name: 'codiceUtente',
+        required: false,
+        description: "Codice dell'utente da cercare",
+        type: Number,
+    }),
+    (0, swagger_1.ApiQuery)({
+        name: 'includeExtensionFields',
+        required: false,
+        description: 'Includi extension fields',
+        type: Boolean,
+    }),
+    (0, swagger_1.ApiQuery)({
+        name: 'includeGrants',
+        required: false,
+        description: 'Includi permessi',
+        type: Boolean,
+    }),
+    (0, swagger_1.ApiQuery)({
+        name: 'limit',
+        required: false,
+        description: 'Numero massimo di utenti restituiti (1-1000). Omesso = tutti.',
+        type: Number,
+    }),
+    (0, swagger_1.ApiQuery)({
+        name: 'offset',
+        required: false,
+        description: 'Numero di utenti da saltare (paginazione).',
+        type: Number,
+    }),
+    (0, swagger_1.ApiBearerAuth)(),
+    (0, common_1.UseGuards)(JwtSimpleGuard_1.JwtSimpleGuard),
+    (0, common_1.Get)('get-users'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Res)()),
+    __param(2, (0, common_1.Query)('email')),
+    __param(3, (0, common_1.Query)('codiceUtente', new common_1.ParseIntPipe({ optional: true }))),
+    __param(4, (0, common_1.Query)('includeExtensionFields', new common_1.ParseBoolPipe({ optional: true }))),
+    __param(5, (0, common_1.Query)('includeGrants', new common_1.ParseBoolPipe({ optional: true }))),
+    __param(6, (0, common_1.Query)('limit', new common_1.ParseIntPipe({ optional: true }))),
+    __param(7, (0, common_1.Query)('offset', new common_1.ParseIntPipe({ optional: true }))),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, String, Number, Boolean, Boolean, Number, Number]),
+    __metadata("design:returntype", Promise)
+], UserController.prototype, "getUsers", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({
+        summary: 'Elimina un utente',
+        operationId: 'deleteUser',
+        description: 'Imposta lo stato di un utente a eliminato senza rimuovere i record.',
+    }),
+    (0, swagger_1.ApiParam)({
+        name: 'codiceUtente',
+        description: "Codice identificativo dell'utente da eliminare",
+        required: true,
+        example: 123,
+    }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: 'Utente eliminato con successo', type: BaseResponse_1.ActionResponse }),
+    (0, swagger_1.ApiResponse)({
+        status: 400,
+        description: 'Errore nei parametri della richiesta',
+        type: BaseResponse_1.ErrorResponse,
+    }),
+    (0, swagger_1.ApiResponse)({ status: 500, description: 'Errore interno del server', type: BaseResponse_1.ErrorResponse }),
+    (0, swagger_1.ApiBearerAuth)(),
+    (0, common_1.UseGuards)(JwtSimpleGuard_1.JwtSimpleGuard),
+    (0, common_1.Delete)('delete-user/:codiceUtente'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Param)('codiceUtente', common_1.ParseIntPipe)),
+    __param(2, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Number, Object]),
+    __metadata("design:returntype", Promise)
+], UserController.prototype, "deleteUser", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({
+        summary: 'Elimina definitivamente un utente',
+        operationId: 'deleteUserPermanently',
+        description: 'Rimuove l utente e tutti i record collegati. Operazione distruttiva riservata agli admin.',
+    }),
+    (0, swagger_1.ApiParam)({
+        name: 'codiceUtente',
+        description: "Codice identificativo dell'utente da eliminare definitivamente",
+        required: true,
+        example: 123,
+    }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: 'Utente eliminato definitivamente', type: BaseResponse_1.ActionResponse }),
+    (0, swagger_1.ApiResponse)({ status: 400, description: 'Errore nei parametri della richiesta', type: BaseResponse_1.ErrorResponse }),
+    (0, swagger_1.ApiResponse)({ status: 403, description: 'Operazione non autorizzata', type: BaseResponse_1.ErrorResponse }),
+    (0, swagger_1.ApiResponse)({ status: 404, description: 'Utente non trovato', type: BaseResponse_1.ErrorResponse }),
+    (0, swagger_1.ApiResponse)({ status: 500, description: 'Errore interno del server', type: BaseResponse_1.ErrorResponse }),
+    (0, swagger_1.ApiBearerAuth)(),
+    (0, common_1.UseGuards)(JwtSimpleGuard_1.JwtSimpleGuard),
+    (0, common_1.Delete)('delete-user-permanent/:codiceUtente'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Param)('codiceUtente', common_1.ParseIntPipe)),
+    __param(2, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Number, Object]),
+    __metadata("design:returntype", Promise)
+], UserController.prototype, "deleteUserPermanently", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({
+        summary: 'Forza l invio dell email di reset password a un utente',
+        operationId: 'forcePasswordReset',
+        description: 'Riservato al superutente. Richiede un servizio email configurato; altrimenti risponde con ACCESSI_EMAIL_NOT_CONFIGURED.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'codiceUtente', description: 'Codice identificativo dell utente', required: true, example: 123, type: Number }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: 'Email di reset inviata', type: BaseResponse_1.ActionResponse }),
+    (0, swagger_1.ApiResponse)({ status: 400, description: 'Servizio email non configurato', type: BaseResponse_1.ErrorResponse }),
+    (0, swagger_1.ApiResponse)({ status: 404, description: 'Utente non trovato', type: BaseResponse_1.ErrorResponse }),
+    (0, swagger_1.ApiBearerAuth)(),
+    (0, common_1.UseGuards)(JwtSimpleGuard_1.JwtSimpleGuard),
+    (0, common_1.Post)('force-password-reset/:codiceUtente'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Param)('codiceUtente', common_1.ParseIntPipe)),
+    __param(2, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Number, Object]),
+    __metadata("design:returntype", Promise)
+], UserController.prototype, "forcePasswordReset", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({
+        summary: 'Forza il reset password per tutti gli utenti con password legacy',
+        operationId: 'forcePasswordResetLegacy',
+        description: 'Riservato al superutente. Invia l email di reset a tutti gli utenti la cui password non e ancora nel formato moderno. Richiede un servizio email configurato.',
+    }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: 'Email di reset inviate', type: BaseResponse_1.ActionResponse }),
+    (0, swagger_1.ApiResponse)({ status: 400, description: 'Servizio email non configurato', type: BaseResponse_1.ErrorResponse }),
+    (0, swagger_1.ApiBearerAuth)(),
+    (0, common_1.UseGuards)(JwtSimpleGuard_1.JwtSimpleGuard),
+    (0, common_1.Post)('force-password-reset-legacy'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], UserController.prototype, "forcePasswordResetLegacy", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({
+        summary: 'Genera un URL di accesso temporaneo come un altro utente',
+        operationId: 'createLoginAsUrl',
+        description: 'Riservato a superutenti e admin (con la gerarchia ADMIN > SUPER). Genera un token per l utente target, con la stessa durata della sessione Accessi standard (jwtOptions.expiresIn), e lo allega all URL indicato come query parameter loginAsToken. Il token e una credenziale: non condividerlo e non registrarlo. Da quel momento l applicazione di destinazione decide come consumarlo.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'codiceUtente', description: 'Utente da impersonare', required: true, example: 123, type: Number }),
+    (0, swagger_1.ApiBody)({ type: LoginAsDtos_1.LoginAsRequest }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: 'URL di accesso temporaneo generato', type: LoginAsDtos_1.LoginAsResponse }),
+    (0, swagger_1.ApiResponse)({ status: 400, description: 'URL non valido', type: BaseResponse_1.ErrorResponse }),
+    (0, swagger_1.ApiResponse)({ status: 403, description: 'Operazione non autorizzata', type: BaseResponse_1.ErrorResponse }),
+    (0, swagger_1.ApiResponse)({ status: 404, description: 'Utente non trovato', type: BaseResponse_1.ErrorResponse }),
+    (0, swagger_1.ApiBearerAuth)(),
+    (0, common_1.UseGuards)(JwtSimpleGuard_1.JwtSimpleGuard),
+    (0, common_1.Post)('login-as/:codiceUtente'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Param)('codiceUtente', common_1.ParseIntPipe)),
+    __param(2, (0, common_1.Body)()),
+    __param(3, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Number, LoginAsDtos_1.LoginAsRequest, Object]),
+    __metadata("design:returntype", Promise)
+], UserController.prototype, "createLoginAsUrl", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({
+        summary: 'Imposta direttamente la password di un utente',
+        operationId: 'setUserPassword',
+        description: 'Riservato agli amministratori. Hasha la password, aggiorna la scadenza secondo la policy e non invia email.',
+    }),
+    (0, swagger_1.ApiParam)({ name: 'codiceUtente', description: 'Codice identificativo dell utente', required: true, example: 123, type: Number }),
+    (0, swagger_1.ApiBody)({ type: SetUserPasswordRequest_1.SetUserPasswordRequest }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: 'Password aggiornata', type: BaseResponse_1.ActionResponse }),
+    (0, swagger_1.ApiResponse)({ status: 400, description: 'Password non valida', type: BaseResponse_1.ErrorResponse }),
+    (0, swagger_1.ApiResponse)({ status: 403, description: 'Operazione non autorizzata', type: BaseResponse_1.ErrorResponse }),
+    (0, swagger_1.ApiBearerAuth)(),
+    (0, common_1.UseGuards)(JwtSimpleGuard_1.JwtSimpleGuard),
+    (0, common_1.Post)('set-password/:codiceUtente'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Param)('codiceUtente', common_1.ParseIntPipe)),
+    __param(2, (0, common_1.Body)()),
+    __param(3, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Number, SetUserPasswordRequest_1.SetUserPasswordRequest, Object]),
+    __metadata("design:returntype", Promise)
+], UserController.prototype, "setUserPassword", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({
+        summary: 'Imposta lo stato di registrazione di un utente',
+        operationId: 'setStatoRegistrazione',
+    }),
+    (0, swagger_1.ApiResponse)({
+        status: 200,
+        description: 'Stato registrazione aggiornato con successo',
+        type: BaseResponse_1.ActionResponse,
+    }),
+    (0, swagger_1.ApiResponse)({
+        status: 400,
+        description: 'Errore nei parametri della richiesta',
+        type: BaseResponse_1.ErrorResponse,
+    }),
+    (0, swagger_1.ApiResponse)({
+        status: 500,
+        description: 'Errore interno del server',
+        type: BaseResponse_1.ErrorResponse,
+    }),
+    (0, swagger_1.ApiBody)({ type: SetStatoRegistrazione_1.SetStatoRegistrazioneDto }),
+    (0, swagger_1.ApiBearerAuth)(),
+    (0, common_1.UseGuards)(JwtSimpleGuard_1.JwtSimpleGuard),
+    (0, common_1.Post)('set-stato'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Body)()),
+    __param(2, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, SetStatoRegistrazione_1.SetStatoRegistrazioneDto, Object]),
+    __metadata("design:returntype", Promise)
+], UserController.prototype, "setStatoRegistrazione", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({
+        summary: 'Registra un nuovo utente',
+        description: 'Disponibile soltanto quando publicRegistration.enabled e true. Per utenti SSO usare il provisioning master nel tag Federated authentication.',
+        operationId: 'register',
+    }),
+    (0, swagger_1.ApiBody)({
+        type: PublicRegisterRequest_1.PublicRegisterRequest,
+        description: "Dati necessari per la registrazione dell'utente",
+    }),
+    (0, swagger_1.ApiCreatedResponse)({
+        description: 'Utente registrato con successo. Restituisce il codice utente e invia una mail di reset password.',
+        type: RegisterResponse_1.RegisterResponse,
+    }),
+    (0, swagger_1.ApiResponse)({
+        status: common_1.HttpStatus.BAD_REQUEST,
+        description: 'Errore nella registrazione.',
+        type: BaseResponse_1.ErrorResponse,
+    }),
+    (0, swagger_1.ApiResponse)({
+        status: common_1.HttpStatus.INTERNAL_SERVER_ERROR,
+        description: 'Errore interno del server durante la registrazione o l\'invio email.',
+        type: BaseResponse_1.ErrorResponse,
+    }),
+    (0, common_1.Post)('register'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Body)()),
+    __param(2, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, PublicRegisterRequest_1.PublicRegisterRequest, Object]),
+    __metadata("design:returntype", Promise)
+], UserController.prototype, "register", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({ summary: 'Crea un utente locale da amministrazione', operationId: 'createManagedUser', description: 'Riservato a superutente. Crea un utente in attesa di impostazione password e invia la mail di reset.' }),
+    (0, swagger_1.ApiBody)({ type: RegisterRequest_1.RegisterRequest }),
+    (0, swagger_1.ApiCreatedResponse)({ type: RegisterResponse_1.RegisterResponse }),
+    (0, swagger_1.ApiBearerAuth)(),
+    (0, common_1.UseGuards)(JwtSimpleGuard_1.JwtSimpleGuard),
+    (0, common_1.Post)('create-managed-user'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Body)()),
+    __param(2, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, RegisterRequest_1.RegisterRequest, Object]),
+    __metadata("design:returntype", Promise)
+], UserController.prototype, "createManagedUser", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({
+        summary: 'Aggiorna un utente esistente',
+        operationId: 'updateUtente',
+    }),
+    (0, swagger_1.ApiParam)({
+        name: 'codiceUtente',
+        description: "Codice identificativo dell'utente da aggiornare",
+        required: true,
+        example: 123,
+    }),
+    (0, swagger_1.ApiBody)({
+        type: UserDto_1.UserDto,
+        description: "Dati aggiornati dell'utente",
+    }),
+    (0, swagger_1.ApiResponse)({
+        status: common_1.HttpStatus.OK,
+        description: 'Utente aggiornato con successo',
+        type: BaseResponse_1.ActionResponse,
+    }),
+    (0, swagger_1.ApiResponse)({ status: 400, description: "Errore nell'aggiornamento", type: BaseResponse_1.ErrorResponse }),
+    (0, swagger_1.ApiResponse)({ status: 403, description: 'Operazione non autorizzata', type: BaseResponse_1.ErrorResponse }),
+    (0, swagger_1.ApiResponse)({ status: 500, description: 'Errore interno del server', type: BaseResponse_1.ErrorResponse }),
+    (0, swagger_1.ApiBearerAuth)(),
+    (0, common_1.UseGuards)(JwtSimpleGuard_1.JwtSimpleGuard),
+    (0, common_1.Put)('update-user/:codiceUtente'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Param)('codiceUtente', common_1.ParseIntPipe)),
+    __param(2, (0, common_1.Body)()),
+    __param(3, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Number, UserDto_1.UserDto, Object]),
+    __metadata("design:returntype", Promise)
+], UserController.prototype, "updateUtente", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({
+        summary: 'Imposta il consenso GDPR per un utente',
+        operationId: 'setGdpr',
+    }),
+    (0, swagger_1.ApiParam)({
+        name: 'codiceUtente',
+        description: "Codice identificativo dell'utente che accetta il GDPR",
+        required: true,
+        example: 123,
+    }),
+    (0, swagger_1.ApiResponse)({
+        status: 200,
+        description: 'Consenso GDPR impostato con successo',
+        type: BaseResponse_1.ActionResponse,
+    }),
+    (0, swagger_1.ApiResponse)({ status: 400, description: 'Errore nella richiesta', type: BaseResponse_1.ErrorResponse }),
+    (0, swagger_1.ApiResponse)({ status: 403, description: 'Operazione non autorizzata', type: BaseResponse_1.ErrorResponse }),
+    (0, swagger_1.ApiBearerAuth)(),
+    (0, common_1.UseGuards)(JwtSimpleGuard_1.JwtSimpleGuard),
+    (0, common_1.Patch)('set-gdpr/:codiceUtente'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Param)('codiceUtente', common_1.ParseIntPipe)),
+    __param(2, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Number, Object]),
+    __metadata("design:returntype", Promise)
+], UserController.prototype, "setGdpr", null);
+exports.UserController = UserController = UserController_1 = __decorate([
+    (0, swagger_1.ApiTags)('User'),
+    (0, common_1.Controller)('accessi/user')
+    /**
+     * Gestione utenti: la registrazione pubblica e opt-in, mentre creazione, stato e profili privilegiati
+     * richiedono un superutente Accessi. Le API restituiscono sempre il wrapper `BaseResponse` storico.
+     */
+    ,
+    __param(0, (0, common_1.Inject)('ACCESSI_OPTIONS')),
+    __metadata("design:paramtypes", [Object, UserService_1.UserService,
+        EmailService_1.EmailService,
+        AuthService_1.AuthService])
+], UserController);
+//# sourceMappingURL=UserController.js.map