emilsoftware-utilities 1.3.97 → 1.3.98

package/dist/accessi-module/AccessiModule.js

@@ -17,6 +17,7 @@ const UserService_1 = require("./Services/UserService/UserService");
 const EmailController_1 = require("./Controllers/EmailController");
 const AuthController_1 = require("./Controllers/AuthController");
 const PermissionController_1 = require("./Controllers/PermissionController");
+const UserController_1 = require("./Controllers/UserController");
 let AccessiModule = AccessiModule_1 = class AccessiModule {
     static forRoot(options) {
         return {
@@ -39,7 +40,7 @@ exports.AccessiModule = AccessiModule;
 exports.AccessiModule = AccessiModule = AccessiModule_1 = __decorate([
     (0, common_1.Global)(),
     (0, common_1.Module)({
-        controllers: [AccessiController_1.AccessiController, EmailController_1.EmailController, AuthController_1.AuthController, PermissionController_1.PermissionController],
+        controllers: [AccessiController_1.AccessiController, EmailController_1.EmailController, AuthController_1.AuthController, PermissionController_1.PermissionController, UserController_1.UserController],
         providers: [AuthService_1.AuthService, UserService_1.UserService, EmailService_1.EmailService, PermissionService_1.PermissionService],
         exports: [AuthService_1.AuthService, UserService_1.UserService, EmailService_1.EmailService, PermissionService_1.PermissionService],
     })

package/dist/accessi-module/Controllers/AccessiController.d.ts

@@ -4,7 +4,7 @@ import { AuthService } from '../Services/AuthService/AuthService';
 import { PermissionService } from '../Services/PermissionService/PermissionService';
 import { UserService } from '../Services/UserService/UserService';
 import { EmailService } from '../Services/EmailService/EmailService';
-import { IUser } from '../Services/UserService/IUserService';
+import { User } from '../Dtos';
 export declare class AccessiController {
     private readonly userService;
     private readonly authService;
@@ -21,7 +21,7 @@ export declare class AccessiController {
     }, res: Response): Promise<Response<any, Record<string, any>>>;
     getUsers(res: Response): Promise<Response<any, Record<string, any>>>;
     deleteUser(codiceUtente: string, res: Response): Promise<Response<any, Record<string, any>>>;
-    register(request: Request, registrationData: IUser, res: Response): Promise<Response<any, Record<string, any>>>;
+    register(request: Request, registrationData: User, res: Response): Promise<Response<any, Record<string, any>>>;
     encrypt(data: string, res: Response): Promise<Response<any, Record<string, any>>>;
     decrypt(data: string, res: Response): Promise<Response<any, Record<string, any>>>;
     resetAbilitazioni(codiceUtente: string, res: Response): Promise<Response<any, Record<string, any>>>;

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

@@ -65,6 +65,7 @@ const PermissionService_1 = require("../Services/PermissionService/PermissionSer
 const UserService_1 = require("../Services/UserService/UserService");
 const EmailService_1 = require("../Services/EmailService/EmailService");
 const path_1 = require("path");
+const Dtos_1 = require("../Dtos");
 let AccessiController = AccessiController_1 = class AccessiController {
     constructor(userService, authService, emailService, permissionService, options) {
         this.userService = userService;
@@ -291,7 +292,7 @@ __decorate([
     __param(1, (0, common_1.Body)()),
     __param(2, (0, common_1.Res)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Request, Object, Object]),
+    __metadata("design:paramtypes", [Request, Dtos_1.User, Object]),
     __metadata("design:returntype", Promise)
 ], AccessiController.prototype, "register", null);
 __decorate([
@@ -350,7 +351,7 @@ __decorate([
 ], AccessiController.prototype, "setGdpr", null);
 exports.AccessiController = AccessiController = AccessiController_1 = __decorate([
     (0, Utilities_1.Deprecated)("AccessiController è deprecato. Usa i controller specifici per ogni area."),
-    (0, swagger_1.ApiTags)('Accessi'),
+    (0, swagger_1.ApiTags)('AccessiDEPRECATED'),
     (0, common_1.Controller)('accessi'),
     __param(4, (0, common_1.Inject)('ACCESSI_OPTIONS')),
     __metadata("design:paramtypes", [UserService_1.UserService,

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

@@ -114,6 +114,10 @@ let AuthController = AuthController_1 = class AuthController {
 exports.AuthController = AuthController;
 __decorate([
     (0, swagger_1.ApiOperation)({ summary: 'Conferma il reset della password' }),
+    (0, swagger_1.ApiParam)({ name: 'token', description: 'Token per il reset della password', required: true }),
+    (0, swagger_1.ApiBody)({ schema: { properties: { newPassword: { type: 'string', description: 'Nuova password da impostare' } } } }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: 'Password aggiornata con successo' }),
+    (0, swagger_1.ApiResponse)({ status: 400, description: 'Errore nella richiesta o token non valido' }),
     (0, common_1.Post)('confirm-reset-password/:token'),
     __param(0, (0, common_1.Res)()),
     __param(1, (0, common_1.Param)('token')),
@@ -124,6 +128,9 @@ __decorate([
 ], AuthController.prototype, "resetPassword", null);
 __decorate([
     (0, swagger_1.ApiOperation)({ summary: 'Recupera le informazioni utente dal token JWT' }),
+    (0, swagger_1.ApiBody)({ schema: { properties: { token: { type: 'string', description: 'JWT dell\'utente' } } } }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: 'Informazioni utente recuperate con successo' }),
+    (0, swagger_1.ApiResponse)({ status: 401, description: 'Token non valido o scaduto' }),
     (0, common_1.Post)('get-user-by-token'),
     __param(0, (0, common_1.Body)('token')),
     __param(1, (0, common_1.Res)()),
@@ -133,6 +140,14 @@ __decorate([
 ], AuthController.prototype, "getUserByToken", null);
 __decorate([
     (0, swagger_1.ApiOperation)({ summary: 'Effettua il login' }),
+    (0, swagger_1.ApiBody)({ schema: {
+            properties: {
+                username: { type: 'string', description: 'Username dell\'utente' },
+                password: { type: 'string', description: 'Password dell\'utente' }
+            }
+        } }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: 'Login effettuato con successo' }),
+    (0, swagger_1.ApiResponse)({ status: 401, description: 'Credenziali non valide' }),
     (0, common_1.Post)('login'),
     __param(0, (0, common_1.Body)()),
     __param(1, (0, common_1.Res)()),

package/dist/accessi-module/Controllers/EmailController.d.ts

@@ -1,4 +1,4 @@
-import { Response } from 'express';
+import { Response, Request } from 'express';
 import { AccessiOptions } from '../AccessiModule';
 import { EmailService } from '../Services/EmailService/EmailService';
 export declare class EmailController {

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

@@ -46,7 +46,7 @@ let EmailController = class EmailController {
                 if (!protocol || !host) {
                     return Utilities_1.RestUtilities.sendErrorMessage(res, "Impossibile procedere: protocollo e host non impostati negli header della richiesta.", AccessiController_1.AccessiController.name);
                 }
-                let confirmationEmailPrefix = protocol + "://" + host;
+                let confirmationEmailPrefix = `${protocol}://${host}`;
                 yield this.emailService.sendPasswordResetEmail(sendResetPasswordData.email, confirmationEmailPrefix);
                 return Utilities_1.RestUtilities.sendOKMessage(res, "L'email di reset è stata inoltrata al destinatario.");
             }
@@ -59,6 +59,8 @@ let EmailController = class EmailController {
 exports.EmailController = EmailController;
 __decorate([
     (0, swagger_1.ApiOperation)({ summary: 'Serve una pagina per il reset della password' }),
+    (0, swagger_1.ApiParam)({ name: 'token', description: 'Token per il reset della password', required: true }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: 'Pagina di reset password servita con successo' }),
     (0, common_1.Get)('reset-password-page/:token'),
     __param(0, (0, common_1.Res)()),
     __param(1, (0, common_1.Param)('token')),
@@ -68,12 +70,16 @@ __decorate([
 ], EmailController.prototype, "serveResetPasswordPage", null);
 __decorate([
     (0, swagger_1.ApiOperation)({ summary: 'Invia una e-mail per il reset della password' }),
+    (0, swagger_1.ApiBody)({ schema: { properties: { email: { type: 'string', description: "L'email dell'utente che richiede il reset" } } } }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: "L'email di reset è stata inviata con successo" }),
+    (0, swagger_1.ApiResponse)({ status: 400, description: "Errore nella richiesta: protocollo o host non impostati" }),
+    (0, swagger_1.ApiResponse)({ status: 500, description: "Errore interno durante l'invio dell'email" }),
     (0, common_1.Post)('send-reset-password-email'),
     __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", [Request, Object, Object]),
+    __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
 ], EmailController.prototype, "sendPasswordResetEmail", null);
 exports.EmailController = EmailController = __decorate([

package/dist/accessi-module/Controllers/PermissionController.d.ts

@@ -1,10 +1,20 @@
 import { Response } from 'express';
 import { AccessiOptions } from '../AccessiModule';
 import { PermissionService } from '../Services/PermissionService/PermissionService';
+import { RoleWithMenus } from '../Dtos/RoleWithMenus';
+import { AssignRolesToUserRequest } from '../Dtos/AssignRolesToUserRequest';
+import { AssignPermissionsToUserRequest } from '../Dtos/AssignPermissionsToUserRequest';
 export declare class PermissionController {
     private readonly permissionService;
     private readonly options;
     constructor(permissionService: PermissionService, options: AccessiOptions);
-    resetAbilitazioni(codiceUtente: string, res: Response): Promise<Response<any, Record<string, any>>>;
-    getRoles(res: Response): Promise<Response<any, Record<string, any>>>;
+    /**
+     * @description Endpoint per ottenere tutti i ruoli con i relativi menù.
+     * @returns Un array di ruoli con menù associati.
+     */
+    getRoles(res: Response): Promise<void>;
+    updateRole(res: Response, role: RoleWithMenus): Promise<Response<any, Record<string, any>>>;
+    createRole(res: Response, role: RoleWithMenus): Promise<Response<any, Record<string, any>>>;
+    assignRolesToUser(res: Response, codiceUtente: string, assignRolesRequest: AssignRolesToUserRequest): Promise<Response<any, Record<string, any>>>;
+    assignPermissionsToUser(res: Response, codiceUtente: string, assignPermissionsRequest: AssignPermissionsToUserRequest): Promise<Response<any, Record<string, any>>>;
 }

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

@@ -27,27 +27,105 @@ const common_1 = require("@nestjs/common");
 const swagger_1 = require("@nestjs/swagger");
 const Utilities_1 = require("../../Utilities");
 const PermissionService_1 = require("../Services/PermissionService/PermissionService");
+const RoleWithMenus_1 = require("../Dtos/RoleWithMenus");
+const AssignRolesToUserRequest_1 = require("../Dtos/AssignRolesToUserRequest");
+const AssignPermissionsToUserRequest_1 = require("../Dtos/AssignPermissionsToUserRequest");
 let PermissionController = PermissionController_1 = class PermissionController {
     constructor(permissionService, options) {
         this.permissionService = permissionService;
         this.options = options;
     }
-    resetAbilitazioni(codiceUtente, res) {
+    /*
+        @ApiOperation({ summary: 'Resetta le abilitazioni di un utente' })
+        @Post('reset-abilitazioni')
+        async resetAbilitazioni(@Body('codiceUtente') codiceUtente: string, @Res() res: Response) {
+            try {
+                await this.permissionService.resetAbilitazioni(codiceUtente);
+                RestUtilities.sendOKMessage(res, `Le abilitazioni dell'utente ${codiceUtente} sono state resettate con successo.`);
+            } catch (error) {
+                RestUtilities.sendErrorMessage(res, error, PermissionController.name);
+                throw error;
+            }
+        }
+    */
+    /**
+     * @description Endpoint per ottenere tutti i ruoli con i relativi menù.
+     * @returns Un array di ruoli con menù associati.
+     */
+    getRoles(res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const roles = yield this.permissionService.getRolesWithMenus();
+                Utilities_1.RestUtilities.sendBaseResponse(res, roles);
+            }
+            catch (error) {
+                Utilities_1.RestUtilities.sendErrorMessage(res, error, PermissionController_1.name);
+                throw error;
+            }
+        });
+    }
+    updateRole(res, role) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                yield this.permissionService.resetAbilitazioni(codiceUtente);
-                return Utilities_1.RestUtilities.sendOKMessage(res, `Le abilitazioni dell'utente ${codiceUtente} sono state resettate con successo.`);
+                if (!role)
+                    throw new Error("Il ruolo non può essere vuoto.");
+                if (!role.codiceRuolo)
+                    throw new Error("Il codice del ruolo non può essere vuoto.");
+                if (!role.descrizioneRuolo)
+                    throw new Error("La descrizione del ruolo non può essere vuota.");
+                if (!role.menu || role.menu.length === 0)
+                    throw new Error("Il ruolo deve avere almeno un menù.");
+                yield this.permissionService.updateOrInsertRole(role);
+                return Utilities_1.RestUtilities.sendOKMessage(res, "Il ruolo è stato aggiornato con successo.");
             }
             catch (error) {
                 return Utilities_1.RestUtilities.sendErrorMessage(res, error, PermissionController_1.name);
             }
         });
     }
-    getRoles(res) {
+    createRole(res, role) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!role)
+                    throw new Error("Il ruolo non può essere vuoto.");
+                if (!role.descrizioneRuolo)
+                    throw new Error("La descrizione del ruolo non può essere vuota.");
+                if (!role.menu || role.menu.length === 0)
+                    throw new Error("Il ruolo deve avere almeno un menù.");
+                yield this.permissionService.updateOrInsertRole(role);
+                return Utilities_1.RestUtilities.sendOKMessage(res, "Il ruolo è stato creato con successo.");
+            }
+            catch (error) {
+                return Utilities_1.RestUtilities.sendErrorMessage(res, error, PermissionController_1.name);
+            }
+        });
+    }
+    assignRolesToUser(res, codiceUtente, assignRolesRequest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!codiceUtente)
+                    throw new Error("Il codice utente è obbligatorio.");
+                if (!assignRolesRequest.roles || assignRolesRequest.roles.length === 0) {
+                    throw new Error("È necessario fornire almeno un ruolo.");
+                }
+                yield this.permissionService.assignRolesToUser(codiceUtente, assignRolesRequest.roles);
+                return Utilities_1.RestUtilities.sendOKMessage(res, `I ruoli ${assignRolesRequest.roles.join(', ')} sono stati assegnati all'utente ${codiceUtente}.`);
+            }
+            catch (error) {
+                return Utilities_1.RestUtilities.sendErrorMessage(res, error, PermissionController_1.name);
+            }
+        });
+    }
+    assignPermissionsToUser(res, codiceUtente, assignPermissionsRequest) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                let roles = yield this.permissionService.getRolesWithMenus();
-                return Utilities_1.RestUtilities.sendBaseResponse(res, roles);
+                if (!codiceUtente)
+                    throw new Error("Il codice utente è obbligatorio.");
+                if (!assignPermissionsRequest.permissions || assignPermissionsRequest.permissions.length === 0) {
+                    throw new Error("È necessario fornire almeno un'abilitazione.");
+                }
+                yield this.permissionService.assignPermissionsToUser(codiceUtente, assignPermissionsRequest.permissions);
+                return Utilities_1.RestUtilities.sendOKMessage(res, `Le abilitazioni sono state assegnate all'utente ${codiceUtente}.`);
             }
             catch (error) {
                 return Utilities_1.RestUtilities.sendErrorMessage(res, error, PermissionController_1.name);
@@ -57,22 +135,97 @@ let PermissionController = PermissionController_1 = class PermissionController {
 };
 exports.PermissionController = PermissionController;
 __decorate([
-    (0, swagger_1.ApiOperation)({ summary: 'Resetta le abilitazioni di un utente' }),
-    (0, common_1.Post)('reset-abilitazioni'),
-    __param(0, (0, common_1.Body)('codiceUtente')),
-    __param(1, (0, common_1.Res)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Object]),
-    __metadata("design:returntype", Promise)
-], PermissionController.prototype, "resetAbilitazioni", null);
-__decorate([
-    (0, swagger_1.ApiOperation)({ summary: 'Resetta le abilitazioni di un utente' }),
+    (0, swagger_1.ApiOperation)({ summary: 'Ritorna i ruoli disponibili con i relativi menù', description: 'Recupera tutti i ruoli presenti nel sistema con le relative voci di menu accessibili.' }),
+    (0, swagger_1.ApiOkResponse)({ description: 'Elenco dei ruoli con i rispettivi menù', type: [RoleWithMenus_1.RoleWithMenus] }),
+    (0, swagger_1.ApiInternalServerErrorResponse)({ description: 'Errore interno del server' }),
+    (0, swagger_1.ApiResponse)({ status: common_1.HttpStatus.OK, description: 'Lista dei ruoli con i menù restituita con successo.' }),
+    (0, swagger_1.ApiResponse)({ status: common_1.HttpStatus.INTERNAL_SERVER_ERROR, description: 'Errore interno del server durante il recupero dei ruoli.' }),
     (0, common_1.Get)('roles'),
     __param(0, (0, common_1.Res)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
 ], PermissionController.prototype, "getRoles", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({ summary: 'Aggiorna un ruolo esistente' }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: 'Il ruolo è stato aggiornato con successo' }),
+    (0, swagger_1.ApiResponse)({ status: 400, description: 'Errore di validazione nei dati inviati' }),
+    (0, swagger_1.ApiResponse)({ status: 500, description: 'Errore interno del server' }),
+    (0, swagger_1.ApiBody)({
+        description: 'Dati del ruolo da aggiornare',
+        required: true,
+        type: RoleWithMenus_1.RoleWithMenus
+    }),
+    (0, common_1.Put)('update-role'),
+    __param(0, (0, common_1.Res)()),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, RoleWithMenus_1.RoleWithMenus]),
+    __metadata("design:returntype", Promise)
+], PermissionController.prototype, "updateRole", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({ summary: 'Crea un nuovo ruolo' }),
+    (0, swagger_1.ApiResponse)({ status: 201, description: 'Il ruolo è stato creato con successo' }),
+    (0, swagger_1.ApiResponse)({ status: 400, description: 'Errore di validazione nei dati inviati' }),
+    (0, swagger_1.ApiResponse)({ status: 500, description: 'Errore interno del server' }),
+    (0, swagger_1.ApiBody)({
+        description: 'Dati del nuovo ruolo',
+        required: true,
+        type: RoleWithMenus_1.RoleWithMenus
+    }),
+    (0, common_1.Post)('create-role'),
+    __param(0, (0, common_1.Res)()),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, RoleWithMenus_1.RoleWithMenus]),
+    __metadata("design:returntype", Promise)
+], PermissionController.prototype, "createRole", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({ summary: 'Assegna più ruoli a un utente' }),
+    (0, swagger_1.ApiParam)({
+        name: 'codiceUtente',
+        description: 'Codice identificativo dell\'utente a cui assegnare i ruoli',
+        required: true,
+        example: 'USR123'
+    }),
+    (0, swagger_1.ApiBody)({
+        type: AssignRolesToUserRequest_1.AssignRolesToUserRequest,
+        description: 'Lista dei ruoli da assegnare all\'utente'
+    }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: 'Ruoli assegnati con successo all\'utente' }),
+    (0, swagger_1.ApiResponse)({ status: 400, description: 'Errore di validazione nei dati inviati' }),
+    (0, swagger_1.ApiResponse)({ status: 500, description: 'Errore interno del server' }),
+    (0, common_1.Post)('assign-roles/:codiceUtente'),
+    __param(0, (0, common_1.Res)()),
+    __param(1, (0, common_1.Param)('codiceUtente')),
+    __param(2, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, AssignRolesToUserRequest_1.AssignRolesToUserRequest]),
+    __metadata("design:returntype", Promise)
+], PermissionController.prototype, "assignRolesToUser", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({ summary: 'Assegna abilitazioni dirette a un utente' }),
+    (0, swagger_1.ApiParam)({
+        name: 'codiceUtente',
+        description: 'Codice identificativo dell\'utente a cui assegnare le abilitazioni',
+        required: true,
+        example: 'USR123'
+    }),
+    (0, swagger_1.ApiBody)({
+        type: AssignPermissionsToUserRequest_1.AssignPermissionsToUserRequest,
+        description: 'Lista delle abilitazioni da assegnare all\'utente'
+    }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: 'Abilitazioni assegnate con successo all\'utente' }),
+    (0, swagger_1.ApiResponse)({ status: 400, description: 'Errore di validazione nei dati inviati' }),
+    (0, swagger_1.ApiResponse)({ status: 500, description: 'Errore interno del server' }),
+    (0, common_1.Post)('assign-permissions/:codiceUtente'),
+    __param(0, (0, common_1.Res)()),
+    __param(1, (0, common_1.Param)('codiceUtente')),
+    __param(2, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, AssignPermissionsToUserRequest_1.AssignPermissionsToUserRequest]),
+    __metadata("design:returntype", Promise)
+], PermissionController.prototype, "assignPermissionsToUser", null);
 exports.PermissionController = PermissionController = PermissionController_1 = __decorate([
     (0, swagger_1.ApiTags)('Permission'),
     (0, common_1.Controller)('accessi/permission'),

package/dist/accessi-module/Controllers/UserController.d.ts

@@ -0,0 +1,17 @@
+import { Response, Request } from 'express';
+import { AccessiOptions } from '../AccessiModule';
+import { UserService } from '../Services/UserService/UserService';
+import { EmailService } from '../Services/EmailService/EmailService';
+import { User } from '../Dtos';
+export declare class UserController {
+    private readonly userService;
+    private readonly emailService;
+    private readonly options;
+    constructor(userService: UserService, emailService: EmailService, options: AccessiOptions);
+    serveResetPasswordPage(res: Response, token: string): Promise<void>;
+    getUsers(res: Response): Promise<Response<any, Record<string, any>>>;
+    deleteUser(codiceUtente: string, res: Response): Promise<Response<any, Record<string, any>>>;
+    register(request: Request, registrationData: User, res: Response): Promise<Response<any, Record<string, any>>>;
+    updateUtente(user: User, res: Response): Promise<Response<any, Record<string, any>>>;
+    setGdpr(codiceUtente: string, res: Response): Promise<Response<any, Record<string, any>>>;
+}

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

@@ -0,0 +1,185 @@
+"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 Utilities_1 = require("../../Utilities");
+const UserService_1 = require("../Services/UserService/UserService");
+const EmailService_1 = require("../Services/EmailService/EmailService");
+const path_1 = require("path");
+const Dtos_1 = require("../Dtos");
+let UserController = UserController_1 = class UserController {
+    constructor(userService, emailService, options) {
+        this.userService = userService;
+        this.emailService = emailService;
+        this.options = options;
+    }
+    serveResetPasswordPage(res, token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return res.sendFile((0, path_1.join)(__dirname, '..', 'Views', 'reset-password.html'));
+        });
+    }
+    getUsers(res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const users = yield this.userService.getUsers();
+                return Utilities_1.RestUtilities.sendBaseResponse(res, users);
+            }
+            catch (error) {
+                return Utilities_1.RestUtilities.sendInvalidCredentials(res);
+            }
+        });
+    }
+    deleteUser(codiceUtente, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!codiceUtente)
+                    throw new Error('Il campo "Codice Utente" è obbligatorio.');
+                yield this.userService.deleteUser(codiceUtente);
+                return Utilities_1.RestUtilities.sendOKMessage(res, "L'utente è stato eliminato con successo.");
+            }
+            catch (error) {
+                return Utilities_1.RestUtilities.sendErrorMessage(res, error);
+            }
+        });
+    }
+    register(request, registrationData, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let protocol = request["protocol"];
+                let host = request.headers["host"];
+                if (!protocol || !host) {
+                    throw new Error("Impossibile procedere: protocollo e host non impostati negli header della richiesta.");
+                }
+                yield this.userService.register(registrationData);
+                let confirmationEmailPrefix = `${protocol}://${host}`;
+                yield this.emailService.sendPasswordResetEmail(registrationData.username, confirmationEmailPrefix);
+                return Utilities_1.RestUtilities.sendOKMessage(res, "L'utente è stato registrato con successo, email di conferma inoltrata al destinatario.");
+            }
+            catch (error) {
+                return Utilities_1.RestUtilities.sendErrorMessage(res, error, UserController_1.name);
+            }
+        });
+    }
+    updateUtente(user, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.userService.updateUser(user);
+                return Utilities_1.RestUtilities.sendOKMessage(res, `L'utente ${user.codiceUtente} è stato aggiornato con successo.`);
+            }
+            catch (error) {
+                return Utilities_1.RestUtilities.sendErrorMessage(res, error, UserController_1.name);
+            }
+        });
+    }
+    setGdpr(codiceUtente, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.userService.setGdpr(codiceUtente);
+                return Utilities_1.RestUtilities.sendOKMessage(res, `L'utente ${codiceUtente} ha accettato il GDPR.`);
+            }
+            catch (error) {
+                return Utilities_1.RestUtilities.sendErrorMessage(res, error, UserController_1.name);
+            }
+        });
+    }
+};
+exports.UserController = UserController;
+__decorate([
+    (0, swagger_1.ApiOperation)({ summary: 'Servire la pagina di reset password' }),
+    (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' }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: 'Lista utenti recuperata con successo' }),
+    (0, swagger_1.ApiResponse)({ status: 401, description: 'Credenziali non valide' }),
+    (0, common_1.Get)('get-users'),
+    __param(0, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], UserController.prototype, "getUsers", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({ summary: 'Elimina un utente' }),
+    (0, swagger_1.ApiBody)({ schema: { properties: { codiceUtente: { type: 'string', description: 'Codice identificativo dell\'utente' } } } }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: 'Utente eliminato con successo' }),
+    (0, swagger_1.ApiResponse)({ status: 400, description: 'Errore nei parametri della richiesta' }),
+    (0, common_1.Delete)('delete-user'),
+    __param(0, (0, common_1.Body)('codiceUtente')),
+    __param(1, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], UserController.prototype, "deleteUser", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({ summary: 'Registra un nuovo utente' }),
+    (0, swagger_1.ApiBody)({ type: Dtos_1.User, description: 'Dati dell\'utente da registrare' }),
+    (0, swagger_1.ApiResponse)({ status: 201, description: 'Utente registrato con successo' }),
+    (0, swagger_1.ApiResponse)({ status: 400, description: 'Errore nella registrazione' }),
+    (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, Dtos_1.User, Object]),
+    __metadata("design:returntype", Promise)
+], UserController.prototype, "register", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({ summary: 'Aggiorna un utente esistente' }),
+    (0, swagger_1.ApiBody)({ type: Dtos_1.User, description: 'Dati aggiornati dell\'utente' }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: 'Utente aggiornato con successo' }),
+    (0, swagger_1.ApiResponse)({ status: 400, description: 'Errore nellaggiornamento' }),
+    (0, common_1.Put)('update-utente'),
+    __param(0, (0, common_1.Body)()),
+    __param(1, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Dtos_1.User, Object]),
+    __metadata("design:returntype", Promise)
+], UserController.prototype, "updateUtente", null);
+__decorate([
+    (0, swagger_1.ApiOperation)({ summary: 'Imposta il consenso GDPR' }),
+    (0, swagger_1.ApiBody)({ schema: { properties: { codiceUtente: { type: 'string', description: 'Codice identificativo dell\'utente' } } } }),
+    (0, swagger_1.ApiResponse)({ status: 200, description: 'Consenso GDPR impostato con successo' }),
+    (0, swagger_1.ApiResponse)({ status: 400, description: 'Errore nella richiesta' }),
+    (0, common_1.Patch)('set-gdpr'),
+    __param(0, (0, common_1.Body)('codiceUtente')),
+    __param(1, (0, common_1.Res)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, 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'),
+    __param(2, (0, common_1.Inject)('ACCESSI_OPTIONS')),
+    __metadata("design:paramtypes", [UserService_1.UserService,
+        EmailService_1.EmailService, Object])
+], UserController);

package/dist/accessi-module/Dtos/Abilitazione.d.ts

@@ -0,0 +1,6 @@
+import { TipoAbilitazione } from "./TipoAbilitazione";
+export declare class Abilitazione {
+    codiceUtente: string;
+    codiceMenu: string;
+    tipoAbilitazione: TipoAbilitazione;
+}

package/dist/accessi-module/Dtos/Abilitazione.js

@@ -0,0 +1,47 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Abilitazione = void 0;
+const swagger_1 = require("@nestjs/swagger");
+const TipoAbilitazione_1 = require("./TipoAbilitazione");
+const class_validator_1 = require("class-validator");
+class Abilitazione {
+}
+exports.Abilitazione = Abilitazione;
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        description: 'Codice univoco dell\'utente',
+        example: 'USR12345'
+    }),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)({ message: "Il codice utente è obbligatorio." }),
+    (0, class_validator_1.Length)(5, 20, { message: "Il codice utente deve essere tra 5 e 20 caratteri." }),
+    __metadata("design:type", String)
+], Abilitazione.prototype, "codiceUtente", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        description: 'Codice univoco del menu',
+        example: 'MENU_001'
+    }),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsNotEmpty)({ message: "Il codice menu è obbligatorio." }),
+    (0, class_validator_1.Length)(3, 20, { message: "Il codice menu deve essere tra 3 e 20 caratteri." }),
+    __metadata("design:type", String)
+], Abilitazione.prototype, "codiceMenu", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        description: 'Tipo di abilitazione',
+        enum: TipoAbilitazione_1.TipoAbilitazione,
+        example: TipoAbilitazione_1.TipoAbilitazione.LETTURA
+    }),
+    (0, class_validator_1.IsEnum)(TipoAbilitazione_1.TipoAbilitazione, { message: "Il tipo di abilitazione non è valido." }),
+    __metadata("design:type", Number)
+], Abilitazione.prototype, "tipoAbilitazione", void 0);