Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01XGaEeS4wbkMHuVXmz5fqkh
333 lines
11 KiB
Python
333 lines
11 KiB
Python
from contextlib import asynccontextmanager
|
|
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
|
|
from fastapi.staticfiles import StaticFiles
|
|
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,
|
|
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
|
|
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)
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
@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)}
|
|
resultats = []
|
|
for m in mails:
|
|
if not m.get("message_id"):
|
|
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": classify_mail(m),
|
|
})
|
|
return {"debut": debut, "fin": fin.isoformat(), "count": len(resultats), "mails": resultats}
|
|
|
|
# --- 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)
|