V3 S1-S2 : corbeille + versions + extract générique

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).
This commit is contained in:
venture
2026-09-26 10:14:07 +02:00
parent a34220bf2d
commit 95b4cf79cf
75 changed files with 5220 additions and 119 deletions
+8
View File
@@ -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é
+122
View File
@@ -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/<user>/<resource>.<ext>`, 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).
+51
View File
@@ -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(),
+5
View File
@@ -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",
@@ -0,0 +1 @@
DROP INDEX IF EXISTS idx_resources_trashed_active;
@@ -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;
@@ -0,0 +1 @@
DROP TABLE IF EXISTS resource_versions;
@@ -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);
@@ -0,0 +1 @@
DROP TABLE IF EXISTS resource_facts;
+23
View File
@@ -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);
+53
View File
@@ -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)
}
+408
View File
@@ -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()
}
+183
View File
@@ -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)
}
}
}
+83
View File
@@ -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")
}
+127 -2
View File
@@ -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")
+5
View File
@@ -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)
+160
View File
@@ -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")
}
+153
View File
@@ -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
}
+5 -6
View File
@@ -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.
+191
View File
@@ -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
}
+131
View File
@@ -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
}
+108
View File
@@ -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
}
+196
View File
@@ -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)
}
}
+25 -1
View File
@@ -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/<user_id>/<resource_id>.<ext> — 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
+38 -5
View File
@@ -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 {
+17 -5
View File
@@ -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 `<id>.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!" {
+61 -7
View File
@@ -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)
+420
View File
@@ -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/<user>/<resource>.* + 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 `<id>.*` 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
}
+364
View File
@@ -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")
}
}
+11 -3
View File
@@ -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&#124;due_date&#124;period&#124;amount&#124;issuer&#124;reference&#124;doc_type, valueText?, valueNum?, valueDate? (ISO), confidence (0..1), origin: auto&#124;user }`, `[]` si rien d'extractible) | `NOT_FOUND` (trashé/absent/étranger) |
| GET | `/files/:id/shares` | — (owner uniquement) | `ShareGrant[]` (`{ granteeUserId, granteeKind: "user"&#124;"group", username, access, inherit, expiresAt (ms&#124;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"&#124;"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`).
@@ -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')"
]
}
}
@@ -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,
@@ -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<List<FileEntity>>
@Query("SELECT * FROM files WHERE trashed_at IS NOT NULL ORDER BY trashed_at DESC")
suspend fun getTrashedOnce(): List<FileEntity>
@Query("SELECT COUNT(*) FROM files WHERE trashed_at IS NOT NULL")
fun observeTrashedCount(): Flow<Int>
/** 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<FileEntity>
/** 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.
@@ -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<List<FolderEntity>>
@Query("SELECT * FROM folders WHERE trashed_at IS NOT NULL ORDER BY trashed_at DESC")
suspend fun getTrashedOnce(): List<FolderEntity>
/** 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<FolderEntity>
/** 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<String>, newParentId: String, updatedAt: Long)
@@ -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
@@ -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")
@@ -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")
@@ -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"
}
@@ -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<Migration> = 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,
)
}
@@ -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<List<TrashDto>, 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<VersionDto> =
unwrap({ apiService.listVersions(fileId) })
/** Recherche serveur paginée — `GET /files/search?q=…` (+ `meta`). */
suspend fun searchFilesPaged(
query: String,
@@ -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<ApiEnvelope<IdResultDto>>
/**
* 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<ApiEnvelope<List<TrashDto>>>
/** Restaure une ressource trashée — `POST /files/:id/restore`. */
@POST("files/{id}/restore")
suspend fun restoreFile(
@Path("id") fileId: String,
): Response<ApiEnvelope<IdResultDto>>
/** Historique des octets — `GET /files/:id/versions` (parent live). */
@GET("files/{id}/versions")
suspend fun listVersions(
@Path("id") fileId: String,
): Response<ApiEnvelope<List<VersionDto>>>
/** 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<ApiEnvelope<FileDto>>
/**
* Recherche serveur (`GET /files/search?q=…`, paginé `meta`). Non consommée
* en V1 (recherche 100 % locale via Room) — exposée pour parité contrat.
@@ -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,
)
@@ -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<List<FileEntity>> = fileDao.observeTrashed()
fun observeTrashedCount(): Flow<Int> = fileDao.observeTrashedCount()
/** Fichiers d'un dossier sans filtre `exists` — collecte trash/restore. */
suspend fun getFilesInFolderAll(folderResourceId: String): List<FileEntity> =
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
@@ -56,6 +56,21 @@ class FolderRepository @Inject constructor(
suspend fun getChildren(parentResourceId: String): List<FolderEntity> =
folderDao.getByParentOnce(parentResourceId)
/** Enfants sans filtre `exists` — collecte trash/restore (FolderDeleter). */
suspend fun getChildrenAll(parentResourceId: String): List<FolderEntity> =
folderDao.getChildrenAll(parentResourceId)
/** Lignes trashées (écran Corbeille). */
fun observeTrashed(): Flow<List<FolderEntity>> = 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<FolderEntity> = 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)
@@ -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
@@ -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<List<FileEntity>> = fileRepository.observeTrashed()
fun observeTrashedFolders(): Flow<List<FolderEntity>> = folderRepository.observeTrashed()
fun observeTrashedCount(): Flow<Int> = 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<String>()
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<String>, folders: MutableList<String>) {
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
}
}
@@ -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++
}
}
@@ -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<FolderEntity>()
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
@@ -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 {
@@ -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)
@@ -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
@@ -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…).
@@ -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(
@@ -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) },
@@ -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<Pair<String, Boolean>?>(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,
)
}
}
}
@@ -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<List<FileEntity>> = trashRepository.observeTrashedFiles()
val trashedFolders: Flow<List<FolderEntity>> = trashRepository.observeTrashedFolders()
val trashedCount: Flow<Int> = trashRepository.observeTrashedCount()
private val _busy = MutableStateFlow(false)
val busy: StateFlow<Boolean> = _busy.asStateFlow()
private val _error = MutableStateFlow<String?>(null)
val error: StateFlow<String?> = _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
}
}
}
}
@@ -303,7 +303,7 @@
<string name="delete_in_cloud">Delete from cloud</string>
<string name="delete_full">Delete everywhere</string>
<string name="delete_confirm_title">Delete %1$d document(s)?</string>
<string name="delete_confirm_message">This action cannot be undone.</string>
<string name="delete_confirm_message">Items go to trash (restorable for 30 days).</string>
<string name="delete_warning_title">Documents not synced</string>
<string name="delete_warning_local_only_msg">%1$d out of %2$d document(s) are not synced to the cloud and will not be deleted from the server.</string>
<string name="delete_warning_cloud_only_msg">%1$d out of %2$d document(s) have no local copy and will not be deleted from this device.</string>
@@ -382,4 +382,14 @@
<string name="share_content_description">Share this folder</string>
<string name="share_action">Share</string>
<string name="more_actions">More actions</string>
<!-- Trash V3 -->
<string name="trash_title">Trash</string>
<string name="trash_hint">Deleted items, restorable for 30 days</string>
<string name="trash_empty">Trash is empty</string>
<string name="trash_retention_hint">Deleted items are destroyed automatically after 30 days.</string>
<string name="trash_restore">Restore</string>
<string name="trash_purge">Delete forever</string>
<string name="trash_purge_confirm_title">Delete forever?</string>
<string name="trash_purge_confirm_message">This action cannot be undone. The item will be destroyed everywhere.</string>
<string name="trash_purge_confirm">Delete</string>
</resources>
@@ -304,7 +304,7 @@
<string name="delete_in_cloud">Supprimer dans le cloud</string>
<string name="delete_full">Supprimer partout</string>
<string name="delete_confirm_title">Supprimer %1$d document(s) ?</string>
<string name="delete_confirm_message">Cette action est irréversible.</string>
<string name="delete_confirm_message">Les éléments partent en corbeille (restaurables 30 jours).</string>
<string name="delete_warning_title">Documents non synchronisés</string>
<string name="delete_warning_local_only_msg">%1$d document(s) sur %2$d n\'est/sont pas synchronisés avec le cloud et ne seront pas supprimés du serveur.</string>
<string name="delete_warning_cloud_only_msg">%1$d document(s) sur %2$d n\'ont pas de copie locale et ne seront pas supprimés de cet appareil.</string>
@@ -383,4 +383,14 @@
<string name="share_content_description">Partager ce dossier</string>
<string name="share_action">Partager</string>
<string name="more_actions">Plus d\'actions</string>
<!-- Corbeille V3 -->
<string name="trash_title">Corbeille</string>
<string name="trash_hint">Éléments supprimés, restaurables 30 jours</string>
<string name="trash_empty">Corbeille vide</string>
<string name="trash_retention_hint">Les éléments supprimés sont détruits automatiquement après 30 jours.</string>
<string name="trash_restore">Restaurer</string>
<string name="trash_purge">Supprimer définitivement</string>
<string name="trash_purge_confirm_title">Supprimer définitivement ?</string>
<string name="trash_purge_confirm_message">Cette action est irréversible. L\'élément sera détruit partout.</string>
<string name="trash_purge_confirm">Supprimer</string>
</resources>
@@ -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<Context>()
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
}
}
@@ -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<Context>()
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<String>()
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
}
}
@@ -312,6 +312,26 @@ class Auth401Test {
fileId: String,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun listTrash(
page: Int?,
pageSize: Int?,
): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.TrashDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun restoreFile(
fileId: String,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun listVersions(
fileId: String,
): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.VersionDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun restoreVersion(
fileId: String,
versionNo: Int,
): Response<ApiEnvelope<FileDto>> = Response.success(ApiEnvelope())
override suspend fun searchFiles(
query: String,
page: Int?,
@@ -186,6 +186,26 @@ class PaginationTest {
fileId: String,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun listTrash(
page: Int?,
pageSize: Int?,
): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.TrashDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun restoreFile(
fileId: String,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun listVersions(
fileId: String,
): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.VersionDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun restoreVersion(
fileId: String,
versionNo: Int,
): Response<ApiEnvelope<FileDto>> = Response.success(ApiEnvelope())
override suspend fun searchFiles(
query: String,
page: Int?,
@@ -132,6 +132,18 @@ class RemoteContentTest {
override suspend fun deleteFile(fileId: String): Response<ApiEnvelope<IdResultDto>> =
Response.success(ApiEnvelope())
override suspend fun listTrash(page: Int?, pageSize: Int?): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.TrashDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun restoreFile(fileId: String): Response<ApiEnvelope<IdResultDto>> =
Response.success(ApiEnvelope())
override suspend fun listVersions(fileId: String): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.VersionDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun restoreVersion(fileId: String, versionNo: Int): Response<ApiEnvelope<FileDto>> =
Response.success(ApiEnvelope())
override suspend fun searchFiles(query: String, page: Int?, pageSize: Int?): Response<ApiEnvelope<List<FileDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
@@ -338,6 +338,18 @@ class SessionReloginTest {
override suspend fun deleteFile(fileId: String): Response<ApiEnvelope<IdResultDto>> =
Response.success(ApiEnvelope())
override suspend fun listTrash(page: Int?, pageSize: Int?): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.TrashDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun restoreFile(fileId: String): Response<ApiEnvelope<IdResultDto>> =
Response.success(ApiEnvelope())
override suspend fun listVersions(fileId: String): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.VersionDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun restoreVersion(fileId: String, versionNo: Int): Response<ApiEnvelope<FileDto>> =
Response.success(ApiEnvelope())
override suspend fun searchFiles(query: String, page: Int?, pageSize: Int?): Response<ApiEnvelope<List<FileDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
@@ -171,6 +171,18 @@ class ShareManagementTest {
override suspend fun deleteFile(fileId: String): Response<ApiEnvelope<IdResultDto>> =
Response.success(ApiEnvelope())
override suspend fun listTrash(page: Int?, pageSize: Int?): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.TrashDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun restoreFile(fileId: String): Response<ApiEnvelope<IdResultDto>> =
Response.success(ApiEnvelope())
override suspend fun listVersions(fileId: String): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.VersionDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun restoreVersion(fileId: String, versionNo: Int): Response<ApiEnvelope<FileDto>> =
Response.success(ApiEnvelope())
override suspend fun searchFiles(query: String, page: Int?, pageSize: Int?): Response<ApiEnvelope<List<FileDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
@@ -265,6 +265,18 @@ class BytesUploadTest {
override suspend fun deleteFile(fileId: String): Response<ApiEnvelope<IdResultDto>> =
Response.success(ApiEnvelope())
override suspend fun listTrash(page: Int?, pageSize: Int?): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.TrashDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun restoreFile(fileId: String): Response<ApiEnvelope<IdResultDto>> =
Response.success(ApiEnvelope())
override suspend fun listVersions(fileId: String): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.VersionDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun restoreVersion(fileId: String, versionNo: Int): Response<ApiEnvelope<FileDto>> =
Response.success(ApiEnvelope())
override suspend fun searchFiles(query: String, page: Int?, pageSize: Int?): Response<ApiEnvelope<List<FileDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
@@ -372,6 +372,26 @@ private class FolderMergeApiService : ApiService {
fileId: String,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun listTrash(
page: Int?,
pageSize: Int?,
): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.TrashDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun restoreFile(
fileId: String,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun listVersions(
fileId: String,
): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.VersionDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun restoreVersion(
fileId: String,
versionNo: Int,
): Response<ApiEnvelope<FileDto>> = Response.success(ApiEnvelope())
override suspend fun searchFiles(
query: String,
page: Int?,
@@ -461,6 +461,26 @@ private class MoveProtectionApiService : ApiService {
fileId: String,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun listTrash(
page: Int?,
pageSize: Int?,
): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.TrashDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun restoreFile(
fileId: String,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun listVersions(
fileId: String,
): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.VersionDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun restoreVersion(
fileId: String,
versionNo: Int,
): Response<ApiEnvelope<FileDto>> = Response.success(ApiEnvelope())
override suspend fun searchFiles(
query: String,
page: Int?,
@@ -373,6 +373,26 @@ private class OcrApiServiceFake : ApiService {
fileId: String,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun listTrash(
page: Int?,
pageSize: Int?,
): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.TrashDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun restoreFile(
fileId: String,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun listVersions(
fileId: String,
): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.VersionDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun restoreVersion(
fileId: String,
versionNo: Int,
): Response<ApiEnvelope<FileDto>> = Response.success(ApiEnvelope())
override suspend fun searchFiles(
query: String,
page: Int?,
@@ -273,6 +273,18 @@ class OfflineDownloadTest {
override suspend fun deleteFile(fileId: String): Response<ApiEnvelope<IdResultDto>> =
Response.success(ApiEnvelope())
override suspend fun listTrash(page: Int?, pageSize: Int?): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.TrashDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun restoreFile(fileId: String): Response<ApiEnvelope<IdResultDto>> =
Response.success(ApiEnvelope())
override suspend fun listVersions(fileId: String): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.VersionDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun restoreVersion(fileId: String, versionNo: Int): Response<ApiEnvelope<FileDto>> =
Response.success(ApiEnvelope())
override suspend fun searchFiles(query: String, page: Int?, pageSize: Int?): Response<ApiEnvelope<List<FileDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
@@ -228,6 +228,26 @@ private class RefreshVsMoveApiService : ApiService {
fileId: String,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun listTrash(
page: Int?,
pageSize: Int?,
): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.TrashDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun restoreFile(
fileId: String,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun listVersions(
fileId: String,
): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.VersionDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun restoreVersion(
fileId: String,
versionNo: Int,
): Response<ApiEnvelope<FileDto>> = Response.success(ApiEnvelope())
override suspend fun searchFiles(
query: String,
page: Int?,
@@ -482,6 +482,26 @@ private class FakeApiService : ApiService {
fileId: String,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun listTrash(
page: Int?,
pageSize: Int?,
): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.TrashDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun restoreFile(
fileId: String,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun listVersions(
fileId: String,
): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.VersionDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun restoreVersion(
fileId: String,
versionNo: Int,
): Response<ApiEnvelope<FileDto>> = Response.success(ApiEnvelope())
override suspend fun searchFiles(
query: String,
page: Int?,
@@ -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))
@@ -155,6 +155,10 @@ class ReleaseLocalCopyTest {
override suspend fun getFileOcr(fileId: String): retrofit2.Response<com.kazier.mobile.data.remote.dto.ApiEnvelope<com.kazier.mobile.data.remote.dto.FileOcrDto>> = TODO()
override suspend fun getFile(fileId: String): retrofit2.Response<com.kazier.mobile.data.remote.dto.ApiEnvelope<com.kazier.mobile.data.remote.dto.FileDto>> = TODO()
override suspend fun deleteFile(fileId: String): retrofit2.Response<com.kazier.mobile.data.remote.dto.ApiEnvelope<com.kazier.mobile.data.remote.dto.IdResultDto>> = TODO()
override suspend fun listTrash(page: Int?, pageSize: Int?): retrofit2.Response<com.kazier.mobile.data.remote.dto.ApiEnvelope<List<com.kazier.mobile.data.remote.dto.TrashDto>>> = TODO()
override suspend fun restoreFile(fileId: String): retrofit2.Response<com.kazier.mobile.data.remote.dto.ApiEnvelope<com.kazier.mobile.data.remote.dto.IdResultDto>> = TODO()
override suspend fun listVersions(fileId: String): retrofit2.Response<com.kazier.mobile.data.remote.dto.ApiEnvelope<List<com.kazier.mobile.data.remote.dto.VersionDto>>> = TODO()
override suspend fun restoreVersion(fileId: String, versionNo: Int): retrofit2.Response<com.kazier.mobile.data.remote.dto.ApiEnvelope<com.kazier.mobile.data.remote.dto.FileDto>> = TODO()
override suspend fun searchFiles(query: String, page: Int?, pageSize: Int?): retrofit2.Response<com.kazier.mobile.data.remote.dto.ApiEnvelope<List<com.kazier.mobile.data.remote.dto.FileDto>>> = TODO()
override suspend fun changePassword(body: com.kazier.mobile.data.remote.dto.ChangePasswordDto): retrofit2.Response<com.kazier.mobile.data.remote.dto.ApiEnvelope<com.kazier.mobile.data.remote.dto.IdResultDto>> = TODO()
override suspend fun getShareLink(token: String): retrofit2.Response<com.kazier.mobile.data.remote.dto.ApiEnvelope<com.kazier.mobile.data.remote.dto.ShareLinkDto>> = TODO()
@@ -495,6 +495,18 @@ class OutboxSyncWorkerTest {
override suspend fun deleteFile(fileId: String): Response<ApiEnvelope<IdResultDto>> =
throw UnsupportedOperationException()
override suspend fun listTrash(page: Int?, pageSize: Int?): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.TrashDto>>> =
throw UnsupportedOperationException()
override suspend fun restoreFile(fileId: String): Response<ApiEnvelope<IdResultDto>> =
throw UnsupportedOperationException()
override suspend fun listVersions(fileId: String): Response<ApiEnvelope<List<com.kazier.mobile.data.remote.dto.VersionDto>>> =
throw UnsupportedOperationException()
override suspend fun restoreVersion(fileId: String, versionNo: Int): Response<ApiEnvelope<FileDto>> =
throw UnsupportedOperationException()
override suspend fun searchFiles(
query: String,
page: Int?,