feat: application Courrier V1a socle et tri du jour (tt-2026-11-059)

This commit is contained in:
gemini-ops committed 2026-11-17 12:14:55 +01:00
1 parent 0199477821
commit b51a8bba69
19 files changed
+1731 -2

No files matched your search

+254
View File
@@ -0,0 +1,254 @@
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)