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