blackcoffee2 2.1.0 → 2.1.2

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

@@ -1,66 +0,0 @@
-const { ControllerBase } = require('insitu-js');
-
-class EndpointController extends ControllerBase {
-  constructor(options = {}) {
-    super(options);
-  }
-
-  // Método para listar todos los endpoints registrados
-  async listEndpoints(req, res) {
-    try {
-      let endpoints = [];
-
-      // Usar el mapa global registeredEndpoints que contiene la información completa de las rutas
-      for (const [key, endpoint] of global.registeredEndpoints) {
-        endpoints.push(endpoint);
-      }
-
-      // Ordenar los endpoints por método y luego por ruta
-      endpoints.sort((a, b) => {
-        // Primero ordenar por método HTTP
-        const methodOrder = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS', 'HEAD'];
-        const methodComparison = methodOrder.indexOf(a.method.toUpperCase()) - methodOrder.indexOf(b.method.toUpperCase());
-
-        if (methodComparison !== 0) {
-          return methodComparison;
-        }
-
-        // Si tienen el mismo método, ordenar por ruta
-        return a.path.localeCompare(b.path);
-      });
-
-      // Preparar respuesta
-      const response = {
-        success: true,
-        count: endpoints.length,
-        endpoints: endpoints
-      };
-
-      // Enviar respuesta JSON
-      res.writeHead(200, {
-        'Content-Type': 'application/json',
-        'Access-Control-Allow-Origin': '*',
-        'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
-        'Access-Control-Allow-Headers': 'Content-Type, Authorization'
-      });
-      res.end(JSON.stringify(response, null, 2));
-    } catch (error) {
-      console.error('Error al listar endpoints:', error);
-
-      this.json(res, {
-        success: false,
-        error: error.message
-      }, 500);
-    }
-  }
-}
-
-// Exportar métodos individualmente para que RouteLoader pueda acceder a ellos
-const controllerInstance = new EndpointController();
-
-module.exports = {
-  listEndpoints: (req, res) => {
-    controllerInstance.setRequestResponse(req, res);
-    controllerInstance.listEndpoints(req, res);
-  }
-};

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

@@ -1,183 +0,0 @@
-const { ControllerBase } = require('insitu-js');
-const ProductModel = require('../models/ExampleModel');
-
-class ProductController extends ControllerBase {
-  constructor(options = {}) {
-    super(options);
-    this.model = new ProductModel();
-  }
-
-  // Método para mostrar la página principal con productos
-  async index(req, res) {
-    try {
-      const products = await this.model.getAllProducts();
-
-      // Preparar datos para la vista
-      this.set('title', 'Tienda de Productos');
-      this.set('products', products);
-      this.set('activePage', 'home');
-
-      // Renderizar la vista
-      const html = this.view('products/index', {
-        title: 'Tienda de Productos',
-        products: products,
-        activePage: 'home'
-      });
-
-      res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-      res.end(html);
-    } catch (error) {
-      this.json(res, {
-        success: false,
-        error: error.message
-      }, 500);
-    }
-  }
-
-  // Método para obtener productos en formato JSON
-  async getAllProducts(req, res) {
-    try {
-      const products = await this.model.getAllProducts();
-
-      // Devolver directamente el array de productos para compatibilidad con el frontend
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify(products));
-    } catch (error) {
-      this.json(res, {
-        success: false,
-        error: error.message
-      }, 500);
-    }
-  }
-
-  // Método para obtener un producto específico por ID
-  async getProductById(req, res) {
-    try {
-      const id = this.input('id', null);
-      if (!id) {
-        return this.json(res, {
-          success: false,
-          error: 'ID de producto es requerido'
-        }, 400);
-      }
-      
-      const product = await this.model.getProductById(id);
-      if (!product) {
-        return this.json(res, {
-          success: false,
-          error: 'Producto no encontrado'
-        }, 404);
-      }
-      
-      this.json(res, {
-        success: true,
-        data: product
-      });
-    } catch (error) {
-      this.json(res, {
-        success: false,
-        error: error.message
-      }, 500);
-    }
-  }
-
-  // Método para crear un nuevo producto
-  async createProduct(req, res) {
-    try {
-      // En una implementación real, aquí obtendríamos los datos del cuerpo de la solicitud
-      const productData = {
-        name: this.input('name', ''),
-        description: this.input('description', ''),
-        price: parseFloat(this.input('price', 0)),
-        category: this.input('category', '')
-      };
-      
-      const newProduct = await this.model.createProduct(productData);
-      
-      this.json(res, {
-        success: true,
-        data: newProduct
-      }, 201);
-    } catch (error) {
-      this.json(res, {
-        success: false,
-        error: error.message
-      }, 500);
-    }
-  }
-
-  // Método para mostrar la página de contacto
-  async showContact(req, res) {
-    try {
-      this.set('title', 'Contacto');
-      this.set('activePage', 'contact');
-
-      const html = this.view('contact/form', {
-        title: 'Contacto',
-        activePage: 'contact'
-      });
-
-      res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-      res.end(html);
-    } catch (error) {
-      this.json(res, {
-        success: false,
-        error: error.message
-      }, 500);
-    }
-  }
-
-  // Método para manejar el envío del formulario de contacto
-  async handleContact(req, res) {
-    try {
-      const contactData = {
-        name: this.input('name', ''),
-        email: this.input('email', ''),
-        message: this.input('message', '')
-      };
-      
-      // Aquí iría la lógica para procesar el formulario de contacto
-      // Por ahora, simplemente devolvemos éxito
-      
-      this.json(res, {
-        success: true,
-        message: 'Mensaje recibido correctamente'
-      });
-    } catch (error) {
-      this.json(res, {
-        success: false,
-        error: error.message
-      }, 500);
-    }
-  }
-}
-
-// Exportar métodos individualmente para que RouteLoader pueda acceder a ellos
-const controllerInstance = new ProductController();
-
-module.exports = {
-  index: (req, res) => {
-    controllerInstance.setRequestResponse(req, res);
-    controllerInstance.index(req, res);
-  },
-  getAllProducts: (req, res) => {
-    controllerInstance.setRequestResponse(req, res);
-    controllerInstance.getAllProducts(req, res);
-  },
-  getProductById: (req, res) => {
-    controllerInstance.setRequestResponse(req, res);
-    controllerInstance.getProductById(req, res);
-  },
-  createProduct: (req, res) => {
-    controllerInstance.setRequestResponse(req, res);
-    controllerInstance.createProduct(req, res);
-  },
-  showContact: (req, res) => {
-    controllerInstance.setRequestResponse(req, res);
-    controllerInstance.showContact(req, res);
-  },
-  handleContact: (req, res) => {
-    controllerInstance.setRequestResponse(req, res);
-    controllerInstance.handleContact(req, res);
-  }
-};

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

@@ -1,367 +0,0 @@
-const { ControllerBase } = require('insitu-js');
-
-class IAQueueController extends ControllerBase {
-  constructor(options = {}) {
-    super(options);
-
-    // Inicializar el almacenamiento global para resultados si no existe
-    if (!global.iaQueueResults) {
-      global.iaQueueResults = new Map();
-    }
-    
-    this.resultsMap = global.iaQueueResults;
-  }
-
-  // Procesar una solicitud de IA a través del sistema de colas
-  async processWithIAQueue(req, res) {
-    try {
-      let requestData = {};
-
-      if (req.body) {
-        if (typeof req.body === 'string') {
-          requestData = JSON.parse(req.body);
-        } else {
-          requestData = req.body;
-        }
-      } else {
-        let body = '';
-        for await (const chunk of req) {
-          body += chunk.toString();
-        }
-        requestData = JSON.parse(body);
-      }
-
-      // Validar que existan las secciones requeridas
-      if (!requestData.data && !requestData.metrics) {
-        return this.json(res, {
-          success: false,
-          error: 'Missing data or metrics section in request'
-        }, 400);
-      }
-
-      if (!requestData.prompt) {
-        return this.json(res, {
-          success: false,
-          error: 'Missing prompt section in request'
-        }, 400);
-      }
-
-      // Preparar el payload para el trabajo
-      const payload = {
-        data: requestData.data || requestData.metrics,
-        prompt: requestData.prompt,
-        userId: requestData.userId || null,
-        requestId: Date.now()
-      };
-
-      // Función que representa la tarea de IA
-      const iaTask = async (datos, taskObj) => {
-        try {
-          console.log('[IA_QUEUE_TASK] Iniciando procesamiento de tarea:', taskObj.id);
-          console.log('[IA_QUEUE_TASK] Datos recibidos:', datos);
-
-          // Importar exec aquí para evitar problemas de dependencias
-          const { exec } = require('child_process');
-          const util = require('util');
-          const execAsync = util.promisify(exec);
-
-          // Preparar el comando para Qwen con el prompt
-          const qwenCommand = `qwen -p "${datos.prompt}"`;
-
-          console.log('[IA_QUEUE_TASK] Ejecutando comando Qwen:', qwenCommand);
-          
-          // Ejecutar el comando de Qwen
-          const result = await execAsync(qwenCommand);
-
-          console.log('[IA_QUEUE_TASK] Comando Qwen ejecutado exitosamente');
-          
-          const response = result.stdout;
-          console.log('[IA_QUEUE_TASK] Respuesta de Qwen:', response);
-
-          const finalResult = {
-            success: true,
-            response: response,
-            command: qwenCommand,
-            userId: datos.userId,
-            requestId: datos.requestId
-          };
-
-          console.log('[IA_QUEUE_TASK] Resultado generado para tarea:', taskObj.id, finalResult);
-          
-          // Guardar el resultado en el almacenamiento global inmediatamente después de generar el resultado
-          if (!global.iaQueueResults) {
-            global.iaQueueResults = new Map();
-          }
-          
-          const resultData = {
-            job_id: taskObj.id,
-            result: typeof finalResult === 'object' ? JSON.stringify(finalResult) : finalResult,
-            created_at: new Date().toISOString()
-          };
-          
-          global.iaQueueResults.set(taskObj.id, resultData);
-          console.log(`[IA_QUEUE_TASK] Resultado guardado inmediatamente para tarea: ${taskObj.id}`);
-          
-          return finalResult;
-        } catch (error) {
-          console.error('[IA_QUEUE_TASK] Error ejecutando comando de Qwen:', error);
-          // Guardar el error también en el almacenamiento global
-          if (!global.iaQueueResults) {
-            global.iaQueueResults = new Map();
-          }
-          
-          const errorResult = {
-            success: false,
-            error: error.message,
-            command: `qwen -p "${datos.prompt}"`,
-            userId: datos.userId,
-            requestId: datos.requestId
-          };
-          
-          const resultData = {
-            job_id: taskObj.id,
-            result: JSON.stringify(errorResult),
-            created_at: new Date().toISOString()
-          };
-          
-          global.iaQueueResults.set(taskObj.id, resultData);
-          console.log(`[IA_QUEUE_TASK] Resultado de error guardado para tarea: ${taskObj.id}`);
-          
-          throw new Error(`Qwen execution failed: ${error.message}`);
-        }
-      };
-
-      // Verificar que el sistema de colas esté disponible
-      if (!global.queueIntegration) {
-        return this.json(res, {
-          success: false,
-          error: 'Queue system is not available'
-        }, 500);
-      }
-
-      // Agregar la tarea a la cola de IA
-      const taskId = global.queueIntegration.addTask(
-        'ia-processing',  // Nombre de la cola
-        iaTask,           // Función de la tarea
-        payload,          // Datos para la tarea
-        requestData.priority || 0  // Prioridad (0 es la más alta)
-      );
-
-      this.json(res, {
-        success: true,
-        data: {
-          jobId: taskId,
-          queue: 'ia-processing',
-          status: 'pending',
-          message: 'IA job added to queue successfully'
-        }
-      });
-
-    } catch (error) {
-      this.json(res, {
-        success: false,
-        error: error.message
-      }, 500);
-    }
-  }
-
-  // Obtener el estado de una tarea de IA
-  async getIAQueueResult(req, res) {
-    try {
-      const jobId = req.params?.id || this.input('id', null);
-
-      if (!jobId) {
-        return this.json(res, {
-          success: false,
-          error: 'Job ID is required'
-        }, 400);
-      }
-
-      // Primero intentar obtener el resultado desde el almacenamiento global
-      try {
-        const resultData = this.resultsMap.get(jobId);
-        if (resultData) {
-          let result = resultData.result;
-          try {
-            // Intentar parsear como JSON si es posible
-            result = JSON.parse(resultData.result);
-          } catch (e) {
-            // Si no es JSON válido, usar como string
-            result = resultData.result;
-          }
-
-          return this.json(res, {
-            success: true,
-            data: {
-              jobId: jobId,
-              status: 'completed',
-              result: result,
-              message: 'Job completed and result retrieved from storage'
-            }
-          });
-        }
-      } catch (error) {
-        console.error('[IA_QUEUE] Error retrieving stored result:', error.message);
-      }
-
-      // Si no está en el almacenamiento global, verificar en el sistema de colas
-      if (!global.queueIntegration) {
-        return this.json(res, {
-          success: true,
-          data: {
-            jobId: jobId,
-            status: 'completed_or_not_found',
-            message: 'Queue system is not available',
-            queueStatus: {}
-          }
-        });
-      }
-
-      const queueStatus = global.queueIntegration.getStatus();
-
-      // Buscar la tarea específica
-      let jobStatus = null;
-
-      // Buscar en la cola de ia-processing
-      if (queueStatus['ia-processing']) {
-        const queueInfo = queueStatus['ia-processing'];
-
-        // La cola de tareas pendientes está en el sistema de colas
-        const pendingQueue = global.queueIntegration.getQueueSystem().pendingTasks.get('ia-processing') || [];
-        const runningTasks = global.queueIntegration.getQueueSystem().runningTasks.get('ia-processing') || new Set();
-
-        // Buscar en tareas pendientes
-        if (pendingQueue.some(task => task.id === jobId)) {
-          jobStatus = 'pending';
-        }
-        // Buscar en tareas en proceso
-        else if (runningTasks.has(jobId)) {
-          jobStatus = 'processing';
-        }
-      }
-
-      if (!jobStatus) {
-        // La tarea no está en colas activas y tampoco en el almacenamiento global
-        this.json(res, {
-          success: true,
-          data: {
-            jobId: jobId,
-            status: 'completed_or_not_found',
-            message: 'Job may be completed or not found in active queues',
-            queueStatus: queueStatus
-          }
-        });
-      } else {
-        this.json(res, {
-          success: true,
-          data: {
-            jobId: jobId,
-            status: jobStatus,
-            message: `Job is ${jobStatus}, please check again later`,
-            queueInfo: queueStatus['ia-processing']
-          }
-        });
-      }
-
-    } catch (error) {
-      this.json(res, {
-        success: false,
-        error: error.message
-      }, 500);
-    }
-  }
-
-  // Obtener historial de resultados de IA
-  async getIAQueueHistory(req, res) {
-    try {
-      const limit = parseInt(req.query.limit) || 10;
-
-      // Convertir el map a array y tomar los últimos 'limit' elementos
-      const allResults = Array.from(this.resultsMap.values())
-        .sort((a, b) => new Date(b.created_at) - new Date(a.created_at))
-        .slice(0, limit);
-
-      const results = allResults.map(result => {
-        try {
-          // Intentar parsear como JSON si es posible
-          return {
-            job_id: result.job_id,
-            result: JSON.parse(result.result),
-            created_at: result.created_at
-          };
-        } catch (e) {
-          // Si no es JSON válido, devolver como string
-          return {
-            job_id: result.job_id,
-            result: result.result,
-            created_at: result.created_at
-          };
-        }
-      });
-
-      this.json(res, {
-        success: true,
-        data: {
-          results: results,
-          count: results.length
-        }
-      });
-
-    } catch (error) {
-      this.json(res, {
-        success: false,
-        error: error.message
-      }, 500);
-    }
-  }
-
-  // Obtener estadísticas de la cola de IA
-  async getIAQueueStats(req, res) {
-    try {
-      if (!global.queueIntegration) {
-        return this.json(res, {
-          success: false,
-          error: 'Queue system is not available'
-        }, 500);
-      }
-
-      const queueStatus = global.queueIntegration.getStatus();
-
-      this.json(res, {
-        success: true,
-        data: {
-          queueStats: queueStatus,
-          message: 'IA queue statistics retrieved successfully'
-        }
-      });
-    } catch (error) {
-      this.json(res, {
-        success: false,
-        error: error.message
-      }, 500);
-    }
-  }
-}
-
-// Instanciar el controlador
-const controllerInstance = new IAQueueController();
-
-// Exportar métodos individualmente
-module.exports = {
-  processWithIAQueue: (req, res) => {
-    controllerInstance.setRequestResponse(req, res);
-    controllerInstance.processWithIAQueue(req, res);
-  },
-  getIAQueueResult: (req, res) => {
-    controllerInstance.setRequestResponse(req, res);
-    controllerInstance.getIAQueueResult(req, res);
-  },
-  getIAQueueHistory: (req, res) => {
-    controllerInstance.setRequestResponse(req, res);
-    controllerInstance.getIAQueueHistory(req, res);
-  },
-  getIAQueueStats: (req, res) => {
-    controllerInstance.setRequestResponse(req, res);
-    controllerInstance.getIAQueueStats(req, res);
-  }
-};