Files
courrier/app/db.py
T

617 lines
24 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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
# Couleur stable par catégorie (jetons --ny-cat-N de l’interface) : 0 = catégorie système, 1 à 5 = catégories d’origine,
# 6 à 12 = les autres, chacune sur sa propre couleur tant qu’il en reste (la moins utilisée sinon).
COULEURS_ORIGINE = {"À classer": 0, "Tunis": 1, "Demande FB": 2, "CI": 3, "Câbles": 4, "Sans objet": 5}
COULEUR_MIN, COULEUR_MAX = 6, 12
def _couleur_libre(conn: sqlite3.Connection, souhaitee: Optional[int] = None) -> int:
prises = {r[0] for r in conn.execute("SELECT couleur FROM categories WHERE couleur IS NOT NULL")}
if souhaitee is not None and COULEUR_MIN <= souhaitee <= COULEUR_MAX and souhaitee not in prises:
return souhaitee
for c in range(COULEUR_MIN, COULEUR_MAX + 1):
if c not in prises:
return c
usage = {c: 0 for c in range(COULEUR_MIN, COULEUR_MAX + 1)}
for r in conn.execute("SELECT couleur FROM categories WHERE couleur BETWEEN ? AND ?", (COULEUR_MIN, COULEUR_MAX)):
usage[r[0]] += 1
return min(usage, key=lambda c: (usage[c], c))
def _attribuer_couleurs(conn: sqlite3.Connection) -> None:
"""Donne une couleur aux catégories qui n’en ont pas encore. Les catégories existantes gardent leur ancienne teinte quand elle est libre."""
for r in conn.execute("SELECT id, name FROM categories WHERE couleur IS NULL ORDER BY id").fetchall():
if r["name"] in COULEURS_ORIGINE:
c = COULEURS_ORIGINE[r["name"]]
else:
c = _couleur_libre(conn, 6 + (r["id"] % 3))
conn.execute("UPDATE categories SET couleur = ? WHERE id = ?", (c, r["id"]))
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 '[]'")
cols_cat = [r["name"] for r in conn.execute("PRAGMA table_info(categories)").fetchall()]
if "couleur" not in cols_cat:
conn.execute("ALTER TABLE categories ADD COLUMN couleur INTEGER")
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)
)
_attribuer_couleurs(conn)
# 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, couleur, 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:
couleur = _couleur_libre(conn)
cursor = conn.execute(
"INSERT INTO categories (name, couleur, created_at) VALUES (?, ?, ?)",
(name, couleur, now)
)
cat_id = cursor.lastrowid
return {"id": cat_id, "name": name, "couleur": couleur, "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"]))
from app.asuivre import _pret as _pret_suivre
_pret_suivre(conn)
conn.execute("UPDATE a_suivre SET categorie = ? WHERE categorie = ?", (new_name, ancien["name"]))
row = conn.execute("SELECT id, name, couleur, 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"],))
from app.asuivre import _pret as _pret_suivre
_pret_suivre(conn)
conn.execute("UPDATE a_suivre SET categorie = 'À classer' 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 _vues_pret(conn: sqlite3.Connection) -> None:
conn.execute("CREATE TABLE IF NOT EXISTS courses_vues (cle TEXT PRIMARY KEY, le TEXT NOT NULL)")
def cles_courses_vues(db_path: Optional[str] = None) -> set:
"""Fils deja importes ou supprimes : la synchronisation ne les recree pas."""
conn = get_connection(db_path)
try:
_vues_pret(conn)
return {r[0] for r in conn.execute("SELECT cle FROM courses_vues")}
finally:
conn.close()
def marquer_courses_vues(cles, db_path: Optional[str] = None) -> None:
conn = get_connection(db_path)
try:
_vues_pret(conn)
with conn:
for c in cles:
if c:
conn.execute("INSERT OR IGNORE INTO courses_vues (cle, le) VALUES (?, ?)", (c, get_tunis_now_iso()))
finally:
conn.close()
def delete_course(course_id: int, db_path: Optional[str] = None) -> bool:
from app.suivi import sujet_normalise
conn = get_connection(db_path)
try:
_courses_pret(conn)
_vues_pret(conn)
with conn:
r = conn.execute("SELECT demande, objet_mail FROM courses WHERE id = ?", (course_id,)).fetchone()
if r is None:
return False
cle = sujet_normalise(r["objet_mail"] or r["demande"])
if cle:
conn.execute("INSERT OR IGNORE INTO courses_vues (cle, le) VALUES (?, ?)", (cle, get_tunis_now_iso()))
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()