Files
courrier/app/main.py
T

255 lines
7.6 KiB
Python

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)