From 95b4cf79cf12c3141e4bc8973cfaa99f873df642 Mon Sep 17 00:00:00 2001 From: venture Date: Sat, 26 Sep 2026 10:14:07 +0200 Subject: [PATCH] =?UTF-8?q?V3=20S1-S2=20:=20corbeille=20+=20versions=20+?= =?UTF-8?q?=20extract=20g=C3=A9n=C3=A9rique?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit S1 filet (backend + mobile) : corbeille 30j (deleted_at réutilisé, trash/restore récursifs, purge auto serveur), versions N=3 à chaque overwrite, ops outbox trash/restore/purge (delete legacy mappé), Room v19 (trashed_at), Deleters -> trash, écran Corbeille, walk guards. S2 extract (backend) : package extract (règles FR stdlib, corpus testé), resource_facts 000019 (origin auto/user), hook worker OCR + backfill boot, GET /files/:id/facts (viewer+). Contrat docs/api-v1.md étendu, V3.md (vision + plan). --- CHANGELOG.md | 8 + V3.md | 122 +++ backend/cmd/server/main.go | 51 ++ backend/cmd/server/router_test.go | 5 + backend/db/migrations/000017_trash.down.sql | 1 + backend/db/migrations/000017_trash.up.sql | 7 + .../db/migrations/000018_versions.down.sql | 1 + backend/db/migrations/000018_versions.up.sql | 19 + backend/db/migrations/000019_facts.down.sql | 1 + backend/db/migrations/000019_facts.up.sql | 23 + backend/db/migrations_test.go | 53 ++ backend/extract/rules.go | 408 ++++++++++ backend/extract/rules_test.go | 183 +++++ backend/handlers/facts_test.go | 83 ++ backend/handlers/files.go | 129 ++- backend/handlers/router.go | 5 + backend/handlers/trash_test.go | 160 ++++ backend/repository/facts.go | 153 ++++ backend/repository/resources.go | 11 +- backend/repository/trash.go | 191 +++++ backend/repository/versions.go | 131 +++ backend/service/extract.go | 108 +++ backend/service/extract_test.go | 196 +++++ backend/service/ocr.go | 26 +- backend/service/resources.go | 43 +- backend/service/resources_test.go | 22 +- backend/service/sync.go | 68 +- backend/service/trash.go | 420 ++++++++++ backend/service/trash_test.go | 364 +++++++++ docs/api-v1.md | 14 +- .../19.json | 766 ++++++++++++++++++ .../kazier/mobile/data/local/AppDatabase.kt | 4 +- .../kazier/mobile/data/local/dao/FileDao.kt | 37 + .../kazier/mobile/data/local/dao/FolderDao.kt | 23 + .../data/local/dao/PendingOperationDao.kt | 26 +- .../mobile/data/local/entity/FileEntity.kt | 10 + .../mobile/data/local/entity/FolderEntity.kt | 6 + .../local/entity/PendingOperationEntity.kt | 9 + .../mobile/data/local/migration/Migrations.kt | 15 +- .../kazier/mobile/data/remote/ApiClient.kt | 17 + .../kazier/mobile/data/remote/ApiService.kt | 31 + .../com/kazier/mobile/data/remote/dto/Dtos.kt | 25 + .../mobile/data/repository/FileRepository.kt | 34 + .../data/repository/FolderRepository.kt | 29 + .../data/repository/OutboxRepository.kt | 30 +- .../mobile/data/repository/TrashRepository.kt | 213 +++++ .../kazier/mobile/features/saf/FileDeleter.kt | 64 +- .../mobile/features/saf/FolderDeleter.kt | 97 ++- .../mobile/features/saf/SafFileDeleter.kt | 24 +- .../kazier/mobile/features/sync/DeviceSync.kt | 5 + .../mobile/features/sync/RetentionWorker.kt | 9 + .../mobile/features/sync/SyncViewModel.kt | 9 + .../kazier/mobile/ui/navigation/NavGraph.kt | 8 + .../mobile/ui/settings/SettingsScreen.kt | 10 + .../com/kazier/mobile/ui/trash/TrashScreen.kt | 222 +++++ .../kazier/mobile/ui/trash/TrashViewModel.kt | 63 ++ .../app/src/main/res/values-en/strings.xml | 12 +- .../app/src/main/res/values/strings.xml | 12 +- .../data/local/dao/TrashCorbeilleTest.kt | 187 +++++ .../local/migration/Migration18To19Test.kt | 95 +++ .../kazier/mobile/data/remote/Auth401Test.kt | 20 + .../mobile/data/remote/PaginationTest.kt | 20 + .../mobile/data/remote/RemoteContentTest.kt | 12 + .../mobile/data/remote/SessionReloginTest.kt | 12 + .../mobile/data/remote/ShareManagementTest.kt | 12 + .../mobile/data/repository/BytesUploadTest.kt | 12 + .../data/repository/FolderMergeDataTest.kt | 20 + .../data/repository/MoveProtectionTest.kt | 20 + .../data/repository/OcrRepositoryTest.kt | 20 + .../data/repository/OfflineDownloadTest.kt | 12 + .../data/repository/RefreshVsMoveTest.kt | 20 + .../data/repository/ShareRepositoryTest.kt | 20 + .../mobile/features/saf/DeleteInCloudTest.kt | 25 +- .../features/saf/ReleaseLocalCopyTest.kt | 4 + .../features/sync/OutboxSyncWorkerTest.kt | 12 + 75 files changed, 5220 insertions(+), 119 deletions(-) create mode 100644 V3.md create mode 100644 backend/db/migrations/000017_trash.down.sql create mode 100644 backend/db/migrations/000017_trash.up.sql create mode 100644 backend/db/migrations/000018_versions.down.sql create mode 100644 backend/db/migrations/000018_versions.up.sql create mode 100644 backend/db/migrations/000019_facts.down.sql create mode 100644 backend/db/migrations/000019_facts.up.sql create mode 100644 backend/extract/rules.go create mode 100644 backend/extract/rules_test.go create mode 100644 backend/handlers/facts_test.go create mode 100644 backend/handlers/trash_test.go create mode 100644 backend/repository/facts.go create mode 100644 backend/repository/trash.go create mode 100644 backend/repository/versions.go create mode 100644 backend/service/extract.go create mode 100644 backend/service/extract_test.go create mode 100644 backend/service/trash.go create mode 100644 backend/service/trash_test.go create mode 100644 mobile-kotlin/app/schemas/com.kazier.mobile.data.local.AppDatabase/19.json create mode 100644 mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/TrashRepository.kt create mode 100644 mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/trash/TrashScreen.kt create mode 100644 mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/trash/TrashViewModel.kt create mode 100644 mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/dao/TrashCorbeilleTest.kt create mode 100644 mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/migration/Migration18To19Test.kt diff --git a/CHANGELOG.md b/CHANGELOG.md index f7216d8..4ce8e14 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,14 @@ Le format suit [Keep a Changelog](https://keepachangelog.com/fr/1.1.0/) et le ve ## [Unreleased] +### Ajouté +- Corbeille V3 (S1 backend) : `DELETE /files/:id` = trash par défaut (`?mode=purge` = définitif), `POST /files/:id/restore`, `GET /trash` (paginé), trash/restore récursifs (subtree + chaîne d'ancêtres), purge auto serveur après 30j (`TrashRetention`, passe au boot + horaire). +- Versions V3 (S1 backend) : table `resource_versions` (N=3, élagage auto), historique figé à chaque overwrite (`Upload` ciblé), `GET /files/:id/versions` + `POST /files/:id/versions/:n/restore` (l'actuel est à son tour versionné), upload ciblé vers trashé → `NOT_FOUND`. +- Outbox : ops `trash_resource` / `restore_resource` / `purge_resource` (owner-only, `delete_resource` legacy mappé vers trash, même idempotence) ; purge d'octets best-effort côté serveur. +- Migrations `000017` (index corbeille) + `000018` (versions), contrat `docs/api-v1.md` §3/§6.1 étendu, test de contrat `router_test.go`. +- Extract générique V3 (S2 backend) : package `extract` (règles FR stdlib — dates/échéances/périodes/montants/émetteurs/références masquées/`doc_type` suggéré, confiances, corpus testé), table `resource_facts` (migration `000019`, `origin` auto/user), hook worker OCR (`OnText` + backfill boot borné, best-effort, anti-panic), `GET /files/:id/facts` (viewer+, `[]` si vide, 404 si trashé/étranger). +- Corbeille V3 (S1 mobile, Room v19) : colonne `trashed_at` (files + folders, migration 18→19), tombstone `exists = 0` (requêtes `exists = 1` inchangées), `FileDeleter`/`FolderDeleter`/`SafFileDeleter` → ops `trash_resource` (plus de `delete_resource` émis), garde walk anti-résurrection + reconcile, `TrashRepository` (restore/purge/convergence `GET /trash`/expiration locale 31j), écran Corbeille (Réglages → restore/purge avec confirmation), expiration tombstones dans `RetentionWorker`, dialogue de suppression rewordé (corbeille 30j, plus « irréversible »). + ## [1.1.0] - 2026-09-25 ### Ajouté diff --git a/V3.md b/V3.md new file mode 100644 index 0000000..d088aaf --- /dev/null +++ b/V3.md @@ -0,0 +1,122 @@ +# Kazier V3 — « Le classeur qui comprend » + +Statut : **vision validée** (2026-09-25). V1 (1.0.0, socle local-first + partage) et V2 (1.1.0, multi-device : upload/download, placements, rétention, groupes) sont livrées. Ce document est le contrat produit + plan d'exécution de la V3. + +## 1. Positionnement (acté) + +- **Tout fichier est un document potentiel, y compris une photo.** Une image (scan, photo de papier, photo tout court) suit le même pipeline : OCR quand il y a du texte, faits génériques, FTS, relations. En revanche **aucune analyse biométrique ou sémantique d'image** : pas de visages, pas de lieux, pas d'événements, pas de clustering de personnes. Si une photo contient du texte (affiche, facture photographiée), on l'exploite ; sinon elle reste un fichier comme un autre (nom, dossier, favori, partage). +- **Tous les documents comptent pareil.** Pas de top-5 types prioritaires. Extraction **générique d'abord** (dates, montants, émetteurs, références), typage (`facture`, `contrat`…) en **bonus humble** : suggestion corrigeable, jamais gate, jamais pénalisant. +- **Humble par design.** L'extraction se trompe (~20% au début). Donc : chaque fait porte une `confidence`, l'UI affiche le douteux en « suggéré », la recherche **déclasse mais n'exclut jamais** sur un fait douteux, et tout est corrigeable en un tap. +- **Échéance = facette, pas alerte.** Trop bruitée pour notifier (faux « expiré » dangereux). Filtre + tri uniquement. Alertes = V4 éventuelle, sur preuve de fiabilité via feedback. +- **100% self-hosté / local-first.** Aucun appel IA externe. Règles FR + petits modèles CPU côté serveur, cache Room offline, workers async jamais bloquants (même pattern que `Ocr.Run`). +- **Pas de LLM génératif en V3.** On extrait des faits vérifiables, on ne rédige rien. Moins d'hallucinations, moins de GPU, plus de confiance famille. + +## 2. Les 5 piliers (cœur, scope 6–8 semaines) + +| # | Pilier | Promesse | Réutilise | +|---|---|---|---| +| P1 | Filet anti-perte | Corbeille 30j + versions N=3 | `deleted_at` soft-delete, `UPLOAD_DIR//.`, overwrite ciblée V2 | +| P2 | Extract générique | Faits universels + type suggéré, validés dans le review existant | Pipeline `upload ciblé → Tesseract → resources.ocr_text → GET /files/:id/ocr`, gate `processed` | +| P3 | Recherche | FTS nom+ocr+faits, facettes, offline | `FileDao.searchWithFilters` (LIKE+accents), `GET /files/search` serveur | +| P4 | Relations doc | `same_scan` (sûr) + doublons/versions/même-émetteur (invalidables), collections virtuelles | `scan_sessions`+`scan_pages`, `content_hash` (V2.md), versions P1 | +| P5 | Partage sobre | Cercles (groupes V2-6), liens à expiration par défaut, révocation tokens, quota/3-2-1 visible | Snapshot permissions + TTL 24h, `share`/`create_link`, `PATCH /users/me/password` | + +## 2bis. Plan A — cohérence obligatoire (inclus dans la V3, pas du scope en plus) + +Sans ces 4 items, les piliers grincent. Ils sont petits et intégrés aux slices S1–S6 : + +- **A1 Appareils connectés** : exposer `storage_locations` (existe depuis V2, migration `000015`) en lecture `GET /devices` + `DELETE /devices/:id` (révocation = bump `token_version` ciblé ou suppression ligne ; le device révoqué retombe en 401 → re-login refusé `INVALID_DEVICE_ID`). Écran Réglages « Appareils » : voir / révoquer un téléphone perdu. Grosse valeur famille, ~1 endpoint + 1 écran. +- **A2 Quota enforcement** : `/usage` (P5) n'est que de l'affichage. Ajouter `users.storage_quota_bytes` (défaut 10 Go, cf. V2.md §3.1) + garde-fou à l'upload (`413 QUOTA_EXCEEDED`) + à l'overwrite versionnée. Migration `000023_quota`. Sans ça, un foyer remplit le disque. +- **A3 Corbeille cohérente des deux côtés** : règle purge serveur (cron au boot + passe quotidienne : `trashed_at < NOW()-30j` → purge dure) **+** miroir mobile (`trashed_at` Room, filtre global `exists=1 AND trashed_at IS NULL`, écran Corbeille). Le walk SAF doit ignorer les trashés (garde `hasPendingTrash`, même pattern que FEEDBACK M5) sinon ils ressuscitent. Fait partie de S1, pas une option. +- **A4 Conflits rename transparents** : `update_metadata` concurrent (2 devices renomment) = last-writer-wins silencieux aujourd'hui. Minimum V3 : comparer `updated_at` (perdant = op arrivée sur `updated_at` plus récent que son `base_updated_at` → appliquée quand même mais flag `conflict` remonté dans la réponse `POST /sync/ops` + badge UI « renommé ailleurs » via snapshot). Pas de CRDT, juste de la transparence. Payload `update_metadata` étendu : `{ name?, baseUpdatedAt? }`. + +## 2ter. Plan B — quick wins produit (inclus : B1, B2, B4 ; B3/B5 en stretch) + +- **B1 Import « classeur » unifié** : un seul point d'entrée « Ajouter un papier » (scan / photo / PDF / fichier) + file d'attente d'import visible (compteur `unprocessed`, déjà en Room). Aujourd'hui scan + upload + PDF builder sont 3 chemins séparés — les unifier en UX, zéro backend nouveau. Inclus (S6). +- **B2 Doublons visibles + action** : `duplicate_of` (P4, hash) exposé en écran « Doublons (240 Mo récupérables) » + action « garder un seul » (= trash les autres, même op `trash_resource`). Les familles adorent. Inclus (S5). +- **B3 Impression / export PDF** : ouvrir le PDF builder existant aux docs déjà stockés (pas qu'au multi-select) + `ACTION_SEND` / impression système. Stretch S7 (pur mobile, pas de backend). +- **B4 Accessibilité + i18n** : labels TalkBack sur review/chips/facettes, contrastes, chaînes FR/EN des nouveaux écrans dès la slice (pas de rattrapage). Inclus, transverse à chaque slice. +- **B5 Onboarding foyer** : écran « Crée ton cercle Famille » au premier login + import guidé des 3 premiers papiers (deep-link vers B1 + création groupe V2-6 pré-rempli). Sans ça, les cercles P5 restent vides. Stretch S6 si le temps manque (1 écran + 1 CTA, pas de backend). + +## 2quater. Plan C — dette V2.md : solder ou enterrer (décisions actées) + +- **C1 `retention_policies` serveur (V2.md §3.6) : ENTERRÉ.** La rétention V2 mobile (`RetentionStore` + `RetentionWorker`) fait le job ; une politique serveur ajouterait un 2e cerveau en conflit avec le walk local-first. Documenter dans `docs/api-v1.md` : « la rétention est une affaire locale ». +- **C2 `sync_queue` serveur (V2.md §3.7) : ENTERRÉ.** L'outbox client (`pending_operations` + batch 20 + dead-letter) + workers WM couvrent le besoin. Ne pas rouvrir. +- **C3 Backup 3-2-1 réel : EXPORT, pas second serveur.** `role='backup'` reste un modèle, pas une infra. Minimum V3 : bouton « Exporter tout » (zip + manifest `resource_id, name, hash, facts`) depuis Réglages/Stockage — testé, restaurable, chiffré par le mot de passe (zip AES). Stretch S7, à arbitrer contre les embeddings : **l'export gagne** (vrai 3-2-1 perçu, zéro GPU). + +## 3. Backend — plan fichier par fichier + +### 3.1 Migrations (`backend/db/migrations/`, une par palier, up+down + `migrations_test.go`) + +- `000017_trash` : rien à créer — ajouter index partiel `idx_resources_deleted_at ON resources(deleted_at) WHERE deleted_at IS NOT NULL` + colonne `trashed_at TIMESTAMPTZ` (NULL = vivant ; purge = `trashed_at < NOW()-30j`). Le `DELETE` actuel devient trash (soft), pas de breaking change API. +- `000018_versions` : table `resource_versions (id 32-hex PK, resource_id FK CASCADE, version_no INT, size_bytes BIGINT, content_hash TEXT, stored_path TEXT, created_at)` + `UNIQUE(resource_id, version_no)`. À chaque overwrite d'octets (upload ciblé), la copie précédente est poussée en version (garder N=3, purger la plus vieille). +- `000019_facts` : table `resource_facts (id 32-hex PK, resource_id FK CASCADE, fact_type TEXT CHECK IN ('date','due_date','period','amount','issuer','reference','doc_type'), value_text TEXT, value_num NUMERIC NULL, value_date DATE NULL, confidence REAL CHECK 0..1, origin TEXT CHECK IN ('auto','user'), created_at, updated_at)` + index `(resource_id)`, `(fact_type, value_text)`. `doc_type` n'est qu'un fait comme un autre (suggestion, pas statut). +- `000020_links` : table `resource_links (id 32-hex PK, from_id FK CASCADE, to_id FK CASCADE, link_type TEXT CHECK IN ('same_scan','duplicate_of','version_of','same_issuer','same_reference'), confidence REAL, created_by TEXT CHECK IN ('auto','user'), CHECK(from_id != to_id), UNIQUE(from_id,to_id,link_type))`. +- `000021_token_version` : `ALTER TABLE users ADD COLUMN token_version INT NOT NULL DEFAULT 0` — `PATCH /users/me/password` bump ; claim paseto `tv`, middleware `RequireAuth` rejette `tv != users.token_version` (lève la limite V1 « tokens non révoqués »). +- `000022_search_fts` : colonne `search_tsv TSVECTOR` sur `resources` (générée : `name + ocr_text` ; les facts sont joints à la requête, pas dupliqués) + index GIN + trigger `UPDATE` sur `name/ocr_text`. Fait après P2 pour ne pas indexer du vide. +- `000023_quota` (A2) : `ALTER TABLE users ADD COLUMN storage_quota_bytes BIGINT NOT NULL DEFAULT 10737418240` (10 Go, V2.md §3.1) + vue/fonction `user_used_bytes(user_id)` (somme `size_bytes`hors trash). Check à l'upload et à l'overwrite versionnée → `413 QUOTA_EXCEEDED` (nouveau code §7). + +### 3.2 Extract — nouveau worker (miroir `service/ocr.go`, `cmd/server/main.go`) + +- Nouveau `backend/extract/rules.go` : pur package, **testable sans PG** — entrée `text string`, sortie `[]Fact{Type, ValueText/Num/Date, Confidence}`. Règles FR : dates (`12/03/2026`, `mars 2026`, `échéance ..`), montants (`1 234,56 €`, `EUR`), raisons sociales (ligne en capitales + SIRET/SIREN voisin), références (`n°`, `facture n°`, `contrat`, IBAN masqué → on ne stocke que les 4 derniers chiffres). +- Nouveau `backend/service/extract.go` : struct `Extract{Repository}` + `Run(ctx)` — même squelette que `Ocr.Run` (poll file, `FOR UPDATE SKIP LOCKED`, `QueuePollInterval`, `ResetStale` au boot). Déclencheur : après chaque OCR `done` avec texte non vide (appel direct `Extract.Enqueue/Process` depuis `Ocr.process`, pas de nouvelle file PG — une colonne `extract_status` sur `ocr_jobs` ou simple appel synchrone borné suffit en V3). +- `backend/repository/facts.go` : `UpsertAuto(resourceID, facts)` (remplace les `origin='auto'`, ne touche jamais aux `origin='user'`), `Correct(resourceID, facts)` (écrit `origin='user'`, confidence 1.0), `ListForResource`, `SearchFacets(...)`. +- `backend/repository/links.go` : `EnsureAuto` (idempotent, upsert par `(from,to,type)`), `SetUserVerdict` (confirme/invalide → `created_by='user'`, confidence 0/1), `ListForResource`. Règles auto V3 : `same_scan` (déterministe depuis `scan_sessions` — en fait côté mobile, voir §4, serveur : `duplicate_of` via `content_hash` égal, `version_of` via `resource_versions`, `same_issuer` via facts `issuer` normalisé identique + confidence = min des deux facts). +- `backend/service/resources.go` : trash/restore/purge (`Trash` = set `trashed_at`, `Restore` = NULL, `Purge` = hard delete + versions + faits + liens + fichier physique) ; overwrite d'octets → pousser l'ancienne copie en `resource_versions` avant écriture. +- `backend/service/sync.go` : nouvelles ops outbox **`trash_resource` / `restore_resource` / `purge_resource` / `correct_facts`** (même enveloppe §6.1, `operation_id` 32-hex, idempotence `(device_id, operation_id)`, arrêt au premier échec non-idempotent). `delete_resource` legacy → mappé vers `trash_resource` (pas de break client existant). `correct_facts` porte `[{fact_type, value, confidence}]`, applique `Correct` (writer = user, écrase l'auto). +- `backend/handlers/` : `GET /trash` (liste `trashed`, paginé, même enveloppe `{data,meta}`), `POST /files/:id/restore`, `DELETE /files/:id?mode=purge` (défaut trash ; `purge` = définitif), `GET /files/:id/versions` + `POST /files/:id/versions/:n/restore`, `GET /files/:id/facts` + `PATCH /files/:id/facts` (correction directe, même sémantique que `correct_facts`), `GET /files/:id/links`, `GET /users/me/usage` (quota + copies 3-2-1 : `used_bytes`, `quota_bytes`, `copies`, `offsite_ok`), `GET /devices` + `DELETE /devices/:id` (A1, lecture `storage_locations` + révocation), `GET /export` (C3, zip + manifest, streamé). Tous scopés `viewer+` lecture / `owner` mutation sauf `correct_facts` (`editor+`, comme `update_metadata`). +- `backend/handlers/router.go` + `cmd/server/router_test.go` : enregistrer les routes (le test de contrat miroir du client doit rester vert). +- `docs/api-v1.md` §6.1/§7 : documenter les 4 ops + codes (`TRASHED` vs `NOT_FOUND` — une ressource trashée reste `NOT_FOUND` en lecture normale, visible seulement via `/trash`). + +### 3.3 Recherche serveur + +- `repository/resources.go` `SearchFilesVisible` : brancher `search_tsv @@ plainto_tsquery('french', q)` en OR avec le `LIKE` existant (compat), rank `ts_rank` + bonus si match facts (`issuer`, `reference`). Jamais d'exclusion sur fait basse-confiance : `confidence < 0.5` → pondération /2, pas filtre. +- Facettes : `GET /files/search?q=&issuer=&from=&to=&min_amount=&max_amount=&doc_type=` — filtres SQL sur `resource_facts` (jointure, `origin` indifférent, `doc_type` = suggestion acceptée comme filtre mais affichée « suggéré » si `origin='auto'`). + +## 4. Mobile — plan fichier par fichier + +### 4.1 Room (v19 → v20, `AppDatabase.kt`, `Migrations.kt`, `app/schemas/` exporté, tests `MigrationXToYTest`) + +- v19 : `resource_facts (id, resource_id FK CASCADE, fact_type, value_text, value_num, value_date, confidence, origin, updated_at)` + `resource_links (id, from_id, to_id, link_type, confidence, created_by)` + miroir `trashed_at` + `is_favorite` sur `files` (colonne, pas table — un flag suffit). DAO `FactsDao`, `LinksDao`. +- v20 : FTS4 `files_fts (name, ocr_text, facts_text)` + triggers sync + requête `searchDocuments(query, facets)` remplaçant `searchWithFilters` pour les docs (garder l'ancien pour dossiers). `facts_text` = concat des `value_text` — reconstruit à chaque sync facts. +- `OutboxRepository.kt` : `enqueueTrash/restore/purge`, `enqueueCorrectFacts` (payload `[{fact_type, value}]`, `GenerateId` 32-hex, même transaction Room que la mutation parente — contrat outbox atomique inchangé). `delete_resource` existant → renommé en trash côté appelants (`FileDeleter`, `FolderDeleter`). + +### 4.2 Review = moment de vérité (zéro écran en plus) + +- `OcrRepository.syncFromServer` : après `ocr_text`, rapatrier `GET /files/:id/facts` → Room (même pattern `syncFromServer`, poll existant réutilisé). +- Écran review existant (`FilePendingReviewBadge` + flow « garder ») : ajouter section « Ce qu'on a compris » — chips `Émetteur: EDF • 84,20 € • Échéance: 12/04 (suggéré)` + correction en un tap → `enqueueCorrectFacts` dans la **même transaction** que `markProcessed` (le `create_resource` et la correction partent ensemble — pas d'état intermédiaire). +- Fiche document : section « Voir aussi » (`LinksDao` → `same_scan` d'abord avec badge « sûr », puis autres avec bouton invalider) + section « Faits » (grisé si `confidence < 0.5`). + +### 4.3 Relations `same_scan` (déterministe, local) + +- `ScanExport.kt` : à l'export multi-pages, écrire les liens `same_scan` entre les `resource_id` de la session (même transaction que les `create_resource`). Confiance 1.0, `created_by='user'` (acte volontaire). Poussés via `correct_facts`-like ? Non — nouvelle op `link_pages` ou piggyback sur `create_resource` payload (préféré : champ `scanSessionId` dans le payload `create_resource`, le serveur en déduit `same_scan` — **zéro nouvelle op**). +- Collections virtuelles : table locale `collections + collection_members` (requêtes sauvées sur facts, ex. « Impôts 2026 » = `doc_type suggéré:impôt + period:2026`) — pur local en V3, pas de sync (un device, pas de conflit). Sync serveur = V4. + +### 4.4 Recherche + facettes UI + +- Barre unique : texte + chips facettes (`émetteur`, `période`, `montant`, `type suggéré`). Requête Room FTS offline ; si réseau, `GET /files/search` enrichit (même ranking affiché, source badgée « serveur »). +- OutboxSyncWorker : après drain, enchaîner `FactsSync` (comme `OcrAutoWorker` aujourd'hui) — pas de nouveau worker WM, simple étape dans le worker existant. + +### 4.5 Partage sobre + confiance + +- Sheet existant : expiration lien **7j par défaut** (aujourd'hui `null`), badge « suggéré » sur `doc_type`, section copies déjà là (placements V2) + ligne quota/3-2-1 (`GET /users/me/usage` → Réglages/Stockage existant). +- `SessionManager` : `tv` claim (voir §3.1 `token_version`) — changement de password → autres devices 401 → re-login silencieux existant (aucun code nouveau, juste le claim). + +## 5. Ordre d'exécution (7–9 semaines, chaque ligne = shippable) + +1. **S1 — Filet + A3** (BE `000017/000018` + trash/restore/purge + cron purge 30j + mobile v19 partiel + `FileDeleter` → trash + garde walk `hasPendingTrash` + écran Corbeille) — done quand : supprimer → restaure depuis un 2e device, le walk ne ressuscite pas. +2. **S2 — Extract générique** (`extract/rules.go` + `service/extract.go` + `000019` + `UpsertAuto` + `GET /files/:id/facts`) — done quand : un scan EDF propose émetteur/montant/échéance. +3. **S3 — Review + correction** (mobile v19 facts + chips review + `correct_facts` + `PATCH /files/:id/facts` + B4 a11y du review) — done quand : corriger en un tap converge serveur ↔ 2e device. +4. **S4 — Recherche** (`000022` FTS + facettes serveur + Room FTS v20 + barre à chips + B4 a11y facettes) — done quand : « facture edf mars » trouve `scan_042.pdf` offline ET online. +5. **S5 — Relations + B2** (`000020` + `duplicate/same_issuer` auto + `same_scan` via `scanSessionId` + fiche « Voir aussi » + collections locales + écran Doublons « garder un seul ») — done quand : fiche CNI → verso + doublon listés, invalidables ; doublons chiffrés en Mo récupérables. +6. **S6 — Partage sobre + A1/A2/A4 + B1 (+B5 si temps)** (expiration défaut 7j + `000021` token_version + `000023` quota + `413 QUOTA_EXCEEDED` + `GET /devices` + écran Appareils + `update_metadata{baseUpdatedAt}` + flag `conflict` + import « classeur » unifié B1 + onboarding cercle B5) — done quand : lien RIB expiré → `NOT_FOUND`, password changé → autres devices re-logués, device perdu révoqué, quota plein → 413 propre, rename concurrent → badge « renommé ailleurs ». +7. **S7 — Preview 1ère page** (`pdf_preview` V2.md §3.3, une seule taille) + **C3 export chiffré** (`GET /export` zip + manifest) + B3 impression si temps + polish + release 1.2.0. Arbitrage stretch : **export > embeddings** (vrai 3-2-1 perçu, zéro GPU). + +## 6. Tests (mêmes harnais, pas de nouveau framework) + +- BE : `dbtest` + `go test ./...` — `extract/rules_test.go` (corpus FR : factures, bulletins, courriers, cas limites montants/dates), tests repo `facts/links` (upsert auto n'écrase pas user, recherche ne filtre pas sur low-confidence), tests handlers (trash/restore/purge, versions, facts, links, usage, devices, export, quota 413, conflit rename), `router_test.go` vert. +- Mobile : `:app:testDebugUnitTest` (Robolectric + Room in-memory) — `Migration18To19/19To20Test`, `FactsSyncTest` (round-trip `correct_facts`), `SearchFtsTest` (accents, `%`/`_` échappés, facettes), `SameScanTest` (export multi-pages → liens), `TrashWalkTest` (walk n ressuscite pas les trashés, miroir FEEDBACK M5), `DuplicatesTest`, `QuotaBadgeTest`. + +## 7. Non-goals V3 (actés, basculables V4) + +Alertes d'échéance, résumés/chat LLM, embeddings sémantiques (déscopés au profit de C3 export — tables `facts`/`links` déjà prêtes à les accueillir en V4), analyse d'image biométrique/sémantique (visages, lieux, événements, clustering personnes — **hors vision par principe**, les photos restent des documents image), OCR on-device, transcodage vidéo, E2EE dédiée (les facts/liens héritent des perms `viewer+` comme `ocr_text` — pas de nouveau modèle de droits), sync des collections, client desktop/web, fédération, `retention_policies` serveur (C1 enterré : rétention = affaire locale), `sync_queue` serveur (C2 enterré : l'outbox client fait le job). diff --git a/backend/cmd/server/main.go b/backend/cmd/server/main.go index 3109175..7168994 100644 --- a/backend/cmd/server/main.go +++ b/backend/cmd/server/main.go @@ -87,6 +87,16 @@ func main() { ) handlers.Ocr = service.NewOcr(repo, cfg.UploadDir, cfg.OcrLang, ocr.NewTesseract()) + // V3 S2 : faits génériques — chaque texte OCR extrait alimente + // `resource_facts` (origin='auto'). Enrichissement best-effort : un + // échec d'extract ne fait jamais échouer le job OCR. + extractSvc := service.NewExtract(repo) + handlers.Ocr.OnText = func(userID, resourceID, text string) { + if err := extractSvc.ProcessText(resourceID, text); err != nil { + log.Printf("extract: %s: %v", resourceID, err) + } + } + ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM) defer stop() @@ -102,6 +112,47 @@ func main() { }() log.Printf("ocr worker démarré (%d workers)", cfg.OcrWorkers) + // V3 S2 : backfill extract (une passe bornée au boot — les ressources + // avec ocr_text mais sans faits auto, ex. OCR d'avant la V3). + go func() { + n, err := extractSvc.Backfill(200) + if err != nil { + log.Printf("extract backfill: %v", err) + return + } + if n > 0 { + log.Printf("extract backfill: %d ressources enrichies", n) + } + }() + + // V3 corbeille : passe de purge (trash > TrashRetention) au boot puis + // toutes les heures. Best-effort : une passe ratée sera rejouée à la + // suivante, jamais de crash serveur sur une erreur de purge. + go func() { + purge := func() { + n, err := handlers.Store.PurgeExpiredTrash(service.TrashRetention) + if err != nil { + log.Printf("purge corbeille: %v", err) + return + } + if n > 0 { + log.Printf("purge corbeille: %d ressources détruites", n) + } + } + purge() + ticker := time.NewTicker(time.Hour) + defer ticker.Stop() + for { + select { + case <-ctx.Done(): + return + case <-ticker.C: + purge() + } + } + }() + log.Printf("purge corbeille démarrée (rétention %s)", service.TrashRetention) + srv := &http.Server{ Addr: fmt.Sprintf(":%d", cfg.Port), Handler: newRouter(), diff --git a/backend/cmd/server/router_test.go b/backend/cmd/server/router_test.go index a1f61bb..378e3cb 100644 --- a/backend/cmd/server/router_test.go +++ b/backend/cmd/server/router_test.go @@ -17,10 +17,15 @@ var expectedRoutes = []string{ "GET /api/v1/files/folders", "GET /api/v1/files/:id", "GET /api/v1/files/:id/ocr", + "GET /api/v1/files/:id/facts", "GET /api/v1/files/:id/content", "GET /api/v1/files/:id/shares", "GET /api/v1/files/:id/links", "GET /api/v1/files/:id/placements", + "GET /api/v1/files/:id/versions", + "POST /api/v1/files/:id/restore", + "POST /api/v1/files/:id/versions/:n/restore", + "GET /api/v1/trash", "DELETE /api/v1/files/:id", "POST /api/v1/files/upload", diff --git a/backend/db/migrations/000017_trash.down.sql b/backend/db/migrations/000017_trash.down.sql new file mode 100644 index 0000000..7523304 --- /dev/null +++ b/backend/db/migrations/000017_trash.down.sql @@ -0,0 +1 @@ +DROP INDEX IF EXISTS idx_resources_trashed_active; diff --git a/backend/db/migrations/000017_trash.up.sql b/backend/db/migrations/000017_trash.up.sql new file mode 100644 index 0000000..9a89417 --- /dev/null +++ b/backend/db/migrations/000017_trash.up.sql @@ -0,0 +1,7 @@ +-- V3 corbeille : `deleted_at` est le timestamp de trash (restauration = +-- `deleted_at = NULL`, purge = hard delete après 30j via PurgeExpired). +-- Toutes les lectures filtrent déjà `deleted_at IS NULL` : les trashés sont +-- invisibles partout sauf via les requêtes dédiées (ListTrashed). Cet index +-- partiel accélère la corbeille (`GET /trash`) et la passe de purge. +CREATE INDEX IF NOT EXISTS idx_resources_trashed_active + ON resources(user_id, deleted_at) WHERE deleted_at IS NOT NULL; diff --git a/backend/db/migrations/000018_versions.down.sql b/backend/db/migrations/000018_versions.down.sql new file mode 100644 index 0000000..54d83af --- /dev/null +++ b/backend/db/migrations/000018_versions.down.sql @@ -0,0 +1 @@ +DROP TABLE IF EXISTS resource_versions; diff --git a/backend/db/migrations/000018_versions.up.sql b/backend/db/migrations/000018_versions.up.sql new file mode 100644 index 0000000..ca85a9a --- /dev/null +++ b/backend/db/migrations/000018_versions.up.sql @@ -0,0 +1,19 @@ +-- V3 versions : historique léger des octets écrasés (N=3, cf. V3.md P1). +-- À chaque overwrite (upload ciblé), l'ancienne copie physique est déplacée +-- sous `stored_path` (relatif à UPLOAD_DIR) et sa métadonnée figée ici. +-- Restaurer = recopier vers l'emplacement live (l'actuel est à son tour +-- versionné). `ON DELETE CASCADE` : purger la ressource purge ses versions. +CREATE TABLE resource_versions ( + id TEXT PRIMARY KEY CHECK (id ~ '^[0-9a-f]{32}$'), + resource_id TEXT NOT NULL REFERENCES resources(resource_id) ON DELETE CASCADE, + version_no INT NOT NULL CHECK (version_no >= 1), + size_bytes BIGINT NOT NULL DEFAULT 0, + mime_type VARCHAR(255), + extension VARCHAR(64), + content_hash VARCHAR(128), + stored_path TEXT NOT NULL, + created_at TIMESTAMPTZ DEFAULT NOW(), + UNIQUE (resource_id, version_no) +); + +CREATE INDEX idx_versions_resource ON resource_versions(resource_id); diff --git a/backend/db/migrations/000019_facts.down.sql b/backend/db/migrations/000019_facts.down.sql new file mode 100644 index 0000000..293274d --- /dev/null +++ b/backend/db/migrations/000019_facts.down.sql @@ -0,0 +1 @@ +DROP TABLE IF EXISTS resource_facts; diff --git a/backend/db/migrations/000019_facts.up.sql b/backend/db/migrations/000019_facts.up.sql new file mode 100644 index 0000000..04ea4d8 --- /dev/null +++ b/backend/db/migrations/000019_facts.up.sql @@ -0,0 +1,23 @@ +-- V3 extract générique (S2) : faits universels extraits du texte OCR +-- (dates, montants, émetteurs, références, type suggéré) — cf. V3.md §2. +-- `doc_type` n'est qu'un fait comme un autre (suggestion, jamais gate) ; +-- `origin` distingue l'auto (remplaçable à chaque passe) du `user` (S3, +-- correction en un tap — l'auto ne l'écrase jamais). Cascade : purger la +-- ressource purge ses faits. +CREATE TABLE resource_facts ( + id TEXT PRIMARY KEY CHECK (id ~ '^[0-9a-f]{32}$'), + resource_id TEXT NOT NULL REFERENCES resources(resource_id) ON DELETE CASCADE, + fact_type TEXT NOT NULL CHECK (fact_type IN ( + 'date', 'due_date', 'period', 'amount', 'issuer', 'reference', 'doc_type' + )), + value_text TEXT, + value_num NUMERIC, + value_date DATE, + confidence REAL NOT NULL CHECK (confidence >= 0 AND confidence <= 1), + origin TEXT NOT NULL DEFAULT 'auto' CHECK (origin IN ('auto', 'user')), + created_at TIMESTAMPTZ DEFAULT NOW(), + updated_at TIMESTAMPTZ DEFAULT NOW() +); + +CREATE INDEX idx_facts_resource ON resource_facts(resource_id); +CREATE INDEX idx_facts_type_value ON resource_facts(fact_type, value_text); diff --git a/backend/db/migrations_test.go b/backend/db/migrations_test.go index 3e547d9..a66d3fa 100644 --- a/backend/db/migrations_test.go +++ b/backend/db/migrations_test.go @@ -369,6 +369,59 @@ func TestMigrationsUpDown(t *testing.T) { // --- 000016 : groupes + cible groupe sur shares ------------------------- assertTables(t, conn, "users", "devices", "resources", "operations", "ocr_jobs", "shares", "share_links", "storage_locations", "resource_placements", "groups", "group_members", "schema_migrations") + // --- 000017 : corbeille (index partiel deleted_at) ---------------------- + var trashedIdx int + err = conn.QueryRow(` + SELECT COUNT(*) FROM pg_index i + JOIN pg_class t ON t.oid = i.indrelid + WHERE t.relname = 'resources' AND i.indisvalid + AND pg_get_indexdef(i.indexrelid) LIKE '%idx_resources_trashed_active%'`).Scan(&trashedIdx) + if err != nil { + t.Fatalf("000017 index: %v", err) + } + if trashedIdx == 0 { + t.Error("index idx_resources_trashed_active manquant après 000017") + } + + // --- 000018 : versions -------------------------------------------------- + assertTables(t, conn, "users", "devices", "resources", "operations", "ocr_jobs", "shares", "share_links", "storage_locations", "resource_placements", "groups", "group_members", "resource_versions", "schema_migrations") + + assertHexCheck(t, conn, "resource_versions", "id") + + var versionUniq int + err = conn.QueryRow(` + SELECT COUNT(*) FROM pg_index i + JOIN pg_class t ON t.oid = i.indrelid + WHERE t.relname = 'resource_versions' AND i.indisunique + AND ARRAY(SELECT a.attname FROM unnest(i.indkey) WITH ORDINALITY k(attnum, ord) + JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum + ORDER BY k.ord)::text[] = ARRAY['resource_id','version_no']`).Scan(&versionUniq) + if err != nil { + t.Fatalf("versions unique: %v", err) + } + if versionUniq == 0 { + t.Error("contrainte UNIQUE(resource_id, version_no) manquante sur resource_versions après 000018") + } + + // --- 000019 : faits génériques ----------------------------------------- + assertTables(t, conn, "users", "devices", "resources", "operations", "ocr_jobs", "shares", "share_links", "storage_locations", "resource_placements", "groups", "group_members", "resource_versions", "resource_facts", "schema_migrations") + + assertHexCheck(t, conn, "resource_facts", "id") + + var factTypeCheck int + err = conn.QueryRow(` + SELECT COUNT(*) FROM pg_constraint c + JOIN pg_class t ON t.oid = c.conrelid + WHERE t.relname = 'resource_facts' + AND pg_get_constraintdef(c.oid) LIKE '%doc_type%' + AND pg_get_constraintdef(c.oid) LIKE '%due_date%'`).Scan(&factTypeCheck) + if err != nil { + t.Fatalf("check resource_facts.fact_type: %v", err) + } + if factTypeCheck == 0 { + t.Error("CHECK fact_type manquant sur resource_facts après 000019") + } + if err := MigrateDownDatabase(url); err != nil { t.Fatalf("migrate down: %v", err) } diff --git a/backend/extract/rules.go b/backend/extract/rules.go new file mode 100644 index 0000000..1911f88 --- /dev/null +++ b/backend/extract/rules.go @@ -0,0 +1,408 @@ +// Package extract derives generic, verifiable facts from OCR text (V3 S2). +// +// Rules-based French heuristics, zero ML : every fact carries a confidence, +// low-confidence facts are suggested (greyed in UI) and user-correctable (S3), +// and search demotes but never excludes on them. No LLM, no network, pure +// stdlib — it runs inside the OCR worker right after Tesseract. +package extract + +import ( + "fmt" + "regexp" + "strconv" + "strings" + "unicode" +) + +// Fact types — mirror of the resource_facts CHECK (migration 000019). +type FactType string + +const ( + FactDate FactType = "date" + FactDueDate FactType = "due_date" + FactPeriod FactType = "period" + FactAmount FactType = "amount" + FactIssuer FactType = "issuer" + FactReference FactType = "reference" + FactDocType FactType = "doc_type" +) + +// Fact is one extracted statement. ValueText holds issuer names, reference +// codes ("facture:FA-2026-0031"), doc types and periods ("2026-03") ; +// ValueNum holds amounts (HasNum) ; ValueDate holds ISO dates ("2026-03-12"). +type Fact struct { + Type FactType + ValueText string + ValueNum float64 + HasNum bool + ValueDate string + Confidence float64 +} + +// MaxFacts caps the output per resource (OCR garbage must stay bounded). +const MaxFacts = 50 + +// FromText extracts generic facts from raw OCR text. Deterministic output +// order (document order within each type, types in fixed order), duplicates +// removed. +func FromText(text string) []Fact { + e := &extractor{seen: map[string]bool{}} + e.extract(collectLines(text)) + out := e.facts + if len(out) > MaxFacts { + out = out[:MaxFacts] + } + return out +} + +type extractor struct { + facts []Fact + seen map[string]bool +} + +func (e *extractor) add(f Fact) { + if f.Confidence < 0 { + f.Confidence = 0 + } + if f.Confidence > 1 { + f.Confidence = 1 + } + key := string(f.Type) + "\x00" + f.ValueText + "\x00" + f.ValueDate + "\x00" + fmt.Sprintf("%.2f", f.ValueNum) + if e.seen[key] { + return + } + e.seen[key] = true + e.facts = append(e.facts, f) +} + +type line struct { + raw string + folded string +} + +func collectLines(text string) []line { + raw := strings.Split(text, "\n") + out := make([]line, 0, len(raw)) + for _, r := range raw { + r = strings.TrimSpace(strings.ReplaceAll(r, "\t", " ")) + if r == "" { + continue + } + out = append(out, line{raw: r, folded: fold(r)}) + } + return out +} + +func (e *extractor) extract(lines []line) { + for _, l := range lines { + e.extractAmounts(l) + e.extractDates(l) + e.extractReferences(l) + } + e.extractIssuers(lines) + e.extractDocType(lines) +} + +// --- amounts --------------------------------------------------------------- + +// Note : pas de `\b` après `€` — c'est un symbole (non-mot), donc il n'y a +// jamais de frontière avec un espace ou une fin de ligne. `eur` garde son +// `\b` (évite "europe"), `euros?` n'en a pas besoin. +var amountPattern = regexp.MustCompile(`(\d[\d\s\x{a0}\x{202f}]*[,\.]\d{2}|\d[\d\s\x{a0}\x{202f}]*)\s*(€|euros?|eur\b)`) + +func (e *extractor) extractAmounts(l line) { + // Percentages are not amounts. + if strings.Contains(l.raw, "%") && !strings.ContainsAny(l.raw, "€") { + return + } + for _, m := range amountPattern.FindAllStringSubmatch(l.raw, -1) { + num, ok := parseFrenchNumber(m[1]) + if !ok || num <= 0 || num >= 1e13 { + continue + } + conf := 0.7 + if amountKeywordPattern.MatchString(l.folded) { + conf = 0.9 + } + e.add(Fact{Type: FactAmount, ValueNum: num, HasNum: true, ValueText: formatAmount(num), Confidence: conf}) + } +} + +var amountKeywordPattern = regexp.MustCompile(`\b(total|montant|a payer|net|ttc|solde|du)\b`) + +func formatAmount(num float64) string { + return strconv.FormatFloat(num, 'f', 2, 64) + " €" +} + +// parseFrenchNumber reads "1 234,56" / "1234.56" / "84 €"-style magnitudes. +// Comma = decimal separator (French), dots/spaces (incl. NBSP U+00A0 and +// narrow NBSP U+202F, common in "1 234 €") = thousands. +func parseFrenchNumber(s string) (float64, bool) { + s = strings.ReplaceAll(s, "\u00a0", "") + s = strings.ReplaceAll(s, "\u202f", "") + s = strings.ReplaceAll(s, " ", "") + if strings.Contains(s, ",") { + s = strings.ReplaceAll(s, ".", "") + s = strings.ReplaceAll(s, ",", ".") + } + num, err := strconv.ParseFloat(s, 64) + return num, err == nil +} + +// --- dates ----------------------------------------------------------------- + +var numericDatePattern = regexp.MustCompile(`\b(\d{1,2})\s*[/\-.]\s*(\d{1,2})\s*[/\-.]\s*(\d{2}|\d{4})\b`) + +var writtenDatePattern = regexp.MustCompile(`\b(\d{1,2})\s+(janv(?:ier)?|fev(?:rier)?|mars|avr(?:il)?|mai|juin|juil(?:let)?|aout|sept?(?:embre)?|oct(?:obre)?|nov(?:embre)?|dec(?:embre)?)\s+(\d{4})\b`) + +var periodPattern = regexp.MustCompile(`\b(janv(?:ier)?|fev(?:rier)?|mars|avr(?:il)?|mai|juin|juil(?:let)?|aout|sept?(?:embre)?|oct(?:obre)?|nov(?:embre)?|dec(?:embre)?)\s+(\d{4})\b`) + +var monthNumbers = map[string]int{ + "janv": 1, "janvier": 1, "fev": 2, "fevrier": 2, "mars": 3, + "avr": 4, "avril": 4, "mai": 5, "juin": 6, "juil": 7, + "juillet": 7, "aout": 8, "sept": 9, "septembre": 9, "oct": 10, + "octobre": 10, "nov": 11, "novembre": 11, "dec": 12, "decembre": 12, +} + +var dueKeywordPattern = regexp.MustCompile(`\b(echeance|a payer avant|date limite|avant le|regler avant|paiement avant)\b`) + +func fullYear(yy int) int { + if yy < 100 { + if yy >= 70 { + return 1900 + yy + } + return 2000 + yy + } + return yy +} + +func isoDate(y, m, d int) (string, bool) { + if m < 1 || m > 12 || d < 1 || d > 31 || y < 1900 || y > 2100 { + return "", false + } + return fmt.Sprintf("%04d-%02d-%02d", y, m, d), true +} + +func (e *extractor) extractDates(l line) { + isDue := dueKeywordPattern.MatchString(l.folded) + for _, m := range numericDatePattern.FindAllStringSubmatch(l.raw, -1) { + d, _ := strconv.Atoi(m[1]) + mo, _ := strconv.Atoi(m[2]) + y, _ := strconv.Atoi(m[3]) + iso, ok := isoDate(fullYear(y), mo, d) + if !ok { + continue + } + typ := FactDate + conf := 0.6 + if isDue { + typ, conf = FactDueDate, 0.8 + } + e.add(Fact{Type: typ, ValueDate: iso, ValueText: iso, Confidence: conf}) + } + for _, m := range writtenDatePattern.FindAllStringSubmatch(l.folded, -1) { + d, _ := strconv.Atoi(m[1]) + mo := monthNumbers[m[2]] + y, _ := strconv.Atoi(m[3]) + iso, ok := isoDate(y, mo, d) + if !ok { + continue + } + typ := FactDate + conf := 0.7 + if isDue { + typ, conf = FactDueDate, 0.85 + } + e.add(Fact{Type: typ, ValueDate: iso, ValueText: iso, Confidence: conf}) + } + for _, m := range periodPattern.FindAllStringSubmatch(l.folded, -1) { + mo := monthNumbers[m[1]] + y, _ := strconv.Atoi(m[2]) + if mo == 0 || y < 1900 || y > 2100 { + continue + } + e.add(Fact{Type: FactPeriod, ValueText: fmt.Sprintf("%04d-%02d", y, mo), Confidence: 0.7}) + } +} + +// --- references ------------------------------------------------------------ + +// referencePattern catches "facture n° FA-2026-0031", "contrat : ABC123", +// "client 42" — the code must contain a digit (avoids "FACTURE DU MOIS"). +var referencePattern = regexp.MustCompile(`(?i)\b(facture|contrat|client|compte|dossier|bulletin|commande|devis|attestation|police)\s*(n°|no|num(?:ero)?|number|ref(?:erence)?)?\s*[:\-#]?\s*([A-Z0-9][A-Z0-9\-/\.]{1,29})`) + +var bareRefPattern = regexp.MustCompile(`\bn°\s*([A-Z0-9][A-Z0-9\-/]{2,20})`) + +var siretPattern = regexp.MustCompile(`(?i)\b(siret|siren|rcs)\b[^\d]{0,10}(\d{3}\s?\d{3}\s?\d{3}(?:\s?\d{5})?)`) + +var ibanPattern = regexp.MustCompile(`\bFR\s?\d{2}(?:\s?[0-9A-Z]{4}){5}\s?[0-9A-Z]{0,3}\b`) + +func hasDigit(s string) bool { + for _, r := range s { + if r >= '0' && r <= '9' { + return true + } + } + return false +} + +func (e *extractor) extractReferences(l line) { + for _, m := range referencePattern.FindAllStringSubmatch(l.raw, -1) { + code := strings.Trim(m[3], "-/.") + if !hasDigit(code) || len(code) < 3 { + continue + } + kind := strings.ToLower(m[1]) + e.add(Fact{Type: FactReference, ValueText: kind + ":" + code, Confidence: 0.75}) + } + for _, m := range bareRefPattern.FindAllStringSubmatch(l.raw, -1) { + code := m[1] + if !hasDigit(code) { + continue + } + e.add(Fact{Type: FactReference, ValueText: "ref:" + code, Confidence: 0.6}) + } + if m := siretPattern.FindStringSubmatch(l.raw); m != nil { + digits := strings.Join(strings.Fields(m[2]), " ") + e.add(Fact{Type: FactReference, ValueText: strings.ToLower(m[1]) + ":" + digits, Confidence: 0.9}) + } + if m := ibanPattern.FindString(l.raw); m != "" { + compact := strings.ReplaceAll(m, " ", "") + if len(compact) == 27 { + // Store masked (privacy) : only the last 4 chars. + e.add(Fact{Type: FactReference, ValueText: "rib:••••" + compact[len(compact)-4:], Confidence: 0.9}) + } + } +} + +// --- issuers --------------------------------------------------------------- + +var companySuffixPattern = regexp.MustCompile(`(?i)\b(sarl|sas|sa|eurl|sasu|sci|eirl|snc|sasau)\b`) + +func isCapsLine(s string) bool { + letters := 0 + for _, r := range s { + if unicode.IsLetter(r) { + letters++ + if unicode.IsLower(r) { + return false + } + } + } + return letters >= 3 +} + +func (e *extractor) extractIssuers(lines []line) { + found := 0 + checked := 0 + for _, l := range lines { + if checked >= 8 || found >= 2 { + break + } + raw := strings.TrimSpace(l.raw) + if len([]rune(raw)) < 3 || len([]rune(raw)) > 60 { + continue + } + if strings.Contains(raw, "@") || strings.HasPrefix(strings.ToLower(raw), "http") { + continue + } + checked++ + if !isCapsLine(raw) { + continue + } + // Skip lines that are really dates/amounts/references in disguise. + if numericDatePattern.MatchString(raw) || amountPattern.MatchString(raw) || bareRefPattern.MatchString(raw) { + continue + } + conf := 0.45 + if found == 0 { + conf = 0.55 + } + if companySuffixPattern.MatchString(raw) { + conf = 0.75 + } + e.add(Fact{Type: FactIssuer, ValueText: raw, Confidence: conf}) + found++ + } +} + +// --- doc_type suggestion --------------------------------------------------- + +// docTypeKeywords maps a suggested type to weighted French keywords (folded). +// A type is emitted when its score reaches docTypeThreshold — the type is a +// humble suggestion (S3-correctable), never a gate. +var docTypeKeywords = []struct { + typ string + keywords map[string]int +}{ + {"facture", map[string]int{"facture": 2, "tva": 1, "montant ttc": 2, "total ttc": 2, "a payer": 1, "devis": 1}}, + {"bulletin", map[string]int{"bulletin": 2, "salaire": 2, "paie": 1, "net social": 2, "brut": 1}}, + {"impot", map[string]int{"impot": 2, "revenu fiscal": 2, "taxe fonciere": 2, "taxe d habitation": 1, "avis d impot": 2}}, + {"contrat", map[string]int{"contrat": 2, "bail": 2, "convention": 1, "article ": 1, "assurance": 1}}, + {"ordonnance", map[string]int{"ordonnance": 2, "posologie": 2, "docteur": 1, "traitement": 1}}, + {"attestation", map[string]int{"attestation": 2, "certifie": 1, "certificat": 1, "atteste": 1}}, + {"rib", map[string]int{"rib": 2, "iban": 2, "bic": 1}}, + {"identite", map[string]int{"carte d identite": 2, "passeport": 2, "permis de conduire": 2, "nationalite": 1}}, +} + +const docTypeThreshold = 2 + +func (e *extractor) extractDocType(lines []line) { + joined := "\n" + for _, l := range lines { + joined += l.folded + "\n" + } + best, bestScore := "", 0 + for _, dt := range docTypeKeywords { + score := 0 + for kw, w := range dt.keywords { + if strings.Contains(joined, kw) { + score += w + } + } + if score > bestScore { + best, bestScore = dt.typ, score + } + } + if bestScore >= docTypeThreshold { + conf := 0.5 + 0.1*float64(bestScore) + if conf > 0.85 { + conf = 0.85 + } + e.add(Fact{Type: FactDocType, ValueText: best, Confidence: conf}) + } +} + +// --- folding --------------------------------------------------------------- + +// fold lowercases French text and strips accents (œ→oe, æ→ae, ç→c) for +// keyword matching. stdlib-only (no x/text dependency churn). +func fold(s string) string { + var b strings.Builder + b.Grow(len(s)) + for _, r := range strings.ToLower(s) { + switch r { + case 'à', 'â', 'ä': + b.WriteRune('a') + case 'é', 'è', 'ê', 'ë': + b.WriteRune('e') + case 'î', 'ï': + b.WriteRune('i') + case 'ô', 'ö': + b.WriteRune('o') + case 'ù', 'û', 'ü': + b.WriteRune('u') + case 'ÿ': + b.WriteRune('y') + case 'ç': + b.WriteRune('c') + case 'œ': + b.WriteString("oe") + case 'æ': + b.WriteString("ae") + default: + b.WriteRune(r) + } + } + return b.String() +} diff --git a/backend/extract/rules_test.go b/backend/extract/rules_test.go new file mode 100644 index 0000000..07054be --- /dev/null +++ b/backend/extract/rules_test.go @@ -0,0 +1,183 @@ +package extract + +import ( + "testing" +) + +func factsByType(facts []Fact) map[FactType][]Fact { + out := map[FactType][]Fact{} + for _, f := range facts { + out[f.Type] = append(out[f.Type], f) + } + return out +} + +func hasText(facts []Fact, want string) bool { + for _, f := range facts { + if f.ValueText == want { + return true + } + } + return false +} + +const edfBill = `EDF - SERVICE CLIENTS +TSA 12345 +Facture n° FA-2026-0031 du 12/03/2026 +Période : mars 2026 +Montant total TTC : 1 234,56 € +À payer avant le 12/04/2026 +Référence client : 123456789 +` + +func TestFactureEDF(t *testing.T) { + by := factsByType(FromText(edfBill)) + + if !hasText(by[FactReference], "facture:FA-2026-0031") { + t.Errorf("référence facture manquante: %+v", by[FactReference]) + } + if !hasText(by[FactDate], "2026-03-12") { + t.Errorf("date émission manquante: %+v", by[FactDate]) + } + if !hasText(by[FactDueDate], "2026-04-12") { + t.Errorf("échéance manquante: %+v", by[FactDueDate]) + } + if !hasText(by[FactPeriod], "2026-03") { + t.Errorf("période manquante: %+v", by[FactPeriod]) + } + found := false + for _, f := range by[FactAmount] { + if f.HasNum && f.ValueNum == 1234.56 && f.Confidence >= 0.9 { + found = true + } + } + if !found { + t.Errorf("montant 1234.56 (conf 0.9) manquant: %+v", by[FactAmount]) + } + if !hasText(by[FactIssuer], "EDF - SERVICE CLIENTS") { + t.Errorf("émetteur manquant: %+v", by[FactIssuer]) + } + if !hasText(by[FactDocType], "facture") { + t.Errorf("doc_type facture manquant: %+v", by[FactDocType]) + } +} + +const bulletin = `BULLETIN DE SALAIRE +DUPONT Jean +Période : janvier 2026 +Salaire brut : 2 845,00 € +Net social : 2 210,35 € +SIRET 123 456 789 00012 +` + +func TestBulletinSalaire(t *testing.T) { + by := factsByType(FromText(bulletin)) + if !hasText(by[FactDocType], "bulletin") { + t.Errorf("doc_type bulletin manquant: %+v", by[FactDocType]) + } + if !hasText(by[FactPeriod], "2026-01") { + t.Errorf("période manquante: %+v", by[FactPeriod]) + } + if !hasText(by[FactReference], "siret:123 456 789 00012") { + t.Errorf("siret manquant: %+v", by[FactReference]) + } + amounts := map[float64]bool{} + for _, f := range by[FactAmount] { + if f.HasNum { + amounts[f.ValueNum] = true + } + } + if !amounts[2845.00] || !amounts[2210.35] { + t.Errorf("montants bulletin manquants: %+v", by[FactAmount]) + } +} + +const ordonnance = `Dr MARTIN Sophie +Ordonnance du 3 mars 2026 +Doliprane 1000mg — 1 matin et soir pendant 7 jours +` + +func TestOrdonnance(t *testing.T) { + by := factsByType(FromText(ordonnance)) + if !hasText(by[FactDocType], "ordonnance") { + t.Errorf("doc_type ordonnance manquant: %+v", by[FactDocType]) + } + if !hasText(by[FactDate], "2026-03-03") { + t.Errorf("date manquante: %+v", by[FactDate]) + } + if len(by[FactAmount]) != 0 { + t.Errorf("1000mg ne doit pas être un montant: %+v", by[FactAmount]) + } +} + +const rib = `RELEVÉ D'IDENTITÉ BANCAIRE +Titulaire : DUPONT Jean +IBAN : FR76 1234 5678 9012 3456 7890 123 +BIC : AGRIFRPP +` + +func TestRIBMasque(t *testing.T) { + by := factsByType(FromText(rib)) + if !hasText(by[FactDocType], "rib") { + t.Errorf("doc_type rib manquant: %+v", by[FactDocType]) + } + if !hasText(by[FactReference], "rib:••••0123") { + t.Errorf("IBAN masqué manquant: %+v", by[FactReference]) + } + // L'IBAN complet ne doit jamais fuiter dans les faits. + for _, f := range by[FactReference] { + if len(f.ValueText) > 20 { + t.Errorf("fuite IBAN en clair: %q", f.ValueText) + } + } +} + +func TestTexteVideEtBruit(t *testing.T) { + if got := FromText(""); len(got) != 0 { + t.Errorf("vide → %d faits, attendu 0", len(got)) + } + // Bruit OCR sans structure : pas de doc_type, pas de montant. + by := factsByType(FromText("lorem ipsum\nbla bla 99\n///")) + if len(by[FactDocType]) != 0 { + t.Errorf("doc_type sur bruit: %+v", by[FactDocType]) + } + if len(by[FactAmount]) != 0 { + t.Errorf("montant sur bruit: %+v", by[FactAmount]) + } +} + +func TestCourrierSimpleSansType(t *testing.T) { + // Tous les documents comptent : un courrier sans mots-clés métier donne + // des faits (date) mais aucun doc_type — jamais pénalisé. + by := factsByType(FromText("Bonjour,\nmerci de me recontacter.\nCordialement.\nParis, le 05/06/2026\n")) + if !hasText(by[FactDate], "2026-06-05") { + t.Errorf("date courrier manquante: %+v", by[FactDate]) + } + if len(by[FactDocType]) != 0 { + t.Errorf("pas de doc_type attendu: %+v", by[FactDocType]) + } +} + +func TestAnneesCourtesEtFormats(t *testing.T) { + by := factsByType(FromText("Fait le 01.02.99\nÉchéance 15-08-26\n")) + if !hasText(by[FactDate], "1999-02-01") { + t.Errorf("année courte 99 → 1999: %+v", by[FactDate]) + } + if !hasText(by[FactDueDate], "2026-08-15") { + t.Errorf("année courte 26 → 2026: %+v", by[FactDueDate]) + } +} + +func TestBornes(t *testing.T) { + // Dates invalides ignorées, pas de crash. + by := factsByType(FromText("le 45/13/2026 et le 00/00/0000")) + if len(by[FactDate])+len(by[FactDueDate]) != 0 { + t.Errorf("dates invalides extraites: %+v", by) + } + // Confiances toujours dans [0,1]. + for _, f := range FromText(edfBill + bulletin + ordonnance + rib) { + if f.Confidence < 0 || f.Confidence > 1 { + t.Errorf("confiance hors bornes: %+v", f) + } + } +} diff --git a/backend/handlers/facts_test.go b/backend/handlers/facts_test.go new file mode 100644 index 0000000..b8081db --- /dev/null +++ b/backend/handlers/facts_test.go @@ -0,0 +1,83 @@ +package handlers_test + +import ( + "encoding/json" + "net/http" + "testing" + + "github.com/kazier/backend/repository" + "github.com/kazier/backend/service" +) + +// TestFactsEndpoint : GET /files/:id/facts — faits auto visibles (viewer+), +// [] si rien d'extractible, 404 si trashé/absent/étranger. +func TestFactsEndpoint(t *testing.T) { + r, store, repo := setup(t) + device := repository.NewID() + token, userID := registerAndLogin(t, r, repo, testUserUsername(device, "fa"), "facts-test-password", device) + + fileID := repository.NewID() + if err := repo.Resources.InsertFile(userID, fileID, "facture.pdf", "", 0, nil, nil); err != nil { + t.Fatalf("insert: %v", err) + } + if err := repo.Resources.UpdateOcrText(userID, fileID, "EDF\nFacture n° F-1 du 01/02/2026\nTotal : 10,00 €\n"); err != nil { + t.Fatalf("ocr text: %v", err) + } + extractSvc := service.NewExtract(repo) + if err := extractSvc.ProcessText(fileID, "EDF\nFacture n° F-1 du 01/02/2026\nTotal : 10,00 €\n"); err != nil { + t.Fatalf("extract: %v", err) + } + _ = store + + rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/facts", token, nil, "") + env := expectOK(t, rec, "facts-get") + var facts []struct { + FactType string `json:"factType"` + ValueText string `json:"valueText"` + ValueNum *float64 `json:"valueNum"` + Confidence float64 `json:"confidence"` + Origin string `json:"origin"` + } + if err := json.Unmarshal(env.Data, &facts); err != nil { + t.Fatalf("facts unmarshal: %v", err) + } + if len(facts) == 0 { + t.Fatal("faits attendus, got []") + } + types := map[string]bool{} + for _, f := range facts { + types[f.FactType] = true + if f.Origin != "auto" { + t.Errorf("origine = %q, attendu auto", f.Origin) + } + } + for _, want := range []string{"reference", "amount", "date", "doc_type"} { + if !types[want] { + t.Errorf("fait %q manquant: %+v", want, facts) + } + } + + // Fichier visible sans faits → [] (200, jamais 404). + emptyID := repository.NewID() + if err := repo.Resources.InsertFile(userID, emptyID, "vide.txt", "", 0, nil, nil); err != nil { + t.Fatalf("insert empty: %v", err) + } + rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+emptyID+"/facts", token, nil, "") + env = expectOK(t, rec, "facts-empty") + if string(env.Data) != "[]" { + t.Fatalf("sans faits : attendu [], got %s", env.Data) + } + + // Trashé → 404 (comme l'OCR). + if _, err := store.Trash(userID, fileID); err != nil { + t.Fatalf("trash: %v", err) + } + rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/facts", token, nil, "") + expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "facts-trashed") + + // Étranger → 404. + deviceB := repository.NewID() + tokenB, _ := registerAndLogin(t, r, repo, testUserUsername(deviceB, "fb"), "facts-test-password", deviceB) + rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+emptyID+"/facts", tokenB, nil, "") + expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "facts-foreign") +} diff --git a/backend/handlers/files.go b/backend/handlers/files.go index e5e916a..f305626 100644 --- a/backend/handlers/files.go +++ b/backend/handlers/files.go @@ -107,7 +107,32 @@ func FilesGetOcr(c *gin.Context) { api.OK(c, dto) } -// FilesContent streame les octets physiques d'un fichier visible (viewer+, +// FilesGetFacts expose les faits génériques d'un fichier visible (V3 S2) : +// GET /files/:id/facts. Même portée que l'OCR (viewer+, own ou shared) — +// les faits dérivent du texte. `[]` si rien d'extractible (jamais 404 pour +// un fichier visible sans faits) ; 404 si trashé/absent/étranger. +func FilesGetFacts(c *gin.Context) { + if Store == nil { + api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized") + return + } + userID := c.GetString(UserIDKey) + id := c.Param("id") + if !deviceIDPattern.MatchString(id) { + api.Error(c, http.StatusNotFound, "NOT_FOUND", "file not found") + return + } + facts, err := Store.GetFacts(userID, id) + if err != nil { + writeError(c, err) + return + } + if facts == nil { + facts = []service.FactDTO{} + } + api.OK(c, facts) +} + // own ou shared) : GET /files/:id/content. Réponse binaire (Content-Type du // fichier, Content-Disposition inline) — jamais d'enveloppe {data}. Supporte // Range via http.ServeContent (Gin c.File). Sans bytes serveur (ressource @@ -145,7 +170,19 @@ func FilesDelete(c *gin.Context) { api.Error(c, http.StatusNotFound, "NOT_FOUND", "file not found") return } - deletedID, err := Store.DeleteFile(userID, id) + // V3 corbeille : DELETE = trash par défaut ; ?mode=purge = destruction + // définitive (lignes + versions + octets). Mode inconnu → 400. + var deletedID string + var err error + switch c.Query("mode") { + case "", "trash": + deletedID, err = Store.Trash(userID, id) + case "purge": + deletedID, err = Store.Purge(userID, id) + default: + api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid query param `mode` (trash|purge)") + return + } if err != nil { writeError(c, err) return @@ -153,6 +190,94 @@ func FilesDelete(c *gin.Context) { api.OK(c, gin.H{"id": deletedID}) } +// FilesRestore restaure une ressource trashée (POST /files/:id/restore). +// Absente/étrangère → 404 NOT_FOUND ; déjà vivante → succès idempotent. +func FilesRestore(c *gin.Context) { + if Store == nil { + api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized") + return + } + userID := c.GetString(UserIDKey) + id := c.Param("id") + if !deviceIDPattern.MatchString(id) { + api.Error(c, http.StatusNotFound, "NOT_FOUND", "file not found") + return + } + restoredID, err := Store.Restore(userID, id) + if err != nil { + writeError(c, err) + return + } + api.OK(c, gin.H{"id": restoredID}) +} + +// TrashList expose la corbeille (GET /trash) : ressources trashées du user, +// les plus récentes d'abord, paginé comme les autres listes. +func TrashList(c *gin.Context) { + if Store == nil { + api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized") + return + } + userID := c.GetString(UserIDKey) + page, pageSize, ok := parsePageParams(c) + if !ok { + return + } + items, total, err := Store.ListTrashed(userID, page, pageSize) + if err != nil { + writeError(c, err) + return + } + api.OKList(c, items, page, pageSize, total) +} + +// VersionsList expose l'historique des octets (GET /files/:id/versions), +// le plus récent d'abord. Ressource trashée/absente/étrangère → 404. +func VersionsList(c *gin.Context) { + if Store == nil { + api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized") + return + } + userID := c.GetString(UserIDKey) + id := c.Param("id") + if !deviceIDPattern.MatchString(id) { + api.Error(c, http.StatusNotFound, "NOT_FOUND", "file not found") + return + } + versions, err := Store.ListVersions(userID, id) + if err != nil { + writeError(c, err) + return + } + api.OK(c, versions) +} + +// VersionRestore recopie la génération n vers le live +// (POST /files/:id/versions/:n/restore). Génération inconnue → 404. +func VersionRestore(c *gin.Context) { + if Store == nil { + api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized") + return + } + userID := c.GetString(UserIDKey) + id := c.Param("id") + if !deviceIDPattern.MatchString(id) { + api.Error(c, http.StatusNotFound, "NOT_FOUND", "file not found") + return + } + n, err := strconv.Atoi(c.Param("n")) + if err != nil || n < 1 { + api.Error(c, http.StatusNotFound, "NOT_FOUND", "version not found") + return + } + dto, err := Store.RestoreVersion(userID, id, n) + if err != nil { + writeError(c, err) + return + } + api.OK(c, dto) +} + func FilesUpload(c *gin.Context) { if Store == nil { api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized") diff --git a/backend/handlers/router.go b/backend/handlers/router.go index f573a0e..0e8a283 100644 --- a/backend/handlers/router.go +++ b/backend/handlers/router.go @@ -33,10 +33,15 @@ func RegisterRoutes(r *gin.Engine) { protected.GET("/files/folders", FoldersList) protected.GET("/files/:id", FilesGet) protected.GET("/files/:id/ocr", FilesGetOcr) + protected.GET("/files/:id/facts", FilesGetFacts) protected.GET("/files/:id/content", FilesContent) protected.GET("/files/:id/shares", SharesList) protected.GET("/files/:id/links", LinksList) protected.GET("/files/:id/placements", PlacementsList) + protected.GET("/files/:id/versions", VersionsList) + protected.POST("/files/:id/restore", FilesRestore) + protected.POST("/files/:id/versions/:n/restore", VersionRestore) + protected.GET("/trash", TrashList) protected.DELETE("/files/:id", FilesDelete) protected.POST("/files/upload", FilesUpload) diff --git a/backend/handlers/trash_test.go b/backend/handlers/trash_test.go new file mode 100644 index 0000000..0479648 --- /dev/null +++ b/backend/handlers/trash_test.go @@ -0,0 +1,160 @@ +package handlers_test + +import ( + "encoding/json" + "net/http" + "testing" + + "github.com/kazier/backend/repository" +) + +// TestTrashEndpoints couvre le cycle corbeille via HTTP : DELETE (trash) → +// 404 en lecture → GET /trash → POST /files/:id/restore → visible → +// DELETE ?mode=purge → corbeille vide, restore → 404. +func TestTrashEndpoints(t *testing.T) { + r, _, repo := setup(t) + device := repository.NewID() + token, userID := registerAndLogin(t, r, repo, testUserUsername(device, "tr"), "trash-test-password", device) + + fileID := repository.NewID() + if err := repo.Resources.InsertFile(userID, fileID, "acte.pdf", "", 0, nil, nil); err != nil { + t.Fatalf("insert: %v", err) + } + + rec, _ := doRequest(t, r, http.MethodDelete, "/api/v1/files/"+fileID, token, nil, "") + expectOK(t, rec, "trash-delete") + + rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID, token, nil, "") + expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "trash-get-hidden") + + rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/trash", token, nil, "") + env := expectOK(t, rec, "trash-list") + var items []struct { + ID string `json:"id"` + Type string `json:"type"` + TrashedAt string `json:"trashedAt"` + } + if err := json.Unmarshal(env.Data, &items); err != nil { + t.Fatalf("trash list unmarshal: %v", err) + } + if len(items) != 1 || items[0].ID != fileID || items[0].TrashedAt == "" { + t.Fatalf("corbeille inattendue: %+v", items) + } + if env.Meta == nil || env.Meta.Total != 1 { + t.Fatalf("meta corbeille: %+v", env.Meta) + } + + rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/files/"+fileID+"/restore", token, nil, "") + expectOK(t, rec, "trash-restore") + + rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID, token, nil, "") + expectOK(t, rec, "trash-get-restored") + + rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/files/"+fileID+"?mode=purge", token, nil, "") + expectOK(t, rec, "trash-purge") + + rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/trash", token, nil, "") + env = expectOK(t, rec, "trash-list-empty") + if env.Meta == nil || env.Meta.Total != 0 { + t.Fatalf("corbeille doit être vide: %+v", env.Meta) + } + + rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/files/"+fileID+"/restore", token, nil, "") + expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "trash-restore-purged") +} + +// TestTrashInvalidMode : ?mode inconnu → 400, la ressource reste vivante. +func TestTrashInvalidMode(t *testing.T) { + r, _, repo := setup(t) + device := repository.NewID() + token, userID := registerAndLogin(t, r, repo, testUserUsername(device, "tm"), "trash-test-password", device) + + fileID := repository.NewID() + if err := repo.Resources.InsertFile(userID, fileID, "doc.pdf", "", 0, nil, nil); err != nil { + t.Fatalf("insert: %v", err) + } + + rec, _ := doRequest(t, r, http.MethodDelete, "/api/v1/files/"+fileID+"?mode=bogus", token, nil, "") + expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "trash-bad-mode") + + rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID, token, nil, "") + expectOK(t, rec, "trash-bad-mode-keeps-live") +} + +// TestTrashIsolation : un user ne voit ni ne touche la corbeille d'autrui. +func TestTrashIsolation(t *testing.T) { + r, _, repo := setup(t) + deviceA := repository.NewID() + deviceB := repository.NewID() + tokenA, userA := registerAndLogin(t, r, repo, testUserUsername(deviceA, "ta"), "trash-test-password", deviceA) + tokenB, _ := registerAndLogin(t, r, repo, testUserUsername(deviceB, "tb"), "trash-test-password", deviceB) + + fileID := repository.NewID() + if err := repo.Resources.InsertFile(userA, fileID, "prive.pdf", "", 0, nil, nil); err != nil { + t.Fatalf("insert: %v", err) + } + + rec, _ := doRequest(t, r, http.MethodDelete, "/api/v1/files/"+fileID, tokenB, nil, "") + expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "trash-foreign") + + rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/trash", tokenB, nil, "") + env := expectOK(t, rec, "trash-foreign-list") + if env.Meta == nil || env.Meta.Total != 0 { + t.Fatalf("corbeille d'autrui doit être vide: %+v", env.Meta) + } + + rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/files/"+fileID, tokenA, nil, "") + expectOK(t, rec, "trash-owner") +} + +// TestVersionsEndpoints : upload miniature (MaxFileSize=10 en test) puis +// re-upload ciblé → GET /files/:id/versions (1 entrée) → restore → contenu +// d'origine. Trashée → versions en 404. +func TestVersionsEndpoints(t *testing.T) { + r, _, repo := setup(t) + device := repository.NewID() + token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "ve"), "trash-test-password", device) + + rec := uploadMultipart(t, r, token, "", "doc.txt", []byte("AAA")) + env := expectOK(t, rec, "versions-upload") + var created fileDTO + if err := json.Unmarshal(env.Data, &created); err != nil { + t.Fatalf("upload unmarshal: %v", err) + } + + rec = uploadMultipartToResource(t, r, token, created.ID, "doc.txt", []byte("BBBB")) + expectOK(t, rec, "versions-overwrite") + + rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+created.ID+"/versions", token, nil, "") + env = expectOK(t, rec, "versions-list") + var vers []struct { + VersionNo int `json:"versionNo"` + Size int64 `json:"size"` + CreatedAt string `json:"createdAt"` + } + if err := json.Unmarshal(env.Data, &vers); err != nil { + t.Fatalf("versions unmarshal: %v", err) + } + if len(vers) != 1 || vers[0].Size != 3 { + t.Fatalf("versions inattendues: %+v", vers) + } + + rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/files/"+created.ID+"/versions/1/restore", token, nil, "") + env = expectOK(t, rec, "versions-restore") + var restored fileDTO + if err := json.Unmarshal(env.Data, &restored); err != nil { + t.Fatalf("restore unmarshal: %v", err) + } + if restored.Size != 3 { + t.Fatalf("live restauré taille=%d, attendu 3", restored.Size) + } + + rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/files/"+created.ID+"/versions/99/restore", token, nil, "") + expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "versions-restore-unknown") + + rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/files/"+created.ID, token, nil, "") + expectOK(t, rec, "versions-trash") + + rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+created.ID+"/versions", token, nil, "") + expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "versions-trashed-hidden") +} diff --git a/backend/repository/facts.go b/backend/repository/facts.go new file mode 100644 index 0000000..29b6316 --- /dev/null +++ b/backend/repository/facts.go @@ -0,0 +1,153 @@ +package repository + +import ( + "database/sql" +) + +// FactParam is one generic fact to persist (V3 S2, migration 000019). +// ValueNum/ValueDate nil when the type carries no numeric/date value. +type FactParam struct { + Type string + ValueText string + ValueNum *float64 + ValueDate *string // ISO YYYY-MM-DD + Confidence float64 +} + +// FactRow is one persisted fact (auto-extracted or user-corrected). +type FactRow struct { + ID string + Type string + ValueText string + ValueNum *float64 + ValueDate *string + Confidence float64 + Origin string +} + +// UpsertAutoFacts replaces the origin='auto' facts of a resource with a fresh +// extraction. Rows with origin='user' (S3 corrections) are never touched. +// An empty params clears stale auto facts (e.g. OCR re-run yielding nothing). +func (r *Resources) UpsertAutoFacts(resourceID string, params []FactParam) error { + tx, err := r.DB.Begin() + if err != nil { + return err + } + defer tx.Rollback() //nolint:errcheck — no-op after Commit. + if _, err := tx.Exec( + `DELETE FROM resource_facts WHERE resource_id = $1 AND origin = 'auto'`, + resourceID, + ); err != nil { + return err + } + for _, p := range params { + id, err := NewIDErr() + if err != nil { + return err + } + if _, err := tx.Exec( + `INSERT INTO resource_facts + (id, resource_id, fact_type, value_text, value_num, value_date, confidence, origin) + VALUES ($1, $2, $3, NULLIF($4, ''), $5, NULLIF($6, '')::date, $7, 'auto')`, + id, resourceID, p.Type, p.ValueText, nullableFloat(p.ValueNum), derefStr(p.ValueDate), clamp01(p.Confidence), + ); err != nil { + return err + } + } + return tx.Commit() +} + +// ListFacts returns the facts of a resource, user-corrected first then auto +// (stable order by type). No visibility check — the caller enforces viewer+ +// (GetFileVisible) like GetFileOcr. +func (r *Resources) ListFacts(resourceID string) ([]FactRow, error) { + rows, err := r.DB.Query( + `SELECT id, fact_type, COALESCE(value_text, ''), value_num, + COALESCE(value_date::text, ''), confidence, origin + FROM resource_facts WHERE resource_id = $1 + ORDER BY CASE origin WHEN 'user' THEN 0 ELSE 1 END, fact_type, value_text`, + resourceID, + ) + if err != nil { + return nil, err + } + defer rows.Close() + out := make([]FactRow, 0) + for rows.Next() { + var row FactRow + var num sql.NullFloat64 + var dat string + if err := rows.Scan(&row.ID, &row.Type, &row.ValueText, &num, &dat, &row.Confidence, &row.Origin); err != nil { + return nil, err + } + if num.Valid { + v := num.Float64 + row.ValueNum = &v + } + if dat != "" { + d := dat + row.ValueDate = &d + } + out = append(out, row) + } + return out, rows.Err() +} + +// factNeedingExtract is a file with OCR text but no auto facts yet. +type factNeedingExtract struct { + ResourceID string + Text string +} + +// ListNeedingExtract returns up to limit files with non-empty ocr_text and no +// origin='auto' facts (boot backfill, S2). Live rows only. +func (r *Resources) ListNeedingExtract(limit int) ([]factNeedingExtract, error) { + rows, err := r.DB.Query( + `SELECT resource_id, ocr_text FROM resources + WHERE type = 'file' AND deleted_at IS NULL + AND ocr_text IS NOT NULL AND ocr_text <> '' + AND NOT EXISTS ( + SELECT 1 FROM resource_facts + WHERE resource_facts.resource_id = resources.resource_id + AND origin = 'auto') + ORDER BY updated_at ASC LIMIT $1`, + limit, + ) + if err != nil { + return nil, err + } + defer rows.Close() + var out []factNeedingExtract + for rows.Next() { + var row factNeedingExtract + if err := rows.Scan(&row.ResourceID, &row.Text); err != nil { + return nil, err + } + out = append(out, row) + } + return out, rows.Err() +} + +func nullableFloat(v *float64) any { + if v == nil { + return nil + } + return *v +} + +func derefStr(v *string) string { + if v == nil { + return "" + } + return *v +} + +func clamp01(v float64) float64 { + if v < 0 { + return 0 + } + if v > 1 { + return 1 + } + return v +} diff --git a/backend/repository/resources.go b/backend/repository/resources.go index 22a4fb8..5bda723 100644 --- a/backend/repository/resources.go +++ b/backend/repository/resources.go @@ -569,13 +569,12 @@ func (r *Resources) UpdateOcrText(ownerID, resourceID, text string) error { // SyncDelete soft-deletes a resource; absence is NOT an error (idempotent // terminal state for the outbox). +// +// Deprecated: V3 trash — préférer TrashResource (récursif sur le subtree). +// Conservé comme alias pour compatibilité (même effet sur une ressource +// sans enfant : TrashResource ne touche que deleted_at IS NULL). func (r *Resources) SyncDelete(ownerID, resourceID string) error { - _, err := r.DB.Exec( - `UPDATE resources SET deleted_at = NOW(), updated_at = NOW() - WHERE resource_id = $1 AND user_id = $2 AND deleted_at IS NULL`, - resourceID, ownerID, - ) - return err + return r.TrashResource(ownerID, resourceID) } // ExistsOwner reports whether a non-deleted resource belongs to the device. diff --git a/backend/repository/trash.go b/backend/repository/trash.go new file mode 100644 index 0000000..2469cd1 --- /dev/null +++ b/backend/repository/trash.go @@ -0,0 +1,191 @@ +package repository + +import ( + "database/sql" + "time" +) + +// TrashedRow is a trashed resource for GET /trash. +type TrashedRow struct { + ID string + Type string + Name string + Size int64 + TrashedAt time.Time + UpdatedAt time.Time +} + +// subtreeCTE selects a resource and all its descendants (any depth). +const subtreeCTE = ` + subtree(id) AS ( + SELECT $2::text + UNION ALL + SELECT r.resource_id FROM resources r JOIN subtree s ON r.parent_id = s.id + )` + +// ancestorsCTE selects a resource and all its ancestors up to the root. +const ancestorsCTE = ` + ancestors(id) AS ( + SELECT $2::text + UNION ALL + SELECT r.parent_id FROM resources r JOIN ancestors a ON r.resource_id = a.id + WHERE r.parent_id IS NOT NULL + )` + +// TrashResource soft-deletes a resource and its whole subtree +// (`deleted_at = NOW()`), owner-scoped. Already-trashed rows are untouched. +// The target must be verified owned beforehand (ExistsOwner / GetResourceOwner) +// for the NOT_FOUND halt semantics — this method only applies. +func (r *Resources) TrashResource(ownerID, resourceID string) error { + _, err := r.DB.Exec( + `WITH RECURSIVE `+subtreeCTE+` + UPDATE resources SET deleted_at = NOW(), updated_at = NOW() + WHERE resource_id IN (SELECT id FROM subtree) + AND user_id = $1 AND deleted_at IS NULL`, + ownerID, resourceID, + ) + return err +} + +// RestoreResource clears the trash flag on a resource, its subtree AND its +// ancestor chain (a file whose folder is still trashed would stay +// unreachable otherwise). Independently-trashed descendants are restored too +// — documented V3 behaviour (restoring the folder restores what it contains). +func (r *Resources) RestoreResource(ownerID, resourceID string) error { + _, err := r.DB.Exec( + `WITH RECURSIVE `+subtreeCTE+`, `+ancestorsCTE+` + UPDATE resources SET deleted_at = NULL, updated_at = NOW() + WHERE (resource_id IN (SELECT id FROM subtree) + OR resource_id IN (SELECT id FROM ancestors)) + AND user_id = $1 AND deleted_at IS NOT NULL`, + ownerID, resourceID, + ) + return err +} + +// ExistsOwnerAny reports ownership regardless of trash state (for purge : +// a trashed resource is still owned). +func (r *Resources) ExistsOwnerAny(ownerID, resourceID string) (bool, error) { + var exists int + err := r.DB.QueryRow( + `SELECT 1 FROM resources WHERE resource_id = $1 AND user_id = $2`, + resourceID, ownerID, + ).Scan(&exists) + if err == sql.ErrNoRows { + return false, nil + } + return err == nil, err +} + +// PurgeResource hard-deletes a resource and its subtree (FK CASCADE on +// parent_id + resource_versions), returning every purged resource_id so the +// caller can remove physical files best-effort. Owner-scoped. +func (r *Resources) PurgeResource(ownerID, resourceID string) ([]string, error) { + rows, err := r.DB.Query( + `WITH RECURSIVE subtree(id) AS ( + SELECT $1::text + UNION ALL + SELECT r.resource_id FROM resources r JOIN subtree s ON r.parent_id = s.id + ) + SELECT id FROM subtree`, + resourceID, + ) + if err != nil { + return nil, err + } + var ids []string + for rows.Next() { + var id string + if err := rows.Scan(&id); err != nil { + rows.Close() + return nil, err + } + ids = append(ids, id) + } + rows.Close() + if err := rows.Err(); err != nil { + return nil, err + } + if _, err := r.DB.Exec( + `DELETE FROM resources WHERE resource_id = $1 AND user_id = $2`, + resourceID, ownerID, + ); err != nil { + return nil, err + } + return ids, nil +} + +// ListTrashed returns the owner's trashed resources, most recently trashed +// first, paginated. +func (r *Resources) ListTrashed(ownerID string, limit, offset int) ([]TrashedRow, int, error) { + var total int + if err := r.DB.QueryRow( + `SELECT COUNT(*) FROM resources WHERE user_id = $1 AND deleted_at IS NOT NULL`, + ownerID, + ).Scan(&total); err != nil { + return nil, 0, err + } + rows, err := r.DB.Query( + `SELECT resource_id, type, name, COALESCE(size_bytes, 0), deleted_at, updated_at + FROM resources WHERE user_id = $1 AND deleted_at IS NOT NULL + ORDER BY deleted_at DESC LIMIT $2 OFFSET $3`, + ownerID, limit, offset, + ) + if err != nil { + return nil, 0, err + } + defer rows.Close() + out := make([]TrashedRow, 0) + for rows.Next() { + var row TrashedRow + if err := rows.Scan(&row.ID, &row.Type, &row.Name, &row.Size, &row.TrashedAt, &row.UpdatedAt); err != nil { + return nil, 0, err + } + out = append(out, row) + } + return out, total, rows.Err() +} + +// PurgedResource identifies a row destroyed by the retention pass. +type PurgedResource struct { + UserID string + ResourceID string +} + +// PurgeExpiredTrash hard-deletes every resource trashed before cutoff +// (corbeille 30j), oldest first, bounded by limit. Returns the destroyed +// identities for physical-file cleanup (best-effort, caller-side). +func (r *Resources) PurgeExpiredTrash(cutoff time.Time, limit int) ([]PurgedResource, error) { + rows, err := r.DB.Query( + `SELECT user_id, resource_id FROM resources + WHERE deleted_at IS NOT NULL AND deleted_at < $1 + ORDER BY deleted_at ASC LIMIT $2`, + cutoff, limit, + ) + if err != nil { + return nil, err + } + var out []PurgedResource + for rows.Next() { + var p PurgedResource + if err := rows.Scan(&p.UserID, &p.ResourceID); err != nil { + rows.Close() + return nil, err + } + out = append(out, p) + } + rows.Close() + if err := rows.Err(); err != nil { + return nil, err + } + for _, p := range out { + // Hard delete cascades to children (parent_id FK) and versions. + if _, err := r.DB.Exec( + `DELETE FROM resources WHERE resource_id = $1 AND user_id = $2 AND deleted_at IS NOT NULL AND deleted_at < $3`, + p.ResourceID, p.UserID, cutoff, + ); err != nil { + return out, err + } + } + return out, nil +} diff --git a/backend/repository/versions.go b/backend/repository/versions.go new file mode 100644 index 0000000..86a734a --- /dev/null +++ b/backend/repository/versions.go @@ -0,0 +1,131 @@ +package repository + +import ( + "database/sql" + "time" + + "github.com/lib/pq" +) + +// VersionRow is one frozen byte-generation of a resource. +type VersionRow struct { + ID string + VersionNo int + Size int64 + MimeType string + Extension string + StoredPath string + CreatedAt time.Time +} + +// MaxVersions caps the per-resource history (V3 P1 : N=3). +const MaxVersions = 3 + +// NextVersionNo returns 1 + the highest version number (monotonic, never +// reused even after pruning). +func (r *Resources) NextVersionNo(resourceID string) (int, error) { + var next int + err := r.DB.QueryRow( + `SELECT COALESCE(MAX(version_no), 0) + 1 FROM resource_versions WHERE resource_id = $1`, + resourceID, + ).Scan(&next) + return next, err +} + +// InsertVersion freezes one byte-generation. ID must be NewID() 32-hex. +func (r *Resources) InsertVersion(id, resourceID string, versionNo int, size int64, mimeType, extension *string, storedPath string) error { + _, err := r.DB.Exec( + `INSERT INTO resource_versions (id, resource_id, version_no, size_bytes, mime_type, extension, stored_path) + VALUES ($1, $2, $3, $4, $5, $6, $7)`, + id, resourceID, versionNo, size, mimeType, extension, storedPath, + ) + return err +} + +// ListVersions returns the history of a resource owned by ownerID +// (ownership checked via the parent row), newest first. +func (r *Resources) ListVersions(ownerID, resourceID string) ([]VersionRow, error) { + if _, err := r.GetFile(ownerID, resourceID); err != nil { + // Folders can be versioned too (metadata only has no bytes — in + // practice only files carry versions, but don't 404 on type). + if _, ferr := r.GetFolder(ownerID, resourceID); ferr != nil { + return nil, err + } + } + rows, err := r.DB.Query( + `SELECT v.id, v.version_no, v.size_bytes, COALESCE(v.mime_type, ''), + COALESCE(v.extension, ''), v.stored_path, v.created_at + FROM resource_versions v + JOIN resources r ON r.resource_id = v.resource_id + WHERE v.resource_id = $1 AND r.user_id = $2 AND r.deleted_at IS NULL + ORDER BY v.version_no DESC`, + resourceID, ownerID, + ) + if err != nil { + return nil, err + } + defer rows.Close() + out := make([]VersionRow, 0) + for rows.Next() { + var row VersionRow + if err := rows.Scan(&row.ID, &row.VersionNo, &row.Size, &row.MimeType, &row.Extension, &row.StoredPath, &row.CreatedAt); err != nil { + return nil, err + } + out = append(out, row) + } + return out, rows.Err() +} + +// GetVersion returns one frozen generation (owner-scoped via parent row). +func (r *Resources) GetVersion(ownerID, resourceID string, versionNo int) (VersionRow, error) { + var row VersionRow + err := r.DB.QueryRow( + `SELECT v.id, v.version_no, v.size_bytes, COALESCE(v.mime_type, ''), + COALESCE(v.extension, ''), v.stored_path, v.created_at + FROM resource_versions v + JOIN resources r ON r.resource_id = v.resource_id + WHERE v.resource_id = $1 AND v.version_no = $2 AND r.user_id = $3 AND r.deleted_at IS NULL`, + resourceID, versionNo, ownerID, + ).Scan(&row.ID, &row.VersionNo, &row.Size, &row.MimeType, &row.Extension, &row.StoredPath, &row.CreatedAt) + if err == sql.ErrNoRows { + return VersionRow{}, ErrNotFound + } + return row, err +} + +// PruneVersions deletes generations beyond the newest keepN, returning their +// stored paths for physical cleanup (best-effort, caller-side). +func (r *Resources) PruneVersions(resourceID string, keepN int) ([]string, error) { + rows, err := r.DB.Query( + `SELECT stored_path FROM resource_versions + WHERE resource_id = $1 + ORDER BY version_no DESC OFFSET $2`, + resourceID, keepN, + ) + if err != nil { + return nil, err + } + var paths []string + for rows.Next() { + var p string + if err := rows.Scan(&p); err != nil { + rows.Close() + return nil, err + } + paths = append(paths, p) + } + rows.Close() + if err := rows.Err(); err != nil { + return nil, err + } + if len(paths) == 0 { + return nil, nil + } + if _, err := r.DB.Exec( + `DELETE FROM resource_versions WHERE resource_id = $1 AND stored_path = ANY($2)`, + resourceID, pq.Array(paths), + ); err != nil { + return nil, err + } + return paths, nil +} diff --git a/backend/service/extract.go b/backend/service/extract.go new file mode 100644 index 0000000..dd292b6 --- /dev/null +++ b/backend/service/extract.go @@ -0,0 +1,108 @@ +package service + +import ( + "log" + + "github.com/kazier/backend/extract" + "github.com/kazier/backend/repository" +) + +// Extract derives generic facts from OCR text (V3 S2) — dates, amounts, +// issuers, references, suggested doc type. Rules-based (package extract), +// no ML, no network : it runs inside the OCR worker right after Tesseract +// and stores origin='auto' rows (user corrections, origin='user', survive +// every re-run — see UpsertAutoFacts). +type Extract struct { + Repository *repository.Repository +} + +func NewExtract(repo *repository.Repository) *Extract { + return &Extract{Repository: repo} +} + +// FactDTO serializes one row of GET /files/:id/facts. +type FactDTO struct { + FactType string `json:"factType"` + ValueText string `json:"valueText,omitempty"` + ValueNum *float64 `json:"valueNum,omitempty"` + ValueDate string `json:"valueDate,omitempty"` + Confidence float64 `json:"confidence"` + Origin string `json:"origin"` +} + +// ProcessText extracts facts from text and replaces the resource's auto +// facts. Empty text clears stale auto facts. Never touches user corrections. +func (e *Extract) ProcessText(resourceID, text string) error { + raw := extract.FromText(text) + params := make([]repository.FactParam, 0, len(raw)) + for _, f := range raw { + var num *float64 + if f.HasNum { + n := f.ValueNum + num = &n + } + var dat *string + if f.ValueDate != "" { + d := f.ValueDate + dat = &d + } + text := f.ValueText + // Amounts carry a display string ("1234.56 €") — keep the numeric + // column as the machine value, the text as the human one. + params = append(params, repository.FactParam{ + Type: string(f.Type), + ValueText: text, + ValueNum: num, + ValueDate: dat, + Confidence: f.Confidence, + }) + } + return e.Repository.Resources.UpsertAutoFacts(resourceID, params) +} + +// Backfill processes files with OCR text but no auto facts yet (one boot +// pass, bounded batches). Returns the number of resources processed. +func (e *Extract) Backfill(batch int) (int, error) { + total := 0 + for { + pending, err := e.Repository.Resources.ListNeedingExtract(batch) + if err != nil { + return total, err + } + if len(pending) == 0 { + return total, nil + } + for _, p := range pending { + if err := e.ProcessText(p.ResourceID, p.Text); err != nil { + log.Printf("extract: backfill %s: %v", p.ResourceID, err) + continue + } + total++ + } + } +} + +// GetFacts returns the facts of a visible resource (viewer+, own or shared — +// same scope as GetFileOcr, facts derive from the OCR text). Trashed/absent/ +// foreign → repository.ErrNotFound. +func (s *Resources) GetFacts(userID, resourceID string) ([]FactDTO, error) { + if _, err := s.Repo.GetFileVisible(userID, resourceID); err != nil { + return nil, err + } + rows, err := s.Repository.Resources.ListFacts(resourceID) + if err != nil { + return nil, err + } + out := make([]FactDTO, 0, len(rows)) + for _, row := range rows { + out = append(out, FactDTO{ + FactType: row.Type, + ValueText: row.ValueText, + ValueNum: row.ValueNum, + ValueDate: derefString(row.ValueDate), + Confidence: row.Confidence, + Origin: row.Origin, + }) + } + return out, nil +} diff --git a/backend/service/extract_test.go b/backend/service/extract_test.go new file mode 100644 index 0000000..aa9a1c4 --- /dev/null +++ b/backend/service/extract_test.go @@ -0,0 +1,196 @@ +package service + +import ( + "testing" + + "github.com/kazier/backend/repository" +) + +func newExtractStore(t *testing.T) (*Resources, *Extract) { + t.Helper() + s := newServiceStore(t) + return s, NewExtract(s.Repository) +} + +const extractCorpus = `EDF - SERVICE CLIENTS +Facture n° FA-2026-0031 du 12/03/2026 +Montant total TTC : 84,20 € +À payer avant le 12/04/2026 +` + +func TestProcessTextPersistsAutoFacts(t *testing.T) { + s, ex := newExtractStore(t) + userID := mustCreateUser(t, s.Repository, "extract-auto") + fileID := repository.NewID() + if err := s.Repository.Resources.InsertFile(userID, fileID, "facture.pdf", "", 0, nil, nil); err != nil { + t.Fatalf("insert: %v", err) + } + + if err := ex.ProcessText(fileID, extractCorpus); err != nil { + t.Fatalf("process: %v", err) + } + facts, err := s.GetFacts(userID, fileID) + if err != nil { + t.Fatalf("get facts: %v", err) + } + byType := map[string][]FactDTO{} + for _, f := range facts { + byType[f.FactType] = append(byType[f.FactType], f) + if f.Origin != "auto" { + t.Errorf("origine = %q, attendu auto", f.Origin) + } + } + if len(byType["reference"]) == 0 || len(byType["amount"]) == 0 || + len(byType["date"]) == 0 || len(byType["due_date"]) == 0 || + len(byType["doc_type"]) == 0 { + t.Fatalf("faits manquants: %+v", byType) + } + var amount float64 + for _, f := range byType["amount"] { + if f.ValueNum != nil { + amount = *f.ValueNum + } + } + if amount != 84.20 { + t.Errorf("montant = %v, attendu 84.20", amount) + } +} + +func TestProcessTextPreservesUserCorrections(t *testing.T) { + s, ex := newExtractStore(t) + userID := mustCreateUser(t, s.Repository, "extract-user") + fileID := repository.NewID() + if err := s.Repository.Resources.InsertFile(userID, fileID, "facture.pdf", "", 0, nil, nil); err != nil { + t.Fatalf("insert: %v", err) + } + + // Correction manuelle (S3, simulée en SQL) : l'auto ne doit jamais l'écraser. + if _, err := s.Repository.Resources.DB.Exec( + `INSERT INTO resource_facts (id, resource_id, fact_type, value_text, confidence, origin) + VALUES ($1, $2, 'issuer', 'Vrai Fournisseur', 1.0, 'user')`, + repository.NewID(), fileID, + ); err != nil { + t.Fatalf("seed user fact: %v", err) + } + + if err := ex.ProcessText(fileID, extractCorpus); err != nil { + t.Fatalf("process: %v", err) + } + // Re-passe (idempotence du remplacement auto). + if err := ex.ProcessText(fileID, extractCorpus); err != nil { + t.Fatalf("re-process: %v", err) + } + facts, err := s.GetFacts(userID, fileID) + if err != nil { + t.Fatalf("get facts: %v", err) + } + issuers := map[string]string{} + autoCount := 0 + for _, f := range facts { + if f.FactType == "issuer" { + issuers[f.Origin] = f.ValueText + } + if f.Origin == "auto" { + autoCount++ + } + } + if issuers["user"] != "Vrai Fournisseur" { + t.Errorf("correction user écrasée: %+v", issuers) + } + if autoCount == 0 { + t.Error("aucun fait auto après re-passe") + } + // Pas de doublons auto après deux passes. + seen := map[string]int{} + for _, f := range facts { + if f.Origin == "auto" { + seen[f.FactType+"\x00"+f.ValueText]++ + } + } + for k, n := range seen { + if n > 1 { + t.Errorf("doublon auto %q x%d", k, n) + } + } +} + +func TestProcessTextEmptyClearsStaleAuto(t *testing.T) { + s, ex := newExtractStore(t) + userID := mustCreateUser(t, s.Repository, "extract-clear") + fileID := repository.NewID() + if err := s.Repository.Resources.InsertFile(userID, fileID, "doc.pdf", "", 0, nil, nil); err != nil { + t.Fatalf("insert: %v", err) + } + if err := ex.ProcessText(fileID, extractCorpus); err != nil { + t.Fatalf("process: %v", err) + } + if err := ex.ProcessText(fileID, ""); err != nil { + t.Fatalf("clear: %v", err) + } + facts, err := s.GetFacts(userID, fileID) + if err != nil { + t.Fatalf("get facts: %v", err) + } + if len(facts) != 0 { + t.Fatalf("auto périmés non purgés: %+v", facts) + } +} + +func TestGetFactsScope(t *testing.T) { + s, ex := newExtractStore(t) + owner := mustCreateUser(t, s.Repository, "extract-scope-o") + other := mustCreateUser(t, s.Repository, "extract-scope-x") + fileID := repository.NewID() + if err := s.Repository.Resources.InsertFile(owner, fileID, "doc.pdf", "", 0, nil, nil); err != nil { + t.Fatalf("insert: %v", err) + } + if err := ex.ProcessText(fileID, extractCorpus); err != nil { + t.Fatalf("process: %v", err) + } + + if _, err := s.GetFacts(other, fileID); err != repository.ErrNotFound { + t.Fatalf("étranger : attendu NOT_FOUND, got %v", err) + } + if _, err := s.GetFacts(owner, repository.NewID()); err != repository.ErrNotFound { + t.Fatalf("inconnu : attendu NOT_FOUND, got %v", err) + } + if _, err := s.Trash(owner, fileID); err != nil { + t.Fatalf("trash: %v", err) + } + if _, err := s.GetFacts(owner, fileID); err != repository.ErrNotFound { + t.Fatalf("trashé : attendu NOT_FOUND, got %v", err) + } +} + +func TestBackfill(t *testing.T) { + s, ex := newExtractStore(t) + userID := mustCreateUser(t, s.Repository, "extract-backfill") + oldID := repository.NewID() + if err := s.Repository.Resources.InsertFile(userID, oldID, "vieux.pdf", "", 0, nil, nil); err != nil { + t.Fatalf("insert: %v", err) + } + // OCR d'avant la V3 : texte présent, aucun fait auto. + if err := s.Repository.Resources.UpdateOcrText(userID, oldID, extractCorpus); err != nil { + t.Fatalf("ocr text: %v", err) + } + + n, err := ex.Backfill(200) + if err != nil { + t.Fatalf("backfill: %v", err) + } + if n != 1 { + t.Fatalf("backfill = %d, attendu 1", n) + } + facts, err := s.GetFacts(userID, oldID) + if err != nil || len(facts) == 0 { + t.Fatalf("faits après backfill: %+v %v", facts, err) + } + // Deuxième passe : rien à faire (idempotent). + n, err = ex.Backfill(200) + if err != nil { + t.Fatalf("backfill 2: %v", err) + } + if n != 0 { + t.Fatalf("backfill 2 = %d, attendu 0", n) + } +} diff --git a/backend/service/ocr.go b/backend/service/ocr.go index 6390ea5..e425dd0 100644 --- a/backend/service/ocr.go +++ b/backend/service/ocr.go @@ -41,6 +41,11 @@ type Ocr struct { Lang string Engine ocr.Engine StaleAfter time.Duration + // OnText, quand non-nil, reçoit chaque texte extrait avec succès (V3 S2 : + // le service Extract en dérive des faits génériques). Appelé dans le + // worker, jamais dans un handler ; une erreur est loggée, pas propagée + // (le job OCR reste `done` — l'extract est un enrichissement, pas un gate). + OnText func(userID, resourceID, text string) } func NewOcr(repo *repository.Repository, uploadDir, lang string, engine ocr.Engine) *Ocr { @@ -166,9 +171,10 @@ func (o *Ocr) process(ctx context.Context, row repository.OcrJobRow) { fail(err.Error()) return } + trimmed := strings.TrimSpace(text) // Le texte atterrit sur la ressource (updated_at bumpé) : consultable par // tous les devices du user et les grantees via GET /files/:id/ocr. - if trimmed := strings.TrimSpace(text); trimmed != "" { + if trimmed != "" { if err := o.Repository.Resources.UpdateOcrText(userID, row.FileID, trimmed); err != nil { if errors.Is(err, repository.ErrNotFound) { fail("file not readable") @@ -178,9 +184,27 @@ func (o *Ocr) process(ctx context.Context, row repository.OcrJobRow) { return } } + // V3 S2 : faits génériques (même texte vide — purge les auto périmés). + if o.OnText != nil { + // userID capturing : le user courant, pas un owner résolu plus tard. + if terr := o.safeOnText(userID, row.FileID, trimmed); terr != nil { + log.Printf("ocr: extract %s: %v", row.FileID, terr) + } + } complete(text) } +// safeOnText isole un hook OnText paniquant (règle défectueuse) du worker. +func (o *Ocr) safeOnText(userID, resourceID, text string) (err error) { + defer func() { + if r := recover(); r != nil { + err = fmt.Errorf("extract panic: %v", r) + } + }() + o.OnText(userID, resourceID, text) + return nil +} + // physicalPath résout UPLOAD_DIR//. — l'ext est // choisi à l'upload, le fichier réel est retrouvé par préfixe. Durci (A12) : // identifiants 32-hex uniquement (anti `..`), `Lstat` + fichier régulier diff --git a/backend/service/resources.go b/backend/service/resources.go index 8b230f2..1b3868e 100644 --- a/backend/service/resources.go +++ b/backend/service/resources.go @@ -233,10 +233,6 @@ func (s *Resources) GetFileOcr(ownerID, id string) (FileOcrDTO, error) { }, nil } -func (s *Resources) DeleteFile(ownerID, id string) (string, error) { - return s.Repo.DeleteFile(ownerID, id) -} - func (s *Resources) ListRootFolders(ownerID string) ([]FolderDTO, error) { rows, err := s.Repo.ListRootFoldersVisible(ownerID) if err != nil { @@ -280,11 +276,17 @@ func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID, return FileDTO{}, ErrInvalidUpload } targetExisting := resourceID != "" + var cur repository.FileRow if targetExisting { if !idPattern.MatchString(resourceID) { return FileDTO{}, repository.ErrNotFound } - if _, err := s.Repo.GetFile(ownerID, resourceID); err != nil { + var err error + // GetFile ne voit que le live : un upload vers une ressource + // trashée/absente/d'autrui → NOT_FOUND (jamais de résurrection + // d'octets sur une ligne en corbeille). + cur, err = s.Repo.GetFile(ownerID, resourceID) + if err != nil { return FileDTO{}, err } } else { @@ -327,8 +329,27 @@ func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID, } } + // V3 versions : sur upload ciblé, figer l'ancienne génération AVANT + // l'écriture (le rename atomique de copyMultipartAtomic détruirait + // l'ancien contenu). Staging = copie, jamais move : l'échec reste safe. + // Metadata-only (aucun octet live) → rien à versionner. + var staged, stagedExt string + var stagedSize int64 + var stagedMime string + var hasStaged bool + if targetExisting { + var ferr error + staged, stagedExt, stagedSize, stagedMime, hasStaged, ferr = s.freezeLive(ownerID, resourceID, cur, destDir) + if ferr != nil { + return FileDTO{}, ferr + } + } + written, err := copyMultipartAtomic(file, destDir, destPath, s.MaxFileSize) if err != nil { + if hasStaged { + _ = os.Remove(staged) + } return FileDTO{}, err } @@ -358,6 +379,9 @@ func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID, if !stillOld { _ = os.Remove(destPath) } + if hasStaged { + _ = os.Remove(staged) + } return FileDTO{}, err } // Succès : supprime les anciens suffixes orphelins (stale bytes, cf. #6). @@ -366,6 +390,15 @@ func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID, _ = os.Remove(m) } } + // Overwrite ciblée : l'ancien live devient une version figée (N=3). + // Best-effort après succès des métadonnées : un échec ici ne fait pas + // échouer l'upload (loggé, staging nettoyé). + if hasStaged { + if ferr := s.finalizeVersion(ownerID, resourceID, staged, stagedExt, stagedSize, stagedMime); ferr != nil { + log.Printf("upload: finalize version(%s): %v", resourceID, ferr) + _ = os.Remove(staged) + } + } row, err := s.Repo.GetFile(ownerID, resourceID) if err != nil { diff --git a/backend/service/resources_test.go b/backend/service/resources_test.go index b413a3c..1095d55 100644 --- a/backend/service/resources_test.go +++ b/backend/service/resources_test.go @@ -291,12 +291,24 @@ func TestUploadReuploadNewExtensionRemovesStaleFile(t *testing.T) { if err != nil { t.Fatalf("readdir: %v", err) } - if len(entries) != 1 || entries[0].Name() != resourceID+".jpg" { - names := make([]string, 0, len(entries)) - for _, e := range entries { - names = append(names, e.Name()) + // V3 versions : le re-upload fige l'ancien live (png) en version, le + // cleanup des suffixes orphelins ne touche que le live. Attendu : le + // live `.jpg` + un dossier `.versions/` contenant le png figé. + var live []string + for _, e := range entries { + if e.Name() == ".versions" { + continue } - t.Errorf("un seul physique attendu (%s.jpg), got %v", resourceID, names) + live = append(live, e.Name()) + } + if len(live) != 1 || live[0] != resourceID+".jpg" { + t.Errorf("un seul live attendu (%s.jpg), got %v", resourceID, live) + } + verFiles, _ := filepath.Glob(filepath.Join(s.UploadDir, userID, ".versions", resourceID+"_v*")) + if len(verFiles) != 1 { + t.Errorf("une version figée (png) attendue, got %v", verFiles) + } else if content, err := os.ReadFile(verFiles[0]); err != nil || string(content) != "PNGDATA" { + t.Errorf("version figée = %q, err=%v (attendu PNGDATA)", content, err) } content, err := os.ReadFile(filepath.Join(s.UploadDir, userID, resourceID+".jpg")) if err != nil || string(content) != "JPGDATA!" { diff --git a/backend/service/sync.go b/backend/service/sync.go index 468dce5..6b4eb20 100644 --- a/backend/service/sync.go +++ b/backend/service/sync.go @@ -25,6 +25,12 @@ const ( OpRevokeLink = "revoke_link" // V2 placements : un device signale la présence de ses octets. OpReportBytes = "report_bytes" + // V3 corbeille (P1) : trash = soft (restaure via restore), purge = hard. + // delete_resource (legacy) est mappé vers trash_resource (même sémantique + // d'idempotence, cf. applyTrashOp). + OpTrashResource = "trash_resource" + OpRestoreResource = "restore_resource" + OpPurgeResource = "purge_resource" ) // SyncOperation is one outbox entry (shadow of mobile PendingOperationRow). @@ -200,7 +206,7 @@ func validateSyncOp(op *SyncOperation) error { switch op.Operation { case OpCreateResource, OpUpdateMetadata, OpMoveResource, OpDeleteResource, OpShare, OpRevokeShare, OpUpdateShare, OpCreateLink, OpRevokeLink, - OpReportBytes: + OpReportBytes, OpTrashResource, OpRestoreResource, OpPurgeResource: default: return errors.New("unknown operation " + op.Operation) } @@ -311,11 +317,13 @@ func (s *Resources) applySyncOp(ownerID, deviceID string, op *SyncOperation) err } return s.Repo.MoveResource(ownerID, resourceID, p.ToFolderResourceID) - case OpDeleteResource: - // A8 : delete owner-only. Ligne vivante d'autrui → NOT_FOUND halt - // (pas de applied silencieux). Aucune ligne vivante (jamais existé, - // ou déjà supprimée par son owner) → no-op idempotent : l'état - // terminal (absente) est déjà atteint, le rejeu reste sûr. + case OpDeleteResource, OpTrashResource: + // V3 : delete_resource (legacy) = trash_resource. A8 : owner-only. + // Ligne vivante d'autrui → NOT_FOUND halt (pas de applied + // silencieux). Aucune ligne (jamais existé, déjà trashée/purgée par + // son owner) → no-op idempotent : l'état terminal est atteint. + // Note : une ressource déjà trashée reste trashée (re-trash = no-op + // via TrashResource qui ne touche que deleted_at IS NULL). exists, err := s.Repo.ExistsOwner(ownerID, resourceID) if err != nil { return err @@ -329,7 +337,53 @@ func (s *Resources) applySyncOp(ownerID, deviceID string, op *SyncOperation) err } return repository.ErrNotFound } - return s.Repo.SyncDelete(ownerID, resourceID) + return s.Repo.TrashResource(ownerID, resourceID) + + case OpRestoreResource: + // Owner-only (live ou trashé). Absente → no-op (rien à restaurer, + // l'état terminal — visible — ne peut pas être atteint autrement, + // mais halter casserait la convergence d'un restore rejoué après + // purge... non : après purge la ligne n'existe plus, le restore est + // sans objet → no-op documenté). Vivante d'autrui → NOT_FOUND halt. + owned, err := s.Repo.ExistsOwnerAny(ownerID, resourceID) + if err != nil { + return err + } + if !owned { + if _, err := s.Repo.GetResourceOwner(resourceID); err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil + } + return err + } + return repository.ErrNotFound + } + return s.Repo.RestoreResource(ownerID, resourceID) + + case OpPurgeResource: + // Owner-only (live ou trashé). Absente → no-op idempotent. + // Vivante d'autrui → NOT_FOUND halt. Octets supprimés best-effort. + owned, err := s.Repo.ExistsOwnerAny(ownerID, resourceID) + if err != nil { + return err + } + if !owned { + if _, err := s.Repo.GetResourceOwner(resourceID); err != nil { + if errors.Is(err, repository.ErrNotFound) { + return nil + } + return err + } + return repository.ErrNotFound + } + purged, err := s.Repo.PurgeResource(ownerID, resourceID) + if err != nil { + return err + } + for _, pid := range purged { + s.removePhysical(ownerID, pid) + } + return nil case OpShare, OpUpdateShare: return s.applyShareOp(ownerID, resourceID, op) diff --git a/backend/service/trash.go b/backend/service/trash.go new file mode 100644 index 0000000..404580d --- /dev/null +++ b/backend/service/trash.go @@ -0,0 +1,420 @@ +package service + +import ( + "fmt" + "io" + "log" + "os" + "path/filepath" + "strings" + "time" + + "github.com/kazier/backend/repository" +) + +// TrashRetention is the corbeille lifetime (V3 P1 : 30j, cf. V3.md §2). +// Après ce délai, la passe de purge détruit définitivement les lignes. +const TrashRetention = 30 * 24 * time.Hour + +// TrashDTO serializes one trashed resource for GET /trash. +type TrashDTO struct { + ID string `json:"id"` + Type string `json:"type"` + Name string `json:"name"` + Size int64 `json:"size"` + TrashedAt string `json:"trashedAt"` + UpdatedAt string `json:"updatedAt,omitempty"` +} + +// VersionDTO serializes one frozen byte-generation for GET /files/:id/versions. +type VersionDTO struct { + VersionNo int `json:"versionNo"` + Size int64 `json:"size"` + MimeType string `json:"mimeType,omitempty"` + CreatedAt string `json:"createdAt"` +} + +// Trash soft-deletes a resource and its subtree (corbeille). Owner-only : +// foreign or absent → repository.ErrNotFound (même code, pas d'oracle). +// delete_resource (legacy) est mappé vers Trash (cf. applySyncOp). +func (s *Resources) Trash(ownerID, id string) (string, error) { + owned, err := s.Repo.ExistsOwner(ownerID, id) + if err != nil { + return "", err + } + if !owned { + return "", repository.ErrNotFound + } + if err := s.Repo.TrashResource(ownerID, id); err != nil { + return "", err + } + return id, nil +} + +// DeleteFile is the legacy owner-only file removal — now a trash (V3 P1). +// Purge définitive : Purge. Le handler choisit via ?mode=purge. +func (s *Resources) DeleteFile(ownerID, id string) (string, error) { + // Restreint aux files comme avant (les dossiers passent par l'outbox). + if _, err := s.Repo.GetFile(ownerID, id); err != nil { + return "", err + } + return s.Trash(ownerID, id) +} + +// Restore clears the trash flag on a resource, its subtree and its ancestor +// chain. Owner-only : absent/foreign → ErrNotFound ; live → no-op succès. +func (s *Resources) Restore(ownerID, id string) (string, error) { + owned, err := s.Repo.ExistsOwnerAny(ownerID, id) + if err != nil { + return "", err + } + if !owned { + return "", repository.ErrNotFound + } + if err := s.Repo.RestoreResource(ownerID, id); err != nil { + return "", err + } + return id, nil +} + +// Purge hard-deletes a resource and its subtree (lignes + versions + octets). +// Owner-only (trashed ou live) : absent/foreign → ErrNotFound. +// Les fichiers physiques sont supprimés best-effort (jamais d'échec sur FS). +func (s *Resources) Purge(ownerID, id string) (string, error) { + owned, err := s.Repo.ExistsOwnerAny(ownerID, id) + if err != nil { + return "", err + } + if !owned { + return "", repository.ErrNotFound + } + purged, err := s.Repo.PurgeResource(ownerID, id) + if err != nil { + return "", err + } + for _, pid := range purged { + s.removePhysical(ownerID, pid) + } + return id, nil +} + +// ListTrashed returns the owner's corbeille, most recently trashed first. +func (s *Resources) ListTrashed(ownerID string, page, pageSize int) ([]TrashDTO, int, error) { + rows, total, err := s.Repo.ListTrashed(ownerID, pageSize, (page-1)*pageSize) + if err != nil { + return nil, 0, err + } + out := make([]TrashDTO, 0, len(rows)) + for _, row := range rows { + out = append(out, TrashDTO{ + ID: row.ID, + Type: row.Type, + Name: row.Name, + Size: row.Size, + TrashedAt: row.TrashedAt.UTC().Format(time.RFC3339), + UpdatedAt: row.UpdatedAt.UTC().Format(time.RFC3339), + }) + } + return out, total, nil +} + +// ListVersions returns the frozen byte-generations of a live owned resource, +// newest first. Trashed/absent/foreign → ErrNotFound. +func (s *Resources) ListVersions(ownerID, id string) ([]VersionDTO, error) { + rows, err := s.Repo.ListVersions(ownerID, id) + if err != nil { + return nil, err + } + out := make([]VersionDTO, 0, len(rows)) + for _, row := range rows { + out = append(out, VersionDTO{ + VersionNo: row.VersionNo, + Size: row.Size, + MimeType: row.MimeType, + CreatedAt: row.CreatedAt.UTC().Format(time.RFC3339), + }) + } + return out, nil +} + +// RestoreVersion recopies la génération n vers l'emplacement live (l'actuel +// est à son tour versionné, puis élagué à N=3). Owner-only, parent live. +func (s *Resources) RestoreVersion(ownerID, id string, n int) (FileDTO, error) { + ver, err := s.Repo.GetVersion(ownerID, id, n) + if err != nil { + return FileDTO{}, err + } + srcAbs := filepath.Join(s.UploadDir, ver.StoredPath) + if fi, err := os.Stat(srcAbs); err != nil || !fi.Mode().IsRegular() { + return FileDTO{}, repository.ErrNotFound + } + cur, err := s.Repo.GetFile(ownerID, id) + if err != nil { + return FileDTO{}, err + } + destDir := filepath.Join(s.UploadDir, ownerID) + if err := os.MkdirAll(destDir, 0o700); err != nil { + return FileDTO{}, fmt.Errorf("create upload dir: %w", err) + } + if err := os.Chmod(destDir, 0o700); err != nil { + return FileDTO{}, fmt.Errorf("chmod upload dir: %w", err) + } + // 1. Geler l'actuel (staging copy, pas de move — l'échec reste safe). + staged, stagedExt, stagedSize, stagedMime, hasLive, err := s.freezeLive(ownerID, id, cur, destDir) + if err != nil { + return FileDTO{}, err + } + if hasLive { + defer func() { + // Staging orphelin si on sort en erreur avant finalize. + if err != nil { + _ = os.Remove(staged) + } + }() + } + // 2. Recopier la version vers le live (même atomicité que l'upload). + destName := id + if ver.Extension != "" { + destName = id + "." + ver.Extension + } + if err := copyFileAtomic(srcAbs, destDir, filepath.Join(destDir, destName)); err != nil { + return FileDTO{}, err + } + mime := ver.MimeType + if mime == "" { + mime = "application/octet-stream" + } + var extPtr *string + if ver.Extension != "" { + extPtr = &ver.Extension + } + fi, err := os.Stat(filepath.Join(destDir, destName)) + if err != nil { + return FileDTO{}, err + } + if err := s.Repo.UpdatePhysical(ownerID, id, fi.Size(), &mime, extPtr); err != nil { + return FileDTO{}, err + } + if err := s.Repo.SetHasContent(ownerID, id, true); err != nil { + log.Printf("versions: SetHasContent(%s): %v", id, err) + } + // 3. Nettoyer les suffixes orphelins + figer l'ancien actuel en version. + s.removeStaleSuffixes(destDir, id, destName) + if hasLive { + if ferr := s.finalizeVersion(ownerID, id, staged, stagedExt, stagedSize, stagedMime); ferr != nil { + log.Printf("versions: finalize displaced current(%s): %v", id, ferr) + } + } + row, err := s.Repo.GetFile(ownerID, id) + if err != nil { + return FileDTO{}, err + } + return toFileDTO(row), nil +} + +// PurgeExpiredTrash détruit les lignes trashées depuis plus de retention +// (corbeille 30j) + leurs octets (best-effort). Boucle par batch jusqu'à vide. +// Retourne le nombre de ressources racines purgées. Appelé au boot puis par +// ticker (cf. cmd/server/main.go). +func (s *Resources) PurgeExpiredTrash(retention time.Duration) (int, error) { + cutoff := time.Now().Add(-retention) + total := 0 + for { + purged, err := s.Repo.PurgeExpiredTrash(cutoff, 500) + if err != nil { + return total, err + } + if len(purged) == 0 { + return total, nil + } + for _, p := range purged { + s.removePhysical(p.UserID, p.ResourceID) + total++ + } + } +} + +// removePhysical supprime tous les octets connus d'une ressource : live +// (UPLOAD_DIR//.* + nu) et versions (.versions/). Best-effort. +func (s *Resources) removePhysical(userID, resourceID string) { + if !idPattern.MatchString(userID) || !idPattern.MatchString(resourceID) { + return + } + dir := filepath.Join(s.UploadDir, userID) + matches, _ := filepath.Glob(filepath.Join(dir, resourceID+".*")) + for _, m := range matches { + if strings.HasPrefix(filepath.Base(m), resourceID+".") { + _ = os.Remove(m) + } + } + _ = os.Remove(filepath.Join(dir, resourceID)) + verMatches, _ := filepath.Glob(filepath.Join(dir, ".versions", resourceID+"_v*")) + for _, m := range verMatches { + _ = os.Remove(m) + } +} + +// removeStaleSuffixes supprime les anciens suffixes orphelins après écriture +// du live (même règle que Upload : tout `.*` sauf le live). +func (s *Resources) removeStaleSuffixes(destDir, resourceID, liveName string) { + matches, _ := filepath.Glob(filepath.Join(destDir, resourceID+".*")) + for _, m := range matches { + if filepath.Base(m) != liveName && strings.HasPrefix(filepath.Base(m), resourceID+".") { + _ = os.Remove(m) + } + } +} + +// livePhysicalFile retourne le chemin live existant d'une ressource (suffixé +// ou nu), "" si metadata-only. +func livePhysicalFile(uploadDir, ownerID, resourceID string) string { + dir := filepath.Join(uploadDir, ownerID) + matches, _ := filepath.Glob(filepath.Join(dir, resourceID+".*")) + for _, m := range matches { + if strings.HasPrefix(filepath.Base(m), resourceID+".") { + if fi, err := os.Lstat(m); err == nil && fi.Mode().IsRegular() { + return m + } + } + } + if bare := filepath.Join(dir, resourceID); bare != "" { + if fi, err := os.Lstat(bare); err == nil && fi.Mode().IsRegular() { + return bare + } + } + return "" +} + +// freezeLive copie les octets live vers un staging temp (jamais de move : +// l'original reste en place jusqu'au succès). Retourne le staging + métadonnées. +// ok=false quand metadata-only (rien à versionner). +func (s *Resources) freezeLive(ownerID, resourceID string, cur repository.FileRow, destDir string) (staging, ext string, size int64, mime string, ok bool, err error) { + live := livePhysicalFile(s.UploadDir, ownerID, resourceID) + if live == "" { + return "", "", 0, "", false, nil + } + base := filepath.Base(live) + ext = "" + if strings.HasPrefix(base, resourceID+".") { + ext = strings.TrimPrefix(base, resourceID+".") + } + tmp, err := os.CreateTemp(destDir, ".ver-"+resourceID+".*") + if err != nil { + return "", "", 0, "", false, fmt.Errorf("stage version: %w", err) + } + staging = tmp.Name() + if err := copyInto(tmp, live); err != nil { + tmp.Close() + _ = os.Remove(staging) + return "", "", 0, "", false, err + } + if err := tmp.Close(); err != nil { + _ = os.Remove(staging) + return "", "", 0, "", false, fmt.Errorf("stage version: %w", err) + } + fi, err := os.Stat(staging) + if err != nil { + _ = os.Remove(staging) + return "", "", 0, "", false, err + } + mime = cur.MimeType + if mime == "" { + mime = "application/octet-stream" + } + return staging, ext, fi.Size(), mime, true, nil +} + +// finalizeVersion déplace le staging vers .versions/, insère la ligne et +// élague au-delà de MaxVersions (fichiers élagués supprimés best-effort). +func (s *Resources) finalizeVersion(ownerID, resourceID, staged, ext string, size int64, mime string) error { + no, err := s.Repo.NextVersionNo(resourceID) + if err != nil { + return err + } + rel := filepath.Join(ownerID, ".versions", fmt.Sprintf("%s_v%d", resourceID, no)) + if ext != "" { + rel += "." + ext + } + abs := filepath.Join(s.UploadDir, rel) + if err := os.MkdirAll(filepath.Dir(abs), 0o700); err != nil { + return err + } + if err := os.Rename(staged, abs); err != nil { + return err + } + if err := os.Chmod(abs, 0o600); err != nil { + log.Printf("versions: chmod(%s): %v", rel, err) + } + var extPtr *string + if ext != "" { + extPtr = &ext + } + vid, err := repository.NewIDErr() + if err != nil { + return err + } + if err := s.Repo.InsertVersion(vid, resourceID, no, size, &mime, extPtr, rel); err != nil { + _ = os.Remove(abs) + return err + } + pruned, err := s.Repo.PruneVersions(resourceID, repository.MaxVersions) + if err != nil { + log.Printf("versions: prune(%s): %v", resourceID, err) + return nil + } + for _, p := range pruned { + _ = os.Remove(filepath.Join(s.UploadDir, p)) + } + return nil +} + +// copyInto copie src vers le fichier ouvert dst. +func copyInto(dst *os.File, src string) error { + in, err := os.Open(src) + if err != nil { + return err + } + defer in.Close() + if _, err := io.Copy(dst, in); err != nil { + return fmt.Errorf("copy version bytes: %w", err) + } + return nil +} + +// copyFileAtomic recopie src vers destPath via temp+rename (0600). +func copyFileAtomic(src, destDir, destPath string) error { + tmp, err := os.CreateTemp(destDir, ".tmp-"+filepath.Base(destPath)+".*") + if err != nil { + return fmt.Errorf("create tmp file: %w", err) + } + tmpName := tmp.Name() + success := false + defer func() { + if !success { + _ = os.Remove(tmpName) + } + }() + if err := tmp.Chmod(0o600); err != nil { + tmp.Close() + return fmt.Errorf("chmod tmp file: %w", err) + } + if err := copyInto(tmp, src); err != nil { + tmp.Close() + return err + } + if err := tmp.Sync(); err != nil { + tmp.Close() + return fmt.Errorf("fsync: %w", err) + } + if err := tmp.Close(); err != nil { + return fmt.Errorf("close: %w", err) + } + if err := os.Rename(tmpName, destPath); err != nil { + return fmt.Errorf("commit: %w", err) + } + if err := os.Chmod(destPath, 0o600); err != nil { + return fmt.Errorf("chmod: %w", err) + } + success = true + return nil +} diff --git a/backend/service/trash_test.go b/backend/service/trash_test.go new file mode 100644 index 0000000..e879393 --- /dev/null +++ b/backend/service/trash_test.go @@ -0,0 +1,364 @@ +package service + +import ( + "errors" + "os" + "path/filepath" + "testing" + "time" + + "github.com/kazier/backend/repository" +) + +func mustInsertFile(t *testing.T, s *Resources, userID, name string) string { + t.Helper() + id := repository.NewID() + if err := s.Repository.Resources.InsertFile(userID, id, name, "", 0, nil, nil); err != nil { + t.Fatalf("insert file %q: %v", name, err) + } + return id +} + +func TestTrashRestoreRoundtrip(t *testing.T) { + s := newServiceStore(t) + userID := mustCreateUser(t, s.Repository, "trash-roundtrip") + fileID := mustInsertFile(t, s, userID, "acte.pdf") + + if _, err := s.Trash(userID, fileID); err != nil { + t.Fatalf("trash: %v", err) + } + if _, err := s.Repo.GetFile(userID, fileID); !errors.Is(err, repository.ErrNotFound) { + t.Fatalf("GetFile après trash : attendu NOT_FOUND, got %v", err) + } + items, total, err := s.ListTrashed(userID, 1, 50) + if err != nil { + t.Fatalf("list trashed: %v", err) + } + if total != 1 || len(items) != 1 || items[0].ID != fileID { + t.Fatalf("corbeille: total=%d items=%+v", total, items) + } + + if _, err := s.Restore(userID, fileID); err != nil { + t.Fatalf("restore: %v", err) + } + if _, err := s.Repo.GetFile(userID, fileID); err != nil { + t.Fatalf("GetFile après restore: %v", err) + } + if _, total, err := s.ListTrashed(userID, 1, 50); err != nil || total != 0 { + t.Fatalf("corbeille après restore: total=%d err=%v", total, err) + } +} + +func TestTrashSubtree(t *testing.T) { + s := newServiceStore(t) + userID := mustCreateUser(t, s.Repository, "trash-subtree") + folderID := repository.NewID() + if err := s.Repository.Resources.InsertFolder(userID, folderID, "Dossier", ""); err != nil { + t.Fatalf("insert folder: %v", err) + } + childID := repository.NewID() + if err := s.Repository.Resources.InsertFile(userID, childID, "enfant.txt", folderID, 0, nil, nil); err != nil { + t.Fatalf("insert child: %v", err) + } + + if _, err := s.Trash(userID, folderID); err != nil { + t.Fatalf("trash folder: %v", err) + } + if _, err := s.Repo.GetFile(userID, childID); !errors.Is(err, repository.ErrNotFound) { + t.Fatalf("enfant après trash dossier : attendu NOT_FOUND, got %v", err) + } + if _, total, _ := s.ListTrashed(userID, 1, 50); total != 2 { + t.Fatalf("corbeille subtree: total=%d, attendu 2", total) + } + + if _, err := s.Restore(userID, folderID); err != nil { + t.Fatalf("restore folder: %v", err) + } + if _, err := s.Repo.GetFile(userID, childID); err != nil { + t.Fatalf("enfant après restore dossier: %v", err) + } +} + +func TestTrashForeignIsNotFound(t *testing.T) { + s := newServiceStore(t) + owner := mustCreateUser(t, s.Repository, "trash-owner") + other := mustCreateUser(t, s.Repository, "trash-other") + fileID := mustInsertFile(t, s, owner, "secret.pdf") + + if _, err := s.Trash(other, fileID); !errors.Is(err, repository.ErrNotFound) { + t.Fatalf("trash autrui : attendu NOT_FOUND, got %v", err) + } + if _, err := s.Restore(other, fileID); !errors.Is(err, repository.ErrNotFound) { + t.Fatalf("restore autrui : attendu NOT_FOUND, got %v", err) + } + if _, err := s.Purge(other, fileID); !errors.Is(err, repository.ErrNotFound) { + t.Fatalf("purge autrui : attendu NOT_FOUND, got %v", err) + } + if _, err := s.Repo.GetFile(owner, fileID); err != nil { + t.Fatalf("fichier owner intact: %v", err) + } +} + +func TestDeleteLegacyMapsToTrash(t *testing.T) { + s := newServiceStore(t) + userID := mustCreateUser(t, s.Repository, "trash-legacy") + device := mustRegisterDevice(t, s.Repository, "b0000000000000000000000000000001") + fileID := mustInsertFile(t, s, userID, "legacy.pdf") + + // delete_resource → trash (restaurable, visible en corbeille). + res, err := s.ApplyBatch(userID, device, []SyncOperation{ + syncOp(repository.NewID(), fileID, OpDeleteResource, "file", map[string]any{}), + }) + if err != nil { + t.Fatalf("apply: %v", err) + } + if res.Applied != 1 || res.Failed != nil { + t.Fatalf("résultat inattendu: %+v", res) + } + if _, err := s.Repo.GetFile(userID, fileID); !errors.Is(err, repository.ErrNotFound) { + t.Fatalf("GetFile après delete legacy : attendu NOT_FOUND, got %v", err) + } + if _, total, _ := s.ListTrashed(userID, 1, 50); total != 1 { + t.Fatalf("delete legacy doit apparaître en corbeille") + } + + // Re-delete (déjà trashé) → no-op idempotent, pas NOT_FOUND. + res, err = s.ApplyBatch(userID, device, []SyncOperation{ + syncOp(repository.NewID(), fileID, OpDeleteResource, "file", map[string]any{}), + }) + if err != nil { + t.Fatalf("re-apply: %v", err) + } + if res.Applied != 1 || res.Failed != nil { + t.Fatalf("re-delete trashé doit être no-op: %+v", res) + } +} + +func TestSyncOpsTrashRestorePurge(t *testing.T) { + s := newServiceStore(t) + userID := mustCreateUser(t, s.Repository, "trash-ops") + other := mustCreateUser(t, s.Repository, "trash-ops-other") + device := mustRegisterDevice(t, s.Repository, "b0000000000000000000000000000002") + fileID := mustInsertFile(t, s, userID, "ops.pdf") + foreignID := mustInsertFile(t, s, other, "foreign.pdf") + + apply := func(op, resID string) SyncResult { + t.Helper() + res, err := s.ApplyBatch(userID, device, []SyncOperation{ + syncOp(repository.NewID(), resID, op, "file", map[string]any{}), + }) + if err != nil { + t.Fatalf("apply %s: %v", op, err) + } + return res + } + + if res := apply(OpTrashResource, fileID); res.Applied != 1 || res.Failed != nil { + t.Fatalf("trash op: %+v", res) + } + // Trash d'autrui → halt NOT_FOUND. + if res := apply(OpTrashResource, foreignID); res.Failed == nil || res.Failed.Code != "NOT_FOUND" { + t.Fatalf("trash autrui doit halter NOT_FOUND: %+v", res) + } + if res := apply(OpRestoreResource, fileID); res.Applied != 1 || res.Failed != nil { + t.Fatalf("restore op: %+v", res) + } + if _, err := s.Repo.GetFile(userID, fileID); err != nil { + t.Fatalf("fichier restauré via op: %v", err) + } + // Restore d'un live → no-op succès. + if res := apply(OpRestoreResource, fileID); res.Applied != 1 || res.Failed != nil { + t.Fatalf("restore live doit être no-op: %+v", res) + } + // Restore d'inexistant → no-op (convergence). + if res := apply(OpRestoreResource, repository.NewID()); res.Applied != 1 || res.Failed != nil { + t.Fatalf("restore inexistant doit être no-op: %+v", res) + } + // Purge d'un live → détruit. + if res := apply(OpPurgeResource, fileID); res.Applied != 1 || res.Failed != nil { + t.Fatalf("purge op: %+v", res) + } + if owned, _ := s.Repo.ExistsOwnerAny(userID, fileID); owned { + t.Fatal("purge doit détruire la ligne") + } + // Purge d'inexistant → no-op. + if res := apply(OpPurgeResource, fileID); res.Applied != 1 || res.Failed != nil { + t.Fatalf("purge inexistant doit être no-op: %+v", res) + } +} + +func TestPurgeRemovesPhysicalFiles(t *testing.T) { + s := newServiceStore(t) + userID := mustCreateUser(t, s.Repository, "trash-physical") + + dto, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte("hello")), "", "") + if err != nil { + t.Fatalf("upload: %v", err) + } + live := filepath.Join(s.UploadDir, userID, dto.ID+".txt") + if _, err := os.Stat(live); err != nil { + t.Fatalf("live absent: %v", err) + } + if _, err := s.Purge(userID, dto.ID); err != nil { + t.Fatalf("purge: %v", err) + } + if _, err := os.Stat(live); !os.IsNotExist(err) { + t.Fatalf("octets live doivent être supprimés: %v", err) + } +} + +func TestUploadOverwriteCreatesVersionsCappedAt3(t *testing.T) { + s := newServiceStore(t) + userID := mustCreateUser(t, s.Repository, "trash-versions") + + v1, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte("AAA")), "", "") + if err != nil { + t.Fatalf("upload v1: %v", err) + } + // Le premier upload (création) ne crée pas de version. + if vers, err := s.ListVersions(userID, v1.ID); err != nil || len(vers) != 0 { + t.Fatalf("création ne doit pas versionner: %+v %v", vers, err) + } + + contents := []string{"BBBB", "CCCCC", "DDDDDD", "EEEEEEE"} + for i, c := range contents { + dto, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte(c)), "", v1.ID) + if err != nil { + t.Fatalf("overwrite %d: %v", i, err) + } + if dto.Size != int64(len(c)) { + t.Fatalf("overwrite %d: taille=%d", i, dto.Size) + } + } + vers, err := s.ListVersions(userID, v1.ID) + if err != nil { + t.Fatalf("list versions: %v", err) + } + if len(vers) != 3 { + t.Fatalf("versions = %d, attendu 3 (plafond N=3)", len(vers)) + } + // Les 3 conservées sont les plus récentes : AAA a été élaguée. + // Ordre décroissant : version_no 4,3,2 → tailles 6,5,4. + wantSizes := []int64{6, 5, 4} + for i, v := range vers { + if v.Size != wantSizes[i] { + t.Errorf("version[%d].size = %d, attendu %d", i, v.Size, wantSizes[i]) + } + } + // 3 fichiers figés sur disque (AAA élaguée avec sa ligne). + verFiles, _ := filepath.Glob(filepath.Join(s.UploadDir, userID, ".versions", v1.ID+"_v*")) + if len(verFiles) != 3 { + t.Errorf("fichiers versionnés = %d, attendu 3 (%v)", len(verFiles), verFiles) + } +} + +func TestRestoreVersion(t *testing.T) { + s := newServiceStore(t) + userID := mustCreateUser(t, s.Repository, "trash-restore-ver") + + dto, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte("AAA")), "", "") + if err != nil { + t.Fatalf("upload v1: %v", err) + } + if _, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte("BBBB")), "", dto.ID); err != nil { + t.Fatalf("overwrite: %v", err) + } + vers, err := s.ListVersions(userID, dto.ID) + if err != nil || len(vers) != 1 { + t.Fatalf("versions: %+v %v", vers, err) + } + + restored, err := s.RestoreVersion(userID, dto.ID, vers[0].VersionNo) + if err != nil { + t.Fatalf("restore version: %v", err) + } + if restored.Size != 3 { + t.Fatalf("live restauré taille=%d, attendu 3", restored.Size) + } + raw, err := os.ReadFile(filepath.Join(s.UploadDir, userID, dto.ID+".txt")) + if err != nil { + t.Fatalf("read live: %v", err) + } + if string(raw) != "AAA" { + t.Fatalf("contenu live = %q, attendu AAA", raw) + } + // L'ancien actuel (BBBB) a été à son tour versionné. + vers2, err := s.ListVersions(userID, dto.ID) + if err != nil || len(vers2) != 2 { + t.Fatalf("versions après restore: %+v %v", vers2, err) + } + if _, err := s.RestoreVersion(userID, dto.ID, 999); !errors.Is(err, repository.ErrNotFound) { + t.Fatalf("restore version inconnue : attendu NOT_FOUND, got %v", err) + } +} + +func TestUploadToTrashedIsNotFound(t *testing.T) { + s := newServiceStore(t) + userID := mustCreateUser(t, s.Repository, "trash-upload-guard") + + dto, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte("AAA")), "", "") + if err != nil { + t.Fatalf("upload: %v", err) + } + if _, err := s.Trash(userID, dto.ID); err != nil { + t.Fatalf("trash: %v", err) + } + if _, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte("BBB")), "", dto.ID); !errors.Is(err, repository.ErrNotFound) { + t.Fatalf("upload vers trashé : attendu NOT_FOUND, got %v", err) + } +} + +func backdateTrash(t *testing.T, s *Resources, resourceID string, ago time.Duration) { + t.Helper() + if _, err := s.Repository.Resources.DB.Exec( + `UPDATE resources SET deleted_at = NOW() - ($1 || ' seconds')::interval WHERE resource_id = $2`, + int(ago.Seconds()), resourceID, + ); err != nil { + t.Fatalf("backdate: %v", err) + } +} + +func TestPurgeExpiredTrash(t *testing.T) { + s := newServiceStore(t) + userID := mustCreateUser(t, s.Repository, "trash-expire") + + old, err := s.Upload(userID, multipartFileHeader(t, "vieux.txt", []byte("old")), "", "") + if err != nil { + t.Fatalf("upload vieux: %v", err) + } + fresh, err := s.Upload(userID, multipartFileHeader(t, "frais.txt", []byte("new")), "", "") + if err != nil { + t.Fatalf("upload frais: %v", err) + } + if _, err := s.Trash(userID, old.ID); err != nil { + t.Fatalf("trash vieux: %v", err) + } + if _, err := s.Trash(userID, fresh.ID); err != nil { + t.Fatalf("trash frais: %v", err) + } + backdateTrash(t, s, old.ID, 31*24*time.Hour) + + n, err := s.PurgeExpiredTrash(TrashRetention) + if err != nil { + t.Fatalf("purge expired: %v", err) + } + if n != 1 { + t.Fatalf("purgés = %d, attendu 1", n) + } + if owned, _ := s.Repo.ExistsOwnerAny(userID, old.ID); owned { + t.Fatal("vieux doit être détruit") + } + if _, _, err := s.ListTrashed(userID, 1, 50); err != nil { + t.Fatalf("list: %v", err) + } + if _, err := s.Repo.GetFile(userID, fresh.ID); err == nil { + // Frais trashé mais pas expiré : invisible en lecture, présent en corbeille. + t.Fatal("frais doit rester trashé (invisible en lecture)") + } + if _, total, _ := s.ListTrashed(userID, 1, 50); total != 1 { + t.Fatalf("corbeille doit garder le frais: total=%d", total) + } + if _, err := os.Stat(filepath.Join(s.UploadDir, userID, old.ID+".txt")); !os.IsNotExist(err) { + t.Fatal("octets du purgé doivent être supprimés") + } +} diff --git a/docs/api-v1.md b/docs/api-v1.md index 64c30ad..c446809 100644 --- a/docs/api-v1.md +++ b/docs/api-v1.md @@ -38,13 +38,18 @@ Références : `V2.md` (modèle cible), `mobile/services/db/` (conventions sync) | GET | `/files` | query `folderId?`, `page?`, `pageSize?`, `sort?` | `FileDto[]` (+ `meta`) | — | | GET | `/files/:id` | — | `FileDto` | `NOT_FOUND` | | GET | `/files/:id/content` | — (binaire brut, hors enveloppe `{data}` ; `Range` supporté) | octets physiques (`Content-Type` du fichier, `Content-Disposition: inline`) — streaming lecture seule, jamais persisté côté client | `NOT_FOUND` (invisible OU metadata-only jamais uploadé — indistinguables) | -| DELETE | `/files/:id` | — | `{ "id": "…" }` | `NOT_FOUND` | +| DELETE | `/files/:id` | query `mode?` (`trash` défaut, `purge` = définitif) | `{ "id": "…" }` | `NOT_FOUND` | +| POST | `/files/:id/restore` | — | `{ "id": "…" }` | `NOT_FOUND` (absente/étrangère/purgée ; vivante = succès idempotent) | +| GET | `/trash` | query `page?`, `pageSize?` | `TrashDto[]` (`{ id, type, name, size, trashedAt, updatedAt }` + `meta`) | — | +| GET | `/files/:id/versions` | — (parent live uniquement) | `VersionDto[]` (`{ versionNo, size, mimeType, createdAt }`, plus récent d'abord) | `NOT_FOUND` | +| POST | `/files/:id/versions/:n/restore` | — (l'actuel est à son tour versionné) | `FileDto` | `NOT_FOUND` | | GET | `/files/search` | query `q` (obligatoire), `page?`, `pageSize?` | `FileDto[]` (+ `meta`) | — | | GET | `/files/folders` | — | `FolderDto[]` (racines) | — | | POST | `/files/upload` | multipart : `file` (uri/name/type), `folderId?` | `FileDto` | `FILE_TOO_LARGE` | | POST | `/ocr/jobs` | `{ "fileId": "…" }` | `OcrJob` | — | | GET | `/ocr/jobs/:id` | — | `OcrJob` | `NOT_FOUND` | | GET | `/files/:id/ocr` | — | `FileOcr` (`{ text, updatedAt }`) | `NOT_FOUND` | +| GET | `/files/:id/facts` | — (viewer+, même portée que l'OCR) | `Fact[]` (`{ factType: date|due_date|period|amount|issuer|reference|doc_type, valueText?, valueNum?, valueDate? (ISO), confidence (0..1), origin: auto|user }`, `[]` si rien d'extractible) | `NOT_FOUND` (trashé/absent/étranger) | | GET | `/files/:id/shares` | — (owner uniquement) | `ShareGrant[]` (`{ granteeUserId, granteeKind: "user"|"group", username, access, inherit, expiresAt (ms|null), updatedAt (ms) }`) | `NOT_FOUND` (non-owner ou inconnue — pas d'énumération) | | GET | `/files/:id/links` | — (owner uniquement) | `ShareLink[]` (même forme que `GET /shares/links/:token`) | `NOT_FOUND` (non-owner ou inconnue) | | GET | `/files/:id/placements` | — (owner uniquement) | `Placement[]` (`{ locationType: "server"|"mobile", deviceId?, hasBytes, updatedAt }`, entrée serveur en premier) | `NOT_FOUND` (non-owner ou inconnue) | @@ -94,6 +99,7 @@ type FileOcr = { text: string; updatedAt?: string | null }; - `fileId` inconnu/pas du user → `NOT_FOUND`. Fichier physique introuvable (ex. suppression manuelle sous `UPLOAD_DIR`) → job `failed` `"file not readable"`. Le job est créé par le device courant (`ocr_jobs.device_id`) mais la validation de la ressource est scopée par le **user**. - **Le texte atterrit sur la ressource** : à la complétion (`done` avec texte non vide), le worker écrit l'extrait trimé dans `resources.ocr_text` (et **bump `updated_at`**, d'où une injection dans le delta outbox/snapshot). `ocr_jobs.text` reste l'historique du job. - **`GET /files/:id/ocr`** → `FileOcr { text, updatedAt }` : l'extrait server-side du fichier, lisible par le **possédant ET les grantees** (`viewer+`, même portée que `GET /files/:id` ; `text` `""` si pas encore extrait). Un **second device** rapatrie ainsi le texte d'un OCR fait par un autre device (ou par la ressource partagée) **sans re-téléverser les octets ni re-soumettre de job** — le client Kotlin le fait en tête de `OcrRepository.syncFromServer`/`processAuto` et du viewer (`OcrViewModel`). +- **Faits génériques V3 (`GET /files/:id/facts`)** : après chaque OCR `done`, le worker en dérive des faits vérifiables (règles FR, sans ML : dates ISO, échéances (`due_date` si mot-clé `échéance|à payer avant|date limite`), périodes (`2026-03`), montants € (confiance 0.9 si mot-clé `total|montant|à payer`), émetteurs (lignes capitales), références (`facture:FA-…`, `siret:…`, IBAN masqué `rib:••••1234`), `doc_type` suggéré (seuil de score, jamais gate). Chaque fait porte `confidence` (0..1) et `origin` (`auto` remplacé à chaque passe, `user` intouchable — corrections S3). Même portée que l'OCR (`viewer+`) ; `[]` si rien d'extractible. Backfill borné au boot (OCR d'avant la V3). ## 6. Contrat de sync (outbox + snapshot) @@ -115,7 +121,7 @@ type FileOcr = { text: string; updatedAt?: string | null }; } ``` -- `operation` ∈ `create_resource | update_metadata | delete_resource | move_resource | share | revoke_share | update_share | create_link | revoke_link | report_bytes` (cf. `PendingOperationType` mobile). +- `operation` ∈ `create_resource | update_metadata | delete_resource | move_resource | share | revoke_share | update_share | create_link | revoke_link | report_bytes | trash_resource | restore_resource | purge_resource` (cf. `PendingOperationType` mobile). - **Identifiants** : `operation_id` est un **TEXT 32-hex** généré par le client (`^[0-9a-f]{32}$`, CHECK-enforced depuis la migration `000008`), distinct de `resource_id`. L'idempotence outbox reste **par device** : `UNIQUE(device_id, operation_id)` (la réinscription d'un device avec un login différent ne réutilise pas l'historique outbox d'un autre compte). Pour chaque op : si déjà traitée → **no-op** (comptée comme appliquée, les doublons arrivent à cause du backoff/retry). Sinon appliquée si valide. - **Ordre** : les opérations sont appliquées **séquentiellement**, dans l'ordre du batch. Le serveur **s'arrête à la première erreur non-idempotente** et renvoie l'index atteint — le client reprend à cet index. - Réponse : `2xx` avec `{ "applied": int, "failed": { "operation_id": "…32-hex", "code": string, "message": string } | null }` (`applied` = index de la prochaine op à envoyer). @@ -123,7 +129,9 @@ type FileOcr = { text: string; updatedAt?: string | null }; - Sémantique d'application (côté serveur) : - `create_resource` : crée la ressource ; **déjà présente → no-op** (rejeu idempotent). `payload.name` obligatoire ; `payload.parentResourceId` (32-hex, optionnel) = dossier parent — absent → racine. **Parent inexistant → `NOT_FOUND`** (cohérent avec `move_resource`). Ordre garanti par construction client : le walk SAF émet les `create` des dossiers (ordre préfixe) avant ceux des fichiers, dans la même transaction Room → `id ASC` = parent avant enfant. - `update_metadata` : ressource absente → **no-op** (état terminal atteint) ; **ressource partagée : nécessite `editor+`** (§6.2) — sinon `NOT_FOUND` (une ressource visible mais sans droit de mutation n'est pas renommée) ; une ressource sans relation applicable (ni owner, ni grant) reste un no-op (pas d'énumération). `move_resource` / `delete_resource` restent **owner-only** (scoping par `user_id`, les ops d'un non-owner sont des no-op). - - `delete_resource` : **idempotent** — suppression d'une ressource absente = succès. + - `delete_resource` : **legacy → mappé vers `trash_resource`** (corbeille, restaurable, même idempotence : absent/déjà trashé = succès, vivant d'autrui = `NOT_FOUND` halt). + - **Corbeille V3** (`trash_resource` / `restore_resource` / `purge_resource`, owner-only) : `trash` pose `deleted_at` sur la ressource **et son subtree** (dossier → contenu) ; `restore` lève le flag sur la ressource, son subtree **et sa chaîne d'ancêtres** (un fichier restauré dont le dossier est encore trashé resterait injoignable) ; `purge` détruit lignes + versions + octets. Sémantique : absent → no-op (`trash`/`restore`/`purge`), vivant d'autrui → `NOT_FOUND` halt, `restore` d'un live → no-op succès. Une ressource trashée reste `NOT_FOUND` en lecture normale, visible seulement via `GET /trash`. Passe serveur : destruction définitive après 30j (`TrashRetention`). + - **Versions V3** : chaque overwrite d'octets (upload ciblé) fige l'ancienne génération (`resource_versions`, N=3, élagage auto) ; `POST /files/:id/versions/:n/restore` recopie vers le live (l'actuel est à son tour versionné). Upload ciblé vers une ressource trashée → `NOT_FOUND` (jamais de résurrection d'octets). - **Partage** (`share` / `update_share`, même sémantique d'upsert) : `payload = { "granteeUserId"?: "…32-hex", "granteeGroupId"?: "…32-hex", "access": "viewer"|"commenter"|"editor", "inherit"?: bool, "expiresAt"?: ms }` — **exactement un** principal (user XOR groupe, V2-6). La ressource doit **appartenir** au user appelant (sinon `NOT_FOUND`) ; le grantee user doit exister (sinon `GRANTEE_NOT_FOUND`), le groupe doit exister (sinon `GROUP_NOT_FOUND`) ; accès déjà partagé → mis à jour (idempotent). Privilégier `viewer` < `commenter` < `editor` (< `owner` réservé à l'ownership, non partageable → `INVALID_REQUEST`). Les membres d'un groupe partagé héritent du grant (un niveau, sans imbrication) dans le snapshot comme dans l'enforcement. - `revoke_share` : `payload = { "granteeUserId": "…32-hex" }`. **Idempotent** (déjà révoqué/absent → no-op). - `create_link` : `payload = { "token": "…32-hex", "access": "viewer"|"commenter"|"editor", "expiresAt"?: ms }`. Le token est **généré côté client** (`GenerateId`), c'est l'identifiant du lien (colonne `id` de `share_links`). diff --git a/mobile-kotlin/app/schemas/com.kazier.mobile.data.local.AppDatabase/19.json b/mobile-kotlin/app/schemas/com.kazier.mobile.data.local.AppDatabase/19.json new file mode 100644 index 0000000..e7ccf31 --- /dev/null +++ b/mobile-kotlin/app/schemas/com.kazier.mobile.data.local.AppDatabase/19.json @@ -0,0 +1,766 @@ +{ + "formatVersion": 1, + "database": { + "version": 19, + "identityHash": "db3263dbb69c07a043d41f1c83a892a5", + "entities": [ + { + "tableName": "folders", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `resource_id` TEXT NOT NULL, `uri` TEXT, `name` TEXT NOT NULL, `exists` INTEGER, `parent_resource_id` TEXT, `owner_id` TEXT, `sync_status` TEXT NOT NULL, `created_in_app` INTEGER NOT NULL DEFAULT 0, `trashed_at` INTEGER, `added_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL)", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "resourceId", + "columnName": "resource_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "uri", + "columnName": "uri", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "name", + "columnName": "name", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "exists", + "columnName": "exists", + "affinity": "INTEGER", + "notNull": false + }, + { + "fieldPath": "parentResourceId", + "columnName": "parent_resource_id", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "ownerId", + "columnName": "owner_id", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "syncStatus", + "columnName": "sync_status", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "createdInApp", + "columnName": "created_in_app", + "affinity": "INTEGER", + "notNull": true, + "defaultValue": "0" + }, + { + "fieldPath": "trashedAt", + "columnName": "trashed_at", + "affinity": "INTEGER", + "notNull": false + }, + { + "fieldPath": "addedAt", + "columnName": "added_at", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updated_at", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": true, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_folders_resource_id", + "unique": true, + "columnNames": [ + "resource_id" + ], + "orders": [], + "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_folders_resource_id` ON `${TABLE_NAME}` (`resource_id`)" + }, + { + "name": "index_folders_uri", + "unique": true, + "columnNames": [ + "uri" + ], + "orders": [], + "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_folders_uri` ON `${TABLE_NAME}` (`uri`)" + }, + { + "name": "index_folders_parent_resource_id", + "unique": false, + "columnNames": [ + "parent_resource_id" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_folders_parent_resource_id` ON `${TABLE_NAME}` (`parent_resource_id`)" + } + ], + "foreignKeys": [] + }, + { + "tableName": "user_preferences", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`key` TEXT NOT NULL, `value` TEXT NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`key`))", + "fields": [ + { + "fieldPath": "key", + "columnName": "key", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "value", + "columnName": "value", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updated_at", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "key" + ] + }, + "indices": [], + "foreignKeys": [] + }, + { + "tableName": "files", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `resource_id` TEXT NOT NULL, `uri` TEXT, `name` TEXT NOT NULL, `folder_resource_id` TEXT NOT NULL, `extension` TEXT, `size` INTEGER NOT NULL, `mime_type` TEXT, `exists` INTEGER, `last_modified` INTEGER, `owner_id` TEXT, `category` TEXT, `sync_status` TEXT NOT NULL, `content` TEXT, `processed` INTEGER NOT NULL, `ocr_text` TEXT, `ocr_attempts` INTEGER NOT NULL, `ocr_queued_at` INTEGER, `bytes_uploaded` INTEGER NOT NULL, `bytes_upload_attempts` INTEGER NOT NULL, `has_content_server` INTEGER NOT NULL, `wanted_offline` INTEGER NOT NULL, `trashed_at` INTEGER, `added_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL)", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "resourceId", + "columnName": "resource_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "uri", + "columnName": "uri", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "name", + "columnName": "name", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "folderResourceId", + "columnName": "folder_resource_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "extension", + "columnName": "extension", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "size", + "columnName": "size", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "mimeType", + "columnName": "mime_type", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "exists", + "columnName": "exists", + "affinity": "INTEGER", + "notNull": false + }, + { + "fieldPath": "lastModified", + "columnName": "last_modified", + "affinity": "INTEGER", + "notNull": false + }, + { + "fieldPath": "ownerId", + "columnName": "owner_id", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "category", + "columnName": "category", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "syncStatus", + "columnName": "sync_status", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "content", + "columnName": "content", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "processed", + "columnName": "processed", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "ocrText", + "columnName": "ocr_text", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "ocrAttempts", + "columnName": "ocr_attempts", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "ocrQueuedAt", + "columnName": "ocr_queued_at", + "affinity": "INTEGER", + "notNull": false + }, + { + "fieldPath": "bytesUploaded", + "columnName": "bytes_uploaded", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "bytesUploadAttempts", + "columnName": "bytes_upload_attempts", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "hasContentServer", + "columnName": "has_content_server", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "wantedOffline", + "columnName": "wanted_offline", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "trashedAt", + "columnName": "trashed_at", + "affinity": "INTEGER", + "notNull": false + }, + { + "fieldPath": "addedAt", + "columnName": "added_at", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updated_at", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": true, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_files_resource_id", + "unique": true, + "columnNames": [ + "resource_id" + ], + "orders": [], + "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_files_resource_id` ON `${TABLE_NAME}` (`resource_id`)" + }, + { + "name": "index_files_uri", + "unique": true, + "columnNames": [ + "uri" + ], + "orders": [], + "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_files_uri` ON `${TABLE_NAME}` (`uri`)" + }, + { + "name": "index_files_folder_resource_id", + "unique": false, + "columnNames": [ + "folder_resource_id" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_files_folder_resource_id` ON `${TABLE_NAME}` (`folder_resource_id`)" + }, + { + "name": "index_files_category", + "unique": false, + "columnNames": [ + "category" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_files_category` ON `${TABLE_NAME}` (`category`)" + }, + { + "name": "index_files_exists_processed_sync_status", + "unique": false, + "columnNames": [ + "exists", + "processed", + "sync_status" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_files_exists_processed_sync_status` ON `${TABLE_NAME}` (`exists`, `processed`, `sync_status`)" + } + ], + "foreignKeys": [] + }, + { + "tableName": "pending_operations", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `device_id` TEXT, `operation_id` TEXT NOT NULL, `ref_type` TEXT, `ref_id` INTEGER, `resource_id` TEXT, `resource_type` TEXT, `operation` TEXT NOT NULL, `payload` TEXT NOT NULL, `parent_resource_id` TEXT, `status` TEXT NOT NULL, `attempts` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL)", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "deviceId", + "columnName": "device_id", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "operationId", + "columnName": "operation_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "refType", + "columnName": "ref_type", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "refId", + "columnName": "ref_id", + "affinity": "INTEGER", + "notNull": false + }, + { + "fieldPath": "resourceId", + "columnName": "resource_id", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "resourceType", + "columnName": "resource_type", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "operation", + "columnName": "operation", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "payload", + "columnName": "payload", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "parentResourceId", + "columnName": "parent_resource_id", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "status", + "columnName": "status", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "attempts", + "columnName": "attempts", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "createdAt", + "columnName": "created_at", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updated_at", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": true, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_pending_operations_device_id_operation_id", + "unique": true, + "columnNames": [ + "device_id", + "operation_id" + ], + "orders": [], + "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_pending_operations_device_id_operation_id` ON `${TABLE_NAME}` (`device_id`, `operation_id`)" + }, + { + "name": "index_pending_operations_status", + "unique": false, + "columnNames": [ + "status" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_pending_operations_status` ON `${TABLE_NAME}` (`status`)" + }, + { + "name": "index_pending_operations_resource_id", + "unique": false, + "columnNames": [ + "resource_id" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_pending_operations_resource_id` ON `${TABLE_NAME}` (`resource_id`)" + }, + { + "name": "index_pending_operations_resource_id_operation_status", + "unique": false, + "columnNames": [ + "resource_id", + "operation", + "status" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_pending_operations_resource_id_operation_status` ON `${TABLE_NAME}` (`resource_id`, `operation`, `status`)" + }, + { + "name": "index_pending_operations_parent_resource_id", + "unique": false, + "columnNames": [ + "parent_resource_id" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_pending_operations_parent_resource_id` ON `${TABLE_NAME}` (`parent_resource_id`)" + } + ], + "foreignKeys": [] + }, + { + "tableName": "scan_sessions", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `resource_id` TEXT NOT NULL, `root_folder_id` TEXT, `status` TEXT NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL)", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "resourceId", + "columnName": "resource_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "rootFolderId", + "columnName": "root_folder_id", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "status", + "columnName": "status", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "createdAt", + "columnName": "created_at", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updated_at", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": true, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_scan_sessions_resource_id", + "unique": true, + "columnNames": [ + "resource_id" + ], + "orders": [], + "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_scan_sessions_resource_id` ON `${TABLE_NAME}` (`resource_id`)" + } + ], + "foreignKeys": [] + }, + { + "tableName": "scan_pages", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `resource_id` TEXT NOT NULL, `session_id` INTEGER NOT NULL, `temp_uri` TEXT NOT NULL, `corners_json` TEXT NOT NULL, `width` INTEGER NOT NULL, `height` INTEGER NOT NULL, `sort_order` INTEGER NOT NULL, `status` TEXT NOT NULL, `created_at` INTEGER NOT NULL, FOREIGN KEY(`session_id`) REFERENCES `scan_sessions`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "resourceId", + "columnName": "resource_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "sessionId", + "columnName": "session_id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "tempUri", + "columnName": "temp_uri", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "cornersJson", + "columnName": "corners_json", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "width", + "columnName": "width", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "height", + "columnName": "height", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "sortOrder", + "columnName": "sort_order", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "status", + "columnName": "status", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "createdAt", + "columnName": "created_at", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": true, + "columnNames": [ + "id" + ] + }, + "indices": [ + { + "name": "index_scan_pages_resource_id", + "unique": true, + "columnNames": [ + "resource_id" + ], + "orders": [], + "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_scan_pages_resource_id` ON `${TABLE_NAME}` (`resource_id`)" + }, + { + "name": "index_scan_pages_session_id", + "unique": false, + "columnNames": [ + "session_id" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_scan_pages_session_id` ON `${TABLE_NAME}` (`session_id`)" + }, + { + "name": "index_scan_pages_sort_order", + "unique": false, + "columnNames": [ + "sort_order" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_scan_pages_sort_order` ON `${TABLE_NAME}` (`sort_order`)" + } + ], + "foreignKeys": [ + { + "table": "scan_sessions", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "session_id" + ], + "referencedColumns": [ + "id" + ] + } + ] + }, + { + "tableName": "resource_permissions", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`resource_id` TEXT NOT NULL, `resource_type` TEXT NOT NULL, `effective_access` TEXT NOT NULL, `owner_id` TEXT, `shared_by_id` TEXT, `expires_at` INTEGER, `cached_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`resource_id`))", + "fields": [ + { + "fieldPath": "resourceId", + "columnName": "resource_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "resourceType", + "columnName": "resource_type", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "effectiveAccess", + "columnName": "effective_access", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "ownerId", + "columnName": "owner_id", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "sharedById", + "columnName": "shared_by_id", + "affinity": "TEXT", + "notNull": false + }, + { + "fieldPath": "expiresAt", + "columnName": "expires_at", + "affinity": "INTEGER", + "notNull": false + }, + { + "fieldPath": "cachedAt", + "columnName": "cached_at", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updated_at", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "resource_id" + ] + }, + "indices": [ + { + "name": "index_resource_permissions_expires_at", + "unique": false, + "columnNames": [ + "expires_at" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_resource_permissions_expires_at` ON `${TABLE_NAME}` (`expires_at`)" + } + ], + "foreignKeys": [] + } + ], + "views": [], + "setupQueries": [ + "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)", + "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'db3263dbb69c07a043d41f1c83a892a5')" + ] + } +} \ No newline at end of file diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/AppDatabase.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/AppDatabase.kt index ebcc848..32b2ba2 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/AppDatabase.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/AppDatabase.kt @@ -34,6 +34,8 @@ import com.kazier.mobile.data.local.entity.UserPreferenceEntity * v16: table resource_permissions (cache snapshot, M27). * v17: bytes_uploaded + bytes_upload_attempts sur files (upload V2). * v18: has_content_server + wanted_offline sur files (download V2). + * v19: trashed_at sur files + folders (corbeille V3 — tombstone exists=0, + * restore exists=1, purge locale après 30j+). */ @Database( entities = [ @@ -41,7 +43,7 @@ import com.kazier.mobile.data.local.entity.UserPreferenceEntity PendingOperationEntity::class, ScanSessionEntity::class, ScanPageEntity::class, ResourcePermissionEntity::class, ], - version = 18, + version = 19, // m19 : schéma exporté (`app/schemas/`) — toute dérive non migrée casse // la compilation au lieu de briqueter les utilisateurs au démarrage. exportSchema = true, diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/FileDao.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/FileDao.kt index 1245795..12c15f2 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/FileDao.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/FileDao.kt @@ -97,6 +97,43 @@ interface FileDao { @Query("UPDATE files SET \"exists\" = 0, updated_at = :updatedAt WHERE resource_id = :resourceId") suspend fun markMissing(resourceId: String, updatedAt: Long) + /** + * V3 corbeille : lignes trashées, les plus récentes d'abord (écran + * Corbeille). Le masquage de l'UI passe par `exists = 0` (requêtes + * `exists = 1` inchangées) ; `trashed_at` date la purge locale. + */ + @Query("SELECT * FROM files WHERE trashed_at IS NOT NULL ORDER BY trashed_at DESC") + fun observeTrashed(): Flow> + + @Query("SELECT * FROM files WHERE trashed_at IS NOT NULL ORDER BY trashed_at DESC") + suspend fun getTrashedOnce(): List + + @Query("SELECT COUNT(*) FROM files WHERE trashed_at IS NOT NULL") + fun observeTrashedCount(): Flow + + /** Descendants sans filtre `exists` — collecte trash/restore (Deleters). */ + @Query("SELECT * FROM files WHERE folder_resource_id = :folderResourceId ORDER BY name ASC") + suspend fun getByFolderAll(folderResourceId: String): List + + /** Trash : tombstone `exists = 0` + timestamp (jamais de DELETE Room). */ + @Query("UPDATE files SET trashed_at = :now, \"exists\" = 0, updated_at = :now WHERE resource_id = :resourceId") + suspend fun markTrashed(resourceId: String, now: Long) + + /** + * Restore : lève le flag, re-visible (`exists = 1` — cloud-only si `uri` + * NULL, le walk re-marque si le physique a vraiment disparu). + */ + @Query("UPDATE files SET trashed_at = NULL, \"exists\" = 1, updated_at = :now WHERE resource_id = :resourceId") + suspend fun clearTrashed(resourceId: String, now: Long) + + /** + * Purge locale miroir de la rétention serveur (corbeille 30j + marge) : + * destruction Room des lignes trashées depuis plus de `cutoff`. Le + * serveur purge de son côté ; sans ça les tombstones s'accumuleraient. + */ + @Query("DELETE FROM files WHERE trashed_at IS NOT NULL AND trashed_at < :cutoff") + suspend fun deleteTrashedOlderThan(cutoff: Long): Int + /** * Promote le placement après confirmation serveur (`POST /sync/ops` appliqué) : * `local-cloud` si une copie physique existe, sinon `cloud`. Idempotent. diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/FolderDao.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/FolderDao.kt index 363dc1e..1f29de1 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/FolderDao.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/FolderDao.kt @@ -86,6 +86,29 @@ interface FolderDao { @Query("UPDATE folders SET \"exists\" = 0, updated_at = :updatedAt WHERE resource_id = :resourceId") suspend fun markMissing(resourceId: String, updatedAt: Long) + /** V3 corbeille : voir `FileDao.observeTrashed` — même sémantique. */ + @Query("SELECT * FROM folders WHERE trashed_at IS NOT NULL ORDER BY trashed_at DESC") + fun observeTrashed(): Flow> + + @Query("SELECT * FROM folders WHERE trashed_at IS NOT NULL ORDER BY trashed_at DESC") + suspend fun getTrashedOnce(): List + + /** Enfants sans filtre `exists` — collecte trash/restore (FolderDeleter). */ + @Query("SELECT * FROM folders WHERE parent_resource_id = :parentResourceId ORDER BY name ASC") + suspend fun getChildrenAll(parentResourceId: String): List + + /** V3 corbeille : voir `FileDao.markTrashed`. */ + @Query("UPDATE folders SET trashed_at = :now, \"exists\" = 0, updated_at = :now WHERE resource_id = :resourceId") + suspend fun markTrashed(resourceId: String, now: Long) + + /** V3 corbeille : voir `FileDao.clearTrashed`. */ + @Query("UPDATE folders SET trashed_at = NULL, \"exists\" = 1, updated_at = :now WHERE resource_id = :resourceId") + suspend fun clearTrashed(resourceId: String, now: Long) + + /** V3 corbeille : voir `FileDao.deleteTrashedOlderThan`. */ + @Query("DELETE FROM folders WHERE trashed_at IS NOT NULL AND trashed_at < :cutoff") + suspend fun deleteTrashedOlderThan(cutoff: Long): Int + /** Re-parente des sous-dossiers vers un nouveau parent (fusion). */ @Query("UPDATE folders SET parent_resource_id = :newParentId, updated_at = :updatedAt WHERE resource_id IN (:resourceIds)") suspend fun reparent(resourceIds: List, newParentId: String, updatedAt: Long) diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/PendingOperationDao.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/PendingOperationDao.kt index c548adb..33c6a6c 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/PendingOperationDao.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/PendingOperationDao.kt @@ -158,20 +158,34 @@ interface PendingOperationDao { suspend fun deleteUnpushed(): Int /** - * Un `delete_resource` est-il encore en attente de push pour cette - * ressource ? Le walk SAF ne doit alors jamais la ressusciter (`exists = - * 1`) : l'intention de suppression est déjà journalisée (ordre - * journal-first, C4) et la repasse physique va suivre. Sans ce garde, le - * walk réimporterait une ressource que le serveur s'apprête à supprimer. + * Un `delete_resource` (legacy) ou `trash_resource` (V3) est-il encore en + * attente de push pour cette ressource ? Le walk SAF ne doit alors jamais + * la ressusciter (`exists = 1`) : l'intention de suppression est déjà + * journalisée (ordre journal-first, C4) et la repasse physique va suivre. + * Sans ce garde, le walk réimporterait une ressource que le serveur + * s'apprête à trasher. */ @Query(""" SELECT COUNT(*) FROM pending_operations WHERE resource_id = :resourceId - AND operation = 'delete_resource' + AND operation IN ('delete_resource', 'trash_resource') AND status = 'pending' """) suspend fun countPendingDeleteOperations(resourceId: String): Int + /** + * Un `purge_resource` est-il encore en attente de push ? Le refresh + * serveur (qui liste encore la ressource tant que l'op n'est pas synced) + * ne doit pas la réimporter — destruction définitive en cours. + */ + @Query(""" + SELECT COUNT(*) FROM pending_operations + WHERE resource_id = :resourceId + AND operation = 'purge_resource' + AND status = 'pending' + """) + suspend fun countPendingPurgeOperations(resourceId: String): Int + /** * Un `move_resource` est-il encore en attente de push ? Tant que l'op est * pendante, le `folder_resource_id` local reflète la cible future : ni le diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/FileEntity.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/FileEntity.kt index b0dcfe9..32b6671 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/FileEntity.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/FileEntity.kt @@ -87,6 +87,16 @@ data class FileEntity( */ @ColumnInfo(name = "wanted_offline") val wantedOffline: Boolean = false, + /** + * V3 corbeille : timestamp de trash (ms epoch), NULL = vivant. Posé avec + * `exists = 0` (tombstone M5 : invisible des requêtes `exists = 1` sans + * toucher à chaque requête, exclu de la rétention via `isReleasable`, + * couvert par le sweep `getMissingWithUri` en cas de kill entre journal + * et suppression SAF). `restore` remet `exists = 1` (cloud-only si `uri` + * NULL — le walk re-marque si le physique a vraiment disparu). + */ + @ColumnInfo(name = "trashed_at") + val trashedAt: Long? = null, @ColumnInfo(name = "added_at") val addedAt: Long, @ColumnInfo(name = "updated_at") diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/FolderEntity.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/FolderEntity.kt index 4fd6b00..c0acbb1 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/FolderEntity.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/FolderEntity.kt @@ -45,6 +45,12 @@ data class FolderEntity( val syncStatus: String = "local", @ColumnInfo(name = "created_in_app", defaultValue = "0") val createdInApp: Boolean = false, + /** + * V3 corbeille : voir `FileEntity.trashedAt` — même sémantique (tombstone + * `exists = 0`, trash/restore récursifs côté Deleters, jamais de delete). + */ + @ColumnInfo(name = "trashed_at") + val trashedAt: Long? = null, @ColumnInfo(name = "added_at") val addedAt: Long, @ColumnInfo(name = "updated_at") diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/PendingOperationEntity.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/PendingOperationEntity.kt index 78b2b7f..44a4d22 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/PendingOperationEntity.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/entity/PendingOperationEntity.kt @@ -90,4 +90,13 @@ object PendingOperationType { * `operation_id` (garde anti-rejeu serveur A9). */ const val REPORT_BYTES = "report_bytes" + /** + * V3 corbeille : `trash_resource` (soft, subtree), `restore_resource` + * (lève le flag), `purge_resource` (destruction définitive). `payload` + * vide — `delete_resource` (legacy, mappé serveur vers trash) conservé + * pour compatibilité des lignes pré-V3 mais plus jamais émis. + */ + const val TRASH_RESOURCE = "trash_resource" + const val RESTORE_RESOURCE = "restore_resource" + const val PURGE_RESOURCE = "purge_resource" } \ No newline at end of file diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/migration/Migrations.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/migration/Migrations.kt index e0bab6f..a5f4641 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/migration/Migrations.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/migration/Migrations.kt @@ -316,7 +316,20 @@ object Migrations { } } + /** + * V3 corbeille : `trashed_at` (ms epoch, NULL = vivant) sur `files` + + * `folders`. Zéro backfill (NULL = vivant = état courant). Le masquage + * passe par `exists = 0` posé par l'action de trash (pas par cette + * colonne seule) — les requêtes `exists = 1` restent inchangées. + */ + private val MIGRATION_18_19 = object : Migration(18, 19) { + override fun migrate(db: SupportSQLiteDatabase) { + db.execSQL("ALTER TABLE `files` ADD COLUMN `trashed_at` INTEGER") + db.execSQL("ALTER TABLE `folders` ADD COLUMN `trashed_at` INTEGER") + } + } + val ALL: Array = arrayOf( - MIGRATION_1_2, MIGRATION_2_3, MIGRATION_3_4, MIGRATION_4_5, MIGRATION_5_6, MIGRATION_6_7, MIGRATION_7_8, MIGRATION_8_9, MIGRATION_9_10, MIGRATION_10_11, MIGRATION_11_12, MIGRATION_12_13, MIGRATION_13_14, MIGRATION_14_15, MIGRATION_15_16, MIGRATION_16_17, MIGRATION_17_18, + MIGRATION_1_2, MIGRATION_2_3, MIGRATION_3_4, MIGRATION_4_5, MIGRATION_5_6, MIGRATION_6_7, MIGRATION_7_8, MIGRATION_8_9, MIGRATION_9_10, MIGRATION_10_11, MIGRATION_11_12, MIGRATION_12_13, MIGRATION_13_14, MIGRATION_14_15, MIGRATION_15_16, MIGRATION_16_17, MIGRATION_17_18, MIGRATION_18_19, ) } \ No newline at end of file diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/ApiClient.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/ApiClient.kt index 21329e3..e9e2488 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/ApiClient.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/ApiClient.kt @@ -29,6 +29,8 @@ import com.kazier.mobile.data.remote.dto.ShareLinkDto import com.kazier.mobile.data.remote.dto.SyncOpDto import com.kazier.mobile.data.remote.dto.SyncOpsRequest import com.kazier.mobile.data.remote.dto.SyncOpsResult +import com.kazier.mobile.data.remote.dto.TrashDto +import com.kazier.mobile.data.remote.dto.VersionDto import kotlin.coroutines.cancellation.CancellationException import okhttp3.MultipartBody import okhttp3.MediaType.Companion.toMediaType @@ -148,6 +150,21 @@ class ApiClient @Inject constructor( suspend fun deleteFile(fileId: String): String = unwrap({ apiService.deleteFile(fileId) }).id + /** Corbeille serveur V3 — `GET /trash` (+ `meta`). */ + suspend fun listTrashPaged( + page: Int? = null, + pageSize: Int? = null, + ): Pair, ApiMeta?> = + unwrapWithMeta({ apiService.listTrash(page, pageSize) }) + + /** Restaure une ressource trashée — `POST /files/:id/restore`. */ + suspend fun restoreFile(fileId: String): String = + unwrap({ apiService.restoreFile(fileId) }).id + + /** Historique des octets — `GET /files/:id/versions`. */ + suspend fun listVersions(fileId: String): List = + unwrap({ apiService.listVersions(fileId) }) + /** Recherche serveur paginée — `GET /files/search?q=…` (+ `meta`). */ suspend fun searchFilesPaged( query: String, diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/ApiService.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/ApiService.kt index 5e16804..b2194a7 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/ApiService.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/ApiService.kt @@ -22,6 +22,8 @@ import com.kazier.mobile.data.remote.dto.ShareGrantDto import com.kazier.mobile.data.remote.dto.ShareLinkDto import com.kazier.mobile.data.remote.dto.SyncOpsRequest import com.kazier.mobile.data.remote.dto.SyncOpsResult +import com.kazier.mobile.data.remote.dto.TrashDto +import com.kazier.mobile.data.remote.dto.VersionDto import okhttp3.MultipartBody import okhttp3.RequestBody import okhttp3.ResponseBody @@ -145,6 +147,35 @@ interface ApiService { @Path("id") fileId: String, ): Response> + /** + * Corbeille serveur V3 (`GET /trash`, paginé `meta`) — ressources + * trashées du user, les plus récentes d'abord. + */ + @GET("trash") + suspend fun listTrash( + @Query("page") page: Int?, + @Query("pageSize") pageSize: Int?, + ): Response>> + + /** Restaure une ressource trashée — `POST /files/:id/restore`. */ + @POST("files/{id}/restore") + suspend fun restoreFile( + @Path("id") fileId: String, + ): Response> + + /** Historique des octets — `GET /files/:id/versions` (parent live). */ + @GET("files/{id}/versions") + suspend fun listVersions( + @Path("id") fileId: String, + ): Response>> + + /** Recopie la génération `n` vers le live (V3 versions). */ + @POST("files/{id}/versions/{n}/restore") + suspend fun restoreVersion( + @Path("id") fileId: String, + @Path("n") versionNo: Int, + ): Response> + /** * Recherche serveur (`GET /files/search?q=…`, paginé `meta`). Non consommée * en V1 (recherche 100 % locale via Room) — exposée pour parité contrat. diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/dto/Dtos.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/dto/Dtos.kt index 26d214b..dd1fb68 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/dto/Dtos.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/dto/Dtos.kt @@ -250,4 +250,29 @@ data class OcrSubmitDto( data class FileOcrDto( @Json(name = "text") val text: String, @Json(name = "updatedAt") val updatedAt: String? = null, +) + +/** + * Entrée `GET /trash` (V3 corbeille) — miroir de `TrashDTO` Go. `type` = + * "file" | "folder", `trashedAt` en RFC3339 (affichage), tri serveur + * (plus récent d'abord). + */ +data class TrashDto( + @Json(name = "id") val id: String, + @Json(name = "type") val type: String, + @Json(name = "name") val name: String, + @Json(name = "size") val size: Long = 0L, + @Json(name = "trashedAt") val trashedAt: String? = null, + @Json(name = "updatedAt") val updatedAt: String? = null, +) + +/** + * Génération figée `GET /files/{id}/versions` (V3) — miroir de `VersionDTO` + * Go. Le restore recopie vers le live (l'actuel est à son tour versionné). + */ +data class VersionDto( + @Json(name = "versionNo") val versionNo: Int, + @Json(name = "size") val size: Long = 0L, + @Json(name = "mimeType") val mimeType: String? = null, + @Json(name = "createdAt") val createdAt: String? = null, ) \ No newline at end of file diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/FileRepository.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/FileRepository.kt index d7a9855..5b1c747 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/FileRepository.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/FileRepository.kt @@ -208,6 +208,13 @@ class FileRepository @Inject constructor( return existing.copy(exists = 0, updatedAt = now) } + // Garde corbeille V3 : une ligne trashée n'est JAMAIS ressuscitée par + // le walk — ni par réimport SAF (IN_CLOUD garde le physique), ni par + // réactivation. Seul `restore` (TrashRepository) lève le flag. + if (existing != null && existing.trashedAt != null) { + return existing + } + // Un `move_resource` encore en attente fait de la cible outbox la // source de vérité du placement : un snapshot SAF périmé (walk lancé // avant le move) ne doit pas ré-attribuer le dossier à l'ancien parent. @@ -271,6 +278,23 @@ class FileRepository @Inject constructor( suspend fun markMissing(resourceId: String, updatedAt: Long) = fileDao.markMissing(resourceId, updatedAt) + /** Lignes trashées (écran Corbeille) — les plus récentes d'abord. */ + fun observeTrashed(): Flow> = fileDao.observeTrashed() + + fun observeTrashedCount(): Flow = fileDao.observeTrashedCount() + + /** Fichiers d'un dossier sans filtre `exists` — collecte trash/restore. */ + suspend fun getFilesInFolderAll(folderResourceId: String): List = + fileDao.getByFolderAll(folderResourceId) + + /** Trash local (tombstone, jamais de DELETE) — dans la transaction de l'op outbox. */ + suspend fun markTrashed(resourceId: String, trashedAt: Long) = + fileDao.markTrashed(resourceId, trashedAt) + + /** Restore local — dans la transaction de l'op outbox `restore_resource`. */ + suspend fun clearTrashed(resourceId: String, now: Long) = + fileDao.clearTrashed(resourceId, now) + /** Met à jour la cible dossier d'un fichier (déplacement local / cloud-only). * * Le `move_resource` n'est journalisé que si le serveur connaît déjà la @@ -320,6 +344,16 @@ class FileRepository @Inject constructor( // L'antichambre outbox fait foi tant que le move n'est pas synced. return@forEach } + if (outboxRepository.hasPendingPurgeOperation(dto.id)) { + // Destruction définitive en cours : le serveur renvoie + // encore la ressource, ne jamais la réimporter (V3). + return@forEach + } + // Ligne trashée localement : le serveur la renvoie encore + // tant que l'op trash n'est pas synced — ne pas la ressusciter. + if (fileDao.getByResourceId(dto.id)?.trashedAt != null) { + return@forEach + } upsertTolerant(toEntity(dto, folderResourceId, now)) } if (files.isEmpty()) break diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/FolderRepository.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/FolderRepository.kt index 4f3bf5c..8b36b6b 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/FolderRepository.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/FolderRepository.kt @@ -56,6 +56,21 @@ class FolderRepository @Inject constructor( suspend fun getChildren(parentResourceId: String): List = folderDao.getByParentOnce(parentResourceId) + /** Enfants sans filtre `exists` — collecte trash/restore (FolderDeleter). */ + suspend fun getChildrenAll(parentResourceId: String): List = + folderDao.getChildrenAll(parentResourceId) + + /** Lignes trashées (écran Corbeille). */ + fun observeTrashed(): Flow> = folderDao.observeTrashed() + + /** Trash local (tombstone) — dans la transaction de l'op outbox. */ + suspend fun markTrashed(resourceId: String, trashedAt: Long) = + folderDao.markTrashed(resourceId, trashedAt) + + /** Restore local — dans la transaction de l'op outbox `restore_resource`. */ + suspend fun clearTrashed(resourceId: String, now: Long) = + folderDao.clearTrashed(resourceId, now) + /** Dossiers créés dans l'app uniquement (cibles du picker de déplacement). */ suspend fun getCreatedInApp(): List = folderDao.getCreatedInApp() @@ -80,6 +95,15 @@ class FolderRepository @Inject constructor( // synced : le serveur renvoie encore l'ancien parent. outboxRepository.hasPendingMoveOperation(dto.id) } + .filterNot { dto -> + // Destruction définitive en cours (V3) : ne pas réimporter. + outboxRepository.hasPendingPurgeOperation(dto.id) + } + .filterNot { dto -> + // Ligne trashée localement : le serveur la renvoie encore + // tant que l'op trash n'est pas synced — ne pas ressusciter. + folderDao.getByResourceId(dto.id)?.trashedAt != null + } .map { toEntity(it, now) } if (rows.isNotEmpty()) folderDao.upsertAll(rows) } @@ -129,6 +153,11 @@ class FolderRepository @Inject constructor( return existing.copy(exists = 0, updatedAt = now) } + // Garde corbeille V3 : voir `FileRepository.saveLocalFile`. + if (existing != null && existing.trashedAt != null) { + return existing + } + // Garde pending-move (M1) : un snapshot SAF périmé ne revert jamais un // reparent/merge en cours de push. val movePending = existing != null && outboxRepository.hasPendingMoveOperation(existing.resourceId) diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/OutboxRepository.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/OutboxRepository.kt index 6a9bf26..98c0a73 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/OutboxRepository.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/OutboxRepository.kt @@ -101,7 +101,7 @@ class OutboxRepository @Inject constructor( payload = mapOf("toFolderResourceId" to toFolderResourceId), ) - /** Raccourci `delete_resource` — idempotent côté serveur. */ + /** Raccourci `delete_resource` — legacy V3 (serveur : mappé vers trash). */ suspend fun enqueueDeleteResource( resourceId: String, resourceType: String, @@ -111,6 +111,20 @@ class OutboxRepository @Inject constructor( resourceType = resourceType, ) + /** + * Raccourcis corbeille V3 — payload vide, `resource_id` + `resource_type` + * portent tout (docs/api-v1.md §6.1). MÊME transaction que le + * `markTrashed`/`clearTrashed` Room correspondant (Deleters). + */ + suspend fun enqueueTrashResource(resourceId: String, resourceType: String): String = + enqueue(PendingOperationType.TRASH_RESOURCE, resourceId, resourceType) + + suspend fun enqueueRestoreResource(resourceId: String, resourceType: String): String = + enqueue(PendingOperationType.RESTORE_RESOURCE, resourceId, resourceType) + + suspend fun enqueuePurgeResource(resourceId: String, resourceType: String): String = + enqueue(PendingOperationType.PURGE_RESOURCE, resourceId, resourceType) + /** * Raccourci `share` — payload `{ granteeUserId|granteeGroupId, access }` * (voir docs/api-v1.md §6.1). `access`: viewer | commenter | editor. @@ -299,13 +313,21 @@ class OutboxRepository @Inject constructor( pendingOperationDao.countPendingMoveOperations(resourceId) > 0 /** - * Un `delete_resource` est-il encore en attente de push ? Garde - * anti-résurrection du walk (C4, voir DAO) : une ressource dont la - * suppression est journalisée ne doit plus être réimportée. + * Un `delete_resource` (legacy) ou `trash_resource` (V3) est-il encore en + * attente de push ? Garde anti-résurrection du walk (C4, voir DAO). */ suspend fun hasPendingDeleteOperation(resourceId: String): Boolean = pendingOperationDao.countPendingDeleteOperations(resourceId) > 0 + /** + * Un `purge_resource` est-il encore en attente de push ? Garde du refresh + * serveur : une destruction définitive en cours ne doit pas être + * réimportée par la liste serveur (qui la renvoie tant que l'op n'est + * pas synced). + */ + suspend fun hasPendingPurgeOperation(resourceId: String): Boolean = + pendingOperationDao.countPendingPurgeOperations(resourceId) > 0 + companion object { /** * Clé du lien parent→enfant, à la fois dans le payload JSON diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/TrashRepository.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/TrashRepository.kt new file mode 100644 index 0000000..0e359b1 --- /dev/null +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/TrashRepository.kt @@ -0,0 +1,213 @@ +package com.kazier.mobile.data.repository + +import androidx.room.withTransaction +import com.kazier.mobile.data.local.AppDatabase +import com.kazier.mobile.data.local.dao.FileDao +import com.kazier.mobile.data.local.dao.FolderDao +import com.kazier.mobile.data.local.entity.FileEntity +import com.kazier.mobile.data.local.entity.FolderEntity +import com.kazier.mobile.data.remote.ApiClient +import javax.inject.Inject +import javax.inject.Singleton +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.combine + +/** + * Corbeille V3 — पढ़ें local-first du trash serveur. + * + * - L'action de trash est portée par les Deleters (journal-first + outbox + * `trash_resource`) ; ce repository porte le **restore**, la **purge + * définitive** et la **convergence** (`GET /trash` → tombstones locales). + * - Ordre outbox préservé : un restore après un trash encore pending + * s'enqueue APRÈS (jamais d'annulation du trash pending) — le serveur + * applique trash puis restore, l'intention finale gagne. + * - Purge = destruction locale immédiate + op `purge_resource` si le serveur + * connaît la ressource ; si l'op dead-letter, le refresh reconverge (la + * ressource réapparaît — l'utilisateur peut re-purger). + */ +@Singleton +class TrashRepository @Inject constructor( + private val appDatabase: AppDatabase, + private val fileDao: FileDao, + private val folderDao: FolderDao, + private val fileRepository: FileRepository, + private val folderRepository: FolderRepository, + private val outboxRepository: OutboxRepository, + private val apiClient: ApiClient, +) { + + /** Lignes trashées pour l'écran Corbeille (fichiers + dossiers). */ + fun observeTrashedFiles(): Flow> = fileRepository.observeTrashed() + + fun observeTrashedFolders(): Flow> = folderRepository.observeTrashed() + + fun observeTrashedCount(): Flow = combine( + fileRepository.observeTrashedCount(), + folderRepository.observeTrashed(), + ) { files, folders -> files + folders.size } + + /** + * Restore d'un fichier : lève le flag + `restore_resource` si le serveur + * connaît la ressource (create synced — sinon rien à restaurer côté + * serveur, réactivation purement locale). + */ + suspend fun restoreFile(resourceId: String) { + val now = System.currentTimeMillis() + appDatabase.withTransaction { + fileRepository.clearTrashed(resourceId, now) + if (outboxRepository.hasSyncedCreateOperation(resourceId)) { + outboxRepository.enqueueRestoreResource(resourceId, "file") + } + } + } + + /** Restore d'un dossier et de tout son arbre (miroir du trash). */ + suspend fun restoreFolder(resourceId: String) { + val now = System.currentTimeMillis() + appDatabase.withTransaction { + folderRepository.clearTrashed(resourceId, now) + if (outboxRepository.hasCreateOperationAnyType(resourceId)) { + outboxRepository.enqueueRestoreResource(resourceId, "folder") + } + for (file in fileRepository.getFilesInFolderAll(resourceId)) { + if (file.trashedAt != null) { + fileRepository.clearTrashed(file.resourceId, now) + if (outboxRepository.hasCreateOperation(file.resourceId)) { + outboxRepository.enqueueRestoreResource(file.resourceId, "file") + } + } + } + restoreFolderChildren(resourceId, now) + } + } + + private suspend fun restoreFolderChildren(parentId: String, now: Long) { + for (child in folderRepository.getChildrenAll(parentId)) { + if (child.trashedAt != null) { + folderRepository.clearTrashed(child.resourceId, now) + if (outboxRepository.hasCreateOperationAnyType(child.resourceId)) { + outboxRepository.enqueueRestoreResource(child.resourceId, "folder") + } + for (file in fileRepository.getFilesInFolderAll(child.resourceId)) { + if (file.trashedAt != null) { + fileRepository.clearTrashed(file.resourceId, now) + if (outboxRepository.hasCreateOperation(file.resourceId)) { + outboxRepository.enqueueRestoreResource(file.resourceId, "file") + } + } + } + restoreFolderChildren(child.resourceId, now) + } + } + } + + /** + * Purge définitive d'un fichier : op `purge_resource` (si connue serveur) + * + destruction locale immédiate (ligne Room). Le SAF a déjà été supprimé + * par l'action de trash (FULL) ou n'a jamais existé (IN_CLOUD). + */ + suspend fun purgeFile(resourceId: String) { + appDatabase.withTransaction { + outboxRepository.cancelPendingCreates(resourceId) + if (outboxRepository.hasSyncedCreateOperation(resourceId)) { + outboxRepository.enqueuePurgeResource(resourceId, "file") + } + fileDao.remove(resourceId) + } + } + + /** Purge définitive d'un dossier et de son arbre. */ + suspend fun purgeFolder(resourceId: String) { + appDatabase.withTransaction { + val files = mutableListOf() + val folders = mutableListOf(resourceId) + collectTrashedTree(resourceId, files, folders) + for (id in files) { + outboxRepository.cancelPendingCreates(id) + if (outboxRepository.hasSyncedCreateOperation(id)) { + outboxRepository.enqueuePurgeResource(id, "file") + } + fileDao.remove(id) + } + for (id in folders) { + outboxRepository.cancelPendingCreates(id) + if (outboxRepository.hasCreateOperationAnyType(id)) { + outboxRepository.enqueuePurgeResource(id, "folder") + } + folderDao.remove(id) + } + } + } + + private suspend fun collectTrashedTree(rootId: String, files: MutableList, folders: MutableList) { + for (file in fileRepository.getFilesInFolderAll(rootId)) { + files += file.resourceId + } + for (child in folderRepository.getChildrenAll(rootId)) { + folders += child.resourceId + collectTrashedTree(child.resourceId, files, folders) + } + } + + /** + * Convergence cross-device : rapatrie `GET /trash` (paginé) et pose les + * tombstones locales manquantes (trash fait ailleurs, jamais poussé + * d'ici — aucune op outbox). Best-effort (réseau toléré, voir + * `SyncViewModel`). + */ + suspend fun syncTrashFromServer() { + var page = 1 + val now = System.currentTimeMillis() + while (page <= MAX_PAGES) { + val (items, meta) = apiClient.listTrashPaged(page = page, pageSize = PAGE_SIZE) + if (items.isEmpty()) break + appDatabase.withTransaction { + for (dto in items) { + when (dto.type) { + "file" -> { + val local = fileDao.getByResourceId(dto.id) + if (local != null && local.trashedAt == null) { + fileDao.markTrashed(dto.id, now) + } + } + "folder" -> { + val local = folderDao.getByResourceId(dto.id) + if (local != null && local.trashedAt == null) { + folderDao.markTrashed(dto.id, now) + } + } + } + } + } + val total = meta?.total + if (total != null) { + if (page * PAGE_SIZE >= total) break + } else if (items.size < PAGE_SIZE) { + break + } + page++ + } + } + + /** + * Expiration locale miroir (corbeille 30j serveur + marge) : destruction + * Room des tombstones anciennes. Appelée par la passe de rétention + * (quotidienne, sans réseau). + */ + suspend fun purgeExpiredLocally(cutoff: Long): Int { + val files = fileDao.deleteTrashedOlderThan(cutoff) + val folders = folderDao.deleteTrashedOlderThan(cutoff) + return files + folders + } + + companion object { + private const val PAGE_SIZE = 50 + private const val MAX_PAGES = 200 + /** + * Rétention locale des tombstones : 31j (serveur 30j + 1j de marge — + * une ligne purgée serveur ne doit jamais réapparaître via un vieux + * restore local). + */ + const val LOCAL_RETENTION_MS = 31L * 24 * 60 * 60 * 1000 + } +} diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/FileDeleter.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/FileDeleter.kt index 5e36720..4d93d05 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/FileDeleter.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/FileDeleter.kt @@ -20,14 +20,16 @@ import javax.inject.Inject import javax.inject.Singleton /** - * Suppression de fichiers en mode multi-sélection. + * Suppression de fichiers en mode multi-sélection (V3 : corbeille). * * Trois modes : * - **LOCALLY** : supprime le fichier physique SAF + marque `exists = 0` en Room, * sans journaliser dans l\'outbox (le serveur n\'est pas affecté). - * - **IN_CLOUD** : enqueue `delete_resource` dans l\'outbox uniquement, sans - * toucher au fichier local. - * - **FULL** : les deux — suppression physique + outbox `delete_resource`. + * - **IN_CLOUD** : enqueue `trash_resource` dans l\'outbox + tombstone locale + * (`trashed_at`, `exists = 0`, M5) dans la MÊME transaction, sans toucher + * au fichier physique local. + * - **FULL** : les deux — journal trash + suppression physique SAF, puis + * détachement `uri` (la ligne devient trashée cloud-only, restaurable). */ @Singleton class FileDeleter @Inject constructor( @@ -84,12 +86,12 @@ class FileDeleter @Inject constructor( } /** - * Suppression cloud uniquement (outbox `delete_resource` + tombstone locale). + * Trash serveur uniquement (outbox `trash_resource` + tombstone locale). * Le fichier physique local n'est pas touché, mais la ligne Room passe - * `exists = 0` dans la MÊME transaction (M5) : sans ça la ressource restait - * affichée, le walk la revoyait et `refreshFromServer` ne supprime jamais - * de lignes → fantôme local vs serveur supprimé. N'a de sens que si la - * ressource a déjà été poussée (gate « processed »). + * `trashed_at` + `exists = 0` dans la MÊME transaction (M5) : sans ça la + * ressource restait affichée, le walk la revoyait et `refreshFromServer` + * ne supprime jamais de lignes → fantôme local vs serveur trashé. + * N'a de sens que si la ressource a déjà été poussée (gate « processed »). */ private suspend fun deleteInCloud(file: FileEntity): Boolean { var ok = false @@ -97,43 +99,43 @@ class FileDeleter @Inject constructor( val now = System.currentTimeMillis() appDatabase.withTransaction { // Jamais poussé (create encore pending) : annulation (M19), pas - // de delete — le serveur n'a rien à oublier. Poussé (synced) : - // `delete_resource`, le serveur connaît la ressource. + // d'op — le serveur n'a rien à oublier. Poussé (synced) : + // `trash_resource`, le serveur connaît la ressource. outboxRepository.cancelPendingCreates(file.resourceId) if (outboxRepository.hasSyncedCreateOperation(file.resourceId)) { - outboxRepository.enqueueDeleteResource(file.resourceId, "file") + outboxRepository.enqueueTrashResource(file.resourceId, "file") } - fileRepository.markMissing(file.resourceId, now) + fileRepository.markTrashed(file.resourceId, now) } ok = true - Timber.d("enqueued cloud delete for %s", file.resourceId) + Timber.d("enqueued trash for %s", file.resourceId) }.onFailure { e -> - Timber.w(e, "enqueueDeleteResource failed for %s", file.resourceId) + Timber.w(e, "enqueueTrashResource failed for %s", file.resourceId) } return ok } /** - * Suppression complète : journal d'abord, physique ensuite (C4). + * Trash complète : journal d'abord, physique ensuite (C4). * - * Ordre crash-safe : la transaction Room (`exists = 0` + annulation du - * create pending + éventuel `delete_resource`) est committée AVANT la + * Ordre crash-safe : la transaction Room (`trashed_at` + annulation du + * create pending + éventuel `trash_resource`) est committée AVANT la * suppression SAF — un kill entre les deux ne perd plus le journal, le * serveur est toujours notifié. Si la suppression physique échoue (ou si - * le kill survient juste après), la ligne reste `exists = 0` avec son - * `uri` : la repasse [sweepPendingPhysicalDeletes] retentera le - * `deleteDocument` au prochain tick (le walk peut la ressusciter - * entre-temps, elle sera re-marquée sans nouveau journal — convergence). + * le kill survient juste après), la ligne reste trashée avec son `uri` : + * la repasse [sweepPendingPhysicalDeletes] retentera le `deleteDocument` + * au prochain tick (le walk ne ressuscite plus les lignes trashées — + * garde `trashedAt`). */ private suspend fun deleteFull(file: FileEntity): Boolean { val uri = file.uri return if (uri != null) { val now = System.currentTimeMillis() appDatabase.withTransaction { - fileRepository.markMissing(file.resourceId, now) + fileRepository.markTrashed(file.resourceId, now) outboxRepository.cancelPendingCreates(file.resourceId) if (outboxRepository.hasSyncedCreateOperation(file.resourceId)) { - outboxRepository.enqueueDeleteResource(file.resourceId, "file") + outboxRepository.enqueueTrashResource(file.resourceId, "file") } } val deleted = runCatching { @@ -144,6 +146,10 @@ class FileDeleter @Inject constructor( if (deleted) { Timber.d("deleted full %s", uri) thumbnailStore.delete(file.resourceId) + // Ligne trashée cloud-only (restaurable, `uri` NULL) + le + // serveur apprend que les octets sont partis (V2 placements). + fileRepository.detachLocalCopy(file.resourceId) + outboxRepository.enqueueReportBytes(file.resourceId, "file", false) } else { Timber.w("deleteDocument returned false for %s (sweep will retry)", uri) } @@ -176,8 +182,14 @@ class FileDeleter @Inject constructor( }.getOrDefault(false) if (deleted) { thumbnailStore.delete(file.resourceId) - // Rattrapage : ces octets n'avaient jamais été signalés partis. - outboxRepository.enqueueReportBytes(file.resourceId, "file", false) + // Ligne trashée (V3) : le serveur l'a déjà oubliée — inutile + // de lui signaler des octets partis (op vouée au NOT_FOUND + // dead-letter). Lignes non trashées : rattrapage V2. + if (file.trashedAt == null) { + outboxRepository.enqueueReportBytes(file.resourceId, "file", false) + } else { + fileRepository.detachLocalCopy(file.resourceId) + } swept++ } } diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/FolderDeleter.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/FolderDeleter.kt index 632d9cb..6856510 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/FolderDeleter.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/FolderDeleter.kt @@ -30,8 +30,10 @@ import javax.inject.Singleton * Trois modes (partagés avec `FileDeleter`) : * - **LOCALLY** : suppression physique SAF de l'arbre + marquage `exists = 0` * Room, sans outbox (le serveur n'est pas affecté). - * - **IN_CLOUD** : enqueue `delete_resource` pour les dossiers uniquement. - * - **FULL** : les deux — suppression physique + outbox, transaction atomique. + * - **IN_CLOUD** : enqueue `trash_resource` pour l'arbre + tombstones locales + * (`trashed_at`, M5) dans la MÊME transaction — le physique reste intact + * mais l'arbre disparaît de l'UI et le walk ne le ressuscite plus. + * - **FULL** : les deux — journal trash + suppression physique, transaction atomique. */ @Singleton class FolderDeleter @Inject constructor( @@ -88,10 +90,11 @@ class FolderDeleter @Inject constructor( } /** - * Suppression cloud uniquement (outbox `delete_resource` + tombstone locale, - * M5) : le dossier et toute sa descendance Room passent `exists = 0` dans + * Trash serveur uniquement (outbox `trash_resource` + tombstones locales, + * M5) : le dossier et toute sa descendance Room passent `trashed_at` dans * la MÊME transaction — le physique reste intact mais l'arbre disparaît de - * l'UI et le walk ne le ressuscite plus (garde `hasPendingDeleteOperation`). + * l'UI et le walk ne le ressuscite plus (gardes `hasPendingDeleteOperation` + * élargi + `trashedAt`). */ private suspend fun deleteInCloud(folder: FolderEntity): Boolean { var ok = false @@ -99,26 +102,26 @@ class FolderDeleter @Inject constructor( val tree = collectDescendants(folder.resourceId) val now = System.currentTimeMillis() appDatabase.withTransaction { - treeMarkMissing(folder, tree, now) + treeMarkTrashed(folder, tree, now) } ok = true - Timber.d("enqueued cloud delete for folder %s", folder.resourceId) + Timber.d("enqueued trash for folder %s", folder.resourceId) }.onFailure { e -> - Timber.w(e, "enqueueDeleteResource failed for folder %s", folder.resourceId) + Timber.w(e, "enqueueTrashResource failed for folder %s", folder.resourceId) } return ok } /** - * Suppression complète : journal d'abord, physique ensuite (C4). + * Trash complète : journal d'abord, physique ensuite (C4). * * Même contrat crash-safe que `FileDeleter.deleteFull` : la transaction - * Room (`exists = 0` sur tout l'arbre + annulation des creates pending + - * `delete_resource` là où le serveur connaît déjà la ressource) est + * Room (`trashed_at` sur tout l'arbre + annulation des creates pending + + * `trash_resource` là où le serveur connaît déjà la ressource) est * committée AVANT la suppression SAF. Un kill entre les deux ne perd plus * le journal ; si le physique échoue, [sweepPendingPhysicalDeletes] - * retentera au prochain tick (le walk ne ressuscite plus les lignes sous - * `delete_resource` pending — garde anti-résurrection). + * retentera au prochain tick (le walk ne ressuscite plus les lignes + * trashées — garde `trashedAt`). */ private suspend fun deleteFull(folder: FolderEntity): Boolean { val uri = folder.uri @@ -126,7 +129,7 @@ class FolderDeleter @Inject constructor( val tree = collectDescendants(folder.resourceId) val now = System.currentTimeMillis() appDatabase.withTransaction { - treeMarkMissing(folder, tree, now) + treeMarkTrashed(folder, tree, now) } return if (deleteTreePhysically(folder, tree)) { tree.files.forEach { thumbnailStore.delete(it.resourceId) } @@ -172,36 +175,76 @@ class FolderDeleter @Inject constructor( private const val SWEEP_LIMIT = 50 } - /** Marque missing + outbox `delete_resource` pour toute la descendance, atomique. */ - private suspend fun treeMarkMissing(folder: FolderEntity, tree: FolderTree, now: Long) { + /** Marque trash + outbox `trash_resource` pour toute la descendance, atomique. */ + private suspend fun treeMarkTrashed(folder: FolderEntity, tree: FolderTree, now: Long) { for (file in tree.files) { - fileRepository.markMissing(file.resourceId, now) + fileRepository.markTrashed(file.resourceId, now) outboxRepository.cancelPendingCreates(file.resourceId) if (outboxRepository.hasSyncedCreateOperation(file.resourceId)) { - outboxRepository.enqueueDeleteResource(file.resourceId, "file") + outboxRepository.enqueueTrashResource(file.resourceId, "file") } } for (desc in tree.folders) { - folderRepository.markMissing(desc.resourceId, now) + folderRepository.markTrashed(desc.resourceId, now) outboxRepository.cancelPendingCreates(desc.resourceId) if (outboxRepository.hasSyncedCreateOperationAnyType(desc.resourceId)) { - outboxRepository.enqueueDeleteResource(desc.resourceId, "folder") + outboxRepository.enqueueTrashResource(desc.resourceId, "folder") } } - folderRepository.markMissing(folder.resourceId, now) + folderRepository.markTrashed(folder.resourceId, now) outboxRepository.cancelPendingCreates(folder.resourceId) if (outboxRepository.hasSyncedCreateOperationAnyType(folder.resourceId)) { - outboxRepository.enqueueDeleteResource(folder.resourceId, "folder") + outboxRepository.enqueueTrashResource(folder.resourceId, "folder") } } - /** Énumère le contenu d'un dossier (fichiers + sous-dossiers, tout niveau) via Room. */ - private suspend fun collectDescendants(folderResourceId: String): FolderTree { - val files = fileRepository.getFilesInFolder(folderResourceId).toMutableList() + /** + * Lève le flag trash sur tout l'arbre + enqueue `restore_resource` par + * nœud connu du serveur (miroir de [treeMarkTrashed]). Les nœuds jamais + * poussés sont juste réactivés localement (le serveur ne les connaît pas). + */ + suspend fun treeRestore(folderResourceId: String) { + val tree = collectDescendants(folderResourceId, includeTrashed = true) + val now = System.currentTimeMillis() + appDatabase.withTransaction { + for (file in tree.files) { + fileRepository.clearTrashed(file.resourceId, now) + if (outboxRepository.hasCreateOperation(file.resourceId)) { + outboxRepository.enqueueRestoreResource(file.resourceId, "file") + } + } + for (desc in tree.folders) { + folderRepository.clearTrashed(desc.resourceId, now) + if (outboxRepository.hasCreateOperationAnyType(desc.resourceId)) { + outboxRepository.enqueueRestoreResource(desc.resourceId, "folder") + } + } + folderRepository.clearTrashed(folderResourceId, now) + if (outboxRepository.hasCreateOperationAnyType(folderResourceId)) { + outboxRepository.enqueueRestoreResource(folderResourceId, "folder") + } + } + } + + /** + * Énumère le contenu d'un dossier (fichiers + sous-dossiers, tout niveau) + * via Room. `includeTrashed = true` pour le restore (les enfants trashés + * sont invisibles des requêtes `exists = 1`). + */ + private suspend fun collectDescendants(folderResourceId: String, includeTrashed: Boolean = false): FolderTree { + val files = if (includeTrashed) { + fileRepository.getFilesInFolderAll(folderResourceId) + } else { + fileRepository.getFilesInFolder(folderResourceId) + }.toMutableList() val folders = mutableListOf() - val children = folderRepository.getChildren(folderResourceId) + val children = if (includeTrashed) { + folderRepository.getChildrenAll(folderResourceId) + } else { + folderRepository.getChildren(folderResourceId) + } for (child in children) { - val sub = collectDescendants(child.resourceId) + val sub = collectDescendants(child.resourceId, includeTrashed) files += sub.files folders += child folders += sub.folders diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/SafFileDeleter.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/SafFileDeleter.kt index a2a1a49..f83158d 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/SafFileDeleter.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/saf/SafFileDeleter.kt @@ -18,14 +18,14 @@ import javax.inject.Inject import javax.inject.Singleton /** - * Suppression physique d'un fichier sur le device (mode review « supprimer »). + * Trash d'un fichier depuis le mode review « supprimer » (V3 : corbeille). * - * Appelle `DocumentsContract.deleteDocument` sur l'uri SAF — le fichier - * disparaît aussi de l'arborescence (et donc du prochain sync). En cas de - * succès, la ligne Room est masquée (`exists = 0`) : cohérent avec la - * réconciliation (jamais de DELETE SQL), idempotent face à la marche 30s. - * La suppression est aussi journalisée dans l'outbox (`delete_resource`), - * dans la même transaction que le masquage Room. + * Journal d'abord (`trashed_at` + `trash_resource` si le serveur connaît la + * ressource), physique ensuite — même contrat crash-safe que + * `FileDeleter.deleteFull` (C4). En cas de succès SAF la ligne reste trashée + * (restaurable, cloud-only si plus d'`uri`) ; en cas de refus, la repasse + * `FileDeleter.sweepPendingPhysicalDeletes` retente (jamais de DELETE SQL, + * idempotent face à la marche 30s). * * Retourne `false` si le provider refuse la suppression (permission ou pas de * geste delete) : dans ce cas le fichier reste dans la file de review. @@ -42,7 +42,7 @@ class SafFileDeleter @Inject constructor( private val resolver: ContentResolver get() = context.contentResolver /** - * Suppression review (swipe ✗) : journal d'abord, physique ensuite (C4 — + * Trash review (swipe ✗) : journal d'abord, physique ensuite (C4 — * même contrat que `FileDeleter.deleteFull`, la repasse * `FileDeleter.sweepPendingPhysicalDeletes` couvrant aussi ces lignes). */ @@ -51,15 +51,15 @@ class SafFileDeleter @Inject constructor( return withContext(Dispatchers.IO) { val now = System.currentTimeMillis() appDatabase.withTransaction { - fileRepository.markMissing(file.resourceId, now) + fileRepository.markTrashed(file.resourceId, now) // Gate « processed » + annulation (M19) : si le fichier // n'a jamais été poussé (create encore pending), on - // annule le create au lieu d'un delete bruit ; le - // delete n'est journalisé que si le serveur connaît + // annule le create au lieu d'une op bruit ; le + // trash n'est journalisé que si le serveur connaît // déjà la ressource (create synced). outboxRepository.cancelPendingCreates(file.resourceId) if (outboxRepository.hasSyncedCreateOperation(file.resourceId)) { - outboxRepository.enqueueDeleteResource(file.resourceId, "file") + outboxRepository.enqueueTrashResource(file.resourceId, "file") } } val deleted = runCatching { diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/DeviceSync.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/DeviceSync.kt index 66205c9..b5876ce 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/DeviceSync.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/DeviceSync.kt @@ -144,7 +144,11 @@ class DeviceSync @Inject constructor( // O(racines×DB) — le SQL filtre par préfixe d'uri (échappé). for (folder in folderRepository.getUnderRoot(rootUri)) { val folderUri = folder.uri + // Lignes trashées (V3) : cycle de vie piloté par la corbeille, pas + // par le walk — jamais de markMissing ni d'annulation de creates + // (l'op trash porte déjà l'intention). if (folder.exists != 0 && folderUri != null && folderUri !in seen && + folder.trashedAt == null && !outboxRepository.hasPendingMoveOperation(folder.resourceId) ) { folderRepository.markMissing(folder.resourceId, now) @@ -164,6 +168,7 @@ class DeviceSync @Inject constructor( // ensuite disparu du disque, c'est une vraie suppression // (sinon fantôme `exists = 1` éternel, M4). if (file.exists != 0 && fileUri != null && fileUri !in seen && + file.trashedAt == null && !outboxRepository.hasPendingMoveOperation(file.resourceId) ) { fileRepository.markMissing(file.resourceId, now) diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/RetentionWorker.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/RetentionWorker.kt index bf97f4d..4a0a928 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/RetentionWorker.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/RetentionWorker.kt @@ -11,6 +11,7 @@ import androidx.work.PeriodicWorkRequestBuilder import androidx.work.WorkManager import androidx.work.WorkerParameters import com.kazier.mobile.data.local.dao.FileDao +import com.kazier.mobile.data.repository.TrashRepository import com.kazier.mobile.domain.RetentionRule import com.kazier.mobile.domain.RetentionStore import com.kazier.mobile.features.saf.FileDeleter @@ -25,6 +26,9 @@ import timber.log.Timber * (gate `isReleasable` : seuls les fichiers dont le serveur a les octets * partent — jamais de perte). Opération purement locale : aucune contrainte * réseau, batterie faible exclue. + * + * V3 corbeille : la même passe expire les tombstones locales + * (`TrashRepository.purgeExpiredLocally`, 31j = serveur 30j + marge). */ @HiltWorker class RetentionWorker @AssistedInject constructor( @@ -33,9 +37,14 @@ class RetentionWorker @AssistedInject constructor( private val retentionStore: RetentionStore, private val fileDeleter: FileDeleter, private val fileDao: FileDao, + private val trashRepository: TrashRepository, ) : CoroutineWorker(appContext, workerParams) { override suspend fun doWork(): Result { + val purged = trashRepository.purgeExpiredLocally( + System.currentTimeMillis() - TrashRepository.LOCAL_RETENTION_MS, + ) + if (purged > 0) Timber.d("retention: tombstones purgées=%d", purged) val rule = retentionStore.current() if (rule is RetentionRule.KeepAll) return Result.success() val months = (rule as RetentionRule.LastMonths).months diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/SyncViewModel.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/SyncViewModel.kt index 71efb84..960a2be 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/SyncViewModel.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/SyncViewModel.kt @@ -11,6 +11,7 @@ import com.kazier.mobile.data.local.entity.PendingOperationEntity import com.kazier.mobile.data.repository.FolderRepository import com.kazier.mobile.data.repository.SaveFolderInput import com.kazier.mobile.data.repository.ShareRepository +import com.kazier.mobile.data.repository.TrashRepository import com.kazier.mobile.features.ocr.OcrAutoWorker import com.kazier.mobile.features.saf.FileDeleter import com.kazier.mobile.features.saf.FolderDeleter @@ -51,6 +52,7 @@ class SyncViewModel @Inject constructor( private val folderRepository: FolderRepository, private val pendingOperationDao: PendingOperationDao, private val shareRepository: ShareRepository, + private val trashRepository: TrashRepository, private val fileDeleter: FileDeleter, private val folderDeleter: FolderDeleter, @ApplicationContext private val appContext: Context, @@ -139,6 +141,13 @@ class SyncViewModel @Inject constructor( if (e is CancellationException) throw e Timber.d("syncSnapshot failed, retrying later: %s", e.message) } + // Convergence corbeille V3 : trash fait ailleurs (2e + // device, autre client) → tombstones locales, sans outbox. + runCatching { trashRepository.syncTrashFromServer() } + .onFailure { e -> + if (e is CancellationException) throw e + Timber.d("syncTrash failed, retrying later: %s", e.message) + } // m2 : ne réveiller WorkManager que si le tick a produit // quelque chose (walk/sweep) ou si l'outbox attend un drain // (op partagée depuis l'UI, drain précédent interrompu…). diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/navigation/NavGraph.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/navigation/NavGraph.kt index 40acd07..92db0c0 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/navigation/NavGraph.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/navigation/NavGraph.kt @@ -29,6 +29,7 @@ import com.kazier.mobile.ui.scan.ScanFlowScreen import com.kazier.mobile.ui.search.SearchScreen import com.kazier.mobile.ui.settings.SettingsScreen import com.kazier.mobile.ui.share.OpenLinkScreen +import com.kazier.mobile.ui.trash.TrashScreen import com.kazier.mobile.ui.watchedfolders.WatchedFoldersScreen object Routes { @@ -38,6 +39,7 @@ object Routes { const val DASHBOARD = "dashboard" const val REVIEW = "review" const val WATCHED_FOLDERS = "watched" + const val TRASH = "trash" const val FOLDER_DETAIL = "folder/{folderResourceId}" const val ARG_FOLDER = "folderResourceId" const val DOCUMENT = "document/{documentResourceId}" @@ -146,6 +148,7 @@ fun NavGraph( selectedTab = selectedTab, onTabSelected = onTabSelected, onOpenWatchedFolders = onOpenWatchedFolders, + onOpenTrash = { navController.navigate(Routes.TRASH) }, authViewModel = authViewModel, connectionStatusViewModel = connectionStatusViewModel, syncViewModel = syncViewModel, @@ -179,6 +182,11 @@ fun NavGraph( syncViewModel = syncViewModel, ) } + composable(Routes.TRASH) { + TrashScreen( + onBack = { navController.popBackStack() }, + ) + } composable( route = Routes.FOLDER_DETAIL, arguments = listOf( diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/settings/SettingsScreen.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/settings/SettingsScreen.kt index dbedc70..b480724 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/settings/SettingsScreen.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/settings/SettingsScreen.kt @@ -17,6 +17,7 @@ import androidx.compose.foundation.verticalScroll import androidx.compose.material.icons.Icons import androidx.compose.material.icons.filled.CloudOff import androidx.compose.material.icons.filled.DarkMode +import androidx.compose.material.icons.filled.Delete import androidx.compose.material.icons.filled.Dns import androidx.compose.material.icons.filled.Folder import androidx.compose.material.icons.filled.Person @@ -69,6 +70,7 @@ fun SettingsScreen( selectedTab: NavTab, onTabSelected: (NavTab) -> Unit, onOpenWatchedFolders: () -> Unit, + onOpenTrash: () -> Unit, authViewModel: AuthViewModel, connectionStatusViewModel: ConnectionStatusViewModel, syncViewModel: SyncViewModel, @@ -153,6 +155,14 @@ fun SettingsScreen( onClick = onOpenWatchedFolders, ) + HorizontalDivider() + SettingsRow( + icon = { Icon(Icons.Filled.Delete, contentDescription = null) }, + title = stringResource(R.string.trash_title), + subtitle = stringResource(R.string.trash_hint), + onClick = onOpenTrash, + ) + HorizontalDivider() SettingsRow( icon = { Icon(Icons.Filled.Dns, contentDescription = null) }, diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/trash/TrashScreen.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/trash/TrashScreen.kt new file mode 100644 index 0000000..7d5c8e5 --- /dev/null +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/trash/TrashScreen.kt @@ -0,0 +1,222 @@ +package com.kazier.mobile.ui.trash + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.automirrored.filled.ArrowBack +import androidx.compose.material.icons.filled.DeleteForever +import androidx.compose.material.icons.filled.Description +import androidx.compose.material.icons.filled.Folder +import androidx.compose.material.icons.filled.RestoreFromTrash +import androidx.compose.material3.AlertDialog +import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.Icon +import androidx.compose.material3.IconButton +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Scaffold +import androidx.compose.material3.SnackbarHost +import androidx.compose.material3.SnackbarHostState +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.material3.TopAppBar +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.saveable.rememberSaveable +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.dp +import androidx.hilt.navigation.compose.hiltViewModel +import androidx.lifecycle.compose.collectAsStateWithLifecycle +import com.kazier.mobile.R +import java.text.DateFormat +import java.util.Date + +/** + * Corbeille V3 : ressources trashées (plus récentes d'abord), restore en un + * tap, purge définitive après confirmation. Destruction auto serveur après + * 30j (rappelée en sous-titre vide) — la purge locale suit (31j). + */ +@OptIn(ExperimentalMaterial3Api::class) +@Composable +fun TrashScreen( + onBack: () -> Unit, + viewModel: TrashViewModel = hiltViewModel(), +) { + val files by viewModel.trashedFiles.collectAsStateWithLifecycle(initialValue = emptyList()) + val folders by viewModel.trashedFolders.collectAsStateWithLifecycle(initialValue = emptyList()) + val busy by viewModel.busy.collectAsStateWithLifecycle() + val error by viewModel.error.collectAsStateWithLifecycle() + + val snackbarHostState = remember { SnackbarHostState() } + LaunchedEffect(error) { + error?.let { + snackbarHostState.showSnackbar(it) + viewModel.clearError() + } + } + + var pendingPurge by rememberSaveable { mutableStateOf?>(null) } + + pendingPurge?.let { (resourceId, isFolder) -> + AlertDialog( + onDismissRequest = { pendingPurge = null }, + title = { Text(stringResource(R.string.trash_purge_confirm_title)) }, + text = { Text(stringResource(R.string.trash_purge_confirm_message)) }, + confirmButton = { + TextButton( + onClick = { + pendingPurge = null + if (isFolder) viewModel.purgeFolder(resourceId) else viewModel.purgeFile(resourceId) + }, + ) { Text(stringResource(R.string.trash_purge_confirm)) } + }, + dismissButton = { + TextButton(onClick = { pendingPurge = null }) { + Text(stringResource(R.string.delete_cancel)) + } + }, + ) + } + + Scaffold( + topBar = { + TopAppBar( + title = { Text(stringResource(R.string.trash_title)) }, + navigationIcon = { + IconButton(onClick = onBack) { + Icon( + Icons.AutoMirrored.Filled.ArrowBack, + contentDescription = stringResource(R.string.back), + ) + } + }, + ) + }, + snackbarHost = { SnackbarHost(hostState = snackbarHostState) }, + ) { padding -> + val rows = remember(folders, files) { + val folderRows = folders.map { TrashRow(it.resourceId, it.name, it.trashedAt, true) } + val fileRows = files.map { TrashRow(it.resourceId, it.name, it.trashedAt, false) } + // Les deux listes sont déjà triées (plus récent d'abord) ; fusion + // par date décroissante (NULL = le plus vieux, jamais en pratique). + (folderRows + fileRows).sortedByDescending { it.trashedAt ?: 0L } + } + if (rows.isEmpty()) { + Column( + modifier = Modifier.fillMaxSize().padding(padding).padding(32.dp), + verticalArrangement = Arrangement.Center, + horizontalAlignment = Alignment.CenterHorizontally, + ) { + Text( + text = stringResource(R.string.trash_empty), + style = MaterialTheme.typography.bodyLarge, + color = MaterialTheme.colorScheme.onSurfaceVariant, + textAlign = TextAlign.Center, + ) + Text( + text = stringResource(R.string.trash_retention_hint), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + textAlign = TextAlign.Center, + modifier = Modifier.padding(top = 8.dp), + ) + } + } else { + LazyColumn( + modifier = Modifier.fillMaxSize().padding(padding), + contentPadding = PaddingValues(horizontal = 16.dp), + ) { + items(rows, key = { it.resourceId }) { row -> + TrashItemRow( + row = row, + actionsEnabled = !busy, + onRestore = { + if (row.isFolder) viewModel.restoreFolder(row.resourceId) + else viewModel.restoreFile(row.resourceId) + }, + onPurge = { pendingPurge = row.resourceId to row.isFolder }, + ) + } + } + } + } +} + +private data class TrashRow( + val resourceId: String, + val name: String, + val trashedAt: Long?, + val isFolder: Boolean, +) + +@Composable +private fun TrashItemRow( + row: TrashRow, + actionsEnabled: Boolean, + onRestore: () -> Unit, + onPurge: () -> Unit, +) { + val dateLabel = remember(row.trashedAt) { + row.trashedAt?.let { + DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT).format(Date(it)) + } + } + Row( + modifier = Modifier.fillMaxWidth().padding(vertical = 12.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(12.dp), + ) { + Icon( + imageVector = if (row.isFolder) Icons.Filled.Folder else Icons.Filled.Description, + contentDescription = null, + tint = MaterialTheme.colorScheme.primary, + modifier = Modifier.size(28.dp), + ) + Column(modifier = Modifier.weight(1f)) { + Text( + text = row.name, + style = MaterialTheme.typography.bodyLarge, + fontWeight = FontWeight.Medium, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + dateLabel?.let { + Text( + text = it, + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + maxLines = 1, + ) + } + } + IconButton(onClick = onRestore, enabled = actionsEnabled) { + Icon( + imageVector = Icons.Filled.RestoreFromTrash, + contentDescription = stringResource(R.string.trash_restore), + ) + } + IconButton(onClick = onPurge, enabled = actionsEnabled) { + Icon( + imageVector = Icons.Filled.DeleteForever, + contentDescription = stringResource(R.string.trash_purge), + tint = MaterialTheme.colorScheme.error, + ) + } + } +} diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/trash/TrashViewModel.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/trash/TrashViewModel.kt new file mode 100644 index 0000000..d967011 --- /dev/null +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/trash/TrashViewModel.kt @@ -0,0 +1,63 @@ +package com.kazier.mobile.ui.trash + +import androidx.lifecycle.ViewModel +import androidx.lifecycle.viewModelScope +import com.kazier.mobile.data.local.entity.FileEntity +import com.kazier.mobile.data.local.entity.FolderEntity +import com.kazier.mobile.data.repository.TrashRepository +import dagger.hilt.android.lifecycle.HiltViewModel +import javax.inject.Inject +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.launch + +/** + * Écran Corbeille V3 : lignes trashées (fichiers + dossiers), restore et + * purge définitive. Les actions passent par [TrashRepository] (transaction + * Room + outbox) ; toute erreur remonte en snackbar via [error]. + */ +@HiltViewModel +class TrashViewModel @Inject constructor( + private val trashRepository: TrashRepository, +) : ViewModel() { + + val trashedFiles: Flow> = trashRepository.observeTrashedFiles() + + val trashedFolders: Flow> = trashRepository.observeTrashedFolders() + + val trashedCount: Flow = trashRepository.observeTrashedCount() + + private val _busy = MutableStateFlow(false) + val busy: StateFlow = _busy.asStateFlow() + + private val _error = MutableStateFlow(null) + val error: StateFlow = _error.asStateFlow() + + fun clearError() { + _error.value = null + } + + fun restoreFile(resourceId: String) = runGuarded { trashRepository.restoreFile(resourceId) } + + fun restoreFolder(resourceId: String) = runGuarded { trashRepository.restoreFolder(resourceId) } + + fun purgeFile(resourceId: String) = runGuarded { trashRepository.purgeFile(resourceId) } + + fun purgeFolder(resourceId: String) = runGuarded { trashRepository.purgeFolder(resourceId) } + + private fun runGuarded(block: suspend () -> Unit) { + if (_busy.value) return + viewModelScope.launch { + _busy.value = true + try { + block() + } catch (e: Exception) { + _error.value = e.message ?: e.javaClass.simpleName + } finally { + _busy.value = false + } + } + } +} diff --git a/mobile-kotlin/app/src/main/res/values-en/strings.xml b/mobile-kotlin/app/src/main/res/values-en/strings.xml index 91db43f..d25e389 100644 --- a/mobile-kotlin/app/src/main/res/values-en/strings.xml +++ b/mobile-kotlin/app/src/main/res/values-en/strings.xml @@ -303,7 +303,7 @@ Delete from cloud Delete everywhere Delete %1$d document(s)? - This action cannot be undone. + Items go to trash (restorable for 30 days). Documents not synced %1$d out of %2$d document(s) are not synced to the cloud and will not be deleted from the server. %1$d out of %2$d document(s) have no local copy and will not be deleted from this device. @@ -382,4 +382,14 @@ Share this folder Share More actions + + Trash + Deleted items, restorable for 30 days + Trash is empty + Deleted items are destroyed automatically after 30 days. + Restore + Delete forever + Delete forever? + This action cannot be undone. The item will be destroyed everywhere. + Delete \ No newline at end of file diff --git a/mobile-kotlin/app/src/main/res/values/strings.xml b/mobile-kotlin/app/src/main/res/values/strings.xml index 01d1a2d..57b7404 100644 --- a/mobile-kotlin/app/src/main/res/values/strings.xml +++ b/mobile-kotlin/app/src/main/res/values/strings.xml @@ -304,7 +304,7 @@ Supprimer dans le cloud Supprimer partout Supprimer %1$d document(s) ? - Cette action est irréversible. + Les éléments partent en corbeille (restaurables 30 jours). Documents non synchronisés %1$d document(s) sur %2$d n\'est/sont pas synchronisés avec le cloud et ne seront pas supprimés du serveur. %1$d document(s) sur %2$d n\'ont pas de copie locale et ne seront pas supprimés de cet appareil. @@ -383,4 +383,14 @@ Partager ce dossier Partager Plus d\'actions + + Corbeille + Éléments supprimés, restaurables 30 jours + Corbeille vide + Les éléments supprimés sont détruits automatiquement après 30 jours. + Restaurer + Supprimer définitivement + Supprimer définitivement ? + Cette action est irréversible. L\'élément sera détruit partout. + Supprimer \ No newline at end of file diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/dao/TrashCorbeilleTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/dao/TrashCorbeilleTest.kt new file mode 100644 index 0000000..9457a6e --- /dev/null +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/dao/TrashCorbeilleTest.kt @@ -0,0 +1,187 @@ +package com.kazier.mobile.data.local.dao + +import android.content.Context +import androidx.room.Room +import androidx.test.core.app.ApplicationProvider +import com.squareup.moshi.Moshi +import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory +import com.kazier.mobile.data.local.AppDatabase +import com.kazier.mobile.data.local.entity.FileEntity +import com.kazier.mobile.data.local.entity.FolderEntity +import com.kazier.mobile.data.local.entity.PendingOperationType +import com.kazier.mobile.data.remote.ApiClient +import com.kazier.mobile.data.remote.ApiService +import com.kazier.mobile.data.repository.FileRepository +import com.kazier.mobile.data.repository.OutboxRepository +import com.kazier.mobile.data.repository.SaveFileInput +import com.kazier.mobile.domain.DeviceIdentity +import com.kazier.mobile.domain.GenerateId +import kotlinx.coroutines.flow.first +import kotlinx.coroutines.test.runTest +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config +import retrofit2.Retrofit +import retrofit2.converter.moshi.MoshiConverterFactory + +/** + * Corbeille V3 côté Room : tombstone (`trashed_at` + `exists = 0`), jamais + * de DELETE — visibilité, anti-résurrection du walk, purge locale, outbox. + */ +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [34]) +class TrashCorbeilleTest { + + private lateinit var db: AppDatabase + private lateinit var fileDao: FileDao + private lateinit var folderDao: FolderDao + private lateinit var opsDao: PendingOperationDao + private lateinit var fileRepository: FileRepository + private lateinit var outboxRepository: OutboxRepository + + @Before + fun setUp() { + val context = ApplicationProvider.getApplicationContext() + db = Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java) + .allowMainThreadQueries() + .build() + fileDao = db.fileDao() + folderDao = db.folderDao() + opsDao = db.pendingOperationDao() + + val moshi = Moshi.Builder().add(KotlinJsonAdapterFactory()).build() + val apiService = Retrofit.Builder() + .baseUrl("http://localhost:1/") + .addConverterFactory(MoshiConverterFactory.create(moshi)) + .build() + .create(ApiService::class.java) + val generateId = GenerateId() + outboxRepository = OutboxRepository(opsDao, generateId, DeviceIdentity(db.userPreferenceDao(), generateId), moshi) + fileRepository = FileRepository(fileDao, folderDao, ApiClient(apiService, moshi), generateId, db, outboxRepository) + + runTest { + folderDao.upsert( + FolderEntity( + resourceId = FOLDER, uri = null, name = FOLDER, exists = 1, + parentResourceId = null, syncStatus = "local", + addedAt = NOW, updatedAt = NOW, + ), + ) + folderDao.upsert( + FolderEntity( + resourceId = FOLDER_CHILD, uri = null, name = "Enfant", exists = 1, + parentResourceId = FOLDER, syncStatus = "local", + addedAt = NOW, updatedAt = NOW, + ), + ) + fileDao.upsert( + FileEntity( + resourceId = RESOURCE_ID, uri = FILE_URI, name = "doc.txt", + folderResourceId = FOLDER, size = 10, exists = 1, + processed = true, addedAt = NOW, updatedAt = NOW, + ), + ) + } + } + + @After + fun tearDown() { + db.close() + } + + @Test + fun trash_masque_et_restorable() = runTest { + fileDao.markTrashed(RESOURCE_ID, NOW) + + assertTrue(fileDao.observeByFolder(FOLDER).first().isEmpty()) + assertTrue(fileDao.getByFolderOnce(FOLDER).isEmpty()) + val trashed = fileDao.observeTrashed().first() + assertEquals(1, trashed.size) + assertEquals(RESOURCE_ID, trashed[0].resourceId) + + fileDao.clearTrashed(RESOURCE_ID, NOW + 1) + assertEquals(1, fileDao.getByFolderOnce(FOLDER).size) + assertTrue(fileDao.observeTrashed().first().isEmpty()) + } + + @Test + fun walk_ne_ressuscite_jamais_une_ligne_trashee() = runTest { + fileDao.markTrashed(RESOURCE_ID, NOW) + + // Le walk revoit le fichier SAF (IN_CLOUD garde le physique) : refusé. + val kept = fileRepository.saveLocalFile( + SaveFileInput(uri = FILE_URI, name = "doc.txt", size = 10), + folderResourceId = FOLDER, + ) + assertEquals(0, kept.exists) + assertEquals(NOW, kept.trashedAt) + assertTrue(fileDao.getByFolderOnce(FOLDER).isEmpty()) + } + + @Test + fun op_trash_pending_bloque_la_reimport() = runTest { + // Ordre journal-first : trash pending AVANT disparition SAF. + outboxRepository.enqueueTrashResource(RESOURCE_ID, "file") + assertTrue(outboxRepository.hasPendingDeleteOperation(RESOURCE_ID)) + assertEquals(1, opsDao.countPendingDeleteOperations(RESOURCE_ID)) + } + + @Test + fun ops_trash_restore_purge_enqueued_avec_bons_noms() = runTest { + outboxRepository.enqueueTrashResource("r1", "file") + outboxRepository.enqueueRestoreResource("r1", "file") + outboxRepository.enqueuePurgeResource("r1", "file") + val ops = opsDao.selectPending(10).map { it.operation } + assertEquals( + listOf( + PendingOperationType.TRASH_RESOURCE, + PendingOperationType.RESTORE_RESOURCE, + PendingOperationType.PURGE_RESOURCE, + ), + ops, + ) + } + + @Test + fun purge_locale_expire_les_vieilles_tombstones() = runTest { + val old = NOW - 32L * 24 * 60 * 60 * 1000 + fileDao.markTrashed(RESOURCE_ID, old) + + val deleted = fileDao.deleteTrashedOlderThan(NOW - 31L * 24 * 60 * 60 * 1000) + assertEquals(1, deleted) + assertNull(fileDao.getByResourceId(RESOURCE_ID)) + } + + @Test + fun purge_locale_garde_les_tombstones_recentes() = runTest { + fileDao.markTrashed(RESOURCE_ID, NOW) + + val deleted = fileDao.deleteTrashedOlderThan(NOW - 31L * 24 * 60 * 60 * 1000) + assertEquals(0, deleted) + assertEquals(1, fileDao.getTrashedOnce().size) + } + + @Test + fun dossier_trash_masque_des_requetes_parent() = runTest { + folderDao.markTrashed(FOLDER_CHILD, NOW) + assertTrue(folderDao.observeByParent(FOLDER).first().none { it.resourceId == FOLDER_CHILD }) + assertEquals(1, folderDao.observeTrashed().first().size) + + folderDao.clearTrashed(FOLDER_CHILD, NOW + 1) + assertTrue(folderDao.observeByParent(FOLDER).first().any { it.resourceId == FOLDER_CHILD }) + } + + companion object { + private const val FOLDER = "folder-trash" + private const val FOLDER_CHILD = "folder-trash-child" + private const val RESOURCE_ID = "file-trash-1" + private const val FILE_URI = "content://trash/doc.txt" + private const val NOW = 1_700_000_000_000L + } +} diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/migration/Migration18To19Test.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/migration/Migration18To19Test.kt new file mode 100644 index 0000000..dfcdeab --- /dev/null +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/migration/Migration18To19Test.kt @@ -0,0 +1,95 @@ +package com.kazier.mobile.data.local.migration + +import android.content.Context +import androidx.sqlite.db.SupportSQLiteDatabase +import androidx.sqlite.db.SupportSQLiteOpenHelper +import androidx.sqlite.db.framework.FrameworkSQLiteOpenHelperFactory +import androidx.test.core.app.ApplicationProvider +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +/** + * V3 corbeille : la migration 18→19 ajoute `trashed_at` (ms epoch, NULL = + * vivant) sur `files` et `folders`. Zéro backfill : NULL = état courant, le + * masquage passe par `exists = 0` posé par l'action de trash. + */ +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [34]) +class Migration18To19Test { + + @Test + fun migration_ajoute_trashed_at_null_par_defaut() { + val context = ApplicationProvider.getApplicationContext() + val helper = FrameworkSQLiteOpenHelperFactory().create( + SupportSQLiteOpenHelper.Configuration.builder(context) + .name(null) + .callback(V18Callback()) + .build(), + ) + val db = helper.writableDatabase + db.execSQL( + "INSERT INTO `files` (`resource_id`, `name`, `folder_resource_id`, `size`, `added_at`, `updated_at`) " + + "VALUES ('d-old', 'vieux.txt', 'f-one', 10, 1, 1)", + ) + db.execSQL( + "INSERT INTO `folders` (`resource_id`, `name`, `added_at`, `updated_at`) " + + "VALUES ('f-one', 'Docs', 1, 1)", + ) + + val migration = Migrations.ALL.first { it.startVersion == 18 && it.endVersion == 19 } + migration.migrate(db) + + for (table in listOf("files", "folders")) { + val columns = mutableListOf() + db.query("PRAGMA table_info(`$table`)").use { cursor -> + val nameIdx = cursor.getColumnIndexOrThrow("name") + while (cursor.moveToNext()) columns += cursor.getString(nameIdx) + } + assertTrue("colonne trashed_at manquante sur $table", columns.contains("trashed_at")) + } + + db.query("SELECT `trashed_at` FROM `files` WHERE `resource_id` = 'd-old'").use { cursor -> + assertTrue(cursor.moveToFirst()) + assertTrue(cursor.isNull(0)) + } + db.query("SELECT `trashed_at` FROM `folders` WHERE `resource_id` = 'f-one'").use { cursor -> + assertTrue(cursor.moveToFirst()) + assertTrue(cursor.isNull(0)) + } + helper.close() + } + + /** Schéma v18 minimal (sans `trashed_at`). */ + private class V18Callback : SupportSQLiteOpenHelper.Callback(18) { + override fun onCreate(db: SupportSQLiteDatabase) { + db.execSQL( + "CREATE TABLE `files` (" + + "`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, " + + "`resource_id` TEXT NOT NULL, " + + "`uri` TEXT, " + + "`name` TEXT NOT NULL, " + + "`folder_resource_id` TEXT NOT NULL, " + + "`size` INTEGER NOT NULL, " + + "`added_at` INTEGER NOT NULL, " + + "`updated_at` INTEGER NOT NULL)", + ) + db.execSQL( + "CREATE TABLE `folders` (" + + "`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, " + + "`resource_id` TEXT NOT NULL, " + + "`name` TEXT NOT NULL, " + + "`added_at` INTEGER NOT NULL, " + + "`updated_at` INTEGER NOT NULL)", + ) + } + + override fun onUpgrade( + db: SupportSQLiteDatabase, + oldVersion: Int, + newVersion: Int, + ) = Unit + } +} diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/Auth401Test.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/Auth401Test.kt index 1b06bb7..ebc2d70 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/Auth401Test.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/Auth401Test.kt @@ -312,6 +312,26 @@ class Auth401Test { fileId: String, ): Response> = Response.success(ApiEnvelope()) + override suspend fun listTrash( + page: Int?, + pageSize: Int?, + ): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun restoreFile( + fileId: String, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listVersions( + fileId: String, + ): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun restoreVersion( + fileId: String, + versionNo: Int, + ): Response> = Response.success(ApiEnvelope()) + override suspend fun searchFiles( query: String, page: Int?, diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/PaginationTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/PaginationTest.kt index 0b07f0e..fabfd8f 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/PaginationTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/PaginationTest.kt @@ -186,6 +186,26 @@ class PaginationTest { fileId: String, ): Response> = Response.success(ApiEnvelope()) + override suspend fun listTrash( + page: Int?, + pageSize: Int?, + ): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun restoreFile( + fileId: String, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listVersions( + fileId: String, + ): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun restoreVersion( + fileId: String, + versionNo: Int, + ): Response> = Response.success(ApiEnvelope()) + override suspend fun searchFiles( query: String, page: Int?, diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/RemoteContentTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/RemoteContentTest.kt index d0a2f30..bbd789c 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/RemoteContentTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/RemoteContentTest.kt @@ -132,6 +132,18 @@ class RemoteContentTest { override suspend fun deleteFile(fileId: String): Response> = Response.success(ApiEnvelope()) + override suspend fun listTrash(page: Int?, pageSize: Int?): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun restoreFile(fileId: String): Response> = + Response.success(ApiEnvelope()) + + override suspend fun listVersions(fileId: String): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun restoreVersion(fileId: String, versionNo: Int): Response> = + Response.success(ApiEnvelope()) + override suspend fun searchFiles(query: String, page: Int?, pageSize: Int?): Response>> = Response.success(ApiEnvelope(data = emptyList())) diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/SessionReloginTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/SessionReloginTest.kt index 028edf8..d3998bd 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/SessionReloginTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/SessionReloginTest.kt @@ -338,6 +338,18 @@ class SessionReloginTest { override suspend fun deleteFile(fileId: String): Response> = Response.success(ApiEnvelope()) + override suspend fun listTrash(page: Int?, pageSize: Int?): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun restoreFile(fileId: String): Response> = + Response.success(ApiEnvelope()) + + override suspend fun listVersions(fileId: String): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun restoreVersion(fileId: String, versionNo: Int): Response> = + Response.success(ApiEnvelope()) + override suspend fun searchFiles(query: String, page: Int?, pageSize: Int?): Response>> = Response.success(ApiEnvelope(data = emptyList())) diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/ShareManagementTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/ShareManagementTest.kt index 87c2760..e216311 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/ShareManagementTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/ShareManagementTest.kt @@ -171,6 +171,18 @@ class ShareManagementTest { override suspend fun deleteFile(fileId: String): Response> = Response.success(ApiEnvelope()) + override suspend fun listTrash(page: Int?, pageSize: Int?): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun restoreFile(fileId: String): Response> = + Response.success(ApiEnvelope()) + + override suspend fun listVersions(fileId: String): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun restoreVersion(fileId: String, versionNo: Int): Response> = + Response.success(ApiEnvelope()) + override suspend fun searchFiles(query: String, page: Int?, pageSize: Int?): Response>> = Response.success(ApiEnvelope(data = emptyList())) diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/BytesUploadTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/BytesUploadTest.kt index 78cdc6c..02db867 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/BytesUploadTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/BytesUploadTest.kt @@ -265,6 +265,18 @@ class BytesUploadTest { override suspend fun deleteFile(fileId: String): Response> = Response.success(ApiEnvelope()) + override suspend fun listTrash(page: Int?, pageSize: Int?): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun restoreFile(fileId: String): Response> = + Response.success(ApiEnvelope()) + + override suspend fun listVersions(fileId: String): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun restoreVersion(fileId: String, versionNo: Int): Response> = + Response.success(ApiEnvelope()) + override suspend fun searchFiles(query: String, page: Int?, pageSize: Int?): Response>> = Response.success(ApiEnvelope(data = emptyList())) diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/FolderMergeDataTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/FolderMergeDataTest.kt index e3b0986..b600797 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/FolderMergeDataTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/FolderMergeDataTest.kt @@ -372,6 +372,26 @@ private class FolderMergeApiService : ApiService { fileId: String, ): Response> = Response.success(ApiEnvelope()) + override suspend fun listTrash( + page: Int?, + pageSize: Int?, + ): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun restoreFile( + fileId: String, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listVersions( + fileId: String, + ): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun restoreVersion( + fileId: String, + versionNo: Int, + ): Response> = Response.success(ApiEnvelope()) + override suspend fun searchFiles( query: String, page: Int?, diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/MoveProtectionTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/MoveProtectionTest.kt index d83ca68..0e70bda 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/MoveProtectionTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/MoveProtectionTest.kt @@ -461,6 +461,26 @@ private class MoveProtectionApiService : ApiService { fileId: String, ): Response> = Response.success(ApiEnvelope()) + override suspend fun listTrash( + page: Int?, + pageSize: Int?, + ): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun restoreFile( + fileId: String, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listVersions( + fileId: String, + ): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun restoreVersion( + fileId: String, + versionNo: Int, + ): Response> = Response.success(ApiEnvelope()) + override suspend fun searchFiles( query: String, page: Int?, diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/OcrRepositoryTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/OcrRepositoryTest.kt index ead2e9f..ebb67c8 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/OcrRepositoryTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/OcrRepositoryTest.kt @@ -373,6 +373,26 @@ private class OcrApiServiceFake : ApiService { fileId: String, ): Response> = Response.success(ApiEnvelope()) + override suspend fun listTrash( + page: Int?, + pageSize: Int?, + ): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun restoreFile( + fileId: String, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listVersions( + fileId: String, + ): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun restoreVersion( + fileId: String, + versionNo: Int, + ): Response> = Response.success(ApiEnvelope()) + override suspend fun searchFiles( query: String, page: Int?, diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/OfflineDownloadTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/OfflineDownloadTest.kt index c5b0c6e..60757b7 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/OfflineDownloadTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/OfflineDownloadTest.kt @@ -273,6 +273,18 @@ class OfflineDownloadTest { override suspend fun deleteFile(fileId: String): Response> = Response.success(ApiEnvelope()) + override suspend fun listTrash(page: Int?, pageSize: Int?): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun restoreFile(fileId: String): Response> = + Response.success(ApiEnvelope()) + + override suspend fun listVersions(fileId: String): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun restoreVersion(fileId: String, versionNo: Int): Response> = + Response.success(ApiEnvelope()) + override suspend fun searchFiles(query: String, page: Int?, pageSize: Int?): Response>> = Response.success(ApiEnvelope(data = emptyList())) diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/RefreshVsMoveTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/RefreshVsMoveTest.kt index f400c13..35f1da3 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/RefreshVsMoveTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/RefreshVsMoveTest.kt @@ -228,6 +228,26 @@ private class RefreshVsMoveApiService : ApiService { fileId: String, ): Response> = Response.success(ApiEnvelope()) + override suspend fun listTrash( + page: Int?, + pageSize: Int?, + ): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun restoreFile( + fileId: String, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listVersions( + fileId: String, + ): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun restoreVersion( + fileId: String, + versionNo: Int, + ): Response> = Response.success(ApiEnvelope()) + override suspend fun searchFiles( query: String, page: Int?, diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/ShareRepositoryTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/ShareRepositoryTest.kt index 9f9d733..c300d0a 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/ShareRepositoryTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/ShareRepositoryTest.kt @@ -482,6 +482,26 @@ private class FakeApiService : ApiService { fileId: String, ): Response> = Response.success(ApiEnvelope()) + override suspend fun listTrash( + page: Int?, + pageSize: Int?, + ): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun restoreFile( + fileId: String, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listVersions( + fileId: String, + ): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun restoreVersion( + fileId: String, + versionNo: Int, + ): Response> = Response.success(ApiEnvelope()) + override suspend fun searchFiles( query: String, page: Int?, diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/features/saf/DeleteInCloudTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/features/saf/DeleteInCloudTest.kt index c485176..89be24c 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/features/saf/DeleteInCloudTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/features/saf/DeleteInCloudTest.kt @@ -32,12 +32,13 @@ import retrofit2.Retrofit import retrofit2.converter.moshi.MoshiConverterFactory /** - * M5 : `deleteInCloud` journalise `delete_resource` ET pose la tombstone - * locale (`exists = 0`) dans la même transaction — sans ça la ressource - * restait affichée et le walk la revoyait (fantôme local vs serveur supprimé). - * - fichier déjà poussé (create synced) → `delete_resource` + `exists = 0` ; - * - fichier jamais poussé → pas de `delete_resource`, mais `exists = 0` ; - * - dossier poussé → dossier + descendance en `exists = 0`, deletes journalisés. + * M5 (V3 corbeille) : `deleteInCloud` journalise `trash_resource` ET pose la + * tombstone locale (`trashed_at` + `exists = 0`) dans la même transaction — + * sans ça la ressource restait affichée et le walk la revoyait (fantôme + * local vs serveur trashé). + * - fichier déjà poussé (create synced) → `trash_resource` + tombstone ; + * - fichier jamais poussé → pas de `trash_resource`, mais tombstone ; + * - dossier poussé → dossier + descendance trashés, trashes journalisés. */ @RunWith(RobolectricTestRunner::class) @Config(sdk = [34]) @@ -99,9 +100,11 @@ class DeleteInCloudTest { ) assertEquals(1, report.succeeded) - assertEquals(0, db.fileDao().getByResourceId(FILE_ID)!!.exists) + val row = db.fileDao().getByResourceId(FILE_ID)!! + assertEquals(0, row.exists) + assertTrue("tombstone trashée", row.trashedAt != null) val deletes = opsDao.selectPending(100).filter { - it.resourceId == FILE_ID && it.operation == PendingOperationType.DELETE_RESOURCE + it.resourceId == FILE_ID && it.operation == PendingOperationType.TRASH_RESOURCE } assertEquals(1, deletes.size) } @@ -122,9 +125,9 @@ class DeleteInCloudTest { assertEquals(1, report.succeeded) assertEquals(0, db.fileDao().getByResourceId(FILE_ID)!!.exists) val deletes = opsDao.selectPending(100).filter { - it.resourceId == FILE_ID && it.operation == PendingOperationType.DELETE_RESOURCE + it.resourceId == FILE_ID && it.operation == PendingOperationType.TRASH_RESOURCE } - assertTrue("jamais poussé : aucun delete_resource", deletes.isEmpty()) + assertTrue("jamais poussé : aucun trash_resource", deletes.isEmpty()) } @Test @@ -146,7 +149,7 @@ class DeleteInCloudTest { assertEquals(0, db.folderDao().getByResourceId(folder.resourceId)!!.exists) assertEquals(0, db.fileDao().getByResourceId(FILE_ID)!!.exists) val deletes = opsDao.selectPending(100).filter { - it.operation == PendingOperationType.DELETE_RESOURCE + it.operation == PendingOperationType.TRASH_RESOURCE }.map { it.resourceId }.toSet() assertTrue(deletes.contains(folder.resourceId)) assertTrue(deletes.contains(FILE_ID)) diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/features/saf/ReleaseLocalCopyTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/features/saf/ReleaseLocalCopyTest.kt index 21b88cc..72b7365 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/features/saf/ReleaseLocalCopyTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/features/saf/ReleaseLocalCopyTest.kt @@ -155,6 +155,10 @@ class ReleaseLocalCopyTest { override suspend fun getFileOcr(fileId: String): retrofit2.Response> = TODO() override suspend fun getFile(fileId: String): retrofit2.Response> = TODO() override suspend fun deleteFile(fileId: String): retrofit2.Response> = TODO() + override suspend fun listTrash(page: Int?, pageSize: Int?): retrofit2.Response>> = TODO() + override suspend fun restoreFile(fileId: String): retrofit2.Response> = TODO() + override suspend fun listVersions(fileId: String): retrofit2.Response>> = TODO() + override suspend fun restoreVersion(fileId: String, versionNo: Int): retrofit2.Response> = TODO() override suspend fun searchFiles(query: String, page: Int?, pageSize: Int?): retrofit2.Response>> = TODO() override suspend fun changePassword(body: com.kazier.mobile.data.remote.dto.ChangePasswordDto): retrofit2.Response> = TODO() override suspend fun getShareLink(token: String): retrofit2.Response> = TODO() diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/features/sync/OutboxSyncWorkerTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/features/sync/OutboxSyncWorkerTest.kt index 6334ff6..53fe6c9 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/features/sync/OutboxSyncWorkerTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/features/sync/OutboxSyncWorkerTest.kt @@ -495,6 +495,18 @@ class OutboxSyncWorkerTest { override suspend fun deleteFile(fileId: String): Response> = throw UnsupportedOperationException() + override suspend fun listTrash(page: Int?, pageSize: Int?): Response>> = + throw UnsupportedOperationException() + + override suspend fun restoreFile(fileId: String): Response> = + throw UnsupportedOperationException() + + override suspend fun listVersions(fileId: String): Response>> = + throw UnsupportedOperationException() + + override suspend fun restoreVersion(fileId: String, versionNo: Int): Response> = + throw UnsupportedOperationException() + override suspend fun searchFiles( query: String, page: Int?,