Feature/0.0.1/54 consultar usuario

app.js

@@ -63,11 +63,16 @@ app.get("/", verifyToken, (request, response) => {
   });
 });
 
-app.get("/getPermissions", verifyToken, verifyUserPermissions, (request, response) => {
-  response.status(200).json({
-    rol: request.rol
-  });
-});
+app.get(
+  "/getPermissions",
+  verifyToken,
+  verifyUserPermissions,
+  (request, response) => {
+    response.status(200).json({
+      permisos: request.permisos,
+    });
+  }
+);
 
 app.use((request, response) => {
   response.status(404).json({

modules/perfil/controllers/buscarUsuarios.controller.js

@@ -2,24 +2,32 @@ const { Usuario } = require("../../../models/perfil/usuario.model");
 const PoseeRol = require("../../../models/perfil/poseeRol.model");
 
 exports.searchUsuarios = async (req, res) => {
-  const { query, firebaseUID } = req.query; // Recibe el criterio de búsqueda desde la URL, por ejemplo: ?query=john.doe
+  const { query, roles } = req.query; // Obtener los parámetros de búsqueda y roles
+
+  // Obtener el firebaseUID del usuario autenticado
+  const firebaseUID = req.userUID.uid;
 
   try {
-    // Consultar los usuarios cuyo username o correo coincidan con el criterio
+    // Consultar los usuarios cuyo username o correo coincidan con el criterio de búsqueda
     const usuarios = await Usuario.find({
       $or: [
-        { username: { $regex: query, $options: "i" } }, // Búsqueda por username (case-insensitive)
-        { correoElectronico: { $regex: query, $options: "i" } }, // Búsqueda por correo electrónico
+        { username: { $regex: query, $options: "i" } }, // Búsqueda por username
       ],
-      firebaseUID: { $ne: firebaseUID }, // Excluir al usuario con el mismo firebaseUID
+      firebaseUID: { $ne: firebaseUID }, // Excluir al usuario autenticado
     });
 
-    // Obtener los roles relacionados para cada usuario encontrado
+    // Convertir los roles en un array
+    const rolesArray = roles ? roles.split(",") : [];
+
+    // Obtener los usuarios que tienen los roles específico
     const usuariosConRoles = await PoseeRol.find({
       IDUsuario: { $in: usuarios.map((u) => u._id) },
     })
-      .populate("IDUsuario") // Unir con los datos del usuario
-      .populate("IDRol"); // Unir con los roles
+      .populate("IDUsuario")
+      .populate({
+        path: "IDRol",
+        match: { nombre: { $in: rolesArray } }, // Filtrar roles por el nombre
+      });
 
     // Filtrar y estructurar la respuesta
     const result = usuariosConRoles
@@ -30,6 +38,7 @@ exports.searchUsuarios = async (req, res) => {
           username: ur.IDUsuario.username,
           nombre: ur.IDUsuario.nombre,
           correoElectronico: ur.IDUsuario.correoElectronico,
+          imagenPerfil: ur.IDUsuario.imagen,
         },
         rol: {
           id: ur.IDRol._id,
@@ -41,8 +50,6 @@ exports.searchUsuarios = async (req, res) => {
     res.status(200).json({ usuarios: result });
   } catch (error) {
     // En caso de error, responder con un mensaje de error
-    res
-      .status(500)
-      .json({ message: "Error al buscar los usuarios", error: error.message });
+    res.status(500).json({ message: "Error al buscar los usuarios", error: error.message });
   }
 };

modules/perfil/controllers/consultarUsuarios.controller.js

@@ -1,80 +1,134 @@
 const PoseeRol = require("../../../models/perfil/poseeRol.model");
+const Usuario = require("../../../models/perfil/usuario.model").Usuario;
+const Rol = require("../../../models/perfil/rol.model");
 
 exports.getUsuarios = async (req, res) => {
-  const { page, limit, roles, firebaseUID  } = req.query;
+  const { page, limit, roles } = req.query;
+
+  // Obtener el firebaseUID del usuario autenticado
+  const firebaseUID = req.userUID.uid;
 
   try {
     // Verificar que los valores de page y limit sean números válidos
     const pageInt = parseInt(page);
     const limitInt = parseInt(limit);
 
-    // Verificar que los valores de page y limit sean números válidos
     if (isNaN(pageInt) || isNaN(limitInt) || pageInt < 1 || limitInt < 1) {
       return res
         .status(400)
         .json({ message: "Parámetros de paginación inválidos" });
     }
 
-    // Roles permitidos para filtrar
+    // Obtener el array de roles de la query (puede ser 'Administrador,Usuario' o 'Staff,Usuario')
     const rolesArray = roles ? roles.split(",") : ["Administrador", "Staff", "Usuario"];
+
+    // Roles especiales (Administrador o Staff) y el rol normal (Usuario)
+    const rolEspecial = rolesArray[0]; // El primer rol en la query ya sea Administrador o Staff
+    const rolNormal = "Usuario"; // El segundo rol siempre es "Usuario"
 
-    // Contar el total de documentos para la paginación
-    const totalUsuarios = await PoseeRol.countDocuments({});
+    // Buscar el ObjectId del rol basado en el nombre
+    const rolEspecialDoc = await Rol.findOne({ nombre: rolEspecial }).select('_id');
+    if (!rolEspecialDoc) {
+      return res.status(404).json({ message: "Rol no encontrado" });
+    }
+    const rolEspecialID = rolEspecialDoc._id;
 
-    // Si no hay usuarios, devolver mensaje de error
-    if (totalUsuarios === 0) {
-      return res.status(404).json({ message: "No se encontraron usuarios." });
+    // Buscar el ObjectId del usuario basado en firebaseUID
+    const usuario = await Usuario.findOne({ firebaseUID: firebaseUID }).select('_id');
+
+    if (!usuario) {
+      return res.status(404).json({ message: "Usuario no encontrado" });
     }
+
+    const usuarioID = usuario._id;
+
+    // Contar el total de documentos para los roles especiales
+    const totalEspeciales = await PoseeRol.countDocuments({
+      IDRol: rolEspecialID, // Usar el ObjectId aquí
+      IDUsuario: { $ne: usuarioID },
+    });
+
+    // Consultar usuarios con el rol especial (Administrador o Staff)
+    let usuariosEspeciales = await PoseeRol.find({
+      IDRol: rolEspecialID, // Usar el ObjectId aquí
+      IDUsuario: { $ne: usuarioID }
+    })
+    .populate({
+      path: "IDRol",
+      select: "nombre",
+    })
+    .populate({
+      path: "IDUsuario",
+      match: { _id: { $ne: usuarioID } },
+      select: "username nombre correoElectronico imagen",
+    })
+    .sort({ _id: 1 }) 
+    .skip((pageInt - 1) * limitInt)
+    .limit(limitInt)
+    .lean();
 
-    // Consultar los usuarios con roles, aplicando paginación y filtros de roles
-    const usuariosConRoles = await PoseeRol.find()
+    // Si no hay más usuarios con el rol especial o la cantidad de usuarios especiales es menor al límite, cargar los usuarios normales
+    const remainingLimit = limitInt - usuariosEspeciales.length;
+
+    let usuariosNormales = [];
+    if (remainingLimit > 0) {
+      // Obtener el ObjectId del rol 'Usuario'
+      const rolNormalDoc = await Rol.findOne({ nombre: rolNormal }).select('_id');
+      if (!rolNormalDoc) {
+        return res.status(404).json({ message: "Rol no encontrado" });
+      }
+      const rolNormalID = rolNormalDoc._id;
+
+      usuariosNormales = await PoseeRol.find({
+        IDRol: rolNormalID,
+        IDUsuario: { $ne: usuarioID }
+      })
       .populate({
         path: "IDRol",
-        match: { nombre: { $in: rolesArray } }, // Filtrar por el nombre del Rol
-        select: "nombre" // Traer solo el campo nombre
+        select: "nombre",
       })
       .populate({
         path: "IDUsuario",
-        match: { firebaseUID: { $ne: firebaseUID } }, // Excluir por firebaseUID
+        match: { _id: { $ne: usuarioID } },
+        select: "username nombre correoElectronico imagen",
       })
       .sort({ _id: 1 })
-      .skip((pageInt - 1) * limitInt) // Saltar los documentos de las páginas anteriores
-      .limit(limitInt); // Limitar el número de documentos devueltos
+      .skip(Math.max(0, (pageInt - 1) * remainingLimit - totalEspeciales))
+      .limit(remainingLimit)
+      .lean();
+    }
+
+    // Combinar los resultados
+    const usuariosConRoles = [...usuariosEspeciales, ...usuariosNormales];
 
     // Filtrar y mapear los resultados
     const result = usuariosConRoles
-      .filter((ur) => ur.IDUsuario && ur.IDRol) // Filtrar los registros que tengan ambos datos
+      .filter((ur) => ur.IDUsuario && ur.IDRol)
       .map((ur) => ({
         usuario: {
           id: ur.IDUsuario._id,
           username: ur.IDUsuario.username,
           nombre: ur.IDUsuario.nombre,
           correoElectronico: ur.IDUsuario.correoElectronico,
+          imagenPerfil: ur.IDUsuario.imagen,
         },
         rol: {
           id: ur.IDRol._id,
           nombreRol: ur.IDRol.nombre,
         },
       }));
 
-    // Verificar si hay resultados después de la paginación
     if (result.length === 0) {
-      return res
-        .status(404)
-        .json({ message: "No se encontraron usuarios en esta página." });
+      return res.status(404).json({ message: "No se encontraron usuarios." });
     }
 
-    // Enviar la respuesta con los usuarios, la página actual y la información de paginación
     res.status(200).json({
       usuarios: result,
-      currentPage: pageInt, // Página actual
-      totalUsuarios: totalUsuarios, // Total de usuarios
-      totalPages: Math.ceil(totalUsuarios / limitInt), // Total de páginas
+      currentPage: pageInt,
+      totalUsuarios: totalEspeciales,
+      totalPages: Math.ceil(totalEspeciales / limitInt),
     });
   } catch (error) {
-    // En caso de error, responder con un mensaje de error y el código HTTP 500
-    res
-      .status(500)
-      .json({ message: "Error al obtener los usuarios", error: error.message });
+    res.status(500).json({ message: "Error al obtener los usuarios", error: error.message });
   }
 };

modules/perfil/routes/buscarUsuarios.routes.js

@@ -1,10 +1,12 @@
 const express = require("express");
 const router = express.Router();
 
+const verifyToken = require("../../../util/verifyUserToken");
+
 // Importar el controlador que maneja la creación de actividades
 const buscarUsuariosController = require("../controllers/buscarUsuarios.controller");
 
 // Definir la ruta para crear una actividad
-router.get("/", buscarUsuariosController.searchUsuarios);
+router.get("/", verifyToken, buscarUsuariosController.searchUsuarios);
 
 module.exports = router;

modules/perfil/routes/consultarPerfil.routes.js

@@ -7,4 +7,4 @@ const consultarPerfilController = require("../controllers/consultarPerfil.contro
 // Definir la ruta para crear una actividad
 router.get("/:firebaseUID", consultarPerfilController.get_Perfil);
 
-module.exports = router;
+module.exports = router;

modules/perfil/routes/consultarUsuarios.routes.js

@@ -1,10 +1,12 @@
 const express = require("express");
 const router = express.Router();
 
+const verifyToken = require("../../../util/verifyUserToken");
+
 // Importar el controlador que maneja la creación de actividades
 const consultarUsuariosController = require("../controllers/consultarUsuarios.controller");
 
 // Definir la ruta para crear una actividad
-router.get("/", consultarUsuariosController.getUsuarios);
+router.get("/", verifyToken, consultarUsuariosController.getUsuarios);
 
 module.exports = router;