298 lines
11 KiB
Python
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
|