Files

298 lines
11 KiB
Python

from datetime import date
from typing import Optional, List
from fastapi import APIRouter, Depends, HTTPException, Query, status
from sqlalchemy import or_
from app import db
from app.models.institutional_benefit import InstitutionalBenefit
from app.models.building import Building
from app.models.user import User
from app.services.audit_service import AuditService
from dependencies import get_current_user, get_optional_current_user, require_roles
from schemas.benefit_dto import (
BenefitCreateDTO,
BenefitUpdateDTO,
BenefitResponseDTO,
BenefitListResponseDTO
)
router = APIRouter(prefix="/api/v1/benefits", tags=["Benefits & Convenios"])
def _to_response_dto(benefit: InstitutionalBenefit) -> BenefitResponseDTO:
"""Convierte una entidad InstitutionalBenefit a BenefitResponseDTO."""
return BenefitResponseDTO(
id=benefit.id,
title=benefit.title,
partner_name=benefit.partner_name,
category=benefit.category,
discount_label=benefit.discount_label,
description=benefit.description,
terms_conditions=benefit.terms_conditions,
target_roles=benefit.target_roles,
building_id=benefit.building_id,
building_name=benefit.building.name if benefit.building else "Todas las Sedes",
coupon_code=benefit.coupon_code,
valid_from=benefit.valid_from,
valid_until=benefit.valid_until,
is_active=benefit.is_active,
is_currently_valid=benefit.is_currently_valid,
image_url=benefit.image_url,
created_by_user_id=benefit.created_by_user_id,
created_at=benefit.created_at,
updated_at=benefit.updated_at
)
@router.get("", response_model=BenefitListResponseDTO)
@router.get("/", response_model=BenefitListResponseDTO)
def list_benefits(
role: Optional[str] = Query(None, description="Filtrar por rol destino: alumno, docente, bedelia"),
category: Optional[str] = Query(None, description="Filtrar por categoría (ej: GASTRONOMIA, LIBRERIA)"),
building_id: Optional[int] = Query(None, description="Filtrar por sede específica"),
active_only: bool = Query(True, description="Si es True, sólo retorna beneficios activos y vigentes"),
search: Optional[str] = Query(None, description="Búsqueda textual en título, comercio o descripción"),
current_user: Optional[User] = Depends(get_optional_current_user)
):
"""
Lista el catálogo de convenios institucionales y promociones disponibles.
Permite filtrar por categoría, rol objetivo, sede y búsqueda textual.
"""
query = InstitutionalBenefit.query
# Si se pide active_only o si el usuario no es admin/bedelía, se muestran sólo activos
is_staff = current_user and (current_user.role or "").upper() in ["ADMIN", "BEDELIA"]
if active_only or not is_staff:
today = date.today()
query = query.filter(
InstitutionalBenefit.is_active.is_(True),
InstitutionalBenefit.valid_from <= today,
or_(
InstitutionalBenefit.valid_until.is_(None),
InstitutionalBenefit.valid_until >= today
)
)
if category and category.strip():
query = query.filter(InstitutionalBenefit.category.ilike(category.strip()))
if building_id:
query = query.filter(
or_(
InstitutionalBenefit.building_id.is_(None),
InstitutionalBenefit.building_id == building_id
)
)
if search and search.strip():
term = f"%{search.strip()}%"
query = query.filter(
or_(
InstitutionalBenefit.title.ilike(term),
InstitutionalBenefit.partner_name.ilike(term),
InstitutionalBenefit.description.ilike(term),
InstitutionalBenefit.coupon_code.ilike(term)
)
)
all_benefits: List[InstitutionalBenefit] = query.order_by(InstitutionalBenefit.title.asc()).all()
# Filtrar por rol efectivo si se solicitó o si el usuario está autenticado
effective_role = role
if not effective_role and current_user and not is_staff:
effective_role = current_user.role
filtered_items = []
for b in all_benefits:
if effective_role and not b.applies_to_role(effective_role):
continue
filtered_items.append(_to_response_dto(b))
# Obtener categorías únicas presentes en la base
raw_cats = db.session.query(InstitutionalBenefit.category).distinct().all()
categories = sorted(list({c[0] for c in raw_cats if c[0]}))
return BenefitListResponseDTO(
total=len(filtered_items),
items=filtered_items,
categories=categories
)
@router.get("/{benefit_id}", response_model=BenefitResponseDTO)
def get_benefit_by_id(benefit_id: int):
"""Obtiene el detalle completo de un convenio por su identificador."""
benefit = InstitutionalBenefit.query.get(benefit_id)
if not benefit:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"Convenio con ID {benefit_id} no encontrado."
)
return _to_response_dto(benefit)
@router.post("", response_model=BenefitResponseDTO, status_code=status.HTTP_201_CREATED)
@router.post("/", response_model=BenefitResponseDTO, status_code=status.HTTP_201_CREATED)
def create_benefit(
payload: BenefitCreateDTO,
current_user: User = Depends(require_roles(["ADMIN", "BEDELIA"]))
):
"""
Crea un nuevo convenio o beneficio institucional.
Operación reservada para personal de Bedelía y Administradores.
"""
if payload.building_id:
b_exists = Building.query.get(payload.building_id)
if not b_exists:
raise HTTPException(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
detail=f"La sede con ID {payload.building_id} no existe."
)
if payload.valid_until and payload.valid_until < payload.valid_from:
raise HTTPException(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
detail="La fecha de vencimiento (valid_until) no puede ser anterior al inicio de vigencia."
)
benefit = InstitutionalBenefit(
title=payload.title.strip(),
partner_name=payload.partner_name.strip(),
category=(payload.category or "GENERAL").strip().upper(),
discount_label=payload.discount_label.strip(),
description=payload.description.strip() if payload.description else None,
terms_conditions=payload.terms_conditions.strip() if payload.terms_conditions else None,
target_roles=(payload.target_roles or "ALL").strip().upper(),
building_id=payload.building_id,
coupon_code=payload.coupon_code.strip() if payload.coupon_code else None,
valid_from=payload.valid_from,
valid_until=payload.valid_until,
is_active=payload.is_active,
image_url=payload.image_url.strip() if payload.image_url else None,
created_by_user_id=current_user.id
)
db.session.add(benefit)
db.session.commit()
# Registro de auditoría
AuditService.log(
user_id=current_user.id,
action="CREATE_BENEFIT",
module="institutional_benefit",
entity_id=benefit.id,
details={"title": benefit.title, "partner": benefit.partner_name, "discount": benefit.discount_label}
)
return _to_response_dto(benefit)
@router.put("/{benefit_id}", response_model=BenefitResponseDTO)
def update_benefit(
benefit_id: int,
payload: BenefitUpdateDTO,
current_user: User = Depends(require_roles(["ADMIN", "BEDELIA"]))
):
"""
Actualiza la información de un convenio existente.
Operación reservada para personal de Bedelía y Administradores.
"""
benefit = InstitutionalBenefit.query.get(benefit_id)
if not benefit:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"Convenio con ID {benefit_id} no encontrado."
)
data = payload.model_dump(exclude_unset=True)
if "building_id" in data and data["building_id"]:
b_exists = Building.query.get(data["building_id"])
if not b_exists:
raise HTTPException(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
detail=f"La sede con ID {data['building_id']} no existe."
)
new_from = data.get("valid_from", benefit.valid_from)
new_until = data.get("valid_until", benefit.valid_until)
if new_until and new_from and new_until < new_from:
raise HTTPException(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
detail="La fecha de vencimiento no puede ser anterior a la fecha de inicio."
)
for field, val in data.items():
if isinstance(val, str) and field in ["category", "target_roles"]:
setattr(benefit, field, val.strip().upper())
elif isinstance(val, str):
setattr(benefit, field, val.strip())
else:
setattr(benefit, field, val)
db.session.commit()
AuditService.log(
user_id=current_user.id,
action="UPDATE_BENEFIT",
module="institutional_benefit",
entity_id=benefit.id,
details={"title": benefit.title, "updated_fields": list(data.keys())}
)
return _to_response_dto(benefit)
@router.patch("/{benefit_id}/toggle-status", response_model=BenefitResponseDTO)
def toggle_benefit_status(
benefit_id: int,
current_user: User = Depends(require_roles(["ADMIN", "BEDELIA"]))
):
"""Activa o pausa la publicación de un convenio."""
benefit = InstitutionalBenefit.query.get(benefit_id)
if not benefit:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"Convenio con ID {benefit_id} no encontrado."
)
benefit.is_active = not benefit.is_active
db.session.commit()
AuditService.log(
user_id=current_user.id,
action="TOGGLE_BENEFIT_STATUS",
module="institutional_benefit",
entity_id=benefit.id,
details={"is_active": benefit.is_active}
)
return _to_response_dto(benefit)
@router.delete("/{benefit_id}", status_code=status.HTTP_204_NO_CONTENT)
def delete_benefit(
benefit_id: int,
current_user: User = Depends(require_roles(["ADMIN", "BEDELIA"]))
):
"""Elimina permanentemente un convenio."""
benefit = InstitutionalBenefit.query.get(benefit_id)
if not benefit:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"Convenio con ID {benefit_id} no encontrado."
)
AuditService.log(
user_id=current_user.id,
action="DELETE_BENEFIT",
module="institutional_benefit",
entity_id=benefit.id,
details={"title": benefit.title, "partner": benefit.partner_name}
)
db.session.delete(benefit)
db.session.commit()
return None