diff --git a/CHANGELOG.md b/CHANGELOG.md index 8f88e97..4d16445 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,6 +11,19 @@ El formato está basado en [Keep a Changelog](https://keepachangelog.com/es-ES/1 - **Sincronización Continua Moodle (Fase 6):** Automatización de workers persistentes en background para el procesamiento continuo de la cola de Web Services Moodle 4.1. - **Pruebas de Carga y Hardening (Fase 6):** Pruebas de estrés de concurrencia y validación final de producción. +## [3.8.9] - 2026-10-23 +### Added +- **Endpoints de Heurística y Optimización Genética en Backend FastAPI (`/api/genetic`)**: + - Implementado `POST /api/genetic/preview-optimization`: previsualiza asignaciones estimadas, puntaje de fitness y posibles conflictos para las comisiones seleccionadas. + - Implementado `POST /api/genetic/optimize`: ejecuta el ciclo evolutivo completo del algoritmo genético y retorna el cronograma de reservas generado. + - Implementado `POST /api/genetic/apply-optimization`: persiste y confirma las reservas en la base de datos de Bedelía con detección de colisiones físicas de aulas y compatibilidad horaria UTC. + - Creados esquemas Pydantic DTO con validación fuerte (`GeneticPreviewRequestDTO`, `GeneticOptimizeRequestDTO`, `GeneticApplyRequestDTO`) en `backend/app/schemas/optimizer_dto.py`. + +### Fixed +- **Enrutamiento y Proxy Inverso en Frontend BFF (`frontend/src/app.js`)**: + - Configurado middleware proxy transparente para `/api/genetic` hacia el backend FastAPI (`:5000/api/genetic`), inyectando token JWT Bearer desde las cookies de sesión y resolviendo el error 404 (Not Found) en la consola del navegador al previsualizar o aplicar optimizaciones. + - Normalizadas fechas `start_time` y `end_time` a formato naive UTC para evitar discrepancias de comparación en SQLite/PostgreSQL. + ## [3.8.8] - 2026-10-23 ### Fixed - **Resolución de Error de Renderizado en Plantillas Nunjucks (`Block "extra_css" defined more than once`)**: diff --git a/MEMORY.md b/MEMORY.md index 15cbb9b..0c0b70d 100644 --- a/MEMORY.md +++ b/MEMORY.md @@ -9,12 +9,15 @@ Memoria del proyecto entre sesiones para la rama `dev`. - Libro de Calificaciones (*Gradebook*) con actas de regularidad inmutables. - Autenticación híbrida (Google OAuth 2.0, Moodle SSO, Local) y Modo Impersonación. - Reinicialización segura del sistema con contraseña de Administrador. -- **Sprint Activo: Corrección de Plantillas Nunjucks (Duplicate extra_css) — v3.8.8**: - - **Corrección de Plantillas Frontend**: - - Reparado error de renderizado en `frontend/views/base.html`: eliminada la definición duplicada de `{% block extra_css %}` en la línea 32, preservando la definición canónica en la línea 876 antes de ``. - - Corregida la expresión de corte de texto en `frontend/views/admin/users/list.html` con `.slice(0, 16)`. - - Verificada la compilación exitosa del 100% de las plantillas `.html` mediante suite de escaneo Nunjucks. - - **Versión Consolidada**: `v3.8.8`. +- **Sprint Activo: Endpoints y Proxy de Optimización Genética (/api/genetic) — v3.8.9**: + - **Endpoints de Algoritmo Genético en FastAPI (`/api/genetic`)**: + - Implementado `POST /api/genetic/preview-optimization` para cálculo preliminar de aptitud (fitness), resumen de comisiones y reporte de colisiones estimadas. + - Implementado `POST /api/genetic/optimize` para ejecución de generaciones evolutivas concurrentes y propuesta de reservas. + - Implementado `POST /api/genetic/apply-optimization` para confirmación y persistencia de reservas en base de datos. + - Definidos esquemas Pydantic DTO con tipado fuerte (`GeneticPreviewRequestDTO`, `GeneticOptimizeRequestDTO`, `GeneticApplyRequestDTO`). + - **Proxy Inverso en Frontend Express BFF**: + - Configurado enrutador `/api/genetic` en `frontend/src/app.js` con inyección transparente de token Bearer para llamadas AJAX del navegador (`genetic-algorithm.js`), subsanando el error 404 (Not Found). + - **Versión Consolidada**: `v3.8.9`. ## Decisiones (y por qué) - **Flujo Secuencial de Bedelía (9 Pasos)**: Estandarizar la carga operativa en: 1) Sede -> 2) Aula -> 3) Ciclo Lectivo -> 4) Carrera -> 5) Materia (vinculada a Carrera) -> 6) Comisión (asociada a Materia, Carrera y Ciclo) -> 7) Profesores -> 8) Alumnos -> 9) Reserva de Espacio. Esto asegura consistencia e integridad relacional. diff --git a/backend/app/__init__.py b/backend/app/__init__.py index 6735505..23d422a 100644 --- a/backend/app/__init__.py +++ b/backend/app/__init__.py @@ -7,7 +7,7 @@ from typing import Any from database import db, get_db, engine, SessionLocal, session from config.config import Config -__version__ = "3.8.8" +__version__ = "3.8.9" class DummyContext: def __enter__(self): diff --git a/backend/app/models/genetic_algorithm.py b/backend/app/models/genetic_algorithm.py index e0beeb8..200211e 100644 --- a/backend/app/models/genetic_algorithm.py +++ b/backend/app/models/genetic_algorithm.py @@ -250,6 +250,8 @@ class GeneticAlgorithm: for request in requests: # Random classroom selection (with capacity constraint) suitable_classrooms = [c for c in classrooms if c.capacity >= request.expected_attendees] + if not suitable_classrooms and classrooms: + suitable_classrooms = [max(classrooms, key=lambda c: getattr(c, 'capacity', 0))] if not suitable_classrooms: continue @@ -308,6 +310,8 @@ class GeneticAlgorithm: if mutation_type == 'classroom': # Change classroom suitable_classrooms = [c for c in classrooms if c.capacity >= gene_to_mutate.expected_attendees] + if not suitable_classrooms and classrooms: + suitable_classrooms = [max(classrooms, key=lambda c: getattr(c, 'capacity', 0))] if suitable_classrooms: selected_room = random.choice(suitable_classrooms) gene_to_mutate.classroom_id = int(getattr(selected_room, 'id')) @@ -439,13 +443,26 @@ class ReservationOptimizer: def apply_optimized_reservations(self, reservation_data: List[Dict]) -> List[Reservation]: """Apply the optimized reservations to the database with ISO string parsing and conflict avoidance""" applied_reservations = [] + valid_keys = { + 'classroom_id', 'commission_id', 'user_id', 'start_time', + 'end_time', 'purpose', 'status', 'expected_attendees', + 'shift', 'virtual_link', 'notes' + } for item in reservation_data: data = dict(item) - if isinstance(data.get('start_time'), str): - data['start_time'] = datetime.fromisoformat(data['start_time'].replace('Z', '+00:00')) - if isinstance(data.get('end_time'), str): - data['end_time'] = datetime.fromisoformat(data['end_time'].replace('Z', '+00:00')) + + # Normalizar fechas a objetos datetime naive (UTC) + for time_field in ('start_time', 'end_time'): + val = data.get(time_field) + if isinstance(val, str): + dt = datetime.fromisoformat(val.replace('Z', '+00:00')) + data[time_field] = dt.replace(tzinfo=None) if dt.tzinfo else dt + elif isinstance(val, datetime) and val.tzinfo: + data[time_field] = val.replace(tzinfo=None) + + if not data.get('classroom_id') or not data.get('start_time') or not data.get('end_time'): + continue # Check for physical room conflicts before creating conflicts = Reservation.find_conflicts( @@ -455,13 +472,10 @@ class ReservationOptimizer: ) if not conflicts: - # Ensure status enum value compatibility - if 'status' in data and isinstance(data['status'], str): - try: - data['status'] = ReservationStatus(data['status']).value - except ValueError: - data['status'] = ReservationStatus.CONFIRMED.value - reservation = Reservation(**data) + # Las reservas aplicadas pasan a estado CONFIRMED + data['status'] = ReservationStatus.CONFIRMED.value + filtered_data = {k: v for k, v in data.items() if k in valid_keys} + reservation = Reservation(**filtered_data) db.session.add(reservation) applied_reservations.append(reservation) else: diff --git a/backend/app/schemas/optimizer_dto.py b/backend/app/schemas/optimizer_dto.py index e133cc4..5300250 100644 --- a/backend/app/schemas/optimizer_dto.py +++ b/backend/app/schemas/optimizer_dto.py @@ -47,3 +47,36 @@ class SpringBootSyncPayloadDTO(BaseModel): commissions: List[SpringBootCommissionDTO] = Field(..., min_length=1) classrooms: Optional[List[SpringBootClassroomDTO]] = None options: Optional[Dict[str, Any]] = None + + +class GeneticPreviewRequestDTO(BaseModel): + """Contrato para la previsualización heurística de asignaciones.""" + commission_ids: List[int] = Field(..., min_length=1, description="Lista de IDs de comisiones a previsualizar") + dry_run: bool = Field(default=True, description="Indicador de simulación sin persistencia") + + @field_validator('commission_ids') + @classmethod + def validate_ids(cls, v: List[int]) -> List[int]: + if not v or len(v) == 0: + raise ValueError("Debe suministrar al menos una comisión para previsualizar.") + return list(set(v)) + + +class GeneticOptimizeRequestDTO(BaseModel): + """Contrato para la ejecución completa del algoritmo genético.""" + commission_ids: List[int] = Field(..., min_length=1, description="Lista de IDs de comisiones a optimizar") + start_date: Optional[datetime] = Field(None, description="Fecha de inicio (ISO format)") + end_date: Optional[datetime] = Field(None, description="Fecha de fin (ISO format)") + + @field_validator('commission_ids') + @classmethod + def validate_ids(cls, v: List[int]) -> List[int]: + if not v or len(v) == 0: + raise ValueError("Debe suministrar al menos una comisión para optimizar.") + return list(set(v)) + + +class GeneticApplyRequestDTO(BaseModel): + """Contrato para aplicar las reservas optimizadas en Bedelía.""" + reservations: List[Dict[str, Any]] = Field(..., min_length=1, description="Lista de reservas a persistir") + diff --git a/backend/routers/optimizer.py b/backend/routers/optimizer.py index 81d250e..7184ea8 100644 --- a/backend/routers/optimizer.py +++ b/backend/routers/optimizer.py @@ -6,13 +6,20 @@ Provides asynchronous optimization jobs and genetic heuristic room assignment. from typing import Optional, Dict, Any, List from fastapi import APIRouter, Depends, HTTPException, Query, status -from app.schemas.optimizer_dto import OptimizerJobRequestDTO, SpringBootSyncPayloadDTO +from app.schemas.optimizer_dto import ( + OptimizerJobRequestDTO, + SpringBootSyncPayloadDTO, + GeneticPreviewRequestDTO, + GeneticOptimizeRequestDTO, + GeneticApplyRequestDTO +) from app.services.optimizer_service import OptimizerService from dependencies import get_current_user from app.models.user import User from app.models.subject import Commission from app.models.classroom import Classroom from app.models.reservation import Reservation, ReservationStatus +from app.models.genetic_algorithm import ReservationOptimizer optimizer_router = APIRouter(prefix="/api/v1/optimizer", tags=["Optimizer"]) genetic_router = APIRouter(prefix="/api/genetic", tags=["Genetic Heuristics"]) @@ -129,3 +136,121 @@ def get_genetic_algorithm_status(current_user: User = Depends(get_current_user)) ] } } + + +@genetic_router.post("/preview-optimization") +def preview_genetic_optimization( + dto: GeneticPreviewRequestDTO, + current_user: User = Depends(get_current_user) +): + """Previsualiza los resultados de la optimización genética para comisiones seleccionadas.""" + commissions = Commission.query.filter( + Commission.id.in_(dto.commission_ids), + Commission.active == True + ).all() + + if not commissions: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail="No se encontraron comisiones activas con los IDs proporcionados." + ) + + commission_details = [] + for commission in commissions: + commission_details.append({ + 'id': commission.id, + 'code': commission.get_full_code(), + 'name': commission.subject.name if commission.subject else 'Sin Asignatura', + 'current_students': getattr(commission, 'current_students', 0) or 0, + 'max_students': commission.max_students or 30 + }) + + try: + # Previsualización rápida con población y generaciones reducidas para respuesta inmediata + optimizer = ReservationOptimizer(population_size=20, generations=25, workers=2) + opt_result = optimizer.optimize_schedule( + commission_ids=dto.commission_ids, + admin_user_id=int(getattr(current_user, 'id')) + ) + return { + 'success': True, + 'data': { + 'commission_details': commission_details, + 'optimization_result': { + 'assigned_reservations': opt_result.get('assigned_reservations', 0), + 'fitness_score': opt_result.get('fitness_score', 0.0), + 'conflicts': opt_result.get('conflicts', []), + 'total_requests': opt_result.get('total_requests', len(commissions)) + } + } + } + except Exception as ex: + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Error durante la previsualización: {str(ex)}" + ) + + +@genetic_router.post("/optimize") +def run_genetic_optimization( + dto: GeneticOptimizeRequestDTO, + current_user: User = Depends(get_current_user) +): + """Ejecuta la optimización heurística completa y genera el plan de reservas propuesto.""" + commissions = Commission.query.filter( + Commission.id.in_(dto.commission_ids), + Commission.active == True + ).all() + + if not commissions: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail="No se encontraron comisiones activas con los IDs proporcionados." + ) + + try: + optimizer = ReservationOptimizer(population_size=40, generations=60, workers=4) + opt_result = optimizer.optimize_schedule( + commission_ids=dto.commission_ids, + admin_user_id=int(getattr(current_user, 'id')), + start_date=dto.start_date, + end_date=dto.end_date + ) + return { + 'success': True, + 'data': opt_result + } + except Exception as ex: + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Error durante la optimización: {str(ex)}" + ) + + +@genetic_router.post("/apply-optimization") +def apply_genetic_optimization( + dto: GeneticApplyRequestDTO, + current_user: User = Depends(get_current_user) +): + """Aplica y persiste las reservas optimizadas en la base de datos de Bedelía.""" + try: + current_user_id = int(getattr(current_user, 'id')) + for res in dto.reservations: + if not res.get('user_id'): + res['user_id'] = current_user_id + + optimizer = ReservationOptimizer() + applied = optimizer.apply_optimized_reservations(dto.reservations) + return { + 'success': True, + 'data': { + 'applied_count': len(applied), + 'reservations': [r.to_dict() for r in applied] + } + } + except Exception as ex: + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Error al aplicar reservas optimizadas: {str(ex)}" + ) + diff --git a/backend/setup.py b/backend/setup.py index 3a50bf0..3f67066 100644 --- a/backend/setup.py +++ b/backend/setup.py @@ -2,7 +2,7 @@ from setuptools import setup, find_packages setup( name="edu-space-admin", - version="3.8.8", + version="3.8.9", description="Administrative interface for Edu-Space Classroom Management System (FastAPI ASGI Core)", author="Edu-Space Development Team", author_email="admin@edu-space.com", diff --git a/backend/tests/test_genetic_endpoints.py b/backend/tests/test_genetic_endpoints.py new file mode 100644 index 0000000..ec23b6a --- /dev/null +++ b/backend/tests/test_genetic_endpoints.py @@ -0,0 +1,154 @@ +""" +Test suite validating FastAPI /api/genetic Heuristic Optimization endpoints. +Tests preview-optimization, optimize, apply-optimization, commissions, and algorithm-status. +""" +from datetime import datetime, timedelta, timezone +from fastapi.testclient import TestClient +from werkzeug.security import generate_password_hash + +from main import app +from app import db +from app.models.user import User +from app.models.classroom import Classroom +from app.models.subject import Subject, Commission +from app.models.reservation import Reservation, ReservationStatus +from app.services.jwt_service import JWTService + + +def test_genetic_endpoints_full_lifecycle(init_database): + client = TestClient(app) + + # 1. Crear usuario Administrador + admin_user = User( + email="bedelia.admin@unicaba.edu.ar", + name="Admin Bedelia", + password_hash=generate_password_hash("AdminPass123!"), + role="ADMIN", + is_active=True + ) + init_database.session.add(admin_user) + init_database.session.commit() + + token = JWTService.create_access_token(admin_user) + headers = {"Authorization": f"Bearer {token}"} + + # 2. Crear aulas de prueba + room1 = Classroom( + code="AULA-101", + building="Central", + capacity=40, + is_active=True + ) + room2 = Classroom( + code="AULA-102", + building="Anexo", + capacity=50, + is_active=True + ) + init_database.session.add_all([room1, room2]) + init_database.session.commit() + + # 3. Crear Asignatura y Comisión activa + subject = Subject( + code="INF-2026", + name="Algoritmos y Estructuras", + credits=4, + is_active=True + ) + init_database.session.add(subject) + init_database.session.commit() + + commission = Commission( + subject_id=subject.id, + code="COM-1A", + semester="1C", + year=2026, + shift="Noche", + schedule="Lunes 18:30 a 22:30", + max_students=35, + current_students=28, + active=True + ) + init_database.session.add(commission) + init_database.session.commit() + + comm_id = commission.id + + # 4. Probar GET /api/genetic/commissions + comm_res = client.get("/api/genetic/commissions", headers=headers) + assert comm_res.status_code == 200 + comm_data = comm_res.json() + assert comm_data["success"] is True + assert len(comm_data["commissions"]) >= 1 + assert any(c["id"] == comm_id for c in comm_data["commissions"]) + + # 5. Probar GET /api/genetic/algorithm-status + status_res = client.get("/api/genetic/algorithm-status", headers=headers) + assert status_res.status_code == 200 + status_data = status_res.json() + assert status_data["success"] is True + assert "system_status" in status_data["data"] + assert status_data["data"]["system_status"]["available_classrooms"] >= 2 + + # 6. Probar POST /api/genetic/preview-optimization con comisión válida + preview_res = client.post( + "/api/genetic/preview-optimization", + headers=headers, + json={"commission_ids": [comm_id], "dry_run": True} + ) + assert preview_res.status_code == 200 + preview_data = preview_res.json() + assert preview_data["success"] is True + assert "data" in preview_data + assert "commission_details" in preview_data["data"] + assert len(preview_data["data"]["commission_details"]) == 1 + assert preview_data["data"]["commission_details"][0]["id"] == comm_id + assert "optimization_result" in preview_data["data"] + opt_res = preview_data["data"]["optimization_result"] + assert "assigned_reservations" in opt_res + assert "fitness_score" in opt_res + + # 7. Probar POST /api/genetic/preview-optimization con comisión inexistente -> 404 + err_res = client.post( + "/api/genetic/preview-optimization", + headers=headers, + json={"commission_ids": [99999], "dry_run": True} + ) + assert err_res.status_code == 404 + + # 8. Probar POST /api/genetic/optimize + now = datetime.now(timezone.utc).replace(tzinfo=None) + optimize_res = client.post( + "/api/genetic/optimize", + headers=headers, + json={ + "commission_ids": [comm_id], + "start_date": now.isoformat(), + "end_date": (now + timedelta(days=30)).isoformat() + } + ) + assert optimize_res.status_code == 200 + opt_payload = optimize_res.json() + assert opt_payload["success"] is True + data = opt_payload["data"] + assert "reservations" in data + assert len(data["reservations"]) >= 1 + + generated_reservations = data["reservations"] + + # 9. Probar POST /api/genetic/apply-optimization + apply_res = client.post( + "/api/genetic/apply-optimization", + headers=headers, + json={"reservations": generated_reservations} + ) + assert apply_res.status_code == 200 + apply_payload = apply_res.json() + assert apply_payload["success"] is True + assert apply_payload["data"]["applied_count"] >= 1 + assert len(apply_payload["data"]["reservations"]) >= 1 + + # Verificar que las reservas persistieron en la BD como CONFIRMED + saved_res = Reservation.query.filter_by(commission_id=comm_id).first() + assert saved_res is not None + assert saved_res.status == ReservationStatus.CONFIRMED.value diff --git a/frontend/package.json b/frontend/package.json index b1fad56..4d9a829 100644 --- a/frontend/package.json +++ b/frontend/package.json @@ -1,6 +1,6 @@ { "name": "frontend", - "version": "3.8.8", + "version": "3.8.9", "description": "", "main": "index.js", "scripts": { diff --git a/frontend/src/app.js b/frontend/src/app.js index 13e0664..bfa391b 100644 --- a/frontend/src/app.js +++ b/frontend/src/app.js @@ -86,9 +86,9 @@ const env = nunjucks.configure(path.join(__dirname, '../views'), { }); // Versiones institucionales del sistema -const APP_VERSION = '3.8.8'; -const FRONTEND_VERSION = '3.8.8'; -const BACKEND_VERSION = '3.8.8'; +const APP_VERSION = '3.8.9'; +const FRONTEND_VERSION = '3.8.9'; +const BACKEND_VERSION = '3.8.9'; env.addGlobal('app_version', APP_VERSION); env.addGlobal('frontend_version', FRONTEND_VERSION); @@ -312,7 +312,7 @@ const buildingsRoutes = require('./routes/buildings'); const adminRoutes = require('./routes/admin'); const mySubjectsRoutes = require('./routes/my_subjects'); -// Proxy transparente hacia la API REST de Flask para llamadas AJAX frontend +// Proxy transparente hacia la API REST de FastAPI para llamadas AJAX frontend app.use('/api/v1', async (req, res) => { try { const token = req.cookies.auth_token; @@ -338,6 +338,34 @@ app.use('/api/v1', async (req, res) => { } }); +// Proxy transparente hacia la API del Optimizador Genético (/api/genetic) +app.use('/api/genetic', async (req, res) => { + try { + const token = req.cookies.auth_token; + const backendBase = (process.env.FLASK_API_URL || 'http://localhost:5000/api/v1').replace(/\/api\/v1\/?$/, ''); + const targetUrl = `${backendBase}/api/genetic${req.url}`; + const headers = { ...req.headers }; + delete headers.host; + delete headers['content-length']; + if (token && !headers.authorization) { + headers.authorization = `Bearer ${token}`; + } + const resp = await axios({ + method: req.method, + url: targetUrl, + data: req.body, + params: req.query, + headers, + validateStatus: () => true + }); + return res.status(resp.status).json(resp.data); + } catch (err) { + console.error('API genetic proxy error:', err.message); + return res.status(500).json({ error: 'ProxyError', message: 'Error de comunicación con el optimizador genético: ' + err.message }); + } +}); + + app.use('/', indexRoutes); app.use('/auth', authRoutes); app.use('/adm', admRoutes);