blackcoffee2 2.1.0 → 2.1.2

package/test-aplicacion.con-logisession/models/TokenModel.js

@@ -1,207 +0,0 @@
-/**
- * Modelo para la tabla tokens en el framework JERK
- * Implementación del componente MVC TokenModel.js
- * Utiliza MariaDB como adaptador de base de datos
- */
-
-const { ModelBase, hooks } = require('insitu-js');
-const { getSharedAdapter } = require('../utils/dbAdapter');
-const { QueryBuilder } = require('insitu-js');
-
-class TokenModel extends ModelBase {
-  constructor(options = {}) {
-    // Obtener el adaptador centralizado
-    const adapter = getSharedAdapter();
-
-    super({
-      ...options,
-      tableName: options.tableName || 'tokens',
-      adapter: adapter
-    });
-
-    // Inicializar QueryBuilder con el adaptador centralizado
-    this.queryBuilder = new QueryBuilder(adapter, 'tokens');
-
-    // Definir campos del modelo
-    this.fields = {
-      id: { type: 'integer', primaryKey: true, autoIncrement: true },
-      token: { type: 'string', required: true },
-      created_at: { type: 'datetime', auto: 'create' },
-      store_id: { type: 'integer' }
-    };
-  }
-
-  /**
-   * Valida un token contra la base de datos
-   * @param {string} token - Token a validar
-   * @returns {Promise<boolean>} - True si el token es válido y no revocado, false en caso contrario
-   */
-  async validateToken(token) {
-    if (!token) {
-      // Disparar hook de validación de token fallida
-      hooks.doAction('token_validation_failed', { token: token, reason: 'Token vacío o nulo' });
-      return false;
-    }
-
-    // Disparar hook de inicio de validación de token
-    hooks.doAction('token_validation_start', { token: token });
-
-    try {
-      // Buscar el token en la base de datos usando QueryBuilder
-      const tokenRecord = await this.queryBuilder
-        .reset()
-        .select('*')
-        .where('token', token)
-        .first();
-
-      if (tokenRecord) {
-        // Verificar si el token está revocado
-        if (tokenRecord.revoked === 1) {
-          // Disparar hook de validación de token fallida por revocación
-          hooks.doAction('token_validation_failed', { token: token, reason: 'Token revocado' });
-          return false;
-        }
-
-        // Disparar hook de validación de token exitosa
-        hooks.doAction('token_validation_success', { token: token, tokenRecord: tokenRecord });
-        return true;
-      } else {
-        // Disparar hook de validación de token fallida
-        hooks.doAction('token_validation_failed', { token: token, reason: 'Token no encontrado en la base de datos' });
-        return false;
-      }
-    } catch (error) {
-      console.error('[ERROR] TokenModel.validateToken:', error);
-      // Disparar hook de validación de token fallida por error
-      hooks.doAction('token_validation_error', { token: token, error: error.message });
-      return false;
-    }
-  }
-
-  /**
-   * Obtiene un token por su valor
-   * @param {string} token - Valor del token
-   * @returns {Promise<Object|null>} - Registro del token o null si no existe
-   */
-  async getToken(token) {
-    if (!token) {
-      return null;
-    }
-
-    try {
-      return await this.queryBuilder
-        .reset()
-        .select('*')
-        .where('token', token)
-        .first();
-    } catch (error) {
-      console.error('[ERROR] TokenModel.getToken:', error);
-      return null;
-    }
-  }
-
-  /**
-   * Obtiene todos los tokens
-   * @returns {Promise<Array>} - Lista de todos los tokens
-   */
-  async getAllTokens() {
-    try {
-      return await this.queryBuilder
-        .reset()
-        .select('*')
-        .get();
-    } catch (error) {
-      console.error('[ERROR] TokenModel.getAllTokens:', error);
-      return [];
-    }
-  }
-
-  /**
-   * Crea un nuevo token
-   * @param {Object} tokenData - Datos del token
-   * @returns {Promise<Object>} - Token creado
-   */
-  async createToken(tokenData) {
-    try {
-      const result = await this.queryBuilder
-        .reset()
-        .insert(tokenData);
-
-      // Obtener y devolver el token recién creado
-      return await this.queryBuilder
-        .reset()
-        .select('*')
-        .where('id', result.insertId)
-        .first();
-    } catch (error) {
-      console.error('[ERROR] TokenModel.createToken:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Revoca un token marcándolo como inhabilitado
-   * @param {string} token - Token a revocar
-   * @returns {Promise<boolean>} - True si se revocó correctamente
-   */
-  async revokeToken(token) {
-    try {
-      const result = await this.queryBuilder
-        .reset()
-        .update({
-          revoked: 1,
-          revoked_at: new Date()
-        })
-        .where('token', token);
-
-      return result.affectedRows > 0;
-    } catch (error) {
-      console.error(`[ERROR] TokenModel.revokeToken:`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * Revoca todos los tokens de un usuario
-   * @param {number} userId - ID del usuario
-   * @returns {Promise<number>} - Número de tokens revocados
-   */
-  async revokeAllUserTokens(userId) {
-    try {
-      const result = await this.queryBuilder
-        .reset()
-        .update({
-          revoked: 1,
-          revoked_at: new Date()
-        })
-        .where('user_id', userId);
-
-      return result.affectedRows;
-    } catch (error) {
-      console.error(`[ERROR] TokenModel.revokeAllUserTokens:`, error);
-      throw error;
-    }
-  }
-
-  /**
-   * Verifica si un token está revocado
-   * @param {string} token - Token a verificar
-   * @returns {Promise<boolean>} - True si el token está revocado
-   */
-  async isTokenRevoked(token) {
-    try {
-      const tokenRecord = await this.queryBuilder
-        .reset()
-        .select(['revoked'])
-        .where('token', token)
-        .first();
-
-      return tokenRecord ? tokenRecord.revoked === 1 : true;
-    } catch (error) {
-      console.error(`[ERROR] TokenModel.isTokenRevoked:`, error);
-      return true; // En caso de error, asumir que está revocado por seguridad
-    }
-  }
-}
-
-module.exports = TokenModel;

package/test-aplicacion.con-logisession/models/auth/AuthModel.js

@@ -1,66 +0,0 @@
-/**
- * Modelo de autenticación simplificado
- * AuthModel.js
- */
-
-const UserModel = require('./UserModel');
-
-class AuthModel {
-  constructor() {
-    this.userModel = new UserModel();
-  }
-
-  /**
-   * Autentica un usuario
-   * @param {string} username - Nombre de usuario o email
-   * @param {string} password - Contraseña
-   * @returns {Promise<Object|null>} - Usuario autenticado o null si falla
-   */
-  async authenticateUser(username, password) {
-    try {
-      return await this.userModel.validateCredentials(username, password);
-    } catch (error) {
-      console.error('[ERROR] AuthModel.authenticateUser:', error);
-      return null;
-    }
-  }
-
-  /**
-   * Registra un nuevo usuario
-   * @param {Object} userData - Datos del usuario
-   * @returns {Promise<Object>} - Usuario registrado
-   */
-  async registerUser(userData) {
-    try {
-      return await this.userModel.createUser(userData);
-    } catch (error) {
-      console.error('[ERROR] AuthModel.registerUser:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Obtiene un usuario por ID
-   * @param {number} userId - ID del usuario
-   * @returns {Promise<Object|null>} - Usuario o null si no existe
-   */
-  async getUserById(userId) {
-    try {
-      const user = await this.userModel.getUserById(userId);
-      if (!user) {
-        return null;
-      }
-
-      return {
-        ...user,
-        roles: [], // No hay roles en esta versión simplificada
-        capabilities: [] // No hay capabilities en esta versión simplificada
-      };
-    } catch (error) {
-      console.error('[ERROR] AuthModel.getUserById:', error);
-      return null;
-    }
-  }
-}
-
-module.exports = AuthModel;

package/test-aplicacion.con-logisession/models/auth/UserModel.js

@@ -1,189 +0,0 @@
-/**
- * Modelo para la tabla users en el framework JERK
- * UserModel.js
- */
-
-const { ModelBase } = require('insitu-js');
-const { getSharedAdapter } = require('../../utils/dbAdapter');
-const { QueryBuilder } = require('insitu-js');
-const bcrypt = require('bcrypt');
-
-class UserModel extends ModelBase {
-  constructor(options = {}) {
-    // Obtener el adaptador centralizado
-    const adapter = getSharedAdapter();
-
-    super({
-      ...options,
-      tableName: options.tableName || 'users',
-      adapter: adapter
-    });
-
-    // Inicializar QueryBuilder con el adaptador centralizado
-    this.queryBuilder = new QueryBuilder(adapter, 'users');
-
-    // Definir campos del modelo
-    this.fields = {
-      id: { type: 'integer', primaryKey: true, autoIncrement: true },
-      username: { type: 'string', required: true, unique: true },
-      password: { type: 'string', required: true },
-      email: { type: 'string', required: true, unique: true },
-      created_at: { type: 'datetime', auto: 'create' },
-      updated_at: { type: 'datetime', auto: 'update' },
-      is_active: { type: 'boolean', default: true }
-    };
-  }
-
-  /**
-   * Crea un nuevo usuario con contraseña encriptada
-   * @param {Object} userData - Datos del usuario
-   * @returns {Promise<Object>} - Usuario creado
-   */
-  async createUser(userData) {
-    try {
-      // Encriptar la contraseña
-      const hashedPassword = await bcrypt.hash(userData.password, 10);
-      
-      const userDataWithHashedPassword = {
-        ...userData,
-        password: hashedPassword
-      };
-
-      const result = await this.queryBuilder
-        .reset()
-        .insert(userDataWithHashedPassword);
-
-      // Obtener y devolver el usuario recién creado
-      return await this.queryBuilder
-        .reset()
-        .select('*')
-        .where('id', result.insertId)
-        .first();
-    } catch (error) {
-      console.error('[ERROR] UserModel.createUser:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Valida las credenciales de un usuario
-   * @param {string} username - Nombre de usuario
-   * @param {string} password - Contraseña sin encriptar
-   * @returns {Promise<Object|null>} - Usuario si las credenciales son válidas, null si no
-   */
-  async validateCredentials(username, password) {
-    try {
-      const user = await this.queryBuilder
-        .reset()
-        .select('*')
-        .where(function(qb) {
-          qb.where('username', username).orWhere('email', username); // Permitir login con email o username
-        })
-        .where('is_active', true)
-        .first();
-
-      if (!user) {
-        return null;
-      }
-
-      // Comparar la contraseña encriptada
-      const isPasswordValid = await bcrypt.compare(password, user.password);
-
-      if (isPasswordValid) {
-        // No devolver la contraseña en la respuesta
-        const { password: _, ...userWithoutPassword } = user;
-        return userWithoutPassword;
-      } else {
-        return null;
-      }
-    } catch (error) {
-      console.error('[ERROR] UserModel.validateCredentials:', error);
-      return null;
-    }
-  }
-
-  /**
-   * Obtiene un usuario por su ID
-   * @param {number} id - ID del usuario
-   * @returns {Promise<Object|null>} - Usuario o null si no existe
-   */
-  async getUserById(id) {
-    try {
-      return await this.queryBuilder
-        .reset()
-        .select('*')
-        .where('id', id)
-        .first();
-    } catch (error) {
-      console.error('[ERROR] UserModel.getUserById:', error);
-      return null;
-    }
-  }
-
-  /**
-   * Obtiene un usuario por su nombre de usuario o email
-   * @param {string} identifier - Nombre de usuario o email
-   * @returns {Promise<Object|null>} - Usuario o null si no existe
-   */
-  async getUserByIdentifier(identifier) {
-    try {
-      return await this.queryBuilder
-        .reset()
-        .select('*')
-        .where(function(qb) {
-          qb.where('username', identifier).orWhere('email', identifier);
-        })
-        .first();
-    } catch (error) {
-      console.error('[ERROR] UserModel.getUserByIdentifier:', error);
-      return null;
-    }
-  }
-
-  /**
-   * Actualiza un usuario
-   * @param {number} id - ID del usuario
-   * @param {Object} updateData - Datos a actualizar
-   * @returns {Promise<Object>} - Usuario actualizado
-   */
-  async updateUser(id, updateData) {
-    try {
-      // Si se está actualizando la contraseña, encriptarla
-      if (updateData.password) {
-        updateData.password = await bcrypt.hash(updateData.password, 10);
-      }
-
-      await this.queryBuilder
-        .reset()
-        .update(updateData)
-        .where('id', id);
-
-      // Devolver el usuario actualizado
-      return await this.getUserById(id);
-    } catch (error) {
-      console.error('[ERROR] UserModel.updateUser:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Elimina un usuario
-   * @param {number} id - ID del usuario
-   * @returns {Promise<boolean>} - True si se eliminó correctamente
-   */
-  async deleteUser(id) {
-    try {
-      const result = await this.queryBuilder
-        .reset()
-        .delete()
-        .where('id', id);
-
-      return result.affectedRows > 0;
-    } catch (error) {
-      console.error('[ERROR] UserModel.deleteUser:', error);
-      throw error;
-    }
-  }
-}
-
-module.exports = UserModel;

package/test-aplicacion.con-logisession/models/tracking/CompletedCartModel.js

@@ -1,213 +0,0 @@
-/**
- * Modelo para la tabla de completed_carts en el framework JERK
- * Implementación del componente MVC CompletedCartModel.js
- * Utiliza MariaDB como adaptador de base de datos
- */
-
-const { ModelBase } = require('insitu-js');
-const { getSharedAdapter } = require('../../utils/dbAdapter');
-const { QueryBuilder } = require('insitu-js');
-
-class CompletedCartModel extends ModelBase {
-  constructor(options = {}) {
-    // Obtener el adaptador centralizado
-    const adapter = getSharedAdapter();
-
-    super({
-      ...options,
-      tableName: options.tableName || 'completed_carts', // Tabla por defecto
-      adapter: adapter
-    });
-
-    // Inicializar QueryBuilder con el adaptador centralizado
-    this.queryBuilder = new QueryBuilder(adapter, 'completed_carts');
-
-    // Definir campos del modelo
-    this.fields = {
-      id: { type: 'integer', primaryKey: true, autoIncrement: true },
-      session_header_id: { type: 'integer' },
-      event_type: { type: 'string', required: true },
-      created_at: { type: 'datetime' },
-      qty: { type: 'integer' },
-      product_id: { type: 'integer' },
-      sku: { type: 'string' },
-      product_name: { type: 'string' },
-      url: { type: 'string' },
-      price: { type: 'decimal' },
-      old_qty: { type: 'integer' },
-      new_qty: { type: 'integer' },
-      compressed_data: { type: 'text' },
-      data_hash: { type: 'string' },
-      event_timestamp: { type: 'datetime' },
-      session_id: { type: 'string' },
-      wtf_session: { type: 'string' },
-      site_url: { type: 'string' }
-    };
-  }
-
-  /**
-   * Consulta personalizada con paginación, filtros y búsqueda global
-   * @param {Object} filters - Filtros para la consulta
-   * @param {Object} pagination - Parámetros de paginación
-   * @param {string} search - Término de búsqueda global
-   * @returns {Promise<Object>} - Resultados con información de paginación
-   */
-  async queryWithFilters(filters = {}, pagination = {}, search = '') {
-    try {
-      // Mostrar parámetros de filtro para depuración
-      console.log('Filtros recibidos en CompletedCartModel queryWithFilters:', filters);
-
-      // Extraer parámetros de paginación
-      const offset = pagination.offset !== undefined ? parseInt(pagination.offset) : 0;
-      const limit = pagination.limit ? parseInt(pagination.limit) : 10;
-
-      // Extraer parámetros de filtro específicos para fechas
-      const { date_from, date_to, event_type, session_id, wtf_session, url, site_url } = filters;
-
-      // Construir condiciones WHERE dinámicamente
-      let whereConditions = [];
-      let whereParams = [];
-
-      // Filtro por fecha desde (date_from) - para event_timestamp
-      if (date_from) {
-        // Si la fecha no tiene hora (es solo YYYY-MM-DD), agregar hora mínima del día
-        let startDate = date_from;
-        if (date_from.length === 10) { // Formato YYYY-MM-DD
-          startDate = `${date_from} 00:00:00`;
-        }
-        console.log('Aplicando filtro: event_timestamp >=', startDate);
-        whereConditions.push('event_timestamp >= ?');
-        whereParams.push(startDate);
-      }
-
-      // Filtro por fecha hasta (date_to) - para event_timestamp
-      if (date_to) {
-        // Si la fecha de fin no tiene hora (es solo YYYY-MM-DD), agregar hora 23:59:59 para incluir todo el día
-        let endDate = date_to;
-        if (date_to.length === 10) { // Formato YYYY-MM-DD
-          endDate = `${date_to} 23:59:59`;
-        }
-        console.log('Aplicando filtro: event_timestamp <=', endDate);
-        whereConditions.push('event_timestamp <= ?');
-        whereParams.push(endDate);
-      }
-
-      // Filtros por campos específicos
-      if (event_type) {
-        whereConditions.push('event_type = ?');
-        whereParams.push(event_type);
-      }
-
-      if (session_id) {
-        whereConditions.push('session_id = ?');
-        whereParams.push(session_id);
-      }
-
-      if (wtf_session) {
-        whereConditions.push('wtf_session = ?');
-        whereParams.push(wtf_session);
-      }
-
-      if (url) {
-        whereConditions.push('url LIKE ?');
-        whereParams.push(`%${url}%`);
-      }
-
-      if (site_url) {
-        whereConditions.push('site_url = ?');
-        whereParams.push(site_url);
-      }
-
-      // Aplicar búsqueda global si se proporciona
-      if (search) {
-        // Campos en los que se realiza la búsqueda global
-        const searchFields = ['event_type', 'product_name', 'sku', 'url', 'session_id', 'wtf_session', 'site_url'];
-
-        const searchConditions = searchFields.map(field => `${field} LIKE ?`).join(' OR ');
-        whereConditions.push(`(${searchConditions})`);
-
-        // Agregar parámetros de búsqueda
-        searchFields.forEach(() => {
-          whereParams.push(`%${search}%`);
-        });
-      }
-
-      // Construir la cláusula WHERE completa
-      const whereClause = whereConditions.length > 0
-        ? 'WHERE ' + whereConditions.join(' AND ')
-        : 'WHERE 1=1'; // Asegurar que siempre haya una condición
-
-      // Consulta SQL para obtener los registros
-      const query = `
-        SELECT *
-        FROM completed_carts
-        ${whereClause}
-        ORDER BY id DESC
-        LIMIT ? OFFSET ?
-      `;
-
-      // Agregar parámetros de paginación
-      const allParams = [...whereParams, limit, offset];
-
-      // Usar el método complexQuery del QueryBuilder
-      const { QueryBuilder } = require('insitu-js');
-      const qb = new QueryBuilder(this.queryBuilder.adapter);
-      qb.complexQuery(query, allParams);
-
-      // Obtener los resultados
-      const rows = await qb.get();
-
-      // Consulta para obtener el conteo total con los mismos filtros
-      const countQuery = `
-        SELECT COUNT(*) as total
-        FROM completed_carts
-        ${whereClause}
-      `;
-
-      // Usar el método complexQuery del QueryBuilder para la consulta de conteo
-      const countQb = new QueryBuilder(this.queryBuilder.adapter);
-      countQb.complexQuery(countQuery, whereParams); // Sin parámetros de paginación
-
-      const countResult = await countQb.first();
-      const total = countResult ? countResult.total : 0;
-
-      return {
-        total: parseInt(total),
-        rows: rows
-      };
-    } catch (error) {
-      console.error(`Error en queryWithFilters para ${this.tableName}:`, error.message);
-      throw error;
-    }
-  }
-
-  /**
-   * Obtiene completed carts con paginación, filtros y búsqueda
-   * @param {Object} queryParams - Parámetros de consulta (offset, limit, search, filtros)
-   * @returns {Promise<Object>} - Resultados con información de paginación
-   */
-  async getCompletedCarts(queryParams = {}) {
-    // Obtener parámetros de paginación
-    const offset = parseInt(queryParams.offset) || 0;
-    const limit = parseInt(queryParams.limit) || 10;
-    const search = queryParams.search || '';
-
-    // Obtener otros parámetros de filtro excluyendo los de paginación y búsqueda
-    const filters = {};
-    for (const [key, value] of Object.entries(queryParams)) {
-      if (!['offset', 'limit', 'search', 'sort', 'order'].includes(key)) {
-        if (value !== '') {  // Solo añadir filtros que no estén vacíos
-          filters[key] = value;
-        }
-      }
-    }
-
-    return await this.queryWithFilters(
-      filters,
-      { offset, limit },
-      search
-    );
-  }
-}
-
-module.exports = CompletedCartModel;