"""Mails marqués « À suivre ». Le marqueur appartient à Courrier : il est enregistré dans la base locale et n’écrit jamais dans O365 ni dans le miroir. Il ne dépend d’aucune date : un mail marqué reste dans la liste jusqu’à ce qu’il soit retiré. Chaque entrée garde une copie de l’expéditeur, de l’objet, de la date et de la catégorie au moment du marquage, pour rester affichable même si le miroir déplace ou purge le mail. """ from datetime import date from typing import Any, Dict, List, Optional from app.config import get_tunis_now_iso from app.db import get_connection MAX_IDS = 500 def _pret(conn) -> None: conn.execute( """CREATE TABLE IF NOT EXISTS a_suivre ( message_id TEXT PRIMARY KEY, expediteur TEXT, objet TEXT, date_mail TEXT, categorie TEXT NOT NULL DEFAULT 'À classer', marque_le TEXT NOT NULL, statut TEXT NOT NULL DEFAULT 'actif', termine_le TEXT )""" ) conn.execute("CREATE INDEX IF NOT EXISTS idx_a_suivre_statut ON a_suivre(statut)") def _jours_depuis(horodatage: Optional[str]) -> int: try: debut = date.fromisoformat(str(horodatage)[:10]) fin = date.fromisoformat(get_tunis_now_iso()[:10]) return max(0, (fin - debut).days) except Exception: return 0 _SELECT = ( "SELECT a.message_id, a.expediteur, a.objet, a.date_mail, a.statut, a.marque_le, a.termine_le, " "COALESCE(c.categorie, a.categorie) AS categorie " "FROM a_suivre a LEFT JOIN classements c ON c.message_id = a.message_id" ) def _vers_dict(r) -> Dict[str, Any]: d = dict(r) d["jours"] = _jours_depuis(d.get("marque_le")) return d def _un(conn, message_id: str) -> Dict[str, Any]: return _vers_dict(conn.execute(_SELECT + " WHERE a.message_id = ?", (message_id,)).fetchone()) def marquer(message_id: str, expediteur: Optional[str] = None, objet: Optional[str] = None, date_mail: Optional[str] = None, categorie: Optional[str] = None, db_path: Optional[str] = None) -> Dict[str, Any]: """Pose le marqueur (ou le réactive si le mail avait été retiré). Un mail déjà actif garde sa date de marquage.""" conn = get_connection(db_path) try: _pret(conn) cat = (categorie or "").strip() if not cat: r = conn.execute("SELECT categorie FROM classements WHERE message_id = ?", (message_id,)).fetchone() cat = r["categorie"] if r else "À classer" maintenant = get_tunis_now_iso() with conn: conn.execute( """INSERT INTO a_suivre (message_id, expediteur, objet, date_mail, categorie, marque_le, statut, termine_le) VALUES (?, ?, ?, ?, ?, ?, 'actif', NULL) ON CONFLICT(message_id) DO UPDATE SET expediteur = COALESCE(NULLIF(excluded.expediteur, ''), a_suivre.expediteur), objet = COALESCE(NULLIF(excluded.objet, ''), a_suivre.objet), date_mail = COALESCE(NULLIF(excluded.date_mail, ''), a_suivre.date_mail), categorie = excluded.categorie, marque_le = CASE WHEN a_suivre.statut = 'actif' THEN a_suivre.marque_le ELSE excluded.marque_le END, statut = 'actif', termine_le = NULL""", (message_id, expediteur or "", objet or "", date_mail or "", cat, maintenant), ) return _un(conn, message_id) finally: conn.close() def lister(statut: Optional[str] = None, db_path: Optional[str] = None) -> Dict[str, Any]: """Entrées du suivi, les plus récentes en premier (date du mail). La catégorie est la catégorie actuelle du mail.""" conn = get_connection(db_path) try: _pret(conn) if statut in ("actif", "termine"): rows = conn.execute(_SELECT + " WHERE a.statut = ?", (statut,)).fetchall() else: rows = conn.execute(_SELECT).fetchall() items = [_vers_dict(r) for r in rows] items.sort(key=lambda i: (i.get("date_mail") or i.get("marque_le") or ""), reverse=True) compte = {"actif": 0, "termine": 0} for r in conn.execute("SELECT statut, COUNT(*) AS n FROM a_suivre GROUP BY statut"): compte[r["statut"]] = r["n"] return {"items": items, "compte": compte} finally: conn.close() def changer_statut(ids: List[str], statut: str, db_path: Optional[str] = None) -> List[str]: """Retire (statut « termine ») ou remet (statut « actif ») des mails. Aucune suppression : la date de marquage est conservée.""" if statut not in ("actif", "termine"): raise ValueError("Statut inconnu.") ids = list(dict.fromkeys(i for i in ids if i))[:MAX_IDS] conn = get_connection(db_path) try: _pret(conn) touches: List[str] = [] maintenant = get_tunis_now_iso() with conn: for i in ids: cur = conn.execute( "UPDATE a_suivre SET statut = ?, termine_le = ? WHERE message_id = ? AND statut != ?", (statut, maintenant if statut == "termine" else None, i, statut), ) if cur.rowcount: touches.append(i) return touches finally: conn.close() def supprimer(ids: List[str], db_path: Optional[str] = None) -> List[str]: """Efface définitivement de l’historique des mails déjà retirés (statut « termine »). Un mail encore actif n’est jamais supprimé ici : il faut d’abord le retirer. Le mail lui-même (O365, miroir) n’est pas touché.""" ids = list(dict.fromkeys(i for i in ids if i))[:MAX_IDS] conn = get_connection(db_path) try: _pret(conn) effaces: List[str] = [] with conn: for i in ids: cur = conn.execute("DELETE FROM a_suivre WHERE message_id = ? AND statut = 'termine'", (i,)) if cur.rowcount: effaces.append(i) return effaces finally: conn.close()