import os import json import sqlite3 from typing import Optional, List, Dict, Any from app.config import DB_PATH, DEFAULT_CATEGORIES, DEFAULT_RULES, get_tunis_now_iso def get_connection(db_path: Optional[str] = None) -> sqlite3.Connection: path = db_path or DB_PATH os.makedirs(os.path.dirname(path), exist_ok=True) conn = sqlite3.connect(path) conn.row_factory = sqlite3.Row conn.execute("PRAGMA journal_mode=WAL") conn.execute("PRAGMA foreign_keys=ON") return conn def init_db(db_path: Optional[str] = None) -> None: conn = get_connection(db_path) try: with conn: conn.execute(""" CREATE TABLE IF NOT EXISTS categories ( id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT UNIQUE NOT NULL, created_at TEXT NOT NULL ); """) conn.execute(""" CREATE TABLE IF NOT EXISTS regles ( id INTEGER PRIMARY KEY AUTOINCREMENT, expediteur TEXT, mot_cle TEXT, etiquette_miroir TEXT, categorie TEXT NOT NULL, statut TEXT NOT NULL DEFAULT 'active', -- 'active' ou 'proposee' created_at TEXT NOT NULL ); """) conn.execute(""" CREATE TABLE IF NOT EXISTS classements ( message_id TEXT PRIMARY KEY, categorie TEXT NOT NULL, source TEXT NOT NULL, -- 'regle' ou 'manuel' horodatage TEXT NOT NULL, traite INTEGER NOT NULL DEFAULT 0, expediteur TEXT, objet TEXT, date_mail TEXT, etiquettes TEXT DEFAULT '[]' ); """) # Migration douce si la table classements existait sans la colonne etiquettes cols = [r["name"] for r in conn.execute("PRAGMA table_info(classements)").fetchall()] if "etiquettes" not in cols: conn.execute("ALTER TABLE classements ADD COLUMN etiquettes TEXT DEFAULT '[]'") now = get_tunis_now_iso() # Initialisation idempotente des catégories par défaut for cat in DEFAULT_CATEGORIES: conn.execute( "INSERT OR IGNORE INTO categories (name, created_at) VALUES (?, ?)", (cat, now) ) # Initialisation idempotente des règles de départ for rule in DEFAULT_RULES: cat = rule["categorie"] eti = rule.get("etiquette_miroir") exp = rule.get("expediteur") mot = rule.get("mot_cle") sta = rule.get("statut", "active") cursor = conn.execute( """ SELECT COUNT(*) as cnt FROM regles WHERE categorie = ? AND (etiquette_miroir IS ? OR etiquette_miroir = ?) AND (expediteur IS ? OR expediteur = ?) AND (mot_cle IS ? OR mot_cle = ?) """, (cat, eti, eti, exp, exp, mot, mot) ) if cursor.fetchone()["cnt"] == 0: conn.execute( """ INSERT INTO regles (categorie, etiquette_miroir, expediteur, mot_cle, statut, created_at) VALUES (?, ?, ?, ?, ?, ?) """, (cat, eti, exp, mot, sta, now) ) finally: conn.close() # --- Catégories --- def list_categories(db_path: Optional[str] = None) -> List[Dict[str, Any]]: conn = get_connection(db_path) try: rows = conn.execute("SELECT id, name, created_at FROM categories ORDER BY id ASC").fetchall() return [dict(r) for r in rows] finally: conn.close() def add_category(name: str, db_path: Optional[str] = None) -> Dict[str, Any]: name = name.strip() if not name: raise ValueError("Le nom de la catégorie ne peut être vide.") conn = get_connection(db_path) try: now = get_tunis_now_iso() with conn: cursor = conn.execute( "INSERT INTO categories (name, created_at) VALUES (?, ?)", (name, now) ) cat_id = cursor.lastrowid return {"id": cat_id, "name": name, "created_at": now} finally: conn.close() def update_category(cat_id: int, new_name: str, db_path: Optional[str] = None) -> Optional[Dict[str, Any]]: new_name = new_name.strip() if not new_name: raise ValueError("Le nom de la catégorie ne peut être vide.") conn = get_connection(db_path) try: with conn: ancien = conn.execute("SELECT name FROM categories WHERE id = ?", (cat_id,)).fetchone() cursor = conn.execute( "UPDATE categories SET name = ? WHERE id = ?", (new_name, cat_id) ) if cursor.rowcount == 0: return None if ancien and ancien["name"] != new_name: # CASCADE-060 conn.execute("UPDATE classements SET categorie = ? WHERE categorie = ?", (new_name, ancien["name"])) conn.execute("UPDATE regles SET categorie = ? WHERE categorie = ?", (new_name, ancien["name"])) row = conn.execute("SELECT id, name, created_at FROM categories WHERE id = ?", (cat_id,)).fetchone() return dict(row) if row else None finally: conn.close() def delete_category(cat_id: int, db_path: Optional[str] = None) -> bool: conn = get_connection(db_path) try: with conn: ancien = conn.execute("SELECT name FROM categories WHERE id = ?", (cat_id,)).fetchone() cursor = conn.execute("DELETE FROM categories WHERE id = ?", (cat_id,)) if cursor.rowcount > 0 and ancien: # CASCADE-060 conn.execute("UPDATE classements SET categorie = 'À classer' WHERE categorie = ?", (ancien["name"],)) conn.execute("DELETE FROM regles WHERE categorie = ?", (ancien["name"],)) return cursor.rowcount > 0 finally: conn.close() # --- Règles --- def list_regles(statut: Optional[str] = None, db_path: Optional[str] = None) -> List[Dict[str, Any]]: conn = get_connection(db_path) try: if statut: rows = conn.execute( "SELECT id, expediteur, mot_cle, etiquette_miroir, categorie, statut, created_at FROM regles WHERE statut = ? ORDER BY id ASC", (statut,) ).fetchall() else: rows = conn.execute( "SELECT id, expediteur, mot_cle, etiquette_miroir, categorie, statut, created_at FROM regles ORDER BY id ASC" ).fetchall() return [dict(r) for r in rows] finally: conn.close() def get_regle(regle_id: int, db_path: Optional[str] = None) -> Optional[Dict[str, Any]]: conn = get_connection(db_path) try: row = conn.execute( "SELECT id, expediteur, mot_cle, etiquette_miroir, categorie, statut, created_at FROM regles WHERE id = ?", (regle_id,) ).fetchone() return dict(row) if row else None finally: conn.close() def add_regle( categorie: str, expediteur: Optional[str] = None, mot_cle: Optional[str] = None, etiquette_miroir: Optional[str] = None, statut: str = "active", db_path: Optional[str] = None ) -> Dict[str, Any]: conn = get_connection(db_path) try: now = get_tunis_now_iso() with conn: cursor = conn.execute( """ INSERT INTO regles (expediteur, mot_cle, etiquette_miroir, categorie, statut, created_at) VALUES (?, ?, ?, ?, ?, ?) """, (expediteur or None, mot_cle or None, etiquette_miroir or None, categorie, statut, now) ) regle_id = cursor.lastrowid return { "id": regle_id, "expediteur": expediteur, "mot_cle": mot_cle, "etiquette_miroir": etiquette_miroir, "categorie": categorie, "statut": statut, "created_at": now } finally: conn.close() def update_regle( regle_id: int, categorie: Optional[str] = None, expediteur: Optional[str] = None, mot_cle: Optional[str] = None, etiquette_miroir: Optional[str] = None, statut: Optional[str] = None, db_path: Optional[str] = None ) -> Optional[Dict[str, Any]]: conn = get_connection(db_path) try: existing = get_regle(regle_id, db_path) if not existing: return None new_cat = categorie if categorie is not None else existing["categorie"] new_exp = expediteur if expediteur is not None else existing["expediteur"] new_mot = mot_cle if mot_cle is not None else existing["mot_cle"] new_eti = etiquette_miroir if etiquette_miroir is not None else existing["etiquette_miroir"] new_sta = statut if statut is not None else existing["statut"] with conn: conn.execute( """ UPDATE regles SET categorie = ?, expediteur = ?, mot_cle = ?, etiquette_miroir = ?, statut = ? WHERE id = ? """, (new_cat, new_exp, new_mot, new_eti, new_sta, regle_id) ) return get_regle(regle_id, db_path) finally: conn.close() def delete_regle(regle_id: int, db_path: Optional[str] = None) -> bool: conn = get_connection(db_path) try: with conn: cursor = conn.execute("DELETE FROM regles WHERE id = ?", (regle_id,)) return cursor.rowcount > 0 finally: conn.close() def confirm_regle(regle_id: int, db_path: Optional[str] = None) -> Optional[Dict[str, Any]]: return update_regle(regle_id, statut="active", db_path=db_path) # --- Classements --- def get_classement(message_id: str, db_path: Optional[str] = None) -> Optional[Dict[str, Any]]: conn = get_connection(db_path) try: row = conn.execute( "SELECT message_id, categorie, source, horodatage, traite, expediteur, objet, date_mail, etiquettes FROM classements WHERE message_id = ?", (message_id,) ).fetchone() if not row: return None d = dict(row) d["traite"] = bool(d["traite"]) return d finally: conn.close() def list_classements( date_prefix: Optional[str] = None, categorie: Optional[str] = None, traite: Optional[bool] = None, db_path: Optional[str] = None ) -> List[Dict[str, Any]]: conn = get_connection(db_path) try: query = "SELECT message_id, categorie, source, horodatage, traite, expediteur, objet, date_mail, etiquettes FROM classements WHERE 1=1" params: list = [] if date_prefix: query += " AND (date_mail LIKE ? OR horodatage LIKE ?)" params.extend([f"{date_prefix}%", f"{date_prefix}%"]) if categorie: query += " AND categorie = ?" params.append(categorie) if traite is not None: query += " AND traite = ?" params.append(1 if traite else 0) query += " ORDER BY horodatage DESC" rows = conn.execute(query, params).fetchall() result = [] for r in rows: d = dict(r) d["traite"] = bool(d["traite"]) result.append(d) return result finally: conn.close() def save_classement_regle( message_id: str, categorie: str, expediteur: str = "", objet: str = "", date_mail: str = "", etiquettes: Optional[str] = None, db_path: Optional[str] = None ) -> Dict[str, Any]: """ Applique un classement par règle. RÈGLE ABSOLUE : Un classement manuel n'est JAMAIS écrasé par une règle. """ conn = get_connection(db_path) try: existing = get_classement(message_id, db_path) if existing and existing["source"] == "manuel": # Protection absolue du classement manuel return existing now = get_tunis_now_iso() traite = existing["traite"] if existing else False exp = expediteur or (existing["expediteur"] if existing else "") obj = objet or (existing["objet"] if existing else "") d_mail = date_mail or (existing["date_mail"] if existing else "") etiq = etiquettes or (existing.get("etiquettes") if existing else "[]") with conn: conn.execute( """ INSERT INTO classements (message_id, categorie, source, horodatage, traite, expediteur, objet, date_mail, etiquettes) VALUES (?, ?, 'regle', ?, ?, ?, ?, ?, ?) ON CONFLICT(message_id) DO UPDATE SET categorie = excluded.categorie, source = 'regle', horodatage = excluded.horodatage, expediteur = excluded.expediteur, objet = excluded.objet, date_mail = excluded.date_mail, etiquettes = CASE WHEN excluded.etiquettes != '[]' THEN excluded.etiquettes ELSE classements.etiquettes END WHERE classements.source != 'manuel' """, (message_id, categorie, now, 1 if traite else 0, exp, obj, d_mail, etiq) ) return get_classement(message_id, db_path) finally: conn.close() def save_classement_manuel( message_id: str, categorie: str, traite: Optional[bool] = None, expediteur: Optional[str] = None, objet: Optional[str] = None, date_mail: Optional[str] = None, etiquettes: Optional[str] = None, db_path: Optional[str] = None ) -> Dict[str, Any]: """ Enregistre un classement manuel posé par l'utilisateur. """ conn = get_connection(db_path) try: existing = get_classement(message_id, db_path) now = get_tunis_now_iso() is_traite = (1 if traite else 0) if traite is not None else (1 if (existing and existing["traite"]) else 0) exp = expediteur if expediteur is not None else (existing["expediteur"] if existing else "") obj = objet if objet is not None else (existing["objet"] if existing else "") d_mail = date_mail if date_mail is not None else (existing["date_mail"] if existing else "") etiq = etiquettes if etiquettes is not None else (existing.get("etiquettes") if existing else "[]") with conn: conn.execute( """ INSERT INTO classements (message_id, categorie, source, horodatage, traite, expediteur, objet, date_mail, etiquettes) VALUES (?, ?, 'manuel', ?, ?, ?, ?, ?, ?) ON CONFLICT(message_id) DO UPDATE SET categorie = excluded.categorie, source = 'manuel', horodatage = excluded.horodatage, traite = excluded.traite, expediteur = CASE WHEN excluded.expediteur != '' THEN excluded.expediteur ELSE classements.expediteur END, objet = CASE WHEN excluded.objet != '' THEN excluded.objet ELSE classements.objet END, date_mail = CASE WHEN excluded.date_mail != '' THEN excluded.date_mail ELSE classements.date_mail END, etiquettes = CASE WHEN excluded.etiquettes != '[]' THEN excluded.etiquettes ELSE classements.etiquettes END """, (message_id, categorie, now, is_traite, exp, obj, d_mail, etiq) ) return get_classement(message_id, db_path) finally: conn.close() def set_traite(message_id: str, traite: bool, db_path: Optional[str] = None) -> Optional[Dict[str, Any]]: conn = get_connection(db_path) try: with conn: cursor = conn.execute( "UPDATE classements SET traite = ? WHERE message_id = ?", (1 if traite else 0, message_id) ) if cursor.rowcount == 0: return None return get_classement(message_id, db_path) finally: conn.close() # --- Courses pour Tunis --- SENS_COURSE = ("tunis_sfax", "sfax_tunis") def _courses_pret(conn: sqlite3.Connection) -> None: conn.execute(""" CREATE TABLE IF NOT EXISTS courses ( id INTEGER PRIMARY KEY AUTOINCREMENT, message_id TEXT, demande TEXT NOT NULL, sens TEXT NOT NULL DEFAULT 'tunis_sfax', objet_mail TEXT, expediteur TEXT, date_mail TEXT, statut TEXT NOT NULL DEFAULT 'a_faire', cree_le TEXT NOT NULL, fait_le TEXT )""") def list_courses(statut: Optional[str] = None, db_path: Optional[str] = None) -> List[Dict[str, Any]]: conn = get_connection(db_path) try: _courses_pret(conn) if statut in ("a_faire", "faite"): rows = conn.execute("SELECT * FROM courses WHERE statut = ? ORDER BY cree_le DESC, id DESC", (statut,)).fetchall() else: rows = conn.execute("SELECT * FROM courses ORDER BY (statut = 'faite'), cree_le DESC, id DESC").fetchall() return [dict(r) for r in rows] finally: conn.close() def get_course(course_id: int, db_path: Optional[str] = None) -> Optional[Dict[str, Any]]: conn = get_connection(db_path) try: _courses_pret(conn) r = conn.execute("SELECT * FROM courses WHERE id = ?", (course_id,)).fetchone() return dict(r) if r else None finally: conn.close() def add_course(demande: str, sens: str = "tunis_sfax", message_id: Optional[str] = None, objet_mail: Optional[str] = None, expediteur: Optional[str] = None, date_mail: Optional[str] = None, db_path: Optional[str] = None) -> Dict[str, Any]: conn = get_connection(db_path) try: _courses_pret(conn) with conn: cur = conn.execute( "INSERT INTO courses (message_id, demande, sens, objet_mail, expediteur, date_mail, cree_le) VALUES (?, ?, ?, ?, ?, ?, ?)", (message_id, demande, sens, objet_mail, expediteur, date_mail, get_tunis_now_iso())) new_id = cur.lastrowid r = conn.execute("SELECT * FROM courses WHERE id = ?", (new_id,)).fetchone() return dict(r) finally: conn.close() def update_course(course_id: int, demande: Optional[str] = None, sens: Optional[str] = None, statut: Optional[str] = None, db_path: Optional[str] = None) -> Optional[Dict[str, Any]]: conn = get_connection(db_path) try: _courses_pret(conn) actuel = conn.execute("SELECT * FROM courses WHERE id = ?", (course_id,)).fetchone() if not actuel: return None champs, vals = [], [] if demande is not None: champs.append("demande = ?"); vals.append(demande) if sens is not None: champs.append("sens = ?"); vals.append(sens) if statut is not None and statut != actuel["statut"]: champs.append("statut = ?"); vals.append(statut) champs.append("fait_le = ?"); vals.append(get_tunis_now_iso() if statut == "faite" else None) if champs: with conn: conn.execute("UPDATE courses SET " + ", ".join(champs) + " WHERE id = ?", (*vals, course_id)) return dict(conn.execute("SELECT * FROM courses WHERE id = ?", (course_id,)).fetchone()) finally: conn.close() def delete_course(course_id: int, db_path: Optional[str] = None) -> bool: conn = get_connection(db_path) try: _courses_pret(conn) with conn: return conn.execute("DELETE FROM courses WHERE id = ?", (course_id,)).rowcount > 0 finally: conn.close() # --- Suivi des demandes : fils clos --- def _suivi_pret(conn: sqlite3.Connection) -> None: conn.execute("CREATE TABLE IF NOT EXISTS suivi_clos (cle TEXT PRIMARY KEY, dernier_id TEXT NOT NULL, clos_le TEXT NOT NULL)") def list_suivi_clos(db_path: Optional[str] = None) -> Dict[str, str]: conn = get_connection(db_path) try: _suivi_pret(conn) return {r["cle"]: r["dernier_id"] for r in conn.execute("SELECT cle, dernier_id FROM suivi_clos").fetchall()} finally: conn.close() def clore_suivi(cle: str, dernier_id: str, db_path: Optional[str] = None) -> None: conn = get_connection(db_path) try: _suivi_pret(conn) with conn: conn.execute("INSERT INTO suivi_clos (cle, dernier_id, clos_le) VALUES (?, ?, ?) ON CONFLICT(cle) DO UPDATE SET dernier_id = excluded.dernier_id, clos_le = excluded.clos_le", (cle, dernier_id, get_tunis_now_iso())) finally: conn.close() def rouvrir_suivi(cle: str, db_path: Optional[str] = None) -> bool: conn = get_connection(db_path) try: _suivi_pret(conn) with conn: return conn.execute("DELETE FROM suivi_clos WHERE cle = ?", (cle,)).rowcount > 0 finally: conn.close()