blackcoffee2 2.1.0

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

@@ -0,0 +1,207 @@
+/**
+ * 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;