128 lines
4.3 KiB
Python
128 lines
4.3 KiB
Python
"""Routes M2 — Présences en réunion d'affaires."""
|
|
from fastapi import APIRouter, Depends, HTTPException
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
from sqlalchemy import select, desc
|
|
|
|
from app.core.database import get_db
|
|
from app.core.security import get_current_membre
|
|
from app.models.reunion import Reunion
|
|
from app.models.presence import Presence
|
|
from app.models.membre import Membre
|
|
from app.models.affectation import Affectation
|
|
from app.models.poste import Poste
|
|
from app.schemas.phase4 import (
|
|
PresencesBatch, PresenceOut, ReunionAffairesCreate, ReunionAffairesOut,
|
|
)
|
|
|
|
router = APIRouter(prefix="/presences", tags=["M2 — Présences affaires"])
|
|
|
|
|
|
async def require_secretaire(membre=Depends(get_current_membre), db=Depends(get_db)):
|
|
"""Vérifie que le membre est secrétaire ou exécutif."""
|
|
result = await db.execute(
|
|
select(Affectation).join(Poste).where(
|
|
Affectation.membre_id == membre.id,
|
|
Affectation.statut == "actif",
|
|
(Poste.nom.ilike("%secrétaire%") | (Poste.categorie == "executif")),
|
|
)
|
|
)
|
|
if not result.scalar_one_or_none():
|
|
raise HTTPException(status_code=403, detail="Réservé au secrétaire ou à l'exécutif")
|
|
return membre
|
|
|
|
|
|
@router.post("/reunion", response_model=ReunionAffairesOut)
|
|
async def creer_reunion_affaires(
|
|
req: ReunionAffairesCreate,
|
|
membre=Depends(require_secretaire),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
"""Créer une réunion d'affaires (point de départ pour présences et PV)."""
|
|
reunion = Reunion(
|
|
groupe_id=membre.groupe_id,
|
|
type="affaires",
|
|
date_reunion=req.date_reunion,
|
|
note=req.note,
|
|
)
|
|
db.add(reunion)
|
|
await db.flush()
|
|
return ReunionAffairesOut(id=reunion.id, date_reunion=reunion.date_reunion, note=reunion.note)
|
|
|
|
|
|
@router.get("/reunions", response_model=list[ReunionAffairesOut])
|
|
async def liste_reunions_affaires(
|
|
limite: int = 12,
|
|
membre=Depends(get_current_membre),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
"""Lister les réunions d'affaires récentes avec leurs présences."""
|
|
result = await db.execute(
|
|
select(Reunion).where(
|
|
Reunion.groupe_id == membre.groupe_id,
|
|
Reunion.type == "affaires",
|
|
).order_by(desc(Reunion.date_reunion)).limit(limite)
|
|
)
|
|
reunions = result.scalars().all()
|
|
|
|
out = []
|
|
for r in reunions:
|
|
pres_result = await db.execute(
|
|
select(Presence).where(Presence.reunion_id == r.id)
|
|
)
|
|
presences = pres_result.scalars().all()
|
|
pres_out = []
|
|
for p in presences:
|
|
mbr = await db.get(Membre, p.membre_id)
|
|
pres_out.append(PresenceOut(
|
|
membre_id=p.membre_id,
|
|
membre_prenom=mbr.prenom if mbr else "?",
|
|
present=p.present,
|
|
))
|
|
out.append(ReunionAffairesOut(
|
|
id=r.id, date_reunion=r.date_reunion, note=r.note, presences=pres_out,
|
|
))
|
|
return out
|
|
|
|
|
|
@router.post("/", response_model=list[PresenceOut])
|
|
async def enregistrer_presences(
|
|
req: PresencesBatch,
|
|
membre=Depends(require_secretaire),
|
|
db: AsyncSession = Depends(get_db),
|
|
):
|
|
"""M2 — Enregistrer les présences pour une réunion d'affaires."""
|
|
# Vérifier que la réunion existe et est de type affaires
|
|
result = await db.execute(
|
|
select(Reunion).where(
|
|
Reunion.id == req.reunion_id,
|
|
Reunion.groupe_id == membre.groupe_id,
|
|
)
|
|
)
|
|
reunion = result.scalar_one_or_none()
|
|
if not reunion:
|
|
raise HTTPException(status_code=404, detail="Réunion introuvable")
|
|
|
|
# Supprimer les présences existantes pour cette réunion (pour pouvoir re-saisir)
|
|
existing = await db.execute(
|
|
select(Presence).where(Presence.reunion_id == req.reunion_id)
|
|
)
|
|
for p in existing.scalars().all():
|
|
await db.delete(p)
|
|
|
|
# Insérer les nouvelles
|
|
out = []
|
|
for item in req.presences:
|
|
pres = Presence(
|
|
reunion_id=req.reunion_id,
|
|
membre_id=item.membre_id,
|
|
present=item.present,
|
|
)
|
|
db.add(pres)
|
|
mbr = await db.get(Membre, item.membre_id)
|
|
out.append(PresenceOut(
|
|
membre_id=item.membre_id,
|
|
membre_prenom=mbr.prenom if mbr else "?",
|
|
present=item.present,
|
|
))
|
|
await db.flush()
|
|
return out
|