emilsoftware-utilities 2.0.0-dev.8 → 2.0.0-dev.81

package/dist/accessi-module/Controllers/UserController.js

@@ -28,42 +28,68 @@ 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 RegisterRequest_1 = require("../Dtos/RegisterRequest");
+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/AuthService/AuthService");
 const EmailService_1 = require("../Services/EmailService/EmailService");
 const UserService_1 = require("../Services/UserService/UserService");
 const jwt_strategy_1 = require("../jwt/jwt.strategy");
 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) {
+    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) {
-        const status = error instanceof common_1.HttpException ? error.getStatus() : common_1.HttpStatus.INTERNAL_SERVER_ERROR;
-        return Utilities_1.RestUtilities.sendErrorMessage(res, error, UserController_1.name, status);
+        // 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) {
+    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) {
+    getUsers(request, res, email, codiceUtente, includeExtensionFields, includeGrants, limit, offset) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                (0, accessControl_1.ensureSuperUser)((0, accessControl_1.getAuthenticatedAccessiUser)(request), 'Solo gli amministratori possono consultare gli utenti.');
-                const filters = { email, codiceUtente };
+                (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) {
@@ -75,7 +101,12 @@ let UserController = UserController_1 = class UserController {
     deleteUser(request, codiceUtente, res) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                (0, accessControl_1.ensureSuperUser)((0, accessControl_1.getAuthenticatedAccessiUser)(request), 'Solo gli amministratori possono eliminare utenti.');
+                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.");
             }
@@ -84,15 +115,110 @@ let UserController = UserController_1 = class UserController {
             }
         });
     }
+    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 {
-                (0, accessControl_1.ensureSuperUser)((0, accessControl_1.getAuthenticatedAccessiUser)(request), 'Solo gli amministratori possono modificare lo stato di registrazione.');
+                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 Error('Il codice utente e\' obbligatorio.');
+                    throw new common_1.BadRequestException('Il codice utente e\' obbligatorio.');
                 if (statoRegistrazione === undefined) {
-                    throw new Error('Lo stato registrazione e\' obbligatorio.');
+                    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}.`);
@@ -104,16 +230,35 @@ let UserController = UserController_1 = class UserController {
     }
     register(request, registrationData, res) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             try {
-                const rateLimitDecision = (0, publicAuthRateLimit_1.checkPublicAuthRateLimit)(this.accessiOptions, 'register', request, [registrationData === null || registrationData === void 0 ? void 0 : registrationData.email]);
+                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,
                 });
-                yield this.emailService.sendPasswordResetEmail(registrationData.email);
-                return Utilities_1.RestUtilities.sendBaseResponse(res, codiceUtente);
+                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;
@@ -121,22 +266,64 @@ let UserController = UserController_1 = class UserController {
             }
         });
     }
+    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.ensureSuperUser)(authenticatedUser, 'Solo gli amministratori possono modificare ruoli, permessi o flag privilegiati.');
+                    (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 Error('Il codice utente nel body non coincide con quello del path.');
+                    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,
+                    allowPrivilegedChanges: authenticatedUser.flagSuper || authenticatedUser.flagAdmin,
                 });
                 return Utilities_1.RestUtilities.sendOKMessage(res, `L'utente ${codiceUtente} e' stato aggiornato con successo.`);
             }
@@ -148,7 +335,11 @@ let UserController = UserController_1 = class UserController {
     setGdpr(request, codiceUtente, res) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                (0, accessControl_1.ensureSelfOrSuperUser)((0, accessControl_1.getAuthenticatedAccessiUser)(request), codiceUtente, 'Puoi impostare il GDPR solo sul tuo utente.');
+                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.`);
             }
@@ -186,26 +377,44 @@ __decorate([
         description: 'Lista utenti recuperata con successo',
         type: GetUsersResponse_1.GetUsersResponse,
     }),
-    (0, swagger_1.ApiResponse)({ status: 401, description: 'Credenziali non valide' }),
+    (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)(jwt_strategy_1.JwtSimpleGuard),
@@ -213,11 +422,13 @@ __decorate([
     __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')),
+    __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]),
+    __metadata("design:paramtypes", [Object, Object, String, Number, Boolean, Boolean, Number, Number]),
     __metadata("design:returntype", Promise)
 ], UserController.prototype, "getUsers", null);
 __decorate([
@@ -230,14 +441,15 @@ __decorate([
         name: 'codiceUtente',
         description: "Codice identificativo dell'utente da eliminare",
         required: true,
-        example: '123',
+        example: 123,
     }),
-    (0, swagger_1.ApiResponse)({ status: 200, description: 'Utente eliminato con successo' }),
+    (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' }),
+    (0, swagger_1.ApiResponse)({ status: 500, description: 'Errore interno del server', type: BaseResponse_1.ErrorResponse }),
     (0, swagger_1.ApiBearerAuth)(),
     (0, common_1.UseGuards)(jwt_strategy_1.JwtSimpleGuard),
     (0, common_1.Delete)('delete-user/:codiceUtente'),
@@ -248,6 +460,115 @@ __decorate([
     __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)(jwt_strategy_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)(jwt_strategy_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)(jwt_strategy_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)(jwt_strategy_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)(jwt_strategy_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',
@@ -256,14 +577,17 @@ __decorate([
     (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)(),
@@ -279,10 +603,11 @@ __decorate([
 __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: RegisterRequest_1.RegisterRequest,
+        type: PublicRegisterRequest_1.PublicRegisterRequest,
         description: "Dati necessari per la registrazione dell'utente",
     }),
     (0, swagger_1.ApiCreatedResponse)({
@@ -292,19 +617,35 @@ __decorate([
     (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, RegisterRequest_1.RegisterRequest, Object]),
+    __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)(jwt_strategy_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',
@@ -314,7 +655,7 @@ __decorate([
         name: 'codiceUtente',
         description: "Codice identificativo dell'utente da aggiornare",
         required: true,
-        example: '123',
+        example: 123,
     }),
     (0, swagger_1.ApiBody)({
         type: UserDto_1.UserDto,
@@ -323,8 +664,11 @@ __decorate([
     (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" }),
+    (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)(jwt_strategy_1.JwtSimpleGuard),
     (0, common_1.Put)('update-user/:codiceUtente'),
@@ -345,13 +689,15 @@ __decorate([
         name: 'codiceUtente',
         description: "Codice identificativo dell'utente che accetta il GDPR",
         required: true,
-        example: '123',
+        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' }),
+    (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)(jwt_strategy_1.JwtSimpleGuard),
     (0, common_1.Patch)('set-gdpr/:codiceUtente'),
@@ -364,9 +710,15 @@ __decorate([
 ], UserController.prototype, "setGdpr", null);
 exports.UserController = UserController = UserController_1 = __decorate([
     (0, swagger_1.ApiTags)('User'),
-    (0, common_1.Controller)('accessi/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])
+        EmailService_1.EmailService,
+        AuthService_1.AuthService])
 ], UserController);
 //# sourceMappingURL=UserController.js.map