routers/api.py

from fastapi import APIRouter, Depends, HTTPException
from typing import List
from sqlalchemy.orm import Session
from models.schema import (
    Becas,
    BecasCreate,
    SearchBecas,
    Estudiantes,
    EstudiantesCreate,
    SearchEstudiantes,
    Profesores,
    ProfesoresCreate,
    SearchProfesores,
    Cursos,
    CursosCreate,
    SearchCursos,
    Horarios,
    HorariosCreate,
    SearchHorarios,
    Evaluaciones,
    EvaluacionesCreate,
    SearchEvaluaciones,
)
from database.database import Base, SessionLocal, engine
from models.schema import (
    Becas as DBBecas,
    Estudiantes as DBEstudiantes,
    Profesores as DBProfesores,
    Cursos as DBCursos,
    Horarios as DBHorarios,
    Evaluaciones as DBEvaluaciones,
)

router = APIRouter(
    prefix="/api",
    tags=["Academia_Stephen_Hawking_API"],
    responses={404: {"description": "No encontrado"}},
)

# Inicializar la base de datos
Base.metadata.create_all(bind=engine)


# Función auxiliar para obtener una sesión de la base de datos
def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()


# Becas
@router.get("/becas/", response_model=List[Becas])
def get_becas(db: Session = Depends(get_db)):
    return db.query(DBBecas).all()


@router.post("/becas/", response_model=Becas)
def create_beca(beca: BecasCreate, db: Session = Depends(get_db)):
    db_beca = DBBecas(**beca.dict())
    db.add(db_beca)
    db.commit()
    db.refresh(db_beca)
    return db_beca


@router.get("/becas/search/", response_model=List[Becas])
def search_becas(beca: SearchBecas, db: Session = Depends(get_db)):
    query = db.query(DBBecas)
    if beca.nombre_beca:
        query = query.filter(DBBecas.Nombre_Beca.contains(beca.nombre_beca))
    return query.all()


# Estudiantes
@router.get("/estudiantes/", response_model=List[Estudiantes])
def get_estudiantes(db: Session = Depends(get_db)):
    return db.query(DBEstudiantes).all()


@router.post("/estudiantes/", response_model=Estudiantes)
def create_estudiante(estudiante: EstudiantesCreate, db: Session = Depends(get_db)):
    db_estudiante = DBEstudiantes(**estudiante.dict())
    db.add(db_estudiante)
    db.commit()
    db.refresh(db_estudiante)
    return db_estudiante


@router.get("/estudiantes/search/", response_model=List[Estudiantes])
def search_estudiantes(estudiante: SearchEstudiantes, db: Session = Depends(get_db)):
    query = db.query(DBEstudiantes)
    if estudiante.nombre:
        query = query.filter(DBEstudiantes.Nombre.contains(estudiante.nombre))
    if estudiante.apellido:
        query = query.filter(DBEstudiantes.Apellido.contains(estudiante.apellido))
    return query.all()


# Profesores
@router.get("/profesores/", response_model=List[Profesores])
def get_profesores(db: Session = Depends(get_db)):
    return db.query(DBProfesores).all()


@router.post("/profesores/", response_model=Profesores)
def create_profesor(profesor: ProfesoresCreate, db: Session = Depends(get_db)):
    db_profesor = DBProfesores(**profesor.dict())
    db.add(db_profesor)
    db.commit()
    db.refresh(db_profesor)
    return db_profesor


@router.get("/profesores/search/", response_model=List[Profesores])
def search_profesores(profesor: SearchProfesores, db: Session = Depends(get_db)):
    query = db.query(DBProfesores)
    if profesor.nombre:
        query = query.filter(DBProfesores.Nombre.contains(profesor.nombre))
    if profesor.apellido:
        query = query.filter(DBProfesores.Apellido.contains(profesor.apellido))
    return query.all()


# Cursos
@router.get("/cursos/", response_model=List[Cursos])
def get_cursos(db: Session = Depends(get_db)):
    return db.query(DBCursos).all()


@router.post("/cursos/", response_model=Cursos)
def create_curso(curso: CursosCreate, db: Session = Depends(get_db)):
    db_curso = DBCursos(**curso.dict())
    db.add(db_curso)
    db.commit()
    db.refresh(db_curso)
    return db_curso


@router.get("/cursos/search/", response_model=List[Cursos])
def search_cursos(curso: SearchCursos, db: Session = Depends(get_db)):
    query = db.query(DBCursos)
    if curso.nombre_curso:
        query = query.filter(DBCursos.Nombre_Curso.contains(curso.nombre_curso))
    return query.all()


# Horarios
@router.get("/horarios/", response_model=List[Horarios])
def get_horarios(db: Session = Depends(get_db)):
    return db.query(DBHorarios).all()


@router.post("/horarios/", response_model=Horarios)
def create_horario(horario: HorariosCreate, db: Session = Depends(get_db)):
    db_horario = DBHorarios(**horario.dict())
    db.add(db_horario)
    db.commit()
    db.refresh(db_horario)
    return db_horario


@router.get("/horarios/search/", response_model=List[Horarios])
def search_horarios(horario: SearchHorarios, db: Session = Depends(get_db)):
    query = db.query(DBHorarios)
    if horario.dia:
        query = query.filter(DBHorarios.Día.contains(horario.dia))
    return query.all()


# Evaluaciones
@router.get("/evaluaciones/", response_model=List[Evaluaciones])
def get_evaluaciones(db: Session = Depends(get_db)):
    return db.query(DBEvaluaciones).all()


@router.post("/evaluaciones/", response_model=Evaluaciones)
def create_evaluacion(evaluacion: EvaluacionesCreate, db: Session = Depends(get_db)):
    db_evaluacion = DBEvaluaciones(**evaluacion.dict())
    db.add(db_evaluacion)
    db.commit()
    db.refresh(db_evaluacion)
    return db_evaluacion


@router.get("/evaluaciones/search/", response_model=List[Evaluaciones])
def search_evaluaciones(evaluacion: SearchEvaluaciones, db: Session = Depends(get_db)):
    query = db.query(DBEvaluaciones)
    if evaluacion.id_estudiante:
        query = query.filter(DBEvaluaciones.ID_Estudiante == evaluacion.id_estudiante)
    if evaluacion.id_curso:
        query = query.filter(DBEvaluaciones.ID_Curso == evaluacion.id_curso)
    return query.all()