Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01XGaEeUbVSdKNfpFRgWfCXa
617 lines
24 KiB
Python
617 lines
24 KiB
Python
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()
|