utn-cli 2.1.17 → 2.1.18

package/templates/backend/servicios/Nucleo/MiscelaneasMixins/Autenticacion.js

@@ -0,0 +1,388 @@
+const { ejecutarConsultaSIGU, crearObjetoConexionSIGU } = require('../db.js');
+const { envioDeCorreo } = require('../EnvioDeCorreos.js');
+const ManejadorDeErrores = require('../ManejadorDeErrores.js');
+
+module.exports = {
+
+  NombresParalocalhost() {
+    return ["localhost", "::", "127.0.0.1", "::1"];
+  },
+
+  async googleClientId() {
+    const clientId = await ejecutarConsultaSIGU("SELECT `Valor` FROM `SIGU`.`SIGU_VariablesDeSistema` WHERE `Nombre` = 'Google-ClientId'");
+    return clientId[0]?.['Valor'] || '';
+  },
+
+  async palabraSecretaParaTokens() {
+    const palabraSecreta = await ejecutarConsultaSIGU("SELECT `Valor` FROM `SIGU`.`SIGU_VariablesDeSistema` WHERE `Nombre` = 'PalabraSecretaParaLaCreacionDeTokens'");
+    return palabraSecreta[0]['Valor'];
+  },
+
+  comparacionDeCadenas(cadena1, cadena2) {
+    const cadenaA = String(cadena1);
+    let cadenaB = String(cadena2);
+    const tamanioDeCadelaA = cadenaA.length;
+    let resultado = 0;
+    if (tamanioDeCadelaA !== cadenaB.length) {
+      cadenaB = cadenaA;
+      resultado = 1;
+    }
+    for (let contador = 0; contador < tamanioDeCadelaA; contador++) {
+      resultado |= (cadenaA.charCodeAt(contador) ^ cadenaB.charCodeAt(contador));
+    }
+    return resultado === 0;
+  },
+
+  async generarLastUser(Solicitud) {
+    const Resultado = await this.obtenerDatosDelUsuario(Solicitud.headers.authorization);
+    let LastUser = '';
+    if (Resultado) {
+      LastUser = Resultado.Identificador;
+    }
+    LastUser = LastUser + '@' + Solicitud.headers.host.trim()
+      + '@' + Solicitud.headers["user-agent"].trim()
+      + '@' + (Solicitud.ip || Solicitud.headers['x-forwarded-for'] || Solicitud.socket.remoteAddress);
+    return LastUser;
+  },
+
+  async obtenerDatosDelUsuario(encabezadoDeAutorizacion) {
+    const jwt = require('jsonwebtoken');
+    let token = undefined;
+    try {
+      token = encabezadoDeAutorizacion.split(" ")[1];
+      if (!token) {
+        throw new ManejadorDeErrores(ManejadorDeErrores.mensajeDeErrorEncabezadoDeAutorizacion(), ManejadorDeErrores.obtenerNumeroDeLinea(), encabezadoDeAutorizacion);
+      }
+    } catch (error) {
+      console.error(error);
+      return false;
+    }
+    let Resultado = undefined;
+    try {
+      Resultado = await jwt.verify(token, await this.palabraSecretaParaTokens());
+      if (!Resultado) {
+        throw new ManejadorDeErrores(ManejadorDeErrores.mensajeDeErrorVerificacionDeToken(), ManejadorDeErrores.obtenerNumeroDeLinea(), encabezadoDeAutorizacion);
+      }
+      Resultado.token = token;
+      const DatosDeLaPersona = await ejecutarConsultaSIGU("SELECT `Identificacion`, `Nombre`, `PrimerApellido`,\
+        `SegundoApellido`, CONCAT(`FechaNacimiento`) AS `FechaDeNacimiento`\
+        FROM `SIGU`.`SIGU_Personas` WHERE `Identificador` = ?", [Resultado.Identificador]);
+      Resultado.Identificacion = DatosDeLaPersona[0]['Identificacion'];
+      Resultado.Nombre = DatosDeLaPersona[0]['Nombre'];
+      Resultado.PrimerApellido = DatosDeLaPersona[0]['PrimerApellido'];
+      Resultado.SegundoApellido = DatosDeLaPersona[0]['SegundoApellido'];
+      Resultado.FechaDeNacimiento = DatosDeLaPersona[0]['FechaDeNacimiento'];
+      return Resultado;
+    } catch (error) {
+      console.error(error);
+      return false;
+    }
+  },
+
+  async verificarToken(Token) {
+    let Resultado = undefined;
+    try {
+      Resultado = await this.obtenerDatosDelUsuario(`Bearer ${Token}`);
+    } catch (error) {
+      console.error(error);
+    }
+    return Resultado;
+  },
+
+  async validarTokenV2(encabezadoDeAutorizacion, permisoExtraId = undefined) {
+    let Resultado = undefined;
+    try {
+      Resultado = await this.obtenerDatosDelUsuario(encabezadoDeAutorizacion);
+    } catch (error) {
+      console.error(error);
+    }
+    if (Resultado) {
+      try {
+        const tokenAlmacenado = await ejecutarConsultaSIGU("SELECT COUNT(*) AS `Total` FROM `SIGU`.`SIGU_Sesiones`\
+          WHERE `Identificador` = ? AND `Token` = ?", [Resultado.Identificador, Resultado.token]);
+        if (tokenAlmacenado[0]['Total'] >= 1) {
+          const rolPermisoId = await this.permisoIdV2();
+          const permisos = await ejecutarConsultaSIGU("SELECT COUNT(*) AS `Total` FROM `SIGU`.`SIGU_PermisosPersonasV2`\
+            WHERE `PermisoId` = ? AND `Identificador` = ?", [rolPermisoId, Resultado.Identificador]);
+          if (permisos[0]['Total'] === 1) {
+            if (permisoExtraId) {
+              const ValidacionPermisoExtra = await ejecutarConsultaSIGU("SELECT COUNT(*) AS `Total` FROM `SIGU`.`SIGU_PermisosExtraPersonasV2`\
+                WHERE `PermisoExtraId` = ? AND `Identificador` = ?", [permisoExtraId, Resultado.Identificador]);
+              if (ValidacionPermisoExtra[0]['Total'] === 1) return true;
+            } else {
+              return true;
+            }
+          } else {
+            throw new ManejadorDeErrores(ManejadorDeErrores.mensajeDeErrorPermisosInsuficientes(), ManejadorDeErrores.obtenerNumeroDeLinea());
+          }
+        } else {
+          throw new ManejadorDeErrores(ManejadorDeErrores.mensajeDeErrorTokenInvalido(), ManejadorDeErrores.obtenerNumeroDeLinea());
+        }
+      } catch (error) {
+        console.error(error);
+        return false;
+      }
+    }
+    return false;
+  },
+
+  async validarToken(encabezadoDeAutorizacion) {
+    return await this.validarTokenV2(encabezadoDeAutorizacion);
+  },
+
+  async validarIdentificadorAPI(Encabezados) {
+    let Identificador = undefined;
+    try {
+      Identificador = Encabezados.authorization.split(" ")[1];
+      if (!Identificador) throw new ManejadorDeErrores(ManejadorDeErrores.mensajeDeErrorEncabezadoDeAutorizacion(), ManejadorDeErrores.obtenerNumeroDeLinea());
+    } catch (error) {
+      console.error(error);
+      return false;
+    }
+    let Repositorio = undefined;
+    try {
+      Repositorio = Encabezados.referrer;
+      if (!Repositorio) throw new ManejadorDeErrores(ManejadorDeErrores.mensajeDeErrorRepositorioOrigen(), ManejadorDeErrores.obtenerNumeroDeLinea());
+    } catch (error) {
+      console.error(error);
+      return false;
+    }
+    let ComprobacionDeRepositorio = undefined;
+    try {
+      ComprobacionDeRepositorio = await ejecutarConsultaSIGU("SELECT COUNT(*) AS `Total` FROM `SIGU`.`SIGU_Repositorios`\
+        WHERE `Repositorio` = ? AND `Identificador` = ?", [Repositorio, Identificador]);
+      if (ComprobacionDeRepositorio[0]['Total'] === 0) {
+        throw new ManejadorDeErrores(ManejadorDeErrores.mensajeDeErrorRepositorioOrigen(), ManejadorDeErrores.obtenerNumeroDeLinea());
+      } else {
+        let ComprobacionDeAcceso = undefined;
+        try {
+          ComprobacionDeAcceso = await ejecutarConsultaSIGU("SELECT COUNT(*) AS `Total` FROM `SIGU`.`SIGU_RepositoriosAccesos`\
+            WHERE `RepositorioDestino` = ? AND `RepositorioOrigen` = ?", [this.NombreDelRepositorioDelBackend, Repositorio]);
+          if (ComprobacionDeAcceso[0]['Total'] === 1) return true;
+          else throw new ManejadorDeErrores(ManejadorDeErrores.mensajeDeErrorPermisosInsuficientes(), ManejadorDeErrores.obtenerNumeroDeLinea());
+        } catch (error) {
+          console.error(error);
+          return false;
+        }
+      }
+    } catch (error) {
+      console.error(error);
+      return false;
+    }
+  },
+
+  async validarUsuarioYContrasenia(Cuerpo) {
+    const crypto = require('crypto');
+    const bcrypt = require('bcryptjs');
+    const resultados = await ejecutarConsultaSIGU("SELECT `Clave` FROM `SIGU`.`SIGU_Personas` WHERE `Activo` = TRUE AND `Identificacion` = ?", [Cuerpo.body.Identificacion]);
+    if (resultados.length != 1) {
+      throw new ManejadorDeErrores(ManejadorDeErrores.mensajeDeErrorAccesoAAPI("El usuario " + Cuerpo.body.Identificacion + " no existe"), ManejadorDeErrores.obtenerNumeroDeLinea());
+    }
+    const Resultado = await bcrypt.compare(crypto.createHash('md5').update(Cuerpo.body.Clave).digest("hex"), resultados[0]['Clave']);
+    if (!Resultado) {
+      const Mensaje = "Desactivación del usario: " + Cuerpo.body.Identificacion + " por fallo de autenticación.";
+      console.log(Mensaje);
+      const solicitudCompleta = { metodo: Cuerpo.method, url: Cuerpo.originalUrl, ip: Cuerpo.ip, headers: Cuerpo.headers, query: Cuerpo.query, params: Cuerpo.params, body: Cuerpo.body };
+      const contenidoHTML = `<h2>Solicitud HTTP completa</h2><p><strong>Método:</strong> ${solicitudCompleta.metodo}</p><p><strong>URL:</strong> ${solicitudCompleta.url}</p><p><strong>IP:</strong> ${solicitudCompleta.ip}</p><h3>Headers:</h3><pre>${JSON.stringify(solicitudCompleta.headers, null, 2)}</pre><h3>Query:</h3><pre>${JSON.stringify(solicitudCompleta.query, null, 2)}</pre><h3>Params:</h3><pre>${JSON.stringify(solicitudCompleta.params, null, 2)}</pre><h3>Body:</h3><pre>${JSON.stringify(solicitudCompleta.body, null, 2)}</pre>`;
+      envioDeCorreo(process.env.DESTINATARIODEINFORMESDEERROR, Mensaje, contenidoHTML);
+      await ejecutarConsultaSIGU("UPDATE `SIGU`.`SIGU_Personas` SET `Activo` = FALSE WHERE `Identificacion` = ?", [Cuerpo.body.Identificacion]);
+    }
+    return Resultado;
+  },
+
+  async restablecimientoDeClave(Solicitud) {
+    let Clave = await ejecutarConsultaSIGU("SELECT MD5(NOW(4)) AS `Dato`");
+    Clave = Clave[0]['Dato'];
+    console.log("El usuario: " + Solicitud.body.Identificacion + " ha solicitado restablecer su clave de acceso.");
+    const CorreoElectronico = await ejecutarConsultaSIGU("SELECT `CorreoElectronico`, `Identificador` FROM `SIGU`.`SIGU_CorreosPersona` WHERE `Identificador` = (SELECT `Identificador` FROM `SIGU`.`SIGU_Personas` WHERE `Identificacion` = ?) AND `Principal` = TRUE LIMIT 1", [Solicitud.body.Identificacion]);
+    const LastUser = Solicitud.body.Identificacion + '@' + Solicitud.headers.host.trim() + '@' + Solicitud.headers["user-agent"].trim() + '@' + (Solicitud.ip || Solicitud.headers['x-forwarded-for'] || Solicitud.socket.remoteAddress);
+    await ejecutarConsultaSIGU("REPLACE INTO `SIGU`.`SIGU_ClavesTemporalesDeLasPersonas` VALUES (?, ?, NOW(4), ?)", [CorreoElectronico[0]['Identificador'], Clave, LastUser]);
+    const SolicitudTextual = JSON.stringify({ timestamp: new Date().toISOString(), httpVersion: Solicitud.httpVersion, method: Solicitud.method, protocol: Solicitud.protocol, secure: Solicitud.secure, ip: Solicitud.ip, ips: Solicitud.ips, hostname: Solicitud.hostname, originalUrl: Solicitud.originalUrl, baseUrl: Solicitud.baseUrl, path: Solicitud.path, url: Solicitud.url, headers: Solicitud.headers, query: Solicitud.query, params: Solicitud.params, body: Solicitud.body, cookies: Solicitud.cookies, signedCookies: Solicitud.signedCookies, userAgent: Solicitud.get('User-Agent'), authUser: Solicitud.user ?? null });
+    await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_SolicitudesDeRestablecimientoDeClave` VALUES (?, ?, ?, NOW(4), ?)", [CorreoElectronico[0]['Identificador'], Solicitud.body.Identificacion, SolicitudTextual, LastUser]);
+    await envioDeCorreo(CorreoElectronico[0]['CorreoElectronico'], "Solicitud de restablecimiento de clave",
+      "<p>Estimada persona usuaria,<br /><br />Se ha realizado una solicitud de cambio de clave para su cuenta de acceso a SIGU.</p>"
+      + "<p>Para continuar con el cambio por favor presione <a href='" + this.EnlaceDeAcceso + "/?Identificacion=" + Solicitud.body.Identificacion + "'>aquí</a> de lo contrario omita este mensaje.</p>"
+      + "<p>Su nueva clave es: " + Clave + " y se le invita a cambiarla lo antes posible haciendo uso del sistema.</p>"
+      + "<p>La vigencia de la clave generada es de 10 minutos, luego de eso se eliminará la solicitud.</p>"
+      + "<p>Si usted no solicitó el cambio de contraseña por favor omita este correo.</p>");
+    return;
+  },
+
+  async AutenticarConGoogle(Solicitud) {
+    const { OAuth2Client } = require('google-auth-library');
+    const jwt = require('jsonwebtoken');
+    const clientId = await this.googleClientId();
+    const client = new OAuth2Client(clientId);
+    const ConexionSigu = await crearObjetoConexionSIGU();
+    const LastUser = await this.generarLastUser(Solicitud);
+    try {
+      const ticket = await client.verifyIdToken({ idToken: Solicitud.body.token, audience: clientId });
+      const payload = ticket.getPayload();
+      const email = payload['email'];
+      const resultadosEmail = await ConexionSigu.query("SELECT `Identificador` FROM `SIGU`.`SIGU_CorreosPersona` WHERE `CorreoElectronico` = ? AND `Principal` = TRUE LIMIT 1", [email]);
+      if (resultadosEmail[0].length === 0) {
+        console.log("El correo de Google", email, "no está registrado como principal en SIGU");
+        return { error: "Su cuenta de Google no está vinculada a ningún usuario de SIGU." };
+      }
+      const Identificador = resultadosEmail[0][0]['Identificador'];
+      const resultadosUsuario = await ConexionSigu.query("SELECT `Identificacion` FROM `SIGU`.`SIGU_Personas` WHERE `Identificador` = ? AND `Activo` = TRUE", [Identificador]);
+      if (resultadosUsuario[0].length === 0) return { error: "El usuario asociado a esta cuenta no está activo." };
+      const Token = await jwt.sign({ Identificador: Identificador, uid: Identificador }, await this.palabraSecretaParaTokens(), { expiresIn: '2h' });
+      await ConexionSigu.query("INSERT INTO `SIGU`.`SIGU_Sesiones` VALUES (?, ?, ?, NOW(4), ?) ON DUPLICATE KEY UPDATE `Token` = ?, `LastUser` = ?", [Identificador, Solicitud.headers.host.trim(), Token, LastUser, Token, LastUser]);
+      await ConexionSigu.query("DELETE FROM `SIGU`.`SIGU_SesionesFallidas` WHERE `Identificador` = ?", [Identificador]);
+      const ipUsuario = (Solicitud.headers['x-forwarded-for'] || '').split(',').shift() || Solicitud.socket?.remoteAddress || Solicitud.connection?.remoteAddress || '-';
+      await ConexionSigu.query("INSERT INTO `SIGU`.`SIGU_DireccionesUsadasPorLosUsuarios` (`DireccionUsadaPorElUsuario`, `Identificador`, `LastUpdate`, `LastUser`) VALUES (?, ?, NOW(4), ?) ON DUPLICATE KEY UPDATE `LastUpdate` = NOW(4), `LastUser` = ?;", [ipUsuario, Identificador, LastUser, LastUser]);
+      return { Token, Dominio: ((process.env.ENV || 'local') === 'production' ? '.sigu.utn.ac.cr' : '.181.193.85.44.nip.io') };
+    } catch (error) {
+      console.error("Error en AutenticarConGoogle:", error);
+      return { error: "Error al autenticar con Google" };
+    } finally {
+      if (ConexionSigu) await ConexionSigu.end();
+    }
+  },
+
+  async Autenticar(Solicitud) {
+    const crypto = require('crypto');
+    const bcrypt = require('bcryptjs');
+    const jwt = require('jsonwebtoken');
+    const LastUser = await this.generarLastUser(Solicitud);
+    const ConexionSigu = await crearObjetoConexionSIGU();
+    try {
+      const resultados = await ConexionSigu.query("SELECT `Identificador`, `Clave` FROM `SIGU`.`SIGU_Personas` WHERE `Activo` = TRUE AND `Identificacion` = ?", [Solicitud.body.Identificacion]);
+      const Identificador = resultados[0][0]['Identificador'];
+      const Resultado = await bcrypt.compare(crypto.createHash('md5').update(Solicitud.body.Clave).digest("hex"), resultados[0][0]['Clave']);
+      if (Resultado) {
+        console.log("La clave brindada para el usuario", Solicitud.body.Identificacion, "coincide");
+        const Token = await jwt.sign({ Identificador: Identificador, uid: Identificador }, await this.palabraSecretaParaTokens(), { expiresIn: '2h' });
+        await ConexionSigu.query("INSERT INTO `SIGU`.`SIGU_Sesiones` VALUES (?, ?, ?, NOW(4), ?) ON DUPLICATE KEY UPDATE `Token` = ?, `LastUser` = ?", [Identificador, Solicitud.headers.host.trim(), Token, LastUser, Token, LastUser]);
+        await ConexionSigu.query("DELETE FROM `SIGU`.`SIGU_SesionesFallidas` WHERE `Identificador` = ?", [Identificador]);
+        const permisos = await ConexionSigu.query("WITH RECURSIVE`ModulosJerarquia` AS( SELECT`Nombre`, `Padre` FROM`SIGU`.`SIGU_ModulosV2` WHERE`Nombre` COLLATE utf8mb4_spanish_ci IN( SELECT`Modulo` FROM`SIGU`.`SIGU_PermisosV2` WHERE`Nombre` LIKE '%Público%' ) UNION ALL SELECT`m`.`Nombre`, `m`.`Padre` FROM`SIGU`.`SIGU_ModulosV2` `m` INNER JOIN`ModulosJerarquia` `mj` ON`mj`.`Padre` COLLATE utf8mb4_spanish_ci = `m`.`Nombre` COLLATE utf8mb4_spanish_ci ) SELECT DISTINCT `p`.`PermisoId` FROM`ModulosJerarquia` `mj` JOIN`SIGU`.`SIGU_PermisosV2` `p` ON`p`.`Modulo` COLLATE utf8mb4_spanish_ci = `mj`.`Nombre` COLLATE utf8mb4_spanish_ci;");
+        for (const permiso of permisos[0]) {
+          await ConexionSigu.query("INSERT INTO `SIGU`.`SIGU_PermisosPersonasV2` (`PermisoId`, `Identificador`, `LastUpdate`, `LastUser`) VALUES (?, ?, NOW(4), USER()) ON DUPLICATE KEY UPDATE `LastUser` = USER(), `LastUpdate` = NOW(4);", [permiso.PermisoId, Identificador]);
+        }
+        const ipUsuario = (Solicitud.headers['x-forwarded-for'] || '').split(',').shift() || Solicitud.socket?.remoteAddress || Solicitud.connection?.remoteAddress || '-';
+        const ipExiste = await ConexionSigu.query("SELECT COUNT(*) AS Total FROM `SIGU`.`SIGU_DireccionesUsadasPorLosUsuarios` WHERE `Identificador` = ? AND `DireccionUsadaPorElUsuario` = ?", [Identificador, ipUsuario]);
+        const fechaUltimoCambio = await ConexionSigu.query("SELECT LastUpdate FROM `SIGU`.`SIGU_FechaDelUltimoCambioDeClave` WHERE `Identificador` = ?", [Identificador]);
+        let fechaBD = fechaUltimoCambio?.[0]?.[0]?.LastUpdate;
+        const fechaUltimo = new Date(fechaBD);
+        const fechaActual = new Date();
+        const diasPasados = (fechaActual - fechaUltimo) / (1000 * 60 * 60 * 24);
+        if (!fechaBD || diasPasados >= 60) {
+          await ConexionSigu.query("UPDATE`SIGU_Personas` SET`Clave` = '' where`Identificador` = ? ;", [Identificador]);
+          return { RequiereCambioContraseña: true };
+        }
+        if (ipExiste[0][0].Total === 0) {
+          let Codigo2FA = await ConexionSigu.query("SELECT UUID() AS `Dato`");
+          Codigo2FA = Codigo2FA[0][0].Dato;
+          await ConexionSigu.query("REPLACE INTO `SIGU`.`SIGU_CodigosDe2FAParaLosUsuarios` VALUES (?, ?, NOW(4), ?)", [Identificador, Codigo2FA, LastUser]);
+          const CorreoElectronico = await ConexionSigu.query("SELECT `CorreoElectronico` FROM `SIGU`.`SIGU_CorreosPersona` WHERE `Identificador` = ? AND `Principal` = TRUE", [Identificador]);
+          await envioDeCorreo(CorreoElectronico[0][0].CorreoElectronico, "Código de verificación 2FA", "<p>Hemos recibido su solicitud de acceso para 2FA.</p><p>Para continuar con el proceso, por favor utilice el siguiente código único de verificación:</p><p>" + Codigo2FA + "</p><p>Si usted no inició este proceso, puede ignorar este mensaje.</p>");
+          return { Requiere2FA: true };
+        }
+        await ConexionSigu.query("INSERT INTO `SIGU`.`SIGU_DireccionesUsadasPorLosUsuarios` (`DireccionUsadaPorElUsuario`, `Identificador`, `LastUpdate`, `LastUser`) VALUES (?, ?, NOW(4), ?) ON DUPLICATE KEY UPDATE `LastUpdate` = NOW(4), `LastUser` = ?;", [ipUsuario, Identificador, LastUser, LastUser]);
+        return { Token, Dominio: ((process.env.ENV || 'local') === 'production' ? '.sigu.utn.ac.cr' : '.svc.cluster.local') };
+      } else {
+        console.log("La clave brindada para el usuario", Solicitud.body.Identificacion, "no conincide");
+        const Resultados2 = await ConexionSigu.query("SELECT COUNT(*) AS `Total` FROM `SIGU`.`SIGU_ClavesTemporalesDeLasPersonas` WHERE `Identificador` = ? AND `Clave` = ?", [Identificador, Solicitud.body.Clave]);
+        if (Resultados2[0][0]['Total'] > 0) {
+          console.log("La clave brindada para el usuario", Solicitud.body.Identificacion, "no conincide, pero coincide la clave temporal");
+          await ConexionSigu.query("UPDATE `SIGU`.`SIGU_Personas` SET `Clave` = ?, `LastUpdate` = NOW(4), `LastUser` = ? WHERE `Identificacion` = ?", [await bcrypt.hash(require('crypto').createHash('md5').update(Solicitud.body.Clave).digest("hex"), 10), LastUser, Solicitud.body.Identificacion]);
+          await ConexionSigu.query("REPLACE INTO `SIGU`.`SIGU_FechaDelUltimoCambioDeClave` VALUES (?, NOW(), ?);", [Identificador, LastUser]);
+          await ConexionSigu.query("DELETE FROM `SIGU`.`SIGU_ClavesTemporalesDeLasPersonas`WHERE `Identificador` = ?", [Identificador]);
+          return await this.Autenticar(Solicitud);
+        } else {
+          await ConexionSigu.query("INSERT INTO `SIGU`.`SIGU_SesionesFallidas` VALUES (?, ?, NOW(4))", [Identificador, Solicitud.headers.host.trim()]);
+        }
+      }
+    } catch (error) {
+      console.log(error);
+      return;
+    } finally {
+      if (ConexionSigu) await ConexionSigu.end();
+    }
+    return;
+  },
+
+  async Verificar2FA(Solicitud) {
+    const jwt = require('jsonwebtoken');
+    const ConexionSigu = await crearObjetoConexionSIGU();
+    const LastUser = await this.generarLastUser(Solicitud);
+    try {
+      const { Identificacion, Codigo } = Solicitud.body;
+      const resultados = await ConexionSigu.query("SELECT `Identificador` FROM `SIGU`.`SIGU_Personas` WHERE `Activo` = TRUE AND `Identificacion` = ?", [Identificacion]);
+      if (!resultados[0].length) return { error: "Usuario no encontrado" };
+      const Identificador = resultados[0][0]['Identificador'];
+      const codigoValido = await ConexionSigu.query("SELECT COUNT(*) AS Total FROM `SIGU`.`SIGU_CodigosDe2FAParaLosUsuarios` WHERE `Identificador` = ? AND `CodigoDe2FAParaElUsuario` = ?", [Identificador, Codigo]);
+      if (codigoValido[0][0].Total === 0) {
+        await ConexionSigu.query("DELETE FROM `SIGU`.`SIGU_CodigosDe2FAParaLosUsuarios` WHERE `Identificador` = ? ", [Identificador]);
+        return { error: "Código inválido" };
+      }
+      await ConexionSigu.query("DELETE FROM `SIGU`.`SIGU_CodigosDe2FAParaLosUsuarios` WHERE `Identificador` = ?", [Identificador]);
+      const ipUsuario = (Solicitud.headers['x-forwarded-for'] || '').split(',').shift() || Solicitud.socket?.remoteAddress || Solicitud.connection?.remoteAddress || '-';
+      await ConexionSigu.query("INSERT INTO `SIGU`.`SIGU_DireccionesUsadasPorLosUsuarios` (`DireccionUsadaPorElUsuario`, `Identificador`, `LastUpdate`, `LastUser`) VALUES (?, ?, NOW(4), ?) ON DUPLICATE KEY UPDATE `LastUpdate` = NOW(4), `LastUser` = ?;", [ipUsuario, Identificador, LastUser, LastUser]);
+      const Token = await jwt.sign({ Identificador: Identificador, uid: Identificador }, await this.palabraSecretaParaTokens(), { expiresIn: '2h' });
+      await ConexionSigu.query("INSERT INTO `SIGU`.`SIGU_Sesiones` VALUES (?, ?, ?, NOW(4), ?) ON DUPLICATE KEY UPDATE `Token` = ?, `LastUser` = ?", [Identificador, Solicitud.headers.host.trim(), Token, LastUser, Token, LastUser]);
+      return { Token, Dominio: ((process.env.ENV || 'local') === 'production' ? '.sigu.utn.ac.cr' : '-') };
+    } catch (error) {
+      console.log(error);
+      return { error: "Error verificando 2FA" };
+    } finally {
+      if (ConexionSigu) await ConexionSigu.end();
+    }
+  },
+
+  async iniciarSesion() {
+    return this.EnlaceDeAcceso;
+  },
+
+  async cerrarSesion(Token) {
+    let Resultado = undefined;
+    try {
+      Resultado = await this.obtenerDatosDelUsuario(Token);
+      if (!Resultado) throw new ManejadorDeErrores(ManejadorDeErrores.mensajeDeErrorVerificacionDeToken(), ManejadorDeErrores.obtenerNumeroDeLinea());
+    } catch (error) {
+      console.log(error);
+      return;
+    }
+    await ejecutarConsultaSIGU("DELETE FROM `SIGU`.`SIGU_Sesiones` WHERE `Token` = ?", [Token.split(" ")[1]]);
+    return this.EnlaceDeAcceso;
+  },
+
+  async cerrarSesionPorToken(Token) {
+    await ejecutarConsultaSIGU("DELETE FROM `SIGU`.`SIGU_Sesiones` WHERE `Token` = ?", [Token]);
+    return true;
+  },
+
+  async crearToken(Identificador) {
+    let Token = undefined;
+    if (this.NombresParalocalhost().includes(process.env.HOST) && (typeof process.env.DB_HOST_SIGU === "undefined")) {
+      const jwt = require('jsonwebtoken');
+      Token = await jwt.sign({ uid: Identificador, Identificador }, await this.palabraSecretaParaTokens(), { expiresIn: '10h' });
+      await ejecutarConsultaSIGU("DELETE FROM `SIGU`.`SIGU_Sesiones` WHERE `Identificador` = ?", [Identificador]);
+      await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_Sesiones` VALUES (?, 'Backend', ?, NOW(4), USER())", [Identificador, Token]);
+    }
+    const fs = require('fs');
+    const ExpresionRegular = new RegExp(/[A-Za-z0-9_-]{30,}\.[A-Za-z0-9_-]{30,}\.[A-Za-z0-9_-]{30,}/, 'g');
+    let ArchivoREST = process.cwd() + '/index.rest';
+    let contenido = fs.readFileSync(ArchivoREST, 'utf-8');
+    let contenidoActualizado = contenido.replace(ExpresionRegular, Token);
+    fs.writeFileSync(ArchivoREST, contenidoActualizado);
+    ArchivoREST = process.cwd() + '/' + this.NombreCanonicoDelModulo + '.rest';
+    contenido = fs.readFileSync(ArchivoREST, 'utf-8');
+    contenidoActualizado = contenido.replace(ExpresionRegular, Token);
+    fs.writeFileSync(ArchivoREST, contenidoActualizado);
+    try {
+      const CWD = process.cwd();
+      process.chdir('..');
+      ArchivoREST = process.cwd() + '/' + this.NombreDelRepositorioDelFrontend + '/src/app/datos-globales.service.ts';
+      process.chdir(CWD);
+      contenido = fs.readFileSync(ArchivoREST, 'utf-8');
+      contenidoActualizado = contenido.replace(ExpresionRegular, Token);
+      fs.writeFileSync(ArchivoREST, contenidoActualizado);
+    } catch (error) {
+      console.warn("No fue posible actualizar el archivo datos-globales.service.ts del front: ", error);
+    }
+    return Token;
+  },
+
+};

package/templates/backend/servicios/Nucleo/MiscelaneasMixins/InicializacionDelModulo.js

@@ -0,0 +1,254 @@
+const { ejecutarConsulta, ejecutarConsultaSIGU } = require('../db.js');
+const ManejadorDeErrores = require('../ManejadorDeErrores.js');
+const { envioDeCorreo } = require('../EnvioDeCorreos.js');
+
+module.exports = {
+
+  async validarAccesoDelOrigen(Solicitud) {
+    if (this.NombresParalocalhost().includes(process.env.HOST) && (typeof process.env.DB_HOST_SIGU === "undefined")) {
+      return true;
+    }
+    const Resultado = await ejecutarConsultaSIGU("SELECT COUNT(*) AS `Total` FROM `SIGU`.`SIGU_RepositoriosAccesos`\
+      WHERE `RepositorioDestino` = ? AND `RepositorioOrigen` = ?"
+      , [this.NombreDelRepositorioDelBackend, this.NombreDelRepositorioDelFrontend]);
+    if (Resultado[0]['Total'] === 1) {
+      return true;
+    } else {
+      console.error('validarAccesoDelOrigen:', Solicitud.headers.origin, 'intentó consumir a:', this.NombreDelRepositorioDelBackend);
+      const Mensaje = "Error de validarAccesoDelOrigen por fallo de autorización.";
+      const solicitudCompleta = {
+        metodo: Solicitud.method,
+        url: Solicitud.originalUrl,
+        ip: Solicitud.ip,
+        headers: Solicitud.headers,
+        query: Solicitud.query,
+        params: Solicitud.params,
+        body: Solicitud.body,
+      };
+      const contenidoHTML = `
+        <h2>Solicitud HTTP completa</h2>
+        <p><strong>Método:</strong> ${solicitudCompleta.metodo}</p>
+        <p><strong>URL:</strong> ${solicitudCompleta.url}</p>
+        <p><strong>IP:</strong> ${solicitudCompleta.ip}</p>
+        <h3>Headers:</h3>
+        <pre>${JSON.stringify(solicitudCompleta.headers, null, 2)}</pre>
+        <h3>Query:</h3>
+        <pre>${JSON.stringify(solicitudCompleta.query, null, 2)}</pre>
+        <h3>Params:</h3>
+        <pre>${JSON.stringify(solicitudCompleta.params, null, 2)}</pre>
+        <h3>Body:</h3>
+        <pre>${JSON.stringify(solicitudCompleta.body, null, 2)}</pre>
+      `;
+      envioDeCorreo(process.env.DESTINATARIODEINFORMESDEERROR, Mensaje, contenidoHTML);
+    }
+    return false;
+  },
+
+  async obtenerDetalleDelModulo() {
+    const Modulos = await ejecutarConsultaSIGU("SELECT `a`.`Nombre`, `a`.`Padre`, `a`.`Descripcion`, `a`.`Detalle`,\
+        `a`.`Tipo`, IF(`a`.`Icono` <> '', CONCAT('https://storage.sigu.utn.ac.cr/images/cards/', `a`.`Icono`), '') AS `Icono`, `a`.`Color`, `a`.`Correo`,\
+        `a`.`Version`, `a`.`FechaDePublicacion`, `a`.`AcuerdoDeNivelDeServicio`, `a`.`DiccionarioDeDatos`, `a`.`Repositorios`,\
+        `a`.`EnlaceDelVideo`,`a`.`EnlaceDelManual`\
+        , `a`.`Estado`, REGEXP_SUBSTR(SUBSTRING_INDEX(`a`.`Repositorios`, '/', -1), '[^,]*front[^,]*') AS `Frontend`\
+      FROM `SIGU`.`SIGU_ModulosV2` `a`\
+      WHERE `a`.`Nombre` = ?", [this.NombreCanonicoDelModulo]);
+    return Modulos.map((linea) => {
+      linea.Enlace = this.generarEnlace(linea.Frontend);
+      return linea;
+    });
+  },
+
+  async registrarVistaDelManual(Token) {
+    const { uid } = await this.obtenerDatosDelUsuario(Token);
+    await ejecutarConsulta(
+      "INSERT INTO `DatosMiscelaneos` (`DatoMiscelaneo`, `Datos`, `LastUser`) VALUES ('VistasDelManual', JSON_OBJECT('Total', 1), ?) ON DUPLICATE KEY UPDATE `Datos` = JSON_SET(`Datos`, '$.Total', CAST(JSON_VALUE(`Datos`, '$.Total') AS UNSIGNED) + 1), `LastUser` = ?",
+      [uid, uid]
+    );
+  },
+
+  async obtenerMensajesModulares() {
+    return await ejecutarConsultaSIGU("SELECT `MensajeModularId`, `Titulo`, `Texto`, `FechaYHoraDeInicio`, `FechaYHoraDeFinalizacion` FROM  `SIGU`.`SIGU_MensajesModulares` WHERE NOW(4) BETWEEN `FechaYHoraDeInicio` AND `FechaYHoraDeFinalizacion` AND `Modulo` = ?"
+      , [this.NombreCanonicoDelModulo]);
+  },
+
+  async obtenerMensajesInstitucionales() {
+    return await ejecutarConsultaSIGU("SELECT `MensajeInstitucionalId`, `Titulo`, `Texto`, `FechaYHoraDeInicio`, `FechaYHoraDeFinalizacion` FROM  `SIGU`.`SIGU_MensajesInstitucionales` WHERE NOW(4) BETWEEN `FechaYHoraDeInicio` AND `FechaYHoraDeFinalizacion`");
+  },
+
+  async obtenerConsentimientoInformado(Modulo = undefined) {
+    if (Modulo === undefined) {
+      Modulo = this.NombreCanonicoDelModulo;
+    }
+    let Datos = await ejecutarConsultaSIGU("SELECT `ConsentimientoInformadoId`, `Titulo`, `Texto`, `TextoDeAceptacion` FROM `SIGU`.`SIGU_ConsentimientosInformadosV2`\
+      WHERE `Estado` = 'Activo' AND `Modulo` = ? AND `Titulo` <> 'Versión del módulo'", [Modulo]);
+    if (Datos.length === 0) {
+      Datos = await ejecutarConsultaSIGU("SELECT `ConsentimientoInformadoId`, `Titulo`, `Texto`, `TextoDeAceptacion` FROM `SIGU`.`SIGU_ConsentimientosInformadosV2`\
+      WHERE `Estado` = 'Activo' AND `Modulo` = ? AND `Titulo` <> 'Versión del módulo'", [this.NombreCanonicoDelModulo]);
+    }
+    return Datos[0];
+  },
+
+  async creacionDeConsetimientoInformado(Titulo, Texto, TextoDeAceptacion) {
+    return await ejecutarConsultaSIGU("UPDATE `SIGU`.`SIGU_ConsentimientosInformadosV2` SET `Estado` = 'Inactivo' WHERE\
+      `Modulo` = ? AND `Titulo` <> 'Versión del módulo'; \
+      SELECT MAX(`ConsentimientoInformadoId`) + 1 INTO @`NuevoId` FROM `SIGU`.`SIGU_ConsentimientosInformadosV2`; \
+      INSERT INTO `SIGU`.`SIGU_ConsentimientosInformadosV2` VALUES\
+      (@`NuevoId`, ?, ?, ?, 'Activo', ?, NOW(), USER())\
+      ON DUPLICATE KEY UPDATE `Estado` = 'Activo';"
+      , [this.NombreCanonicoDelModulo, Titulo, Texto, TextoDeAceptacion, this.NombreCanonicoDelModulo]);
+  },
+
+  obtenerCorreoParaReportes() {
+    return this.CorreoParaReportes;
+  },
+
+  async obtenerModulos(Token, Padre, ModulosFavoritos) {
+    let Resultado = undefined;
+    try {
+      Resultado = await this.obtenerDatosDelUsuario(Token);
+      if (!Resultado) {
+        throw new ManejadorDeErrores(ManejadorDeErrores.mensajeDeErrorVerificacionDeToken(), ManejadorDeErrores.obtenerNumeroDeLinea());
+      }
+    } catch (error) {
+      console.log(error);
+      return;
+    }
+    const Permisos = await ejecutarConsultaSIGU("SELECT `PermisoId` FROM `SIGU`.`SIGU_PermisosPersonasV2` WHERE `Identificador` = ?"
+      , [Resultado.Identificador]);
+    const Modulos = await ejecutarConsultaSIGU("SELECT `a`.`Nombre`, `a`.`Padre`, `a`.`Descripcion`, `a`.`Detalle`,\
+        `a`.`Tipo`, IF(`a`.`Icono` <> '', CONCAT('https://storage.sigu.utn.ac.cr/images/cards/', `a`.`Icono`), '') AS `Icono`, `a`.`Color`, `a`.`Correo`,\
+        `a`.`Version`, `a`.`FechaDePublicacion`, `a`.`AcuerdoDeNivelDeServicio`, `a`.`DiccionarioDeDatos`, `a`.`Repositorios`,\
+        `a`.`EnlaceDelVideo`,`a`.`EnlaceDelManual`\
+        , `a`.`Estado`, REGEXP_SUBSTR(SUBSTRING_INDEX(`a`.`Repositorios`, '/', -1), '[^,]*front[^,]*') AS `Frontend`\
+        , `c`.`Etiqueta`, `c`.`ColorDeLaEtiqueta`\
+        , (SELECT COUNT(*) FROM `SIGU`.`SIGU_ModulosV2` `h`\
+            JOIN `SIGU`.`SIGU_PermisosV2` `hp` ON (`h`.`Nombre` = `hp`.`Modulo`)\
+            WHERE `h`.`Estado` = 'Activo' AND `h`.`Padre` = `a`.`Nombre` AND `hp`.`PermisoId` IN (?)) AS `CantidadDeHijos`\
+      FROM `SIGU`.`SIGU_ModulosV2` `a`\
+        JOIN `SIGU`.`SIGU_PermisosV2` `b` ON (`a`.`Nombre` = `b`.`Modulo`)\
+        LEFT JOIN `SIGU`.`SIGU_ModulosV2InformacionExtra` `c` ON (`a`.`Nombre` = `c`.`Modulo`)\
+      WHERE `a`.`Estado` = 'Activo' AND `a`.`Padre` = ? AND `b`.`PermisoId` IN (?)\
+      ORDER BY FIELD(a.Nombre, " + ModulosFavoritos + ") DESC, a.Nombre", [Permisos.map(p => p.PermisoId), Padre, Permisos.map(p => p.PermisoId)]);
+    return Modulos.map((linea) => {
+      linea.Enlace = this.generarEnlace(linea.Frontend);
+      return linea;
+    });
+  },
+
+  async configurarFrontend(Token = undefined) {
+    let NombreUsuario = '';
+    if (Token) {
+      try {
+        const datosUsuario = await this.obtenerDatosDelUsuario(Token);
+        if (datosUsuario) {
+          NombreUsuario = `${datosUsuario.Nombre || ''} ${datosUsuario.PrimerApellido || ''} ${datosUsuario.SegundoApellido || ''}`.trim();
+        }
+      } catch (e) {
+        console.error('Error obteniendo datos de usuario para frontend:', e);
+      }
+    }
+    return {
+      "Modulo": this.NombreCanonicoDelModulo,
+      "Titulo": this.NombreDelModulo,
+      "Version": this.Version + "$$" + this.versionDelNucleo().split(' ')[0],
+      "Descripcion": this.DescripcionDelModulo,
+      "Detalle": this.DetalleDelModulo,
+      "NombreUsuario": NombreUsuario
+    };
+  },
+
+  async obtenerEnlaceDePortal() {
+    return this.EnlaceDePortal;
+  },
+
+  async obtenerEnlaceDePerfil() {
+    return this.EnlaceDePerfil;
+  },
+
+  async obtenerTarjetas() {
+    const resultados = await ejecutarConsultaSIGU(
+      "SELECT `Datos` FROM `SIGU`.`SIGU_ModulosV2Tarjetas` WHERE `Modulo` = ? AND JSON_EXTRACT(`Datos`, '$.Activa') = TRUE",
+      [this.NombreCanonicoDelModulo]
+    );
+    return resultados.map(fila => typeof fila.Datos === 'string' ? JSON.parse(fila.Datos) : fila.Datos);
+  },
+
+  async inicializar(solicitud) {
+    const ConsentimientoInformado = require('./ConsentimientoInformado.js');
+    const LastUser = await this.generarLastUser(solicitud);
+    const [configuracion, detalleDelModulo, notificaciones, mensajesModulares, consentimiento] = await Promise.all([
+      this.configurarFrontend(solicitud.headers.authorization),
+      this.obtenerDetalleDelModulo(),
+      this.obtenerNotificaciones(solicitud.headers.authorization),
+      this.obtenerMensajesModulares(),
+      ConsentimientoInformado.ConsentimientoInformado({ LastUser })
+    ]);
+    return {
+      TienePermiso: true,
+      ...configuracion,
+      Descripcion: detalleDelModulo[0]?.Descripcion ?? configuracion.Descripcion,
+      Detalle: detalleDelModulo[0]?.Detalle ?? configuracion.Detalle,
+      EnlaceDelManual: detalleDelModulo[0]?.EnlaceDelManual ?? '-',
+      EnlaceDelVideo: detalleDelModulo[0]?.EnlaceDelVideo ?? '-',
+      Notificaciones: notificaciones,
+      MensajesModulares: mensajesModulares,
+      Consentimiento: consentimiento
+    };
+  },
+
+  async obtenerTarjetasDelContenedor(token) {
+    const ConfiguracionDeTarjetas = require('./ConfiguracionDeTarjetas.js');
+    const path = require('path');
+    const serviciosDir = path.join(__dirname, '..');
+
+    const usuario = await this.obtenerDatosDelUsuario(token);
+    const [tarjetas, configuracion] = await Promise.all([
+      this.obtenerTarjetas(),
+      ConfiguracionDeTarjetas.obtener({ Identificador: usuario.uid })
+    ]);
+
+    const datosDeServicio = await Promise.all(
+      tarjetas
+        .filter(t => t.Archivo)
+        .map(async t => {
+          try {
+            const rutaArchivo = this._buscarArchivoRecursivo(serviciosDir, t.Archivo);
+            if (!rutaArchivo) return null;
+            const servicio = require(rutaArchivo);
+            const [cantidades, tienePermisoExtra] = await Promise.all([
+              typeof servicio.Cantidades === 'function' ? servicio.Cantidades(token) : null,
+              typeof servicio.PermisoExtra === 'function' ? servicio.PermisoExtra(token) : null
+            ]);
+            return [t['Título'], { cantidades, tienePermisoExtra }];
+          } catch { return null; }
+        })
+    );
+
+    const datosPorTitulo = Object.fromEntries(datosDeServicio.filter(Boolean));
+
+    const titulosAExcluir = new Set(
+      Object.entries(datosPorTitulo)
+        .filter(([, { cantidades }]) => cantidades && !(cantidades.cantidadMaxima > 0))
+        .map(([titulo]) => titulo)
+    );
+
+    return tarjetas
+      .filter(t => !t.RequierePermisoExtra || datosPorTitulo[t['Título']]?.tienePermisoExtra)
+      .filter(t => !titulosAExcluir.has(t['Título']))
+      .map(t => {
+        const config = configuracion.find(c => c.Titulo === t['Título']);
+        if (config) {
+          t['Posición'] = config.Posicion;
+          if (config.ColorDeBorde) t.ColorDeBorde = config.ColorDeBorde;
+        }
+        const datos = datosPorTitulo[t['Título']];
+        if (datos?.cantidades) {
+          t['Cantidad'] = datos.cantidades.cantidad;
+          t['CantidadMaxima'] = datos.cantidades.cantidadMaxima;
+        }
+        return t;
+      })
+      .sort((a, b) => a['Posición'] - b['Posición']);
+  },
+
+};