From 92cf21309f714aa611fa2ebc827c5f84ed3fd812 Mon Sep 17 00:00:00 2001
From: Bertrand Benjamin <benjamin.bertrand@opytex.org>
Date: Sun, 26 Jul 2026 06:52:49 +0200
Subject: [PATCH] feat: affiche la date de derniere extraction et revient aux
 documents

La liste des documents montrait la date d'import, figee au premier
enregistrement : c'est la date de la derniere extraction ayant produit les
donnees affichees qui renseigne, surtout apres un balayage de re-extraction. La
colonne `extracted_at` la porte, mise a jour a chaque enregistrement, et la date
d'import reste consultable en infobulle.

Le projet n'ayant pas d'outil de migration (`create_all` laisse intactes les
tables existantes), `init_db` rattrape les colonnes ajoutees apres coup : sans
cela une base deja installee cesserait de fonctionner. Les documents deja
presents recoivent leur date d'import, qui est bien celle de leur extraction.

Une fois la selection appliquee sans echec, le balayage renvoie vers la liste des
documents ; en cas d'echec on reste sur place, les lignes concernees portant leur
message.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 frontend/src/pages/DocumentsPage.vue       |  9 ++-
 frontend/src/pages/ReExtractionPage.vue    |  6 ++
 src/plesna_gerance/api/routes/documents.py |  4 ++
 src/plesna_gerance/api/schemas/models.py   |  3 +
 src/plesna_gerance/database/connection.py  | 29 +++++++++
 src/plesna_gerance/database/models.py      |  4 ++
 src/plesna_gerance/database/service.py     |  4 +-
 tests/test_schema_updates.py               | 73 ++++++++++++++++++++++
 8 files changed, 129 insertions(+), 3 deletions(-)
 create mode 100644 tests/test_schema_updates.py

diff --git a/frontend/src/pages/DocumentsPage.vue b/frontend/src/pages/DocumentsPage.vue
index 8c4190b..78f3c8f 100644
--- a/frontend/src/pages/DocumentsPage.vue
+++ b/frontend/src/pages/DocumentsPage.vue
@@ -64,7 +64,7 @@
             <tr>
               <th>Document</th>
               <th>Immeuble</th>
-              <th>Date</th>
+              <th>Date / extraction</th>
               <th class="text-right">Solde</th>
               <th class="text-center">Fichiers</th>
               <th class="text-right">Actions</th>
@@ -100,7 +100,12 @@
               <!-- Date -->
               <td>
                 <div class="text-sm text-white">{{ formatDate(doc.date) }}</div>
-                <div class="text-xs text-gray-500">Importe le {{ formatDateTime(doc.created_at) }}</div>
+                <div
+                  class="text-xs text-gray-500"
+                  :title="`Importé le ${formatDateTime(doc.created_at)}`"
+                >
+                  Extrait le {{ formatDateTime(doc.extracted_at || doc.created_at) }}
+                </div>
               </td>
 
               <!-- Solde -->
diff --git a/frontend/src/pages/ReExtractionPage.vue b/frontend/src/pages/ReExtractionPage.vue
index 70882bc..eebe791 100644
--- a/frontend/src/pages/ReExtractionPage.vue
+++ b/frontend/src/pages/ReExtractionPage.vue
@@ -320,6 +320,7 @@
 
 <script setup>
 import { computed, onMounted, onBeforeUnmount, reactive, ref } from 'vue'
+import { useRouter } from 'vue-router'
 import ExtractionDiffDetails from '../components/ExtractionDiffDetails.vue'
 import TagAutocomplete from '../components/TagAutocomplete.vue'
 import {
@@ -333,6 +334,8 @@ import { fillPredictions, remapTags, toDepensesTags } from '../utils/tagRemap.js
 // Ordre de grandeur mesuré d'une extraction, avant toute mesure réelle.
 const SECONDS_PER_DOC = 7
 
+const router = useRouter()
+
 const documents = ref([])
 const items = ref([])
 const availableTags = ref([])
@@ -663,8 +666,11 @@ async function applySelection() {
 
   isApplying.value = false
   if (failures) {
+    // On reste sur la page : les lignes en échec portent leur message.
     applyError.value = `${failures} document${failures > 1 ? 's' : ''} n'${failures > 1 ? 'ont' : 'a'} pas pu être enregistré${failures > 1 ? 's' : ''}`
+    return
   }
+  router.push('/documents')
 }
 
 function formatDate(dateStr) {
diff --git a/src/plesna_gerance/api/routes/documents.py b/src/plesna_gerance/api/routes/documents.py
index 4413e03..85ef075 100644
--- a/src/plesna_gerance/api/routes/documents.py
+++ b/src/plesna_gerance/api/routes/documents.py
@@ -195,6 +195,7 @@ async def list_documents(
             solde_montant=doc.solde_montant,
             solde_type=doc.solde_type,
             created_at=doc.created_at.isoformat() if doc.created_at else None,
+            extracted_at=doc.extracted_at.isoformat() if doc.extracted_at else None,
             has_pdf=doc.pdf_path is not None,
             has_json=doc.json_path is not None,
         )
@@ -245,6 +246,9 @@ async def get_document(
         "json_data": json.loads(document.json_data) if document.json_data else None,
         "depenses_tags": db_service.get_depenses_tags(document_id),
         "created_at": document.created_at.isoformat() if document.created_at else None,
+        "extracted_at": document.extracted_at.isoformat()
+        if document.extracted_at
+        else None,
         "has_pdf": document.pdf_path is not None,
         "has_json": document.json_path is not None,
     }
diff --git a/src/plesna_gerance/api/schemas/models.py b/src/plesna_gerance/api/schemas/models.py
index 7facc00..90a0cb6 100644
--- a/src/plesna_gerance/api/schemas/models.py
+++ b/src/plesna_gerance/api/schemas/models.py
@@ -53,6 +53,9 @@ class DocumentSummary(BaseModel):
     solde_montant: float | None
     solde_type: str | None
     created_at: str
+    #: Derniere extraction ayant produit les donnees (absente sur une base
+    #: anterieure a ce champ : l'appelant retombe alors sur `created_at`).
+    extracted_at: str | None = None
     has_pdf: bool = False
     has_json: bool = False
 
diff --git a/src/plesna_gerance/database/connection.py b/src/plesna_gerance/database/connection.py
index ed35ee7..c7adb87 100644
--- a/src/plesna_gerance/database/connection.py
+++ b/src/plesna_gerance/database/connection.py
@@ -87,6 +87,7 @@ def init_db(db_path: Path | None = None) -> Path:
     # Build the engine (reuses the shared configuration) and create tables
     engine = get_engine(db_path)
     Base.metadata.create_all(bind=engine)
+    _apply_schema_updates(engine)
 
     # Seed predefined tags if the table is empty
     _seed_tags_if_empty(engine)
@@ -94,6 +95,34 @@ def init_db(db_path: Path | None = None) -> Path:
     return db_path
 
 
+#: Colonnes ajoutees apres coup, par table : nom -> (definition SQL, valeur de
+#: rattrapage pour les lignes existantes). `create_all` ne modifie pas une table
+#: deja presente, et le projet n'utilise pas d'outil de migration : sans ce
+#: rattrapage, une base installee cesserait de fonctionner apres mise a jour.
+_ADDED_COLUMNS = {
+    "documents": {
+        # Les documents deja en base ont ete extraits lors de leur import.
+        "extracted_at": ("DATETIME", "created_at"),
+    },
+}
+
+
+def _apply_schema_updates(engine):
+    """Ajoute a une base existante les colonnes apparues depuis sa creation."""
+    with engine.begin() as conn:
+        for table, columns in _ADDED_COLUMNS.items():
+            existing = {
+                row[1] for row in conn.execute(text(f"PRAGMA table_info({table})"))
+            }
+            if not existing:  # table absente : create_all vient de la creer
+                continue
+            for name, (definition, backfill) in columns.items():
+                if name in existing:
+                    continue
+                conn.execute(text(f"ALTER TABLE {table} ADD COLUMN {name} {definition}"))
+                conn.execute(text(f"UPDATE {table} SET {name} = {backfill}"))
+
+
 def _seed_tags_if_empty(engine):
     """Insert predefined tags if the tags table is empty."""
     from ..scripts.seed_tags import PREDEFINED_TAGS
diff --git a/src/plesna_gerance/database/models.py b/src/plesna_gerance/database/models.py
index a30d441..dcd7e4b 100644
--- a/src/plesna_gerance/database/models.py
+++ b/src/plesna_gerance/database/models.py
@@ -161,6 +161,10 @@ class Document(Base):
     solde_date_arrete = Column(Date, nullable=True)
 
     created_at = Column(DateTime, default=_utcnow)
+    #: Date de la derniere extraction ayant produit les donnees stockees. Une
+    #: re-extraction validee la met a jour, contrairement a `created_at` qui
+    #: reste la date du premier import.
+    extracted_at = Column(DateTime, default=_utcnow)
 
     # Chemins vers les fichiers stockés (relatifs à PLESNA_STORAGE_PATH)
     pdf_path = Column(
diff --git a/src/plesna_gerance/database/service.py b/src/plesna_gerance/database/service.py
index 6da873b..0499a31 100644
--- a/src/plesna_gerance/database/service.py
+++ b/src/plesna_gerance/database/service.py
@@ -1,7 +1,7 @@
 """Database service for saving and querying extracted data."""
 
 import json
-from datetime import date, datetime
+from datetime import date, datetime, timezone
 from typing import Any
 
 from sqlalchemy import select
@@ -249,6 +249,8 @@ class DatabaseService:
             "solde_date_arrete": self._parse_date(solde_info.get("date_arrete")),
             "pdf_path": pdf_path,
             "json_path": json_path,
+            # Ces donnees viennent de l'extraction qu'on est en train d'enregistrer.
+            "extracted_at": datetime.now(timezone.utc),
         }
         if reused is not None:
             document = reused
diff --git a/tests/test_schema_updates.py b/tests/test_schema_updates.py
new file mode 100644
index 0000000..6a93fbf
--- /dev/null
+++ b/tests/test_schema_updates.py
@@ -0,0 +1,73 @@
+"""Rattrapage de schema sur une base creee avant l'ajout d'une colonne.
+
+Le projet n'a pas d'outil de migration : `create_all` laisse intactes les tables
+deja presentes. Sans le rattrapage d'`init_db`, une base installee cesserait de
+fonctionner des qu'une colonne est ajoutee au modele.
+"""
+
+from datetime import datetime, timezone
+
+from sqlalchemy import text
+
+from plesna_gerance.database import connection
+
+
+def test_ajoute_extracted_at_a_une_base_existante(tmp_path, monkeypatch):
+    db_path = tmp_path / "ancienne.sqlite"
+    monkeypatch.setenv("PLESNA_DB_PATH", str(db_path))
+    monkeypatch.setenv("PLESNA_STORAGE_PATH", str(tmp_path / "documents"))
+
+    # Base telle qu'elle existait avant le champ, avec un document dedans.
+    connection.reset_connection()
+    connection.init_db(db_path)
+    engine = connection.get_engine(db_path)
+    importe_le = datetime(2026, 3, 1, 10, 0, tzinfo=timezone.utc)
+    with engine.begin() as conn:
+        conn.execute(text("ALTER TABLE documents DROP COLUMN extracted_at"))
+        conn.execute(
+            text(
+                "INSERT INTO immeubles (code) VALUES ('IMM1');"
+            )
+        )
+        conn.execute(
+            text(
+                "INSERT INTO documents (reference, date, immeuble_id, json_data,"
+                " created_at) VALUES ('REF', '2026-03-01', 1, '{}', :created)"
+            ),
+            {"created": importe_le},
+        )
+    connection.reset_connection()
+
+    connection.init_db(db_path)
+
+    with connection.get_engine(db_path).begin() as conn:
+        colonnes = {
+            row[1] for row in conn.execute(text("PRAGMA table_info(documents)"))
+        }
+        assert "extracted_at" in colonnes
+
+        # Un document deja en base a ete extrait lors de son import.
+        extracted_at, created_at = conn.execute(
+            text("SELECT extracted_at, created_at FROM documents")
+        ).one()
+        assert extracted_at == created_at
+
+    connection.reset_connection()
+
+
+def test_rattrapage_idempotent(tmp_path, monkeypatch):
+    """Relancer init_db sur une base a jour ne doit rien casser."""
+    db_path = tmp_path / "a_jour.sqlite"
+    monkeypatch.setenv("PLESNA_DB_PATH", str(db_path))
+    monkeypatch.setenv("PLESNA_STORAGE_PATH", str(tmp_path / "documents"))
+
+    connection.reset_connection()
+    connection.init_db(db_path)
+    connection.reset_connection()
+    connection.init_db(db_path)
+
+    with connection.get_engine(db_path).begin() as conn:
+        colonnes = [row[1] for row in conn.execute(text("PRAGMA table_info(documents)"))]
+        assert colonnes.count("extracted_at") == 1
+
+    connection.reset_connection()