blackcoffee2 2.1.0

package/test-aplicacion.con-logisession/controllers/analyticsController.js

@@ -0,0 +1,117 @@
+const { ControllerBase } = require('insitu-js');
+const { spawn, exec } = require('child_process');
+
+class AnalyticsController extends ControllerBase {
+  constructor(options = {}) {
+    super(options);
+  }
+
+  // Método para procesar datos de métricas y prompt con Qwen
+  async processAnalytics(req, res) {
+    try {
+      // Obtener el cuerpo de la solicitud
+      let requestData = {};
+
+      // Parsear el cuerpo de la solicitud
+      if (req.body) {
+        if (typeof req.body === 'string') {
+          requestData = JSON.parse(req.body);
+        } else {
+          requestData = req.body;
+        }
+      } else {
+        // Si no está en req.body, intentar parsear desde raw body si está disponible
+        if (req.rawBody) {
+          requestData = JSON.parse(req.rawBody);
+        } else {
+          // Para casos donde necesitamos leer directamente del stream
+          let body = '';
+          for await (const chunk of req) {
+            body += chunk.toString();
+          }
+          requestData = JSON.parse(body);
+        }
+      }
+
+      // Extraer las secciones del JSON
+      const { metrics, prompt } = requestData;
+
+      // Validar que ambas secciones existan
+      if (!metrics) {
+        return this.json(res, {
+          success: false,
+          error: 'Missing metrics section in request'
+        }, 400);
+      }
+
+      if (!prompt) {
+        return this.json(res, {
+          success: false,
+          error: 'Missing prompt section in request'
+        }, 400);
+      }
+
+      // Convertir los datos de métricas a string para el comando y escapar comillas
+      const metricsString = JSON.stringify(metrics).replace(/"/g, '\\"');
+
+      // Construir el comando para Qwen usando la bandera -p para modo no interactivo
+      const qwenCommand = `qwen -p "${prompt} ${metricsString}"`;
+
+      // Ejecutar el comando de Qwen y esperar la respuesta
+      const qwenResult = await this.executeQwenSync(qwenCommand);
+
+      // Devolver la respuesta completa incluyendo la respuesta de Qwen
+      this.json(res, {
+        success: true,
+        data: {
+          originalRequest: { metrics, prompt },
+          qwenResponse: qwenResult.stdout,
+          commandUsed: qwenCommand,
+          error: qwenResult.stderr || null
+        }
+      });
+
+    } catch (error) {
+      // Manejar errores de parsing u otros
+      this.json(res, {
+        success: false,
+        error: error.message
+      }, 500);
+    }
+  }
+
+  // Método para ejecutar Qwen de forma síncrona (esperando la respuesta)
+  async executeQwenSync(command) {
+    const { exec } = require('child_process');
+    const util = require('util');
+    const execAsync = util.promisify(exec);
+
+    try {
+      // Ejecutar el comando usando exec en lugar de spawn para manejar correctamente las comillas
+      const result = await execAsync(command);
+      return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        code: 0
+      };
+    } catch (error) {
+      // En caso de error, devolver el error con formato consistente
+      return {
+        stdout: error.stdout || '',
+        stderr: error.stderr || error.message,
+        code: error.code || 1
+      };
+    }
+  }
+}
+
+// Instanciar el controlador
+const controllerInstance = new AnalyticsController();
+
+// Exportar métodos individualmente para que RouteLoader pueda acceder a ellos
+module.exports = {
+  processAnalytics: (req, res) => {
+    controllerInstance.setRequestResponse(req, res);
+    controllerInstance.processAnalytics(req, res);
+  }
+};

package/test-aplicacion.con-logisession/controllers/auth/AdminAuthController.js

@@ -0,0 +1,142 @@
+/**
+ * Controlador de autenticación de administración simplificado (sin roles y capacidades)
+ * AdminAuthController.js
+ */
+
+const { ControllerBase } = require('insitu-js');
+
+class AdminAuthController extends ControllerBase {
+  constructor(options = {}) {
+    super(options);
+  }
+
+  /**
+   * Verifica si el usuario tiene rol de administrador
+   * @param {Object} req - Objeto de solicitud
+   * @returns {Promise<boolean>} - True si es admin
+   */
+  async checkAdminRole(req) {
+    // En esta versión simplificada, todos los usuarios autenticados pueden acceder
+    // a funciones de administrador (en un entorno real, se verificaría un rol específico)
+    if (req.session && req.session.data && req.session.data.authenticated) {
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Crea un nuevo rol
+   * POST /api/admin/roles
+   */
+  async createRole(req, res) {
+    // En esta versión simplificada, no se soporta la creación de roles
+    this.json(res, {
+      success: false,
+      error: 'Funcionalidad de roles y capacidades deshabilitada en esta versión'
+    }, 501);
+  }
+
+  /**
+   * Obtiene todos los roles
+   * GET /api/admin/roles
+   */
+  async getRoles(req, res) {
+    // En esta versión simplificada, devolvemos una lista vacía
+    this.json(res, {
+      success: true,
+      roles: []
+    });
+  }
+
+  /**
+   * Crea una nueva capability
+   * POST /api/admin/capabilities
+   */
+  async createCapability(req, res) {
+    // En esta versión simplificada, no se soporta la creación de capabilities
+    this.json(res, {
+      success: false,
+      error: 'Funcionalidad de roles y capacidades deshabilitada en esta versión'
+    }, 501);
+  }
+
+  /**
+   * Obtiene todas las capabilities
+   * GET /api/admin/capabilities
+   */
+  async getCapabilities(req, res) {
+    // En esta versión simplificada, devolvemos una lista vacía
+    this.json(res, {
+      success: true,
+      capabilities: []
+    });
+  }
+
+  /**
+   * Asigna un rol a un usuario
+   * POST /api/admin/users/:userId/assign-role
+   */
+  async assignRoleToUser(req, res) {
+    // En esta versión simplificada, no se soporta la asignación de roles
+    this.json(res, {
+      success: false,
+      error: 'Funcionalidad de roles y capacidades deshabilitada en esta versión'
+    }, 501);
+  }
+
+  /**
+   * Asigna una capability a un usuario
+   * POST /api/admin/users/:userId/assign-capability
+   */
+  async assignCapabilityToUser(req, res) {
+    // En esta versión simplificada, no se soporta la asignación de capabilities
+    this.json(res, {
+      success: false,
+      error: 'Funcionalidad de roles y capacidades deshabilitada en esta versión'
+    }, 501);
+  }
+
+  /**
+   * Método para validar token
+   */
+  async validateToken(token) {
+    try {
+      const { validateToken } = require('../../utils/tokenHelper');
+      const isValid = await validateToken(token);
+      return isValid;
+    } catch (error) {
+      console.error('Error validando token:', error);
+      return false;
+    }
+  }
+}
+
+// Exportar métodos individualmente para que RouteLoader pueda acceder a ellos
+const controllerInstance = new AdminAuthController();
+
+module.exports = {
+  createRole: (req, res) => {
+    controllerInstance.setRequestResponse(req, res);
+    controllerInstance.createRole(req, res);
+  },
+  getRoles: (req, res) => {
+    controllerInstance.setRequestResponse(req, res);
+    controllerInstance.getRoles(req, res);
+  },
+  createCapability: (req, res) => {
+    controllerInstance.setRequestResponse(req, res);
+    controllerInstance.createCapability(req, res);
+  },
+  getCapabilities: (req, res) => {
+    controllerInstance.setRequestResponse(req, res);
+    controllerInstance.getCapabilities(req, res);
+  },
+  assignRoleToUser: (req, res) => {
+    controllerInstance.setRequestResponse(req, res);
+    controllerInstance.assignRoleToUser(req, res);
+  },
+  assignCapabilityToUser: (req, res) => {
+    controllerInstance.setRequestResponse(req, res);
+    controllerInstance.assignCapabilityToUser(req, res);
+  }
+};

package/test-aplicacion.con-logisession/controllers/auth/AuthController.js

@@ -0,0 +1,439 @@
+/**
+ * Controlador de autenticación para el framework JERK
+ * AuthController.js
+ */
+
+const { ControllerBase } = require('insitu-js');
+const AuthModel = require('../../models/auth/AuthModel');
+const { validateToken } = require('../../utils/tokenHelper');
+const jwt = require('jsonwebtoken');
+
+class AuthController extends ControllerBase {
+  constructor(options = {}) {
+    super(options);
+    this.authModel = new AuthModel();
+  }
+
+  /**
+   * Endpoint para login de usuarios
+   * POST /api/auth/login
+   */
+  async login(req, res) {
+    try {
+      const { username, password } = req.body;
+
+      if (!username || !password) {
+        return this.json(res, {
+          success: false,
+          error: 'Username y password son requeridos'
+        }, 400);
+      }
+
+      // Autenticar al usuario
+      const user = await this.authModel.authenticateUser(username, password);
+
+      if (!user) {
+        return this.json(res, {
+          success: false,
+          error: 'Credenciales inválidas'
+        }, 401);
+      }
+
+      // Crear sesión de usuario autenticado
+      if (req.session) {
+        req.session.create({
+          authenticated: true,
+          userId: user.id,
+          username: user.username,
+          email: user.email
+        });
+      }
+
+      // Generar token JWT para el usuario autenticado
+      const jwt = require('jsonwebtoken');
+      const secret = process.env.JWT_SECRET || 'default_secret_key_for_dev';
+      
+      const tokenPayload = {
+        userId: user.id,
+        username: user.username,
+        email: user.email
+      };
+
+      const token = jwt.sign(tokenPayload, secret, { expiresIn: '24h' });
+
+      // Guardar el token en la base de datos
+      const TokenModel = require('../../models/tracking/TokenModel');
+      const tokenModel = new TokenModel();
+      
+      await tokenModel.createToken({
+        token: token,
+        user_id: user.id,
+        store_id: 1 // ID del store predeterminado
+      });
+
+      // Obtener información del usuario
+      const userInfo = await this.authModel.getUserById(user.id);
+
+      this.json(res, {
+        success: true,
+        message: 'Inicio de sesión exitoso',
+        token: token, // Incluir el token en la respuesta
+        user: {
+          id: user.id,
+          username: user.username,
+          email: user.email,
+          roles: userInfo.roles || [],
+          capabilities: userInfo.capabilities || []
+        }
+      });
+    } catch (error) {
+      console.error('Error en login:', error);
+      this.json(res, {
+        success: false,
+        error: error.message
+      }, 500);
+    }
+  }
+
+  /**
+   * Endpoint para registro de usuarios
+   * POST /api/auth/register
+   */
+  async register(req, res) {
+    try {
+      const { username, password, email } = req.body;
+
+      if (!username || !password || !email) {
+        return this.json(res, {
+          success: false,
+          error: 'Username, password y email son requeridos'
+        }, 400);
+      }
+
+      // Verificar si el usuario ya existe
+      const existingUser = await this.authModel.userModel.getUserByIdentifier(username);
+      if (existingUser) {
+        return this.json(res, {
+          success: false,
+          error: 'El nombre de usuario ya existe'
+        }, 409);
+      }
+
+      // Verificar si el email ya existe
+      const existingEmail = await this.authModel.userModel.queryBuilder
+        .reset()
+        .select('*')
+        .where('email', email)
+        .first();
+        
+      if (existingEmail) {
+        return this.json(res, {
+          success: false,
+          error: 'El email ya está registrado'
+        }, 409);
+      }
+
+      // Registrar al nuevo usuario
+      const newUser = await this.authModel.registerUser({
+        username,
+        password,
+        email
+      });
+
+      // Obtener información del usuario
+      const userInfo = await this.authModel.getUserById(newUser.id);
+
+      this.json(res, {
+        success: true,
+        message: 'Usuario registrado exitosamente',
+        user: {
+          id: newUser.id,
+          username: newUser.username,
+          email: newUser.email,
+          roles: userInfo.roles || [],
+          capabilities: userInfo.capabilities || []
+        }
+      });
+    } catch (error) {
+      console.error('Error en registro:', error);
+      this.json(res, {
+        success: false,
+        error: error.message
+      }, 500);
+    }
+  }
+
+  /**
+   * Endpoint para obtener el perfil del usuario autenticado
+   * GET /api/auth/profile
+   */
+  async profile(req, res) {
+    try {
+      // Verificar si el usuario está autenticado a través de la sesión
+      if (!req.session || !req.session.data || !req.session.data.authenticated) {
+        return this.json(res, {
+          success: false,
+          error: 'Usuario no autenticado'
+        }, 401);
+      }
+
+      // Obtener información del usuario desde la sesión
+      const sessionData = req.session.data;
+      const userId = sessionData.userId;
+
+      // Obtener información del usuario
+      const user = await this.authModel.getUserById(userId);
+
+      if (!user) {
+        return this.json(res, {
+          success: false,
+          error: 'Usuario no encontrado'
+        }, 404);
+      }
+
+      this.json(res, {
+        success: true,
+        user: {
+          id: user.id,
+          username: user.username,
+          email: user.email,
+          roles: user.roles,
+          capabilities: user.capabilities
+        }
+      });
+    } catch (error) {
+      console.error('Error en profile:', error);
+      this.json(res, {
+        success: false,
+        error: error.message
+      }, 500);
+    }
+  }
+
+  /**
+   * Endpoint para verificar si un usuario tiene una capability específica
+   * GET /api/auth/check-capability
+   */
+  async checkCapability(req, res) {
+    try {
+      // Verificar si el usuario está autenticado a través de la sesión
+      if (!req.session || !req.session.data || !req.session.data.authenticated) {
+        return this.json(res, {
+          success: false,
+          error: 'Usuario no autenticado'
+        }, 401);
+      }
+
+      // Obtener información del usuario desde la sesión
+      const sessionData = req.session.data;
+      const userId = sessionData.userId;
+
+      // Obtener el nombre de la capability de los parámetros de consulta
+      const capabilityName = req.query.capability;
+      if (!capabilityName) {
+        return this.json(res, {
+          success: false,
+          error: 'Nombre de capability requerido'
+        }, 400);
+      }
+
+      // Verificar si el usuario tiene la capability
+      const hasCapability = await this.authModel.userHasCapability(userId, capabilityName);
+
+      this.json(res, {
+        success: true,
+        hasCapability: hasCapability,
+        capability: capabilityName,
+        userId: userId
+      });
+    } catch (error) {
+      console.error('Error en checkCapability:', error);
+      this.json(res, {
+        success: false,
+        error: error.message
+      }, 500);
+    }
+  }
+
+  /**
+   * Endpoint para logout de usuarios
+   * POST /api/auth/logout
+   */
+  async logout(req, res) {
+    try {
+      // Destruir la sesión si existe
+      if (req.session) {
+        req.session.destroy();
+      }
+
+      // Si se proporciona un token en el header, revocarlo
+      const authHeader = req.headers['authorization'];
+      if (authHeader && authHeader.startsWith('Bearer ')) {
+        const token = authHeader.substring(7); // Remover 'Bearer ' del principio
+        
+        // Revocar el token específico
+        const TokenModel = require('../../models/tracking/TokenModel');
+        const tokenModel = new TokenModel();
+        
+        try {
+          await tokenModel.revokeToken(token);
+        } catch (revokeError) {
+          console.error('Error revocando token durante logout:', revokeError);
+          // No lanzar error si falla la revocación del token, solo registrar
+        }
+      }
+
+      this.json(res, {
+        success: true,
+        message: 'Cierre de sesión exitoso'
+      });
+    } catch (error) {
+      console.error('Error en logout:', error);
+      this.json(res, {
+        success: false,
+        error: error.message
+      }, 500);
+    }
+  }
+
+  /**
+   * Método para validar token
+   */
+  async validateToken(token) {
+    try {
+      const isValid = await validateToken(token);
+      return isValid;
+    } catch (error) {
+      console.error('Error validando token:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Endpoint para verificar si un usuario tiene un rol específico
+   * GET /api/auth/check-role
+   */
+  async checkRole(req, res) {
+    try {
+      // Verificar si el usuario está autenticado a través de la sesión o token
+      const isAuthenticated = await this.checkAuthentication(req);
+      
+      if (!isAuthenticated) {
+        return this.json(res, {
+          success: false,
+          error: 'Usuario no autenticado'
+        }, 401);
+      }
+
+      // Obtener el ID del usuario desde la sesión o token
+      const userId = await this.getUserIdFromRequest(req);
+
+      // Obtener el nombre del rol de los parámetros de consulta
+      const roleName = req.query.role;
+      if (!roleName) {
+        return this.json(res, {
+          success: false,
+          error: 'Nombre de rol requerido'
+        }, 400);
+      }
+
+      // Verificar si el usuario tiene el rol
+      const UserRoleModel = require('../models/UserRoleModel');
+      const userRoleModel = new UserRoleModel();
+      
+      const hasRole = await userRoleModel.userHasRoleByName(userId, roleName);
+
+      this.json(res, {
+        success: true,
+        hasRole: hasRole,
+        role: roleName,
+        userId: userId
+      });
+    } catch (error) {
+      console.error('Error en checkRole:', error);
+      this.json(res, {
+        success: false,
+        error: error.message
+      }, 500);
+    }
+  }
+
+  /**
+   * Método para verificar autenticación (token o sesión)
+   */
+  async checkAuthentication(req) {
+    // Primero verificar si hay un token de autorización
+    const authHeader = req.headers['authorization'];
+    if (authHeader && authHeader.startsWith('Bearer ')) {
+      const token = authHeader.substring(7); // Remover 'Bearer ' del principio
+      const isValidToken = await this.validateToken(token);
+      return isValidToken;
+    }
+    
+    // Luego verificar si hay una sesión válida
+    if (req.session && req.session.data && req.session.data.authenticated) {
+      return true;
+    }
+    
+    // Si no hay token ni sesión válidos
+    return false;
+  }
+
+  /**
+   * Método para obtener el ID del usuario desde la solicitud (token o sesión)
+   */
+  async getUserIdFromRequest(req) {
+    // Primero intentar obtener de token
+    const authHeader = req.headers['authorization'];
+    if (authHeader && authHeader.startsWith('Bearer ')) {
+      const token = authHeader.substring(7);
+      const jwt = require('jsonwebtoken');
+      const secret = process.env.JWT_SECRET || 'default_secret_key_for_dev';
+      
+      try {
+        const decoded = jwt.verify(token, secret);
+        return decoded.userId;
+      } catch (error) {
+        console.error('Error decodificando token:', error);
+        return null;
+      }
+    }
+    
+    // Luego intentar obtener de sesión
+    if (req.session && req.session.data && req.session.data.authenticated) {
+      return req.session.data.userId;
+    }
+    
+    return null;
+  }
+}
+
+// Exportar métodos individualmente para que RouteLoader pueda acceder a ellos
+const controllerInstance = new AuthController();
+
+module.exports = {
+  login: (req, res) => {
+    controllerInstance.setRequestResponse(req, res);
+    controllerInstance.login(req, res);
+  },
+  register: (req, res) => {
+    controllerInstance.setRequestResponse(req, res);
+    controllerInstance.register(req, res);
+  },
+  profile: (req, res) => {
+    controllerInstance.setRequestResponse(req, res);
+    controllerInstance.profile(req, res);
+  },
+  checkCapability: (req, res) => {
+    controllerInstance.setRequestResponse(req, res);
+    controllerInstance.checkCapability(req, res);
+  },
+  logout: (req, res) => {
+    controllerInstance.setRequestResponse(req, res);
+    controllerInstance.logout(req, res);
+  },
+  checkRole: (req, res) => {
+    controllerInstance.setRequestResponse(req, res);
+    controllerInstance.checkRole(req, res);
+  }
+};