import base64 import os import re from contextlib import asynccontextmanager from urllib.parse import quote from typing import Optional, List, Dict, Any from pathlib import Path from fastapi import FastAPI, APIRouter, Depends, HTTPException, Query, Request from fastapi.responses import FileResponse, Response from fastapi.staticfiles import StaticFiles from pydantic import BaseModel, Field from app.config import get_tunis_now_iso, ENV 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, list_courses, cles_courses_vues, marquer_courses_vues, get_course, add_course, update_course, delete_course, SENS_COURSE, list_suivi_clos, clore_suivi, rouvrir_suivi ) from app.classifier import ( classify_mail, classify_batch, manual_classify_and_propose, confirm_and_apply_rule, reclassify_today_mails ) from app import asuivre from app.mirror_client import MirrorClient from app.ia import creer_routeur 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 et des règles par défaut init_db() # Reclassement des mails du jour après ajout des règles de départ try: reclassify_today_mails(mirror_client=mirror_client) except Exception: pass if ENV != "test": mirror_client.demarrer_rafraichissement() 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 ) # STATIC-060 : interface web (HTML et ressources statiques ; /api reste protégé par le jeton Access) STATIC_DIR = Path(__file__).parent / "static" CSP = ("default-src 'self'; script-src 'self'; style-src 'self'; img-src 'self' data:; font-src 'self'; " "connect-src 'self'; frame-ancestors 'none'; base-uri 'none'; form-action 'self'") ICONES = ["favicon.svg", "favicon.ico", "apple-touch-icon.png", "icon-192.png", "icon-512.png", "safari-pinned-tab.svg", "favicon-16.png", "favicon-32.png", "favicon-48.png"] @app.middleware("http") async def en_tetes_securite(request: Request, call_next): reponse = await call_next(request) reponse.headers["Content-Security-Policy"] = CSP reponse.headers["X-Content-Type-Options"] = "nosniff" reponse.headers["X-Frame-Options"] = "DENY" reponse.headers["Referrer-Policy"] = "no-referrer" if request.url.path == "/" or request.url.path.startswith("/api/"): reponse.headers["Cache-Control"] = "no-store" elif request.url.path.startswith("/static/") or request.url.path in ("/favicon.ico", "/apple-touch-icon.png"): reponse.headers["Cache-Control"] = "no-cache" return reponse @app.get("/", include_in_schema=False) def page_accueil(): return FileResponse(STATIC_DIR / "index.html", media_type="text/html; charset=utf-8") def _servir_icone(nom: str): def _f(): chemin = STATIC_DIR / "icons" / nom if not chemin.is_file(): raise HTTPException(status_code=404, detail="Icône introuvable") return FileResponse(chemin) return _f for _nom in ICONES: app.add_api_route("/" + _nom, _servir_icone(_nom), methods=["GET"], include_in_schema=False) app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static") # 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) } classes = {c["message_id"]: c for c in classify_batch(mails)} classified_results = [] for m in mails: c = classes.get(m.get("message_id")) if c is None: continue 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 } @api.get("/mails/periode") def get_mails_periode(jours: int = 7): """Mails des N derniers jours (1 à 30), classés, pour la vue par groupe. Lecture seule.""" from datetime import date as _date, timedelta jours = max(1, min(int(jours), 30)) fin = _date.fromisoformat(get_tunis_now_iso()[:10]) debut = (fin - timedelta(days=jours - 1)).isoformat() try: mails = mirror_client.get_mails_since(debut, max_items=min(150 * jours, 800)) except Exception as e: return {"debut": debut, "fin": fin.isoformat(), "count": 0, "mails": [], "miroir_erreur": str(e)} classes = {c["message_id"]: c for c in classify_batch(mails)} resultats = [] for m in mails: c = classes.get(m.get("message_id")) if c is None: continue resultats.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 {"debut": debut, "fin": fin.isoformat(), "count": len(resultats), "mails": resultats} # --- Lecture d'un mail (texte seul, lecture seule) --- MAX_CORPS_LECTURE = 200_000 MAX_PIECE = 25 * 1024 * 1024 # Extensions exécutables ou actives : jamais servies (le mail est un contenu non fiable). EXT_REFUSEES = {"exe", "msi", "bat", "cmd", "com", "scr", "pif", "vbs", "vbe", "js", "jse", "wsf", "wsh", "ps1", "psm1", "jar", "lnk", "hta", "cpl", "reg", "dll", "sys", "iso", "img", "html", "htm", "xhtml", "svg", "docm", "xlsm", "pptm", "dotm", "xlam", "appx", "apk", "sh", "py", "app", "dmg", "chm"} def _extension(nom: str) -> str: return nom.rsplit(".", 1)[-1].lower().strip() if "." in nom else "" def _nom_sur(nom: str) -> str: nom = re.sub(r"[\\/\x00-\x1f\x7f\"]", "_", nom.replace("\\", "/").split("/")[-1]).strip(" .") return (nom or "piece-jointe")[:150] def _entete(en_tetes: Dict[str, Any], nom: str) -> str: for k, v in (en_tetes or {}).items(): if str(k).lower() == nom.lower() and v: return str(v) return "" @api.get("/mail") def lire_mail(id: str = Query(..., min_length=1, max_length=400)): """Contenu d'un mail du miroir : en-têtes utiles, texte et liste des pièces jointes. Aucune écriture, aucun contenu de mail dans les journaux. Le miroir ne fournit pas de lien vers Outlook.""" try: res = mirror_client.get_mail(id) except Exception: raise HTTPException(status_code=502, detail="Lecture du mail impossible : miroir indisponible.") d = res.get("donnees") if isinstance(res, dict) else None if not isinstance(d, dict) or not d: raise HTTPException(status_code=404, detail="Mail introuvable.") eh = d.get("en_tetes") or {} corps = str(d.get("corps_texte") or "") pj = [] for p in d.get("pieces_jointes") or []: if isinstance(p, dict): pj.append({ "nom": str(p.get("filename") or p.get("nom") or "(sans nom)"), "type": str(p.get("content_type") or p.get("type") or ""), "taille": int(p.get("size") or p.get("taille") or 0), "bloquee": _extension(str(p.get("filename") or p.get("nom") or "")) in EXT_REFUSEES, }) return { "message_id": d.get("message_id") or id, "dossier": d.get("dossier"), "de": _entete(eh, "From"), "a": _entete(eh, "To"), "cc": _entete(eh, "Cc"), "date": _entete(eh, "Date"), "objet": _entete(eh, "Subject"), "corps": corps[:MAX_CORPS_LECTURE], "tronque": len(corps) > MAX_CORPS_LECTURE, "pieces_jointes": pj, "taille_octets": d.get("taille_octets"), } @api.get("/mail/piece") def telecharger_piece(id: str = Query(..., min_length=1, max_length=400), nom: str = Query(..., min_length=1, max_length=260)): """Télécharge une pièce jointe : toujours en téléchargement (jamais affichée), extensions actives refusées, plafond de taille, aucune écriture, aucun contenu dans les journaux.""" if _extension(nom) in EXT_REFUSEES: raise HTTPException(status_code=403, detail="Type de fichier bloqué par sécurité.") try: res = mirror_client.get_attachment(id, nom) except Exception: raise HTTPException(status_code=502, detail="Pièce jointe indisponible : miroir injoignable.") d = res.get("donnees") if isinstance(res, dict) else None b64 = d.get("contenu_base64") if isinstance(d, dict) else None if not b64: raise HTTPException(status_code=404, detail="Pièce jointe introuvable.") if len(b64) * 3 // 4 > MAX_PIECE or int(d.get("taille") or 0) > MAX_PIECE: raise HTTPException(status_code=413, detail="Pièce jointe trop volumineuse (25 Mo maximum).") try: brut = base64.b64decode(b64) except Exception: raise HTTPException(status_code=502, detail="Pièce jointe illisible.") propre = _nom_sur(nom) ascii_nom = propre.encode("ascii", "replace").decode().replace("?", "_") return Response(content=brut, media_type="application/octet-stream", headers={ "Content-Disposition": f"attachment; filename=\"{ascii_nom}\"; filename*=UTF-8''{quote(propre)}", "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff", }) # --- Recherche --- def _dossier_court(dossier: str) -> str: d = re.sub(r"^Boîte de réception(-00 \d{4})?-?", "", dossier or "") d = re.sub(r"^[^\w]+", "", d).strip() return d or ("Boîte de réception" if (dossier or "").startswith("Boîte de réception") else (dossier or "")) @api.get("/recherche") def rechercher_mails(q: str = Query(..., min_length=2, max_length=100), depuis: Optional[str] = Query(None, pattern=r"^\d{4}-\d{2}-\d{2}$"), jusqu_a: Optional[str] = Query(None, pattern=r"^\d{4}-\d{2}-\d{2}$"), n: int = Query(100, ge=1, le=100)): """Recherche plein texte dans tout le miroir (insensible à la casse et aux accents). Lecture seule ; la requête n'est jamais écrite dans les journaux.""" from datetime import date, timedelta terme = re.sub(r"[\x00-\x1f\x7f]", " ", q).strip() if len(terme) < 2: raise HTTPException(status_code=422, detail="Saisissez au moins 2 caractères.") jusque = None if jusqu_a: try: jusque = (date.fromisoformat(jusqu_a) + timedelta(days=1)).isoformat() except ValueError: raise HTTPException(status_code=422, detail="Date de fin invalide.") try: brut = mirror_client.rechercher(terme, depuis, jusque, n) except Exception: raise HTTPException(status_code=502, detail="Recherche impossible : miroir indisponible.") res = [] for r in brut: res.append({ "message_id": r.get("message_id"), "date": r.get("date_reception") or r.get("date") or "", "expediteur": r.get("expediteur") or "", "objet": r.get("sujet") or r.get("titre") or r.get("objet_original") or "", "dossier": _dossier_court(r.get("dossier") or ""), "pj": bool(r.get("has_attachments")), "etiquettes": r.get("etiquettes") or [], }) res.sort(key=lambda x: x["date"], reverse=True) return {"total": len(res), "plafond": len(res) >= n, "resultats": res} # --- Suivi des demandes --- MON_ADRESSE = os.environ.get("MON_ADRESSE", "nabil.derouiche@") class SuiviClore(BaseModel): cle: str = Field(..., min_length=1, max_length=400) dernier_id: str = Field(..., min_length=1, max_length=400) class SuiviRouvrir(BaseModel): cle: str = Field(..., min_length=1, max_length=400) @api.get("/suivi") def lire_suivi(jours: int = Query(14, ge=1, le=60)): """Suivi des demandes par fil de discussion : en attente de réponse, réponses reçues, demandes à traiter.""" from datetime import datetime, timedelta from zoneinfo import ZoneInfo from app.suivi import calculer_suivi maintenant = datetime.now(ZoneInfo("Africa/Tunis")) debut = (maintenant - timedelta(days=jours)).strftime("%Y-%m-%d") try: recus = mirror_client.get_mails_since(debut, max_items=800) tous_envoyes = mirror_client.get_sent_mails() envoyes = [m for m in tous_envoyes if (m.get("date") or "")[:10] >= debut] except Exception: raise HTTPException(status_code=502, detail="Lecture du courrier momentanément indisponible.") vus, tous = set(), [] for m in recus + envoyes: if m.get("message_id") not in vus: vus.add(m.get("message_id")); tous.append(m) items = calculer_suivi(tous, MON_ADRESSE, maintenant, list_suivi_clos()) compte = {k: sum(1 for i in items if i["etat"] == k and not i["clos"]) for k in ("attente", "reponse", "a_repondre")} compte["clos"] = sum(1 for i in items if i["clos"]) derniere = max(((x.get("date") or "")[:10] for x in tous_envoyes), default="") seuil = (maintenant - timedelta(days=2)).strftime("%Y-%m-%d") return {"jours": jours, "items": items, "compte": compte, "envoyes_jusqu_au": derniere, "envoyes_a_jour": bool(derniere) and derniere >= seuil} @api.post("/suivi/clore") def suivi_clore(c: SuiviClore): clore_suivi(c.cle, c.dernier_id) return {"clos": c.cle} @api.post("/suivi/rouvrir") def suivi_rouvrir(c: SuiviRouvrir): rouvrir_suivi(c.cle) return {"rouvert": c.cle} # --- Courses pour Tunis --- class CourseIn(BaseModel): demande: str = Field(..., min_length=1, max_length=300) sens: str = "tunis_sfax" message_id: Optional[str] = Field(None, max_length=400) objet_mail: Optional[str] = Field(None, max_length=500) expediteur: Optional[str] = Field(None, max_length=300) date_mail: Optional[str] = Field(None, max_length=40) class CourseUp(BaseModel): demande: Optional[str] = Field(None, min_length=1, max_length=300) sens: Optional[str] = None statut: Optional[str] = None def _verifier_course(sens: Optional[str], statut: Optional[str] = None): if sens is not None and sens not in SENS_COURSE: raise HTTPException(status_code=422, detail="Sens invalide.") if statut is not None and statut not in ("a_faire", "faite"): raise HTTPException(status_code=422, detail="Statut invalide.") @api.get("/courses") def lister_courses(statut: Optional[str] = Query(None, pattern="^(a_faire|faite|toutes)$")): return {"courses": list_courses(statut)} @api.get("/courses/export") def exporter_courses(statut: Optional[str] = Query(None, pattern="^(a_faire|faite|toutes)$")): from app.export_courses import construire_xlsx libelle = {"a_faire": "A faire", "faite": "Faites"}.get(statut or "", "Toutes les courses") maintenant = get_tunis_now_iso() contenu = construire_xlsx(list_courses(statut), libelle, maintenant) nom = f"Courses-pour-Tunis-{maintenant[:10]}.xlsx" return Response(content=contenu, media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", headers={"Content-Disposition": f'attachment; filename="{nom}"', "Cache-Control": "no-store"}) @api.post("/courses/synchroniser") def synchroniser_courses(jours: int = Query(14, ge=1, le=30)): """Cree une course par fil de discussion classe Tunis. Un fil supprime ou deja importe n'est pas recree.""" from datetime import date as _date, timedelta from app.suivi import sujet_normalise fin = _date.fromisoformat(get_tunis_now_iso()[:10]) debut = (fin - timedelta(days=jours - 1)).isoformat() try: mails = mirror_client.get_mails_since(debut, max_items=min(150 * jours, 800)) except Exception: raise HTTPException(status_code=502, detail="Miroir indisponible.") classes = {c["message_id"]: c for c in classify_batch(mails)} existantes = list_courses(None) ids = {k["message_id"] for k in existantes if k.get("message_id")} cles = cles_courses_vues() | {sujet_normalise(k.get("objet_mail") or k["demande"]) for k in existantes} ajoutees = [] for m in sorted(mails, key=lambda x: x.get("date") or ""): mid = m.get("message_id") c = classes.get(mid) if not mid or c is None or c.get("categorie") != "Tunis" or mid in ids: continue objet = (m.get("objet") or "").strip() cle = sujet_normalise(objet) if not cle or cle in cles: continue sens = "sfax_tunis" if re.search(r"sfax\s*(?:vers|->|\u2192|/)\s*tunis", objet, re.IGNORECASE) else "tunis_sfax" demande = re.sub(r"\s+", " ", re.sub(r"^((re|tr|fw|fwd)\s*:\s*)+", "", objet, flags=re.IGNORECASE)).strip()[:300] or objet[:300] ajoutees.append(add_course(demande, sens, mid, objet[:500], (m.get("expediteur") or "")[:300], (m.get("date") or "")[:40])) cles.add(cle) marquer_courses_vues(cles) return {"ajoutees": len(ajoutees), "courses": ajoutees} @api.post("/courses", status_code=201) def creer_course(c: CourseIn): _verifier_course(c.sens) demande = c.demande.strip() if not demande: raise HTTPException(status_code=422, detail="Demande vide.") return add_course(demande, c.sens, c.message_id, c.objet_mail, c.expediteur, c.date_mail) @api.patch("/courses/{course_id}") def modifier_course(course_id: int, c: CourseUp): _verifier_course(c.sens, c.statut) if c.demande is not None and not c.demande.strip(): raise HTTPException(status_code=422, detail="Demande vide.") r = update_course(course_id, c.demande.strip() if c.demande is not None else None, c.sens, c.statut) if r is None: raise HTTPException(status_code=404, detail="Course introuvable.") return r @api.delete("/courses/{course_id}") def supprimer_course(course_id: int): if not delete_course(course_id): raise HTTPException(status_code=404, detail="Course introuvable.") return {"supprimee": course_id} # --- À suivre : mails marqués à la main, sans limite de date --- class SuivreMarque(BaseModel): message_id: str = Field(..., min_length=1, max_length=400) expediteur: Optional[str] = Field(None, max_length=500) objet: Optional[str] = Field(None, max_length=1000) date_mail: Optional[str] = Field(None, max_length=64) categorie: Optional[str] = Field(None, max_length=100) class SuivreIds(BaseModel): ids: List[str] = Field(..., min_length=1, max_length=500) def _ids_valides(ids: List[str]) -> List[str]: propres = [i for i in ids if isinstance(i, str) and 0 < len(i) <= 400] if not propres: raise HTTPException(status_code=422, detail="Aucun identifiant de mail valide.") return propres @api.get("/a-suivre") def lire_a_suivre(statut: str = Query("tous", pattern="^(actif|termine|tous)$")): """Mails marqués « À suivre », du plus récent au plus ancien. Le marqueur reste dans Courrier : O365 n'est jamais modifié.""" return asuivre.lister(None if statut == "tous" else statut) @api.post("/a-suivre/marquer") def marquer_a_suivre(m: SuivreMarque): return asuivre.marquer(m.message_id, m.expediteur, m.objet, m.date_mail, m.categorie) @api.post("/a-suivre/retirer") def retirer_a_suivre(r: SuivreIds): """Retire un ou plusieurs mails du suivi : ils passent en « terminés », rien n'est supprimé.""" return {"ids": asuivre.changer_statut(_ids_valides(r.ids), "termine")} @api.post("/a-suivre/remettre") def remettre_a_suivre(r: SuivreIds): """Remet au suivi des mails retirés (annulation ou retour depuis les terminés) en gardant leur date de marquage.""" return {"ids": asuivre.changer_statut(_ids_valides(r.ids), "actif")} # --- 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 --- def _refuser_categorie_systeme(cat_id: int): """« À classer » reçoit les mails sans règle : ni renommée ni supprimée.""" for c in list_categories(): if c["id"] == cat_id and c["name"] == "À classer": raise HTTPException(status_code=400, detail="La catégorie « À classer » est protégée") @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.""" _refuser_categorie_systeme(cat_id) try: res = update_category(cat_id, req.name) except Exception: raise HTTPException(status_code=400, detail="Nom de catégorie invalide ou déjà utilisé") 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.""" _refuser_categorie_systeme(cat_id) 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." } api.include_router(creer_routeur(mirror_client)) app.include_router(api)