257 lines
9.3 KiB
Python
257 lines
9.3 KiB
Python
"""
|
|
FastAPI Optimizer & Genetic Algorithm Router (/api/v1/optimizer and /api/genetic)
|
|
Provides asynchronous optimization jobs and genetic heuristic room assignment.
|
|
100% Native FastAPI - Zero Flask dependencies.
|
|
"""
|
|
from typing import Optional, Dict, Any, List
|
|
from fastapi import APIRouter, Depends, HTTPException, Query, status
|
|
|
|
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"])
|
|
|
|
|
|
@optimizer_router.post("/jobs", status_code=status.HTTP_202_ACCEPTED)
|
|
def submit_optimization_job(
|
|
dto: OptimizerJobRequestDTO,
|
|
current_user: User = Depends(get_current_user)
|
|
):
|
|
"""Despacha un trabajo de optimización heurística asíncrono."""
|
|
job = OptimizerService.submit_job(
|
|
commission_ids=dto.commission_ids,
|
|
admin_user_id=int(getattr(current_user, 'id')),
|
|
start_date=dto.start_date,
|
|
end_date=dto.end_date,
|
|
generations=dto.generations,
|
|
population_size=dto.population_size,
|
|
workers=dto.workers
|
|
)
|
|
|
|
return {
|
|
'job_id': job.job_id,
|
|
'status': job.status.value,
|
|
'poll_url': f'/api/v1/optimizer/jobs/{job.job_id}',
|
|
'message': 'Trabajo de optimización puesto en cola con éxito.'
|
|
}
|
|
|
|
|
|
@optimizer_router.get("/jobs/{job_id}")
|
|
def get_optimization_job(
|
|
job_id: str,
|
|
current_user: User = Depends(get_current_user)
|
|
):
|
|
"""Obtiene el estado, progreso y resultados de un trabajo de optimización en cola."""
|
|
job = OptimizerService.get_job(job_id)
|
|
if not job:
|
|
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Trabajo de optimización {job_id} no encontrado.")
|
|
|
|
return job.to_dict()
|
|
|
|
|
|
@optimizer_router.get("/jobs")
|
|
def list_optimization_jobs(
|
|
limit: int = Query(20, ge=1, le=100),
|
|
current_user: User = Depends(get_current_user)
|
|
):
|
|
"""Lista los trabajos de optimización más recientes."""
|
|
jobs = OptimizerService.list_jobs(limit=limit)
|
|
return {'total': len(jobs), 'jobs': jobs}
|
|
|
|
|
|
@optimizer_router.post("/spring-boot/sync")
|
|
def sync_with_spring_boot(
|
|
dto: SpringBootSyncPayloadDTO,
|
|
current_user: User = Depends(get_current_user)
|
|
):
|
|
"""Endpoint interoperable para la sincronización con microservicios Spring Boot."""
|
|
try:
|
|
result = OptimizerService.sync_with_spring_boot(dto, admin_user_id=int(getattr(current_user, 'id')))
|
|
return result
|
|
except Exception as ex:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail={'requestId': dto.requestId, 'status': 'ERROR', 'error': str(ex)}
|
|
)
|
|
|
|
|
|
@genetic_router.get("/commissions")
|
|
def get_genetic_commissions(current_user: User = Depends(get_current_user)):
|
|
"""Retorna comisiones activas para el optimizador genético."""
|
|
commissions = Commission.query.filter_by(active=True).all()
|
|
commissions_data: List[Dict[str, Any]] = []
|
|
for commission in commissions:
|
|
commission_dict = commission.to_dict()
|
|
commission_dict['get_full_code'] = commission.get_full_code()
|
|
commission_dict['subject_name'] = commission.subject.name if commission.subject else 'Sin Asignatura'
|
|
commission_dict['subject_code'] = commission.subject.code if commission.subject else ''
|
|
commissions_data.append(commission_dict)
|
|
|
|
return {
|
|
'success': True,
|
|
'commissions': commissions_data
|
|
}
|
|
|
|
|
|
@genetic_router.get("/algorithm-status")
|
|
def get_genetic_algorithm_status(current_user: User = Depends(get_current_user)):
|
|
"""Retorna estado y capacidades de los algoritmos de optimización."""
|
|
total_classrooms = Classroom.query.filter_by(is_active=True).count()
|
|
total_commissions = Commission.query.filter_by(active=True).count()
|
|
total_reservations = Reservation.query.filter_by(status=ReservationStatus.CONFIRMED.value).count()
|
|
|
|
return {
|
|
'success': True,
|
|
'data': {
|
|
'algorithm_config': {
|
|
'population_size': 50,
|
|
'generations': 100,
|
|
'mutation_rate': 0.1,
|
|
'crossover_rate': 0.8
|
|
},
|
|
'system_status': {
|
|
'available_classrooms': total_classrooms,
|
|
'active_commissions': total_commissions,
|
|
'confirmed_reservations': total_reservations
|
|
},
|
|
'capabilities': [
|
|
'Automatic classroom assignment',
|
|
'Capacity optimization',
|
|
'Time conflict resolution',
|
|
'Resource matching',
|
|
'Batch reservation processing'
|
|
]
|
|
}
|
|
}
|
|
|
|
|
|
@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)}"
|
|
)
|
|
|