diff --git a/AGENTS.md b/AGENTS.md index 6ac966a..da63dfe 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -2,7 +2,7 @@ ## Project Status -`backend/` (Go) et `mobile-kotlin/` (Kotlin/Android) ont du scaffolding en place. Le client mobile est **local-first** : il reflète le SAF dans une base Room (v7, migrations, DAO) et pousse les **métadonnées** de ses mutations locales via un **outbox transactionnel** (`pending_operations` + worker WorkManager → `POST /sync/ops`). Pas d'upload physique, pas d'OCR ni de recherche serveur côté client en V1. +`backend/` (Go) et `mobile-kotlin/` (Kotlin/Android) ont du scaffolding en place. Le client mobile est **local-first** : il reflète le SAF dans une base Room (v16, migrations, DAO) et pousse les **métadonnées** de ses mutations locales via un **outbox transactionnel** (`pending_operations` + worker WorkManager → `POST /sync/ops`). Upload physique ciblée (pipeline OCR : `POST /files/upload` + `resourceId`), streaming lecture des fichiers distants (`GET /files/:id/content`, jamais persisté), OCR serveur consommé côté client, recherche locale via Room (+ recherche serveur exposée mais non consommée). ## Architecture @@ -38,11 +38,11 @@ Tests mobiles : JVM unit tests dans `app/src/test` (JUnit + Robolectric + Room i - `config/` — env (`godotenv`, optionnel) + defaults: `PORT`, `DATABASE_URL`, `UPLOAD_DIR`, `MAX_FILE_SIZE_MB`, `OCR_LANG`, `AUTH_SECRET` (secret des tokens paseto), `ADMIN_USERNAME`/`ADMIN_PASSWORD` (bootstrap du premier admin) - `models/` — domain entities (users, devices, documents/resources, clients) - `service/` — business logic (permissions, upload, create folder, move, **sync outbox + snapshot**, bootstrap admin) -- `handlers/` — HTTP handlers (health, devices register, **auth/login**, **users resolve + change password**, files CRUD/upload/search, folders, **sync/ops + sync/permissions, ocr/jobs** — réels) ; middleware `RequireAuth` -- `repository/` — Postgres persistence (`repository.Resources` : insert/list/get/soft-delete scoping `owner_id`, search, move, rename, root-name unique index, `ListOwned` pour le snapshot ; `repository.Devices` : Upsert, Exists, MarkUser ; `repository.Operations` : trace outbox idempotente `(device_id, operation_id)` ; `repository.OcrJobs` : jobs queued→processing→done/failed ; `repository.Users` : GetByUsernameNormalized, ResolveExact, UpdatePassword) ; IDs sont TEXT 32-hex, `NewID()` = `crypto/rand` 16 octets hex (jamais UUID conversion, cf. `docs/api-v1.md`) -- `db/` — package migrations (`golang-migrate/v4`, embarquées via `embed` dans `db/migrations/*.sql`, 000001→000008) : `db.MigrateDatabase(url)` au boot du serveur ; test harness `db/migrations_test.go` (up → assertions schéma → down, `TEST_DATABASE_URL`, skip si PG indisponible) ; `dbtest/` — helper cross-package pour les tests repo/handlers (crée la DB test si absente, reset schema, migrate ; skip si PG down) +- `handlers/` — HTTP handlers (health, devices register, **auth/login**, **users resolve + change password**, files CRUD/upload/search, folders, **sync/ops + sync/permissions, ocr/jobs, files/:id/content, files/:id/shares, files/:id/links** — réels) ; middleware `RequireAuth` +- `repository/` — Postgres persistence (`repository.Resources` : insert/list/get/soft-delete scoping `owner_id`, search, move, rename, root-name unique index, `ListOwned` pour le snapshot, `OpenContent` (bytes streaming), `ListShares`/`ListLinks` (owner-only) ; `repository.Devices` : Upsert, Exists, MarkUser ; `repository.Operations` : trace outbox idempotente `(device_id, operation_id)` ; `repository.OcrJobs` : jobs queued→processing→done/failed ; `repository.Users` : GetByUsernameNormalized, ResolveExact, UpdatePassword ; `repository.Shares` : Upsert/Revoke, CreateLink/RevokeLink, ListActiveForResource, ListActiveLinksForResource, snapshot `ListEffectivePermissions`) ; IDs sont TEXT 32-hex, `NewID()` = `crypto/rand` 16 octets hex (jamais UUID conversion, cf. `docs/api-v1.md`) +- `db/` — package migrations (`golang-migrate/v4`, embarquées via `embed` dans `db/migrations/*.sql`, 000001→000013) : `db.MigrateDatabase(url)` au boot du serveur ; test harness `db/migrations_test.go` (up → assertions schéma → down, `TEST_DATABASE_URL`, skip si PG indisponible) ; `dbtest/` — helper cross-package pour les tests repo/handlers (crée la DB test si absente, reset schema, migrate ; skip si PG down) - `ocr/` — OCR engine behind an interface (Tesseract system call, `OCR_LANG` défaut `fra+eng`) -- `pkg/api/` — response helpers (`response.go`) ; `pkg/auth/` — tokens **paseto v4-local** (subject = `user_id`, claim = `device_id`, TTL 7j, voir `docs/api-v1.md`) ; `pkg/passwd/` — hashing/vérification bcrypt (timing-equal) +- `pkg/api/` — response helpers (`response.go`) ; `pkg/auth/` — tokens **paseto v4-local** (subject = `user_id`, claim = `device_id`, TTL 7j, voir `docs/api-v1.md`) ; `pkg/passwd/` — hashing/vérification argon2id (comparaison `subtle`, délai égalisé) - File uploads stored in `backend/uploads/` - Standard JSON response envelope: `{ "data": ..., "meta": { "page": ..., "total": ... } }` - Error format: `{ "error": { "code": "...", "message": "..." } }` @@ -52,39 +52,41 @@ Tests mobiles : JVM unit tests dans `app/src/test` (JUnit + Robolectric + Room i - Entry point: `app/src/main/java/com/kazier/mobile/KazierApplication.kt` (Hilt + `HiltWorkerFactory`) + `MainActivity.kt` (Hilt) ; navigation Compose dans `ui/navigation/` (`NavGraph.kt`, `KazierApp.kt`) - Data layer — `data/`: - - `data/local/` — Room SQLite (DB `dot.db`, **version 7**, `Migrations.kt` : tables `folders`, `files`, `user_preferences`, `pending_operations`) : entités Folder/File/UserPreference/PendingOperation, DAO, tri (`FileOrdering`) ; flag `processed` sur `files` (mode review « traiter », local au device, **gate de sync** : un fichier pas encore traité n'est jamais poussé) ; outbox transactionnel `pending_operations` (v7) + - `data/local/` — Room SQLite (DB `dot.db`, **version 16**, `Migrations.kt` : tables `folders`, `files` (+ `category`, `processed`, `content`, `ocr_text`, `ocr_attempts`, `ocr_queued_at`), `user_preferences`, `pending_operations` (+ `device_id`, `parent_resource_id`), `scan_sessions`, `scan_pages`, `resource_permissions`) : entités + DAO, tri (`FileOrdering`), schéma exporté (`app/schemas/`, m19) ; flag `processed` sur `files` (mode review « traiter », local au device, **gate de sync** : un fichier pas encore traité n'est jamais poussé) ; outbox transactionnel `pending_operations` - `data/remote/` — Retrofit/Moshi : `ApiService.kt` + `dto/Dtos.kt` = **contrat HTTP** (`{ data, meta }`, erreurs `{ error: { code, message } }`) ; `ApiClient.kt` normalise les réponses ; interceptors OkHttp (`AuthInterceptor`, `ServerUrlInterceptor`) - - `data/repository/` — `FolderRepository`, `FileRepository`, `AuthRepository`, `OutboxRepository` (enqueue `create_resource`/`move_resource`/`delete_resource`, écrivains dans la même transaction Room que la mutation parente ; pour un fichier SAF, la mutation parente du `create_resource` est le **garder** de la review (`markProcessed`), et `hasCreateOperation` en garde l'unicité) + - `data/repository/` — `FolderRepository`, `FileRepository`, `AuthRepository`, `OutboxRepository` (enqueue `create_resource`/`move_resource`/`delete_resource` + ops partage `share`/`update_share`/`revoke_share`/`create_link`/`revoke_link`, écrivains dans la même transaction Room que la mutation parente ; pour un fichier SAF, la mutation parente du `create_resource` est le **garder** de la review (`markProcessed`), et `hasCreateOperation` en garde l'unicité), `ShareRepository` (hydratation + delta + `canAccess` depuis `GET /sync/permissions`), `OcrRepository` (upload ciblé + jobs + `syncFromServer`), `RemoteContentRepository` (streaming `GET /files/:id/content`, jamais persisté) - `features/` — logique descendue côté client : - `sync/DeviceSync.kt` + `SafScanner.kt` — sync device↔SAF : **two-pass walk** (listing hors transaction puis upserts Room dans une seule transaction), réconciliation `exists = 0` (jamais de suppression), single-flight via `Mutex` ; les nouveaux **dossiers** sont journalisés dans l'outbox à la découverte, les **fichiers** uniquement au « garder » de la review (gate `processed`) - `saf/` — `SafUris`, `SafFolderCreator`, `FileMover` (relocalisation SAF `DocumentsContract.moveDocument`, repli métadonnée seule ; le déplacement est poussé en `move_resource`), `SafFileDeleter` (suppression SAF + `delete_resource` atomique) - `sync/OutboxSyncWorker.kt` — worker WorkManager (`enqueueUniqueWork` KEEP, single-flight, `NetworkType.CONNECTED`, backoff 30s) qui draine `pending_operations` vers `POST /sync/ops` (batch 20, dead-letter immédiat `failed` sur erreur 4xx non-idempotente — `attempts` diagnostic, purge synced > 7 jours) ; **schedulé** au login/restauration de session (`AuthViewModel`) et après chaque `syncAll()` (`SyncViewModel`) - `sync/SyncViewModel.kt` — état du sync exposé à l'UI (`SyncStatus` : marche en cours, ops en attente, dernières opérations) via le badge header `ui/components/SyncStatusBadge.kt` + `SyncOperationsDialog.kt` (« liste des sync ») -- `auth/` — session (login user + token paseto) : `SessionManager`, `SecureTokenStore`, `TokenProvider` -- `ui/` — écrans Compose : `folderlist`, `folderdetail`, `document` (contenu PDF/image/texte + placeholder cloud-only), `search` (**recherche locale** via Room, sans endpoint serveur), `settings` (URL serveur + thème), `pdfbuilder` (multi-select → génération PDF), `auth` (login, mode local), `components`, `theme` +- `auth/` — session (login user + token paseto + **re-login silencieux** sur 401 via identifiants chiffrés persistés, single-flight, événements `Reauthenticated`/`SessionExpired`) : `SessionManager`, `SecureTokenStore`, `TokenProvider`, `TokenStore` (+ `Credentials`) +- `ui/` — écrans Compose : `folderlist`, `folderdetail`, `document` (contenu PDF/image/texte local + streaming distant image/texte/PDF multi-pages via `RemoteDocumentViewer`, autres types non supportés en streaming), `search` (**recherche locale** via Room, sans endpoint serveur), `settings` (URL serveur + thème), `pdfbuilder` (multi-select → génération PDF), `auth` (login, mode local, avis d'expiration), `share` (`ShareBottomSheet` : grants + liens + ouverture de lien ; `OpenLinkScreen` + deep-link `kazier://share/`), `components`, `theme` - `domain/` — stores de préférences: `DeviceIdentity`, `ActiveUserStore`, `LocalModeStore`, `ServerConfigStore`, `ThemePreferenceStore`, `GenerateId` (identifiants 32-hex) - `di/` — modules Hilt (`AppModule`, `DatabaseModule`, `NetworkModule`) - Base URL serveur **configurée à l'exécution** dans les Réglages (`ServerConfigStore`, persistée en `user_preferences`), défaut `http://10.0.2.2:8080/api/v1` (pas de variable d'env) -- Client **local-first** : lecture via `GET /files/folders`, `GET /files` ; mutations locales poussées via l'outbox `POST /sync/ops` (`create_resource`/`move_resource`/`delete_resource`) ; `POST /devices`, `POST /auth/login` ; download/upload physique hors scope +- Client **local-first** : lecture via `GET /files/folders`, `GET /files` (+ streaming distant `GET /files/:id/content` pour les fichiers cloud-only, jamais persisté) ; mutations locales poussées via l'outbox `POST /sync/ops` (`create_resource`/`move_resource`/`delete_resource` + ops partage) ; `POST /devices`, `POST /auth/login` ; upload physique limité au pipeline OCR (`POST /files/upload` + `resourceId` ciblé) ## Data Conventions - Canonical identity for folders/files is `resource_id`: opaque 32-hex, generated locally (`GenerateId`), never reused. The physical `uri` (SAF) is nullable (NULL = cloud-only) and is the reconciliation key for the SAF walk (unique index, NULLs distincts). -- Similarly, `pending_operations.operation_id` is a client-generated 32-hex (`GenerateId`), the idempotency key of the outbox `UNIQUE(device_id, operation_id)` lettre contre les rejeux du worker. +- `pending_operations.operation_id` est un **TEXT 32-hex** généré par le client (`^[0-9a-f]{32}$`, CHECK-enforced côté serveur depuis la migration `000008`), distinct de `resource_id`. L'idempotence outbox reste **par device** : `UNIQUE(device_id, operation_id)` (colonne `device_id` côté mobile depuis Room v12). - `owner_id` is **nullable** in the Room schema; it is set at runtime from `DeviceIdentity.getOrCreate()` during the SAF walk. - Folder/file `sync_status` is a **placement** state: `local` | `cloud` | `local-cloud`. It is not a push progress marker. - Client storage: `user_preferences` (clé/valeur) pour l'identité device, le compte actif, l'URL serveur, le thème, le mode local. - Outbox atomique : `create_resource`/`move_resource`/`delete_resource` sont écrits dans la **même transaction Room** que la mutation parente ; l'écrivain (repository) et le worker partagent ce contrat. En mode local (pas de token), le worker est no-op. **Gate `processed`** : un fichier SAF nouvellement découvert est importé localement mais poussé seulement au « garder » (`markProcessed`, qui enqueue le `create_resource` dans la même transaction, une seule fois via `hasCreateOperation`) — d'où le filtrage des documents par l'utilisateur avant toute synchro. Un `delete_resource` n'est journalisé que si un `create_resource` a existé (jamais pour un fichier non poussé). -- Pas de cache de permissions côté client en V1 : le serveur reste la source de vérité pour l'accès (`GET /sync/permissions` non consommé par le client Kotlin). +- Cache de permissions côté client : `ShareRepository` hydrate `resource_permissions` depuis `GET /sync/permissions` (delta + pull complet, TTL 24h → downgrade lecture seule) et expose `canAccess` ; le serveur reste la source de vérité. ## API Contract (V1) - **Le client mobile est le contrat**: les formes d'endpoints dans `mobile-kotlin/.../data/remote/ApiService.kt` + `dto/Dtos.kt` sont autoritatives et doivent matcher exactement ; le serveur ne renégocie pas. Spec consolidée: `docs/api-v1.md`. -- **Identity (user-first, V1 finale)**: le device s'enregistre (`POST /devices`, `{ "deviceId" }` seul, sans token), puis `POST /auth/login` (`username` + `password` + `device_id`) émet le seul token paseto **v4-local** — subject = `user_id` (autorise, scoping de toutes les ressources), claim `device_id` (porté, non autorisant seul), **TTL 7j sans refresh**. À expiration, le client re-logine. +- **Identity (user-first, V1 finale)**: le device s'enregistre (`POST /devices`, `{ "deviceId" }` seul, sans token), puis `POST /auth/login` (`username` + `password` + `device_id`) émet le seul token paseto **v4-local** — subject = `user_id` (autorise, scoping de toutes les ressources), claim `device_id` (porté, non autorisant seul), **TTL 7j sans refresh**. À expiration, le client re-logine **silencieusement** via les identifiants chiffrés persistés (`SecureTokenStore`, single-flight, événements `Reauthenticated`/`SessionExpired`), sans rejouer la requête en vol. - **Bootstrap**: au premier démarrage, si `users` est vide, `ADMIN_USERNAME`/`ADMIN_PASSWORD` (env) créent le premier admin ; absents → le serveur refuse de démarrer. L'env n'écrase jamais un compte existant. Usernames résolus sur `username_normalized` (lowercase + trim), `GET /users/resolve` exact uniquement (pas d'énumération). - **Identifiers**: `resource_id` / `device_user_id` / `user_id` / share-link `token` / `operation_id` sont des **lowercase 32-hex** TEXT (`^[0-9a-f]{32}$`, CHECK-enforced), stockés tels quels côté serveur (pas de conversion UUID). Le mobile génère toujours 32-hex. - **Outbox idempotence + ordering**: le serveur applique les batchs de `pending_operations` **séquentiellement**, s'arrête à la première erreur non-idempotente et retourne l'index atteint. Consommé par le client Kotlin (`OutboxSyncWorker` → `POST /sync/ops`, batch 20, dead-letter immédiat sur 4xx non-idempotente, purge > 7 jours). `create_resource` porte le `parentResourceId` optionnel (racine si absent) — le walk SAF garantit parent avant enfant dans l'ordre d'`id`. -- **Permissions snapshot**: le serveur pousse des snapshots `resource_permissions` (`effective_access` ranking viewer < commenter < editor < owner, `inherit`, `expires_at`, TTL 24h → read-only downgrade). (Endpoint existant côté serveur ; pas encore consommé par le client Kotlin.) +- **Permissions snapshot**: le serveur pousse des snapshots `resource_permissions` (`effective_access` ranking viewer < commenter < editor < owner, `inherit`, `expires_at`, TTL 24h → read-only downgrade). Consommé par le client Kotlin (`ShareRepository` : hydratation + delta + `canAccess`). + +- **Lecture partagée** : `GET /files/:id/shares` + `GET /files/:id/links` (owner uniquement, 404 sinon) exposent grants et liens au propriétaire ; `GET /files/:id/content` streame les octets (viewer+, `Range` supporté). ## Non-Goals (V1) @@ -92,7 +94,7 @@ Tests mobiles : JVM unit tests dans `app/src/test` (JUnit + Robolectric + Room i - On-device OCR - Full multi-tenant federation / public discovery - Multi-writer sync conflicts (single-owner device identity) -- Upload physique client→cloud (métadonnées seules via l'outbox, download, OCR jobs, permissions) côté mobile Kotlin +- Upload physique généralisé client→cloud et download persistant (seuls l'upload ciblé OCR et le streaming lecture existent, cf. `docs/api-v1.md`) ## References diff --git a/CHANGELOG.md b/CHANGELOG.md index 4cbaa7c..458d317 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,10 +5,10 @@ Le format suit [Keep a Changelog](https://keepachangelog.com/fr/1.1.0/) et le ve ## [Unreleased] -### Changé -- **Renommage : VaultDrop → Kazier.** Marque, package Android (`com.kazier.mobile`), module Go (`github.com/kazier/backend`), binaire/image `kazier-server`, creds Postgres par défaut. Le code interne `dot.db` est conservé. - ### Ajouté +- Streaming lecture des fichiers distants : `GET /files/:id/content` (binaire brut, `Range`, viewer+), viewer mobile à la demande sans persistance (image/texte/PDF multi-pages, autres types non supportés). +- Gestion du partage côté owner : `GET /files/:id/shares` + `GET /files/:id/links`, sheet mobile (grants modifiables/révocables, liens création/copie/révocation, ouverture de lien, badge pending outbox), deep-link `kazier://share/` + écran de résolution. +- Re-login silencieux : identifiants chiffrés persistés, renouvellement auto sur 401 (single-flight, file conservée si même compte), écran login avec avis d'expiration + username pré-rempli. - Pipeline de release CI (GitLab) : lint, tests backend/mobile, build Docker, signature APK release, publication GitLab Release + Docker Hub. - `backend/Dockerfile` multi-stage : image de production avec Tesseract (fra+eng) embarqué, user non-root, labels OCI. - Service `backend` actif dans `docker-compose.yml` (déploiement conteneurisé). @@ -17,6 +17,9 @@ Le format suit [Keep a Changelog](https://keepachangelog.com/fr/1.1.0/) et le ve - Licence AGPLv3, badge README, `CHANGELOG.md`. - Versioning Android aligné sur le `VERSION` racine (versionCode dérivé). +### Changé +- **Renommage : VaultDrop → Kazier.** Marque, package Android (`com.kazier.mobile`), module Go (`github.com/kazier/backend`), binaire/image `kazier-server`, creds Postgres par défaut. Le code interne `dot.db` est conservé. + ### Corrigé - Docs : en-tête `docs/api-v1.md` (référence à l'ancien client Expo remplacée par le client Kotlin), quickstart et docker de la doc Starlight. - `.gitignore` racine (uploads, binaires, keystore, artifacts). diff --git a/README.md b/README.md index d807b2b..d3c43cd 100644 --- a/README.md +++ b/README.md @@ -29,5 +29,5 @@ cd mobile-kotlin && ./gradlew :app:testDebugUnitTest | Backend entry | `backend/cmd/server/main.go` — wiring gin + routes | | Sync outbox | `mobile-kotlin/.../features/sync/OutboxSyncWorker.kt` — worker WorkManager → `POST /sync/ops` | | SAF scan | `mobile-kotlin/.../features/sync/DeviceSync.kt` — two-pass walk SAF ↔ Room | -| Room DB | `mobile-kotlin/.../data/local/AppDatabase.kt` — version 7, migrations, DAO | +| Room DB | `mobile-kotlin/.../data/local/AppDatabase.kt` — version 16, migrations, DAO | | API Retrofit | `mobile-kotlin/.../data/remote/ApiService.kt` — interface Retrofit (contrat client) | diff --git a/docs/api-v1.md b/docs/api-v1.md index 4779220..a040e11 100644 --- a/docs/api-v1.md +++ b/docs/api-v1.md @@ -122,7 +122,7 @@ type FileOcr = { text: string; updatedAt?: string | null }; - `revoke_link` : `payload = { "token": "…32-hex" }`. **Idempotent**. - Validation (deuxième champ `operation_id`, hex32 pour `resource_id` **et** `operation_id`, enum `operation`) → échec `INVALID_REQUEST` avec arrêt du batch. - Nom déjà pris (même parent, ou à la racine) → échec `NAME_CONFLICT`.** -- **Lien public** : `GET /shares/links/:token` est **sans authentification** (résolution publique d'un lien) et renvoie `{ "token", "resource_id", "resourceType", "name", "access", "expiresAt" }`. `NOT_FOUND` si le lien est inconnu, révoqué ou expiré. +- **Lien public** : `GET /shares/links/:token` est **sans authentification** (résolution publique d'un lien) et renvoie `{ "token", "resource_id", "resourceType", "name", "access", "expiresAt" }`. `NOT_FOUND` si le lien est inconnu, révoqué ou expiré. Le client partage les liens sous forme de deep-link `kazier://share/` (custom scheme, pas d'App Links https) : indépendant du domaine du serveur, donc compatible self-hosting (chaque instance a son propre host). ### 6.2 Snapshot — `GET /sync/permissions?after=` diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/LikeEscape.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/LikeEscape.kt index 4f4af94..0684de0 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/LikeEscape.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/LikeEscape.kt @@ -1,5 +1,8 @@ package com.kazier.mobile.data.local +import java.text.Normalizer +import java.util.Locale + /** * Échappe les jokers `LIKE` (`%`, `_`) et l'échappement lui-même (`\`) dans * un fragment destiné à une requête `... LIKE ... ESCAPE '\'` (m5, m7). @@ -8,3 +11,17 @@ package com.kazier.mobile.data.local */ internal fun String.escapeLike(): String = replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_") + +/** + * Normalise une saisie de recherche pour le matching insensible aux accents + * (suivi m7) : minuscules (ROOT, pas de surprise turque), décomposition NFD, + * suppression des diacritiques, ligatures `œ`/`æ` explicites (non décomposées + * par NFD). À appliquer AVANT [escapeLike] ; le SQL compare contre + * `name` normalisé de la même façon (chaîne de `REPLACE`, voir `FileDao`). + */ +internal fun String.normalizeSearch(): String = + lowercase(Locale.ROOT) + .let { Normalizer.normalize(it, Normalizer.Form.NFD) } + .replace(Regex("\\p{Mn}+"), "") + .replace("œ", "oe") + .replace("æ", "ae") diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/FileDao.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/FileDao.kt index 188629d..3557305 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/FileDao.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/FileDao.kt @@ -46,20 +46,28 @@ interface FileDao { suspend fun getByUri(uri: String): FileEntity? /** - * Recherche par nom (m7) : `:query` arrive déjà échappé (`escapeLike`, - * `%`/`_` littéraux, pas des jokers) avec `ESCAPE '\'`. `COLLATE NOCASE` - * sur l'opérande gauche pour une casse ASCII insensible explicite - * (le repli Unicode « ete » → « ÉTÉ » demanderait une colonne normalisée, - * hors scope — voir FEEDBACK). + * Recherche par nom (m7 + suivi accents) : `:query` arrive déjà échappé + * (`escapeLike`, `%`/`_` littéraux, pas des jokers) avec `ESCAPE '\'`. + * `COLLATE NOCASE` couvre la casse ASCII ; la deuxième branche compare + * `lower(name)` débarrassé de ses accents (chaîne de `REPLACE` FR — pas de + * colonne normalisée ni de migration) contre `:normQuery` (saisie passée + * par `normalizeSearch` + `escapeLike`). « ete » trouve « ÉTÉ ». */ @Query(""" SELECT * FROM files WHERE "exists" = 1 - AND (:query IS NULL OR name COLLATE NOCASE LIKE '%' || :query || '%' ESCAPE '\') + AND (:query IS NULL OR name COLLATE NOCASE LIKE '%' || :query || '%' ESCAPE '\' + OR REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE( + REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(REPLACE( + lower(name), + 'œ','oe'),'æ','ae'),'ç','c'),'à','a'),'â','a'),'ä','a'), + 'é','e'),'è','e'),'ê','e'),'ë','e'),'î','i'),'ï','i'), + 'ô','o'),'ö','o'),'ù','u'),'û','u'),'ü','u'),'ÿ','y') + LIKE '%' || :normQuery || '%' ESCAPE '\') AND (:category IS NULL OR category = :category) ORDER BY name ASC """) - fun searchWithFilters(query: String?, category: String?): Flow> + fun searchWithFilters(query: String?, normQuery: String?, category: String?): Flow> @Query(""" SELECT * FROM files diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/FileRepository.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/FileRepository.kt index 237decf..441b18b 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/FileRepository.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/FileRepository.kt @@ -3,6 +3,7 @@ package com.kazier.mobile.data.repository import androidx.room.withTransaction import com.kazier.mobile.data.local.AppDatabase import com.kazier.mobile.data.local.escapeLike +import com.kazier.mobile.data.local.normalizeSearch import com.kazier.mobile.data.local.dao.FileDao import com.kazier.mobile.data.local.dao.FolderDao import com.kazier.mobile.data.local.entity.FileEntity @@ -49,13 +50,18 @@ class FileRepository @Inject constructor( /** * Recherche/filtrage par nom et catégorie (utilisé par SearchViewModel). - * m7 : la saisie est échappée (`%`/`_` littéraux, pas des jokers). + * m7 : la saisie est échappée (`%`/`_` littéraux, pas des jokers) ; + * suivi accents : la saisie normalisée (`normalizeSearch`) matche + * « ÉTÉ » depuis « ete » (branche SQL dédiée, sans migration). */ - fun searchFiles(query: String?, category: String?): Flow> = - fileDao.searchWithFilters( - query = query?.trim()?.takeIf { it.isNotEmpty() }?.escapeLike(), + fun searchFiles(query: String?, category: String?): Flow> { + val trimmed = query?.trim()?.takeIf { it.isNotEmpty() } + return fileDao.searchWithFilters( + query = trimmed?.escapeLike(), + normQuery = trimmed?.normalizeSearch()?.escapeLike(), category = category, ) + } /** Les `limit` fichiers les plus récents (date de référence), filtrés par catégorie. */ fun recentFiles(category: String?, limit: Int = RECENT_LIMIT): Flow> = diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/document/DocumentViewerScreen.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/document/DocumentViewerScreen.kt index 95e639d..ce3071d 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/document/DocumentViewerScreen.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/document/DocumentViewerScreen.kt @@ -367,6 +367,9 @@ fun DocumentViewerScreen( * - IMAGE → document plein écran sur fond noir * - TEXT → lecture immersive (fond sombre, texte clair, sélectionnable) * + * Fichier cloud-only (`uri == null`) : le viewer streaming plein écran + * (même contenu que la page, en plus grand) — jamais persisté. + * * Le retour (tap ou bouton système) est géré par le cadre commun [FocusScaffold]. */ @Composable @@ -376,6 +379,20 @@ private fun FocusDocumentReader( onExitFullscreen: () -> Unit, modifier: Modifier = Modifier, ) { + if (file.uri == null) { + FocusScaffold( + file = file, + onExitFullscreen = onExitFullscreen, + modifier = modifier, + ) { + DocumentContentViewer( + file = file, + onOpenExternalFailed = onOpenExternalFailed, + modifier = Modifier.fillMaxSize(), + ) + } + return + } when (file.categoryValue()) { FileCategory.PDF -> PdfFullscreenReader( file = file, @@ -942,9 +959,9 @@ internal fun resolveViewerPage(currentPage: Int, restoredPage: Int, itemCount: I internal fun shouldExitViewer(jumpPending: Boolean, hadDocuments: Boolean, isEmpty: Boolean): Boolean = !jumpPending && hadDocuments && isEmpty -/** Vrai si le fichier est local et appartient à une catégorie consultable en mode focus. */ +/** Vrai si le fichier appartient à une catégorie consultable en mode focus. */ private fun FileEntity.canFocus(): Boolean = - uri != null && categoryValue() in FOCUS_CATEGORIES + categoryValue() in FOCUS_CATEGORIES /** * Vrai si le fichier est prêt pour l'OCR serveur : copie physique locale ET diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/document/content/PdfPageViewer.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/document/content/PdfPageViewer.kt index 2f8828b..b10e526 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/document/content/PdfPageViewer.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/document/content/PdfPageViewer.kt @@ -55,6 +55,10 @@ import kotlinx.coroutines.withContext * largeur cible borne les bitmaps et un cache LRU limite la mémoire. Le * `PdfRenderer` n'est pas thread-safe : toutes les lectures passent par un * `Mutex` et un dispatcher IO. + * + * `openFd` (optionnel) remplace la lecture SAF : streaming distant (lot 1) — + * les octets sont écrits dans un fichier temporaire du `cacheDir` par + * l'appelant ([RemoteDocumentViewer]), supprimé à la sortie. */ @Composable fun PdfPageViewer( @@ -62,16 +66,17 @@ fun PdfPageViewer( contentResolver: ContentResolver, onOpenExternalFailed: () -> Unit, modifier: Modifier = Modifier, + openFd: (() -> ParcelFileDescriptor?)? = null, ) { val uri = file.uri - if (uri == null) { + if (uri == null && openFd == null) { CloudOnlyPlaceholder(file, modifier) return } - val document = remember(uri) { PdfDocumentState(contentResolver, uri) } - var pageCount by remember(uri) { mutableIntStateOf(0) } - var loadFailed by remember(uri) { mutableStateOf(false) } + val document = remember(file.resourceId, uri) { PdfDocumentState(contentResolver, uri, openFd) } + var pageCount by remember(file.resourceId) { mutableIntStateOf(0) } + var loadFailed by remember(file.resourceId) { mutableStateOf(false) } // Le state vit en mémoire (cache + dossier ouvert) tant que ce lecteur est // affiché ; il est fermé à la sortie ou au changement de document. @@ -79,7 +84,7 @@ fun PdfPageViewer( onDispose { document.close() } } - LaunchedEffect(uri) { + LaunchedEffect(document) { pageCount = 0 loadFailed = false if (document.load()) { @@ -136,22 +141,23 @@ fun PdfFocusViewer( modifier: Modifier = Modifier, onPageCountChanged: ((Int) -> Unit)? = null, renderScale: Float = 1f, + openFd: (() -> ParcelFileDescriptor?)? = null, ) { val uri = file.uri - if (uri == null) { + if (uri == null && openFd == null) { CloudOnlyPlaceholder(file, modifier) return } - val document = remember(uri) { PdfDocumentState(contentResolver, uri) } - var pageCount by remember(uri) { mutableIntStateOf(0) } - var loadFailed by remember(uri) { mutableStateOf(false) } + val document = remember(file.resourceId, uri) { PdfDocumentState(contentResolver, uri, openFd) } + var pageCount by remember(file.resourceId) { mutableIntStateOf(0) } + var loadFailed by remember(file.resourceId) { mutableStateOf(false) } DisposableEffect(document) { onDispose { document.close() } } - LaunchedEffect(uri) { + LaunchedEffect(document) { pageCount = 0 loadFailed = false if (document.load()) { @@ -303,10 +309,15 @@ private fun PdfPageItem( /** * État d'un document PDF : ouvre le `PdfRenderer` à la demande, rend chaque * page via le cache LRU et verrouille l'accès au renderer (non thread-safe). + * + * Source des octets : SAF (`contentResolver` + `uri`) par défaut, ou + * `openFd` (streaming distant — l'appelant écrit les octets dans un fichier + * temporaire et fournit un descripteur frais à chaque appel). */ private class PdfDocumentState( private val contentResolver: ContentResolver, - private val uri: String, + private val uri: String?, + private val openFd: (() -> ParcelFileDescriptor?)? = null, ) { @Volatile private var renderer: PdfRenderer? = null @@ -329,7 +340,8 @@ private class PdfDocumentState( if (closed) return@withLock false if (renderer != null) return@withLock true val opened = runCatching { - val pfd: ParcelFileDescriptor? = DocumentContent.openFileDescriptor(contentResolver, uri) + val pfd: ParcelFileDescriptor? = openFd?.invoke() + ?: uri?.let { DocumentContent.openFileDescriptor(contentResolver, it) } if (pfd != null) PdfRenderer(pfd) else null }.getOrNull() if (opened != null) renderer = opened diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/document/content/RemoteDocumentViewer.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/document/content/RemoteDocumentViewer.kt index b44960f..1f71f56 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/document/content/RemoteDocumentViewer.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/document/content/RemoteDocumentViewer.kt @@ -1,7 +1,6 @@ package com.kazier.mobile.ui.document.content import android.graphics.BitmapFactory -import android.graphics.pdf.PdfRenderer import android.os.ParcelFileDescriptor import androidx.compose.foundation.Image import androidx.compose.foundation.layout.Arrangement @@ -197,7 +196,12 @@ private fun RemoteContentBody( when (file.categoryValue()) { FileCategory.IMAGE -> RemoteImageViewer(bytes = bytes, description = file.name, modifier = modifier) FileCategory.TEXT -> RemoteTextViewer(bytes = bytes, modifier = modifier) - FileCategory.PDF -> RemotePdfViewer(file = file, bytes = bytes, modifier = modifier) + FileCategory.PDF -> RemotePdfViewer( + file = file, + bytes = bytes, + onOpenExternalFailed = onOpenExternalFailed, + modifier = modifier, + ) else -> Column( modifier = modifier.padding(24.dp), horizontalAlignment = Alignment.CenterHorizontally, @@ -266,19 +270,25 @@ private fun RemoteTextViewer(bytes: ByteArray, modifier: Modifier = Modifier) { } /** - * PDF distant : le `PdfRenderer` système exige un descripteur de fichier — - * les octets sont écrits dans un fichier temporaire du `cacheDir` - * (`stream-.pdf`), supprimé à la sortie. Première page affichée - * (aperçu streaming, pas de navigation complète). + * PDF distant : les octets sont écrits dans un fichier temporaire du + * `cacheDir` (`stream-.pdf`), lu via le pager multi-pages + * partagé ([PdfPageViewer]), puis supprimé à la sortie. La fermeture du + * renderer (enfant) précède la suppression du fichier (parent). */ @Composable -private fun RemotePdfViewer(file: FileEntity, bytes: ByteArray, modifier: Modifier = Modifier) { +private fun RemotePdfViewer( + file: FileEntity, + bytes: ByteArray, + onOpenExternalFailed: () -> Unit, + modifier: Modifier = Modifier, +) { val context = LocalContext.current + val contentResolver = context.contentResolver var tmpFile by remember(file.resourceId) { mutableStateOf(null) } - var loadFailed by remember(file.resourceId) { mutableStateOf(false) } + var writeFailed by remember(file.resourceId) { mutableStateOf(false) } LaunchedEffect(file.resourceId, bytes) { - loadFailed = false + writeFailed = false tmpFile = withContext(Dispatchers.IO) { runCatching { val tmp = File(context.cacheDir, "stream-${file.resourceId}.pdf") @@ -286,7 +296,7 @@ private fun RemotePdfViewer(file: FileEntity, bytes: ByteArray, modifier: Modifi tmp }.getOrNull() } - if (tmpFile == null) loadFailed = true + if (tmpFile == null) writeFailed = true } DisposableEffect(file.resourceId) { onDispose { @@ -302,7 +312,7 @@ private fun RemotePdfViewer(file: FileEntity, bytes: ByteArray, modifier: Modifi val tmp = tmpFile when { - loadFailed || (tmp != null && !tmp.exists()) -> Text( + writeFailed -> Text( text = stringResource(R.string.document_cannot_read), style = MaterialTheme.typography.bodyMedium, modifier = modifier, @@ -310,56 +320,17 @@ private fun RemotePdfViewer(file: FileEntity, bytes: ByteArray, modifier: Modifi tmp == null -> Box(modifier.fillMaxSize(), contentAlignment = Alignment.Center) { CircularProgressIndicator() } - else -> RemotePdfFirstPage(tmp = tmp, modifier = modifier) - } -} - -@Composable -private fun RemotePdfFirstPage(tmp: File, modifier: Modifier = Modifier) { - var bitmap by remember(tmp.absolutePath) { mutableStateOf(null) } - var failed by remember(tmp.absolutePath) { mutableStateOf(false) } - LaunchedEffect(tmp.absolutePath) { - failed = false - bitmap = withContext(Dispatchers.IO) { - runCatching { - val pfd = ParcelFileDescriptor.open(tmp, ParcelFileDescriptor.MODE_READ_ONLY) - val renderer = PdfRenderer(pfd) - try { - if (renderer.pageCount <= 0) return@runCatching null - val page = renderer.openPage(0) - try { - val width = (page.width * 2f).toInt().coerceIn(1, 4096) - val height = (page.height * 2f).toInt().coerceIn(1, 4096) - val bmp = android.graphics.Bitmap.createBitmap( - width, height, android.graphics.Bitmap.Config.ARGB_8888, - ) - page.render(bmp, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY) - bmp - } finally { - page.close() - } - } finally { - renderer.close() - pfd.close() - } - }.getOrNull() - } - if (bitmap == null) failed = true - } - Box(modifier.fillMaxSize(), contentAlignment = Alignment.Center) { - when { - bitmap != null -> Image( - bitmap = bitmap!!.asImageBitmap(), - contentDescription = null, - modifier = Modifier.fillMaxSize(), - contentScale = ContentScale.Fit, - ) - failed -> Text( - text = stringResource(R.string.document_cannot_read), - style = MaterialTheme.typography.bodyMedium, - ) - else -> CircularProgressIndicator() - } + else -> PdfPageViewer( + file = file, + contentResolver = contentResolver, + onOpenExternalFailed = onOpenExternalFailed, + modifier = modifier, + openFd = { + runCatching { + ParcelFileDescriptor.open(tmp, ParcelFileDescriptor.MODE_READ_ONLY) + }.getOrNull() + }, + ) } } diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/share/ShareLinkParser.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/share/ShareLinkParser.kt index f3320cb..f8a2691 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/share/ShareLinkParser.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/share/ShareLinkParser.kt @@ -3,14 +3,19 @@ package com.kazier.mobile.ui.share /** * Extraction d'un token de lien de partage depuis une saisie utilisateur. * - * Formats acceptés : 32-hex brut, URL deep-link `kazier://share/`, - * ou URL API `…/shares/links/`. Retourne le token normalisé - * (lowercase) ou null si rien d'exploitable. + * Formats acceptés : 32-hex brut, deep-link `kazier://share/`, + * URL API `…/shares/links/`, ou page courte `…/s/`. + * Retourne le token normalisé (lowercase) ou null si rien d'exploitable. + * + * Le format partagé est TOUJOURS le deep-link `kazier://share/` + * (voir [shareUrl]) : indépendant du domaine du serveur, donc compatible + * self-hosting (pas d'App Links https vérifiés, qui exigeraient un domaine + * unique). Les formes https ne servent qu'à tolérer un lien collé. */ object ShareLinkParser { private val HEX32 = Regex("^[0-9a-f]{32}$") private val HEX32_LOOSE = Regex("^[0-9a-fA-F]{32}$") - private val IN_URL = Regex("(?:shares/links|/share)[:/]([0-9a-fA-F]{32})(?![0-9a-fA-F])") + private val IN_URL = Regex("(?:shares/links|/share|/s)[:/]([0-9a-fA-F]{32})(?![0-9a-fA-F])") fun extractToken(input: String): String? { val trimmed = input.trim() diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/dao/SearchEscapeTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/dao/SearchEscapeTest.kt index 7f13d85..69b7da0 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/dao/SearchEscapeTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/local/dao/SearchEscapeTest.kt @@ -18,7 +18,9 @@ import org.robolectric.annotation.Config /** * m7 : la recherche `LIKE` échappe `%`/`_` (littéraux, pas des jokers) — * « 100% » ne matchait pas tout avant le fix. La casse ASCII reste - * insensible (`COLLATE NOCASE`). + * insensible (`COLLATE NOCASE`), et le suivi accents rend la recherche + * insensible aux diacritiques (« ete » → « ÉTÉ », branche SQL `REPLACE`, + * sans migration). */ @RunWith(RobolectricTestRunner::class) @Config(sdk = [34]) @@ -50,7 +52,7 @@ class SearchEscapeTest { // Le repository échappe avant d'appeler le DAO — on rejoue ici le // contrat (`escapeLike`) pour verrouiller le comportement SQL. val escaped = "100%".escapeLikeForTest() - val rows = fileDao.searchWithFilters(escaped, null).first() + val rows = fileDao.searchWithFilters(escaped, escaped.normalizeForTest(), null).first() assertEquals(listOf("100%.txt"), rows.map { it.name }) } @@ -61,7 +63,7 @@ class SearchEscapeTest { fileDao.upsert(file("b".repeat(32), "a_b.txt")) fileDao.upsert(file("c".repeat(32), "axb.txt")) - val rows = fileDao.searchWithFilters("a\\_b", null).first() + val rows = fileDao.searchWithFilters("a\\_b", "a\\_b", null).first() assertEquals(listOf("a_b.txt"), rows.map { it.name }) } @@ -70,11 +72,53 @@ class SearchEscapeTest { fun recherche_insensible_a_la_casse_ascii() = runTest { fileDao.upsert(file("a".repeat(32), "Rapport.TXT")) - val rows = fileDao.searchWithFilters("rapport", null).first() + val rows = fileDao.searchWithFilters("rapport", "rapport", null).first() assertEquals(listOf("Rapport.TXT"), rows.map { it.name }) } + @Test + fun recherche_insensible_aux_accents() = runTest { + fileDao.upsert(file("a".repeat(32), "Été à la plage.txt")) + fileDao.upsert(file("b".repeat(32), "ÉCOLE.pdf")) + fileDao.upsert(file("c".repeat(32), "chœur final.mp3")) + fileDao.upsert(file("d".repeat(32), "façade naïve.doc")) + fileDao.upsert(file("e".repeat(32), "rien à voir.txt")) + + assertEquals( + listOf("Été à la plage.txt"), + fileDao.searchWithFilters("ete", "ete", null).first().map { it.name }, + ) + assertEquals( + listOf("ÉCOLE.pdf"), + fileDao.searchWithFilters("ecole", "ecole", null).first().map { it.name }, + ) + assertEquals( + listOf("chœur final.mp3"), + fileDao.searchWithFilters("choeur", "choeur", null).first().map { it.name }, + ) + assertEquals( + listOf("façade naïve.doc"), + fileDao.searchWithFilters("facade naive", "facade naive", null).first().map { it.name }, + ) + // La saisie accentuée trouve aussi (normalisée des deux côtés). + assertEquals( + listOf("Été à la plage.txt"), + fileDao.searchWithFilters("été", "ete", null).first().map { it.name }, + ) + } + + @Test + fun normalize_miroir_kotlin() { + // Miroir de `normalizeSearch` (interne au main) — verrouille le + // contrat repository → DAO. + assertEquals("ete", "Été".normalizeForTest()) + assertEquals("choeur", "chœur".normalizeForTest()) + assertEquals("facade", "façade".normalizeForTest()) + assertEquals("aether", "Æther".normalizeForTest()) + assertEquals("noel", "Noël".normalizeForTest()) + } + private fun file(resourceId: String, name: String) = FileEntity( resourceId = resourceId, name = name, @@ -89,6 +133,14 @@ class SearchEscapeTest { private fun String.escapeLikeForTest(): String = replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_") + /** Miroir de `normalizeSearch` (interne au main) : minuscules + sans accents. */ + private fun String.normalizeForTest(): String = + lowercase(java.util.Locale.ROOT) + .let { java.text.Normalizer.normalize(it, java.text.Normalizer.Form.NFD) } + .replace(Regex("\\p{Mn}+"), "") + .replace("œ", "oe") + .replace("æ", "ae") + private companion object { const val NOW = 1_700_000_000_000L } diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/ui/share/ShareLinkParserTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/ui/share/ShareLinkParserTest.kt index bd277f7..9f19bbb 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/ui/share/ShareLinkParserTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/ui/share/ShareLinkParserTest.kt @@ -36,6 +36,14 @@ class ShareLinkParserTest { ) } + @Test + fun `extractToken_extrait_de_la_page_courte`() { + assertEquals( + token, + ShareLinkParser.extractToken("https://mon-serveur.fr/s/$token"), + ) + } + @Test fun `extractToken_rejette_l_illisible`() { assertNull(ShareLinkParser.extractToken(""))