Implementación módulo permisos para roles

backend/src/app.ts

@@ -16,7 +16,8 @@ import lpgRouter from "./modules/lpg/lpg.routes";
 import anomalyRouter from "./modules/anomalies/anomaly.routes";
 import pumpReadingRouter from "./modules/pump-reading/pumpReading.routes";
 import dashboardRouter from "./modules/dashboard/dashboard.routes";
-
+import permissionRouter from "./modules/permissions/permission.routes";
+import rolePermissionRoute from "./modules/role-permissions/rolePermission.router";
 
 
 
@@ -40,6 +41,10 @@ app.use("/api/lpg",lpgRouter);
 app.use("/api/anomaly", anomalyRouter);
 app.use("/api/pumpReading", pumpReadingRouter);
 app.use("/api/dashboard", dashboardRouter);
+app.use("/api/permission", permissionRouter);
+app.use("/api/rolePermission", rolePermissionRoute);
+app.use("/api/permission", permissionRouter);
+app.use("/api/rolePermission", rolePermissionRoute);
 
 app.use(express.urlencoded({
     extended:true

backend/src/modules/permissions/permission.routes.ts

@@ -18,4 +18,6 @@ permissionRouter.post("/", authMiddleware, controller.create);
 
 permissionRouter.put("/:id", authMiddleware, controller.update);
 
-permissionRouter.delete("/:id", authMiddleware, controller.delete);
+permissionRouter.delete("/:id", authMiddleware, controller.delete);
+
+export default permissionRouter;

backend/src/modules/role-permissions/rolePermission.controller.ts

@@ -0,0 +1,141 @@
+import { Request, Response } from "express";
+import { RolePermissionService } from "./rolePermission.service";
+
+const service = new RolePermissionService();
+
+export class RolePermissionController{
+
+    async getAll(
+        req:Request,
+        res:Response
+    ){
+        try{
+
+            const rolePermissions = await service.getAll();
+            res.json(rolePermissions);
+
+        } catch (error){
+            res.status(500).json({
+                message:"Error al obtener configuación de permisos",
+                error
+            });
+        }
+    }
+
+    async getById(
+        req:Request,
+        res:Response
+    ){
+        try{
+
+            const rolePermission = await service.getById(
+                req.params.id as string
+            );
+
+            if(!rolePermission){
+                return res.status(404).json({
+                    message:"Configuración de permisos no encontrada"
+                });
+            }
+            res.json(rolePermission);
+        } catch(error){
+            res.status(500).json({
+                message:"Error al obtener configuración de permiso"
+            });
+        }
+    }
+
+     async getByRole(
+        req:Request,
+        res:Response
+    ){
+        try{
+
+            const rolePermission = await service.getByRole(
+                req.params.roleId as string
+            );
+
+            if(!rolePermission){
+                return res.status(404).json({
+                    message:"El rol no tiene permisos asignados"
+                });
+            }
+            res.json(rolePermission);
+        } catch(error){
+            res.status(500).json({
+                message:"Error al obtener permisos del rol"
+            });
+        }
+    }
+
+    async create(
+        req:Request,
+        res:Response
+    ){
+        try{
+            const rolePemission = await service.create(
+                req.body
+            );
+
+            res.status(201).json(rolePemission);
+
+        }catch(error){
+            res.status(500).json({
+                message:"Error al crear configuración de permiso"
+            });
+        }
+    }
+
+    async update(
+        req:Request,
+        res:Response
+    ){
+        try{
+
+            const rolePermission = await service.update(
+                req.params.id as string,
+                req.body
+            )
+
+            if (!rolePermission) {
+                return res.status(404).json({
+                    message:
+                    "Configuración de permiso no encontrada"
+                });
+            }
+        } catch(error){
+            res.status(500).json({
+                message:"Error al actualizar configuración de permiso"
+            });
+        }
+    }
+
+    async delete(
+        req:Request,
+        res:Response
+    ){
+        try{
+
+            const rolePermission = await service.delete(
+                req.params.id as string
+            );
+            
+            if(!rolePermission){
+                return res.status(404).json({
+                    message:
+                    "Configuración de permiso no encontrada"
+                });
+            }
+            res.json({
+                message:"Configuración de permiso eliminada correctamente"
+            });
+
+        }catch(error){
+            res.status(500).json({
+                message:"Error al eliminar configuración de vehículo"
+
+            })
+
+        }
+    }
+}

backend/src/modules/role-permissions/rolePermission.interface.ts

@@ -0,0 +1,14 @@
+import { Types } from "mongoose";
+
+export interface IRolePermission{
+
+    roleId:Types.ObjectId;
+
+    permissions: Types.ObjectId[];
+
+    active: boolean;
+
+    createdBy: Types.ObjectId;
+
+    updateBy: Types.ObjectId;
+}

backend/src/modules/role-permissions/rolePermission.model.ts

@@ -0,0 +1,41 @@
+import mongoose from "mongoose";
+import { IRolePermission } from "./rolePermission.interface";
+
+const rolePermissionSchema = new mongoose.Schema({
+
+    roleId:{
+        type: mongoose.Schema.Types.ObjectId,
+        ref:"Role",
+        required:true,
+        unique:true,
+    },
+
+    permissions:{
+        type: mongoose.Schema.Types.ObjectId,
+        ref:"Permission",
+        required:true
+    },
+
+    active:{
+        type:Boolean,
+        default:true
+    },
+
+    createdBy:{
+        type: mongoose.Schema.Types.ObjectId,
+        ref:"User",
+        required:true
+    },
+
+    updateBy:{
+        type: mongoose.Schema.Types.ObjectId,
+        ref:"User",
+    }
+},
+    {
+        timestamps:true,
+        versionKey:false
+    }
+);
+
+export default mongoose.model<IRolePermission>("RolePermission", rolePermissionSchema);

backend/src/modules/role-permissions/rolePermission.router.ts

@@ -0,0 +1,21 @@
+import { Router } from "express";
+import { RolePermissionController } from "./rolePermission.controller";
+import { authMiddleware } from "../auth/auth.middleware";
+
+const rolePermissionRoute = Router();
+
+const controller = new RolePermissionController();
+
+rolePermissionRoute.get("/", authMiddleware, controller.getAll);
+
+rolePermissionRoute.get("/role/:roleId", authMiddleware, controller.getByRole);
+
+rolePermissionRoute.get("/:id", authMiddleware, controller.getById);
+
+rolePermissionRoute.post("/", authMiddleware, controller.create);
+
+rolePermissionRoute.put("/:id", authMiddleware, controller.update);
+
+rolePermissionRoute.delete("/:id", authMiddleware, controller.delete);
+
+export default rolePermissionRoute;

backend/src/modules/role-permissions/rolePermission.service.ts

@@ -0,0 +1,122 @@
+import rolePermissionModel from "./rolePermission.model";
+import { IRolePermission } from "./rolePermission.interface";
+
+export class RolePermissionService {
+
+
+    async getAll() {
+
+        return await rolePermissionModel
+            .find()
+            .populate("roleId")
+            .populate("permissions")
+            .populate("createdBy", "userName")
+            .populate("updatedBy", "userName");
+
+    }
+
+    async getById(
+        id: string
+    ) {
+
+        return await rolePermissionModel
+            .findById(id)
+            .populate("roleId")
+            .populate("permissions")
+            .populate("createdBy", "userName")
+            .populate("updatedBy", "userName");
+
+    }
+
+    async getByRole(
+        roleId: string
+    ) {
+
+        return await rolePermissionModel
+            .findOne({
+
+                roleId,
+
+                active: true
+
+            })
+            .populate("roleId")
+            .populate("permissions")
+            .populate("createdBy", "userName")
+            .populate("updatedBy", "userName");
+
+    }
+
+    async getPermissionByRole(
+        roleId:string
+    ){
+
+        const rolePermission = await rolePermissionModel.findOne({
+
+            roleId,
+
+            active:true
+        })
+        .populate("permissions");
+
+        if(!rolePermission){
+            return[];
+        }
+
+        return rolePermission.permissions;
+    }
+
+    async create(
+        data: IRolePermission
+    ) {
+
+        const exists =  await rolePermissionModel.findOne({
+
+                roleId: data.roleId
+
+            });
+
+        if (exists) {
+
+            throw new Error("Este rol ya tiene permisos asignados.");
+        }
+
+        return await rolePermissionModel.create(
+            data
+        );
+
+    }
+
+
+    async update(
+        id: string,
+        data: Partial<IRolePermission>
+    ) {
+
+        return await rolePermissionModel.findByIdAndUpdate(
+            id,
+            data,
+            {
+                new: true
+            }
+
+        )
+        .populate("roleId")
+        .populate("permissions")
+        .populate("createdBy", "userName")
+        .populate("updatedBy", "userName");
+
+    }
+
+
+    async delete(
+        id: string
+    ) {
+
+        return await rolePermissionModel.findByIdAndDelete(
+            id
+        );
+
+    }
+
+}