utn-cli 1.0.0

package/templates/backend/rutas/misc.js

@@ -0,0 +1,671 @@
+const express = require('express');
+const Router = express.Router();
+
+const Miscelaneo = require('./../servicios/Nucleo/Miscelaneas.js');
+const ManejadorDeErrores = require('../servicios/Nucleo/ManejadorDeErrores.js');
+
+Router.get('/DatosParaReporteCSV', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        respuesta.header('Content-Type', 'text/csv; charset=utf-8');
+        respuesta.attachment('Datos.csv');
+        return respuesta.send(encodeURI(await Miscelaneo.DatosParaReporteCSV()));
+      } catch (error) {
+        const MensajeDeError = 'No fue posible generar el reporte de los datos';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/DatosParaGraficoDeBarras', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await Miscelaneo.DatosParaGraficoDeBarras(), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible obtener los datos para el gráfico de barras';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/DatosParaGraficoDePie', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await Miscelaneo.DatosParaGraficoDePie(), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible obtener los datos para el gráfico de pie';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.post('/restablecimientoDeClave', async (solicitud, respuesta, next) => {
+  try {
+    return respuesta.json({ body: await Miscelaneo.restablecimientoDeClave(solicitud), error: undefined });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/obtenerEnlaceDePortal2', async (solicitud, respuesta, next) => {
+  try {
+    return respuesta.json({ body: await Miscelaneo.obtenerEnlaceDePortal(), error: undefined });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/validarTokenV2', async (solicitud, respuesta, next) => {
+  return respuesta.json({ body: await Miscelaneo.validarTokenV2(solicitud.headers.authorization), error: undefined });
+});
+
+Router.post('/Autenticar', async (solicitud, respuesta, next) => {
+  try {
+    return respuesta.json({ body: await Miscelaneo.Autenticar(solicitud), error: undefined });
+  } catch (error) {
+    next(error);
+  }
+  // const NombresParalocalhost = ['127.0.0.1', '::1', '::ffff:127.0.0.1'];
+  // if (NombresParalocalhost.includes(solicitud.ip)) {
+  //   try {
+  //     return respuesta.json(await Miscelaneo.configurarFrontend());
+  //   } catch (error) {
+  //     const MensajeDeError = 'No fue posible configurar el frontend';
+  //     console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+  //     return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+  //   }
+  // }
+  // return respuesta.status(500).json({ body: undefined, error: undefined });
+});
+
+Router.get('/ListadoDePaisesParaCrearCuenta', async (solicitud, respuesta, next) => {
+  try {
+    return respuesta.json({ body: await Miscelaneo.ListadoDePaisesParaCrearCuenta(), error: undefined });
+  } catch (error) {
+    next(error);
+  }
+  // const NombresParalocalhost = ['127.0.0.1', '::1', '::ffff:127.0.0.1'];
+  // if (NombresParalocalhost.includes(solicitud.ip)) {
+  //   try {
+  //     return respuesta.json(await Miscelaneo.configurarFrontend());
+  //   } catch (error) {
+  //     const MensajeDeError = 'No fue posible configurar el frontend';
+  //     console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+  //     return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+  //   }
+  // }
+  // return respuesta.status(500).json({ body: undefined, error: undefined });
+});
+
+Router.get('/configurarFrontend2', async (solicitud, respuesta, next) => {
+  try {
+    return respuesta.json({ body: await Miscelaneo.configurarFrontend(), error: undefined });
+  } catch (error) {
+    next(error);
+  }
+  // const NombresParalocalhost = ['127.0.0.1', '::1', '::ffff:127.0.0.1'];
+  // if (NombresParalocalhost.includes(solicitud.ip)) {
+  //   try {
+  //     return respuesta.json(await Miscelaneo.configurarFrontend());
+  //   } catch (error) {
+  //     const MensajeDeError = 'No fue posible configurar el frontend';
+  //     console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+  //     return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+  //   }
+  // }
+  // return respuesta.status(500).json({ body: undefined, error: undefined });
+});
+
+Router.get('/obtenerDetalleDelModulo', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await Miscelaneo.obtenerDetalleDelModulo(), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible obtener el detalle del módulo';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/obtenerDatosDelUsuario', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await Miscelaneo.obtenerDatosDelUsuario(solicitud.headers.authorization), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible obtener los datos del usuario';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/obtenerMensajesInstitucionales', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await Miscelaneo.obtenerMensajesInstitucionales(), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible obtener los mensajes institucionales';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/iniciarSesion', async (solicitud, respuesta, next) => {
+  return respuesta.json({ body: await Miscelaneo.iniciarSesion(), error: undefined });
+});
+
+Router.get('/obtenerModulos/:Padre/:ModulosFavoritos', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({
+          body: await Miscelaneo.obtenerModulos(solicitud.headers.authorization
+            , solicitud.params.Padre, solicitud.params.ModulosFavoritos), error: undefined
+        });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible obtener los módulos';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.post('/actualizarNotificacion', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await Miscelaneo.actualizarNotificacion(solicitud.headers.authorization, solicitud.body.FechaYHoraDeCreacion), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible actualizar la notificación';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/obtenerNotificaciones', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await Miscelaneo.obtenerNotificaciones(solicitud.headers.authorization), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible obtener las notificaciones';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.post('/reporteDeIncidencia/:Datos', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await Miscelaneo.reporteDeIncidencia(solicitud, solicitud.params.Datos), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible reportar la incidencia';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/cerrarSesion', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await Miscelaneo.cerrarSesion(solicitud.headers.authorization), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible obtener cerrar la sesión';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/obtenerEnlaceDePerfil', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await Miscelaneo.obtenerEnlaceDePerfil(), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible obtener la ruta de perfil';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/obtenerPersonasFuncionarias', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await Miscelaneo.obtenerPersonasFuncionarias(), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible obtener los datos de las personas estudiantes';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/obtenerEnlaceDePortal', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await Miscelaneo.obtenerEnlaceDePortal(), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible obtener la ruta de portal';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/obtenerEnlaceDelModuloPadre', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await Miscelaneo.obtenerEnlaceDelModuloPadre(), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible obtener la ruta del menú padre';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/configurarFrontend', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await Miscelaneo.configurarFrontend(), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible obtener la información para configurar el frontend';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+  // const NombresParalocalhost = ['127.0.0.1', '::1', '::ffff:127.0.0.1'];
+  // if (NombresParalocalhost.includes(solicitud.ip)) {
+  //   try {
+  //     return respuesta.json(await Miscelaneo.configurarFrontend());
+  //   } catch (error) {
+  //     const MensajeDeError = 'No fue posible configurar el frontend';
+  //     console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+  //     return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+  //   }
+  // }
+  // return respuesta.status(500).json({ body: undefined, error: undefined });
+});
+
+Router.get('/validarToken', async (solicitud, respuesta, next) => {
+  return respuesta.json({ body: await Miscelaneo.validarToken(solicitud.headers.authorization), error: undefined });
+});
+
+Router.get('/descargarArchivo/:ArchivoId', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        const Datos = { ArchivoId: solicitud.params.ArchivoId };
+        Datos.Token = solicitud.headers.authorization;
+        return Miscelaneo.descargarArchivo(respuesta, Datos);
+      } catch (error) {
+        const MensajeDeError = 'No fue posible descargar el archivo';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.delete('/borrarArchivo/:ArchivoId', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        const Datos = { ArchivoId: solicitud.params.ArchivoId };
+        Datos.Token = solicitud.headers.authorization;
+        return respuesta.json({ body: await Miscelaneo.borrarArchivo(Datos), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible borrar el archivo';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/listarArchivos/:Etiquetas', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        const Datos = { Etiquetas: solicitud.params.Etiquetas };
+        Datos.Token = solicitud.headers.authorization;
+        return respuesta.json({ body: await Miscelaneo.listarArchivos(Datos), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible obtener los arcvhivos';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.post('/cargarArchivo/:Etiquetas', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await Miscelaneo.cargarArchivo(solicitud, solicitud.params.Etiquetas), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible cargar el archivo';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/crearToken/:Identificador', async (solicitud, respuesta, next) => {
+  const NombresParalocalhost = ['127.0.0.1', '::1', '::ffff:127.0.0.1'];
+  if (NombresParalocalhost.includes(solicitud.ip)) {
+    try {
+      return respuesta.json(await Miscelaneo.crearToken(solicitud.params.Identificador));
+    } catch (error) {
+      const MensajeDeError = 'No fue posible generar el token';
+      console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+      return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+    }
+  }
+  return respuesta.status(500).json({ body: undefined, error: undefined });
+});
+
+Router.post('/verificarToken', async (solicitud, respuesta, next) => {
+  try {
+    return respuesta.json({ body: await Miscelaneo.verificarToken(solicitud.body.Token), error: undefined });
+  } catch (error) {
+    const MensajeDeError = 'No fue posible verificar el token';
+    console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+    return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+  }
+});
+
+Router.post('/almacenarCuentaIBAN', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        const Datos = solicitud.body;
+        Datos.LastUser = await Miscelaneo.generarLastUser(solicitud);
+        return respuesta.json({ body: await Miscelaneo.almacenarCuentaIBAN(Datos), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible almacenar la cuenta IBAN a la persona';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/reportePDFDeEjemplo/', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return Miscelaneo.reportePDFDeEjemplo(respuesta);
+      } catch (error) {
+        const MensajeDeError = 'No fue posible generar el reporte de ejemplo';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/versionDelNucleo', async (solicitud, respuesta, next) => {
+  return respuesta.json({ body: await Miscelaneo.versionDelNucleo(), error: undefined });
+});
+
+Router.get('/obtenerDatosDeLaPersonaPorIdentificacion/:Identificacion', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await Miscelaneo.obtenerDatosDeLaPersonaPorIdentificacion(solicitud.params.Identificacion), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible obtener los datos de la persona';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.post('/obtenerDatosDeLaPersona', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await Miscelaneo.obtenerDatosDeLaPersona(solicitud.headers.authorization), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible obtener los datos de la persona';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/obtenerEstudiantes', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await Miscelaneo.obtenerEstudiantes(), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible obtener los datos de los estudiantes';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/obtenerBeneficios', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await Miscelaneo.obtenerBeneficios(), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible obtener los datos de los beneficios';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/obtenerPeriodos', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await Miscelaneo.obtenerPeriodos(), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible obtener los datos de los periodos';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/obtenerAnios', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await Miscelaneo.obtenerAnios(), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible obtener los datos de los años';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/obtenerRecintos', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await Miscelaneo.obtenerRecintos(), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible obtener los datos de los recintos';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/obtenerSedes', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await Miscelaneo.obtenerSedes(), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible obtener los datos de las sedes';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+Router.get('/obtenerIdentificacion/:Identificador', async (solicitud, respuesta, next) => {
+  try {
+    if (await Miscelaneo.validarToken(solicitud.headers.authorization) && await Miscelaneo.validarAccesoDelOrigen(solicitud)) {
+      try {
+        return respuesta.json({ body: await Miscelaneo.obtenerIdentificacion(solicitud.params.Identificador), error: undefined });
+      } catch (error) {
+        const MensajeDeError = 'No fue posible obtener la identificación';
+        console.error(new ManejadorDeErrores(MensajeDeError, ManejadorDeErrores.obtenerNumeroDeLinea(), true, `Dirección IP: ${solicitud.ip}`));
+        return respuesta.status(500).json({ body: undefined, error: MensajeDeError });
+      }
+    }
+    return respuesta.status(401).json({ body: undefined, error: ManejadorDeErrores.mensajeDeError401() });
+  } catch (error) {
+    next(error);
+  }
+});
+
+module.exports = Router;

package/templates/backend/rutas/rutas.js

@@ -0,0 +1,11 @@
+const rutasMiscelaneas = require('./misc.js');
+const rutasDeAPI = require('./API.js');
+const rutasDelServicio1 = require('./Servicio1.js');
+
+function asignarRutasAExpress(app) {
+  app.use('/misc', rutasMiscelaneas);
+  app.use('/api', rutasDeAPI);
+  app.use('/Servicio1', rutasDelServicio1);
+}
+
+module.exports = asignarRutasAExpress;