utn-cli 2.1.18 → 2.1.19

package/templates/backend/servicios/Nucleo/Miscelaneas.js

@@ -1,15 +1,7 @@
 const { ejecutarConsulta, ejecutarConsultaSIGU, crearObjetoConexionSIGU } = require('./db.js');
 const ManejadorDeErrores = require('./ManejadorDeErrores.js');
 const InformacionDelModulo = require('../InformacionDelModulo.js');
-
-const MixinAutenticacion = require('./MiscelaneasMixins/Autenticacion.js');
-const MixinNotificaciones = require('./MiscelaneasMixins/Notificaciones.js');
-const MixinTareasProgramadas = require('./MiscelaneasMixins/TareasProgramadas.js');
-const MixinPersonas = require('./MiscelaneasMixins/Personas.js');
-const MixinArchivos = require('./MiscelaneasMixins/Archivos.js');
-const MixinModulos = require('./MiscelaneasMixins/Modulos.js');
-const MixinInicializacion = require('./MiscelaneasMixins/InicializacionDelModulo.js');
-const MixinReportes = require('./MiscelaneasMixins/Reportes.js');
+const { envioDeCorreo } = require('./EnvioDeCorreos.js');
 
 class Miscelaneo {
 
@@ -38,6 +30,8 @@ class Miscelaneo {
     this.CorreoParaReportes = InformacionDelModulo.getCorreoParaReportes();
     this.Version = InformacionDelModulo.getVersion();
 
+    // Declaración de variables
+    // A estas variables no es necesario darles un valor inicial
     this.UUID = 'UUID';
     this.Enlace = undefined;
     this.RolId = 0;
@@ -45,37 +39,49 @@ class Miscelaneo {
     this.EnlaceDePortal = undefined;
     this.EnlaceDePerfil = undefined;
     this.EnlaceDeAcceso = undefined;
-  }
+  };
 
   async PasosDeFlujoDeAprobacion(Identificador, PasoActual, Accion, Metadatos, Justificacion, LastUser) {
     const DatosARetornar = {};
+
+    // Determina si la acción es una improbación para manejar el flujo de forma diferente
     const EsImprobacion = Accion === 'Improbacion';
+
+    // Obtiene el ID del flujo de aprobación configurado para este módulo
     const idDelFlujoDeAprobacion = await this.idDelFlujoDeAprobacion();
 
+    // Consulta cuál es el último paso del flujo, para saber si el detalle queda completamente aprobado
     const PasoMaximo = await ejecutarConsultaSIGU("SELECT MAX(`NumeroDePaso`) \
             AS `PasoMaximo` FROM `SIGU`.`SIGU_FlujosDeAprobacionPasos` WHERE \
             `FlujoDeAprobacionId`  = ?"
       , [idDelFlujoDeAprobacion]);
 
+    // En improbación el flujo retrocede, por lo que el paso siguiente se resuelve después;
+    // en aprobación simplemente avanza al siguiente paso
     let PasoSiguiente = EsImprobacion ? PasoActual : PasoActual + 1;
 
+    // Verifica que el usuario tenga permiso para actuar en el paso correspondiente
     const TienePermiso = await ejecutarConsultaSIGU("SELECT `NumeroDePasoPorImprobacion` FROM `SIGU`.`SIGU_FlujosDeAprobacionPasos` \
              WHERE `NumeroDePaso`=? AND  (`Identificadores`  LIKE '%?%' OR `Identificadores`='Persona usuaria')",
       [PasoSiguiente, Number(Identificador)]);
 
+    // Si el usuario no aparece como firmante autorizado del paso, se corta la ejecución
     if (TienePermiso.length == 0) {
       DatosARetornar.Mensaje = 'No tiene permisos para firmar este detalle';
       DatosARetornar.error = true;
       return DatosARetornar;
     }
 
+    // Registra el movimiento en el historial del flujo de aprobación
     await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_FlujosDeAprobacionMovimientos` VALUES (?, ?, ?, ?, ?, ?, NOW(4), ?)"
       , [idDelFlujoDeAprobacion, PasoActual
         , Identificador, Accion
         , Justificacion, JSON.stringify(Metadatos), LastUser]);
 
+    // En improbación, el paso destino viene definido en la configuración del flujo (retroceso configurado)
     PasoSiguiente = EsImprobacion ? TienePermiso[0].NumeroDePasoPorImprobacion : PasoSiguiente;
 
+    // Indica al llamador si el detalle alcanzó el último paso y debe cambiar su estado global
     DatosARetornar.CambiarEstado = PasoSiguiente === PasoMaximo[0].PasoMaximo;
     DatosARetornar.Mensaje = EsImprobacion ? 'Detalle firmado como no aprobado' : 'Detalle firmado correctamente';
     DatosARetornar.PasoSiguiente = PasoSiguiente;
@@ -110,7 +116,7 @@ class Miscelaneo {
           JSON_VALUE(Solicitud, '$.originalUrl') AS URL,
           IFNULL(JSON_VALUE(Solicitud, '$.country'), 'Costa Rica') AS Pais,
           SUBSTRING_INDEX(JSON_VALUE(Solicitud, '$.headers.authorization'), ' ', -1) AS Token,
-          CASE
+          CASE 
             WHEN JSON_VALUE(Solicitud, '$.userAgent') LIKE '%Mobile%' THEN 'Móvil'
             WHEN JSON_VALUE(Solicitud, '$.userAgent') LIKE '%Android%' AND JSON_VALUE(Solicitud, '$.userAgent') NOT LIKE '%Mobile%' THEN 'Tablet'
             WHEN JSON_VALUE(Solicitud, '$.userAgent') LIKE '%iPad%' THEN 'Tablet'
@@ -129,6 +135,11 @@ class Miscelaneo {
     }
   }
 
+  async cerrarSesionPorToken(Token) {
+    await ejecutarConsultaSIGU("DELETE FROM `SIGU`.`SIGU_Sesiones` WHERE `Token` = ?", [Token]);
+    return true;
+  }
+
   async UsuariosActuales() {
     const ConexionSigu = await crearObjetoConexionSIGU();
     const Actuales = await ConexionSigu.query("SELECT COUNT(DISTINCT `Identificador`) AS `Total` FROM `SIGU`.`SIGU_Sesiones` WHERE `LastUpdate` >= NOW() - INTERVAL 2 HOUR");
@@ -137,103 +148,2441 @@ class Miscelaneo {
     return {
       UsuariosActuales: Actuales[0][0]['Total'],
       UsuariosActivos: Activos[0][0]['Total']
-    };
+    }
   }
 
-  async consumirBackend(URL, Cuerpo = undefined, Tipo = undefined) {
+  async generarFirmaHTML(Identificador, FechaDeLaFirma) {
+    const ReporteHTML = require('./ReporteHTML.js');
+    return await ReporteHTML.generarFirmaHTML(Identificador, FechaDeLaFirma);
+  }
+
+  GenerarReporteHTMLRegistrosVerticales(ElementosParaLaTabla, ParametrosExcluidos = [], ParametrosExtra = [], MostrarEncabezado = true) {
+    const ReporteHTML = require('./ReporteHTML.js');
+    return ReporteHTML.GenerarReporteHTMLRegistrosVerticales(ElementosParaLaTabla, ParametrosExcluidos, ParametrosExtra, MostrarEncabezado);
+  }
+
+  GenerarReporteHTMLEncabezado(InformacionDeLaDerecha, titulares, marcaDeAgua = '') {
+    const ReporteHTML = require('./ReporteHTML.js');
+    return ReporteHTML.GenerarReporteHTMLEncabezado(InformacionDeLaDerecha, titulares, marcaDeAgua);
+  }
+
+  GenerarReporteHTMLFecha() {
+    const ReporteHTML = require('./ReporteHTML.js');
+    return ReporteHTML.GenerarReporteHTMLFecha();
+  }
+
+  GenerarReporteHTMLTablas(ElementosParaLaTabla, ParametrosExcluidos = [], ParametrosExtra = []) {
+    const ReporteHTML = require('./ReporteHTML.js');
+    return ReporteHTML.GenerarReporteHTMLTablas(ElementosParaLaTabla, ParametrosExcluidos, ParametrosExtra);
+  }
+
+  GenerarReporteHTMLPie() {
+    const ReporteHTML = require('./ReporteHTML.js');
+    return ReporteHTML.GenerarReporteHTMLPie();
+  }
+
+  obtenerNombreLaBaseDeDatos() {
+    return this.NombreDelRepositorioDeLaBaseDeDatos.slice(0, -3);
+  }
+
+  async RegistrarPermisoExtra(Permiso, Descripcion) {
+    await ejecutarConsultaSIGU("SELECT IFNULL(MAX(`PermisoExtraId`), 0) + 1 INTO @`SiguientePermisoId` FROM `SIGU`.`SIGU_PermisosExtraV2`;\
+      INSERT INTO `SIGU`.`SIGU_PermisosExtraV2` VALUES\
+      (@`SiguientePermisoId`, ?, ?, ?, NOW(4), USER()) ON DUPLICATE KEY UPDATE `LastUser` = USER(), `Nombre` = ?, `Descripcion` = ?;"
+      , [Permiso, this.NombreCanonicoDelModulo, Descripcion, Permiso, Descripcion]);
+
+    // Asginación inicial de permisos
+    if (this.UsuariosConAccesoInicial.length > 0) {
+      const PermisoExtraIdValor = await this.PermisoExtraId(Permiso);
+      this.UsuariosConAccesoInicial.forEach(async (dato) => {
+        await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_PermisosExtraPersonasV2` VALUES (?,\
+          (SELECT `Identificador` FROM `SIGU`.`SIGU_Personas` WHERE `Identificacion` = ?), NOW(4), USER())\
+            ON DUPLICATE KEY UPDATE `LastUpdate` = NOW(4)"
+          , [PermisoExtraIdValor, dato]);
+      });
+    }
+  }
+
+  async PermisoExtraId(Permiso) {
+    const PermisoExtraId = await ejecutarConsultaSIGU("SELECT `PermisoExtraId` FROM `SIGU`.`SIGU_PermisosExtraV2` \
+      WHERE `Nombre` = ? AND `Modulo` = ?"
+      , [Permiso, this.NombreCanonicoDelModulo]);
+    return PermisoExtraId[0]['PermisoExtraId'];
+  }
+
+  obtenerNombreCanonicoDelModulo() {
+    return this.NombreCanonicoDelModulo;
+  }
+
+  obtenerVersionDelModulo() {
+    return this.Version;
+  }
+
+  async convertirTextoEnArchivoLocal(Texto, Token, NombreDelArchivo, Etiquetas) {
+    let EnlaceDelBack = 'http';
+    EnlaceDelBack = EnlaceDelBack + ((process.env.ENV || 'local') === 'production' ? 's' : '');
+    EnlaceDelBack = EnlaceDelBack + '://';
+    EnlaceDelBack = EnlaceDelBack + (['desarrollo', 'calidad', 'pruebas', 'production'].includes(process.env.ENV) ? this.NombreDelRepositorioDelBackend : 'localhost');
+    EnlaceDelBack = EnlaceDelBack + '/misc/cargarArchivo/' + Etiquetas;
+    // let EnlaceDelBack = `${Solicitud.protocol}://${Solicitud.get('host')}` + '/misc/cargarArchivo/' + Etiquetas;
     const Encabezados = {
-      'Content-Type': 'application/json',
-      'Authorization': 'Bearer ' + await this.getUUID(),
+      'Authorization': Token,
       'Referrer': this.NombreDelRepositorioDelBackend,
-      'Origin': this.Enlace
+      'Origin': EnlaceDelBack
     };
-    let Respuesta = undefined;
-    const Opciones = {
-      method: Cuerpo ? "POST" : "GET",
-      headers: Encabezados,
-      redirect: 'error'
+    const blob = new Blob([Texto], { type: 'text/plain' });
+    const formData = new FormData();
+    formData.append('archivo', blob, NombreDelArchivo);
+    try {
+      const response = await fetch(EnlaceDelBack, {
+        method: 'POST',
+        headers: Encabezados,
+        body: formData,
+        redirect: 'error'
+      });
+      if (!response.ok) {
+        const errorTexto = await response.text();
+        throw new Error(`Error del servidor (${response.status}): ${errorTexto}`);
+      }
+      return await response.json();
+    } catch (error) {
+      console.error(error.message);
+    }
+  }
+
+  async RegistrarElServicio(Servicio, Tarjetas = null) {
+    const archivo = this._archivoFuenteActual;
+    try {
+      await ejecutarConsultaSIGU("REPLACE INTO `SIGU`.`SIGU_ModulosV2Secciones` (`Modulo`, `Descripcion`) VALUES (?, ?)"
+        , [this.NombreCanonicoDelModulo, Servicio]);
+      console.log(`Servicio ${Servicio} registrado correctamente`);
+    } catch (error) {
+      console.error(error.message);
+    }
+
+    if (!Tarjetas) return;
+
+    const listaTarjetas = Array.isArray(Tarjetas) ? Tarjetas : [Tarjetas];
+
+    for (const tarjeta of listaTarjetas) {
+      try {
+        const titulo = tarjeta['Título'];
+        const existentes = await ejecutarConsultaSIGU(
+          `SELECT CAST(JSON_VALUE(\`Datos\`, '$."Posición"') AS UNSIGNED) AS Posicion, JSON_VALUE(\`Datos\`, '$."Título"') AS Titulo, JSON_VALUE(\`Datos\`, '$."Descripción"') AS Descripcion FROM \`SIGU\`.\`SIGU_ModulosV2Tarjetas\` WHERE \`Modulo\` = ? AND JSON_VALUE(\`Datos\`, '$."Título"') = ?`,
+          [this.NombreCanonicoDelModulo, titulo]
+        );
+
+        let datosFinales;
+        if (existentes.length > 0) {
+          datosFinales = { ...tarjeta, 'Posición': existentes[0].Posicion, 'Título': existentes[0].Titulo, 'Descripción': existentes[0].Descripcion, 'Archivo': archivo };
+          await ejecutarConsultaSIGU(
+            `UPDATE \`SIGU\`.\`SIGU_ModulosV2Tarjetas\` SET \`Datos\` = ?, \`LastUser\` = 'Sistema' WHERE \`Modulo\` = ? AND JSON_VALUE(\`Datos\`, '$."Título"') = ?`,
+            [JSON.stringify(datosFinales), this.NombreCanonicoDelModulo, titulo]
+          );
+        } else {
+          let posicion = tarjeta['Posición'];
+          if (posicion === undefined) {
+            const [{ NuevaPosicion }] = await ejecutarConsultaSIGU(
+              `SELECT COALESCE(MAX(CAST(JSON_VALUE(\`Datos\`, '$."Posición"') AS UNSIGNED)), 0) + 10 AS NuevaPosicion FROM \`SIGU\`.\`SIGU_ModulosV2Tarjetas\` WHERE \`Modulo\` = ?`,
+              [this.NombreCanonicoDelModulo]
+            );
+            posicion = NuevaPosicion;
+          }
+          datosFinales = { ...tarjeta, 'Posición': posicion, 'Archivo': archivo };
+          await ejecutarConsultaSIGU(
+            `INSERT INTO \`SIGU\`.\`SIGU_ModulosV2Tarjetas\` (\`Modulo\`, \`Datos\`, \`LastUser\`) VALUES (?, ?, 'Sistema')`,
+            [this.NombreCanonicoDelModulo, JSON.stringify(datosFinales)]
+          );
+        }
+        console.log(`Tarjeta "${titulo}" registrada correctamente`);
+      } catch (error) {
+        console.error(`Error al registrar tarjeta "${tarjeta['Título']}":`, error.message);
+      }
+    }
+  }
+
+  _archivoFuenteActual = null;
+  _archivoCache = new Map();
+
+  _buscarArchivoRecursivo(dir, nombre) {
+    if (this._archivoCache.has(nombre)) return this._archivoCache.get(nombre);
+    const fs = require('fs');
+    const path = require('path');
+    const buscar = (directorio) => {
+      for (const entrada of fs.readdirSync(directorio, { withFileTypes: true })) {
+        const ruta = path.join(directorio, entrada.name);
+        if (entrada.isDirectory()) {
+          const resultado = buscar(ruta);
+          if (resultado) return resultado;
+        } else if (entrada.name === nombre) {
+          return ruta;
+        }
+      }
+      return null;
     };
-    if (Tipo === 'stream') {
-      Opciones.responseType = 'stream';
+    const resultado = buscar(dir);
+    this._archivoCache.set(nombre, resultado);
+    return resultado;
+  }
+
+  async DatosParaReporteCSV() {
+    return this.convertirACSV(await this.DatosParaGraficoDeBarras());
+  }
+
+  async DatosParaGraficoDeBarras() {
+    return await ejecutarConsultaSIGU("SELECT MONTHNAME(`FechaNacimiento`) AS `EjeHorizontal`, `Sexo` AS `Etiqueta`, COUNT(*) AS `Total` FROM `SIGU`.`SIGU_Personas` WHERE MONTH(`FechaNacimiento`) > 0 AND `Sexo` <> '' GROUP BY MONTHNAME(`FechaNacimiento`), `Sexo` ORDER BY MONTH(`FechaNacimiento`)");
+  }
+
+  async DatosParaGraficoDePie() {
+    return await ejecutarConsultaSIGU("SELECT `Tipo` AS `Etiqueta`, COUNT(*) AS `Total` FROM `SIGU`.`SIGU_ModulosV2` GROUP BY `Tipo`");
+  }
+
+  JSONAHTML(input, title = 'Reporte') {
+    // intentar parsear si es string JSON
+    let obj = input;
+    if (typeof input === 'string') {
+      try { obj = JSON.parse(input); }
+      catch (e) { /* no es JSON, lo tratamos como texto primitivo */ }
     }
-    if (Cuerpo) {
-      Opciones.body = JSON.stringify(Cuerpo);
+
+    const escapeHtml = (s) =>
+      String(s)
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+
+    const isPrimitive = v => v === null || v === undefined || typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean';
+
+    const seen = new WeakSet();
+
+    function renderValue(v) {
+      if (v === null || v === undefined || v === '') return '—';
+      if (isPrimitive(v)) return escapeHtml(String(v));
+      if (Array.isArray(v)) return renderArray(v);
+      return renderObject(v);
     }
-    const ListaDeDominiosPermitidos = [
-      "sigu.utn.ac.cr",
-      "localhost",
-      "svc.cluster.local"
-    ];
+
+    function renderObject(o) {
+      if (seen.has(o)) return '<em>(referencia circular)</em>';
+      seen.add(o);
+
+      // si es objeto vacío
+      const keys = Object.keys(o);
+      if (keys.length === 0) {
+        seen.delete(o);
+        return '—';
+      }
+
+      // construir filas key / value
+      let rows = '';
+      for (const k of keys) {
+        rows += `
+        <tr>
+          <th>${escapeHtml(k)}</th>
+          <td>${renderValue(o[k])}</td>
+        </tr>
+      `;
+      }
+
+      seen.delete(o);
+      return `<table border='1'><tbody>${rows}</tbody></table>`;
+    }
+
+    function renderArray(arr) {
+      if (arr.length === 0) return '—';
+
+      // si todos son primitivos => lista simple
+      if (arr.every(isPrimitive)) {
+        return `<div>${arr.map(x => `<span>${escapeHtml(String(x))}</span>`).join(' ')}</div>`;
+      }
+
+      // si todos son objetos => tabla con columnas (union de keys)
+      if (arr.every(it => typeof it === 'object' && it !== null && !Array.isArray(it))) {
+        const columns = Array.from(new Set(arr.flatMap(item => Object.keys(item))));
+        const header = columns.map(c => `<th>${escapeHtml(c)}</th>`).join('');
+        const body = arr.map(item => {
+          const cells = columns.map(c => `<td>${item.hasOwnProperty(c) ? renderValue(item[c]) : ''}</td>`).join('');
+          return `<tr>${cells}</tr>`;
+        }).join('');
+        return `<table border='1'><thead><tr>${header}</tr></thead><tbody>${body}</tbody></table>`;
+      }
+
+      // mezcla de tipos: render por ítem
+      return `<div>${arr.map(it => `<div>${renderValue(it)}</div>`).join('')}</div>`;
+    }
+
+    // construir contenido (una sección por clave del primer nivel)
+    let content = '';
+    if (typeof obj === 'object' && obj !== null && !Array.isArray(obj)) {
+      const topKeys = Object.keys(obj);
+      for (const k of topKeys) {
+        content += `
+        <section>
+          <h2>${escapeHtml(k)}</h2>
+          <div>${renderValue(obj[k])}</div>
+        </section>
+      `;
+      }
+    } else {
+      // si el input fue un array o primitivo
+      content = `<section><div>${renderValue(obj)}</div></section>`;
+    }
+
+    // template HTML + CSS
+    return `<h1>${escapeHtml(title)}</h1>${content}`;
+  }
+
+  async generarLastUser(Solicitud) {
+    const Resultado = await this.obtenerDatosDelUsuario(Solicitud.headers.authorization);
+    // try {
+    //   Resultado = await this.obtenerDatosDelUsuario(Solicitud.headers.authorization);
+    //   if (!Resultado) {
+    //     throw new ManejadorDeErrores(ManejadorDeErrores.mensajeDeErrorVerificacionDeToken(), ManejadorDeErrores.obtenerNumeroDeLinea());
+    //   }
+    // } catch (error) {
+    //   console.log(error);
+    // }
+    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 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;
+  }
+
+  getNombreDelRepositorioDelBackend() {
+    return this.NombreDelRepositorioDelBackend;
+  }
+
+  async ejecucionCadaXMinutos(callback, intervaloMinutos) {
+    while (true) {
+      try {
+        await this.crearTareaProgramada(callback);
+        break;
+      } catch (error) {
+        console.error('Error al ejecutar crearTareaProgramada:', error);
+        console.log('Reintentando en 5 segundos...');
+        await new Promise(resolve => setTimeout(resolve, 5000));
+      }
+    }
+    const intervaloMilisegundos = intervaloMinutos * 60 * 1000;
+    while (true) {
+      const inicio = Date.now();
+      try {
+        await callback();
+      } catch (error) {
+        console.error(`Error en la función "${callback.name}":`, error?.message || error);
+      }
+      const duracion = Date.now() - inicio;
+      const tiempoRestante = intervaloMilisegundos - duracion;
+      if (tiempoRestante > 0) {
+        await new Promise(resolve => setTimeout(resolve, tiempoRestante));
+      }
+    }
+  }
+
+  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 {
-      if (ListaDeDominiosPermitidos.some(dominio => URL.includes(dominio))) {
-        Respuesta = await fetch(URL, Opciones);
+      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." };
       }
-      if (!Respuesta.ok) {
-        throw new ManejadorDeErrores(ManejadorDeErrores.mensajeDeErrorAccesoAAPI(Respuesta.error), ManejadorDeErrores.obtenerNumeroDeLinea());
+
+      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." };
       }
-      if (Tipo === 'stream') {
-        return await Respuesta;
+
+      const Identificacion = resultadosUsuario[0][0]['Identificacion'];
+
+      // Generar Token
+      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]);
+
+      // OBTENER IP DEL USUARIO
+      const ipUsuario = (Solicitud.headers['x-forwarded-for'] || '').split(',').shift() || Solicitud.socket?.remoteAddress || Solicitud.connection?.remoteAddress || '-';
+
+      // SI LA IP YA EXISTE CONTINUA
+      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]);
+        }
+
+        // OBTENER IP DEL USUARIO
+        const ipUsuario = (Solicitud.headers['x-forwarded-for'] || '').split(',').shift() || Solicitud.socket?.remoteAddress || Solicitud.connection?.remoteAddress || '-';
+
+        // VERIFICAR SI LA IP YA EXISTE
+        const ipExiste = await ConexionSigu.query("\
+        SELECT COUNT(*) AS Total \
+        FROM `SIGU`.`SIGU_DireccionesUsadasPorLosUsuarios` \
+        WHERE `Identificador` = ? AND `DireccionUsadaPorElUsuario` = ?", [Identificador, ipUsuario]);
+
+        // Verificar si la fecha de cambio supera los 2 meses
+        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 diferenciaMs = fechaActual - fechaUltimo;
+        const diasPasados = diferenciaMs / (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) {
+          // GENERAR CODIGO 2FA
+          let Codigo2FA = await ConexionSigu.query("SELECT UUID() AS `Dato`");
+          Codigo2FA = Codigo2FA[0][0].Dato;
+
+          // GUARDAR CODIGO 2FA
+          await ConexionSigu.query(" \
+          REPLACE INTO `SIGU`.`SIGU_CodigosDe2FAParaLosUsuarios` \
+          VALUES (?, ?, NOW(4), ?)", [
+            Identificador,
+            Codigo2FA,
+            LastUser
+          ]);
+
+          // OBTENER CORREO
+          const CorreoElectronico = await ConexionSigu.query(
+            "SELECT `CorreoElectronico` \
+          FROM `SIGU`.`SIGU_CorreosPersona` \
+          WHERE `Identificador` = ? \
+          AND `Principal` = TRUE"
+            , [Identificador]);
+          // ENVIAR CORREO
+          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 };
+
+        }
+
+        // SI LA IP YA EXISTE CONTINUA
+        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()]);
+        }
       }
-      return await Respuesta.json();
     } catch (error) {
-      console.error(error);
-      console.error(Respuesta);
-      throw new ManejadorDeErrores(error.message, ManejadorDeErrores.obtenerNumeroDeLinea());
+      console.log(error);
+      return;
+    } finally {
+      if (ConexionSigu) await ConexionSigu.end();
     }
+    return;
   }
 
-  // Re-lee todas las propiedades del módulo desde InformacionDelModulo.
-  // Se llama después de InformacionDelModulo.initialize() para que los valores
-  // de la BD queden reflejados en la instancia.
-  _sincronizarConInformacionDelModulo() {
-    const Info = require('../InformacionDelModulo.js');
-    this.NombreDelModulo = Info.getNombreDelModulo();
-    this.DescripcionDelModulo = Info.getDescripcionDelModulo();
-    this.DetalleDelModulo = Info.getDetalleDelModulo();
-    this.NombreCanonicoDelModulo = Info.getNombreCanonicoDelModulo();
-    this.TipoDeCard = Info.getTipoDeCard();
-    this.NombreDelRol = this.NombreCanonicoDelModulo + ' - ' + Info.getNombreDelRol();
-    this.NombreDelRepositorioDeLaBaseDeDatos = Info.getNombreDelRepositorioDeLaBaseDeDatos();
-    this.NombreDelRepositorioDelBackend = Info.getNombreDelRepositorioDelBackend();
-    this.NombreDelRepositorioDelFrontend = Info.getNombreDelRepositorioDelFrontend();
-    this.UrlDelGrupo = Info.getUrlDelGrupo();
-    this.Repositorios = this.UrlDelGrupo + '/' + this.NombreDelRepositorioDeLaBaseDeDatos
-      + ',' + this.UrlDelGrupo + '/' + this.NombreDelRepositorioDelBackend
-      + ',' + this.UrlDelGrupo + '/' + this.NombreDelRepositorioDelFrontend;
-    this.NombreDelPermiso = this.NombreCanonicoDelModulo + ' - ' + Info.getNombreDelPermiso();
-    this.NombreDelPermisoV2 = Info.getNombreDelPermiso();
-    this.DescripcionDelPermiso = Info.getDescripcionDelPermiso();
-    this.MenuPadre = Info.getMenuPadre();
-    this.BackEndsQueConsumeEsteModulo = Info.getBackEndsQueConsumeEsteModulo();
-    this.PerfilGeneral = Info.getPerfilGeneral();
-    this.UsuariosConAccesoInicial = Info.getUsuariosConAccesoInicial();
-    this.IconoDelModulo = this.NombreCanonicoDelModulo + '.svg';
-    this.ColorDelModulo = Info.getColorDelModulo();
-    this.CorreoParaReportes = Info.getCorreoParaReportes();
-    this.Version = Info.getVersion();
+  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'];
+      // Validar código 2FA
+      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) {
+        // Eliminar código usado cuando falle
+        await ConexionSigu.query(" \
+      DELETE FROM `SIGU`.`SIGU_CodigosDe2FAParaLosUsuarios` \
+      WHERE `Identificador` = ? ", [Identificador]);
+        return { error: "Código inválido" };
+      }
+
+      // Eliminar código usado
+      await ConexionSigu.query(" \
+      DELETE FROM `SIGU`.`SIGU_CodigosDe2FAParaLosUsuarios` WHERE `Identificador` = ?", [Identificador]);
+
+      // Obtener IP del usuario
+      const ipUsuario = (Solicitud.headers['x-forwarded-for'] || '').split(',').shift() || Solicitud.socket?.remoteAddress || Solicitud.connection?.remoteAddress || '-';
+
+      // Guardar IP autorizada
+      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
+      ]);
+
+      // Generar token
+      const Token = await jwt.sign(
+        { Identificador: Identificador, uid: Identificador },
+        await this.palabraSecretaParaTokens(),
+        { expiresIn: '2h' }
+      );
+
+      // Registrar sesión
+      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();
+    }
   }
 
-  obtenerNombreLaBaseDeDatos() {
-    return this.NombreDelRepositorioDeLaBaseDeDatos.slice(0, -3);
+  async ListadoDePaisesParaCrearCuenta() {
+    const Resultado = await ejecutarConsultaSIGU("SELECT REPLACE(MID(`COLUMN_TYPE`, 6, CHAR_LENGTH(`COLUMN_TYPE`) - 6), \"'\", '') AS `Datos` FROM `information_schema`.`COLUMNS`\
+        WHERE `TABLE_SCHEMA` = 'SIGU' AND `TABLE_NAME` = 'SIGU_Personas' AND\
+          `COLUMN_NAME` = 'Pais'");
+    return Resultado[0]['Datos'].split(',').sort();
   }
 
-  obtenerNombreCanonicoDelModulo() {
-    return this.NombreCanonicoDelModulo;
+  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;
+    });
   }
 
-  obtenerVersionDelModulo() {
-    return this.Version;
+  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 iniciarSesion() {
+    return this.EnlaceDeAcceso;
+  }
+
+  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 crearNotificacion(IdentificadorDelUsuario, IdentificadorDelDestinatario, Mensaje) {
+    return await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_NotificacionesV2` VALUES (?, ?, 'Sin leer', NOW(4), NOW(4), ?)"
+      , [IdentificadorDelDestinatario, Mensaje, IdentificadorDelUsuario]);
+  }
+
+  async actualizarNotificacion(Token, FechaYHoraDeCreacion) {
+    let Resultado = undefined;
+    try {
+      Resultado = await this.obtenerDatosDelUsuario(Token);
+      if (!Resultado) {
+        throw new ManejadorDeErrores(ManejadorDeErrores.mensajeDeErrorVerificacionDeToken(), ManejadorDeErrores.obtenerNumeroDeLinea());
+      }
+    } catch (error) {
+      console.log(error);
+      return;
+    }
+    return await ejecutarConsultaSIGU("UPDATE `SIGU`.`SIGU_NotificacionesV2` SET `Estado` = 'Leída' WHERE `Identificador` = ? AND `FechaYHoraDeCreacion` = ?"
+      , [Resultado.Identificador, FechaYHoraDeCreacion]);
+  }
+
+  async obtenerNotificaciones(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;
+    }
+    return await ejecutarConsultaSIGU("SELECT `Notificacion` AS `valor`, CONCAT(`FechaYHoraDeCreacion`) AS `llave`, false AS `tachado` FROM `SIGU`.`SIGU_NotificacionesV2` WHERE `Identificador` = ? AND `Estado` = 'Sin leer' ORDER BY `FechaYHoraDeCreacion` DESC LIMIT 10", [Resultado.Identificador]);
+  }
+
+  async reporteDeIncidencia(Solicitud, Datos) {
+    const DatosDelArchivo = await this.cargarArchivo(Solicitud, Datos);
+    await envioDeCorreo('msavatar@utn.ac.cr', "Reporte de incidencia",
+      "<p><b>Sistema: </b>" + this.NombreCanonicoDelModulo + "</p><br />"
+      + "<p><b>Asunto: </b>Reporte de incidencia</p><br />"
+      + "<p><b>Detalle de la incidencia: </b>" + Datos.detalle + "</p><br />"
+      + "<p><b>Resultado esperado: </b>" + Datos.resultado + "</p><br />"
+      + "<p><b>Información de contacto: </b>" + Datos.concato + "</p><br />"
+      + "<p><b>Información del usuario: </b>" + await this.obtenerDatosDelUsuario(Solicitud.headers.authorization) + "</p><br />"
+      , [DatosDelArchivo.rutaDeArchivo]);
+    return;
+  }
+
+  async reporteDeSugerencia(Solicitud, Datos) {
+    // const DatosDelArchivo = await this.cargarArchivo(Solicitud, Datos);
+    await envioDeCorreo('msavatar@utn.ac.cr', "Reporte de sugerencia",
+      "<p><b>Sistema: </b>" + this.NombreCanonicoDelModulo + "</p><br />"
+      + "<p><b>Asunto: </b>Reporte de sugerencia</p><br />"
+      + "<p><b>Detalle de la sugerencia: </b>" + Datos.detalle + "</p><br />"
+      + "<p><b>Información del usuario: </b>" + await this.obtenerDatosDelUsuario(Solicitud.headers.authorization) + "</p><br />");
+    return;
+  }
+
+  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 permisosDelModuloV2(NombreCanonicoDelModulo) {
+    return await ejecutarConsultaSIGU("\
+        WITH RECURSIVE `Jerarquia` AS (\
+          SELECT\
+            `m`.`Padre`,\
+            `m`.`Nombre` AS `Modulo`,\
+            `p`.`PermisoId`,\
+            `p`.`Nombre` AS `Permiso`\
+          FROM `SIGU`.`SIGU_ModulosV2` `m`\
+          JOIN `SIGU`.`SIGU_PermisosV2` `p` ON `p`.`Modulo` = `m`.`Nombre`\
+          WHERE `m`.`Nombre` = ?\
+          UNION ALL\
+          SELECT \
+            `m`.`Padre`,\
+            `m`.`Nombre` AS `Modulo`,\
+            `p`.`PermisoId`,\
+            `p`.`Nombre` AS `Permiso`\
+          FROM `SIGU`.`SIGU_ModulosV2` `m`\
+          JOIN `SIGU`.`SIGU_PermisosV2` `p` ON `p`.`Modulo` = `m`.`Nombre`\
+          JOIN `Jerarquia` `j` ON `j`.`Padre` = `m`.`Nombre`\
+        )\
+        SELECT DISTINCT * FROM `Jerarquia`"
+      , [NombreCanonicoDelModulo]
+    );
+  }
+
+  async modulosV2() {
+    return await ejecutarConsultaSIGU("SELECT `Nombre`, `Padre`, `Descripcion`, `Detalle`, `Tipo`, `Icono`, `Color`, `Correo`, `Version`, `FechaDePublicacion`, `AcuerdoDeNivelDeServicio`, `DiccionarioDeDatos`, `Repositorios`, `EnlaceDelVideo`, `EnlaceDelManual`, `Estado` FROM `SIGU`.`SIGU_ModulosV2`");
+  }
+
+  async permisoIdV2() {
+    const Datos = await ejecutarConsultaSIGU("SELECT `PermisoId` FROM `SIGU`.`SIGU_PermisosV2` WHERE `Nombre` = ? AND `Modulo` = ?", [this.NombreDelPermisoV2, this.NombreCanonicoDelModulo]);
+    return Datos[0]['PermisoId'];
+  }
+
+  async permisoIdDelPadreV2() {
+    const Datos = await ejecutarConsultaSIGU("SELECT `PermisoId` FROM `SIGU`.`SIGU_PermisosV2` WHERE `Modulo` = ?"
+      , [this.MenuPadre]);
+    return Datos[0]['PermisoId'];
+  }
+
+  async registroDelModuloEnSIGUV2() {
+    const Version = this.Version + "$$" + this.versionDelNucleo().split(' ')[0];
+    await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_ModulosV2` VALUES\
+      (?, ?, ?, ?, ?, ?, ?, ?, ?, NOW(4), ?, 'DiccionarioDeDatos'\
+      , ?, '-', '-', 'Activo', NOW(4), USER()) ON DUPLICATE KEY UPDATE `Version` = ?, `Repositorios` = ?"
+      , [this.NombreCanonicoDelModulo, this.MenuPadre, this.DescripcionDelModulo, this.DetalleDelModulo
+        , this.TipoDeCard, this.IconoDelModulo, this.ColorDelModulo, this.CorreoParaReportes, Version, this.versionDelNucleo().split(' ')[0], this.Repositorios
+        , Version, this.Repositorios]);
+    await ejecutarConsultaSIGU("SELECT IFNULL(MAX(`PermisoId`), 0) + 1 INTO @`SiguientePermisoId` FROM `SIGU`.`SIGU_PermisosV2`;\
+      INSERT INTO `SIGU`.`SIGU_PermisosV2` VALUES\
+      (@`SiguientePermisoId`, ?, ?, ?, NOW(4), USER()) ON DUPLICATE KEY UPDATE `LastUser` = USER(), `Nombre` = ?, `Descripcion` = ?;"
+      , [this.NombreDelPermisoV2, this.NombreCanonicoDelModulo, this.DescripcionDelPermiso, this.NombreDelPermisoV2, this.DescripcionDelPermiso]);
+
+    // Creación de Flujo de aprobaciones predeterminado del módulo
+    await ejecutarConsultaSIGU("SELECT COALESCE(MAX(`FlujoDeAprobacionId`), 0) + 1 INTO @`Consecutivo` FROM `SIGU`.`SIGU_FlujosDeAprobacion`;\
+      INSERT INTO `SIGU`.`SIGU_FlujosDeAprobacion` VALUES (@`Consecutivo`, ?, CONCAT('Flujo de aprobación predeterminado para:', ' ', ?), TRUE, NOW(4), USER()) ON DUPLICATE KEY UPDATE `LastUpdate` = NOW(4);"
+      , [this.NombreCanonicoDelModulo, this.NombreCanonicoDelModulo]);
+    await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_FlujosDeAprobacionPasos` VALUES (\
+          (SELECT `FlujoDeAprobacionId` FROM `SIGU`.`SIGU_FlujosDeAprobacion` WHERE `NombreCanonico` = ?)\
+          , 0, 'Sin aprobaciones realizadas', (SELECT `Identificador` FROM `SIGU`.`SIGU_Personas` WHERE `Identificacion` = '111050570'), 0, NOW(4), USER()) ON DUPLICATE KEY UPDATE `LastUpdate` = NOW(4)"
+      , [this.NombreCanonicoDelModulo]);
+
+    // Asignación del permiso a dvillalobos
+    await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_PermisosPersonasV2` VALUES (?,\
+    (SELECT `Identificador` FROM `SIGU`.`SIGU_Personas` WHERE `Identificacion` = '111050570'), NOW(4), USER()) ON DUPLICATE KEY UPDATE `LastUser` = USER()"
+      , [await this.permisoIdV2()]);
+
+    // Asginación inicial de permisos
+    if (this.UsuariosConAccesoInicial.length > 0) {
+      const permisoId = await this.permisoIdV2();
+      const permisoIdDelPadre = await this.permisoIdDelPadreV2();
+      this.UsuariosConAccesoInicial.forEach(async (dato) => {
+        await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_PermisosPersonasV2` VALUES (?,\
+          (SELECT `Identificador` FROM `SIGU`.`SIGU_Personas` WHERE `Identificacion` = ?), NOW(4), USER())\
+            ON DUPLICATE KEY UPDATE `LastUpdate` = NOW(4)"
+          , [permisoIdDelPadre, dato]);
+        await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_PermisosPersonasV2` VALUES (?,\
+          (SELECT `Identificador` FROM `SIGU`.`SIGU_Personas` WHERE `Identificacion` = ?), NOW(4), USER())\
+            ON DUPLICATE KEY UPDATE `LastUpdate` = NOW(4)"
+          , [permisoId, dato]);
+      });
+    }
+
+    // Validación de que sólo el front especificado pueda consumir este backend
+    const uuidTemporal = await ejecutarConsultaSIGU("SELECT UUID() AS `UUID`");
+    await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_Repositorios` VALUES (?, ?) ON DUPLICATE KEY UPDATE `Identificador` = ?"
+      , [this.NombreDelRepositorioDelFrontend, uuidTemporal[0]['UUID'], uuidTemporal[0]['UUID']]);
+    await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_RepositoriosAccesos` VALUES (?, ?)\
+             ON DUPLICATE KEY UPDATE `RepositorioDestino` = ?,`RepositorioOrigen` = ?"
+      , [this.NombreDelRepositorioDelBackend, this.NombreDelRepositorioDelFrontend, this.NombreDelRepositorioDelBackend, this.NombreDelRepositorioDelFrontend]);
+
+    // Impresión de la información de registro
+    console.log(new Date());
+    console.log(`Módulo registrado correctamente en SIGU. Módulo: ${this.NombreCanonicoDelModulo}`);
+    console.log(`Identificador del flujo de aprobación: ${await this.idDelFlujoDeAprobacion()}`);
+    console.log(`Enlace del módulo: ${this.Enlace}`);
+    console.log(`Permisos: ${JSON.stringify(await this.permisosDelModuloV2(this.NombreCanonicoDelModulo))}`);
+    this.creacionDeldirectorioParaElAlmacenamientoDeArchivos();
+    console.log(`Versión del núcleo: ${this.versionDelNucleo()}`);
+
+    // // Creación de variables de entorno
+    // process.env.SERVIDORSMTP = await this.servidorSMTP();
+    // process.env.USUARIOSMTP = await this.usuarioSMTP();
+    // process.env.PUERTOSMTP = await this.puertoSMTP();
+    // process.env.CLAVESMTP = await this.claveSMTP();
+    // process.env.DESTINATARIODEINFORMESDEERROR = await this.destinatarioDeInformesDeError();
+    // process.env.NOMBRECANONICODELMODULO = this.NombreCanonicoDelModulo;
+  }
+
+  generarUUID() {
+    return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11)
+      .replace(/[018]/g, c =>
+        (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16)
+      );
+  }
+
+  async obtenerPersonasFuncionarias() {
+    return await ejecutarConsultaSIGU("SELECT `Identificador`, `Identificacion`, `Nombre`, `PrimerApellido`,\
+      `SegundoApellido` FROM `SIGU`.`SIGU_Personas` WHERE `Identificador` IN\
+        (SELECT `Identificador` FROM `SIGU`.`EstructuraOrganizacional_Instancias`) ORDER BY `Nombre`, `PrimerApellido`,\
+      `SegundoApellido`");
+  }
+
+  // async rolPermisoIdDelMenuPadre() {
+  //   const rolPermisoIdDelMenuPadre = await ejecutarConsultaSIGU("SELECT `RolPermisoId` FROM `SIGU`.`SIGU_RolesPermisos` WHERE\
+  //     `PermisoId` = (SELECT `PermisoId` FROM `SIGU`.`SIGU_Menu` WHERE `Nombre` = ?)", [this.MenuPadre]);
+  //   return rolPermisoIdDelMenuPadre[0]['RolPermisoId'];
+  // }
+
+  async getUUID() {
+    const Identificador = await ejecutarConsultaSIGU("SELECT `Identificador` FROM `SIGU`.`SIGU_Repositorios` WHERE `Repositorio` = ?", [this.NombreDelRepositorioDelBackend]);
+    return Identificador[0]['Identificador'];
+  }
 
-Object.assign(Miscelaneo.prototype, MixinAutenticacion);
-Object.assign(Miscelaneo.prototype, MixinNotificaciones);
-Object.assign(Miscelaneo.prototype, MixinTareasProgramadas);
-Object.assign(Miscelaneo.prototype, MixinPersonas);
-Object.assign(Miscelaneo.prototype, MixinArchivos);
-Object.assign(Miscelaneo.prototype, MixinModulos);
-Object.assign(Miscelaneo.prototype, MixinInicializacion);
-Object.assign(Miscelaneo.prototype, MixinReportes);
+  async perfilGeneralId() {
+    const PerfilGeneralId = await ejecutarConsultaSIGU("SELECT `PerfilGeneralId` FROM `SIGU`.`SIGU_PerfilesGenerales` WHERE `Perfil` = ?", [this.PerfilGeneral]);
+    return PerfilGeneralId[0]['PerfilGeneralId'];
+  }
+
+  // async rolIdDelModulo() {
+  //   const RolId = await ejecutarConsultaSIGU("SELECT `RolId` FROM `SIGU`.`SIGU_Roles` WHERE `Descripcion` = ?", [this.NombreDelRol]);
+  //   return RolId[0]['RolId'];
+  // }
+
+  // async permisoIdDelModulo() {
+  //   const PermisoId = await ejecutarConsultaSIGU("SELECT `PermisoId` FROM `SIGU`.`SIGU_Permisos` WHERE `Nombre` = ?", [this.NombreDelPermiso]);
+  //   return PermisoId[0]['PermisoId'];
+  // }
+
+  async rolPermisoIdDelModulo() {
+    this.RolId = await this.rolIdDelModulo();
+    this.PermisoId = await this.permisoIdDelModulo();
+    const RolPermisoId = await ejecutarConsultaSIGU("SELECT `RolPermisoId` FROM `SIGU`.`SIGU_RolesPermisos` WHERE `RolId` = ? AND `PermisoId` = ?"
+      , [this.RolId, this.PermisoId]);
+    return RolPermisoId[0]['RolPermisoId'];
+  }
+
+  // async idDelMenuPadre() {
+  //   const IdDelMenuPadre = await ejecutarConsultaSIGU("SELECT `MenuId` FROM `SIGU`.`SIGU_Menu` WHERE `Nombre` = ?", [this.MenuPadre]);
+  //   return IdDelMenuPadre[0]['MenuId'];
+  // }
+
+  // async idDelMenuDelModulo() {
+  //   const IdDelMenuDelModulo = await ejecutarConsultaSIGU("SELECT `MenuId` FROM `SIGU`.`SIGU_Menu` WHERE `Nombre` = ?", [this.NombreCanonicoDelModulo]);
+  //   return IdDelMenuDelModulo[0]['MenuId'];
+  // }
+
+  generarEnlace(Modulo) {
+    return ((process.env.ENV || 'local') === 'production' ? 'https' : 'http')
+      + '://' + Modulo
+      + ((process.env.ENV || 'local') === 'production' ? '' : '-' + (process.env.ENV || 'local'))
+      + ((process.env.ENV || 'local') === 'production' ? '.sigu.utn.ac.cr' : '-');
+  }
+
+  async registroDelModuloEnSIGU() {
+
+    // Creación del enlace
+    this.Enlace = this.generarEnlace(this.NombreDelRepositorioDelFrontend);
+
+    // Creación del enlace a portal
+    this.EnlaceDePortal = this.generarEnlace('portalv2-frontend');
+
+    // Creación del enlace a perfil
+    this.EnlaceDePerfil = this.generarEnlace('perfilv2-frontend');
+
+    // Creación del enlace a acceso
+    this.EnlaceDeAcceso = this.generarEnlace('accesov2-frontend');
+
+    // // Creación del Rol
+    // const RolId = await ejecutarConsultaSIGU("SELECT (MAX(`RolId`) + 1) AS `RolId` FROM `SIGU`.`SIGU_Roles` WHERE `RolId` < 1000");
+    // await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_Roles` VALUES (?, ?, NOW(4), USER()) ON DUPLICATE KEY UPDATE `LastUpdate` = NOW(4)", [RolId[0]['RolId'], this.NombreDelRol]);
+    // this.RolId = await this.rolIdDelModulo();
+
+    // // Creación del Módulo
+    // await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_Modulos` VALUES (?, ?, ?, ?, ?, 1, ?, ?\
+    //     , (SELECT `Identificador` FROM  `SIGU`.`SIGU_Personas` WHERE `Identificacion` = '111050570')\
+    //     , (SELECT `Identificador` FROM  `SIGU`.`SIGU_Personas` WHERE `Identificacion` = '111050570')\
+    //     , (SELECT `Identificador` FROM  `SIGU`.`SIGU_Personas` WHERE `Identificacion` = '111050570')\
+    //     , ?, '1.0.0', NOW(4), 'ANS', '/', ?, '1', NOW(4), USER()) ON DUPLICATE KEY UPDATE `LastUpdate` = NOW(4)"
+    //   , [this.NombreDelModulo, this.DescripcionDelModulo, this.NombreCanonicoDelModulo, this.TipoDeCard, this.IconoDelModulo
+    //     , this.ColorDelModulo, this.RolId, this.CorreoParaReportes, this.Repositorios]);
+
+    // // Creación del Permiso
+    // await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_Permisos` VALUES (NULL, ?, ?, NOW(4), USER()) ON DUPLICATE KEY UPDATE `LastUpdate` = NOW(4)"
+    //   , [this.NombreDelPermiso, this.DescripcionDelPermiso]);
+    // this.PermisoId = await this.permisoIdDelModulo();
+
+    // // Creación del Rol-Permiso
+    // await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_RolesPermisos` VALUES (NULL, ?, ?, NOW(4), USER()) ON DUPLICATE KEY UPDATE `LastUpdate` = NOW(4)"
+    //   , [this.RolId, this.PermisoId]);
+    // this.RolPermisoId = await this.rolPermisoIdDelModulo();
+
+    // // Asignación del permiso a dvillalobos
+    // const perfilGeneralId = await this.perfilGeneralId();
+    // await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_RolesPersonas` VALUES (?, ?,\
+    //     (SELECT `Identificador` FROM `SIGU`.`SIGU_Personas` WHERE `Identificacion` = '111050570'), NOW(4), USER())\
+    //     ON DUPLICATE KEY UPDATE `LastUpdate` = NOW(4)"
+    //   , [this.RolPermisoId, perfilGeneralId]);
+
+    // // Creación de los menús
+    // this.IdDelMenuPadre = await this.idDelMenuPadre();
+    // await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_Menu` VALUES (NULL, ?, ?, ?, 'Módulo', 'opciones', ?\
+    //   , ?, ?, 0, 1, NOW(4), USER()) ON DUPLICATE KEY UPDATE `LastUpdate` = NOW(4)"
+    //   , [this.PermisoId, this.NombreCanonicoDelModulo, this.DescripcionDelModulo, this.NombreCanonicoDelModulo, this.Enlace, this.IdDelMenuPadre]);
+    // this.IdDelMenuDelModulo = await this.idDelMenuDelModulo();
+
+    // let IdDelMenuAreas = await ejecutarConsultaSIGU("SELECT `MenuId` FROM `SIGU`.`SIGU_Menu` WHERE `Nombre` = 'Menú principal de áreas'\
+    //   AND `Padre` = ?", [this.IdDelMenuDelModulo]);
+    // if (IdDelMenuAreas.length === 0) {
+    //   IdDelMenuAreas = await ejecutarConsultaSIGU("SELECT MAX(`MenuId`) + 1 AS `MenuId` FROM `SIGU`.`SIGU_Menu`");
+    //   await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_Menu` VALUES (?, ?, 'Menú principal de áreas', 'Regreso al menú principal de áreas', 'Opción Menú', 'inicio'\
+    //     , NULL, '/modulos', ?, 0, 1, NOW(4), USER())"
+    //     , [IdDelMenuAreas[0]['MenuId'], this.PermisoId, this.IdDelMenuDelModulo]);
+    // }
+
+    // let IdDelMenuRegreso1 = await ejecutarConsultaSIGU("SELECT `MenuId` FROM `SIGU`.`SIGU_Menu` WHERE `Nombre` = CONCAT('Regreso a ', ?)\
+    //   AND `Padre` = ?", [this.MenuPadre, this.IdDelMenuDelModulo]);
+    // if (IdDelMenuRegreso1.length === 0) {
+    //   IdDelMenuRegreso1 = await ejecutarConsultaSIGU("SELECT MAX(`MenuId`) + 1 AS `MenuId` FROM `SIGU`.`SIGU_Menu`");
+    //   await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_Menu` VALUES (?, ?, CONCAT('Regreso a ', ?), CONCAT('Regreso a ', ?), 'Opción Menú', 'opciones'\
+    //     , NULL, CONCAT('/modulos/', ?), ?, 0, 1, NOW(4), USER())"
+    //     , [IdDelMenuRegreso1[0]['MenuId'], this.PermisoId, this.MenuPadre, this.MenuPadre, this.IdDelMenuPadre, this.IdDelMenuDelModulo]);
+    // }
+
+    // let IdDelMenuRegreso2 = await ejecutarConsultaSIGU("SELECT `MenuId` FROM `SIGU`.`SIGU_Menu` WHERE `Nombre` = CONCAT('Regreso a ', ?)\
+    //   AND `Padre` = ?", [this.NombreCanonicoDelModulo, this.IdDelMenuDelModulo]);
+    // if (IdDelMenuRegreso2.length === 0) {
+    //   IdDelMenuRegreso2 = await ejecutarConsultaSIGU("SELECT MAX(`MenuId`) + 1 AS `MenuId` FROM `SIGU`.`SIGU_Menu`");
+    //   await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_Menu` VALUES (?, ?, CONCAT('Regreso a ', ?), CONCAT('Regreso a ', ?), 'Opción Menú', 'menus'\
+    //     , NULL, CONCAT('/enlace/', ?, '/', ?), ?, 0, 1, NOW(4), USER())"
+    //     , [IdDelMenuRegreso2[0]['MenuId'], this.PermisoId, this.NombreCanonicoDelModulo, this.NombreCanonicoDelModulo
+    //       , this.IdDelMenuDelModulo, Buffer.from(this.Enlace.split('//')[1]).toString('base64'), this.IdDelMenuDelModulo]);
+    // }
+
+    // Creación del UUID del módulo
+    const uuidTemporal = await ejecutarConsultaSIGU("SELECT UUID() AS `UUID`");
+    this.UUID = uuidTemporal[0]['UUID'];
+    await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_Repositorios` VALUES (?, ?) ON DUPLICATE KEY UPDATE `Identificador` = ?"
+      , [this.NombreDelRepositorioDelBackend, this.UUID, this.UUID]);
+    process.env.UUID = this.UUID;
+    if (this.BackEndsQueConsumeEsteModulo.length > 0) {
+      this.BackEndsQueConsumeEsteModulo.forEach(async (dato) => {
+        await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_RepositoriosAccesos` VALUES (?, ?)\
+             ON DUPLICATE KEY UPDATE `RepositorioDestino` = ?,`RepositorioOrigen` = ?"
+          , [dato, this.NombreDelRepositorioDelBackend, dato, this.NombreDelRepositorioDelBackend]);
+      });
+    }
+
+    // // Asginación inicial de permisos
+    // if (this.UsuariosConAccesoInicial.length > 0) {
+    //   const rolPermisoIdDelPadre = await this.rolPermisoIdDelMenuPadre();
+    //   this.UsuariosConAccesoInicial.forEach(async (dato) => {
+    //     await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_RolesPersonas` VALUES (?, ?,\
+    //         (SELECT `Identificador` FROM `SIGU`.`SIGU_Personas` WHERE `Identificacion` = ?), NOW(4), USER())\
+    //          ON DUPLICATE KEY UPDATE `LastUpdate` = NOW(4)"
+    //       , [this.RolPermisoId, perfilGeneralId, dato]);
+    //     await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_RolesPersonas` VALUES (?, ?,\
+    //         (SELECT `Identificador` FROM `SIGU`.`SIGU_Personas` WHERE `Identificacion` = ?), NOW(4), USER())\
+    //          ON DUPLICATE KEY UPDATE `LastUpdate` = NOW(4)"
+    //       , [rolPermisoIdDelPadre, perfilGeneralId, dato]);
+    //   });
+    // }
+
+    // // Impresión de la información de registro
+    // console.log(new Date());
+    // console.log(`Módulo registrado correctamente en SIGU. Módulo: ${this.NombreCanonicoDelModulo}`);
+    // console.log(`Identificador de rol a utilizar (RolId): ${this.RolId}`);
+    // console.log(`Identificador de permiso a utilizar (PermisoId): ${this.PermisoId}`);
+    // console.log(`Identificador de Rol-Permiso a utilizar (RolPermisoId): ${this.RolPermisoId}`);
+    // console.log(`Identificador del menú padre (MenuId del padre): ${this.IdDelMenuPadre}`);
+    // console.log(`Identificador del menú (MenuId del módulo): ${this.IdDelMenuDelModulo}`);
+    // // console.log(`Identificador del flujo de aprobación: ${await this.idDelFlujoDeAprobacion()}`);
+    // console.log(`Enlace del módulo: ${this.Enlace}`);
+    // this.creacionDeldirectorioParaElAlmacenamientoDeArchivos();
+    // console.log(`Versión del núcleo: ${this.versionDelNucleo()}`);
+
+    // Creación de variables de entorno
+    process.env.SERVIDORSMTP = await this.servidorSMTP();
+    process.env.USUARIOSMTP = await this.usuarioSMTP();
+    process.env.PUERTOSMTP = await this.puertoSMTP();
+    process.env.CLAVESMTP = await this.claveSMTP();
+    process.env.DESTINATARIODEINFORMESDEERROR = await this.destinatarioDeInformesDeError();
+    process.env.NOMBRECANONICODELMODULO = this.NombreCanonicoDelModulo;
+
+    await this.registroDelModuloEnSIGUV2();
+  }
+
+  enlaceDelFrontend() {
+    return this.Enlace;
+  }
+
+  async idDelFlujoDeAprobacion() {
+    const Resultado = await ejecutarConsultaSIGU("SELECT `FlujoDeAprobacionId` FROM `SIGU`.`SIGU_FlujosDeAprobacion` WHERE `NombreCanonico` = ?"
+      , [this.NombreCanonicoDelModulo]);
+    return Resultado[0]['FlujoDeAprobacionId'];
+  }
+
+  fechaConFormato() {
+    const ahora = new Date(Date.now());
+    const anio = ahora.getFullYear();
+    const mes = String(ahora.getMonth() + 1).padStart(2, '0');
+    const dia = String(ahora.getDate()).padStart(2, '0');
+    const hora = String(ahora.getHours()).padStart(2, '0');
+    const minutos = String(ahora.getMinutes()).padStart(2, '0');
+    const segundos = String(ahora.getSeconds()).padStart(2, '0');
+    return `${anio}${mes}${dia}${hora}${minutos}${segundos}`;
+  }
+  creacionDeldirectorioParaElAlmacenamientoDeArchivos() {
+    const fs = require('fs');
+    try {
+      if (!fs.existsSync(this.directorioParaElAlmacenamientoDeArchivos())) {
+        fs.mkdirSync(this.directorioParaElAlmacenamientoDeArchivos(), { recursive: true });
+        console.log(`El directorio '${this.directorioParaElAlmacenamientoDeArchivos()}' ha sido creado.`);
+      } else {
+        console.log(`El directorio '${this.directorioParaElAlmacenamientoDeArchivos()}' ya existe.`);
+      }
+    } catch (error) {
+      console.error(`Se presentó el siguiente problema al interactuar con el sistema de archivos: ${error}`);
+    }
+  }
+
+  directorioParaElAlmacenamientoDeArchivos() {
+    return '/var/storage/public/' + this.NombreCanonicoDelModulo;
+  }
+
+  versionDelNucleo() {
+    return "VERSION_DEL_NUCLEO" + " " + this.NombreCanonicoDelModulo;
+  }
+
+  async destinatarioDeInformesDeError() {
+    const destinatarioDeInformesDeError = await ejecutarConsultaSIGU("SELECT `Valor` FROM `SIGU`.`SIGU_VariablesDeSistema` WHERE `Nombre` = 'DestinatarioDeInformesDeError'");
+    if (destinatarioDeInformesDeError.length > 0) {
+      return destinatarioDeInformesDeError[0]['Valor'];
+    } else {
+      return '';
+    }
+  }
+
+  async claveSMTP() {
+    const claveSMTP = await ejecutarConsultaSIGU("SELECT `Valor` FROM `SIGU`.`SIGU_VariablesDeSistema` WHERE `Nombre` = 'ClaveSMTP'");
+    if (claveSMTP.length > 0) {
+      return claveSMTP[0]['Valor'];
+    } else {
+      return '';
+    }
+  }
+
+  async puertoSMTP() {
+    const puertoSMTP = await ejecutarConsultaSIGU("SELECT `Valor` FROM `SIGU`.`SIGU_VariablesDeSistema` WHERE `Nombre` = 'PuertoSMTP'");
+    if (puertoSMTP.length > 0) {
+      return puertoSMTP[0]['Valor'];
+    } else {
+      return '';
+    }
+  }
+
+  async usuarioSMTP() {
+    const usuarioSMTP = await ejecutarConsultaSIGU("SELECT `Valor` FROM `SIGU`.`SIGU_VariablesDeSistema` WHERE `Nombre` = 'UsuarioSMTP'");
+    if (usuarioSMTP.length > 0) {
+      return usuarioSMTP[0]['Valor'];
+    } else {
+      return '';
+    }
+  }
+
+  async servidorSMTP() {
+    const servidorSMTP = await ejecutarConsultaSIGU("SELECT `Valor` FROM `SIGU`.`SIGU_VariablesDeSistema` WHERE `Nombre` = 'ServidorSMTP'");
+    if (servidorSMTP.length > 0) {
+      return servidorSMTP[0]['Valor'];
+    } else {
+      return '';
+    }
+  }
+
+  almacenarCuentaIBAN(Cuerpo) {
+    return ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_CuentasBancariasPersonas` VALUES (NULL, ?, ?, TRUE, NOW(4), ?)\
+      ON DUPLICATE KEY UPDATE `LastUpdate` = NOW(4), `LastUser` = ?"
+      , [Cuerpo.Identificador, Cuerpo.IBAN, Cuerpo.LastUser, Cuerpo.LastUser]);
+  }
+
+  async obtenerDatosDeLaPersona(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;
+    }
+    return await ejecutarConsultaSIGU("SELECT `a`.`Identificador`, `a`.`Identificacion`\
+      , `a`.`Nombre`, `a`.`PrimerApellido`, `a`.`SegundoApellido`\
+      , (SELECT GROUP_CONCAT(`b`.`CuentaIBAN`) FROM `SIGU`.`SIGU_CuentasBancariasPersonas` `b` WHERE `b`.`Estado` = TRUE AND `a`.`Identificador` = `b`.`Identificador`) AS `CuentasIBAN`\
+      FROM `SIGU`.`SIGU_Personas` `a` WHERE `a`.`Identificador` = ?"
+      , [Resultado.Identificador]);
+  }
+
+  async obtenerDatosDeLaPersonaPorIdentificacion(Identificacion) {
+    return await ejecutarConsultaSIGU("SELECT `a`.`Identificador`, `a`.`Identificacion`\
+      , `a`.`Nombre`, `a`.`PrimerApellido`, `a`.`SegundoApellido`\
+      , (SELECT GROUP_CONCAT(`b`.`CuentaIBAN`) FROM `SIGU`.`SIGU_CuentasBancariasPersonas` `b` WHERE `b`.`Estado` = TRUE AND `a`.`Identificador` = `b`.`Identificador`) AS `CuentasIBAN`\
+      FROM `SIGU`.`SIGU_Personas` `a` WHERE `a`.`Identificacion` = ?"
+      , [Identificacion]);
+  }
+
+  async obtenerEstudiantes() {
+    return await ejecutarConsultaSIGU("SELECT `Identificador`, `Identificacion`, `Nombre`, `PrimerApellido`,\
+      `SegundoApellido` FROM `SIGU`.`SIGU_Personas` WHERE `Identificador` IN\
+        (SELECT `Identificador` FROM `SIGU`.`SIGU_RolesPersonas` WHERE `PerfilGeneralId` = 1 /*El perfil 1 parece ser para Estudiantes*/)");
+  }
+
+  async obtenerBeneficios() {
+    return await ejecutarConsultaSIGU("SELECT `BeneficioId`, `Beneficio`, `Estado` FROM `SIGU`.`SIGU_Beneficios`");
+  }
+
+  async obtenerIdentificacion(Identificador) {
+    return await ejecutarConsultaSIGU("SELECT `Identificacion` FROM `SIGU`.`SIGU_Personas` WHERE `Identificador` = ?", [Identificador]);
+  }
+
+  async obtenerPeriodos() {
+    return await ejecutarConsultaSIGU("SELECT `PeriodoId`, `CodigoPeriodo`, `Anio`, `Periodo`, `FechaInicio`, `FechaFinal`, `Tipo`, `Estado` FROM `SIGU`.`SIGU_Periodos` ORDER BY `Anio` DESC, `CodigoPeriodo` DESC");
+  }
+
+  async obtenerAnios() {
+    return await ejecutarConsultaSIGU("SELECT DISTINCT `Anio` FROM `SIGU`.`SIGU_Periodos`");
+  }
+
+  async obtenerSedes() {
+    return await ejecutarConsultaSIGU("SELECT `SedesId`, `CodigoAvatar`, `Descripcion`, `Siglas` FROM `SIGU`.`SIGU_Sedes` ORDER BY `Descripcion`");
+  }
+
+  async obtenerRecintos() {
+    return await ejecutarConsultaSIGU("SELECT `a`.`RecintoId`, CONCAT(`b`.`Descripcion`, '/', `a`.`Recinto`) AS `Recinto` FROM `SIGU`.`SIGU_Recintos` `a` LEFT JOIN `SIGU`.`SIGU_Sedes` `b` ON (`a`.`SedeId` = `b`.`SedesId`) ORDER BY `Recinto`");
+  }
+
+  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 obtenerDatosDelUsuario(encabezadoDeAutorizacion) {
+    const jwt = require('jsonwebtoken');
+    // Obtención del token
+    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;
+    }
+
+    // Verificación del token
+    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 validarTokenV2(encabezadoDeAutorizacion, permisoExtraId = undefined) {
+    let Resultado = undefined;
+    try {
+      Resultado = await this.obtenerDatosDelUsuario(encabezadoDeAutorizacion);
+    } catch (error) {
+      console.error(error);
+    }
+    // Validación del token para el usuario y authorización
+    if (Resultado) {
+      try {
+        // Validación del token en la sesión
+        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) {
+          // Validación de permisos
+          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);
+    // const Resultado = undefined;
+    // try {
+    //   Resultado = await this.obtenerDatosDelUsuario(encabezadoDeAutorizacion);
+    // } catch (error) {
+    //   console.error(error);
+    // }
+    // // Validación del token para el usuario y authorización
+    // if (Resultado) {
+    //   try {
+    //     // Validación del token en la sesión
+    //     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) { // Se compara con >= para preveer multisesiones
+    //       // Validación de permisos
+    //       const perfilGeneralId = await this.perfilGeneralId();
+    //       const rolPermisoId = await this.rolPermisoIdDelModulo();
+    //       const permisos = await ejecutarConsultaSIGU("SELECT COUNT(*) AS `Total` FROM `SIGU`.`SIGU_RolesPersonas`\
+    //         WHERE `RolPermisoId` = ? AND `Identificador` = ? AND `PerfilGeneralId` = ?", [rolPermisoId, Resultado.Identificador, perfilGeneralId]);
+    //       if (permisos[0]['Total'] === 1) {
+    //         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;
+  }
+
+  convertirACSV(ArregloDeJSON) {
+    if (!ArregloDeJSON || ArregloDeJSON.length === 0) return '';
+    const intentarParsearJSON = (valor) => {
+      if (typeof valor === 'object' && valor !== null && !Array.isArray(valor)) return valor;
+      if (typeof valor === 'string' && valor.trim().startsWith('{')) {
+        try {
+          const objeto = JSON.parse(valor);
+          if (typeof objeto === 'object' && objeto !== null && !Array.isArray(objeto)) return objeto;
+        } catch (e) { }
+      }
+      return null;
+    };
+    const columnasOriginales = Object.keys(ArregloDeJSON[0]);
+    const mapaColumnasJSON = {};
+    columnasOriginales.forEach(col => {
+      const todasLasLlaves = new Set();
+      let esJSON = false;
+      ArregloDeJSON.forEach(fila => {
+        const obj = intentarParsearJSON(fila[col]);
+        if (obj) {
+          esJSON = true;
+          Object.keys(obj).forEach(k => todasLasLlaves.add(k));
+        }
+      });
+      if (esJSON) mapaColumnasJSON[col] = Array.from(todasLasLlaves);
+    });
+
+    const encabezadosFinales = [];
+    columnasOriginales.forEach(col => {
+      if (mapaColumnasJSON[col]) {
+        mapaColumnasJSON[col].forEach(llave => encabezadosFinales.push(`${col}_${llave}`));
+      } else {
+        encabezadosFinales.push(col);
+      }
+    });
+
+    const filasCSV = ArregloDeJSON.map(fila => {
+      const valoresFila = [];
+      columnasOriginales.forEach(col => {
+        if (mapaColumnasJSON[col]) {
+          const obj = intentarParsearJSON(fila[col]) || {};
+          mapaColumnasJSON[col].forEach(llave => {
+            let valor = obj[llave];
+            if (valor === undefined || valor === null || valor === 'null') valor = '';
+            valoresFila.push(JSON.stringify(String(valor)).replace(/,/g, ' '));
+          });
+        } else {
+          let valor = fila[col];
+          if (valor === null || valor === 'null') valor = '';
+          valoresFila.push(JSON.stringify(String(valor)).replace(/,/g, ' '));
+        }
+      });
+      return valoresFila.join(',');
+    });
+    return [encabezadosFinales.join(','), ...filasCSV].join('\n');
+  };
+
+  convertirACSVConDetalle(ArregloDeJSON, ColumnaConDetalle) {
+    if (!ArregloDeJSON || ArregloDeJSON.length === 0) return '';
+    const ejemploConDetalle = ArregloDeJSON.find(e => Array.isArray(e[ColumnaConDetalle]) && e[ColumnaConDetalle].length > 0);
+    const camposDetalle = ejemploConDetalle ? Object.keys(ejemploConDetalle[ColumnaConDetalle][0]) : [];
+    const columnasBase = Object.keys(ArregloDeJSON[0]).filter(key => key !== ColumnaConDetalle);
+    const encabezados = [...columnasBase, ...camposDetalle];
+    const filas = ArregloDeJSON.flatMap(fila => {
+      const detalles = Array.isArray(fila[ColumnaConDetalle]) ? fila[ColumnaConDetalle] : [];
+      if (detalles.length === 0) {
+        return [
+          encabezados.map(col => {
+            const valor = fila[col];
+            return formatearValor(valor);
+          }).join(',')
+        ];
+      }
+      return detalles.map(detalle => {
+        return encabezados.map(col => {
+          if (camposDetalle.includes(col)) {
+            return formatearValor(detalle[col]);
+          } else {
+            return formatearValor(fila[col]);
+          }
+        }).join(',');
+      });
+    });
+    return [encabezados.join(','), ...filas].join('\n');
+    function formatearValor(valor) {
+      if (valor === null || valor === 'null' || typeof valor === 'undefined') {
+        return '""';
+      }
+      return `"${String(valor).replace(/"/g, '""')}"`; // Escapa comillas
+    }
+  }
+
+  async validarIdentificadorAPI(Encabezados) {
+    // Obtención del UUID del repositorio
+    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;
+    }
+
+    // Obtención del Repositorio
+    let Repositorio = undefined;
+    try {
+      Repositorio = Encabezados.referrer;
+      if (!Repositorio) {
+        throw new ManejadorDeErrores(ManejadorDeErrores.mensajeDeErrorRepositorioOrigen(), ManejadorDeErrores.obtenerNumeroDeLinea());
+      }
+    } catch (error) {
+      console.error(error);
+      return false;
+    }
+
+    // Comprobar el UUID y el repositorio
+    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 {
+        // Comprobar si el repositorio origen tiene derecho a consumir el repositorio destino
+        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) {
+    // Esta función no es para autenticación, se parte del hecho de que la clave y el usario dada son correctos.
+    // Esta función se usa para que APIs de entidades externas debidamente documentadas consuman nuestros servicios.
+    // Si la clave no coincide, el usuario se bloquea.
+    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 consumirBackend(URL, Cuerpo = undefined, Tipo = undefined) {
+    const Encabezados = {
+      'Content-Type': 'application/json',
+      'Authorization': 'Bearer ' + await this.getUUID(),
+      'Referrer': this.NombreDelRepositorioDelBackend,
+      'Origin': this.Enlace
+    };
+    let Respuesta = undefined;
+    const Opciones = {
+      method: Cuerpo ? "POST" : "GET",
+      headers: Encabezados,
+      redirect: 'error'
+    };
+    if (Tipo === 'stream') {
+      Opciones.responseType = 'stream';
+    }
+    if (Cuerpo) {
+      Opciones.body = JSON.stringify(Cuerpo);
+    }
+    const ListaDeDominiosPermitidos = [
+      "sigu.utn.ac.cr",
+      "localhost",
+      "svc.cluster.local"
+    ];
+    try {
+      if (ListaDeDominiosPermitidos.some(dominio => URL.includes(dominio))) {
+        Respuesta = await fetch(URL, Opciones);
+      }
+      if (!Respuesta.ok) {
+        throw new ManejadorDeErrores(ManejadorDeErrores.mensajeDeErrorAccesoAAPI(Respuesta.error), ManejadorDeErrores.obtenerNumeroDeLinea());
+      }
+      if (Tipo === 'stream') {
+        return await Respuesta;
+      }
+      return await Respuesta.json();
+    } catch (error) {
+      console.error(error);
+      console.error(Respuesta);
+      throw new ManejadorDeErrores(error.message, ManejadorDeErrores.obtenerNumeroDeLinea());
+    }
+  };
+
+  async almacenarArchivoEnDisco(Solicitud, UId) {
+    const fs = require('fs');
+    const trozos = [];
+    let tamanioTotal = 0;
+    let informacionDelArchivo = {};
+
+    await new Promise((resolve, reject) => {
+      Solicitud.on('data', (trozo) => {
+        trozos.push(trozo);
+        tamanioTotal += trozo.length;
+      });
+
+      Solicitud.on('end', resolve);
+      Solicitud.on('error', reject);
+    });
+
+    try {
+      const buffer = Buffer.concat(trozos);
+      const limite = Solicitud.headers['content-type'].split('; ')[1].split('=')[1];
+      const limiteDelimitador = `--${limite}`;
+      const partes = buffer.toString('latin1').split(limiteDelimitador).filter(Boolean);
+
+      for (const parte of partes) {
+        if (parte.includes('filename=')) {
+          const [headers, ...contentParts] = parte.split('\r\n\r\n');
+          const contenidoBinario = Buffer.from(contentParts.join('\r\n\r\n'), 'latin1');
+          const nombreDeArchivoMatch = headers.match(/filename="([^"]+)"/);
+          const tipoDeContenidoMatch = headers.match(/Content-Type: ([^\r\n]+)/);
+
+          if (nombreDeArchivoMatch) {
+            const nombreDeArchivo = Buffer.from(nombreDeArchivoMatch[1], 'latin1').toString('utf8');
+            const tipoDeContenido = tipoDeContenidoMatch ? tipoDeContenidoMatch[1] : 'application/octet-stream';
+            const rutaDeArchivo = `${this.directorioParaElAlmacenamientoDeArchivos()}/${UId}-${this.fechaConFormato()}-${nombreDeArchivo}`;
+
+            fs.writeFileSync(rutaDeArchivo, contenidoBinario);
+
+            informacionDelArchivo = {
+              nombreDeArchivo,
+              tipoDeContenido,
+              tamanioTotal,
+              rutaDeArchivo,
+            };
+          }
+        }
+      }
+    } catch (error) {
+      console.error('Error al guardar el archivo:', error);
+      throw new ManejadorDeErrores(error.message, ManejadorDeErrores.obtenerNumeroDeLinea());
+    }
+    return informacionDelArchivo;
+  }
+
+  async cargarArchivo(Solicitud, Etiquetas) {
+    const Partes = Etiquetas.split('--');
+    Etiquetas = Partes.slice(0, -1).join("--");
+    let Resultado = undefined;
+    try {
+      Resultado = await this.obtenerDatosDelUsuario(Solicitud.headers.authorization);
+    } catch (error) {
+      console.error(error);
+    }
+    // Validación del token para el usuario y authorización
+    if (Resultado) {
+      const informacionDelArchivo = await this.almacenarArchivoEnDisco(Solicitud, Resultado['uid']);
+      const Respuesta = await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_Adjuntos` (`AdjuntosId`, `Identificador`, `Modulo`, `Seccion`, `Nombre`,\
+        `NombreOriginal`, `Ruta`, `Tipo`, `Tamanio`, `Etiqueta`, `LastUpdate`, `LastUser`)\
+        VALUES (NULL, ?, ?, 'No aplica', ?, ?, ?, ?, ?, ?, NOW(4), ?)"
+        , [Resultado['uid'], this.NombreCanonicoDelModulo, informacionDelArchivo.nombreDeArchivo, informacionDelArchivo.nombreDeArchivo
+          , informacionDelArchivo.rutaDeArchivo, informacionDelArchivo.tipoDeContenido, informacionDelArchivo.tamanioTotal
+          , Etiquetas, Resultado['uid']]);
+      informacionDelArchivo.insertId = Respuesta.insertId;
+      informacionDelArchivo.Etiquetas = Etiquetas;
+      await ejecutarConsulta("INSERT INTO `" + this.NombreDelRepositorioDeLaBaseDeDatos.slice(0, -3) + "`.`Archivos`\
+        VALUES (?, ?, ?, ?, ?, NOW(4), ?)"
+        , [Respuesta.insertId, Resultado.Identificador, informacionDelArchivo.rutaDeArchivo, informacionDelArchivo.nombreDeArchivo
+          , Etiquetas, Resultado.Identificador]);
+      return informacionDelArchivo;
+    }
+    return;
+  }
+
+  archivoCSVAJSON(rutaArchivo) {
+    const fs = require('fs');
+    const path = require('path');
+    return new Promise((resolve, reject) => {
+      fs.readFile(path.resolve(rutaArchivo), 'utf8', (err, data) => {
+        if (err) {
+          return reject(err);
+        }
+        try {
+          const lineas = data.trim().split('\n'); // Dividir en líneas
+          const encabezados = lineas[0].split(','); // Extraer encabezados de la primera línea
+          const resultados = lineas.slice(1).map((linea) => {
+            const valores = linea.split(','); // Dividir cada línea en valores
+            const objeto = {};
+            encabezados.forEach((encabezado, index) => {
+              objeto[encabezado.trim()] = valores[index]?.trim(); // Crear clave-valor
+            });
+            return objeto;
+          });
+          resolve(resultados);
+        } catch (error) {
+          reject(error);
+        }
+      });
+    });
+  }
+
+  jsonATabla(Datos) {
+    if (!Array.isArray(Datos) || Datos.length === 0) {
+      return 'El arreglo está vacío o no es válido.';
+    }
+    const columnas = Object.keys(Datos[0]);
+    const anchos = columnas.map(columna => {
+      return Math.max(
+        columna.length,
+        ...Datos.map(row => (row[columna] ? row[columna].toString().length : 0))
+      );
+    });
+    const formatearFila = (fila) => '| ' + fila.map((valor, index) => (valor || '').toString().padEnd(anchos[index])).join(' | ') + ' |';
+    const separador = '+-' + anchos.map(ancho => '-'.repeat(ancho)).join('-+-') + '-+';
+    const encabezado = formatearFila(columnas);
+    const filas = Datos.map(row => formatearFila(columnas.map(col => row[col] || '')));
+    return [separador, encabezado, separador, ...filas, separador].join('\n');
+  }
+
+  // async agregarCodigoQR(doc, url, opciones = {}) {
+  //   const { x = 0, y = 0, size = 100 } = opciones;
+
+
+
+  //   const urlQR = `https://qrcode.tec-it.com/API/QRCode?data=${encodeURIComponent(url)}&backcolor=%23ffffff&size=small&quietzone=1&errorcorrection=H`;
+  //   doc.image(urlQR, x, y, { width: size, height: size });
+  // }
+
+  agregarMarcaDeAgua(doc, texto = 'Borrador', opciones = {}) {
+    const {
+      color = '#CCCCCC',
+      opacity = 0.3,
+    } = opciones;
+
+    const { width, height } = doc.page; // Tamaño de la página
+
+    doc.save(); // Guardar el estado original de la página
+
+    // Calcular la posición y el ángulo de la marca de agua
+    doc
+      .font('Times-Roman', 220)
+      .fillColor(color)
+      .opacity(opacity)
+      .rotate(-55, { origin: [width / 2, height / 2] }) // Rotar el texto en diagonal
+      .text(
+        texto,
+        -width * 0.2, // Ajustar el desplazamiento horizontal
+        height * 0.4, // Ajustar el desplazamiento vertical
+        {
+          align: 'center',
+          valign: 'center',
+          width: width * 1.5, // Asegurar que el texto abarca toda la diagonal
+        }
+      );
+
+    doc.restore(); // Restaurar el estado original de la página
+  }
+
+  async generarObjetoInfoDeUnReportePDF() {
+
+    // Título:  UTN-1-1-2024
+    // Autor:  Apellido Apellido Nombre + cédula del funcionario
+    // Asunto: Boleta de Vacaciones
+    // Palabras Clave: Hash documento: asfsadffsdafsdfafggef4455
+
+    // Agregarle al doc un QR con el enlace a SIGU y códiigo de verificación
+
+    const UUID = await ejecutarConsulta("SELECT UUID() AS `Dato`");
+    const PalabrasClave = {
+      "Módulo": this.NombreCanonicoDelModulo,
+      "UUID": UUID[0]['Dato']
+    };
+    return {
+      Title: 'Nombre del reporte, como por ejemplo: Boleta de Vacaciones',
+      Author: 'Universidad Técnica Nacional',
+      Subject: 'Reporte PDF',
+      Keywords: JSON.stringify(PalabrasClave),
+      Creator: 'SIGU',
+      Producer: 'SIGU'
+    };
+  }
+
+  agregarTablaElegante(doc, datos, opciones = {}) {
+    const { x = 50, y = 50, columnWidth = 100, rowHeight = 20, headerHeight = 25, fontSize = 10 } = opciones;
+
+    // Configuración de fuentes
+    doc.fontSize(fontSize);
+
+    // Obtener las claves del primer objeto como encabezados
+    const encabezados = Object.keys(datos[0]);
+
+    // Dibujar los encabezados
+    encabezados.forEach((encabezado, i) => {
+      const posX = x + i * columnWidth;
+      doc
+        .rect(posX, y, columnWidth, headerHeight)
+        .fillAndStroke('#d3d3d3', '#000')
+        .fillColor('#000')
+        .text(encabezado, posX + 5, y + 5, { width: columnWidth - 10, align: 'left' });
+    });
+
+    // Dibujar las filas
+    datos.forEach((fila, filaIndex) => {
+      const filaY = y + headerHeight + filaIndex * rowHeight;
+      encabezados.forEach((columna, colIndex) => {
+        const posX = x + colIndex * columnWidth;
+        const texto = fila[columna] !== undefined ? fila[columna].toString() : '';
+        doc
+          .rect(posX, filaY, columnWidth, rowHeight)
+          .stroke()
+          .fillColor('#000')
+          .text(texto, posX + 5, filaY + 5, { width: columnWidth - 10, align: 'left' });
+      });
+    });
+
+    return doc;
+  }
+
+  async reportePDFDeEjemplo(Respuesta) {
+
+    Respuesta.setHeader('Content-Type', 'application/pdf');
+    Respuesta.setHeader('Content-Disposition', 'inline; filename="reporte.pdf"');
+    const PDFDocument = require('pdfkit');
+
+    const opciones = {
+      font: 'Courier',
+      size: 'LETTER',
+      info: await this.generarObjetoInfoDeUnReportePDF()
+    };
+    var doc = new PDFDocument(opciones);
+    doc.pipe(Respuesta);
+
+    this.agregarMarcaDeAgua(doc, 'Borrador', {
+      fontSize: 80,
+      opacity: 0.2,
+      color: '#FF0000',
+    });
+
+    doc.fontSize(25).text('Here is some vector graphics...', 100, 80);
+
+    doc.save()
+      .moveTo(100, 150)
+      .lineTo(100, 250)
+      .lineTo(200, 250)
+      .fill('#FF3300');
+
+    doc.circle(280, 200, 50).fill('#6600FF');
+
+    doc.scale(0.6)
+      .translate(470, 130)
+      .path('M 250,75 L 323,301 131,161 369,161 177,301 z')
+      .fill('red', 'even-odd')
+      .restore();
+
+    doc.text('And here is some wrapped text...', 100, 300)
+      .font('Times-Roman', 13)
+      .moveDown()
+      .text("lorem", {
+        width: 412,
+        align: 'justify',
+        indent: 30,
+        columns: 2,
+        height: 300,
+        ellipsis: true
+      });
+
+    // Datos de ejemplo
+    const datos = [
+      { Nombre: 'Juan', Edad: 28, Ciudad: 'San José', LugarDeTrabajo: 'UTN' },
+      { Nombre: 'Ana', Edad: 34 },
+      { Nombre: 'Luis', Edad: 25, Ciudad: 'Alajuela' },
+    ];
+    this.agregarTablaElegante(doc, datos, { x: 0, y: 400, columnWidth: 150, fontSize: 12 });
+    // await this.agregarCodigoQR(doc, 'https://www.utn.ac.cr', { x: doc.page.width - 150, y: doc.page.height - 150, size: 100 });
+    doc.end();
+  }
+
+  async verificarToken(Token) {
+    let Resultado = undefined;
+    try {
+      Resultado = await this.obtenerDatosDelUsuario(`Bearer ${Token}`);
+    } catch (error) {
+      console.error(error);
+    }
+    return Resultado;
+  }
+
+  async crearTareaProgramada(Tarea) {
+    const os = require('node:os');
+    return await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_ModulosTareasProgramadas` VALUES\
+      (?, ?, 'Ejecutada', NOW(4), ?) ON DUPLICATE KEY UPDATE `NombreDelEquipo` = ?"
+      , [this.NombreDelRepositorioDelBackend, Tarea.name, os.hostname(), os.hostname()]);
+  }
+
+  async pseudoEjecutarTareaProgramada(Tarea) {
+    const os = require('node:os');
+    const Resultado = await ejecutarConsultaSIGU("UPDATE `SIGU`.`SIGU_ModulosTareasProgramadas` SET `Estado` = 'Procesando'\
+      , `NombreDelEquipo` = ?, `FechaYHoraDeLaUltimaEjecucion` = NOW(4)\
+      WHERE `Repositorio` = ? AND `TareaProgramada` = ? AND `Estado` IN ('Ejecutada', 'Cancelada', 'Fallida')"
+      , [os.hostname(), this.NombreDelRepositorioDelBackend, Tarea]);
+    return Resultado['affectedRows'];
+  }
+
+  async finalizarTareaProgramada(Tarea) {
+    const os = require('node:os');
+    const Resultado = await ejecutarConsultaSIGU("UPDATE `SIGU`.`SIGU_ModulosTareasProgramadas` SET `Estado` = 'Ejecutada'\
+      , `NombreDelEquipo` = ?, `FechaYHoraDeLaUltimaEjecucion` = NOW(4)\
+      WHERE `Repositorio` = ? AND `TareaProgramada` = ? AND `Estado` IN ('Procesando')"
+      , [os.hostname(), this.NombreDelRepositorioDelBackend, Tarea]);
+    return Resultado['affectedRows'];
+  }
+
+  async ejecutarEnHoraEspecifica(hora, minuto, segundo, callback) {
+    while (true) {
+      try {
+        await this.crearTareaProgramada(callback);
+        break;
+      } catch (error) {
+        console.error('Error al ejecutar crearTareaProgramada:', error);
+        console.log('Reintentando en 5 segundos...');
+        await new Promise(resolve => setTimeout(resolve, 5000));
+      }
+    }
+
+    function programarEjecucion() {
+      const ahora = new Date();
+      const proximaEjecucion = new Date(ahora);
+      proximaEjecucion.setHours(hora, minuto, segundo, 0);
+      let tiempoEspera = proximaEjecucion - ahora;
+      if (tiempoEspera < 0) {
+        proximaEjecucion.setDate(proximaEjecucion.getDate() + 1);
+        tiempoEspera = proximaEjecucion - ahora;
+      }
+      console.log(`Se ha programado a '${callback.name}' para ejecución a las ${proximaEjecucion.toLocaleTimeString()}`);
+
+      setTimeout(() => {
+        callback();
+        programarEjecucion();
+      }, tiempoEspera);
+    }
+
+    programarEjecucion();
+  }
+
+  NombresParalocalhost() {
+    return ["localhost", "::", "127.0.0.1", "::1"];
+  }
+
+  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');
+    // index.rest
+    let ArchivoREST = process.cwd() + '/index.rest';
+    let contenido = fs.readFileSync(ArchivoREST, 'utf-8');
+    let contenidoActualizado = contenido.replace(ExpresionRegular, Token);
+    fs.writeFileSync(ArchivoREST, contenidoActualizado);
+    // Módulo.rest
+    ArchivoREST = process.cwd() + '/' + this.NombreCanonicoDelModulo + '.rest';
+    contenido = fs.readFileSync(ArchivoREST, 'utf-8');
+    contenidoActualizado = contenido.replace(ExpresionRegular, Token);
+    fs.writeFileSync(ArchivoREST, contenidoActualizado);
+    // datos-globales.service.ts
+    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;
+  }
+
+  async listarArchivos(Datos) {
+    const Partes = Datos.Etiquetas.split('--');
+    const Etiquetas = Partes.slice(0, -1).join("--");
+    const partes = Datos.Etiquetas.split('--');
+    const ultimaParte = partes[partes.length - 1].split('=')[1];
+    if (ultimaParte === 'Usuario') {
+      let Resultado = undefined;
+      try {
+        Resultado = await this.obtenerDatosDelUsuario(Datos.Token);
+        if (!Resultado) {
+          throw new ManejadorDeErrores(ManejadorDeErrores.mensajeDeErrorVerificacionDeToken(), ManejadorDeErrores.obtenerNumeroDeLinea());
+        }
+      } catch (error) {
+        console.log(error);
+        return;
+      }
+      return await ejecutarConsulta("SELECT `ArchivoId`, `Identificador`, `Ruta`, CONCAT(`Nombre`, ' (', DATE_FORMAT(`LastUpdate`, '%Y-%M-%d %H:%i'), ')') AS `Nombre`, `Etiquetas`\
+        FROM `" + this.NombreDelRepositorioDeLaBaseDeDatos.slice(0, -3) + "`.`Archivos`\
+        WHERE `Identificador` = ? AND `Etiquetas` = ?"
+        , [Resultado.Identificador, Etiquetas]);
+    }
+    if (ultimaParte === 'Servicio') {
+      return await ejecutarConsulta("SELECT `ArchivoId`, `Identificador`, `Ruta`, CONCAT(`Nombre`, ' (', DATE_FORMAT(`LastUpdate`, '%Y-%M-%d %H:%i'), ')') AS `Nombre`, `Etiquetas`\
+        FROM `" + this.NombreDelRepositorioDeLaBaseDeDatos.slice(0, -3) + "`.`Archivos`\
+        WHERE `Etiquetas` = ?"
+        , [Etiquetas]);
+    }
+    if (ultimaParte === 'Proceso') {
+      return await ejecutarConsulta("SELECT `ArchivoId`, `Identificador`, `Ruta`, CONCAT(`Nombre`, ' (', DATE_FORMAT(`LastUpdate`, '%Y-%M-%d %H:%i'), ')') AS `Nombre`, `Etiquetas`\
+        FROM `" + this.NombreDelRepositorioDeLaBaseDeDatos.slice(0, -3) + "`.`Archivos`\
+        WHERE `Etiquetas` = ?"
+        , [Etiquetas]);
+    }
+    if (typeof ultimaParte === "number") {
+      if (this.validarTokenV2(Datos.Token, ultimaParte)) {
+        return await ejecutarConsulta("SELECT `ArchivoId`, `Identificador`, `Ruta`, CONCAT(`Nombre`, ' (', DATE_FORMAT(`LastUpdate`, '%Y-%M-%d %H:%i'), ')') AS `Nombre`, `Etiquetas`\
+          FROM `" + this.NombreDelRepositorioDeLaBaseDeDatos.slice(0, -3) + "`.`Archivos`\
+          WHERE `Etiquetas` = ?"
+          , [Etiquetas]);
+      }
+    }
+  }
+
+  async listarArchivosExterno(Datos) {
+    const Partes = Datos.Etiquetas.split('--');
+    const Etiquetas = Partes.slice(0, -1).join("--");
+    const partes = Datos.Etiquetas.split('--');
+    const ultimaParte = partes[partes.length - 1].split('=')[1];
+    let Resultado = undefined;
+    try {
+      Resultado = await this.obtenerDatosDelUsuario(Datos.Token);
+      if (!Resultado) {
+        throw new ManejadorDeErrores(ManejadorDeErrores.mensajeDeErrorVerificacionDeToken(), ManejadorDeErrores.obtenerNumeroDeLinea());
+      }
+    } catch (error) {
+      console.log(error);
+      return;
+    }
+    return await ejecutarConsulta("SELECT `ArchivoId`, `Identificador`, `Ruta`, CONCAT(`Nombre`, ' (', DATE_FORMAT(`LastUpdate`, '%Y-%M-%d %H:%i'), ')') AS `Nombre`, `Etiquetas`\
+        FROM `" + this.NombreDelRepositorioDeLaBaseDeDatos.slice(0, -3) + "`.`Archivos`\
+        WHERE `Identificador` = ?"
+      , [Etiquetas]);
+  }
+
+  async borrarArchivo(Datos) {
+    let Resultado = undefined;
+    try {
+      Resultado = await this.obtenerDatosDelUsuario(Datos.Token);
+      if (!Resultado) {
+        throw new ManejadorDeErrores(ManejadorDeErrores.mensajeDeErrorVerificacionDeToken(), ManejadorDeErrores.obtenerNumeroDeLinea());
+      }
+    } catch (error) {
+      console.log(error);
+      return;
+    }
+    const fs = require('fs');
+    const Archivo = await ejecutarConsulta("SELECT `Ruta`\
+      FROM `" + this.NombreDelRepositorioDeLaBaseDeDatos.slice(0, -3) + "`.`Archivos`\
+      WHERE `Identificador` = ? AND `ArchivoId` = ?"
+      , [Resultado.Identificador, Datos.ArchivoId]);
+    fs.unlinkSync(Archivo[0]['Ruta']);
+    await ejecutarConsulta("DELETE FROM `" + this.NombreDelRepositorioDeLaBaseDeDatos.slice(0, -3) + "`.`Archivos`\
+      WHERE `Identificador` = ? AND `ArchivoId` = ?"
+      , [Resultado.Identificador, Datos.ArchivoId]);
+    await ejecutarConsultaSIGU("DELETE FROM `SIGU`.`SIGU_Adjuntos`\
+      WHERE `Identificador` = ? AND `AdjuntosId` = ?"
+      , [Resultado.Identificador, Datos.ArchivoId]);
+    return;
+  }
+
+  async descargarArchivo(Respuesta, Datos) {
+    let RutaDelArchivo = undefined;
+    const ArchivoId = Datos.ArchivoId.split('--')[0];
+    const partes = Datos.ArchivoId.split('--');
+    const ultimaParte = partes[partes.length - 1].split('=')[1];
+    if (ultimaParte === 'Usuario') {
+      let Resultado = undefined;
+      try {
+        Resultado = await this.obtenerDatosDelUsuario(Datos.Token);
+        if (!Resultado) {
+          throw new ManejadorDeErrores(ManejadorDeErrores.mensajeDeErrorVerificacionDeToken(), ManejadorDeErrores.obtenerNumeroDeLinea());
+        }
+      } catch (error) {
+        console.log(error);
+        return;
+      }
+      RutaDelArchivo = await ejecutarConsulta("SELECT `Ruta`\
+          FROM `" + this.NombreDelRepositorioDeLaBaseDeDatos.slice(0, -3) + "`.`Archivos`\
+          WHERE `Identificador` = ? AND `ArchivoId` = ?"
+        , [Resultado.Identificador, ArchivoId]);
+    }
+    if (ultimaParte === 'Servicio') {
+      RutaDelArchivo = await ejecutarConsulta("SELECT `Ruta`\
+          FROM `" + this.NombreDelRepositorioDeLaBaseDeDatos.slice(0, -3) + "`.`Archivos`\
+          WHERE `ArchivoId` = ?"
+        , [ArchivoId]);
+    }
+    if (ultimaParte === 'Proceso') {
+      RutaDelArchivo = await ejecutarConsulta("SELECT `Ruta`\
+          FROM `" + this.NombreDelRepositorioDeLaBaseDeDatos.slice(0, -3) + "`.`Archivos`\
+          WHERE `ArchivoId` = ?"
+        , [ArchivoId]);
+    }
+    if (typeof ultimaParte === "number") {
+      if (this.validarTokenV2(Datos.Token, ultimaParte)) {
+        RutaDelArchivo = await ejecutarConsulta("SELECT `Ruta`\
+          FROM `" + this.NombreDelRepositorioDeLaBaseDeDatos.slice(0, -3) + "`.`Archivos`\
+          WHERE `ArchivoId` = ?"
+          , [ArchivoId]);
+      }
+    }
+    Respuesta.download(RutaDelArchivo[0]['Ruta']);
+    return;
+  }
+
+  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
+    };
+    // if (this.NombresParalocalhost().includes(process.env.HOST) && (typeof process.env.DB_HOST_SIGU === "undefined")) {
+    //   try {
+    //     const fs = require('fs');
+    //     const Archivo;
+    //     const CWD = process.cwd();
+    //     let contenido;
+    //     let contenidoActualizado;
+    //     // contenedor-principal.component.html
+    //     process.chdir('..');
+    //     Archivo = process.cwd() + '/' + this.NombreDelRepositorioDelFrontend + '/src/app/Paginas/contenedor-principal/contenedor-principal.component.html';
+    //     contenido = fs.readFileSync(Archivo, 'utf-8');
+    //     contenidoActualizado = contenido.replace('DESCRIPCION_DEL_PROYECTO', this.DescripcionDelModulo);
+    //     fs.writeFileSync(Archivo, contenidoActualizado);
+    //     contenido = fs.readFileSync(Archivo, 'utf-8');
+    //     contenidoActualizado = contenido.replace('DETALLE_DEL_PROYECTO', this.DetalleDelModulo);
+    //     fs.writeFileSync(Archivo, contenidoActualizado);
+    //     process.chdir(CWD);
+
+    //     // contenedor-componentes.component.html
+    //     process.chdir('..');
+    //     Archivo = process.cwd() + '/' + this.NombreDelRepositorioDelFrontend + '/src/app/Paginas/Nucleo/contenedor-componentes/contenedor-componentes.component.html';
+    //     contenido = fs.readFileSync(Archivo, 'utf-8');
+    //     contenidoActualizado = contenido.replace('NOMBRE_DEL_PROYECTO', this.NombreDelModulo);
+    //     fs.writeFileSync(Archivo, contenidoActualizado);
+    //     contenido = fs.readFileSync(Archivo, 'utf-8');
+    //     contenidoActualizado = contenido.replace('MODULO', this.NombreCanonicoDelModulo);
+    //     fs.writeFileSync(Archivo, contenidoActualizado);
+    //     contenido = fs.readFileSync(Archivo, 'utf-8');
+    //     contenidoActualizado = contenido.replace('VERSION', '1.0.0');
+    //     fs.writeFileSync(Archivo, contenidoActualizado);
+    //     process.chdir(CWD);
+
+    //   } catch (error) {
+    //     console.warn("No fue posible actualizar el archivo contenedor-principal.component.html del front: ", error);
+    //   }
+    // }
+    // return;
+  }
+
+  async DatosPersonalesDeUnaPersona(Identificador) {
+    const Resultado = {};
+    const DatosDeLaPersona = await ejecutarConsultaSIGU("SELECT `Identificacion`, `Nombre`, `PrimerApellido`,\
+      `SegundoApellido`, (SELECT `CorreoElectronico` FROM `SIGU`.`SIGU_CorreosPersona` WHERE `Identificador` = ? AND `Principal` = TRUE) AS `CorreoElectronicoPrincipal`\
+        FROM `SIGU`.`SIGU_Personas` WHERE `Identificador` = ?", [Identificador, Identificador]);
+    Resultado.Identificador = Identificador;
+    Resultado.Identificacion = DatosDeLaPersona[0]['Identificacion'];
+    Resultado.Nombre = DatosDeLaPersona[0]['Nombre'];
+    Resultado.PrimerApellido = DatosDeLaPersona[0]['PrimerApellido'];
+    Resultado.SegundoApellido = DatosDeLaPersona[0]['SegundoApellido'];
+    Resultado.CorreoElectronicoPrincipal = DatosDeLaPersona[0]['CorreoElectronicoPrincipal'];
+    return Resultado;
+  }
+
+  async ejecucionDiferida(callback) {
+    const stackLines = new Error().stack.split('\n');
+    const lineaCaller = stackLines[2] ?? '';
+    const match = lineaCaller.match(/\((.+?):\d+:\d+\)/) ?? lineaCaller.match(/at (.+?):\d+:\d+/);
+    const archivo = match ? require('path').basename(match[1]) : null;
+
+    while (true) {
+      try {
+        this._archivoFuenteActual = archivo;
+        await callback();
+        break;
+      } catch (error) {
+        console.error(`Error en la función "${callback.name}": `, error.message);
+        console.log('Reintentando en 5 segundos...');
+        await new Promise(resolve => setTimeout(resolve, 5000));
+      }
+    }
+    this._archivoFuenteActual = null;
+  }
+
+  // async obtenerEnlaceDelModuloPadre() {
+  //   const Ruta = await ejecutarConsultaSIGU("SELECT CONCAT('modulos/', `MenuId`) AS `Ruta` FROM `SIGU`.`SIGU_Menu`\
+  //     WHERE `MenuId` = (SELECT `Padre` FROM `SIGU`.`SIGU_Menu` WHERE `Nombre` = ?)"
+  //     , [this.NombreCanonicoDelModulo]);
+  //   return await this.obtenerEnlaceDePortal() + "/" + Ruta[0]['Ruta'];
+  // }
+
+  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']);
+  }
+}
 
 module.exports = new Miscelaneo();