utn-cli 1.0.0

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

@@ -0,0 +1,1901 @@
+const { ejecutarConsulta, ejecutarConsultaSIGU, ejecutarConsultaCumulo } = require('./db.js');
+const ManejadorDeErrores = require('./ManejadorDeErrores.js');
+const InformacionDelModulo = require('../InformacionDelModulo.js');
+const { envioDeCorreo } = require('./EnvioDeCorreos.js');
+
+class Miscelaneo {
+
+  constructor() {
+    this.NombreDelModulo = InformacionDelModulo.getNombreDelModulo();
+    this.DescripcionDelModulo = InformacionDelModulo.getDescripcionDelModulo();
+    this.DetalleDelModulo = InformacionDelModulo.getDetalleDelModulo();
+    this.NombreCanonicoDelModulo = InformacionDelModulo.getNombreCanonicoDelModulo();
+    this.TipoDeCard = InformacionDelModulo.getTipoDeCard();
+    this.NombreDelRol = this.NombreCanonicoDelModulo + ' - ' + InformacionDelModulo.getNombreDelRol();
+    this.NombreDelRepositorioDeLaBaseDeDatos = InformacionDelModulo.getNombreDelRepositorioDeLaBaseDeDatos();
+    this.NombreDelRepositorioDelBackend = InformacionDelModulo.getNombreDelRepositorioDelBackend();
+    this.NombreDelRepositorioDelFrontend = InformacionDelModulo.getNombreDelRepositorioDelFrontend();
+    this.Repositorios = this.NombreDelRepositorioDeLaBaseDeDatos + ',' + this.NombreDelRepositorioDelBackend
+      + ',' + this.NombreDelRepositorioDelFrontend;
+    this.NombreDelPermiso = this.NombreCanonicoDelModulo + ' - ' + InformacionDelModulo.getNombreDelPermiso();
+    this.NombreDelPermisoV2 = InformacionDelModulo.getNombreDelPermiso();
+    this.DescripcionDelPermiso = InformacionDelModulo.getDescripcionDelPermiso();
+    this.MenuPadre = InformacionDelModulo.getMenuPadre();
+    this.BackEndsQueConsumeEsteModulo = InformacionDelModulo.getBackEndsQueConsumeEsteModulo();
+    this.PerfilGeneral = InformacionDelModulo.getPerfilGeneral();
+    this.UsuariosConAccesoInicial = InformacionDelModulo.getUsuariosConAccesoInicial();
+    this.IconoDelModulo = this.NombreCanonicoDelModulo + '.svg';
+    this.ColorDelModulo = InformacionDelModulo.getColorDelModulo();
+    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;
+    this.PermisoId = 0;
+    this.EnlaceDePortal = undefined;
+    this.EnlaceDePerfil = undefined;
+    this.EnlaceDeAcceso = undefined;
+  };
+
+  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 = {
+      'Authorization': Token,
+      'Referrer': this.NombreDelRepositorioDelBackend,
+      'Origin': EnlaceDelBack
+    };
+    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) {
+    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);
+    }
+  }
+
+  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 */ }
+    }
+
+    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);
+    }
+
+    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) {
+    let Resultado = undefined;
+    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.uid;
+    }
+    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 + "&Clave=" + Clave + "'>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 Autenticar(Solicitud) {
+    const crypto = require('crypto');
+    const bcrypt = require('bcryptjs');
+    const jwt = require('jsonwebtoken');
+    const LastUser = await this.generarLastUser(Solicitud);
+    const resultados = await ejecutarConsultaSIGU("SELECT `Identificador`, `Clave` FROM `SIGU`.`SIGU_Personas` WHERE `Activo` = TRUE AND `Identificacion` = ?"
+      , [Solicitud.body.Identificacion]);
+    const Resultado = await bcrypt.compare(crypto.createHash('md5').update(Solicitud.body.Clave).digest("hex"), resultados[0]['Clave']);
+    if (Resultado) {
+      console.log("La clave brindada para el usuario", Solicitud.body.Identificacion, "conincide");
+      const Token = await jwt.sign({ Identificador: resultados[0]['Identificador'], uid: resultados[0]['Identificador'] }, await this.palabraSecretaParaTokens(), { expiresIn: '2h' });
+      await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_Sesiones` VALUES (?, ?, ?, NOW(4), ?) ON DUPLICATE KEY UPDATE `Token` = ?, `LastUser` = ?"
+        , [resultados[0]['Identificador'], Solicitud.headers.host.trim(), Token, LastUser, Token, LastUser]
+      );
+      await ejecutarConsultaSIGU("DELETE FROM `SIGU`.`SIGU_SesionesFallidas` WHERE `Identificador` = ?"
+        , [resultados[0]['Identificador']]);
+      await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_PermisosPersonasV2`\
+        SELECT `PermisoId`, ?, NOW(4), USER() FROM `SIGU`.`SIGU_PermisosV2` WHERE `Nombre` LIKE '%Público%'\
+        ON DUPLICATE KEY UPDATE `LastUser` = USER()", [resultados[0]['Identificador']]);
+      return { Token, Dominio: ((process.env.ENV || 'local') === 'production' ? '.sigu.utn.ac.cr' : '.181.193.85.44.nip.io') };
+    } else {
+      console.log("La clave brindada para el usuario", Solicitud.body.Identificacion, "no conincide");
+      const Resultados2 = await ejecutarConsultaSIGU("SELECT COUNT(*) AS `Total` FROM `SIGU`.`SIGU_ClavesTemporalesDeLasPersonas`\
+        WHERE `Identificador` = ? AND `Clave` = ?"
+        , [resultados[0]['Identificador'], Solicitud.body.Clave]);
+      if (Resultados2[0]['Total'] > 0) {
+        console.log("La clave brindada para el usuario", Solicitud.body.Identificacion, "no conincide, pero coincide la clave temporal");
+        const bcrypt = require('bcryptjs');
+        await ejecutarConsultaSIGU("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 ejecutarConsultaSIGU("DELETE FROM `SIGU`.`SIGU_ClavesTemporalesDeLasPersonas`\
+        WHERE `Identificador` = ?", [resultados[0]['Identificador']]);
+        await this.Autenticar(Solicitud);
+      } else {
+        await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_SesionesFallidas` VALUES (?, ?, NOW(4))"
+          , [resultados[0]['Identificador'], Solicitud.headers.host.trim()]);
+      }
+    }
+    return;
+  }
+
+  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();
+  }
+
+  async obtenerDetalleDelModulo() {
+    const Modulos = await ejecutarConsultaSIGU("SELECT `a`.`Nombre`, `a`.`Padre`, `a`.`Descripcion`, `a`.`Detalle`,\
+        `a`.`Tipo`, 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(`a`.`Repositorios`, '[^,]*front[^,]*') AS `Frontend`\
+      FROM `SIGU`.`SIGU_ModulosV2` `a`\
+      WHERE `a`.`Nombre` = ?", [this.NombreCanonicoDelModulo]);
+    return Modulos.map((linea) => {
+      linea.Enlace = this.generarEnlace(linea.Frontend);
+      return linea;
+    });
+  }
+
+  async 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` = ?", [Modulo]);
+    if (Datos.length === 0) {
+      Datos = await ejecutarConsultaSIGU("SELECT `ConsentimientoInformadoId`, `Titulo`, `Texto`, `TextoDeAceptacion` FROM `SIGU`.`SIGU_ConsentimientosInformadosV2`\
+      WHERE `Estado` = 'Activo' AND `Modulo` = ?", [this.NombreCanonicoDelModulo]);
+    }
+    return Datos[0];
+  }
+
+  async creacionDeConsetimientoInformado(Titulo, Texto, TextoDeAceptacion) {
+    return await ejecutarConsultaSIGU("UPDATE `SIGU`.`SIGU_ConsentimientosInformadosV2` SET `Estado` = 'Inactivo' WHERE\
+      `Modulo` = ?; INSERT INTO `SIGU`.`SIGU_ConsentimientosInformadosV2` VALUES\
+      (NULL, ?, ?, ?, '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.uid]);
+    const Modulos = await ejecutarConsultaSIGU("SELECT `a`.`Nombre`, `a`.`Padre`, `a`.`Descripcion`, `a`.`Detalle`,\
+        `a`.`Tipo`, 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(`a`.`Repositorios`, '[^,]*front[^,]*') AS `Frontend`\
+      FROM `SIGU`.`SIGU_ModulosV2` `a`\
+        JOIN `SIGU`.`SIGU_PermisosV2` `b` ON (`a`.`Nombre` = `b`.`Modulo`)\
+      WHERE `a`.`Estado` = 'Activo' AND `a`.`Padre` = ? AND `b`.`PermisoId` IN (?)\
+      ORDER BY FIELD(a.Nombre, " + ModulosFavoritos + ") DESC, a.Nombre", [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.uid, 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.uid]);
+  }
+
+  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.obtenerDatosDeLaPersona(Solicitud.headers.authorization) + "</p><br />"
+      , [DatosDelArchivo.rutaDeArchivo]);
+    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() {
+    await ejecutarConsultaSIGU("INSERT INTO `SIGU`.`SIGU_ModulosV2` VALUES\
+      (?, ?, ?, ?, ?, ?, ?, ?, ?, NOW(4), ?, 'DiccionarioDeDatos'\
+      , ?, '-', '-', 'Activo', NOW(4), USER()) ON DUPLICATE KEY UPDATE `Padre` = ?, `Descripcion` = ?, `Detalle` = ?\
+      , `Color` = ?, `Correo` = ?, `Version` = ?, `Repositorios` = ?, `AcuerdoDeNivelDeServicio` = ?"
+      , [this.NombreCanonicoDelModulo, this.MenuPadre, this.DescripcionDelModulo, this.DetalleDelModulo
+        , this.TipoDeCard, this.IconoDelModulo, this.ColorDelModulo, this.CorreoParaReportes, this.Version, this.versionDelNucleo().split(' ')[0], this.Repositorios
+        , this.MenuPadre, this.DescripcionDelModulo, this.DetalleDelModulo, this.ColorDelModulo, this.CorreoParaReportes
+        , this.Version, this.Repositorios, this.versionDelNucleo().split(' ')[0]]);
+    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`.`SIGU_RolesPersonas` WHERE `PerfilGeneralId` = ?) ORDER BY `Nombre`, `PrimerApellido`,\
+      `SegundoApellido`", [await this.perfilGeneralId()]);
+  }
+
+  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'];
+  }
+
+  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' : '.181.193.85.44.nip.io');
+  }
+
+  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 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.uid]);
+  }
+
+  obtenerDatosDeLaPersonaPorIdentificacion(Identificacion) {
+    return 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]);
+  }
+
+  obtenerEstudiantes() {
+    return 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*/)");
+  }
+
+  obtenerBeneficios() {
+    return ejecutarConsultaSIGU("SELECT `BeneficioId`, `Beneficio`, `Estado` FROM `SIGU`.`SIGU_Beneficios`");
+  }
+
+  obtenerIdentificacion(Identificador) {
+    return ejecutarConsultaSIGU("SELECT `Identificacion` FROM `SIGU`.`SIGU_Personas` WHERE `Identificador` = ?", [Identificador]);
+  }
+
+  obtenerPeriodos() {
+    return ejecutarConsultaSIGU("SELECT `PeriodoId`, `CodigoPeriodo`, `Anio`, `Periodo`, `FechaInicio`, `FechaFinal`, `Tipo`, `Estado` FROM `SIGU`.`SIGU_Periodos` ORDER BY `Anio` DESC, `CodigoPeriodo` DESC");
+  }
+
+  obtenerAnios() {
+    return ejecutarConsultaSIGU("SELECT DISTINCT `Anio` FROM `SIGU`.`SIGU_Periodos`");
+  }
+
+  obtenerSedes() {
+    return ejecutarConsultaSIGU("SELECT `SedesId`, `CodigoAvatar`, `Descripcion`, `Siglas` FROM `SIGU`.`SIGU_Sedes` ORDER BY `Descripcion`");
+  }
+
+  obtenerRecintos() {
+    return 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 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.uid]);
+      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.uid, Resultado.token]);
+        if (tokenAlmacenado[0]['Total'] >= 1) { // Se compara con >= para preveer multisesiones
+          // 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.uid]);
+          if (permisos[0]['Total'] === 1) {
+            if (permisoExtraId) {
+              const ValidacionPermisoExtra = await ejecutarConsultaSIGU("SELECT COUNT(*) AS `Total` FROM `SIGU`.`SIGU_PermisosPersonasV2`\
+                WHERE `PermisoId` = ? AND `Identificador` = ?", [permisoExtraId, Resultado.uid]);
+              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.uid, 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.uid, 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) {
+    const Encabezados = Object.keys(ArregloDeJSON[0]);
+    const Filas = ArregloDeJSON.map(Fila => {
+      return Encabezados.map(Encabezado => {
+        let valor = Fila[Encabezado];
+        if (valor === null || valor === 'null') {
+          valor = '';
+        }
+        return JSON.stringify(String(valor)).replace(/,/g, ' ');
+      }).join(',');
+    });
+    return [Encabezados.join(','), ...Filas].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 = [
+      "181.193.85.44.nip.io",
+      "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', ?, ?, ?, ?, ?, 'No aplica', NOW(4), ?)"
+        , [Resultado['uid'], this.NombreCanonicoDelModulo, informacionDelArchivo.nombreDeArchivo, informacionDelArchivo.nombreDeArchivo
+          , informacionDelArchivo.rutaDeArchivo, informacionDelArchivo.tipoDeContenido, informacionDelArchivo.tamanioTotal
+          , 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.uid, informacionDelArchivo.rutaDeArchivo, informacionDelArchivo.nombreDeArchivo
+          , Etiquetas, Resultado.uid]);
+      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 }, 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.uid, 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 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.uid, Datos.ArchivoId]);
+    fs.unlinkSync(Archivo[0]['Ruta']);
+    await ejecutarConsulta("DELETE FROM `" + this.NombreDelRepositorioDeLaBaseDeDatos.slice(0, -3) + "`.`Archivos`\
+      WHERE `Identificador` = ? AND `ArchivoId` = ?"
+      , [Resultado.uid, Datos.ArchivoId]);
+    await ejecutarConsultaSIGU("DELETE FROM `SIGU`.`SIGU_Adjuntos`\
+      WHERE `Identificador` = ? AND `AdjuntosId` = ?"
+      , [Resultado.uid, 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.uid, 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() {
+    return {
+      "Modulo": this.NombreCanonicoDelModulo,
+      "Titulo": this.NombreDelModulo,
+      "Version": this.Version,
+      "Descripcion": this.DescripcionDelModulo,
+      "Detalle": this.DetalleDelModulo
+    };
+    // 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) {
+    while (true) {
+      try {
+        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));
+      }
+    }
+  }
+
+  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;
+  }
+}
+
+module.exports = new Miscelaneo();