Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01XGaEeWkqZYNP6Wn3mGQsrL
595 lines
22 KiB
Python
595 lines
22 KiB
Python
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,
|
|
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.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 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", 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}
|
|
|
|
|
|
# --- 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."
|
|
}
|
|
|
|
app.include_router(api)
|