from contextlib import asynccontextmanager from typing import Optional, List, Dict, Any from fastapi import FastAPI, APIRouter, Depends, HTTPException, Query from pydantic import BaseModel, Field from app.config import get_tunis_now_iso from app.db import ( init_db, list_categories, add_category, update_category, delete_category, list_regles, get_regle, add_regle, update_regle, delete_regle, get_classement, list_classements, set_traite ) from app.classifier import ( classify_mail, manual_classify_and_propose, confirm_and_apply_rule ) from app.mirror_client import MirrorClient from app.auth import verify_cf_access_jwt # --- Schémas Pydantic --- class CategoryCreate(BaseModel): name: str = Field(..., min_length=1, max_length=100) class CategoryUpdate(BaseModel): name: str = Field(..., min_length=1, max_length=100) class RegleCreate(BaseModel): categorie: str = Field(..., min_length=1) expediteur: Optional[str] = None mot_cle: Optional[str] = None etiquette_miroir: Optional[str] = None statut: str = "active" class RegleUpdate(BaseModel): categorie: Optional[str] = None expediteur: Optional[str] = None mot_cle: Optional[str] = None etiquette_miroir: Optional[str] = None statut: Optional[str] = None class ClassementManualRequest(BaseModel): categorie: str = Field(..., min_length=1) traite: Optional[bool] = None mail_info: Optional[Dict[str, Any]] = None class TraiteRequest(BaseModel): traite: bool # --- Lifespan --- @asynccontextmanager async def lifespan(app: FastAPI): # Démarrage : initialisation de la base SQLite init_db() yield app = FastAPI( title="Courrier API", description="Socle et tri du jour par règles de l'application Courrier", version="1.0.0", lifespan=lifespan ) # Route de santé publique sans authentification @app.get("/health") def health(): return { "status": "healthy", "service": "courrier", "horodatage": get_tunis_now_iso() } # Router sécurisé par jeton Cloudflare Access api = APIRouter(prefix="/api/v1", dependencies=[Depends(verify_cf_access_jwt)]) mirror_client = MirrorClient() # --- Mails du jour et tri --- @api.get("/mails") def get_mails_du_jour(date: Optional[str] = None, n: int = 50): """ Récupère les mails d'un jour donné depuis le miroir et applique les règles de tri. Ne modifie jamais un classement manuel existant. """ target_date = date or get_tunis_now_iso()[:10] try: mails = mirror_client.get_mails_for_day(target_date, max_items=n) except Exception as e: # En cas d'indisponibilité momentanée du miroir, renvoyer les classements en base classements = list_classements(date_prefix=target_date) return { "date": target_date, "count": len(classements), "mails": classements, "miroir_erreur": str(e) } classified_results = [] for m in mails: c = classify_mail(m) classified_results.append({ "message_id": m["message_id"], "date": m.get("date"), "expediteur": m.get("expediteur"), "objet": m.get("objet"), "etiquettes": m.get("etiquettes", []), "classement": c }) return { "date": target_date, "count": len(classified_results), "mails": classified_results } # --- Classements --- @api.get("/classements") def get_classements( date: Optional[str] = None, categorie: Optional[str] = None, traite: Optional[bool] = None ): """Liste tous les classements enregistrés en base.""" items = list_classements(date_prefix=date, categorie=categorie, traite=traite) return {"count": len(items), "classements": items} @api.get("/classements/{message_id}") def get_single_classement(message_id: str): """Récupère le classement d'un email particulier.""" c = get_classement(message_id) if not c: raise HTTPException(status_code=404, detail="Classement introuvable") return c @api.post("/classements/{message_id}") def classer_manuellement(message_id: str, req: ClassementManualRequest): """ Classement manuel ou correction. Propose automatiquement une règle d'après l'expéditeur et les mots-clés, qui ne s'appliquera qu'une fois confirmée. """ classement, regle_proposee = manual_classify_and_propose( message_id=message_id, new_category=req.categorie, mail_info=req.mail_info, traite=req.traite ) return { "classement": classement, "regle_proposee": regle_proposee } @api.patch("/classements/{message_id}/traite") def modifier_statut_traite(message_id: str, req: TraiteRequest): """Coche ou décoche la case 'traité' pour un mail.""" res = set_traite(message_id, req.traite) if not res: raise HTTPException(status_code=404, detail="Classement introuvable") return res # --- CRUD Catégories --- @api.get("/categories") def list_cats(): """Liste les catégories disponibles.""" return {"categories": list_categories()} @api.post("/categories", status_code=201) def create_cat(req: CategoryCreate): """Ajoute une nouvelle catégorie.""" try: return add_category(req.name) except Exception as e: raise HTTPException(status_code=400, detail=str(e)) @api.put("/categories/{cat_id}") def edit_cat(cat_id: int, req: CategoryUpdate): """Met à jour le nom d'une catégorie.""" res = update_category(cat_id, req.name) if not res: raise HTTPException(status_code=404, detail="Catégorie introuvable") return res @api.delete("/categories/{cat_id}") def remove_cat(cat_id: int): """Supprime une catégorie.""" ok = delete_category(cat_id) if not ok: raise HTTPException(status_code=404, detail="Catégorie introuvable") return {"success": True} # --- CRUD Règles --- @api.get("/regles") def get_rules(statut: Optional[str] = None): """Liste les règles (filtrable par statut: active ou proposee).""" return {"regles": list_regles(statut=statut)} @api.post("/regles", status_code=201) def create_rule(req: RegleCreate): """Crée une nouvelle règle.""" return add_regle( categorie=req.categorie, expediteur=req.expediteur, mot_cle=req.mot_cle, etiquette_miroir=req.etiquette_miroir, statut=req.statut ) @api.put("/regles/{regle_id}") def edit_rule(regle_id: int, req: RegleUpdate): """Met à jour une règle existante.""" res = update_regle( regle_id=regle_id, categorie=req.categorie, expediteur=req.expediteur, mot_cle=req.mot_cle, etiquette_miroir=req.etiquette_miroir, statut=req.statut ) if not res: raise HTTPException(status_code=404, detail="Règle introuvable") return res @api.delete("/regles/{regle_id}") def remove_rule(regle_id: int): """Supprime une règle.""" ok = delete_regle(regle_id) if not ok: raise HTTPException(status_code=404, detail="Règle introuvable") return {"success": True} @api.post("/regles/{regle_id}/confirmer") def confirm_rule_endpoint(regle_id: int): """ Confirme une règle proposée : la passe en active et l'applique à tous les mails non-manuels. """ res = confirm_and_apply_rule(regle_id) if not res: raise HTTPException(status_code=404, detail="Règle introuvable") return { "success": True, "regle": res, "message": "Règle confirmée et appliquée aux classements automatiques." } app.include_router(api)