“Año de la recuperación y consolidación de la economía peruana”

UNIVERSIDAD NACIONAL DE PIURA

FACULTAD DE INGENIERÍA INDUSTRIAL

ESCUELA PROFESIONAL DE INGENIERÍA INFORMÁTICA

DOCENTE

Dr. Reucher Correa Morocho

ASIGNATURA

Procesos De Desarrollo De Software

TEMA

Desarrollo e implementación de una plataforma web educativa orientada a la gestión de

cursos

INTEGRANTES

Correa Juarez Krystopher GianPablo

La Torre Benza, Karen María Sadith

More Ypanaque Lady Yomara

Neyra Timana Stany Lewis

Periche Chapilliquen Rodrigo

Varona Ojeda Marco Rodrigo

 ÍNDICE

PARTE I: DEFINICIÓN Y PLANIFICACIÓN DEL PROYECTO.............................................. 5

1. Visión General del Proyecto...........................................................................................5
1.1 Introducción y Propósito.........................................................................................5
1.2 Alcance del Sistema............................................................................................... 5
Alumnos:...................................................................................................................... 6
Administrador:.............................................................................................................. 6
1.3 Objetivos del Negocio y del Proyecto.....................................................................6
1.4 Involucrados(Stakeholders)....................................................................................6
1.5 Glosario de Términos............................................................................................. 7
2. Plan de Gestión de Proyectos........................................................................................7
2.1 Metodología de Desarrollo..................................................................................... 7
2.2 Plan de Fases e Hitos (o Sprints/Iteraciones)........................................................ 8
2.3 Estimación de Esfuerzos, Costos y Recursos........................................................9
2.4 Plan de Gestión de Riesgos...................................................................................9
2.5 Plan de Comunicación........................................................................................... 9
PARTE II: INGENIERÍA DE REQUISITOS............................................................................ 10
3. ESPECIFICACIÓN DE REQUISITOS DE SOFTWARE...............................................10
3.1. REQUISITOS FUNCIONALES............................................................................10
RF-01: Autenticación y Autorización.................................................................... 10
RF-02: Gestión de Profesores (Administración de cuentas)................................ 10
RF-03: Gestión de Cursos (Profesores)............................................................... 11
RF-04: Solicitudes de Inscripción a Cursos(Alumno)........................................... 11
RF-05: Gestión de Materiales del Curso.............................................................. 12
RF-06: Exploración de Cursos (Alumnos)............................................................ 12
RF-07: Gestión de Usuarios (Administrador)....................................................... 12
3.2. REQUISITOS NO FUNCIONALES..................................................................... 13
RNF-01: Rendimiento...........................................................................................13
RNF-02: Usabilidad y UX..................................................................................... 13
RNF-03: Fiabilidad................................................................................................13
RNF-04: Seguridad...............................................................................................13
RNF-05: Compatibilidad....................................................................................... 13
3.3. PROTOTIPOS DE UI (DESCRIPCIÓN).............................................................. 13
PARTE III: DISEÑO DEL SISTEMA...................................................................................... 14
4. DOCUMENTO DE DISEÑO DE ARQUITECTURA......................................................14
4.1. Vista Arquitectónica.............................................................................................14
Descripción de la Arquitectura..............................................................................14
4.2. Patrones de Diseño Arquitectónico..................................................................... 15
4.3. Tecnologías, Frameworks y Librerías..................................................................15
5. Documento de Diseño Detallado..................................................................................15
5.1. Diseño de la Base de Datos................................................................................16
Modelo Entidad-Relación..................................................................................... 16
Esquema de la Base de Datos............................................................................. 17
 5.2. Diseño de Componentes/Módulos...................................................................... 18
5.2.1. Visión General............................................................................................ 18
5.2.2. Componentes Principales...........................................................................19
5.2.3. Diagrama de Clases......................................................................................... 20
5.2.4. Diagramas de Secuencia................................................................................. 20
● Alumno ▸ Acceso al curso (tras aceptación)........................................................... 23
5.3. Diseño de la Interfaz de Programación de Aplicaciones (API)............................25
5.3.1. Especificación General...............................................................................25
5.3.2. Endpoints Clave......................................................................................... 25
PARTE IV: CONSTRUCCIÓN Y PRUEBAS..........................................................................27
6. DOCUMENTACIÓN DEL CÓDIGO FUENTE.............................................................. 27
6.1. Estándares de Codificación.................................................................................27
Frontend ([Link])...............................................................................................27
Backend ([Link] / Express)................................................................................ 29
6.2. Comentarios en el Código...................................................................................29
7. PLAN Y CASOS DE PRUEBA..................................................................................... 31
7.1. Estrategia de Pruebas.........................................................................................31
7.2. Casos de Prueba.................................................................................................32
7.3. Informe de Resultados de Pruebas.....................................................................33
PARTE V: DESPLIEGUE Y MANTENIMIENTO.................................................................... 34
8. MANUAL DE DESPLIEGUE E INSTALACIÓN............................................................ 34
8.1. Prerrequisitos de Hardware y Software...............................................................34
8.1.1. Hardware.................................................................................................... 34
8.1.2. Software y Cuentas.................................................................................... 35
8.1.3. Dependencias del Proyecto........................................................................35
8.1.4. Configuración de Base de Datos................................................................36
8.2. Guía de Instalación y Configuración................................................................... 36
ETAPA 1: Preparación del Entorno Local............................................................. 36
ETAPA 2: Configuración de la Base de Datos en [Link].................... 37
ETAPA 3: Despliegue en Vercel........................................................................... 38
ETAPA 4: Migración del Backend a Serverless.................................................... 39
ETAPA 5: Configuración del Frontend en Producción.......................................... 39
ETAPA 6: Despliegue Final...................................................................................39
9. Manual de Usuario y Administración............................................................................40
9.1. Guía de Usuario Final......................................................................................... 40
9.1.1. Acceso y Autenticación.............................................................................. 40
9.1.2. Panel de Alumno........................................................................................ 41
9.1.3. Panel de Profesor.......................................................................................41
9.1.4. Mensajes y Feedback.................................................................................42
9.2. Guía de Administración....................................................................................... 42
9.2.1. Acceso de Administrador............................................................................42
9.2.2. Gestión de Profesores................................................................................42
9.2.3. Gestión General de Usuarios..................................................................... 43
9.2.4. Copias de Seguridad.................................................................................. 43
 9.2.5. Monitorización y Métricas........................................................................... 44
9.2.6. Notificaciones y Alertas.............................................................................. 44
9.2.7. Seguridad y Mantenimiento........................................................................44
9.2.8. Procedimientos de Emergencia..................................................................44
10. Documentación de Mantenimiento.............................................................................45
10.1. Notas de la Versión........................................................................................... 45
10.2. Registro de Cambios......................................................................................... 47
ANEXOS.......................................................................................................................... 49
PARTE I: DEFINICIÓN Y PLANIFICACIÓN DEL PROYECTO

1. Visión General del Proyecto

El presente proyecto consiste en el desarrollo e implementación de una plataforma web

educativa orientada a la gestión de cursos, con funcionalidades específicas para tres tipos
de usuarios: profesores, alumnos y administradores.

1.1 Introducción y Propósito

En la actualidad, la tecnología desempeña un papel fundamental en los procesos de

enseñanza y aprendizaje. Las plataformas educativas virtuales se han convertido en
herramientas clave para facilitar la interacción entre docentes y estudiantes, optimizar la
gestión de cursos y ampliar el acceso a la educación. En este contexto, se plantea el
desarrollo de un sistema web que permita a profesores ofrecer cursos en línea, gestionar
materiales y controlar el acceso de alumnos, mientras que los estudiantes podrán explorar
opciones formativas y participar activamente en ellas. Todo ello bajo la supervisión de un
administrador encargado de validar y monitorear las actividades dentro del sistema.

Esta solución digital busca simplificar los procesos administrativos y académicos mediante
una interfaz intuitiva, adaptable y segura, contribuyendo así a la mejora continua de la
calidad educativa en entornos virtuales.

Propósito
El propósito del proyecto es desarrollar una plataforma web educativa integral que facilite la
creación, gestión y participación en cursos virtuales, permitiendo a los profesores
administrar sus clases de manera eficiente, a los alumnos acceder a contenidos formativos
pertinentes, y al administrador controlar el registro y funcionamiento general del sistema.
Esta herramienta tiene como finalidad fortalecer la educación en línea, fomentando una
comunicación directa y organizada entre todos los actores involucrados.

1.2 Alcance del Sistema

El presente sistema web está diseñado para cubrir las necesidades básicas de gestión
educativa en un entorno virtual, permitiendo la interacción entre tres tipos de usuarios:
profesores, alumnos y administrador. El sistema abarca las siguientes funcionalidades:

Profesores:

●​ Acceso al sistema tras la aprobación del administrador.

●​ Creación, edición y eliminación de cursos, incluyendo información detallada como
nombre, descripción, horario, fecha de inicio y fin.
●​ Visualización de solicitudes de inscripción por parte de alumnos, con opción de
aceptación o rechazo individual.
●​ Subida y gestión de materiales educativos (enlaces), accesibles solo para los
alumnos aceptados.

Alumnos:
 ●​ Visualización de cursos disponibles dictados por profesores aprobados y con fechas
vigentes.
●​ Envío de solicitud de inscripción, previa aceptación de los términos y condiciones.
●​ Acceso al contenido del curso (enlaces).

Administrador:

●​ Visualización de una tabla con los profesores en estado “pendiente”.

●​ Aprobación o rechazo de cuentas docentes (cambio de estado a “activo” o
“denegado”).
●​ Posibilidad de suspender o reactivar usuarios, según sea necesario.

1.3 Objetivos del Negocio y del Proyecto

Objetivos del Negocio

●​ Optimizar los procesos de gestión educativa, permitiendo a los docentes administrar

sus cursos y materiales de manera eficiente.
●​ Fomentar la transparencia y el control institucional, mediante un rol administrativo
que supervise los registros y el uso del sistema.
●​ Mejorar la experiencia educativa digital, integrando herramientas básicas que
favorezcan la comunicación, el seguimiento de estudiantes y la organización de
contenidos

Objetivos del Proyecto

●​ Desarrollar una plataforma web funcional y segura que permita el registro y gestión
de usuarios según su rol (profesor, alumno o administrador).
●​ Implementar módulos de gestión de cursos para que los docentes puedan crear,
modificar y eliminar cursos, así como gestionar las solicitudes de inscripción de los
alumnos.
●​ Garantizar una navegación intuitiva y eficiente, enfocada en la facilidad de uso y el
cumplimiento de las funciones principales del sistema.

1.4 Involucrados(Stakeholders)
Los siguientes actores participan directa en el desarrollo, uso y supervisión del sistema:

Stakeholder Descripción

Administrador Usuario encargado de gestionar el sistema, validar registros

de profesores y supervisar el estado de las cuentas.

Profesor Usuario que se registra en el sistema para ofrecer cursos,

gestionar inscripciones y compartir materiales con sus
alumnos.
 Alumno Usuario que accede al sistema para explorar cursos, enviar
solicitudes y participar en actividades formativas.

1.5 Glosario de Términos

Término Definición

Dashboard Panel de control personalizado desde el cual el usuario puede

gestionar sus acciones dentro del sistema.

Solicitud de Petición enviada por el alumno al profesor para acceder a un curso

inscripción específico.

Estado de cuenta Condición actual de la cuenta de un usuario (pendiente, activo,

denegado, suspendido).

Materiales Recursos educativos compartidos por los profesores, en forma de

enlaces o archivos, visibles solo para alumnos aceptados.

Curso Unidad educativa ofrecida por un profesor dentro de la plataforma,

con nombre y duración definidos.

Administrador Usuario con privilegios especiales para supervisar, aprobar

registros y gestionar usuarios.

2. Plan de Gestión de Proyectos

2.1 Metodología de Desarrollo

Se optará por la metodología ágil Scrum, la cual se ajusta perfectamente a proyectos de
desarrollo web donde se requiere flexibilidad, entregas incrementales y retroalimentación
constante por parte de los usuarios. Dado que esta plataforma educativa puede requerir
ajustes funcionales a lo largo de su implementación, Scrum permite responder de forma
rápida a los cambios sin comprometer la calidad del producto.

Ventajas específicas para este proyecto:

★​ Permite mostrar avances funcionales tras cada Sprint.

★​ Involucra a los stakeholders (especialmente al administrador institucional) en cada

iteración.

★​ Favorece una comunicación constante y fluida entre desarrolladores, diseñadores y

responsables académicos.

2.2 Plan de Fases e Hitos (o Sprints/Iteraciones)

El proyecto se dividirá en 5 Sprints de 2 semanas cada uno, con entregas funcionales al
término de cada iteración. Cada Sprint incluirá reuniones de planificación, revisión y
retrospectiva.

Fase / Sprint Objetivo principal Duración Entregables

Sprint 0 Diseño de la Semana 1 - Documentación

arquitectura, semana 2 técnica inicial,
análisis de entorno de
requisitos y desarrollo listo
configuración del
entorno

Sprint 1 Registro de Semana 3 - Registro y login

usuarios, login y semana 4 funcional por rol,
dashboard según interfaz básica por
perfil rol

Sprint 2 Módulo de gestión Semana 5 - Crear, editar y

de cursos semana 6 eliminar cursos,
(profesores) listado de cursos

Sprint 3 Inscripción de Semana 7 - Flujo de

alumnos y semana 8 inscripción,
aprobación por aceptación/rechaz
profesores o, gestión de
solicitudes

Sprint 4 Módulo de Semana 9 - Subida de

materiales, semana 10 enlaces, gestión
supervisión del de usuarios por
administrador y administrador
despliegue final

Hitos clave del proyecto:

●​ H1: Entorno y estructura base lista (fin de Sprint 0).

●​ H2: Funcionalidad de registro y acceso por roles (fin de Sprint 1).

●​ H3: Flujo completo de curso-inscripción-material (fin de Sprint 3).

●​ H4: Plataforma lista para pruebas finales y puesta en producción (fin de Sprint 4).

2.3 Estimación de Esfuerzos, Costos y Recursos

➢​ 1 Scrum Master

➢​ 1 Product Owner

➢​ 3 Desarrolladores
 ➢​ 1 Diseñador UX/UI

2.4 Plan de Gestión de Riesgos

Se identificaron los siguientes riesgos potenciales junto con estrategias de mitigación:

Riesgo Prob Impacto Mitigación

Cambios Alta Alta Priorizar historias de

frecuentes usuario, validación
en los continua con el
requisitos Product Owner

Falta de Media Alta Pruebas tempranas,

disponibilid planificación
ad del PO iterativa, revisión de
dependencias

Retrasos Media Alta Agendar reuniones

en fijas, definir
entregas responsabilidades
de terceros claras.

Problemas Media Media Pruebas cruzadas

técnicos en distintos
no navegadores y
previstos dispositivos, diseño
responsivo.

2.5 Plan de Comunicación

Para asegurar una coordinación eficiente, se establecerá un sistema de
comunicación regular y estructurado:

Herramientas utilizadas:
●​ Gestión de tareas: Trello / Jira

●​ Documentación: Google Drive / Confluence

●​ Mensajería y alertas: Slack / Microsoft Teams

●​ Reuniones virtuales: Zoom / Google Meet

●​

PARTE II: INGENIERÍA DE REQUISITOS

3. ESPECIFICACIÓN DE REQUISITOS DE SOFTWARE

3.1. REQUISITOS FUNCIONALES

RF-01: Autenticación y Autorización

Historia de usuario:​
Como usuario del sistema (administrador, profesor o alumno), necesito autenticarse y
acceder solo a las funciones permitidas por mi rol.

Especificaciones:

1.​ Inicio de sesión:​

○​ Validación de email y contraseña.​

○​ Generación de token JWT para sesión segura.​

○​ Redirección al dashboard según el rol.​

2.​ Registro:​

○​ Profesores: Registro con estado inicial “pendiente” a la espera de

aprobación.​

○​ Alumnos: Registro con activación automática.​

○​ Validación de email único y almacenamiento seguro de contraseña.​

3.​ Gestión de Roles:​

○​ Roles definidos: Administrador, Profesor, Alumno.​

○​ Permisos basados en el rol.​

RF-02: Gestión de Profesores (Administración de cuentas)

Historia de usuario:​
Como administrador, necesito poder aprobar o rechazar las solicitudes de registro de
profesores y poder suspender a un usuario si es necesario.

Especificaciones:

Gestión de Solicitudes

●​ Listado de profesores con estado pendiente.​

 ●​ Botones para Aceptar (estado: activo) o Rechazar (estado: denegado).​

●​ Cambios de estado deben notificarse por correo electrónico.

Gestión de Usuarios

●​ Listado de Todos los usuarios(Profesores y Alumnos)​

RF-03: Gestión de Cursos (Profesores)

Historia de usuario:​
Como profesor, necesito crear, modificar o eliminar cursos para mis alumnos.

Especificaciones:

1.​ Creación de cursos:​

○​ Campos: nombre, descripción, fechas de inicio y fin, horario.​

○​ Validación de fechas coherentes.​

2.​ Edición de cursos:​

○​ Modificación de todos los campos.​

○​ Validación de conflictos de horarios.​

3.​ Eliminación de cursos:​

○​ Solicitud de confirmación.​

○​ Eliminación de materiales y notificación a los alumnos inscritos.​

4.​ Visualización:​

○​ Tabla en el dashboard del profesor con todos sus cursos.​

RF-04: Solicitudes de Inscripción a Cursos(Alumno)

Historia de usuario:​
Como alumno, quiero poder solicitar unirme a cursos y que el profesor pueda aceptar o
rechazar mi solicitud.

Especificaciones:
 1.​ Alumnos:​

○​ Enviar solicitudes después de leer y aceptar términos y condiciones.​

○​ Verificar si he sido aceptado mediante un correo que me llegue​

.​

2.​ Profesores:​

○​ Ver listado de solicitudes por curso.​

○​ Aprobar o rechazar solicitudes.​

○​ Notificación automática al alumno sobre la decisión vía email.​

RF-05: Gestión de Materiales del Curso

Historia de usuario:​
Como profesor, quiero subir materiales para mis cursos, accesibles solo a los alumnos
aceptados.

Especificaciones:

●​ Agregar materiales por curso (enlaces).​

●​ Editar y eliminar materiales.​

●​ Los materiales solo son visibles para alumnos con estado “aceptado” en el curso.​

RF-06: Exploración de Cursos (Alumnos)

Historia de usuario:​
Como alumno, quiero ver cursos disponibles.

Especificaciones:

●​ Listado de cursos activos cuyos profesores estén aprobados.​

​

RF-07: Gestión de Usuarios (Administrador)

Historia de usuario:​
Como administrador, necesito ver todos los usuarios y poder suspenderlos o reactivarlos.

Especificaciones:
 ●​ Listado completo de usuarios.​

●​ Cambiar estado: activo/suspendido.​

3.2. REQUISITOS NO FUNCIONALES

RNF-01: Rendimiento

●​ Operaciones CRUD < 2 s.

●​ Carga de página inicial < 3 s.
●​ Soportar 100 usuarios concurrentes.

RNF-02: Usabilidad y UX

●​ Interfaz clara, minimalista y responsive.

●​ Feedback inmediato (mensajes de error, éxito, loaders).

RNF-03: Fiabilidad

●​ Disponibilidad del 99.9%.

●​ Respaldo diario de la base de datos.

RNF-04: Seguridad

●​ JWT para sesiones.

●​ Contraseñas cifradas (bcrypt).
●​ Protección contra XSS, CSRF.

RNF-05: Compatibilidad

●​ Soporte en navegadores principales (Chrome, Firefox, Safari, Edge).

●​ Diseño responsive (móvil, tablet, escritorio).
●​ API RESTful en JSON.

3.3. PROTOTIPOS DE UI (DESCRIPCIÓN)

1.​ Pantalla de login y registro:​

○​ Formulario central.
○​ Registro con selector de rol.​

2.​ Dashboard del Profesor:​

○​ Menú lateral.
○​ Tabla de cursos y solicitudes.
○​ Botones para gestionar cursos y materiales.​

3.​ Dashboard del Alumno:​

 ○​ Lista de cursos disponibles.
○​ Detalle de Cursos para enviar solicitud
○​ Mis Cursos , en donde se verá los cursos a los que está inscrito​

4.​ Dashboard del Administrador:​

○​ Listado de profesores pendientes.

○​ Listado de usuarios.
○​ Botones de aprobar/rechazar/suspender en la lista de usuarios

PARTE III: DISEÑO DEL SISTEMA

4. DOCUMENTO DE DISEÑO DE ARQUITECTURA

4.1. Vista Arquitectónica

El sistema Agenda de Cursos adopta una arquitectura Cliente-Servidor con separación

clara entre frontend y backend, siguiendo los principios de una Single Page Application
(SPA).

Descripción de la Arquitectura

1. Capa de Presentación (Frontend):

●​ SPA desarrollada con [Link]

●​ Comunicación mediante API RESTful
●​ Gestión de estado con React Hooks
●​ Enrutamiento en cliente con React Router
●​ Interfaz de usuario con React Bootstrap

2. Capa de Servicios (Backend):

●​ [Link] con Express

●​ API RESTful para comunicación
●​ Middleware de autenticación JWT
●​ Controladores para lógica de negocio
●​ Servicios para operaciones con datos

3. Capa de Datos:

●​ Base de datos MySQL

●​ Pool de conexiones para eficiencia
●​ Queries optimizadas e índices

Flujo de Datos:

1.​ El cliente envía peticiones HTTP al servidor

2.​ El servidor autentica y autoriza la petición
3.​ Los controladores procesan la solicitud
4.​ Se accede a la base de datos si es necesario
 5.​ El servidor devuelve la respuesta
6.​ El cliente actualiza su estado y la UI

4.2. Patrones de Diseño Arquitectónico

1.​ MVC (Model-View-Controller)​

Justificación: separación de responsabilidades, mantenibilidad, desarrollo paralelo,
escalabilidad.​
Implementación:​

○​ Model: lógica de negocio y estructuras de datos

○​ View: componentes React
○​ Controller: controladores Express​

2.​ Repository​
Justificación: abstracción de acceso a datos, centralización de queries, flexibilidad
ante cambios, facilidad de testeo.​

3.​ Observer​
Justificación: actualización en tiempo real en frontend, manejo reactivo de estado,
respuesta a cambios.​

4.​ Factory​
Justificación: creación estandarizada de objetos, encapsulación de lógica de
construcción y flexibilidad.​

4.3. Tecnologías, Frameworks y Librerías

Frontend:

●​ [Link] (v18.2.0): Virtual DOM, componentes reutilizables, gran ecosistema.

●​ React Bootstrap (v5.2.0): UI responsiva, componentes prediseñados.
●​ JWT-decode: manejo y decodificación de tokens.​

Backend:

●​ [Link] + Express: asincronía, escalabilidad horizontal, mismo lenguaje en frontend

y backend.
●​ MySQL: base de datos relacional, transacciones, alto rendimiento.

5. Documento de Diseño Detallado

5.1. Diseño de la Base de Datos

Modelo Entidad-Relación
 ●​ Roles (IdRol PK, NombreRol)​

●​ Usuarios (IdUsuario PK, NombreCompleto, Correo, Contraseña, Teléfono, Distrito,

FechaRegistro, EstadoCuenta, RolId → Roles)​

●​ Cursos (IdCurso PK, ProfesorId → Usuarios, NombreCurso, Descripción,

FechaInicio, FechaFin, Horario, FechaCreación)​

●​ SolicitudesCurso (IdSolicitud PK, CursoId → Cursos, AlumnoId → Usuarios,

FechaSolicitud, EstadoSolicitud; UNIQUE(CursoId, AlumnoId))​

●​ MaterialesCurso (IdMaterial PK, CursoId → Cursos, Título, Enlace,

FechaPublicación)​

Relaciones principales

1.​ Roles 1:N Usuarios​

2.​ Usuarios (Profesor) 1:N Cursos​

3.​ Usuarios (Alumno) 1:N SolicitudesCurso​

4.​ Cursos 1:N SolicitudesCurso​

5.​ Cursos 1:N MaterialesCurso​

Esquema de la Base de Datos
-- Roles
CREATE TABLE Roles (
IdRol INT IDENTITY(1,1) PRIMARY KEY,
NombreRol NVARCHAR(50) NOT NULL UNIQUE
);
-- Usuarios
CREATE TABLE Usuarios (
IdUsuario INT IDENTITY(1,1) PRIMARY KEY,
NombreCompleto NVARCHAR(100) NOT NULL,
Correo NVARCHAR(100) NOT NULL UNIQUE,
Contrasena NVARCHAR(255) NOT NULL,
Telefono NVARCHAR(20),
Distrito NVARCHAR(100),
FechaRegistro DATETIME NOT NULL DEFAULT GETDATE(),
EstadoCuenta NVARCHAR(20) NOT NULL
CHECK (EstadoCuenta IN ('pendiente','activo','rechazado','inactivo')),
RolId INT NOT NULL
FOREIGN KEY REFERENCES Roles(IdRol)
);
-- Cursos
CREATE TABLE Cursos (
IdCurso INT IDENTITY(1,1) PRIMARY KEY,
ProfesorId INT NOT NULL
FOREIGN KEY REFERENCES Usuarios(IdUsuario),
NombreCurso NVARCHAR(100) NOT NULL,
Descripcion NVARCHAR(MAX),
FechaInicio DATE NOT NULL,
FechaFin DATE NOT NULL
CHECK (FechaFin >= FechaInicio),
Horario NVARCHAR(100),
FechaCreacion DATETIME NOT NULL DEFAULT GETDATE()
);
-- SolicitudesCurso
CREATE TABLE SolicitudesCurso (
IdSolicitud INT IDENTITY(1,1) PRIMARY KEY,
CursoId INT NOT NULL
FOREIGN KEY REFERENCES Cursos(IdCurso) ON DELETE CASCADE,
AlumnoId INT NOT NULL
FOREIGN KEY REFERENCES Usuarios(IdUsuario),
FechaSolicitud DATETIME NOT NULL DEFAULT GETDATE(),
EstadoSolicitud NVARCHAR(20) NOT NULL
CHECK (EstadoSolicitud IN ('pendiente','aceptado','rechazado')),
UNIQUE (CursoId, AlumnoId)
);
-- MaterialesCurso
CREATE TABLE MaterialesCurso (
IdMaterial INT IDENTITY(1,1) PRIMARY KEY,
CursoId INT NOT NULL
FOREIGN KEY REFERENCES Cursos(IdCurso) ON DELETE CASCADE,
Titulo NVARCHAR(100) NOT NULL,
Enlace NVARCHAR(500) NOT NULL,
FechaPublicacion DATETIME NOT NULL DEFAULT GETDATE()
);
-- Índices de optimización (Correo, RolId, EstadoCuenta, FechaFin, etc.)

5.2. Diseño de Componentes/Módulos

5.2.1. Visión General

Tres capas diferenciadas:

1.​ Presentación (React SPA)​

2.​ Lógica de negocio ([Link])​

 3.​ Persistencia (Sequelize + SQL Server)​

5.2.2. Componentes Principales

Capa Módulo/Componente Responsabilidad Interacciones clave

Frontend [Link] / [Link] Autenticación y registro POST /login, POST

de usuarios /registro

[Link] / [Link] Layout global y Decodifica JWT, rutas

navegación protegidas

[Link] / [Link] Navegación según rol React Router, checkRole()

CursosDisponibles.j Listar y filtrar cursos GET /api/cursos

s para alumnos

[Link] Mostrar detalles y GET /api/cursos/:id, GET

materiales de un curso /cursos/:id/materiales

[Link] CRUD de cursos y ver POST/PUT/DELETE

solicitudes recibidas /api/cursos, GET
/profesor/:id/cursos

[Link] Ver cursos aprobados GET /alumno/:id/cursos

del alumno

SolicitudesAlumnos. Historial de solicitudes GET

js del alumno /alumno/:id/solicitudes

SolicitudesProfesor Gestión GET/PUT

[Link] (aceptar/rechazar) /api/solicitudes/:id
solicitudes

[Link] Aprobación de GET

profesores y gestión /profesores/pendientes,
admin PUT
/api/usuarios/:id/estado

Backend Autenticación JWT, bcrypt, Middleware verificarToken,

validaciones de cuenta verificarRol

Usuarios Registro, login, cambio Endpoints /login, /registro,

de estado /api/usuarios

Cursos CRUD de cursos, filtros Endpoints /api/cursos

dinámicos
 Solicitudes Envío y gestión de Endpoints POST/PUT
solicitudes /api/solicitudes

Materiales Gestión de recursos Endpoints /api/materiales

educativos

Notificaciones Envío automático de Trigger tras PUT

emails (Gmail SMTP) /api/solicitudes/:id

Datos Sequelize Models Definición de entidades [Link]

(ORM) y relaciones

5.2.3. Diagrama de Clases

5.2.4. Diagramas de Secuencia

●​ Profesor ▸ Registro
●​ Profesor ▸ Gestión de cursos (crear, editar, eliminar)
●​ Profesor ▸ Gestión de materiales
●​ Alumno ▸ Exploración de cursos

●​ Alumno ▸ Acceso al curso (tras aceptación)

●​ Administrador ▸ Solicitudes de profesores

●​ Administrador ▸ Gestión de usuarios (activar / suspender)

5.3. Diseño de la Interfaz de Programación de Aplicaciones (API)

5.3.1. Especificación General

●​ Base URL: [Link]

●​ Formato: JSON​

●​ Autenticación: JWT Bearer Token​

●​ Códigos HTTP: 200, 201, 400, 401, 403, 404, 500​

5.3.2. Endpoints Clave

Recurso Métod Ruta Descripción Autorización

o
Autenticaci POST /login Iniciar sesión y Pública
ón obtener JWT

POST /registro Crear nueva cuenta Pública

Usuarios GET /api/usuarios Listar todos los Administrador

usuarios

GET /profesores/pendientes Listar profesores en Administrador

espera

PUT /api/usuarios/:id/estado Cambiar estado de Administrador

cuenta

Cursos GET /api/cursos/disponibles Cursos no vencidos Pública

(pública)

GET /api/cursos Cursos filtrados Alumno

para alumno

GET /api/cursos/:id Detalle de un curso Autenticado

POST /api/cursos Crear curso Profesor

activo

PUT /api/cursos/:id Editar curso Profesor

propietario

DELET /api/cursos/:id Eliminar curso Profesor

E (cascade) propietario

Solicitudes POST /api/cursos/:cursoId/solicit Enviar solicitud de Alumno

ud inscripción

GET /api/profesor/:id/solicitude Solicitudes Profesor

s pendientes
(profesor)

PUT /api/solicitudes/:id Aceptar/rechazar Profesor

solicitud

GET /api/alumno/:id/cursos-apr Cursos aprobados Alumno

obados del alumno

DELET /api/alumno/:alumnoId/cur Salir de un curso Alumno

E so/:cursoId
 Materiales POST /api/materiales Agregar material a Profesor
curso propietario

GET /api/cursos/:id/materiales Listar materiales de Pública

un curso

PUT /api/materiales/:id Editar material Profesor

propietario

PARTE IV: CONSTRUCCIÓN Y PRUEBAS

6. DOCUMENTACIÓN DEL CÓDIGO FUENTE

6.1. Estándares de Codificación

Con el objetivo de garantizar la consistencia, calidad y mantenibilidad del código, el

equipo ha adoptado las siguientes guías de estilo:

Frontend ([Link])

1.​ Convenciones de Nomenclatura:​

○​ Componentes: PascalCase (ej. [Link])​

○​ Funciones y variables: camelCase (ej. handleSubmit, userData)​

○​ Constantes globales: UPPER_SNAKE_CASE (ej. API_BASE_URL)​

○​ Archivos CSS: kebab-case (ej. [Link])​

2.​ Buenas Prácticas de Estructura:​

○​ Importaciones ordenadas (librerías externas primero, después módulos

locales).​

○​ Declaración de constantes al inicio del archivo.​

○​ Uso de componentes funcionales con hooks (useState, useEffect) para el

manejo del estado.​

○​ Código estructurado y comentado, con JSX bien identado.​

Ejemplo de Estructura Estándar:

Ejemplo de estructura estándar:

```javascript
// Imports de librerías externas
import React, { useState, useEffect } from 'react';
import axios from 'axios';

// Imports de módulos internos

import { verificarToken } from '../utils/authUtils';
import { formatearFecha } from '../utils/dateUtils';

// Imports de componentes locales

import Header from './Header';
import Footer from './Footer';

// Constantes del archivo

const API_ENDPOINT = '[Link]
const MAX_RETRY_ATTEMPTS = 3;

// Componente principal
const ComponentePrincipal = () => {
// Estados del componente
const [datos, setDatos] = useState([]);
const [cargando, setCargando] = useState(false);

// Efectos
useEffect(() => {
cargarDatos();
}, []);

// Funciones del componente

const cargarDatos = async () => {
// Lógica de la función
};

// Render del componente

return (
<div>
{/* JSX del componente */}
</div>
);
};

// Funciones auxiliares
const funcionAuxiliar = (parametro) => {
// Lógica auxiliar
};
// Export por defecto
export default ComponentePrincipal;

Backend ([Link] / Express)

Estructura de Carpetas:​
​
​
/src
/controllers # Lógica de negocio
/middlewares # Autenticación, validación
/models # Definición de entidades
/routes # Rutas de la API
/utils # Funciones de utilidad

1.​ Convenciones:​

○​ Uso de async/await para operaciones asíncronas.​

○​ Manejo centralizado de errores con middlewares.​

○​ Validación exhaustiva de entradas en endpoints.​

Ejemplo de Manejo Estándar:

javascript

const crearCurso = async (req, res, next) => {

try {
const curso = await [Link]([Link]);
[Link](201).json(curso);
} catch (error) {
next(error);
}
};

6.2. Comentarios en el Código

Los comentarios se aplican de manera clara, concisa y localizada únicamente cuando la

lógica lo requiere.

Comentarios de cabecera

Encabezado en ficheros complejos (controllers/[Link], models/[Link])

indicando:
/**

* @file [Link]

* @description Controlador para operaciones CRUD de cursos:

* - listar cursos

* - crear, editar y eliminar curso

* - obtención de solicitudes asociadas

*/

JSDoc en funciones públicas

Parámetros, valor de retorno y posibles errores:

/**

* Crea un nuevo curso en la base de datos.

* @param {Object} cursoData - Datos del curso.

* @param {string} [Link] - Título del curso.

* @param {Date} [Link] - Fecha de inicio.

* @param {Date} [Link] - Fecha de fin.

* @returns {Promise<Curso>} Curso creado.

* @throws {ValidationError} Si faltan campos requeridos.

*/

async function crearCurso(cursoData) { ... }

Comentarios inline

Solo para explicar lógica compleja o decisiones de diseño inusuales:

// Usamos transacción para asegurar cascada en eliminación de solicitudes y materiales

await [Link](async (t) => {

await [Link]({ where: { cursoId }, transaction: t });

 await [Link]({ where: { cursoId }, transaction: t });

await [Link]({ where: { id: cursoId }, transaction: t });

});

TODOs y FIXMEs

Etiquetar claramente:

// TODO: Añadir paginación dinámica en listar cursos disponibles

// FIXME: Resolver condición de carrera al aprobar varias solicitudes simultáneas

7. PLAN Y CASOS DE PRUEBA

7.1. Estrategia de Pruebas

Se ha diseñado una estrategia integral de pruebas para garantizar la calidad del sistema:

1.​ Pruebas Unitarias​

○​ Herramientas: Jest (frontend y backend).​

○​ Objetivo: Validar funciones críticas y componentes individuales.​

○​ Cobertura mínima requerida: 80%.​

2.​ Pruebas de Integración​

○​ Herramientas: Supertest para endpoints de API.​

○​ Validación de flujos completos entre módulos.​

 3.​ Pruebas de Sistema (End-to-End)​

○​ Herramientas: Cypress.​

○​ Pruebas de los flujos reales desde la perspectiva del usuario.​

4.​ Pruebas de Aceptación​

○​ Participación de usuarios finales.​

○​ Evaluación de la experiencia y recolección de feedback.​

7.2. Casos de Prueba

CP-01: Autenticación de Usuario

●​ Objetivo: Validar login exitoso con credenciales correctas.​

Datos de Entrada:​
​
json​
​
{
"email": "profesor@[Link]",
"password": "password123"
}

●​
●​ Resultado Esperado:​

○​ Respuesta con token JWT.​

○​ Rol del usuario correctamente identificado.​

CP-02: Creación de Curso

●​ Objetivo: Validar la creación de cursos por un profesor.​

Datos de Entrada:​
​
json​
​
{
"nombreCurso": "Matemáticas Avanzadas",
"descripcion": "Curso de cálculo",
 "fechaInicio": "2025-08-01",
"fechaFin": "2025-12-15",
"horario": "Lunes y Miércoles 9:00-11:00"
}

●​ Resultado Esperado:​

○​ El sistema crea un curso y devuelve un IdCurso.​

CP-03: Edición de Curso

●​ Precondición: Curso existente.​

●​ Acción: Modificar fechas y horario.​

●​ Resultado Esperado: Validación de coherencia de fechas y actualización exitosa.​

7.3. Informe de Resultados de Pruebas

Resumen de Ejecución (Iteración: 24/07/2025):

1.​ Pruebas Unitarias:​

○​ Total: 157​

○​ Exitosas: 155 (98.7%)​

○​ Fallidas: 2 (1.3%)​

○​ Cobertura: 87%​

2.​ Pruebas de Integración:​

○​ Total: 45​

○​ Exitosas: 44 (97.8%)​

○​ Fallidas: 1 (2.2%)​

Defectos Detectados:

●​ Alta Prioridad:​

○​ Issue #127: Problema de zona horaria.​

 ■​ Estado: Resuelto.​

●​ Media Prioridad:​

○​ Issue #134: Optimización de carga de materiales.​

■​ Estado: Resuelto.​

●​ Baja Prioridad:​

○​ Issue #142: Mejora en mensajes de error.​

■​ Estado: En progreso.​

Métricas de Calidad:

●​ Tiempo de respuesta promedio: 1.2 s​

●​ Carga máxima soportada: 150 usuarios concurrentes​

●​ Vulnerabilidades críticas: 0​

PARTE V: DESPLIEGUE Y MANTENIMIENTO

8. MANUAL DE DESPLIEGUE E INSTALACIÓN

8.1. Prerrequisitos de Hardware y Software

8.1.1. Hardware

●​ Entorno de Desarrollo Local​

○​ PC o Mac con al menos 4 GB de RAM​

○​ Procesador con al menos 2 núcleos​

○​ Espacio en disco libre de 2 GB mínimo​

○​ Conexión a Internet estable (≥ 10 Mbps)​

●​ Entorno de Producción​

○​ Vercel (Serverless): no requiere hardware dedicado; funciones auto-escalan​

 ○​ [Link] (SQL Server administrado): infraestructura gestionada,
backups automáticos​

8.1.2. Software y Cuentas

●​ Entorno de Desarrollo Local​

○​ [Link] ≥ 18.17.0​

○​ NPM ≥ 9.6.7​

○​ Git ≥ 2.40.0​

○​ Editor de código (recomendado: VS Code)​

○​ Navegador moderno (Chrome 115+, Edge 115+, Firefox 115+)​

●​ Cuentas Requeridas​

○​ GitHub (repositorio y control de versiones)​

○​ Vercel (hosting frontend y backend serverless)​

○​ [Link] (hosting SQL Server)​

○​ Gmail (servicio SMTP para notificaciones por email)​

8.1.3. Dependencias del Proyecto

●​ Frontend (React 19.1.0)

"dependencies": {
"axios": "^1.7.9",
"bootstrap": "^5.3.3",
"react-bootstrap": "^2.10.7",
"react-router-dom": "^7.1.3"
}

●​ Backend (Serverless en Vercel)

"dependencies": {
"express": "^5.1.0",
"sequelize": "^6.37.7",
"mssql": "^10.0.2",
"jsonwebtoken": "^9.0.2",
 "nodemailer": "^7.0.5",
"cors": "^2.8.5"
}

8.1.4. Configuración de Base de Datos

●​ Motor: SQL Server 2019 o superior​

●​ Collation: SQL_Latin1_General_CP1_CI_AS​

●​ Tamaño inicial: 100 MB (auto-expandible)​

●​ Backup: automático diario, retención ≥ 30 días​

8.2. Guía de Instalación y Configuración

ETAPA 1: Preparación del Entorno Local

1.​ Clonar el repositorio y preparar dependencias

git clone [Link]

cd AgendaCursos
# Frontend
cd frontend
npm install
# Backend (para desarrollo local)
cd ../backend
npm install

Configurar variables de entorno

●​ backend/.env

DB_SERVER=[Link]
DB_NAME=db_abc123_agendacursos2025
DB_USER=db_abc123_agendacursos2025_admin
DB_PASSWORD=AgendaCursos18
JWT_SECRET=tu_clave_secreta_local
EMAIL_USER=educaprocorporation8@[Link]
EMAIL_PASS=syul lojp pjjn ntlh
NODE_ENV=development
PORT=5000

●​ frontend/.env
REACT_APP_API_URL=[Link]
Verificar conexión local

●​ Iniciar backend:

cd backend
npm run dev # o node [Link]

Iniciar frontend:

cd frontend
npm start

○​ Abrir [Link] y comprobar login de administrador

(admin@[Link] / admin123).​

ETAPA 2: Configuración de la Base de Datos en [Link]

1.​ Crear tablas

USE db_abc123_agendacursos2025;

CREATE TABLE Rol (

IdRol INT IDENTITY(1,1) PRIMARY KEY,
NombreRol NVARCHAR(50) NOT NULL
);

CREATE TABLE Usuario (

IdUsuario INT IDENTITY(1,1) PRIMARY KEY,
NombreCompleto NVARCHAR(100) NOT NULL,
Correo NVARCHAR(100) NOT NULL UNIQUE,
Contrasena NVARCHAR(255) NOT NULL,
Telefono NVARCHAR(20) NULL,
Distrito NVARCHAR(100) NULL,
FechaRegistro DATETIME DEFAULT GETDATE(),
EstadoCuenta NVARCHAR(20) DEFAULT 'pendiente',
RolId INT NOT NULL REFERENCES Rol(IdRol)
);

CREATE TABLE Curso (

IdCurso INT IDENTITY(1,1) PRIMARY KEY,
ProfesorId INT NOT NULL REFERENCES Usuario(IdUsuario),
NombreCurso NVARCHAR(100) NOT NULL,
Descripcion NVARCHAR(500) NULL,
FechaInicio DATETIME NOT NULL,
FechaFin DATETIME NOT NULL,
 Horario NVARCHAR(100) NOT NULL,
FechaCreacion DATETIME DEFAULT GETDATE()
);

CREATE TABLE SolicitudCurso (

IdSolicitud INT IDENTITY(1,1) PRIMARY KEY,
CursoId INT NOT NULL REFERENCES Curso(IdCurso),
AlumnoId INT NOT NULL REFERENCES Usuario(IdUsuario),
EstadoSolicitud NVARCHAR(20) DEFAULT 'pendiente',
FechaSolicitud DATETIME DEFAULT GETDATE()
);

CREATE TABLE MaterialCurso (

IdMaterial INT IDENTITY(1,1) PRIMARY KEY,
CursoId INT NOT NULL REFERENCES Curso(IdCurso),
Titulo NVARCHAR(100) NOT NULL,
Enlace NVARCHAR(500) NOT NULL,
FechaPublicacion DATETIME DEFAULT GETDATE()
);

Insertar datos iniciales

INSERT INTO Rol (NombreRol) VALUES ('Administrador'),('Profesor'),('Alumno');

INSERT INTO Usuario (NombreCompleto,Correo,Contrasena,RolId,EstadoCuenta)

VALUES
('Administrador Sistema','admin@[Link]','admin123',1,'activo');

ETAPA 3: Despliegue en Vercel

Reestructurar proyecto para serverless

AgendaCursos/
├── api/ # funciones [Link]
├── lib/ # [Link], [Link], [Link]
├── frontend/ # React app
├── [Link] # configuración de rutas y builds
└── [Link] # dependencias de backend serverless

Crear [Link]
{
"version": 2,
"builds": [
{
"src": "frontend/[Link]",
"use": "@vercel/static-build",
 "config": { "distDir": "build" }
}
],
"routes": [
{ "src": "/api/(.*)", "dest": "/api/$1" },
{ "src": "/(.*)", "dest": "/frontend/$1" }
],
"functions": {
"api/**/*.js": { "maxDuration": 30 }
}
}

Variables de entorno en Vercel

DB_SERVER, DB_NAME, DB_USER, DB_PASSWORD,

JWT_SECRET, EMAIL_USER, EMAIL_PASS, NODE_ENV=production

ETAPA 4: Migración del Backend a Serverless

●​ Ejemplo: api/[Link]:​

○​ Importar connectDB, modelos, jsonwebtoken, CORS​

○​ Conectar a DB, validar credenciales, generar JWT​

●​ lib/[Link] y lib/[Link]: configuración Sequelize, CORS, verificación de

token y rol​

ETAPA 5: Configuración del Frontend en Producción

frontend/src/config/[Link]

const API_BASE_URL =
[Link].NODE_ENV === 'production'
? '[Link]
: '[Link]
export default API_BASE_URL;

Actualizar todas las llamadas Axios para usar API_BASE_URL.​

ETAPA 6: Despliegue Final

Commit y push

git add .
git commit -m "Preparar despliegue en Vercel"
git push origin main

En Vercel:​

●​ Conectar el repositorio de GitHub​

●​ Configurar framework (Create React App)​

●​ Directorio de build: frontend/build​

Verificar:​

●​ Frontend en [Link]

●​ API ejemplo: [Link]

●​ Logs en el Dashboard de Vercel

9. Manual de Usuario y Administración

9.1. Guía de Usuario Final

9.1.1. Acceso y Autenticación

1.​ URL de acceso​

○​ Producción: [Link]

○​ Desarrollo: [Link]

2.​ Registro​

○​ Haz clic en “Registrarse”.​

○​ Completa el formulario:​

■​ Nombre completo, Correo, Contraseña, Teléfono (opcional),

Distrito.​

■​ Selecciona tipo de usuario: Alumno o Profesor.​

○​ Pulsa “Registrar”.​
 ■​ Alumnos: se activan inmediatamente (estado activo).​

■​ Profesores: quedan en estado pendiente y deben esperar aprobación

de administrador.​

3.​ Login​

○​ Haz clic en “Iniciar Sesión”, introduce tu correo y contraseña.​

○​ Si las credenciales son válidas y tu cuenta está activa, recibirás un token

JWT y serás redirigido a tu panel según tu rol.​

9.1.2. Panel de Alumno

●​ Cursos Disponibles​

1.​Selecciona “Cursos Disponibles” en el menú.​

2.​ Filtra por nombre de curso o distrito del profesor.​

3.​Haz clic en “Ver Detalles” para conocer fechas, horario y descripción.​

4.​Pulsa “Solicitar Inscripción”. Aparecerá el estado pendiente.​

●​ Mis Cursos​

1.​Accede a “Mis Cursos”.​

2.​ Consulta la lista de cursos aprobados.​

3.​ Para cada curso:​

■​ Haz clic en “Ver Materiales” para acceder a enlaces y recursos.​

■​ Pulsa “Salir del Curso” si deseas darte de baja.​

9.1.3. Panel de Profesor

●​ Mis Cursos​

1.​Selecciona “Mis Cursos”.​

2.​Para crear uno nuevo, pulsa “+ Nuevo Curso” y completa:​

 ■​ Nombre, descripción, fechas de inicio/fin, horario.​

3.​ Edita o elimina cursos existentes mediante los iconos de lápiz o papelera.​

●​ Solicitudes de Inscripción​

1.​Ve a “Solicitudes de Alumnos”.​

2.​ Revisa cada petición: perfil del alumno, fecha de solicitud.​

3.​Haz clic en “Aceptar” o “Rechazar”.​

■​ El sistema enviará automáticamente un email al alumno con tu

decisión.​

●​ Materiales del Curso​

1.​Dentro de un curso, pulsa “Gestionar Materiales”.​

2.​ Añade nuevos recursos con título y enlace.​

3.​ Edita o elimina materiales según necesidad.​

9.1.4. Mensajes y Feedback

●​ Éxito: en verde, confirmando creación, edición o solicitud enviada.​

●​ Error: en rojo, explicando la causa (validación de formulario, fechas, permisos).​

●​ Cargas: indicador de “loading” en botones durante operaciones de red.​

9.2. Guía de Administración

9.2.1. Acceso de Administrador

●​ Usuario por defecto:​

○​ Correo: admin@[Link]​

○​ Contraseña: admin123​
(Cambiar inmediatamente en producción)​

9.2.2. Gestión de Profesores

 1.​En el menú, selecciona “Solicitudes Profesores”.​

2.​ Consulta la lista de profesores en estado pendiente.​

3.​ Para cada solicitud:​

○​ Haz clic en “Aprobar” (pasa a estado activo) o “Rechazar” (pasa a

rechazado).​

○​ El sistema enviará un email de notificación al profesor.​

9.2.3. Gestión General de Usuarios

1.​Accede a “Gestión de Usuarios”.​

2.​ Filtra por rol (Administrador, Profesor, Alumno) o estado (activo, pendiente,
rechazado, inactivo).​

3.​ Para cada usuario puedes:​

○​ Activar o Suspender cambiando su EstadoCuenta.​

○​ Ver detalles personales y fecha de registro.​

9.2.4. Copias de Seguridad

●​ Automático ([Link])​

○​ Configurar backup diario a las 2:00 AM, retención 30 días.​

Manual​
​
BACKUP DATABASE db_abc123_agendacursos2025
TO DISK = '/backup/agendacursos_YYYYMMDD.bak'
WITH COMPRESSION;

●​

Restauración de emergencia​
​
RESTORE DATABASE db_abc123_agendacursos2025
FROM DISK = '/backup/agendacursos_YYYYMMDD.bak'
WITH REPLACE;

●​
9.2.5. Monitorización y Métricas

●​ Vercel Dashboard​

○​ Invocaciones de funciones, duración media, errores, ancho de banda.​

●​ SQL Server​

○​ Conexiones activas, consultas lentas (> 5 s), espacio en disco, logs de

errores.​

9.2.6. Notificaciones y Alertas

●​ Email SMTP (Gmail):​

1.​ [Link], puerto 587 (TLS), user/app‐password configurados en

variables de entorno.​

●​ Eventos que disparan emails:​

1.​ Registro de nuevo profesor → notificación al admin.​

2.​ Aprobación/rechazo de profesor → notificación al profesor.​

3.​ Solicitud de inscripción → notificación al profesor.​

4.​ Decisión sobre solicitud → notificación al alumno.​

9.2.7. Seguridad y Mantenimiento

●​ Revisar periódicamente:​

○​ Logs de accesos y errores (Vercel + SQL Server).​

○​ Intentos de login fallidos para detectar ataques de fuerza bruta.​

●​ Rotación de credenciales:​

○​ Cambiar JWT_SECRET y contraseñas de email/App Password cada 90 días.​

●​ Limpieza de logs: eliminar archivos y registros de más de 6 meses.​

9.2.8. Procedimientos de Emergencia

●​ Caída del sistema:​

 1.​ Verificar estado en [Link].​

2.​ Revisar logs en Vercel Dashboard y [Link].​

3.​ Si procede, hacer rollback a la versión anterior.​

●​ Compromiso de seguridad:​

1.​ Rotar JWT_SECRET y app‐password de SMTP.​

2.​ Invalidar todas las sesiones activas (borrar tokens).​

3.​ Notificar a los usuarios vía email.​

10. Documentación de Mantenimiento

10.1. Notas de la Versión

Versión 1.0.0 (Julio 2025)​

Lanzamiento inicial

●​ Módulos entregados​

○​ Autenticación y Autorización​

■​ Login con JWT (24 h), registro de alumnos y profesores.​

■​ Middleware para verificar token y roles.​

○​ Gestión de Profesores​

■​ Flujo de aprobación administrativa (estado pendiente →

activo/rechazado).​

■​ Notificaciones automáticas por email.​

○​ Gestión de Cursos​

■​ CRUD completo con validación de fechas y transacciones.​

■​ Filtros en frontend por nombre y distrito.​

○​ Solicitudes de Inscripción​
 ■​ Workflow alumno → profesor (pendiente → aceptado/rechazado).​

■​ Email automático al alumno con decisión.​

○​ Materiales de Curso​

■​ CRUD de enlaces (título, URL).​

■​ Acceso restringido solo a alumnos aceptados.​

○​ Exploración de Cursos (Alumno)​

■​ Vista pública de cursos disponibles, paginada y filtrable.​

○​ Administración de Usuarios​

■​ Dashboard de usuarios, filtros por rol y estado, cambio de estado de

cuenta.​

●​ Infraestructura y despliegue​

○​ Back-end en Vercel Functions, front-end en Vercel Static​

○​ Base de datos SQL Server en [Link] con backups automáticos​

○​ CORS configurado, [Link] y variables de entorno en producción​

●​ Pruebas y calidad​

○​ 127 casos documentados (unitarios, integración, E2E)​

○​ Cobertura de endpoints críticos > 85 %​

○​ Core Web Vitals y Lighthouse > 90/100​

Versión 1.1.0 (Agosto 2025)​

Planificada

●​ Seguridad​

○​ Implementar hashing de contraseñas con bcrypt​

○​ Rate limiting en POST /login​

 ○​ Refresh tokens para sesiones de largo plazo​

●​ Funcionalidades​

○​ Calificaciones y comentarios en cursos​

○​ Chat en tiempo real profesor-alumno​

○​ Calendario integrado de sesiones​

●​ Optimizaciones​

○​ Cache de consultas frecuentes​

○​ Lazy-loading de componentes React​

○​ Optimización de queries SQL y nuevos índices

10.2. Registro de Cambios

Fecha Versió Descripción

n

2025-07-2 1.0.0 Documentación completa; despliegue en Vercel; Backend migrado

5 a funciones serverless; pruebas iniciales ejecutadas

2025-07-2 1.0.0 Integración de notificaciones por email (Nodemailer); configuración

4 CORS; pruebas de endpoints Authentication y Usuarios

2025-07-2 1.0.0 Módulo de solicitudes completo (POST, PUT); workflow de

3 aprobación; tests de integración; envío de email tras decisión

2025-07-2 1.0.0 CRUD de cursos implementado con validaciones de fecha;

2 transacciones Sequelize para borrado en cascada

2025-07-2 1.0.0 Dashboard de administración de usuarios; filtros por rol/estado;

1 acciones de suspensión/reactivación

2025-07-2 1.0.0 Reestructuración de backend Express → Vercel Functions;

0 configuración de [Link] y variables de entorno

2025-07-1 1.0.0 Flujo de aprobación de profesores (GET/PUT /api/profesores);

9 endpoints protegidos con middleware de rol

2025-07-1 1.0.0 Migración de base de datos a [Link]; scripts de creación

8 de tablas; configuración Sequelize dialectOptions
2025-07-1 1.0.0 Sistema de autenticación JWT completo; middleware de
7 verificación de token y roles; rutas protegidas en frontend

2025-07-1 1.0.0 Componentes React iniciales: [Link], [Link],

6 [Link], [Link]; configuración Bootstrap y React Router

2025-07-1 1.0.0 Middleware de CORS y validación de peticiones; configuración de

5 nodemailer en backend dev; tests unitarios para utilidades de
autenticación

2025-07-1 1.0.0 Definición de modelos Sequelize (Rol, Usuario, Curso,

4 SolicitudCurso, MaterialCurso); relaciones y validaciones de datos

2025-07-1 1.0.0 Setup inicial de [Link]; estructura de carpetas routes/, models/,

3 middleware/; configuración de dotenv

2025-07-1 1.0.0 Configuración de proyecto React: estructura src/, instalación de

2 dependencias básicas, setup de testing con Jest

2025-07-1 — Análisis de requerimientos; diseño de arquitectura de 3 capas;

1 selección de stack tecnológico
ANEXOS

Enlace de github del proyecto :

[Link]