16 Commits
Author SHA1 Message Date
venture d0957e90d0 release 1.0.0 : fin du périmètre V1
Release / release-apk (push) Successful in 9m23s
Release / release-docker (push) Successful in 38s
CI / docker (push) Successful in 7s
CI / lint-backend (push) Successful in 1m23s
CI / lint-mobile (push) Failing after 7m45s
CI / test-backend (push) Successful in 1m24s
CI / test-mobile (push) Successful in 9m16s
CI / build-backend (push) Successful in 58s
2026-09-25 18:13:36 +02:00
venture a50eb830f4 consolidation V1 : docs resync, PDF streaming multi-pages, recherche sans accents, parser https 2026-09-25 18:13:30 +02:00
venture c642763035 api use
CI / lint-backend (push) Successful in 1m24s
CI / lint-mobile (push) Failing after 7m28s
CI / test-backend (push) Successful in 1m25s
CI / test-mobile (push) Successful in 9m9s
CI / build-backend (push) Successful in 45s
CI / docker (push) Successful in 33s
2026-09-25 17:34:35 +02:00
venture b869f70922 streaming d'un fichier 2026-09-25 15:34:28 +02:00
venture 9e8b01b135 chage floatting footer into scanned files
CI / lint-backend (push) Successful in 1m19s
CI / lint-mobile (push) Successful in 8m44s
CI / test-backend (push) Successful in 1m21s
CI / test-mobile (push) Successful in 8m55s
CI / build-backend (push) Successful in 45s
CI / docker (push) Successful in 9s
2026-09-25 14:09:12 +02:00
venture 456579880e improve documents
CI / lint-backend (push) Successful in 1m19s
CI / lint-mobile (push) Canceled after 5m8s
CI / test-backend (push) Canceled after 0s
CI / test-mobile (push) Canceled after 0s
CI / build-backend (push) Canceled after 0s
CI / docker (push) Canceled after 0s
2026-09-25 14:02:41 +02:00
venture 25aedb431e hide sync status is local mode app
CI / lint-backend (push) Successful in 1m21s
CI / lint-mobile (push) Successful in 20m43s
CI / test-backend (push) Successful in 1m50s
CI / test-mobile (push) Successful in 8m49s
CI / build-backend (push) Successful in 45s
CI / docker (push) Successful in 3m50s
2026-09-25 12:09:14 +02:00
venture 25bab43b21 split serveur config and login
CI / lint-backend (push) Successful in 1m42s
CI / lint-mobile (push) Canceled after 5m5s
CI / test-backend (push) Canceled after 0s
CI / test-mobile (push) Canceled after 0s
CI / build-backend (push) Canceled after 0s
CI / docker (push) Canceled after 0s
2026-09-25 12:02:23 +02:00
venture cbc94c8722 feat(mobile): refonte UI phases 0-4 + nav sans transitions
CI / lint-backend (push) Successful in 1m37s
CI / lint-mobile (push) Successful in 11m18s
CI / test-backend (push) Successful in 1m34s
CI / test-mobile (push) Successful in 13m11s
CI / build-backend (push) Successful in 1m6s
CI / docker (push) Successful in 9s
- Phase 0: design system (Color/Theme/Type complets light/dark,
  Shapes/Dimens, KazierCard, formatFileSize centralise)
- Phase 1: composants partages sur colorScheme (badges, dialogs,
  nav flottante factorisee, contentDescriptions)
- Phase 2: ecrans principaux (cartes unifiees, boutons M3,
  LoginForm partage, recherche avec compteur/clear)
- Phase 3: flows secondaires (dashboard sync, review animee,
  scan 360dp + sortie cul-de-sac camera, PdfBuilder checkbox/
  recherche/fin auto-nav, share ExposedDropdownMenu + confirmation,
  watched rescan + erreur import)
- Phase 4: a11y (selection semantics), dialogs saveable, cibles 48dp
- NavHost: transitions d'ecran desactivees (Enter/Exit None)
2026-09-24 20:32:08 +02:00
venture d1b0807d38 fix feedback bugs
CI / lint-backend (push) Successful in 1m27s
CI / lint-mobile (push) Successful in 10m24s
CI / test-backend (push) Successful in 1m33s
CI / test-mobile (push) Failing after 12m6s
CI / build-backend (push) Successful in 59s
CI / docker (push) Successful in 8s
2026-09-24 19:40:13 +02:00
venture 225f6e4b93 fix(ci): release Gitea idempotente (réutilise le tag existant, remplace l'APK)
Release / release-apk (push) Successful in 8m27s
Release / release-docker (push) Successful in 3m33s
CI / docker (push) Successful in 7s
CI / lint-backend (push) Successful in 1m41s
CI / lint-mobile (push) Successful in 19m44s
CI / test-backend (push) Successful in 1m50s
CI / test-mobile (push) Successful in 8m27s
CI / build-backend (push) Successful in 45s
2026-09-24 06:43:59 +02:00
venture f97e0aed45 chore(deploy): release Gitea-only + compose prod (registre interne)
Release / release-apk (push) Failing after 6m37s
Release / release-docker (push) Successful in 7s
CI / docker (push) Successful in 7s
CI / lint-backend (push) Successful in 1m18s
CI / lint-mobile (push) Successful in 8m14s
CI / test-backend (push) Successful in 1m21s
CI / test-mobile (push) Successful in 8m19s
CI / build-backend (push) Successful in 47s
2026-09-23 22:18:09 +02:00
venture 9dbd9d7a11 fix(ci): force bash shell in release workflow (pipefail under sh)
Release / release-apk (push) Successful in 8m27s
Release / release-docker (push) Failing after 10s
CI / docker (push) Successful in 6s
CI / lint-backend (push) Successful in 1m24s
CI / lint-mobile (push) Successful in 8m9s
CI / test-backend (push) Successful in 1m18s
CI / test-mobile (push) Successful in 8m17s
CI / build-backend (push) Successful in 43s
2026-09-23 19:37:36 +02:00
venture 33ff9a6789 add missing translation
CI / lint-backend (push) Successful in 1m21s
CI / lint-mobile (push) Successful in 8m14s
CI / test-backend (push) Successful in 1m20s
CI / test-mobile (push) Successful in 8m23s
Release / release-apk (push) Failing after 24s
Release / release-docker (push) Failing after 11s
CI / build-backend (push) Successful in 44s
CI / docker (push) Skipped
2026-09-23 10:32:15 +02:00
venture 22286aa2b1 fix mobile audit review: ownership, outbox purge, delete gates, journal-first sweep, parent link column
CI / lint-backend (push) Successful in 1m19s
CI / lint-mobile (push) Failing after 6m39s
CI / test-backend (push) Successful in 1m19s
CI / test-mobile (push) Successful in 8m18s
CI / build-backend (push) Successful in 43s
CI / docker (push) Successful in 8s
2026-09-23 00:25:27 +02:00
venture d89c0d03c9 fix 1 to 6 2026-09-22 23:55:49 +02:00
170 changed files with 13027 additions and 2452 deletions
+28
View File
@@ -0,0 +1,28 @@
# Production — copier vers .env.prod (jamais commité) et adapter.
# Utilisé avec : docker compose -f docker-compose.prod.yml --env-file .env.prod [pull|up -d]
# Image (registre Gitea). VERSION=latest par défaut ; pincer pour figer, ex. :
# VERSION=v0.1.0 (le tag release inclut le "v", cf. release.yml)
REGISTRY_IMAGE=gitea.thirdshop.fr/thirdshop/kazier
VERSION=latest
# Port d'écoute exposé sur l'hôte (derrière Caddy/Nginx/TLS en prod publique)
PORT=8080
# Postgres (mots de passe forts, générés, uniques à la prod)
POSTGRES_DB=kazier
POSTGRES_USER=kazier
POSTGRES_PASSWORD=CHANGE_ME_GENERER_UN_SECRET_LONG
# Backend
MAX_FILE_SIZE_MB=50
OCR_LANG=fra+eng
# Sécurité — générer un secret long et aléatoire, ex. :
# openssl rand -base64 48
AUTH_SECRET=CHANGE_ME_GENERER_UN_SECRET_LONG
# Premier admin (créé UNIQUEMENT si la table users est vide au premier boot).
# L'env n'écrase jamais un compte existant.
ADMIN_USERNAME=admin
ADMIN_PASSWORD=CHANGE_ME_MOT_DE_PASSE_INITIAL_FORT
+24 -21
View File
@@ -2,7 +2,8 @@
# #
# Construit l'APK signé (assembleRelease), crée la Release Gitea avec l'APK en # Construit l'APK signé (assembleRelease), crée la Release Gitea avec l'APK en
# asset (API, équivalent de `glab release create`), puis pousse l'image # asset (API, équivalent de `glab release create`), puis pousse l'image
# kazier-server sur le registre conteneur Gitea + Docker Hub (tag + latest). # kazier-server sur le registre conteneur Gitea (tag + latest).
# Déploiement perso uniquement : pas de push Docker Hub.
# #
# Prérequis act_runner : job `release-docker` s'exécute directement sur # Prérequis act_runner : job `release-docker` s'exécute directement sur
# l'hôte et utilise le daemon Docker local (pas de conteneur `docker:27`, # l'hôte et utilise le daemon Docker local (pas de conteneur `docker:27`,
@@ -17,7 +18,6 @@
# - RELEASE_API_TOKEN PAT scope write:repository (API : création Release) # - RELEASE_API_TOKEN PAT scope write:repository (API : création Release)
# - CONTAINER_REGISTRY_TOKEN PAT scope write:package (registre conteneur Gitea) # - CONTAINER_REGISTRY_TOKEN PAT scope write:package (registre conteneur Gitea)
# - CONTAINER_REGISTRY_USER utilisateur propriétaire du PAT ci-dessus # - CONTAINER_REGISTRY_USER utilisateur propriétaire du PAT ci-dessus
# - DOCKERHUB_USER DOCKERHUB_TOKEN PAT Docker Hub (push public)
name: Release name: Release
@@ -30,7 +30,6 @@ permissions:
env: env:
ANDROID_IMAGE: cimg/android:2024.01-node ANDROID_IMAGE: cimg/android:2024.01-node
DOCKERHUB_IMAGE: docker.io/thirdshop/kazier
# API Gitea (host de l'instance) # API Gitea (host de l'instance)
API_HOST: gitea.thirdshop.fr API_HOST: gitea.thirdshop.fr
@@ -53,6 +52,7 @@ jobs:
- name: Signer + assembler l'APK release - name: Signer + assembler l'APK release
working-directory: mobile-kotlin working-directory: mobile-kotlin
shell: bash
env: env:
RELEASE_KEYSTORE_B64: ${{ secrets.RELEASE_KEYSTORE_B64 }} RELEASE_KEYSTORE_B64: ${{ secrets.RELEASE_KEYSTORE_B64 }}
SIGNING_STORE_PASSWORD: ${{ secrets.SIGNING_STORE_PASSWORD }} SIGNING_STORE_PASSWORD: ${{ secrets.SIGNING_STORE_PASSWORD }}
@@ -80,25 +80,41 @@ jobs:
./gradlew :app:assembleRelease -q ./gradlew :app:assembleRelease -q
- name: Créer la Release Gitea + upload APK - name: Créer la Release Gitea + upload APK
shell: bash
env: env:
RELEASE_API_TOKEN: ${{ secrets.RELEASE_API_TOKEN }} RELEASE_API_TOKEN: ${{ secrets.RELEASE_API_TOKEN }}
run: | run: |
set -euo pipefail set -euo pipefail
VERSION="$(cat VERSION)" VERSION="$(cat VERSION)"
TAG="v${VERSION}"
API="https://${API_HOST}/api/v1" API="https://${API_HOST}/api/v1"
AUTH="Authorization: token ${RELEASE_API_TOKEN:?RELEASE_API_TOKEN manquant (PAT scope write:repository)}" AUTH="Authorization: token ${RELEASE_API_TOKEN:?RELEASE_API_TOKEN manquant (PAT scope write:repository)}"
NOTES_JSON="$(python3 -c 'import json;print(json.dumps(open("CHANGELOG.md", encoding="utf-8").read()))')" NOTES_JSON="$(python3 -c 'import json;print(json.dumps(open("CHANGELOG.md", encoding="utf-8").read()))')"
PAYLOAD_JSON="$(TAG="v${VERSION}" BODY="$NOTES_JSON" python3 -c 'import json,os;print(json.dumps({"tag_name":os.environ["TAG"],"name":"Kazier "+os.environ["TAG"],"body":json.loads(os.environ["BODY"])}))')" # Idempotent : si la release du tag existe déjà (re-tag, retry du job),
# la réutiliser au lieu d'échouer en 409.
if RELEASE_JSON="$(curl -sSf -H "${AUTH}" "${API}/repos/${GITHUB_REPOSITORY}/releases/tags/${TAG}" 2>/dev/null)"; then
echo "Release ${TAG} existante — réutilisation."
else
PAYLOAD_JSON="$(TAG="${TAG}" BODY="$NOTES_JSON" python3 -c 'import json,os;print(json.dumps({"tag_name":os.environ["TAG"],"name":"Kazier "+os.environ["TAG"],"body":json.loads(os.environ["BODY"])}))')"
RELEASE_JSON="$(curl -sSf -X POST "${API}/repos/${GITHUB_REPOSITORY}/releases" \ RELEASE_JSON="$(curl -sSf -X POST "${API}/repos/${GITHUB_REPOSITORY}/releases" \
-H "${AUTH}" \ -H "${AUTH}" \
-H "Content-Type: application/json" \ -H "Content-Type: application/json" \
-d "${PAYLOAD_JSON}")" -d "${PAYLOAD_JSON}")"
fi
RELEASE_ID="$(printf '%s' "${RELEASE_JSON}" | python3 -c 'import json,sys;print(json.load(sys.stdin)["id"])')" RELEASE_ID="$(printf '%s' "${RELEASE_JSON}" | python3 -c 'import json,sys;print(json.load(sys.stdin)["id"])')"
: "${RELEASE_ID:?id de release introuvable dans la réponse API}" : "${RELEASE_ID:?id de release introuvable dans la réponse API}"
# Asset idempotent : remplace l'APK existant de même nom s'il y en a un.
APK_PATH="mobile-kotlin/app/build/outputs/apk/release/app-release.apk"
EXISTING_ASSET_ID="$(curl -sSf -H "${AUTH}" "${API}/repos/${GITHUB_REPOSITORY}/releases/${RELEASE_ID}/assets" \
| python3 -c 'import json,sys;assets=json.load(sys.stdin);print(next((str(a["id"]) for a in assets if a.get("name")=="app-release.apk"),""))')"
if [ -n "${EXISTING_ASSET_ID}" ]; then
echo "Asset existant ${EXISTING_ASSET_ID} — suppression avant re-upload."
curl -sSf -X DELETE -H "${AUTH}" "${API}/repos/${GITHUB_REPOSITORY}/releases/${RELEASE_ID}/assets/${EXISTING_ASSET_ID}" > /dev/null
fi
curl -sSf -X POST \ curl -sSf -X POST \
"${API}/repos/${GITHUB_REPOSITORY}/releases/${RELEASE_ID}/assets?name=app-release.apk" \ "${API}/repos/${GITHUB_REPOSITORY}/releases/${RELEASE_ID}/assets?name=app-release.apk" \
-H "${AUTH}" \ -H "${AUTH}" \
-F "attachment=@mobile-kotlin/app/build/outputs/apk/release/app-release.apk" -F "attachment=@${APK_PATH}"
release-docker: release-docker:
runs-on: ubuntu-24.04 runs-on: ubuntu-24.04
@@ -111,12 +127,14 @@ jobs:
token: ${{ secrets.GITEA_TOKEN }} token: ${{ secrets.GITEA_TOKEN }}
- name: Sanity daemon Docker hôte - name: Sanity daemon Docker hôte
shell: bash
run: | run: |
set -euo pipefail set -euo pipefail
docker info >/dev/null docker info >/dev/null
echo "daemon Docker hôte joignable" echo "daemon Docker hôte joignable"
- name: Login registre Gitea - name: Login registre Gitea
shell: bash
env: env:
CONTAINER_REGISTRY_TOKEN: ${{ secrets.CONTAINER_REGISTRY_TOKEN }} CONTAINER_REGISTRY_TOKEN: ${{ secrets.CONTAINER_REGISTRY_TOKEN }}
CONTAINER_REGISTRY_USER: ${{ secrets.CONTAINER_REGISTRY_USER }} CONTAINER_REGISTRY_USER: ${{ secrets.CONTAINER_REGISTRY_USER }}
@@ -129,6 +147,7 @@ jobs:
echo "REGISTRY_IMAGE=${API_HOST}/${OWNER_LC}/kazier" >> "$GITHUB_ENV" echo "REGISTRY_IMAGE=${API_HOST}/${OWNER_LC}/kazier" >> "$GITHUB_ENV"
- name: "Build + push (registre Gitea : vX.Y.Z + latest)" - name: "Build + push (registre Gitea : vX.Y.Z + latest)"
shell: bash
run: | run: |
set -euo pipefail set -euo pipefail
VERSION="$(cat VERSION)" VERSION="$(cat VERSION)"
@@ -144,19 +163,3 @@ jobs:
docker run --rm "$REGISTRY_IMAGE:v${VERSION}" --version docker run --rm "$REGISTRY_IMAGE:v${VERSION}" --version
docker push "$REGISTRY_IMAGE:v${VERSION}" docker push "$REGISTRY_IMAGE:v${VERSION}"
docker push "$REGISTRY_IMAGE:latest" docker push "$REGISTRY_IMAGE:latest"
echo "TAG=v${VERSION}" >> "$GITHUB_ENV"
- name: Push Docker Hub (tag + latest)
env:
DOCKERHUB_USER: ${{ secrets.DOCKERHUB_USER }}
DOCKERHUB_TOKEN: ${{ secrets.DOCKERHUB_TOKEN }}
run: |
set -euo pipefail
: "${DOCKERHUB_USER:?DOCKERHUB_USER manquant}"
: "${DOCKERHUB_TOKEN:?DOCKERHUB_TOKEN manquant}"
IMAGE="$DOCKERHUB_IMAGE"
echo "$DOCKERHUB_TOKEN" | docker login -u "$DOCKERHUB_USER" --password-stdin docker.io
docker tag "$REGISTRY_IMAGE:$TAG" "$IMAGE:$TAG"
docker tag "$REGISTRY_IMAGE:$TAG" "$IMAGE:latest"
docker push "$IMAGE:$TAG"
docker push "$IMAGE:latest"
+17 -15
View File
@@ -2,7 +2,7 @@
## Project Status ## 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 ## 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) - `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) - `models/` — domain entities (users, devices, documents/resources, clients)
- `service/` — business logic (permissions, upload, create folder, move, **sync outbox + snapshot**, bootstrap admin) - `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` - `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 ; `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`) - `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→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) - `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`) - `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/` - File uploads stored in `backend/uploads/`
- Standard JSON response envelope: `{ "data": ..., "meta": { "page": ..., "total": ... } }` - Standard JSON response envelope: `{ "data": ..., "meta": { "page": ..., "total": ... } }`
- Error format: `{ "error": { "code": "...", "message": "..." } }` - 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`) - 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 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/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 : - `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`) - `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) - `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/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 ») - `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` - `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 + 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` - `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/<token>`), `components`, `theme`
- `domain/` — stores de préférences: `DeviceIdentity`, `ActiveUserStore`, `LocalModeStore`, `ServerConfigStore`, `ThemePreferenceStore`, `GenerateId` (identifiants 32-hex) - `domain/` — stores de préférences: `DeviceIdentity`, `ActiveUserStore`, `LocalModeStore`, `ServerConfigStore`, `ThemePreferenceStore`, `GenerateId` (identifiants 32-hex)
- `di/` — modules Hilt (`AppModule`, `DatabaseModule`, `NetworkModule`) - `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) - 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 ## 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). - 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. - `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. - 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. - 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é). - 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) ## 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`. - **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). - **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. - **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`. - **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) ## Non-Goals (V1)
@@ -92,7 +94,7 @@ Tests mobiles : JVM unit tests dans `app/src/test` (JUnit + Robolectric + Room i
- On-device OCR - On-device OCR
- Full multi-tenant federation / public discovery - Full multi-tenant federation / public discovery
- Multi-writer sync conflicts (single-owner device identity) - 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 ## References
+7 -2
View File
@@ -5,10 +5,12 @@ Le format suit [Keep a Changelog](https://keepachangelog.com/fr/1.1.0/) et le ve
## [Unreleased] ## [Unreleased]
### Changé ## [1.0.0] - 2026-09-25
- **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é ### 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/<token>` + é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. - 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. - `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é). - Service `backend` actif dans `docker-compose.yml` (déploiement conteneurisé).
@@ -17,6 +19,9 @@ Le format suit [Keep a Changelog](https://keepachangelog.com/fr/1.1.0/) et le ve
- Licence AGPLv3, badge README, `CHANGELOG.md`. - Licence AGPLv3, badge README, `CHANGELOG.md`.
- Versioning Android aligné sur le `VERSION` racine (versionCode dérivé). - 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é ### 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. - 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). - `.gitignore` racine (uploads, binaires, keystore, artifacts).
+128 -287
View File
@@ -1,317 +1,158 @@
# FEEDBACK — Audit backend Kazier # FEEDBACK — Audit bugs mobile-kotlin (local-first)
Date : 2026-09-21 > Généré le 2026-09-22 par 5 agents d'exploration parallèles (scopes : Room/DB, sync/outbox/SAF, réseau/auth/repos, UI/navigation/VM, scan/pdf/review/thumbnails).
Scope : `backend/` (Go, Gin, Postgres, Paseto, Tesseract) > Mise à jour le 2026-09-24 : les items corrigés par `d89c0d0 (fix 1 to 6)` et `22286aa (fix mobile audit review)` ont été re-vérifiés code en main et retirés. Ce document ne liste que le **reliquat confirmé**.
Mode : lecture seule, vérifié dans le code. > Màj 2026-09-24 (soir) : tout le reliquat ci-dessous est **corrigé et testé** (`:app:testDebugUnitTest` : 162/162 verts, DB v16, schéma `app/schemas/16.json` exporté). Les sections 🟠/🟡/🛠️ sont conservées comme traçabilité.
But : autre agent relit et complète ci-dessous (voir § À compléter). > Chaque finding restant est vérifié avec preuve `file:line`.
> Scope : `mobile-kotlin/` uniquement.
> Légende : 🟠 Majeur (divergence silencieuse, contrat violé) · 🟡 Mineur (UX, perf, dette).
## Haute priorité Base paths : `mobile-kotlin/app/src/main/java/com/kazier/mobile/…`
1. **Route `GET /files/folders` masquée** — `backend/handlers/router.go:29-32` ---
`GET /files/:id` déclaré avant `GET /files/folders`. Gin peut capter `folders` comme `id="folders"` → 404 au lieu de la liste.
2. **`move_resource` sans check de cycle** — `backend/service/sync.go:204-219` ## ✅ Corrigés et retirés (vérifiés le 2026-09-24)
Seul `toFolder == resourceID` rejeté. Déplacer un parent dans son enfant crée un cycle, casse les CTE récursives (`depth<100`).
3. **`create_link` non-idempotent** — `backend/service/sync.go:337` → `backend/repository/shares.go` (`CreateLink` INSERT simple sur PK `token`) ### 🔴 Critiques : 9/9 corrigés
Rejeu même `operation_id` (crash entre apply et `Record`) → violation PK classée `INVALID_REQUEST` terminale, bloque tout l'outbox. Prévoir `ON CONFLICT DO NOTHING` comme `Operations.Record`. - **C1** `domain/GenerateId.kt:19` — masque `and 0xFF` contre la sign-extension, 32-hex conforme.
- **C2** `features/sync/OutboxSyncWorker.kt:139-145` — erreurs non-attribuables (`INVALID_RESPONSE`, 429/408, 4xx batch-level) → `Result.retry()` sans toucher aux ops.
- **C3** `data/local/dao/PendingOperationDao.kt:66-72` — `purgeSynced` exclut les `create_resource` (tombstones), gates `countCreateOperations` préservés.
- **C4** `features/saf/FileDeleter.kt:122-128` + `FolderDeleter.kt:122-124` — journal-first (`withTransaction` avant suppression SAF) + `sweepPendingPhysicalDeletes`.
- **C5** `auth/SessionManager.kt:70-77` — `clear()` purge les ops non poussées (`pending`/`failed`), appelé par `AuthViewModel.signOut/signOutToLocal`.
- **C6** `OutboxSyncWorker.kt:185-188` — stop au 1er échec (`return success()`, jamais `continue`) + cascade transitive `cascadeCreateFailure` via `parent_resource_id`/payload.
- **C7** `OutboxSyncWorker.kt:152,170-174,193-196` — `applied.coerceIn`, `failedIndex < 0 → stop`, `applied == 0 → stop` (anti busy-loop/crash).
- **C8** Scan export — `ScanExport.pendingForExport` idempotent, `shouldFinishSession` gate `DONE`, `uniquePageFile()` UUID, `deletePage` DB-d'abord, `exportPdf` ne marque que les succès.
- **C9** `features/scan/ScanImageProcessor.kt:91-92` + `ScanViewModel.kt:213` — jamais de `recycle()` sur l'alias affiché (`!==` check).
4. **`AUTH_SECRET` défaut faible** — `backend/config/config.go:49` + `backend/pkg/auth/auth.go` ### 🟠 Majeurs corrigés (31)
Défaut `dev-secret-change-me`, juste `SHA256`, pas de check longueur/entropie → tokens paseto v4-local forgeables sur déploiements par défaut. M1 (garde pending-move dossiers), M2 (gate `create` avant `move`), M3 (`FileMover` sans repli mensonger), M4 (exclusion `exists=0` pending seul), M6 (parent inconnu → `continue`), M7 (`importRoot` schedule le drain), M8 (fichiers 0-octet acceptés), M10 (`DeviceIdentity` mutex + `insertIgnore`), M11 (décision assumée : pas de backfill `create_resource`), M12 (`upsertTolerant` sur `resource_id`/`uri`), M14 (colonne `device_id`, `UNIQUE(device_id, operation_id)` + migration 11→12), M15 (`failDescendants` élargi, cf. C6), M21 (boucle `listFilesPaged` + `meta.total`), M22 (`ApiClient` distingue `CancellationException`/`JsonDataException`/`IOException`), M23 (`activeUserStore` vs `ownerId`, plus de confusion device/user), M24 (`normalizePayloadNumbers` Double→Long), M25 (`SessionManager` possède `onUnauthorized`), M26 (`ServerUrlInterceptor` `runBlocking load()` anti-race), M28 (validation URL `toHttpUrl()`), M29 (`pendingDefaultPick` saveable), M30 (pager `rememberSaveable`), M31 (debounce sur résultats seuls), M32 (gate `canShare` FolderDetail), M33 (`refreshShareGate` au login/logout), M34 (`selection.clear()` + chips figés en sélection), M35 (`resolveViewerPage` clamp), M36 (sélecteur thème 3 états), M37 (flag `dirty` anti-écrasement saisie), M38 (`MAX(sortOrder)+1`), M42 (`processed=true` PDF builder), M43 (réinsertion optimiste review), M44 (`remember(existingIds)` stable).
5. **Upload : extension non sanitisée** — `backend/service/resources.go:148-154` ### 🟡 Mineurs corrigés dans `d89c0d0` (voir `git show --stat d89c0d0`)
`filepath.Ext(file.Filename)` client tel quel → `destPath = <user>/<id>.<ext>`. Cas `""` → fichier `id.`, cas `../../`, `/`, très long → traversal / orphelins / ambiguïté `Glob(id.*)` pour OCR. m4 (gardes cursor SAF), m6 (`deleteLocally` transactionnel), m8 (`FileOrdering` aligné SQL), m9 (commentaire `attempts` diagnostic), m10-m14 (`updateUri`, `LocalModeStore`, `load` réarmable, `StateFlow` après succès DB, clé `SYNC_MODE` retirée), m16-m18 (index, `defaultValue processed`, `swapOrder` contraint), m22 (`ApiService` endpoints contrat ajoutés), m23 (`registerDevice` erreurs visibles), m24 (garde mode local), m25 (logging sans PII), m26 (`Bearer` hors routes publiques), m27 (`expiresAt` persisté), m28 (`SecureTokenStore` lazy + Direct Boot), m29-m31 (nav `pdfbuilder/empty`, `launchSingleTop`, controller hoisté), m33-m39 (side-effects `buildPhase`, dialogs `rememberSaveable`, badge collectes, saisie serveur debouncée, flash thème, bandeau import, `FileStatus.LOCAL`), m40-m56 (scan/camera/thumbnails : résolution bornée, `toBitmap` throttlé, listener retiré, `else` rotation, garde `sourceRect`, arrondi crop, `combine` nettoyé, purge `ABANDONED`, unicité session active, `FileCategory` CSV cohérent, purge map `Mutex`, `.tmp` nettoyés, `isUpToDate` taille+mtime, `runCatching` close, commentaire `max`, `release()` sur exception, deck conservé sur erreur).
6. **Orphelins + stale bytes au re-upload** — `backend/service/resources.go:161-162` + `backend/service/ocr.go` ---
`UpdatePhysical` ne supprime pas l'ancien `<id>.<oldExt>`. `Glob` prend le premier match → OCR sur bytes périmés + fuite disque. Échec `GetFile` après `InsertFile` réussi laisse aussi le fichier.
7. **`ApplyBatch` non-atomique** — `backend/service/sync.go:103-125` ## 🟠 Majeurs restants (4) — ✅ tous corrigés le 2026-09-24 (162/162 tests verts)
`Applied() → apply → Record()` sans transaction. TOCTOU sur batches concurrents même `(device_id,operation_id)`, replay après crash, `Record` en 500 avec `applied` inconnu.
8. **Fuite d'erreurs internes** — `backend/handlers/store.go:20-33` + `backend/service/sync.go:87-98` - **M5 — `features/saf/FileDeleter.kt:88-104` + `features/saf/FolderDeleter.kt:91-103`** : `deleteInCloud` sans tombstone locale (`exists` reste 1) → ressource toujours affichée, walk la revoit, `refreshFromServer` ne supprime jamais de lignes → fantôme local vs serveur supprimé.
Défaut `500 err.Error()` / `INVALID_REQUEST err.Error()` expose SQL/FS/paths au client. - **M9 — `features/saf/FolderMerger.kt:59,65-101`** : merge toujours multi-transactions (create, moves, deletes séparés) ; seule idempotence `findExistingMerged:154-161` ajoutée, pas d'atomicité → crash à mi-fusion = état partiel poussé.
- **M13 — entités `exists: Int? = null` + filtres `= 1`** (`FolderEntity.kt:36`, `FileEntity.kt:46`, `FolderDao.kt:43,50`, `FileDao.kt:27,44`) : toute ligne sans `exists` explicite disparaît UI/recherche/review — perte fonctionnelle silencieuse.
- **M27 — `data/repository/ShareRepository.kt:47` + `data/remote/dto/Dtos.kt:150-151`** : snapshot permissions sans delta (`after` jamais passé), `sharedById`/`expiresAt` en `Any?` jamais lus, `cachedAt` jamais persisté, aucun downgrade 24h ni `canAccess` → grant révoqué/expiré reste visible et ouvrable (`404`) jusqu'au prochain login.
9. **`Count()` bloque le bootstrap** — `backend/repository/users.go` + `backend/service/bootstrap.go` ---
Compte les soft-deleted. Tous users supprimés → plus jamais de nouvel admin, lock définitif. Devrait filtrer `WHERE deleted_at IS NULL`.
10. **Migrations destructives / irréversibles** ## 🟡 Mineurs restants (8) — ✅ tous corrigés le 2026-09-24 (162/162 tests verts)
- `backend/db/migrations/000007_resources_user_ownership.up.sql:7` fait `DELETE FROM resources` à l'upgrade (wipe prod).
- `backend/db/migrations/000008_operation_uuid.down.sql` fait `operation_id::bigint` → casse dès que des IDs 32-hex avec `a-f` existent.
11. **Stubs dangereux** — `backend/service/services.go`, `move.go`, `upload.go`, `folders.go` ### Sync / Worker / SAF
`UserCan*` toujours `true`, no-ops. Si jamais câblés = bypass auth total. À supprimer. - **m1 — `features/sync/SyncViewModel.kt:108-133`** : `_walkInProgress` sans `finally` dans la boucle (reste `true` si scope annulé ; seul `importRoot:173` a un `finally`) → badge « syncing » collé ; la fenêtre inclut l'appel réseau partage.
- **m2 — `features/sync/SyncViewModel.kt:110-116`** : `OutboxSyncWorker.enqueue` + `OcrAutoWorker.enqueue` à chaque tick même sans changement → réveils WorkManager / 30s pour rien.
- **m5 — `features/sync/DeviceSync.kt:76-162`** : « transaction courte » en réalité géante (N upserts + `getAll()` dossiers **et** fichiers par racine sous verrou écriture) → lecteurs Room bloqués, jank/ANR sur grosses arborescences.
12. **Oracle `INVALID_DEVICE_ID` au login** — `backend/handlers/auth.go:55-81` ### Room / Domain / DI
Check device après `VerifyTimedEqual`. Creds valides + device inconnu → 400 vs 401 → oracle + pas de rate-limit. - **m7 — `data/local/dao/FileDao.kt:45`** : `searchWithFilters` `LIKE` brut sans `ESCAPE`, casse ASCII-only → `%`/`_` = jokers (match-all), « ete » ne trouve pas « ÉTÉ ».
- **m15 — `di/DatabaseModule.kt:25-28`** : aucune stratégie de downgrade → APK plus ancien sur DB v14 = crash `IllegalStateException` au lieu de dégradation contrôlée.
- **m19 — `data/local/AppDatabase.kt:36-37`** : `version=14, exportSchema=false`, migrations non snapshotées → dérives indétectables en CI.
## Priorité moyenne (phase 2) ### Sync contrat / OCR
- **m20 — `data/repository/OcrRepository.kt:66-73`** : `poll()` infini (`while(true)` + 3s, sans timeout) alors qu'un job peut rester `processing` longtemps (stale claim serveur) → coroutine tenue indéfiniment.
- **m21 — `data/repository/OutboxRepository.kt:72-147`** : ops contrat non émissibles (`update_metadata`, `update_share`, `create_link`, `revoke_link` — §6.1 = 9 ops, helpers partiels) → rename partagé, update share, liens publics inopérants.
- `DeviceID` login non validé `^[0-9a-f]{32}$` (`backend/handlers/auth.go:50` vs `devices.go:23`), `folderId/fileId/token` jamais validés hex avant DB. ---
- `POST /sync/ops` non borné (`backend/handlers/sync.go`) : pas de `MaxBytesReader`, pas de cap batch (client=20) → DoS OOM.
- `ParentResourceID/ToFolder` non validés hex → mal classés `NOT_FOUND`.
- `UpdateNameByID`, `TouchResource` non scopés owner (reposent que sur l'appelant) — TOCTOU.
- `Revoke/RevokeLink` : erreurs swallow `_ =` → masque vraies pannes (`backend/service/sync.go:306-309,359-361`).
- OCR : `Create` owner-only mais `GetFileOcr` viewer+, `Get` job scopé `device_id` → 2e device du même user = 404. PDF ignore `ctx`, pas de cap taille/pages, stderr (avec paths) exposé (`backend/ocr/tesseract.go:47-66`).
- `passwd.Verify` parse `m=` du hash stocké sans cap → ligne DB compromise = OOM Argon2 au login (`backend/pkg/passwd/passwd.go:74-88`).
- `POST /devices` public sans rate-limit → remplissage table. `MarkUser` permet à n'importe qui de claim n'importe quel `device_id` (`backend/repository/devices.go:36-42`).
- `getInt` sans range check (PORT/WORKERS/MAX négatifs acceptés) (`backend/config/config.go:64-70`).
- `ChangePassword` ne révoque pas les tokens (fenêtre 7j) (`backend/handlers/auth.go:113-151`).
- `expiresAt` passé accepté pour shares/links → grants instantanément expirés.
- `Snapshot/ListOwned` `LIMIT 10000` sans pagination → troncation silencieuse (`backend/repository/shares.go:199`, `resources.go:547`).
- Positif : pas d'injection SQL trouvée (tout en `$n`, `sortClause` whitelist).
## Plan proposé ## 🛠️ Plans de correction (reliquat) — ✅ implémentés le 2026-09-24
1. **P0 robustesse** : ordre routes, cycle move, idempotence `CreateLink`, transaction `ApplyBatch`, secret requis en prod, sanit `extension` + cleanup orphelins. Ordre suivi : M13 → M5 → M27+m21 → M9 → mineurs par lot (m1+m2, m5, m7, m20, m15+m19).
2. **P1 data** : fix `Count()` soft-deleted, corriger migrations 000007/000008, supprimer stubs, mapper erreurs sans fuite. Écarts d'implémentation vs plan : M13 sans rewrite (colonne restée nullable, défaut Kotlin 1 + backfill — pas de bump de contrainte) ; m7 `COLLATE NOCASE` sans colonne normalisée (repli Unicode « ete » → « ÉTÉ » toujours ouvert, voir suivi) ; M27 `cachedAt` persisté = heure locale du pull (pas l'horloge serveur, skew).
3. **P2 durcissement** : validation hex systématique, cap `sync/ops`, rate-limit login/devices, cap Argon2 + PDF/OCR, scope `Touch/UpdateName`, pagination snapshot.
## À compléter (pour le relecteur) ### M5 — `deleteInCloud` sans tombstone locale
Fichiers : `features/saf/FileDeleter.kt:88-104`, `features/saf/FolderDeleter.kt:91-103` (+ descendants via `collectDescendants`).
Constat : `deleteInCloud` enqueue `delete_resource` mais laisse `exists = 1` ; la ressource reste affichée et le walk la revoit.
Plan :
1. Dans `FileDeleter.deleteInCloud`, après `enqueueDeleteResource`, appeler `fileRepository.markMissing(resourceId, now)` dans la même transaction Room (ou `appDatabase.withTransaction` comme `deleteFull`).
2. Dans `FolderDeleter.deleteInCloud`, idem pour le dossier ET sa descendance Room (`treeMarkMissing`-léger : `markMissing` sur fichiers + sous-dossiers, sans `delete_resource` supplémentaire sauf si `hasSyncedCreateOperation`).
3. Vérifier que le walk ne ressuscite pas : les lignes `exists = 0` + `delete_resource` pending doivent être ignorées par la réconciliation (garde `hasPendingDeleteOperation`, cf. `OutboxRepository.kt:204`).
4. UI : vérifier que les listes filtrent `exists = 1` (déjà le cas) → la ligne disparaît aussitôt.
Tests : étendre `ProcessedGateTest` ou nouveau `DeleteInCloudTest` — `deleteInCloud` puis assert `exists == 0` + op `delete_resource` présente ; walk simulé ne ressuscite pas.
- Ajouter nouveaux bugs ci-dessous avec `fichier:ligne`, sévérité, explication courte. ### M9 — `FolderMerger` multi-transactions non-atomique
- Ne pas supprimer les entrées existantes, juste append ou annoter. Fichier : `features/saf/FolderMerger.kt:53-106`.
- Idées à creuser : `handlers/files.go` (`intParam`, `q` non borné), `service/resources.go:164` (filename brut comme `name`, mime verbatim), `repository/resources.go` (parent check puis UPDATE non-atomique → FK 500), `cmd/server/main.go` (double pool, `conn` jamais `Close`, worker OCR non attendu), `pkg/auth` (TTL 7j sans refresh/révocation). Constat : `createMergedFolder` (transaction 1), moves (N transactions via `FileMover`/`reparentSubFolders`), deletes (N transactions). Un crash à mi-fusion laisse un état partiel ; la relance est idempotente (dossier réutilisé) mais ne reprend pas les moves manquants proprement.
Plan :
1. Envelopper `mergeSelectedFolders` dans `appDatabase.withTransaction` pour la partie Room (create + reparent + `treeMarkMissing`) — nécessite d'injecter `AppDatabase` dans `FolderMerger` et de rendre `FileMover.moveFiles` / `reparentSubFolders` appelables dans une transaction existante (ou journaliser les `move_resource`/`delete_resource` dans la transaction et n'exécuter le SAF physique qu'avant/après selon le sens crash-safe : journal-first comme C4).
2. Ordre crash-safe : (a) transaction Room = create + moves logiques + deletes logiques (`exists = 0` + outbox), (b) exécution SAF physique (moves + deletes), (c) sweep au prochain tick pour les physiques manqués (réutiliser `sweepPendingPhysicalDeletes`).
3. Garder l'idempotence `findExistingMerged` pour les relances.
4. À défaut d'une transaction unique (SAF non transactionnel), a minima : rendre chaque étape reprise-safe (skip les sources déjà vides, skip les moves déjà journalisés via `hasPendingMoveOperation`).
Tests : nouveau `FolderMergerTest` — fusion 2 dossiers avec fichiers + sous-dossier, assert `movedFiles/deletedFolders`, relance idempotente (pas de doublon), crash simulé entre étape 2 et 3 → reprise sans perte.
### Ajouts relecteur (2026-09-21, vérifié en lecture) ### M13 — `exists: Int? = null` invisible
Fichiers : `data/local/entity/FolderEntity.kt:36`, `data/local/entity/FileEntity.kt:46`, DAO (`FolderDao`, `FileDao` filtres `= 1`), `Migrations.kt` (créations tables sans `DEFAULT 1` / `NOT NULL`).
Constat : toute ligne insérée sans `exists` explicite (défaut Kotlin `null`) est cachée par les requêtes `WHERE exists = 1`.
Plan :
1. Durcir les entités : `exists: Int = 1` (non-null, défaut 1) dans `FolderEntity` et `FileEntity`.
2. Migration v14→v15 : `UPDATE folders SET exists = 1 WHERE exists IS NULL`, idem `files`, puis recréation ou `NOT NULL DEFAULT 1` (Room : via `autoMigrations` ou SQL `ALTER` + table rewrite selon la version SQLite ; le plus simple : `UPDATE` + contrainte applicative + défaut entité, sans rewrite si Room accepte le changement nullable→non-null via migration manuelle avec recréation de table).
3. Auditer tous les `saveFolder`/`saveLocalFile`/`upsertShared*` pour passer `exists = 1` explicitement.
4. Option : ajouter un test `ExistsDefaultTest` — insert sans `exists`, assert visible dans `observeByFolder`/`searchWithFilters`.
Note : migration à tester via `Migration13To14Test`-style (nouveau `Migration14To15Test`) + `:app:testDebugUnitTest`.
> Nota : entrées existantes conservées. Ci-dessous uniquement des ajouts. ### M27 — snapshot permissions sans delta ni `canAccess`
> Annotation §1 : `GET /files/folders` vs `GET /files/:id` — Gin privilégie Fichiers : `data/repository/ShareRepository.kt:44-47`, `data/remote/dto/Dtos.kt:144-156` (`sharedById`/`expiresAt: Any?`), `data/remote/ApiService.kt:74-78`, `ApiClient.kt:106-108`.
> les segments statiques sur `:param` dans son arbre, donc l'ordre de Constat : `syncPermissions()` sans `after`, champs `sharedById`/`expiresAt` jamais lus, `cachedAt` jamais persisté, aucun downgrade TTL 24h ni `canAccess` → grants révoqués/expirés visibles jusqu'au prochain login.
> déclaration (`router.go:29-32`) ne masque pas forcément `folders` en Plan :
> pratique. Reste fragile (dépend du routeur) : à verrouiller par un test 1. DTO : typer `sharedById: String?`, `expiresAt: Long?` (le serveur renvoie ms epoch ou null — vérifier `docs/api-v1.md §6.2` et adapter avec un adapter Moshi tolérant `Any?`→Long).
> `GET /files/folders → 200` + `GET /files/<32hex> → 200/404`, pas par l'ordre. 2. Persistance : stocker `cachedAt`/`expiresAt`/`sharedById`/`effectiveAccess` — soit colonnes sur `files`/`folders`, soit nouvelle table `resource_permissions` (préférable : ne pas polluer les entités). A minima `user_preferences` : `permissions_cached_at`.
3. Delta : `syncSnapshot(after: Long? = cachedAt)` → `apiClient.syncPermissions(after)` ; pull complet (`after = null`) au login/restauration + quand `now - cachedAt > 24h` (TTL).
4. Expiration locale : au tick, marquer `exists = 0` les lignes dont `expiresAt < now` ; downgrade lecture seule après TTL sans reseed (gate `canAccess` : à exposer via `ShareRepository.canAccess(resourceId, required)` utilisé par les VM avant open/share/rename).
5. `canAccess` : ranking viewer < commenter < editor < owner, `ownerId == currentUser` → owner.
Tests : étendre `ShareRepositoryTest` — delta `after`, révocation (absent du snapshot → `markMissing`), expiration (`expiresAt` passé → masqué), `canAccess` ranking.
#### A1 — CRITIQUE : bypass dummy-password + panic nil-deref au login ### m1+m2 — badge sync et réveils WorkManager
- `backend/pkg/passwd/passwd.go:37-43,98-103` + `backend/handlers/auth.go:55-83` Fichier : `features/sync/SyncViewModel.kt:100-137`.
- `VerifyTimedEqual("", dummy)` vérifie contre `Hash("kazier-constantime-dummy")` Plan :
en dur. `username=<inconnu> + password="kazier-constantime-dummy"` → `Verify` 1. m1 : envelopper le corps de boucle dans `try { … } finally { _walkInProgress.value = false }` (comme `importRoot:173-176`), et sortir `syncSnapshot` de la fenêtre `_walkInProgress` (flag séparé ou `syncing` = walk || drain déjà calculé via WorkManager).
retourne `nil` → suite du handler avec `user == nil` → `user.ID:83` panic 2. m2 : n'enqueuer `OutboxSyncWorker`/`OcrAutoWorker` que si le tick a produit quelque chose (`results.any { folders+files+missing > 0 }` ou `pendingOperationDao.countPending() > 0` / fichier promu). Éviter les réveils /30s à vide.
(Gin recovery → 500). Effets : DoS à la demande + oracle 500 vs 401 qui casse Tests : Robolectric `SyncViewModelTest` — annulation du scope → flag retombe ; tick sans changement → `WorkManager` non sollicité (mock/static ou extraction d'un `SyncScheduler` testable).
l'indistinguabilité revendiquée + préimage hardcodée en source. Fix :
dummy aléatoire par boot (ou hash du mot fourni à sel fixe) + ne jamais
toucher `user` si `userErr != nil`.
#### A2 — Upload : `file.Size` fait confiance au header, `io.Copy` illimité ### m5 — walk : transaction géante + `getAll()` par racine
- `backend/service/resources.go:135,178-195` (service) vs `backend/handlers/files.go:119-133` (handler) Fichier : `features/sync/DeviceSync.kt:67-163`.
- Le handler protège le transport (`MaxBytesReader`), mais l'invariant Plan :
service est absent : header menteur → écriture disque illimitée. Envelopper 1. Découper la phase 2 : upserts dossiers/fichiers par batch (ex. 200) en transactions courtes successives au lieu d'une transaction unique ; la réconciliation `missing` en passe séparée.
`src` dans `io.LimitReader` + re-contrôler les octets écrits. 2. Remplacer `folderRepository.getAll()` + `fileRepository.getAll()` (full-table scan par racine) par des requêtes scopées à la racine (`getByRootUri`/`getDescendants`) — à ajouter aux DAO avec index sur `uri` (déjà unique) ; filtrer en SQL plutôt qu'en mémoire (`isChildOf` en `LIKE rootUri || '/%'`).
3. Conserver le `Mutex` single-flight ; vérifier `ensureActive()` dans les boucles longues pour annulation propre.
Tests : `SafScannerTest`-style perf — 5k fichiers simulés, assert temps/absence d'ANR ; test de convergence identique avant/après.
#### A3 — Upload non-atomique, torn reads OCR ### m7 — recherche `LIKE` sans `ESCAPE`
- `backend/service/resources.go:154-157,178-195` Fichier : `data/local/dao/FileDao.kt:42-49`.
- `os.Create(dest)` + `io.Copy` direct, overwrite sur place pour Plan : échapper `%`, `_`, `\` dans `:query` côté repository (`searchFiles`) + `LIKE … ESCAPE '\'` dans la requête ; ajouter `COLLATE NOCASE` (ou normalisation) pour « ete » → « ÉTÉ ». Tester : `%`, `_`, `\`, accents, casse.
`targetExisting`. `service/ocr.go` (`Glob`) peut lire un fichier à moitié Tests : `SearchFieldTest` ou nouveau `SearchEscapeTest` — `%` littéral ne matche pas tout, `_` littéral, insensible à la casse.
écrit. Fix : temp + `Rename` (+ `Fsync`).
#### A4 — Fichiers world-readable ### m20 — `OcrRepository.poll()` infini
- `backend/service/resources.go:149-150` : `MkdirAll 0755`, `os.Create` → 0644 Fichier : `data/repository/OcrRepository.kt:66-73`.
selon umask. Données user lisibles sur hôte partagé. Passer en `0700/0600`. Plan : ajouter timeout (ex. 10 min) + nombre max de polls + backoff ; lever `OcrTimeoutException` ou retourner le dernier état ; coopérer avec l'annulation (`ensureActive`). Mettre à jour les appelants (viewer auto) pour afficher « OCR indisponible, réessayer ».
- Positif vérifié : pas de traversal via `ownerID/resourceID` (32-hex issus Tests : `OcrRepositoryTest` — job restant `processing` → timeout au bout de N polls (fake `ApiClient` + virtual time/delays courts).
token/serveur), `UPLOAD_DIR` = config admin.
#### A5 — `NewID()` panic sur échec entropie ### m15+m19 — robustesse DB (downgrade + `exportSchema`)
- `backend/repository/resources.go:23-29` : `panic` si `crypto/rand` échoue → Fichiers : `di/DatabaseModule.kt:25-28`, `data/local/AppDatabase.kt:31-38`.
crash serveur entier. Retourner `(string,error)`. Plan :
1. m19 : `exportSchema = true` + `schemas/` commité ; ajouter un test `Migration13To14Test`-style qui échoue en cas de dérive (CI).
2. m15 : stratégie downgrade explicite et documentée — soit `fallbackToDestructiveMigrationOnDowngrade()` (avec avertissement perte de données locales, acceptable car miroir SAF + outbox non poussée à préserver → plutôt refuser le démarrage avec message), soit crash contrôlé avec écran « mettez à jour l'app ». Choisir et documenter ; ne jamais laisser `IllegalStateException` brut.
Tests : build avec `exportSchema=true` + `room.schemaLocation` ; test downgrade (ouverture v15 avec APK v14 → comportement attendu).
#### A6 — `ShareLinkGet` compare avec `==` au lieu de `errors.Is` ### m21 — ops contrat non émissibles
- `backend/handlers/share_links.go:23` (tous les autres handlers via Fichiers : `data/repository/OutboxRepository.kt:72-147`, `data/local/entity/PendingOperationEntity.kt:76-86` (constantes déjà présentes : `UPDATE_METADATA`, `UPDATE_SHARE`, `CREATE_LINK`, `REVOKE_LINK`).
`writeError` utilisent `errors.Is`) : `ErrNotFound` wrappé → 500 au lieu de Plan : ajouter `enqueueUpdateMetadata(resourceId, resourceType, name?)`, `enqueueUpdateShare(...)`, `enqueueCreateLink(resourceId, resourceType, token, access, expiresAt?)`, `enqueueRevokeLink(...)` avec payloads §6.1 (`granteeUserId/access/inherit/expiresAt`, `token/access/expiresAt`) ; brancher les appelants (rename partagé, update share, liens publics) ; `GenerateId` pour `token` 32-hex côté client.
404, sur endpoint public non-authentifié → oracle 500/404. Tests : `OutboxSyncWorkerTest`-style — sérialisation payload, `normalizePayloadNumbers` (`expiresAt` Long exact, non `1.7E12`), round-trip `POST /sync/ops` mocké.
#### A7 — Incohérences contrat / parsing silencieux (mineurs mais réels) ---
- `backend/handlers/auth.go:94-96` : `ExpiresAt = Now()+TTL` seconde lecture
d'horloge, pas le `exp` du token (dérive ms).
- `backend/handlers/auth.go:90` : code `TOKEN_ERROR` non-standard.
- `backend/handlers/files.go:114-117,50-53` : 32-hex malformé → `404`, vs
`backend/handlers/devices.go:23-26` → `400 INVALID_DEVICE_ID`.
- `backend/handlers/files.go:13-22` + `backend/handlers/sync.go:43-47` :
`intParam` invalide/négatif → `fallback` silencieux ; `after` garbage →
`0` = full snapshot au lieu de 400. `Atoi` 32-bit overflow pour epoch-ms.
- `backend/handlers/middleware.go:29` : préfixe `Bearer ` case-sensitive.
#### A8 — Sémantiques silencieuses outbox (désync grantees + fuite d'existence) ## ✅ Vérifié infondé (suspects écartés)
- `backend/service/sync.go:180-202` : `update_metadata` cible absente → `nil` - Single-flight `Mutex` présent (`DeviceSync.kt:49`), `enqueueUniqueWork(KEEP)` + batch 20 + `ORDER BY id` conformes — non-bugs.
marqué *applied* (client croit le rename fait) vs `<editor` → `ErrNotFound` - `checkHealth` construit bien `{base}/health` avec base incluant `/api/v1` = route backend `GET /api/v1/health` — OK.
(batch halté). Incohérent. - Token **non** stocké en clair (`EncryptedSharedPreferences` AES256-SIV/GCM + Keystore) — seul `TokenProvider.current` en mémoire, normal.
- `backend/service/sync.go:204-222` : `move`/`delete` sur ressource partagée - Ordre interceptors `serverUrl → auth → logging`, `BASIC` ne log ni headers ni bodies — OK.
non-owned → no-op silencieux marqué applied → client grantee désync. - Contrat HTTP conforme sur endpoints déclarés (query `folderId/page/pageSize`, `deviceId` camel vs `device_id` login, multipart `file`/`resourceId`/`folderId`, enveloppes `{data,meta}`/`{error:{code,message}}`, codes) — OK.
- `backend/service/sync.go:152-178` : `ExistsOwner` (own seul) puis `Insert` ; - `device_id` claim jamais utilisé comme preuve, seul le `Bearer` parle — conforme middleware.
id d'autrui deviné → PK globale → `23505 → ErrNameConflict` - Worker no-op en mode local (`OutboxSyncWorker.kt:111`), batch 20 ≤ 100 serveur, statuts OCR, `resolveUser` trim compatible, password jamais trimé — OK.
(`repository/resources.go:143-146`) = oracle d'existence cross-user. + TOCTOU - Deep-links : aucun défini (absence, pas de bug) ; args nav `folderResourceId`/`documentResourceId`/`ids` cohérents, 32-hex sans `/`.
`Exists→Insert`. - Hilt : `MainActivity @AndroidEntryPoint`, tous `hiltViewModel()` ↔ `@HiltViewModel`, scopes corrects — aucune injection manquante.
- Pas de recomposition infinie trouvée ; `collectAsStateWithLifecycle` partout ; placeholder cloud-only correct (`DocumentContentViewer.kt:39-47`) ; recherche 100 % locale conforme V1 ; back stack onglets correct (`saveState`/`restoreState`) ; `SelectionState` volatile documenté volontaire.
#### A9 — Replay à payload muté avalé - Scan : pas de double-`recycle` draft, pas de double rotation EXIF (comportement correct, commentaire trompeur), `swapOrder` args corrects, FK `scan_pages→sessions CASCADE` actif.
- `backend/service/sync.go:109-115` + `backend/repository/operations.go:44-50`
(`ON CONFLICT DO NOTHING`) : même `(device,op)` avec payload différent =
skip « succès », nouvelle intention dropée sans comparaison de hash.
#### A10 — `UpdatePassword` / `MarkDeleted` sans garde
- `backend/repository/users.go:87-103` : pas de `AND deleted_at IS NULL`, pas
de check `RowsAffected` → re-hash d'un compte soft-deleted, succès
silencieux sur id inconnu / course avec `MarkDeleted`.
#### A11 — `OcrJobs` : transitions sans garde
- `backend/repository/ocr_jobs.go:60-67,112-128` : `TouchProcessing`,
`Complete`/`Fail` sans garde de statut ni `RowsAffected` → `queued→done`,
`done→failed`, double-complete silencieux. `ResetStaleProcessing:100-110`
sur horloge app (skew DB), lignes `processing` à `started_at NULL` jamais
requeued. `ClaimNext:72-95` correct atomiquement mais sans index composite
`(status,created_at)` → scan O(queue).
#### A12 — `physicalPath` via `Glob` sans vérification fichier
- `backend/service/ocr.go:142-153` : symlink/répertoire/`id.` acceptés ;
symlink hors `UPLOAD_DIR` suivi par tesseract. Faire `Lstat + IsRegular +
EvalSymlinks`-containment. `lang` (`ocr/tesseract.go:30`, depuis `OCR_LANG`)
non whitelisté (argv, pas de shell — worst case erreur tesseract).
#### A13 — OCR : causes avalées, `done` trompeur
- `backend/service/ocr.go:113-138` : `Fail("file not readable")` sans `err`,
`Complete`/`UpdateOcrText` partiellement log-only → job `done` alors que
`ocr_text` non persisté ; `GET /files/:id/ocr` renvoie `""` 200
indistinguable de « pas encore extrait ».
- `backend/ocr/tesseract.go:29-45,47-67` : pas de timeout par job (ctx = vie
serveur), stdout/stderr non bornés → OOM, pages PDF en erreur `continue`
silencieusement → texte partiel vu comme complet, pas de cap taille/pages.
#### A14 — `main.go` : lifecycle / concurrence boot
- `backend/cmd/server/main.go:44-51,59` : `db.Open` + `MigrateDatabase` (qui
ouvre son propre pool) = double pool ; `conn` jamais `Close` ; migrations
DDL à chaque boot (rôle runtime devrait être DML-only en prod).
- `backend/service/bootstrap.go:25-47` : double réplica sur DB vide →
duplicate `username_normalized` → un réplica `Fatal`, pas de retry.
#### A15 — Complément device/token (étend § moyenne existant)
- Vérifié : `pkg/auth/auth.go:54-67` `Verify` n'impose pas `^[0-9a-f]{32}$` ;
`handlers/middleware.go:46-62` vérifie que le user existe mais jamais le
device (hex ni `Exists`) → tokens à device supprimé/jamais-enregistré
passent l'auth, 500 plus tard (FK). `repository/operations.go:36-51`
valide `operation_id` mais pas `device_id` ; payloads vides/`"null"`/invalides
normalisés en `{}` (`60-68`) au lieu d'être rejetés → trace infidèle.
#### A16 — Idées à creuser : conclusions
- `handlers/files.go:q` : `TrimSpace` + `!= ""` ok, mais pas de longueur maxi
→ `ILIKE %…%` géant = full scan (index trigram manquant,
`repository/resources.go:297,327`). `page/pageSize` cappés à 200 côté
handler, mais `(page-1)*pageSize` non cappé + repo sans validation
(`repository/resources.go:170-227`, `LIMIT` négatif → 500).
- `service/resources.go:159,164` : confirmé — `file.Filename` brut comme `name`
(sauts de ligne, 255+ chars, unicode) + `Content-Type` verbatim comme mime,
sans whitelist/normalisation.
- `repository/resources.go:124-147,374-403` : confirmé — `folderExists(SELECT)`
puis `INSERT`/`UPDATE` non-atomique → parent supprimé entre les deux = 500
FK ou orphelin.
- `cmd/server/main.go` : confirmé ci-dessus (A14) + worker OCR non attendu au
shutdown (5s puis exit, jobs `processing` → requeue au prochain boot via
`ResetStaleProcessing`, ok mais à documenter).
- `pkg/auth` : TTL 7j sans refresh/révocation confirmé par design
(`auth.go:13`, `handlers/auth.go:110-112`) ; `iat=nbf=now`, `exp` vérifié via
`NewParserForValidNow` (`auth.go:55`) — correct, pas de bug ici au-delà du
secret (A-suite § haute prio n°4) et du format non validé (A15).
## Validation (2026-09-21, autre agent — suite verte)
`go build ./...` OK. `go test ./...` : 11 packages OK, 0 fail
(`cmd/server, config, db, handlers, ocr, pkg/api, pkg/auth, pkg/passwd,
repository, service`). Les 4 échecs transitoires vus pendant l'édition
concurrente (RecordNormalizes, MarkDeleted, UploadSanitizes,
UpdateMetadata/Move) ne se reproduisent plus — tests alignés sur la
nouvelle sémantique.
### Haute priorité : tout corrigé
- §1 route `folders` : réordonnée avant `:id` + tests d'ordre (durcissement,
Gin préférait déjà le statique).
- #2 cycle : `checkNoCycle` (walk `GetParentID` ≤128) + `MoveResource`
atomique. Manque : pas de test cycle dédié.
- #3 `CreateLink` : `ON CONFLICT DO NOTHING` + même ressource → no-op,
sinon `NAME_CONFLICT`. Tests rejeu/conflit OK.
- #4 secret : défaut allongé (≥32), refusé en prod (`APP_ENV/ENV`),
`len<32` rejeté. Reste : dev boot sur défaut public (assumé).
- #5/#6/A2/A3/A4 upload : ext whitelistée, `LimitReader` octets réels,
temp+`Rename`+`Fsync`, `0700/0600`, cleanup stale/orphelins. Tests OK.
- #7 batch : `Claim`/`MarkApplied` + `applied:i/INTERNAL` explicites.
Documenté non-transactionnel (vrai Tx reportée).
- #8 fuites : `classifySyncError` générique + log serveur. OK côté sync.
- #9 `Count` : `WHERE deleted_at IS NULL`, bootstrap recrée l'admin. OK.
- #10 migrations : `000007` sans `DELETE`, `000008 down` sans `::bigint`
crash, + `000011/12/13` saines. Up/down OK.
- #11 stubs : `folders/move/upload/move_test` supprimés, 0 réf. OK.
- #12 oracle : device inconnu → `401` identique + rate-limit 60/min/IP. OK.
- A1 dummy : random 32B/boot + guard `user==nil → 401` + caps Argon2. OK.
### Moyens : corrigé, 3 partiels assumés
- A6 `errors.Is`, A8 sémantiques (absent → no-op, étranger → `NOT_FOUND`
halt), A9 rejeu (`payload_hash` 000013 + `ErrInvalidPayload`), A10 users
guards, A11 jobs gardés, A12 path containment + lang whitelist, A13 OCR
(timeout 120s, 2MiB, 50 pages), A7/A16 contrat : tous OK.
- Partiels : `EnforceDeviceExists` opt-in **défaut `false`** (tokens à
device inconnu passent toujours par défaut) ; `NewID()` panic conservé
(migration appelants partielle) ; double pool `main.go` subsiste ;
`POST /devices` sans rate-limit (TODO assumé).
- Reste : `UpdateNameByID`/`TouchResource` non scopés encore appelés
(`TouchOwned`/`UpdateNameOwned` ajoutés, migration appelants reportée).
### Risques résiduels à trancher
1. Activer `EnforceDeviceExists` par défaut (casse tokens existants —
planifier rotation).
2. Vrai Tx `ApplyBatch` (fenêtre TOCTOU admise, couverte par idempotence).
3. Rate-limit `POST /devices` + test cycle dédié manquant.
### Addendum validation v2 (autres tâches finalisées)
`go build ./...` OK, `go test ./...` vert (12 packages, dont
`handlers 9.6s`, `repository 3.4s`, `service 9.9s`).
Nouveautés depuis v1, toutes validées :
- `handlers/store.go` : `writeError` défaut → `500 INTERNAL "internal error"`
générique + `log` serveur (plus de `err.Error()` brut) — clôt #8 côté
handlers.
- `handlers/sync.go` : `POST /sync/ops` borné (`MaxBytesReader` 1 MiB, max
100 ops/batch → 400 explicite) + `parseAfterMs` strict 64-bit
(garbage/négatif → 400, fini le repli silencieux vers full snapshot) —
clôt le gap « sync non borné ».
- `repository/devices.go` : `MarkUser` → `ErrNotFound` si 0 rows (fini le
no-op silencieux sur device fantôme ; la course `Exists→MarkUser` est
désormais distinguable). Résiduel mineur : `handlers/auth.go` mappe
encore cette erreur vers 500 au lieu de 401.
- Nouveaux tests : `handlers/ocr_test.go`, `handlers/sync_test.go`,
`repository/devices_test.go` — tous verts.
Restent ouverts : `EnforceDeviceExists=false` par défaut, vrai Tx
`ApplyBatch`, rate-limit `POST /devices`, test cycle dédié.
## Suite (2026-09-21, fin des restes — suite verte)
`go build ./...` OK, `go vet ./...` OK, `go test ./...` : 12 packages OK, 0 fail.
Nouveaux tests exécutés nominalement (`-run` ciblé) : `TestApplyBatchMoveIntoDescendantRejected`,
`TestDevicesRegisterRateLimited`, `TestSyncOpsBatchTooLargeRejected`,
`TestDevicesMarkUserUnknownDevice`, `TestIssueWithExpiryMatchesTokenExp`.
- **#8 fuite `writeError`** : défaut `500` → message générique `"internal error"`
+ `log.Printf` serveur (`handlers/store.go:20-33`). Plus aucun `err.Error()`
brut vers le client (sync déjà générique, `response.go` déjà enveloppe).
- **A7 `ExpiresAt`** : `pkg/auth.IssueWithExpiry` retourne le `exp` embarqué ;
`AuthLogin` l'expose tel quel (plus de `Now()+TTL` recalculé). `Issue`
conservée (délègue) → 0 appelant cassé. Test d'égalité à la seconde
(le token sérialise sans monotonique/sous-seconde).
- **`MarkUser`** : `RowsAffected == 0 → ErrNotFound`
(`repository/devices.go:36-42`) ; login mappe en **401 indistinguable**
(jamais de token pour device fantôme). Test repo ajouté.
- **`TouchOwned` migré** : les 4 `TouchResource` des paths share/revoke/link
→ `TouchOwned(ownerID, …)` (tous précédés de `ExistsOwner`). `UpdateNameByID`
**conservé volontairement** pour `update_metadata` (un editor non-owner peut
renommer — `UpdateNameOwned` rejetterait à tort ; garde d'accès juste avant
l'écriture). Commentaires `Deprecated`/inter-lots mis à jour.
- **Test cycle** : `TestApplyBatchMoveIntoDescendantRejected` (parent→enfant →
`INVALID_REQUEST`, parent toujours à la racine). Point 3 des risques soldé
côté cycle.
- **Rate-limit `POST /devices`** : 300/min/IP → 429 `RATE_LIMITED` + hook
`OnDevicesRateLimited` + `ResetDevicesRateLimit` (placé APRÈS validation :
l'invalide ne consomme pas le budget). Resets ajoutés aux helpers de test
(`files_test.go setup`, `auth_test.go setTestAuth`, `ocr_test.go setupOcr` —
ce dernier manquait et faisait échouer `TestOcrJobsScopedByOwner` en 429,
corrigé). Budget large assumé : anti-flood massif, WAF frontal en prod.
- **Cap `POST /sync/ops`** : `MaxBytesReader` 1 MiB + max 100 ops/batch → 400
`INVALID_REQUEST` (client = 20, test 25 ops existant compatible).
Test `TestSyncOpsBatchTooLargeRejected` (101 ops → 400).
### Reste assumé (inchangé, documenté)
- `EnforceDeviceExists` défaut `false` ; `NewID()` panic conservé
(`NewIDErr` dispo) ; double pool `main.go` (migrate-avant-open, un seul
vivant) ; vraie Tx `ApplyBatch` reportée (idempotence couvre la fenêtre).
+1 -1
View File
@@ -29,5 +29,5 @@ cd mobile-kotlin && ./gradlew :app:testDebugUnitTest
| Backend entry | `backend/cmd/server/main.go` — wiring gin + routes | | Backend entry | `backend/cmd/server/main.go` — wiring gin + routes |
| Sync outbox | `mobile-kotlin/.../features/sync/OutboxSyncWorker.kt` — worker WorkManager → `POST /sync/ops` | | 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 | | 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) | | API Retrofit | `mobile-kotlin/.../data/remote/ApiService.kt` — interface Retrofit (contrat client) |
-137
View File
@@ -1,137 +0,0 @@
# Découpage parallèle — Backend Kazier
Source : `FEEDBACK.md` (12 + A1-A16). But : 6 lots preneurs en parallèle, **zéro chevauchement de fichiers**.
Règle : chaque lot ne touche QUE ses fichiers. Si besoin transverse → note dans `Besoins inter-lots`, ne pas éditer hors lot.
Commande vérif par lot : `cd backend && go test ./...` (ou package ciblé). DB tests : `TEST_DATABASE_URL` si PG dispo, sinon skip OK.
---
## LOT 1 — AUTH critique (A1, #4, #12, A15-part)
**Fichiers exclusifs :**
- `backend/pkg/passwd/passwd.go`
- `backend/pkg/auth/auth.go`
- `backend/config/config.go`
- `backend/handlers/auth.go`
- `backend/handlers/middleware.go`
**Tâches :**
1. A1 : `dummyHash` aléatoire par boot (plus de `"kazier-constantime-dummy"` en dur). `AuthLogin` : early-return si `userErr != nil`, ne jamais toucher `user.ID` quand nil. Ajouter test : login user inconnu + password dummy → 401, pas 500.
2. #4 : `AUTH_SECRET` : refuser défaut `dev-secret-change-me` en prod (ex. `if ENV=prod && secret==défaut → Fatal`), exiger longueur ≥ 32, doc `.env.example`.
3. #12 : casser l'oracle : même code/délai que device existe ou non (vérifier device AVANT ou uniformiser 401). Ajouter rate-limit basique ou hook (même no-op + TODO).
4. A15-part : `Verify` : rejeter `userID/deviceID` non `^[0-9a-f]{32}$`. Middleware : option `EnforceDeviceExists` (défaut off, documenté) ou au moins log.
**Ne pas toucher :** `handlers/devices.go` (LOT 6), `repository/*` (LOT 4).
**Acceptance :** `go test ./pkg/passwd/... ./pkg/auth/... ./handlers/...` OK + test regression A1.
---
## LOT 2 — UPLOAD safe (A2, A3, A4, #5, #6, A16-part)
**Fichiers exclusifs :**
- `backend/service/resources.go`
- `backend/handlers/files.go`
**Tâches :**
1. #5 : sanit `extension` : `[a-z0-9]{1,10}` lowercase, sinon `""` ou `bin`. `destPath` sans `ext` si vide (pas de `id.`). Rejeter `/`, `..`, très long.
2. A2 : service : `io.LimitReader(src, MaxFileSize+1)` + vérifier octets écrits, retourner `ErrFileTooLarge` même si header ment.
3. A3 : écriture atomique : temp `destDir/.tmp-<id>` + `Fsync` + `Rename`. Pas d'overwrite direct.
4. #6 : au `UpdatePhysical` : lister `Glob(id.*)` ancien, `Remove` les autres ext. Sur `Insert` fail → `Remove(destPath)`. Sur `GetFile` fail après insert → tenter cleanup, au moins log.
5. A4 : `MkdirAll 0700`, fichier `0600` (`OpenFile` + `Chmod`). Vérifier umask.
6. A16-part : `file.Filename` → `name` : `TrimSpace`, cap 255, rejeter vide/`/`/`\n`. `Content-Type` : whitelist ou fallback `application/octet-stream`. `intParam/page/pageSize` : cap + 400 si négatif (pas fallback silencieux), `q` : `MaxLen 200`.
**Acceptance :** tests service upload : header menteur, ext vide/malicieuse, re-upload change ext → un seul fichier physique, perms 0600/0700.
---
## LOT 3 — SYNC core (#3, #7, A8, A9)
**Fichiers exclusifs :**
- `backend/service/sync.go`
- `backend/repository/operations.go`
- `backend/repository/shares.go`
**Tâches :**
1. #7 : rendre `ApplyBatch` atomique par op : `SELECT ... FOR UPDATE` ou transaction `Applied→apply→Record`. `Record` fail → retourner `applied:i` explicite, pas 500 nu.
2. #3 : `CreateLink` idempotent : `ON CONFLICT (id) DO NOTHING` + vérifier owner identique, sinon `NAME_CONFLICT`.
3. A9 : stocker `payload_hash (sha256)` dans `operations`, au replay même `(device,op)` comparer hash : différent → `INVALID_REQUEST` (pas skip silencieux). Migration `000011`.
4. A8 : uniformiser sémantiques : `update_metadata` absent → `NOT_FOUND` halt (pas no-op applied) ; `move/delete` non-owned → `NOT_FOUND` (pas applied silencieux) ; documenter choix. `create` : `ExistsOwner` + `Insert` en transaction ou `ON CONFLICT DO NOTHING` + check owner.
5. `classifySyncError` : ne plus fuir `err.Error()` brut (#8-part) : messages génériques + log interne.
**Ne pas toucher :** `repository/resources.go` (LOT 4) — si besoin, exposer interface, pas d'édit direct.
**Acceptance :** tests `service/sync_test.go` : replay même op, replay payload muté, create_link rejoué, move/delete grantee.
---
## LOT 4 — DATA ownership + migrations (#9, #10, A10, + parent-check)
**Fichiers exclusifs :**
- `backend/repository/users.go`
- `backend/repository/resources.go`
- `backend/repository/devices.go`
- `backend/service/bootstrap.go`
- `backend/db/migrations/*`
- `backend/db/db.go` (lecture seule sauf si besoin migration)
**Tâches :**
1. #9+A10 : `Count()` → `WHERE deleted_at IS NULL`. `UpdatePassword/MarkDeleted/GetByID` : ajouter `AND deleted_at IS NULL` + check `RowsAffected` → `ErrNotFound` si 0.
2. #10 : `000007` : supprimer `DELETE FROM resources` (backfill `owner_id` via user admin ou colonne nullable + migration douce). `000008 down` : down sans `::bigint` (ex. recréer colonne bigint + drop text, ou marquer irréversible avec message clair).
3. Parent-check atomique : `InsertFolder/InsertFile/MoveResource` : `INSERT ... SELECT` ou transaction `SELECT parent FOR SHARE → INSERT`, FK 500 → mapper `NOT_FOUND`.
4. `TouchResource/UpdateNameByID` : ajouter variantes scopées `TouchOwned(ownerID,...)`, `UpdateNameOwned(...)`, laisser anciennes en `deprecated` (LOT 3 migrera ensuite).
5. `NewID()` (A5) : retourner `(string,error)` OU `MustNewID` + `NewIDErr`. Choisir une signature, mettre à jour appelants **uniquement dans ces fichiers**.
**Acceptance :** `go test ./repository/... ./service/... ./db/...` + test soft-deleted login/bootstrap.
---
## LOT 5 — OCR + INFRA (A11, A12-part, A13, A14, #11)
**Fichiers exclusifs :**
- `backend/service/ocr.go`
- `backend/repository/ocr_jobs.go`
- `backend/ocr/*`
- `backend/cmd/server/main.go`
- `backend/service/services.go`, `move.go`, `upload.go`, `folders.go` (suppression)
**Tâches :**
1. #11 : supprimer les 4 stubs `UserCan*` toujours-true.
2. A11 : transitions gardées : `Complete/ Fail WHERE status='processing'`, `TouchProcessing WHERE status='queued'`, check `RowsAffected`. `ResetStaleProcessing` sur horloge DB (`now() - interval`), inclure `started_at IS NULL`. Ajouter index `(status,created_at)` (migration `000012` — coordonner nom avec LOT 4 pour éviter collision : LOT 5 prend `000012`, LOT 4 prend `000011`, LOT 3 payload_hash prend `000013`).
3. A13 : `Fail` avec `err`, `Complete` vérifie `UpdateOcrText RowsAffected`, sinon `Fail`. `tesseract.go` : `context.WithTimeout` par job (ex. 120s), `LimitReader` stdout/stderr (ex. 2MB), cap pages PDF (ex. 50) + erreur si tronqué, pas `continue` silencieux.
4. A12-part : `physicalPath` : `Lstat`, `IsRegular`, `EvalSymlinks` ∈ `UPLOAD_DIR`. `OCR_LANG` : whitelist `^[a-z+]{2,20}$`.
5. A14 : `main.go` : un seul pool (réutiliser `conn` pour migrate), `defer conn.Close()`, worker OCR avec `WaitGroup` + shutdown 5s documenté. Bootstrap : retry duplicate `username_normalized` ou `ON CONFLICT DO NOTHING`.
**Acceptance :** `go test ./ocr/... ./service/... ./repository/...` + test double-complete, stale requeue.
---
## LOT 6 — CONTRACT + DEVICE (A6, A7, §1 route, devices, secret-doc)
**Fichiers exclusifs :**
- `backend/handlers/router.go`
- `backend/handlers/share_links.go`
- `backend/handlers/sync.go`
- `backend/handlers/devices.go`
- `backend/handlers/health.go` (tests seulement si besoin)
- `backend/cmd/server/router_test.go`
- `backend/pkg/api/response.go` (messages génériques seulement)
**Tâches :**
1. §1 : réordonner `GET /files/folders` avant `GET /files/:id` + test `folders→200`, `:id=folders→404` (verrouille, même si Gin priorise statique).
2. A6 : `ShareLinkGet` : `errors.Is(err, ErrNotFound)`.
3. A7 : `ExpiresAt` : utiliser `exp` du token (retourner `Auth` ou parser), pas `Now()+TTL`. `TOKEN_ERROR` → `INTERNAL`. 32-hex malformé → `400 INVALID_REQUEST` partout (aligner `files.go` sur `devices.go`). `intParam/after` : 400 si garbage/négatif (pas fallback 0), `Atoi` 64-bit pour epoch-ms. `Bearer` : accepter `bearer` case-insensitive (option).
4. Devices : `POST /devices` : rate-limit/TODO + doc. `MarkUser` : check `RowsAffected` (device supprimé → 404).
5. `response.go` : messages génériques côté client, détail en log serveur (#8-part lot 6).
**Acceptance :** `router_test.go` étendu + tests handlers 400/404 cohérents.
---
## Ordre et dépendances
- Démarrage immédiat possible : LOT 1, LOT 2, LOT 5, LOT 6 (aucune dépendance mutuelle).
- LOT 3 et LOT 4 se touchent via `repository/resources.go` : LOT 4 seul l'édite. LOT 3 utilise l'interface existante, migrera vers `*Owned` au tour suivant.
- Migrations : LOT 4 = `000011`, LOT 5 = `000012`, LOT 3 = `000013`. Ne pas réutiliser un numéro.
- `NewID()` signature (LOT 4) : prévenir LOT 2/LOT 3 après merge, pas avant.
## Besoins inter-lots (ne pas éditer, juste signaler)
- LOT 3 → LOT 4 : besoin `TouchOwned/UpdateNameOwned`, `INSERT ... SELECT` parent.
- LOT 5 → LOT 2 : `physicalPath` safe partagé après merge LOT 2.
- Tous → LOT 6 : après uniformisation 400/404, aligner messages d'erreur.
+1 -1
View File
@@ -1 +1 @@
0.1.0 1.0.0
+3
View File
@@ -17,6 +17,9 @@ var expectedRoutes = []string{
"GET /api/v1/files/folders", "GET /api/v1/files/folders",
"GET /api/v1/files/:id", "GET /api/v1/files/:id",
"GET /api/v1/files/:id/ocr", "GET /api/v1/files/:id/ocr",
"GET /api/v1/files/:id/content",
"GET /api/v1/files/:id/shares",
"GET /api/v1/files/:id/links",
"DELETE /api/v1/files/:id", "DELETE /api/v1/files/:id",
"POST /api/v1/files/upload", "POST /api/v1/files/upload",
+27
View File
@@ -107,6 +107,33 @@ func FilesGetOcr(c *gin.Context) {
api.OK(c, dto) api.OK(c, dto)
} }
// FilesContent streame les octets physiques d'un fichier visible (viewer+,
// 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
// metadata-only jamais uploadée) → 404 NOT_FOUND, comme invisible (pas
// d'énumération). V1 streaming : le client ne persiste rien.
func FilesContent(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
}
info, err := Store.OpenContent(userID, id)
if err != nil {
writeError(c, err)
return
}
c.Header("Content-Type", info.MimeType)
c.Header("Content-Disposition", "inline; filename=\""+info.Name+"\"")
c.File(info.Path)
}
func FilesDelete(c *gin.Context) { func FilesDelete(c *gin.Context) {
if Store == nil { if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized") api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
+144
View File
@@ -686,3 +686,147 @@ func TestSearchQTooLong(t *testing.T) {
rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/files/search?q="+string(long), token, nil, "") rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/files/search?q="+string(long), token, nil, "")
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "search-q-too-long") expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "search-q-too-long")
} }
func TestFilesContentStreaming(t *testing.T) {
r, _, repo := setup(t)
ownerDevice := repository.NewID()
ownerToken, owner := registerAndLogin(t, r, repo, testUserUsername(ownerDevice, "ct"), "content-test-password", ownerDevice)
granteeDevice := repository.NewID()
granteeToken, grantee := registerAndLogin(t, r, repo, testUserUsername(granteeDevice, "cg"), "content-test-password-b", granteeDevice)
outsiderDevice := repository.NewID()
outsiderToken, _ := registerAndLogin(t, r, repo, testUserUsername(outsiderDevice, "ch"), "content-test-password-c", outsiderDevice)
// Ressource metadata-only (outbox) puis upload ciblé des octets (≤10o, cf. setup).
fileID := repository.NewID()
if err := repo.Resources.InsertFile(owner, fileID, "note.txt", "", 0, nil, nil); err != nil {
t.Fatalf("insert file: %v", err)
}
rec := uploadMultipartToResource(t, r, ownerToken, fileID, "note.txt", []byte("hello"))
if rec.Code != http.StatusOK {
t.Fatalf("upload ciblé: attendu 200, got %d body=%s", rec.Code, rec.Body.String())
}
// Owner : octets + Content-Type.
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/content", ownerToken, nil, "")
if rec.Code != http.StatusOK {
t.Fatalf("content-owner: attendu 200, got %d body=%s", rec.Code, rec.Body.String())
}
if rec.Body.String() != "hello" {
t.Errorf("content-owner = %q, attendu %q", rec.Body.String(), "hello")
}
if ct := rec.Header().Get("Content-Type"); ct == "" {
t.Errorf("content-owner: Content-Type manquant")
}
// Grantée viewer : mêmes octets (résolution dir owner, pas requester).
if err := repo.Shares.Upsert(fileID, grantee, "viewer", false, nil, owner); err != nil {
t.Fatalf("share: %v", err)
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/content", granteeToken, nil, "")
if rec.Code != http.StatusOK || rec.Body.String() != "hello" {
t.Errorf("content-grantee: attendu 200 hello, got %d %q", rec.Code, rec.Body.String())
}
// Outsider : 404 (pas d'énumération).
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/content", outsiderToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "content-outsider")
// Metadata-only sans octets : 404 (jamais uploadé).
bareID := repository.NewID()
if err := repo.Resources.InsertFile(owner, bareID, "vide.txt", "", 0, nil, nil); err != nil {
t.Fatalf("insert bare: %v", err)
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+bareID+"/content", ownerToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "content-no-bytes")
// ID invalide → 404 ; sans token → 401.
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/not-hex/content", ownerToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "content-invalid-id")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/content", "", nil, "")
if rec.Code != http.StatusUnauthorized {
t.Errorf("content-sans-token: attendu 401, got %d", rec.Code)
}
}
func TestFilesSharesLinksListing(t *testing.T) {
r, _, repo := setup(t)
ownerDevice := repository.NewID()
ownerToken, owner := registerAndLogin(t, r, repo, testUserUsername(ownerDevice, "sl"), "shares-list-password", ownerDevice)
granteeDevice := repository.NewID()
granteeToken, grantee := registerAndLogin(t, r, repo, testUserUsername(granteeDevice, "sg"), "shares-list-password-b", granteeDevice)
outsiderDevice := repository.NewID()
outsiderToken, _ := registerAndLogin(t, r, repo, testUserUsername(outsiderDevice, "sh"), "shares-list-password-c", outsiderDevice)
fileID := repository.NewID()
if err := repo.Resources.InsertFile(owner, fileID, "shared.txt", "", 4, nil, nil); err != nil {
t.Fatalf("insert file: %v", err)
}
// Vide au départ (pas d'erreur).
rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/shares", ownerToken, nil, "")
env := expectOK(t, rec, "shares-empty")
var emptyShares []map[string]any
if err := json.Unmarshal(env.Data, &emptyShares); err != nil {
t.Fatalf("shares-empty: unmarshal: %v", err)
}
if len(emptyShares) != 0 {
t.Errorf("shares-empty = %d grants, attendu 0", len(emptyShares))
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/links", ownerToken, nil, "")
env = expectOK(t, rec, "links-empty")
var emptyLinks []map[string]any
if err := json.Unmarshal(env.Data, &emptyLinks); err != nil {
t.Fatalf("links-empty: unmarshal: %v", err)
}
if len(emptyLinks) != 0 {
t.Errorf("links-empty = %d links, attendu 0", len(emptyLinks))
}
// Un grant + un lien côté serveur (comme après des ops `share`/`create_link`).
if err := repo.Shares.Upsert(fileID, grantee, "editor", true, nil, owner); err != nil {
t.Fatalf("share: %v", err)
}
linkToken := repository.NewID()
if err := repo.Shares.CreateLink(linkToken, fileID, "viewer", nil, owner); err != nil {
t.Fatalf("create link: %v", err)
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/shares", ownerToken, nil, "")
env = expectOK(t, rec, "shares-owner")
var grants []struct {
GranteeUserID string `json:"granteeUserId"`
Username string `json:"username"`
Access string `json:"access"`
}
if err := json.Unmarshal(env.Data, &grants); err != nil {
t.Fatalf("shares-owner: unmarshal: %v", err)
}
if len(grants) != 1 || grants[0].GranteeUserID != grantee || grants[0].Access != "editor" || grants[0].Username == "" {
t.Errorf("shares-owner = %+v, attendu 1 grant editor du grantee", grants)
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/links", ownerToken, nil, "")
env = expectOK(t, rec, "links-owner")
var links []struct {
Token string `json:"token"`
Access string `json:"access"`
}
if err := json.Unmarshal(env.Data, &links); err != nil {
t.Fatalf("links-owner: unmarshal: %v", err)
}
if len(links) != 1 || links[0].Token != linkToken || links[0].Access != "viewer" {
t.Errorf("links-owner = %+v, attendu 1 lien viewer", links)
}
// Granté et outsider : 404 (pas d'énumération).
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/shares", granteeToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "shares-grantee")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/links", granteeToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "links-grantee")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/shares", outsiderToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "shares-outsider")
// ID invalide → 404.
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/not-hex/shares", ownerToken, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "shares-invalid-id")
}
+3
View File
@@ -33,6 +33,9 @@ func RegisterRoutes(r *gin.Engine) {
protected.GET("/files/folders", FoldersList) protected.GET("/files/folders", FoldersList)
protected.GET("/files/:id", FilesGet) protected.GET("/files/:id", FilesGet)
protected.GET("/files/:id/ocr", FilesGetOcr) protected.GET("/files/:id/ocr", FilesGetOcr)
protected.GET("/files/:id/content", FilesContent)
protected.GET("/files/:id/shares", SharesList)
protected.GET("/files/:id/links", LinksList)
protected.DELETE("/files/:id", FilesDelete) protected.DELETE("/files/:id", FilesDelete)
protected.POST("/files/upload", FilesUpload) protected.POST("/files/upload", FilesUpload)
+52
View File
@@ -0,0 +1,52 @@
package handlers
import (
"net/http"
"github.com/gin-gonic/gin"
"github.com/kazier/backend/pkg/api"
)
// SharesList exposes the active user-to-user grants of a resource the caller
// OWNS : GET /files/:id/shares. Non-owner (or unknown resource) → 404
// NOT_FOUND (no enumeration, same scoping as the share outbox ops).
func SharesList(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
}
grants, err := Store.ListShares(userID, id)
if err != nil {
writeError(c, err)
return
}
api.OK(c, grants)
}
// LinksList exposes the active public links of a resource the caller OWNS :
// GET /files/:id/links. Same owner-only scoping as SharesList.
func LinksList(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
}
links, err := Store.ListLinks(userID, id)
if err != nil {
writeError(c, err)
return
}
api.OK(c, links)
}
+44
View File
@@ -455,5 +455,49 @@ func (s *Shares) ListActiveLinksForResource(resourceID string) ([]LinkInfo, erro
return links, rows.Err() return links, rows.Err()
} }
// ShareGrant is one active user-to-user grant on a resource (owner view).
type ShareGrant struct {
GranteeUserID string
Username string
Access string
Inherit bool
ExpiresAt *time.Time
UpdatedAt time.Time
}
// ListActiveForResource returns the active (non-revoked) grants on a resource,
// oldest first. Expired grants are included (the owner sees what will lapse);
// the caller filters display. Empty (not error) when nothing is shared.
func (s *Shares) ListActiveForResource(resourceID string) ([]ShareGrant, error) {
rows, err := s.DB.Query(
`SELECT s.grantee_user_id, COALESCE(u.username, s.grantee_user_id),
s.access, s.inherit, s.expires_at, s.updated_at
FROM shares s
LEFT JOIN users u ON u.id = s.grantee_user_id AND u.deleted_at IS NULL
WHERE s.resource_id = $1 AND s.revoked_at IS NULL
ORDER BY s.created_at ASC`,
resourceID,
)
if err != nil {
return nil, err
}
defer rows.Close()
var grants []ShareGrant
for rows.Next() {
var (
g ShareGrant
expiresAt sql.NullTime
)
if err := rows.Scan(&g.GranteeUserID, &g.Username, &g.Access, &g.Inherit, &expiresAt, &g.UpdatedAt); err != nil {
return nil, err
}
if expiresAt.Valid {
g.ExpiresAt = &expiresAt.Time
}
grants = append(grants, g)
}
return grants, rows.Err()
}
// Errors specific to shares. // Errors specific to shares.
var ErrGranteeNotFound = errors.New("grantee user not found") var ErrGranteeNotFound = errors.New("grantee user not found")
+60
View File
@@ -146,6 +146,66 @@ type FileOcrDTO struct {
UpdatedAt string `json:"updatedAt,omitempty"` UpdatedAt string `json:"updatedAt,omitempty"`
} }
// ContentInfo describes the physical bytes of a file the user can see
// (viewer+, own or shared) for GET /files/:id/content (streaming lecture,
// jamais persisté côté client en V1 streaming).
type ContentInfo struct {
Path string
Name string
MimeType string
Size int64
}
// OpenContent resolves the physical file of a visible resource. Auth is
// viewer+ (GetFileVisible, own or shared) ; the bytes live under the OWNER
// dir (UPLOAD_DIR/<owner_id>/<resource_id>.<ext>), never under the requester.
// No physical file (metadata-only outbox resource, never uploaded) →
// repository.ErrNotFound (handler maps to 404 NOT_FOUND, same as invisible).
func (s *Resources) OpenContent(userID, resourceID string) (ContentInfo, error) {
row, err := s.Repo.GetFileVisible(userID, resourceID)
if err != nil {
return ContentInfo{}, err
}
ownerID, err := s.Repo.GetResourceOwner(resourceID)
if err != nil {
return ContentInfo{}, err
}
if !idPattern.MatchString(ownerID) || !idPattern.MatchString(resourceID) {
return ContentInfo{}, repository.ErrNotFound
}
base, err := filepath.EvalSymlinks(s.UploadDir)
if err != nil {
return ContentInfo{}, repository.ErrNotFound
}
matches, err := filepath.Glob(filepath.Join(s.UploadDir, ownerID, resourceID+".*"))
if err != nil {
return ContentInfo{}, repository.ErrNotFound
}
for _, m := range matches {
if !strings.HasPrefix(filepath.Base(m), resourceID+".") {
continue
}
fi, err := os.Lstat(m)
if err != nil || !fi.Mode().IsRegular() {
continue
}
resolved, err := filepath.EvalSymlinks(m)
if err != nil {
continue
}
rel, err := filepath.Rel(base, resolved)
if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(os.PathSeparator)) {
continue
}
mime := row.MimeType
if mime == "" {
mime = "application/octet-stream"
}
return ContentInfo{Path: resolved, Name: row.Name, MimeType: mime, Size: fi.Size()}, nil
}
return ContentInfo{}, repository.ErrNotFound
}
// GetFileOcr returns the OCR text of a file the user can see (viewer+, own or // GetFileOcr returns the OCR text of a file the user can see (viewer+, own or
// shared). Absent text → Text empty ("") with 200 (the caller decides). // shared). Absent text → Text empty ("") with 200 (the caller decides).
func (s *Resources) GetFileOcr(ownerID, id string) (FileOcrDTO, error) { func (s *Resources) GetFileOcr(ownerID, id string) (FileOcrDTO, error) {
+98
View File
@@ -0,0 +1,98 @@
package service
import (
"time"
"github.com/kazier/backend/repository"
)
// ShareGrantDTO serializes one active grant for GET /files/:id/shares.
// Milliseconds epoch (null = never), mirroring the permissions snapshot
// (docs/api-v1.md §6.2) for cheap client-side expiry checks.
type ShareGrantDTO struct {
GranteeUserID string `json:"granteeUserId"`
Username string `json:"username"`
Access string `json:"access"`
Inherit bool `json:"inherit"`
ExpiresAt *int64 `json:"expiresAt"`
UpdatedAt int64 `json:"updatedAt"`
}
// LinkDTO serializes one active public link for GET /files/:id/links —
// same shape as the public GET /shares/links/:token resolution.
type LinkDTO struct {
Token string `json:"token"`
ResourceID string `json:"resource_id"`
ResourceType string `json:"resourceType"`
Name string `json:"name"`
Access string `json:"access"`
ExpiresAt *string `json:"expiresAt"`
}
// ListShares returns the active grants on a resource the user OWNS.
// Non-owner (or unknown resource) → repository.ErrNotFound (no enumeration,
// same scoping as the share outbox ops).
func (s *Resources) ListShares(userID, resourceID string) ([]ShareGrantDTO, error) {
ownerID, err := s.Repo.GetResourceOwner(resourceID)
if err != nil {
return nil, err
}
if ownerID != userID {
return nil, repository.ErrNotFound
}
grants, err := s.Repository.Shares.ListActiveForResource(resourceID)
if err != nil {
return nil, err
}
out := make([]ShareGrantDTO, 0, len(grants))
for _, g := range grants {
var expires *int64
if g.ExpiresAt != nil {
ms := g.ExpiresAt.UnixMilli()
expires = &ms
}
out = append(out, ShareGrantDTO{
GranteeUserID: g.GranteeUserID,
Username: g.Username,
Access: g.Access,
Inherit: g.Inherit,
ExpiresAt: expires,
UpdatedAt: g.UpdatedAt.UnixMilli(),
})
}
return out, nil
}
// ListLinks returns the active public links of a resource the user OWNS.
// Same owner-only scoping as ListShares.
func (s *Resources) ListLinks(userID, resourceID string) ([]LinkDTO, error) {
ownerID, err := s.Repo.GetResourceOwner(resourceID)
if err != nil {
return nil, err
}
if ownerID != userID {
return nil, repository.ErrNotFound
}
links, err := s.Repository.Shares.ListActiveLinksForResource(resourceID)
if err != nil {
return nil, err
}
out := make([]LinkDTO, 0, len(links))
for _, l := range links {
var expires *string
if l.ExpiresAt != nil {
// Même forme que ShareLinkGet (time.Time marshaled en RFC3339).
str := l.ExpiresAt.UTC().Format(time.RFC3339)
expires = &str
}
out = append(out, LinkDTO{
Token: l.Token,
ResourceID: l.ResourceID,
ResourceType: l.ResourceType,
Name: l.Name,
Access: l.Access,
ExpiresAt: expires,
})
}
return out, nil
}
+51
View File
@@ -0,0 +1,51 @@
# Déploiement perso — pull l'image depuis le registre Gitea (pas de build local).
#
# Usage sur le serveur :
# 1. cp .env.prod.example .env.prod && adapter (mots de passe forts, jamais commité)
# 2. echo "<PAT read:package>" | docker login gitea.thirdshop.fr -u <user> --password-stdin
# 3. docker compose -f docker-compose.prod.yml --env-file .env.prod pull
# 4. docker compose -f docker-compose.prod.yml --env-file .env.prod up -d
# 5. curl http://localhost:${PORT:-8080}/api/v1/health
#
# MAJ : répéter pull + up -d (ou tag précis via VERSION=x.y.z).
services:
postgres:
image: postgres:17-alpine
environment:
POSTGRES_DB: ${POSTGRES_DB:-kazier}
POSTGRES_USER: ${POSTGRES_USER:-kazier}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?POSTGRES_PASSWORD requis (.env.prod)}
volumes:
- postgres-data:/var/lib/postgresql/data
restart: unless-stopped
healthcheck:
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-kazier}"]
interval: 10s
timeout: 5s
retries: 5
backend:
# Image publiée par la release Gitea (tag vX.Y.Z + latest).
image: ${REGISTRY_IMAGE:-gitea.thirdshop.fr/thirdshop/kazier}:${VERSION:-latest}
ports:
- "${PORT:-8080}:8080"
environment:
PORT: 8080
DATABASE_URL: postgres://${POSTGRES_USER:-kazier}:${POSTGRES_PASSWORD:?POSTGRES_PASSWORD requis}@postgres:5432/${POSTGRES_DB:-kazier}?sslmode=disable
UPLOAD_DIR: /app/uploads
MAX_FILE_SIZE_MB: ${MAX_FILE_SIZE_MB:-50}
OCR_LANG: ${OCR_LANG:-fra+eng}
AUTH_SECRET: ${AUTH_SECRET:?AUTH_SECRET requis (.env.prod)}
ADMIN_USERNAME: ${ADMIN_USERNAME:?ADMIN_USERNAME requis au premier démarrage}
ADMIN_PASSWORD: ${ADMIN_PASSWORD:?ADMIN_PASSWORD requis au premier démarrage}
volumes:
- backend-uploads:/app/uploads
depends_on:
postgres:
condition: service_healthy
restart: unless-stopped
volumes:
postgres-data:
backend-uploads:
+4 -1
View File
@@ -37,6 +37,7 @@ Références : `V2.md` (modèle cible), `mobile/services/db/` (conventions sync)
| PATCH | `/users/me/password` | `{ "current_password", "new_password" }` | `{ "id" }` | `INVALID_PASSWORD` (403) | | PATCH | `/users/me/password` | `{ "current_password", "new_password" }` | `{ "id" }` | `INVALID_PASSWORD` (403) |
| GET | `/files` | query `folderId?`, `page?`, `pageSize?`, `sort?` | `FileDto[]` (+ `meta`) | — | | GET | `/files` | query `folderId?`, `page?`, `pageSize?`, `sort?` | `FileDto[]` (+ `meta`) | — |
| GET | `/files/:id` | — | `FileDto` | `NOT_FOUND` | | 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` | — | `{ "id": "…" }` | `NOT_FOUND` |
| GET | `/files/search` | query `q` (obligatoire), `page?`, `pageSize?` | `FileDto[]` (+ `meta`) | — | | GET | `/files/search` | query `q` (obligatoire), `page?`, `pageSize?` | `FileDto[]` (+ `meta`) | — |
| GET | `/files/folders` | — | `FolderDto[]` (racines) | — | | GET | `/files/folders` | — | `FolderDto[]` (racines) | — |
@@ -44,6 +45,8 @@ Références : `V2.md` (modèle cible), `mobile/services/db/` (conventions sync)
| POST | `/ocr/jobs` | `{ "fileId": "…" }` | `OcrJob` | — | | POST | `/ocr/jobs` | `{ "fileId": "…" }` | `OcrJob` | — |
| GET | `/ocr/jobs/:id` | — | `OcrJob` | `NOT_FOUND` | | GET | `/ocr/jobs/:id` | — | `OcrJob` | `NOT_FOUND` |
| GET | `/files/:id/ocr` | — | `FileOcr` (`{ text, updatedAt }`) | `NOT_FOUND` | | GET | `/files/:id/ocr` | — | `FileOcr` (`{ text, updatedAt }`) | `NOT_FOUND` |
| GET | `/files/:id/shares` | — (owner uniquement) | `ShareGrant[]` (`{ granteeUserId, username, access, inherit, expiresAt (ms\|null), updatedAt (ms) }`) | `NOT_FOUND` (non-owner ou inconnue — pas d'énumération) |
| GET | `/files/:id/links` | — (owner uniquement) | `ShareLink[]` (même forme que `GET /shares/links/:token`) | `NOT_FOUND` (non-owner ou inconnue) |
| POST | `/sync/ops` | voir §6 | voir §6 | — | | POST | `/sync/ops` | voir §6 | voir §6 | — |
| GET | `/sync/permissions` | query `after?` (cached_at ms) | `ResourcePermission[]` | — | | GET | `/sync/permissions` | query `after?` (cached_at ms) | `ResourcePermission[]` | — |
@@ -119,7 +122,7 @@ type FileOcr = { text: string; updatedAt?: string | null };
- `revoke_link` : `payload = { "token": "…32-hex" }`. **Idempotent**. - `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. - 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`.** - 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/<token>` (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=<cached_at_ms>` ### 6.2 Snapshot — `GET /sync/permissions?after=<cached_at_ms>`
+25 -2
View File
@@ -21,9 +21,32 @@ set -euo pipefail
./gradlew :app:assembleDebug -q ./gradlew :app:assembleDebug -q
APK="app/build/outputs/apk/debug/app-debug.apk" APK="app/build/outputs/apk/debug/app-debug.apk"
if [ "${usage_target?}" = "emulator" ]; then if [ "${usage_target?}" = "emulator" ]; then
adb -e install -r "$APK" ADB_FLAGS=(-e)
else else
adb -d install -r "$APK" ADB_FLAGS=(-d)
fi
# adb natif s'il fonctionne (PATH + binaire exécutable sur cet OS)...
if command -v adb >/dev/null 2>&1 && adb version >/dev/null 2>&1; then
adb "${ADB_FLAGS[@]}" install -r "$APK"
# ...sinon repli NixOS : l'adb du SDK est un binaire FHS dynamiquement
# lié, on l'exécute via steam-run (cf. local.properties pour sdk.dir).
elif command -v steam-run >/dev/null 2>&1; then
SDK_DIR="${ANDROID_SDK_ROOT:-${ANDROID_HOME:-}}"
if [ -z "$SDK_DIR" ] && [ -f local.properties ]; then
SDK_DIR="$(sed -n 's/^sdk\.dir=//p' local.properties | head -n 1)"
fi
if [ -z "$SDK_DIR" ] && [ -d "$HOME/Android/Sdk" ]; then
SDK_DIR="$HOME/Android/Sdk"
fi
if [ -z "$SDK_DIR" ] || [ ! -x "$SDK_DIR/platform-tools/adb" ]; then
echo "adb introuvable : définissez ANDROID_HOME ou sdk.dir dans local.properties." >&2
exit 1
fi
export LD_LIBRARY_PATH="${LD_LIBRARY_PATH:-}:$HOME/.nix-profile/lib:/run/opengl-driver/lib"
steam-run "$SDK_DIR/platform-tools/adb" "${ADB_FLAGS[@]}" install -r "$APK"
else
echo "adb ne fonctionne pas sur cet OS et steam-run est absent (NixOS)." >&2
exit 1
fi fi
''' '''
+5
View File
@@ -84,6 +84,11 @@ android {
} }
} }
// m19 : export du schéma Room (`app/schemas/`) pour détecter les dérives en CI.
ksp {
arg("room.schemaLocation", "$projectDir/schemas")
}
dependencies { dependencies {
implementation(libs.androidx.core.ktx) implementation(libs.androidx.core.ktx)
implementation(libs.androidx.lifecycle.runtime.ktx) implementation(libs.androidx.lifecycle.runtime.ktx)
@@ -0,0 +1,730 @@
{
"formatVersion": 1,
"database": {
"version": 16,
"identityHash": "ec10fdb23d5da3a76a73222e9c404561",
"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, `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": "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, `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": "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, 'ec10fdb23d5da3a76a73222e9c404561')"
]
}
}
@@ -41,6 +41,16 @@
<action android:name="android.intent.action.MAIN" /> <action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" /> <category android:name="android.intent.category.LAUNCHER" />
</intent-filter> </intent-filter>
<!-- Liens de partage `kazier://share/<token>` (32-hex) : ouverture
dans l'écran de résolution (route publique, sans auth). -->
<intent-filter>
<action android:name="android.intent.action.VIEW" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
<data
android:scheme="kazier"
android:host="share" />
</intent-filter>
</activity> </activity>
</application> </application>
@@ -24,8 +24,10 @@ class MainActivity : ComponentActivity() {
super.onCreate(savedInstanceState) super.onCreate(savedInstanceState)
enableEdgeToEdge() enableEdgeToEdge()
lifecycleScope.launch { themePreferenceStore.load() } // m37 : le contenu n'est posé qu'une fois le thème persisté chargé —
// avant, le défaut SYSTEM flashait aux premières frames.
lifecycleScope.launch {
themePreferenceStore.load()
setContent { setContent {
val theme by themePreferenceStore.theme.collectAsStateWithLifecycle() val theme by themePreferenceStore.theme.collectAsStateWithLifecycle()
KazierTheme(theme = theme) { KazierTheme(theme = theme) {
@@ -34,3 +36,4 @@ class MainActivity : ComponentActivity() {
} }
} }
} }
}
@@ -15,16 +15,20 @@ import javax.inject.Singleton
* Persistance chiffrée du token paseto et du profil compte (Keystore + AES). * Persistance chiffrée du token paseto et du profil compte (Keystore + AES).
* Miroir de `services/secureStore.ts` (expo-secure-store). Le token n'est * Miroir de `services/secureStore.ts` (expo-secure-store). Le token n'est
* JAMAIS écrit en clair dans SQLite. * JAMAIS écrit en clair dans SQLite.
*
* L'init Keystore/`EncryptedSharedPreferences` est paresseuse (m28) : aucun
* I/O au construct Hilt — le premier accès a lieu sur le thread de l'appelant
* ([SessionManager] bascule sur `Dispatchers.IO`).
*/ */
@Singleton @Singleton
class SecureTokenStore @Inject constructor( class SecureTokenStore @Inject constructor(
@ApplicationContext context: Context, @ApplicationContext private val context: Context,
moshi: Moshi, moshi: Moshi,
) { ) : TokenStore {
private val userAdapter: JsonAdapter<UserDto> = moshi.adapter(UserDto::class.java) private val userAdapter: JsonAdapter<UserDto> = moshi.adapter(UserDto::class.java)
private val prefs: SharedPreferences = run { private val prefs: SharedPreferences by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
val masterKeyAlias = MasterKeys.getOrCreate(MasterKeys.AES256_GCM_SPEC) val masterKeyAlias = MasterKeys.getOrCreate(MasterKeys.AES256_GCM_SPEC)
EncryptedSharedPreferences.create( EncryptedSharedPreferences.create(
FILE_NAME, FILE_NAME,
@@ -35,29 +39,52 @@ class SecureTokenStore @Inject constructor(
) )
} }
fun getToken(): String? = prefs.getString(KEY_TOKEN, null) override fun getToken(): String? = prefs.getString(KEY_TOKEN, null)
fun getUser(): UserDto? { override fun getUser(): UserDto? {
val raw = prefs.getString(KEY_ACCOUNT, null) ?: return null val raw = prefs.getString(KEY_ACCOUNT, null) ?: return null
return runCatching { userAdapter.fromJson(raw) } return runCatching { userAdapter.fromJson(raw) }
.getOrNull() .getOrNull()
?.takeIf { it.id.isNotEmpty() && it.username.isNotEmpty() } ?.takeIf { it.id.isNotEmpty() && it.username.isNotEmpty() }
} }
fun save(token: String, user: UserDto) { override fun getExpiresAt(): Long? =
prefs.getLong(KEY_EXPIRES_AT, -1L).takeIf { it >= 0L }
override fun getCredentials(): Credentials? {
val username = prefs.getString(KEY_USERNAME, null)?.takeIf { it.isNotBlank() } ?: return null
val password = prefs.getString(KEY_PASSWORD, null)?.takeIf { it.isNotEmpty() } ?: return null
return Credentials(username, password)
}
override fun saveCredentials(username: String, password: String) {
prefs.edit().putString(KEY_USERNAME, username).putString(KEY_PASSWORD, password).apply()
}
override fun clearCredentials() {
prefs.edit().remove(KEY_USERNAME).remove(KEY_PASSWORD).apply()
}
override fun save(token: String, user: UserDto, expiresAt: Long?) {
prefs.edit() prefs.edit()
.putString(KEY_TOKEN, token) .putString(KEY_TOKEN, token)
.putString(KEY_ACCOUNT, userAdapter.toJson(user)) .putString(KEY_ACCOUNT, userAdapter.toJson(user))
.apply {
if (expiresAt != null) putLong(KEY_EXPIRES_AT, expiresAt) else remove(KEY_EXPIRES_AT)
}
.apply() .apply()
} }
fun clear() { override fun clear() {
prefs.edit().remove(KEY_TOKEN).remove(KEY_ACCOUNT).apply() prefs.edit().remove(KEY_TOKEN).remove(KEY_ACCOUNT).remove(KEY_EXPIRES_AT).apply()
} }
companion object { companion object {
private const val FILE_NAME = "kazier_secure" private const val FILE_NAME = "kazier_secure"
private const val KEY_TOKEN = "kazier.auth_token" private const val KEY_TOKEN = "kazier.auth_token"
private const val KEY_ACCOUNT = "kazier.account" private const val KEY_ACCOUNT = "kazier.account"
private const val KEY_EXPIRES_AT = "kazier.expires_at"
private const val KEY_USERNAME = "kazier.auth_username"
private const val KEY_PASSWORD = "kazier.auth_password"
} }
} }
@@ -1,46 +1,201 @@
package com.kazier.mobile.auth package com.kazier.mobile.auth
import com.kazier.mobile.data.local.dao.PendingOperationDao
import com.kazier.mobile.data.remote.ApiClient import com.kazier.mobile.data.remote.ApiClient
import com.kazier.mobile.data.remote.dto.LoginResponseDto import com.kazier.mobile.data.remote.ApiException
import com.kazier.mobile.data.remote.dto.UserDto
import com.kazier.mobile.data.repository.AuthRepository
import com.kazier.mobile.domain.ActiveUserStore import com.kazier.mobile.domain.ActiveUserStore
import com.kazier.mobile.domain.DeviceIdentity
import com.kazier.mobile.domain.LocalModeStore import com.kazier.mobile.domain.LocalModeStore
import javax.inject.Inject import javax.inject.Inject
import javax.inject.Singleton import javax.inject.Singleton
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.SharedFlow
import kotlinx.coroutines.flow.asSharedFlow
import kotlinx.coroutines.launch
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlinx.coroutines.withContext
import timber.log.Timber
/** Événements de session vers l'UI (re-login silencieux, lot 3). */
sealed interface AuthEvent {
/** Le token a été renouvelé sans action utilisateur — rester connecté. */
data class Reauthenticated(val user: UserDto) : AuthEvent
/** Plus de session récupérable — afficher le login (pré-rempli si possible). */
data class SessionExpired(val username: String?) : AuthEvent
}
/** /**
* Orchestration de la session (restauration/sauvegarde/purge) : relie le store * Orchestration de la session (restauration/sauvegarde/purge) : relie le store
* sécurisé, le miroir `active_user_id` et le token en mémoire lu par * sécurisé, le miroir `active_user_id` et le token en mémoire lu par
* `AuthInterceptor`. Le drapeau « mode local » est persisté à part * `AuthInterceptor`. Le drapeau « mode local » est persisté à part
* ([LocalModeStore]) pour survivre aux redémarrages. * ([LocalModeStore]) pour survivre aux redémarrages.
*
* Le callback 401 est possédé ici (singleton, M25) — jamais par un ViewModel :
* après `onCleared`, un token expiré/révoqué continue d'être traité (le worker
* cesse alors de rejouer l'outbox sous un token mort).
*
* Re-login silencieux (lot 3) : les identifiants saisis au login sont
* persistés chiffrés ; sur 401 (ou token expiré détecté en proactif), une
* seule tentative de `POST /auth/login` est jouée (single-flight). Succès →
* [AuthEvent.Reauthenticated] (file conservée si même compte) ; identifiants
* rejetés → purge complète + [AuthEvent.SessionExpired]. La requête en vol
* ayant subi le 401 n'est PAS rejouée — l'appelant la relance (pull, retry).
*/ */
@Singleton @Singleton
class SessionManager @Inject constructor( class SessionManager @Inject constructor(
private val secureTokenStore: SecureTokenStore, private val tokenStore: TokenStore,
private val activeUserStore: ActiveUserStore, private val activeUserStore: ActiveUserStore,
private val tokenProvider: TokenProvider, private val tokenProvider: TokenProvider,
private val localModeStore: LocalModeStore, private val localModeStore: LocalModeStore,
private val pendingOperationDao: PendingOperationDao,
private val apiClient: ApiClient,
private val authRepository: AuthRepository,
) { ) {
/** Restaure la session persistée (si présente), sinon null. */ private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
suspend fun restore(): AuthSession? {
val token = secureTokenStore.getToken() ?: return null /** Single-flight du re-login : N 401 concurrents → 1 seul `POST /auth/login`. */
val user = secureTokenStore.getUser() ?: return null private val reloginMutex = Mutex()
tokenProvider.current = token
return AuthSession(token = token, user = user) private val _events = MutableSharedFlow<AuthEvent>(extraBufferCapacity = 4)
val events: SharedFlow<AuthEvent> = _events.asSharedFlow()
init {
// 401 sur un endpoint protégé (token expiré/révoqué, compte supprimé)
// → re-login silencieux puis purge si irrécupérable. Le 401 du login
// et des routes publiques est exonéré côté ApiClient
// (skipUnauthorizedHandling).
apiClient.onUnauthorized = { handleUnauthorized() }
} }
suspend fun save(token: String, user: com.kazier.mobile.data.remote.dto.UserDto) { /** Restaure la session persistée (si présente), sinon null. */
secureTokenStore.save(token, user) suspend fun restore(): AuthSession? = withContext(Dispatchers.IO) {
val token = tokenStore.getToken() ?: return@withContext null
val user = tokenStore.getUser() ?: return@withContext null
tokenProvider.current = token
AuthSession(token = token, user = user, expiresAt = tokenStore.getExpiresAt())
}
suspend fun save(
token: String,
user: UserDto,
expiresAt: Long? = null,
username: String? = null,
password: String? = null,
) = withContext(Dispatchers.IO) {
val previousUserId = activeUserStore.get()
tokenStore.save(token, user, expiresAt)
if (username != null && password != null) {
tokenStore.saveCredentials(username, password)
}
activeUserStore.set(user.id) activeUserStore.set(user.id)
localModeStore.clear() localModeStore.clear()
tokenProvider.current = token tokenProvider.current = token
// Changement de compte sans sign-out explicite (login de B par
// dessus la session de A) : même purge que `clear()` — la file de
// A ne doit pas partir sous le token de B. Premier login
// (`previousUserId == null`, éventuel travail du mode local) et
// re-login du même compte : file conservée.
if (previousUserId != null && previousUserId != user.id) {
pendingOperationDao.deleteUnpushed()
}
} }
suspend fun clear() { suspend fun clear() = withContext(Dispatchers.IO) {
secureTokenStore.clear() tokenStore.clear()
tokenStore.clearCredentials()
activeUserStore.clear() activeUserStore.clear()
tokenProvider.current = null tokenProvider.current = null
// Sign-out explicite : la file non poussée est abandonnée (C5, voir
// `deleteUnpushed`). Les ops `synced` survivent comme tombstones.
pendingOperationDao.deleteUnpushed()
}
/**
* 401 sur endpoint protégé (appelée depuis le thread OkHttp via
* `ApiClient`) : le token en mémoire tombe synchronement pour ne plus
* émettre de requêtes authentifiées, puis le re-login silencieux est tenté
* en IO (single-flight).
*/
fun handleUnauthorized() {
tokenProvider.current = null
scope.launch {
reloginMutex.withLock { silentReloginLocked() }
}
}
/**
* Re-login proactif (démarrage, retour foreground) : si le token en
* mémoire est absent ou expiré et que des identifiants sont sauvés, tente
* un renouvellement. Vrai si un token frais est disponible au retour.
*/
suspend fun trySilentRelogin(nowMs: Long = System.currentTimeMillis()): Boolean =
withContext(Dispatchers.IO) {
if (tokenProvider.current != null && !isTokenExpired(nowMs)) return@withContext true
reloginMutex.withLock { silentReloginLocked() }
}
/**
* Corps du re-login, sous [reloginMutex]. Vrai si la session est (à
* nouveau) valide. Émet [AuthEvent.Reauthenticated] en cas de succès et
* [AuthEvent.SessionExpired] quand rien n'est récupérable.
*/
private suspend fun silentReloginLocked(): Boolean {
// Re-vérification sous mutex : un re-login concurrent vient peut-être
// de rafraîchir le token pendant l'attente du verrou (N 401 → 1 login).
if (tokenProvider.current != null && !isTokenExpired()) return true
val creds = runCatching { tokenStore.getCredentials() }.getOrNull()
if (creds == null) {
purgeToExpired(username = null)
return false
}
return try {
val response = authRepository.login(creds.username, creds.password)
save(response.token, response.user, response.expiresAt)
Timber.d("auth: re-login silencieux OK pour %s", creds.username)
_events.tryEmit(AuthEvent.Reauthenticated(response.user))
true
} catch (e: Exception) {
if (e is ApiException && e.code == "UNAUTHORIZED") {
// Identifiants rejetés (mot de passe changé ailleurs, compte
// supprimé) : ne plus jamais les rejouer.
Timber.w("auth: re-login rejeté, purge des identifiants")
runCatching { tokenStore.clearCredentials() }
purgeToExpired(username = creds.username)
} else {
// Transitoire (réseau/5xx) : token mort, identifiants conservés
// pour une tentative ultérieure (prochain démarrage/login).
Timber.w(e, "auth: re-login transitoire, session expirée")
purgeToExpired(username = creds.username)
}
false
}
}
/** Purge token + compte actif (file intacte, cf. C5) + événement UI. */
private suspend fun purgeToExpired(username: String?) {
val knownUsername = username ?: runCatching { tokenStore.getUser()?.username }.getOrNull()
tokenProvider.current = null
runCatching { tokenStore.clear() }
runCatching { activeUserStore.clear() }
_events.tryEmit(AuthEvent.SessionExpired(knownUsername))
}
/**
* Pré-relogin : vrai si l'`expires_at` persistée du login est atteinte
* (marge anti-course d'1 min par défaut). L'appelant peut alors reloginer
* avant de subir le 401 brutal (tokens 7 j, m27).
*/
suspend fun isTokenExpired(nowMs: Long = System.currentTimeMillis(), marginMs: Long = 60_000L): Boolean =
withContext(Dispatchers.IO) {
val expiresAt = tokenStore.getExpiresAt() ?: return@withContext false
nowMs + marginMs >= expiresAt
} }
suspend fun isLocalMode(): Boolean = localModeStore.get() suspend fun isLocalMode(): Boolean = localModeStore.get()
@@ -52,5 +207,7 @@ class SessionManager @Inject constructor(
data class AuthSession( data class AuthSession(
val token: String, val token: String,
val user: com.kazier.mobile.data.remote.dto.UserDto, val user: UserDto,
/** Expiration persistée du token (ms epoch) — null si inconnue. */
val expiresAt: Long? = null,
) )
@@ -0,0 +1,41 @@
package com.kazier.mobile.auth
import com.kazier.mobile.data.remote.dto.UserDto
/**
* Persistance du token paseto, du profil compte et de l'expiration du token
* (claim `expires_at` du login, TTL 7 j). Implémentation : [SecureTokenStore]
* (Keystore + AES, jamais en clair dans SQLite).
*
* Les identifiants (username + password) sont persistés à part pour le
* re-login silencieux sur 401 (lot 3) : ils survivent à la purge du token
* ([clear] ne les touche pas) et ne tombent qu'au sign-out explicite
* ([clearCredentials]) ou quand le serveur les rejette (401 au re-login).
*/
interface TokenStore {
fun getToken(): String?
fun getUser(): UserDto?
/** Expiration du token (ms epoch, `expires_at` du login) — null si inconnue. */
fun getExpiresAt(): Long?
fun save(token: String, user: UserDto, expiresAt: Long?)
/** Purge token + compte + expiration — jamais les identifiants. */
fun clear()
/** Identifiants du re-login silencieux — null si jamais connectés. */
fun getCredentials(): Credentials?
fun saveCredentials(username: String, password: String)
fun clearCredentials()
}
/** Identifiants persistés (chiffrés) pour le re-login silencieux. */
data class Credentials(
val username: String,
val password: String,
)
@@ -5,11 +5,13 @@ import androidx.room.RoomDatabase
import com.kazier.mobile.data.local.dao.FileDao import com.kazier.mobile.data.local.dao.FileDao
import com.kazier.mobile.data.local.dao.FolderDao import com.kazier.mobile.data.local.dao.FolderDao
import com.kazier.mobile.data.local.dao.PendingOperationDao import com.kazier.mobile.data.local.dao.PendingOperationDao
import com.kazier.mobile.data.local.dao.ResourcePermissionDao
import com.kazier.mobile.data.local.dao.ScanDao import com.kazier.mobile.data.local.dao.ScanDao
import com.kazier.mobile.data.local.dao.UserPreferenceDao import com.kazier.mobile.data.local.dao.UserPreferenceDao
import com.kazier.mobile.data.local.entity.FileEntity import com.kazier.mobile.data.local.entity.FileEntity
import com.kazier.mobile.data.local.entity.FolderEntity import com.kazier.mobile.data.local.entity.FolderEntity
import com.kazier.mobile.data.local.entity.PendingOperationEntity import com.kazier.mobile.data.local.entity.PendingOperationEntity
import com.kazier.mobile.data.local.entity.ResourcePermissionEntity
import com.kazier.mobile.data.local.entity.ScanPageEntity import com.kazier.mobile.data.local.entity.ScanPageEntity
import com.kazier.mobile.data.local.entity.ScanSessionEntity import com.kazier.mobile.data.local.entity.ScanSessionEntity
import com.kazier.mobile.data.local.entity.UserPreferenceEntity import com.kazier.mobile.data.local.entity.UserPreferenceEntity
@@ -23,14 +25,24 @@ import com.kazier.mobile.data.local.entity.UserPreferenceEntity
* v10: ocr_text sur files (extrait OCR serveur persisté localement) ; * v10: ocr_text sur files (extrait OCR serveur persisté localement) ;
* v11: ocr_attempts + ocr_queued_at sur files (driver OCR auto côté client — * v11: ocr_attempts + ocr_queued_at sur files (driver OCR auto côté client —
* compteur d'échecs terminaux ≤ 3, marqueur « en cours » de l'upload). * compteur d'échecs terminaux ≤ 3, marqueur « en cours » de l'upload).
* v12: device_id sur pending_operations + unicité UNIQUE(device_id,
* operation_id) (contrat outbox docs/api-v1.md §6.1).
* v13: index composites files(exists, processed, sync_status) et
* pending_operations(resource_id, operation, status) (requêtes review/OCR/gates).
* v14: parent_resource_id sur pending_operations (cascade P8).
* v15: backfill exists NULL→1 sur folders/files (M13).
* v16: table resource_permissions (cache snapshot, M27).
*/ */
@Database( @Database(
entities = [ entities = [
FolderEntity::class, UserPreferenceEntity::class, FileEntity::class, FolderEntity::class, UserPreferenceEntity::class, FileEntity::class,
PendingOperationEntity::class, ScanSessionEntity::class, ScanPageEntity::class, PendingOperationEntity::class, ScanSessionEntity::class, ScanPageEntity::class,
ResourcePermissionEntity::class,
], ],
version = 11, version = 16,
exportSchema = false, // 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,
) )
abstract class AppDatabase : RoomDatabase() { abstract class AppDatabase : RoomDatabase() {
@@ -39,4 +51,5 @@ abstract class AppDatabase : RoomDatabase() {
abstract fun fileDao(): FileDao abstract fun fileDao(): FileDao
abstract fun pendingOperationDao(): PendingOperationDao abstract fun pendingOperationDao(): PendingOperationDao
abstract fun scanDao(): ScanDao abstract fun scanDao(): ScanDao
abstract fun resourcePermissionDao(): ResourcePermissionDao
} }
@@ -4,8 +4,11 @@ import com.kazier.mobile.data.local.entity.FileEntity
/** Date de référence d'un fichier : modification SAF quand dispo, sinon ajout local. */ /** Date de référence d'un fichier : modification SAF quand dispo, sinon ajout local. */
val FileEntity.referenceDate: Long val FileEntity.referenceDate: Long
get() = lastModified ?: addedAt get() {
val modified = lastModified
return if (modified != null && modified > 0L) modified else addedAt
}
/** Tri documents : même ordre que la grille d'accueil, du plus récent au plus vieux. */ /** Tri documents : même ordre que la grille d'accueil, du plus récent au plus vieux. */
fun List<FileEntity>.orderedByReferenceDateDesc(): List<FileEntity> = fun List<FileEntity>.orderedByReferenceDateDesc(): List<FileEntity> =
sortedByDescending { it.referenceDate } sortedWith(compareByDescending<FileEntity> { it.referenceDate }.thenBy { it.name })
@@ -0,0 +1,27 @@
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).
* Sans ça, un `%`/`_` saisi (recherche) ou présent (uris SAF encodées
* `%3A…`) agit comme joker : match-all en recherche, sur-sélection au walk.
*/
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")
@@ -1,7 +1,10 @@
package com.kazier.mobile.data.local.dao package com.kazier.mobile.data.local.dao
import androidx.room.Dao import androidx.room.Dao
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query import androidx.room.Query
import androidx.room.Update
import androidx.room.Upsert import androidx.room.Upsert
import com.kazier.mobile.data.local.entity.FileEntity import com.kazier.mobile.data.local.entity.FileEntity
import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.Flow
@@ -12,6 +15,21 @@ interface FileDao {
@Query("SELECT * FROM files ORDER BY name ASC") @Query("SELECT * FROM files ORDER BY name ASC")
suspend fun getAll(): List<FileEntity> suspend fun getAll(): List<FileEntity>
/**
* Lignes sous une racine SAF (m5) — voir `FolderDao.getUnderRoot`.
*/
@Query("SELECT * FROM files WHERE uri = :rootUri OR uri LIKE :escapedRoot || '/%' ESCAPE '\\'")
suspend fun getUnderRoot(rootUri: String, escapedRoot: String): List<FileEntity>
/**
* Repasse C4 : lignes déjà journalisées (`exists = 0`) dont les octets
* sont peut-être encore sur le disque (journal-first, crash ou refus SAF
* entre la transaction et la suppression physique). Borné pour ne jamais
* bloquer un tick de sync.
*/
@Query("SELECT * FROM files WHERE \"exists\" = 0 AND uri IS NOT NULL ORDER BY updated_at ASC LIMIT :limit")
suspend fun getMissingWithUri(limit: Int): List<FileEntity>
@Query("SELECT * FROM files WHERE folder_resource_id = :folderResourceId AND \"exists\" = 1 ORDER BY name ASC") @Query("SELECT * FROM files WHERE folder_resource_id = :folderResourceId AND \"exists\" = 1 ORDER BY name ASC")
fun observeByFolder(folderResourceId: String): Flow<List<FileEntity>> fun observeByFolder(folderResourceId: String): Flow<List<FileEntity>>
@@ -27,14 +45,29 @@ interface FileDao {
@Query("SELECT * FROM files WHERE uri = :uri LIMIT 1") @Query("SELECT * FROM files WHERE uri = :uri LIMIT 1")
suspend fun getByUri(uri: String): FileEntity? suspend fun getByUri(uri: String): FileEntity?
/**
* 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(""" @Query("""
SELECT * FROM files SELECT * FROM files
WHERE "exists" = 1 WHERE "exists" = 1
AND (:query IS NULL OR name LIKE '%' || :query || '%') 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) AND (:category IS NULL OR category = :category)
ORDER BY name ASC ORDER BY name ASC
""") """)
fun searchWithFilters(query: String?, category: String?): Flow<List<FileEntity>> fun searchWithFilters(query: String?, normQuery: String?, category: String?): Flow<List<FileEntity>>
@Query(""" @Query("""
SELECT * FROM files SELECT * FROM files
@@ -48,6 +81,19 @@ interface FileDao {
@Upsert @Upsert
suspend fun upsert(file: FileEntity) suspend fun upsert(file: FileEntity)
/**
* Insert sans écrasement, résolu sur TOUTES les contraintes uniques
* (`resource_id`, `uri`) — pas seulement la PK. Retourne le rowId, ou -1
* si une ligne existe déjà : le repository relit alors le gagnant et
* applique [update]. Deux walks/refresh concurrents ne lèvent jamais
* `SQLiteConstraintException`.
*/
@Insert(onConflict = OnConflictStrategy.IGNORE)
suspend fun insertIgnore(file: FileEntity): Long
@Update
suspend fun update(file: FileEntity)
@Query("UPDATE files SET \"exists\" = 0, updated_at = :updatedAt WHERE resource_id = :resourceId") @Query("UPDATE files SET \"exists\" = 0, updated_at = :updatedAt WHERE resource_id = :resourceId")
suspend fun markMissing(resourceId: String, updatedAt: Long) suspend fun markMissing(resourceId: String, updatedAt: Long)
@@ -86,8 +132,8 @@ interface FileDao {
@Query("UPDATE files SET folder_resource_id = :folderId, updated_at = :updatedAt WHERE resource_id IN (:resourceIds)") @Query("UPDATE files SET folder_resource_id = :folderId, updated_at = :updatedAt WHERE resource_id IN (:resourceIds)")
suspend fun moveToFolder(resourceIds: List<String>, folderId: String, updatedAt: Long) suspend fun moveToFolder(resourceIds: List<String>, folderId: String, updatedAt: Long)
@Query("UPDATE files SET uri = :uri WHERE resource_id = :resourceId") @Query("UPDATE files SET uri = :uri, updated_at = :updatedAt WHERE resource_id = :resourceId")
suspend fun updateUri(resourceId: String, uri: String?) suspend fun updateUri(resourceId: String, uri: String?, updatedAt: Long)
@Query("DELETE FROM files WHERE resource_id = :resourceId") @Query("DELETE FROM files WHERE resource_id = :resourceId")
suspend fun remove(resourceId: String) suspend fun remove(resourceId: String)
@@ -129,7 +175,10 @@ interface FileDao {
/** Candidate OCR auto : fichier `processed`, `local-cloud`, avec copie /** Candidate OCR auto : fichier `processed`, `local-cloud`, avec copie
* locale, format potentiellement extractible, jamais extrait, pas en cours * locale, format potentiellement extractible, jamais extrait, pas en cours
* et pas épuisé (< 3 échecs terminaux). Trié par dernier upload. */ * et pas épuisé (< 3 échecs terminaux). Trié par dernier upload.
*
* Les lignes pré-v4 sans `category` (NULL) restent éligibles sur la base
* de leur `mime_type`/`extension` (backfill logique, sans migration). */
@Query(""" @Query("""
SELECT * FROM files SELECT * FROM files
WHERE "exists" = 1 WHERE "exists" = 1
@@ -139,7 +188,16 @@ interface FileDao {
AND ocr_text IS NULL AND ocr_text IS NULL
AND ocr_attempts < 3 AND ocr_attempts < 3
AND ocr_queued_at IS NULL AND ocr_queued_at IS NULL
AND category IN ('PDF', 'IMAGE', 'TEXT') AND (
category IN ('PDF', 'IMAGE', 'TEXT')
OR (category IS NULL AND (
mime_type = 'application/pdf'
OR mime_type LIKE 'image/%'
OR mime_type LIKE 'text/%'
OR extension IN ('pdf', 'png', 'jpg', 'jpeg', 'webp', 'gif', 'bmp',
'txt', 'md', 'html', 'xml', 'json')
))
)
ORDER BY COALESCE(last_modified, added_at) DESC, name ASC ORDER BY COALESCE(last_modified, added_at) DESC, name ASC
""") """)
suspend fun getOcrAutoCandidates(): List<FileEntity> suspend fun getOcrAutoCandidates(): List<FileEntity>
@@ -148,8 +206,10 @@ interface FileDao {
@Query("UPDATE files SET ocr_queued_at = :queuedAt, updated_at = :now WHERE resource_id = :resourceId") @Query("UPDATE files SET ocr_queued_at = :queuedAt, updated_at = :now WHERE resource_id = :resourceId")
suspend fun markOcrQueued(resourceId: String, queuedAt: Long, now: Long) suspend fun markOcrQueued(resourceId: String, queuedAt: Long, now: Long)
/** Levé du marqueur + reset du compteur d'échecs (succès / erreur transitoire). */ /** Levé du marqueur « en cours » (succès / erreur transitoire). Le
@Query("UPDATE files SET ocr_queued_at = NULL, ocr_attempts = 0, updated_at = :now WHERE resource_id = :resourceId") * compteur d'échecs est préservé : seul [markOcrFailure] l'incrémente,
* un succès durable passe par `updateOcrText` + `markOcrQueued` réarmé. */
@Query("UPDATE files SET ocr_queued_at = NULL, updated_at = :now WHERE resource_id = :resourceId")
suspend fun clearOcrQueued(resourceId: String, now: Long) suspend fun clearOcrQueued(resourceId: String, now: Long)
/** Échec terminal : +1 tentative, marqueur levé (ne rejoue pas à l'infini). */ /** Échec terminal : +1 tentative, marqueur levé (ne rejoue pas à l'infini). */
@@ -4,6 +4,7 @@ import androidx.room.Dao
import androidx.room.Insert import androidx.room.Insert
import androidx.room.OnConflictStrategy import androidx.room.OnConflictStrategy
import androidx.room.Query import androidx.room.Query
import androidx.room.Update
import androidx.room.Upsert import androidx.room.Upsert
import com.kazier.mobile.data.local.entity.FolderEntity import com.kazier.mobile.data.local.entity.FolderEntity
import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.Flow
@@ -17,6 +18,22 @@ interface FolderDao {
@Query("SELECT * FROM folders ORDER BY name ASC") @Query("SELECT * FROM folders ORDER BY name ASC")
suspend fun getAll(): List<FolderEntity> suspend fun getAll(): List<FolderEntity>
/**
* Lignes sous une racine SAF (m5) : le walk et sa réconciliation ne
* scannent plus toute la table par racine. `:escapedRoot` est la racine
* avec `%`, `_`, `\` échappés côté appelant (`ESCAPE '\'`).
*/
@Query("SELECT * FROM folders WHERE uri = :rootUri OR uri LIKE :escapedRoot || '/%' ESCAPE '\\'")
suspend fun getUnderRoot(rootUri: String, escapedRoot: String): List<FolderEntity>
/**
* Repasse C4 (dossiers) : voir `FileDao.getMissingWithUri`. Un dossier
* n'est re-supprimé physiquement que si toute sa descendance Room est
* aussi `exists = 0` (jamais de suppression d'un arbre encore vivant).
*/
@Query("SELECT * FROM folders WHERE \"exists\" = 0 AND uri IS NOT NULL ORDER BY updated_at ASC LIMIT :limit")
suspend fun getMissingWithUri(limit: Int): List<FolderEntity>
/** Dossiers créés dans l'app (`created_in_app = 1`) — cibles du picker de déplacement. */ /** Dossiers créés dans l'app (`created_in_app = 1`) — cibles du picker de déplacement. */
@Query("SELECT * FROM folders WHERE \"created_in_app\" = 1 ORDER BY name ASC") @Query("SELECT * FROM folders WHERE \"created_in_app\" = 1 ORDER BY name ASC")
suspend fun getCreatedInApp(): List<FolderEntity> suspend fun getCreatedInApp(): List<FolderEntity>
@@ -50,6 +67,19 @@ interface FolderDao {
@Upsert @Upsert
suspend fun upsert(folder: FolderEntity) suspend fun upsert(folder: FolderEntity)
/**
* Insert sans écrasement, résolu sur TOUTES les contraintes uniques
* (`resource_id`, `uri`) — pas seulement la PK. Retourne le rowId, ou -1
* si une ligne existe déjà : le repository relit alors le gagnant et
* applique [update]. Deux walks concurrents ne lèvent jamais
* `SQLiteConstraintException`.
*/
@Insert(onConflict = OnConflictStrategy.IGNORE)
suspend fun insertIgnore(folder: FolderEntity): Long
@Update
suspend fun update(folder: FolderEntity)
@Insert(onConflict = OnConflictStrategy.REPLACE) @Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun upsertAll(folders: List<FolderEntity>) suspend fun upsertAll(folders: List<FolderEntity>)
@@ -27,19 +27,48 @@ interface PendingOperationDao {
@Query("UPDATE pending_operations SET status = 'synced', updated_at = :now WHERE id = :id") @Query("UPDATE pending_operations SET status = 'synced', updated_at = :now WHERE id = :id")
suspend fun markSynced(id: Long, now: Long) suspend fun markSynced(id: Long, now: Long)
/** Échec avec bump du compteur de tentatives (dead-letter après MAX_PENDING_ATTEMPTS). */ /**
* Échec définitif (dead-letter immédiate) ; `attempts` est un compteur
* diagnostic (bump), pas un seuil — il n'y a aucun `MAX_PENDING_ATTEMPTS` :
* une op `failed` n'est plus resélectionnée.
*/
@Query("UPDATE pending_operations SET status = 'failed', attempts = attempts + 1, updated_at = :now WHERE id = :id") @Query("UPDATE pending_operations SET status = 'failed', attempts = attempts + 1, updated_at = :now WHERE id = :id")
suspend fun markFailed(id: Long, now: Long) suspend fun markFailed(id: Long, now: Long)
/** /**
* Invalidation en cascade : un `create_resource` définitivement échoué rend * Invalidation en cascade : un `create_resource` définitivement échoué rend
* fautives toutes les ops en attente qui ciblent la même ressource (filles). * fautives toutes les ops en attente qui ciblent la même ressource, ainsi
* que les creates enfants (autre `resource_id`, liés via la colonne
* `parent_resource_id` — le walk émet parent avant enfant, cf. C6).
* Le repli `LIKE` sur le payload ne sert que les lignes pré-v14 sans
* colonne renseignée.
*/ */
@Query("UPDATE pending_operations SET status = 'failed', updated_at = :now WHERE resource_id = :resourceId AND status = 'pending'") @Query("""
UPDATE pending_operations SET status = 'failed', updated_at = :now
WHERE status = 'pending' AND (
resource_id = :resourceId
OR parent_resource_id = :resourceId
OR (parent_resource_id IS NULL AND payload LIKE '%"parentResourceId":"' || :resourceId || '"%')
)
""")
suspend fun failDescendants(resourceId: String, now: Long) suspend fun failDescendants(resourceId: String, now: Long)
/** Rétention : purge des ops synchronisées plus anciennes que `cutoff`. */ /**
@Query("DELETE FROM pending_operations WHERE status = 'synced' AND updated_at < :cutoff") * Rétention : purge des ops synchronisées plus anciennes que `cutoff`.
*
* Décision C3 — les `create_resource` synced ne sont JAMAIS purgés
* (tombstones) : les gates delete/create (`hasCreateOperation`,
* `countCreateOperations…`) et le backfill de placement sont fondés sur
* `pending+synced`. Purger un create casserait le gate delete (fantôme
* serveur indélébile) et ré-enqueue un create dupliqué au prochain
* `markProcessed`. Les autres ops synced (> 7j) sont purgées normalement.
*/
@Query("""
DELETE FROM pending_operations
WHERE status = 'synced'
AND updated_at < :cutoff
AND operation != 'create_resource'
""")
suspend fun purgeSynced(cutoff: Long) suspend fun purgeSynced(cutoff: Long)
/** /**
@@ -69,14 +98,85 @@ interface PendingOperationDao {
""") """)
suspend fun countCreateOperationsAnyType(resourceId: String): Int suspend fun countCreateOperationsAnyType(resourceId: String): Int
/**
* Annulation (M19) : supprime les `create_resource` encore `pending` pour
* cette ressource. Appelé quand la ressource disparaît localement
* (suppression, réconciliation du walk) AVANT que le serveur l'ait connue :
* pousser un create puis un delete serait du bruit — le serveur n'a rien
* à oublier. Les creates `synced` sont conservés (tombstones C3) : le gate
* delete reste fondé dessus.
*/
@Query("""
DELETE FROM pending_operations
WHERE resource_id = :resourceId
AND operation = 'create_resource'
AND status = 'pending'
""")
suspend fun deletePendingCreates(resourceId: String): Int
/**
* Un `create_resource` a-t-il déjà été POUSSÉ (synced) pour ce fichier ?
* Gate delete précis : après [deletePendingCreates], `hasCreateOperation`
* (pending+synced) y est équivalent — ce compteur l'exprime directement.
*/
@Query("""
SELECT COUNT(*) FROM pending_operations
WHERE resource_id = :resourceId
AND operation = 'create_resource'
AND resource_type = 'file'
AND status = 'synced'
""")
suspend fun countSyncedCreateOperations(resourceId: String): Int
/** Variante sans filtre `resource_type` (dossiers) de [countSyncedCreateOperations]. */
@Query("""
SELECT COUNT(*) FROM pending_operations
WHERE resource_id = :resourceId
AND operation = 'create_resource'
AND status = 'synced'
""")
suspend fun countSyncedCreateOperationsAnyType(resourceId: String): Int
@Query("SELECT COUNT(*) FROM pending_operations WHERE status = 'pending'") @Query("SELECT COUNT(*) FROM pending_operations WHERE status = 'pending'")
suspend fun countPending(): Int suspend fun countPending(): Int
/** Compteur diagnostique par statut (tests, badge « liste des sync »). */
@Query("SELECT COUNT(*) FROM pending_operations WHERE status = :status")
suspend fun countByStatus(status: String): Int
/** /**
* Une op `move_resource` encore en attente de push existe-t-elle pour cette * Abandon de la file non poussée (C5) : supprime les ops `pending` et
* ressource ? L'antichambre outbox est alors la source de vérité du * `failed` — jamais les `synced`. Au changement de compte (sign-out, ou
* placement : ni le refresh serveur ni le walk SAF ne doivent écraser le * login d'un autre user), rejouer la file de A sous le token de B
* `folder_resource_id` local avant que le serveur ait accusé le move. * appliquerait ses mutations dans le scope de B (`NOT_FOUND`,
* `NAME_CONFLICT`, voire créations croisées). Les ops `synced` sont
* conservées : ce sont des tombstones (C3) fondant les gates
* delete/create et le backfill — elles ne sont plus jamais sélectionnées
* (`selectPending` ne lit que `pending`) donc sans risque de rejeu.
*/
@Query("DELETE FROM pending_operations WHERE status IN ('pending', 'failed')")
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.
*/
@Query("""
SELECT COUNT(*) FROM pending_operations
WHERE resource_id = :resourceId
AND operation = 'delete_resource'
AND status = 'pending'
""")
suspend fun countPendingDeleteOperations(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
* refresh serveur (qui renvoie l'ancien dossier) ni le walk SAF (snapshot
* périmé) ne doivent l'écraser.
*/ */
@Query(""" @Query("""
SELECT COUNT(*) FROM pending_operations SELECT COUNT(*) FROM pending_operations
@@ -98,4 +198,19 @@ interface PendingOperationDao {
AND status IN ('pending', 'synced') AND status IN ('pending', 'synced')
""") """)
suspend fun countMoveOperations(resourceId: String): Int suspend fun countMoveOperations(resourceId: String): Int
/**
* Ops de partage encore en attente de push pour cette ressource
* (`share`, `update_share`, `revoke_share`, `create_link`, `revoke_link`).
* Le sheet de partage les affiche comme « en attente d'envoi » : la liste
* serveur ne les reflète qu'après le drain du worker.
*/
@Query("""
SELECT * FROM pending_operations
WHERE resource_id = :resourceId
AND operation IN ('share', 'update_share', 'revoke_share', 'create_link', 'revoke_link')
AND status = 'pending'
ORDER BY id ASC
""")
suspend fun pendingShareOps(resourceId: String): List<PendingOperationEntity>
} }
@@ -0,0 +1,30 @@
package com.kazier.mobile.data.local.dao
import androidx.room.Dao
import androidx.room.Query
import androidx.room.Upsert
import com.kazier.mobile.data.local.entity.ResourcePermissionEntity
@Dao
interface ResourcePermissionDao {
@Upsert
suspend fun upsertAll(perms: List<ResourcePermissionEntity>)
@Query("SELECT * FROM resource_permissions WHERE resource_id = :resourceId LIMIT 1")
suspend fun getByResourceId(resourceId: String): ResourcePermissionEntity?
/** Grants périmés à masquer localement (`expires_at` passé). */
@Query("SELECT * FROM resource_permissions WHERE expires_at IS NOT NULL AND expires_at <= :now")
suspend fun getExpired(now: Long): List<ResourcePermissionEntity>
/**
* Convergence du pull complet : oublie les grants absents du snapshot
* (révocation/expiration côté serveur).
*/
@Query("DELETE FROM resource_permissions WHERE resource_id NOT IN (:snapshotIds)")
suspend fun deleteNotIn(snapshotIds: List<String>)
@Query("DELETE FROM resource_permissions")
suspend fun clear()
}
@@ -45,6 +45,9 @@ interface ScanDao {
@Query("DELETE FROM scan_pages WHERE id = :pageId AND session_id = :sessionId") @Query("DELETE FROM scan_pages WHERE id = :pageId AND session_id = :sessionId")
suspend fun deletePage(pageId: Long, sessionId: Long) suspend fun deletePage(pageId: Long, sessionId: Long)
@Query("DELETE FROM scan_sessions WHERE id = :sessionId")
suspend fun deleteSession(sessionId: Long)
@Query( @Query(
""" """
UPDATE scan_pages SET sort_order = CASE id UPDATE scan_pages SET sort_order = CASE id
@@ -61,4 +64,12 @@ interface ScanDao {
@Query("SELECT COUNT(*) FROM scan_pages WHERE session_id = :sessionId") @Query("SELECT COUNT(*) FROM scan_pages WHERE session_id = :sessionId")
suspend fun pageCount(sessionId: Long): Int suspend fun pageCount(sessionId: Long): Int
/**
* Plus grand `sort_order` de la session (NULL si vide) : l'ordre d'une
* nouvelle page est `MAX + 1`, jamais `COUNT` (qui collisionne après
* suppression : A,B → del A → C réutiliserait l'ordre de B).
*/
@Query("SELECT MAX(sort_order) FROM scan_pages WHERE session_id = :sessionId")
suspend fun maxSortOrder(sessionId: Long): Int?
} }
@@ -22,6 +22,7 @@ import androidx.room.PrimaryKey
Index(value = ["uri"], unique = true), Index(value = ["uri"], unique = true),
Index(value = ["folder_resource_id"]), Index(value = ["folder_resource_id"]),
Index(value = ["category"]), Index(value = ["category"]),
Index(value = ["exists", "processed", "sync_status"]),
], ],
) )
data class FileEntity( data class FileEntity(
@@ -41,8 +42,9 @@ data class FileEntity(
val size: Long, val size: Long,
@ColumnInfo(name = "mime_type") @ColumnInfo(name = "mime_type")
val mimeType: String? = null, val mimeType: String? = null,
// M13 : voir `FolderEntity.exists` — défaut 1, backfill en migration 14→15.
@ColumnInfo(name = "exists") @ColumnInfo(name = "exists")
val exists: Int? = null, val exists: Int? = 1,
@ColumnInfo(name = "last_modified") @ColumnInfo(name = "last_modified")
val lastModified: Long? = null, val lastModified: Long? = null,
@ColumnInfo(name = "owner_id") @ColumnInfo(name = "owner_id")
@@ -32,8 +32,11 @@ data class FolderEntity(
val uri: String? = null, val uri: String? = null,
@ColumnInfo(name = "name") @ColumnInfo(name = "name")
val name: String, val name: String,
// M13 : défaut 1 — une ligne sans `exists` explicite restait invisible
// des requêtes `WHERE exists = 1`. La colonne reste nullable côté schéma
// (pas de rewrite), le backfill NULL→1 est fait en migration 14→15.
@ColumnInfo(name = "exists") @ColumnInfo(name = "exists")
val exists: Int? = null, val exists: Int? = 1,
@ColumnInfo(name = "parent_resource_id") @ColumnInfo(name = "parent_resource_id")
val parentResourceId: String? = null, val parentResourceId: String? = null,
@ColumnInfo(name = "owner_id") @ColumnInfo(name = "owner_id")
@@ -20,14 +20,18 @@ import androidx.room.PrimaryKey
@Entity( @Entity(
tableName = "pending_operations", tableName = "pending_operations",
indices = [ indices = [
Index(value = ["operation_id"], unique = true), Index(value = ["device_id", "operation_id"], unique = true),
Index(value = ["status"]), Index(value = ["status"]),
Index(value = ["resource_id"]), Index(value = ["resource_id"]),
Index(value = ["resource_id", "operation", "status"]),
Index(value = ["parent_resource_id"]),
], ],
) )
data class PendingOperationEntity( data class PendingOperationEntity(
@PrimaryKey(autoGenerate = true) @PrimaryKey(autoGenerate = true)
val id: Long = 0L, val id: Long = 0L,
@ColumnInfo(name = "device_id")
val deviceId: String? = null,
@ColumnInfo(name = "operation_id") @ColumnInfo(name = "operation_id")
val operationId: String, val operationId: String,
@ColumnInfo(name = "ref_type") @ColumnInfo(name = "ref_type")
@@ -42,6 +46,15 @@ data class PendingOperationEntity(
val operation: String, val operation: String,
@ColumnInfo(name = "payload") @ColumnInfo(name = "payload")
val payload: String, val payload: String,
/**
* Lien parent→enfant dénormalisé (P8) : `resource_id` du dossier parent
* pour un `create_resource` avec parent (les enfants portent un autre
* `resource_id`). Évite de parser le JSON du payload (`LIKE`) pour la
* cascade d'invalidation — robuste au format de sérialisation Moshi.
* NULL pour les ops sans parent et les lignes pré-v14 (repli LIKE).
*/
@ColumnInfo(name = "parent_resource_id")
val parentResourceId: String? = null,
@ColumnInfo(name = "status") @ColumnInfo(name = "status")
val status: String = PendingOpStatus.PENDING, val status: String = PendingOpStatus.PENDING,
@ColumnInfo(name = "attempts") @ColumnInfo(name = "attempts")
@@ -0,0 +1,59 @@
package com.kazier.mobile.data.local.entity
import androidx.room.ColumnInfo
import androidx.room.Entity
import androidx.room.Index
import androidx.room.PrimaryKey
/**
* Cache local du snapshot `GET /sync/permissions` (M27, docs/api-v1.md §6.2).
*
* Une ligne = la permission effective connue pour une ressource NON possédée
* (les ressources `owner` ne sont pas stockées : l'ownership se résout depuis
* les lignes `files`/`folders`). Fondement de [canAccess][com.kazier.mobile.data.repository.ShareRepository.canAccess]
* sans réseau : rang effectif, expiration du grant et fraîcheur du snapshot
* (TTL 24h → downgrade lecture seule).
*/
@Entity(
tableName = "resource_permissions",
indices = [
Index(value = ["expires_at"]),
],
)
data class ResourcePermissionEntity(
@PrimaryKey
@ColumnInfo(name = "resource_id")
val resourceId: String,
@ColumnInfo(name = "resource_type")
val resourceType: String,
@ColumnInfo(name = "effective_access")
val effectiveAccess: String,
@ColumnInfo(name = "owner_id")
val ownerId: String? = null,
@ColumnInfo(name = "shared_by_id")
val sharedById: String? = null,
/** Fin du grant, ms epoch ; null = jamais. */
@ColumnInfo(name = "expires_at")
val expiresAt: Long? = null,
/** Horodatage du snapshot serveur, ms epoch (TTL 24h). */
@ColumnInfo(name = "cached_at")
val cachedAt: Long,
@ColumnInfo(name = "updated_at")
val updatedAt: Long,
)
/** Rangs d'accès effectif — `viewer < commenter < editor < owner`. */
object AccessRank {
const val VIEWER = "viewer"
const val COMMENTER = "commenter"
const val EDITOR = "editor"
const val OWNER = "owner"
fun rank(access: String?): Int = when (access) {
OWNER -> 4
EDITOR -> 3
COMMENTER -> 2
VIEWER -> 1
else -> 0
}
}
@@ -26,6 +26,16 @@ import androidx.sqlite.db.SupportSQLiteDatabase
* l'app (fichier cloud-only, uri = NULL). Null pour les fichiers importés. * l'app (fichier cloud-only, uri = NULL). Null pour les fichiers importés.
* v10 : ajout colonne `ocr_text` sur `files` — extrait OCR serveur persisté * v10 : ajout colonne `ocr_text` sur `files` — extrait OCR serveur persisté
* localement (résultat d'un job `POST /ocr/jobs`, réaffichable sans relance). * localement (résultat d'un job `POST /ocr/jobs`, réaffichable sans relance).
* v11 : `ocr_attempts` + `ocr_queued_at` sur `files` (driver OCR auto).
* v12 : ajout colonne `device_id` sur `pending_operations` + unicité
* composite `UNIQUE(device_id, operation_id)` (contrat docs/api-v1.md §6.1) ;
* backfill depuis `user_preferences.device_user_id` pour les lignes existantes.
* v13 : index composites `files(exists, processed, sync_status)` (review +
* candidats OCR auto) et `pending_operations(resource_id, operation, status)`
* (gates outbox create/move) — requêtes à chaud sans full-table scan.
* v14 : colonne `parent_resource_id` sur `pending_operations` (cascade P8).
* v15 : backfill `exists` NULL→1 sur `folders`/`files` (M13) + défaut Kotlin 1.
* v16 : table `resource_permissions` (cache snapshot, M27) + index `expires_at`.
*/ */
object Migrations { object Migrations {
@@ -92,6 +102,14 @@ object Migrations {
db.execSQL("ALTER TABLE `files` ADD COLUMN `processed` INTEGER NOT NULL DEFAULT 0") db.execSQL("ALTER TABLE `files` ADD COLUMN `processed` INTEGER NOT NULL DEFAULT 0")
// Backlog = déjà traité : la file de review ne contient que les // Backlog = déjà traité : la file de review ne contient que les
// fichiers découverts après l'activation de la fonctionnalité. // fichiers découverts après l'activation de la fonctionnalité.
//
// Décision M11 (documentée, assumée) : aucun `create_resource`
// rétroactif n'est journalisé pour ce backlog — ces fichiers ne
// seront jamais poussés vers le serveur (ni vizibles en review).
// Un backfill applicatif créerait des doublons serveur pour les
// ressources déjà connues par d'autres chemins (scan, second
// device) sans moyen fiable de les distinguer : la perte silencieuse
// du backlog pré-v6 est préférée à une résurrection massive.
db.execSQL("UPDATE `files` SET `processed` = 1") db.execSQL("UPDATE `files` SET `processed` = 1")
} }
} }
@@ -181,7 +199,99 @@ object Migrations {
} }
} }
private val MIGRATION_11_12 = object : Migration(11, 12) {
override fun migrate(db: SupportSQLiteDatabase) {
db.execSQL("ALTER TABLE `pending_operations` ADD COLUMN `device_id` TEXT")
// Backfill : les ops pré-v12 héritent du device courant (une seule
// identité device par base en pratique).
db.execSQL(
"""
UPDATE `pending_operations` SET `device_id` =
(SELECT `value` FROM `user_preferences` WHERE `key` = 'device_user_id')
WHERE `device_id` IS NULL
""".trimIndent(),
)
db.execSQL("DROP INDEX IF EXISTS `index_pending_operations_operation_id`")
db.execSQL(
"CREATE UNIQUE INDEX IF NOT EXISTS " +
"`index_pending_operations_device_id_operation_id` " +
"ON `pending_operations` (`device_id`, `operation_id`)",
)
}
}
private val MIGRATION_12_13 = object : Migration(12, 13) {
override fun migrate(db: SupportSQLiteDatabase) {
db.execSQL(
"CREATE INDEX IF NOT EXISTS `index_files_exists_processed_sync_status` " +
"ON `files` (`exists`, `processed`, `sync_status`)",
)
db.execSQL(
"CREATE INDEX IF NOT EXISTS `index_pending_operations_resource_id_operation_status` " +
"ON `pending_operations` (`resource_id`, `operation`, `status`)",
)
}
}
/**
* P8 : colonne `parent_resource_id` dénormalisée (cascade sans parsing
* JSON). Les lignes pré-v14 gardent NULL et restent couvertes par le repli
* `LIKE` de `failDescendants` — pas de backfill (le `json_extract`
* SQLite n'est pas garanti sur tous les niveaux d'API).
*/
private val MIGRATION_13_14 = object : Migration(13, 14) {
override fun migrate(db: SupportSQLiteDatabase) {
db.execSQL("ALTER TABLE `pending_operations` ADD COLUMN `parent_resource_id` TEXT")
db.execSQL(
"CREATE INDEX IF NOT EXISTS `index_pending_operations_parent_resource_id` " +
"ON `pending_operations` (`parent_resource_id`)",
)
}
}
/**
* M13 : backfill `exists` NULL→1 sur `folders` et `files`. Les lignes
* insérées sans `exists` explicite (défaut Kotlin `null` avant ce fix)
* étaient invisibles des requêtes `WHERE exists = 1` — elles
* réapparaissent comme présentes, état le plus sûr (le walk les
* re-marque `exists = 0` si elles ont vraiment disparu).
*/
private val MIGRATION_14_15 = object : Migration(14, 15) {
override fun migrate(db: SupportSQLiteDatabase) {
db.execSQL("UPDATE `folders` SET `exists` = 1 WHERE `exists` IS NULL")
db.execSQL("UPDATE `files` SET `exists` = 1 WHERE `exists` IS NULL")
}
}
/**
* M27 : cache du snapshot permissions — table `resource_permissions`
* (rang effectif + expiration + fraîcheur, fondement de `canAccess`).
*/
private val MIGRATION_15_16 = object : Migration(15, 16) {
override fun migrate(db: SupportSQLiteDatabase) {
db.execSQL(
"""
CREATE TABLE IF NOT EXISTS `resource_permissions` (
`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`)
)
""".trimIndent(),
)
db.execSQL(
"CREATE INDEX IF NOT EXISTS `index_resource_permissions_expires_at` " +
"ON `resource_permissions` (`expires_at`)",
)
}
}
val ALL: Array<Migration> = arrayOf( 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_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,
) )
} }
@@ -1,22 +1,30 @@
package com.kazier.mobile.data.remote package com.kazier.mobile.data.remote
import com.squareup.moshi.JsonAdapter import com.squareup.moshi.JsonAdapter
import com.squareup.moshi.JsonDataException
import com.squareup.moshi.JsonEncodingException
import com.squareup.moshi.Moshi import com.squareup.moshi.Moshi
import com.kazier.mobile.data.remote.dto.ApiEnvelope import com.kazier.mobile.data.remote.dto.ApiEnvelope
import com.kazier.mobile.data.remote.dto.ApiErrorEnvelope import com.kazier.mobile.data.remote.dto.ApiErrorEnvelope
import com.kazier.mobile.data.remote.dto.ApiMeta
import com.kazier.mobile.data.remote.dto.ChangePasswordDto
import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto
import com.kazier.mobile.data.remote.dto.FileDto import com.kazier.mobile.data.remote.dto.FileDto
import com.kazier.mobile.data.remote.dto.FileOcrDto import com.kazier.mobile.data.remote.dto.FileOcrDto
import com.kazier.mobile.data.remote.dto.FolderDto import com.kazier.mobile.data.remote.dto.FolderDto
import com.kazier.mobile.data.remote.dto.IdResultDto
import com.kazier.mobile.data.remote.dto.LoginRequestDto import com.kazier.mobile.data.remote.dto.LoginRequestDto
import com.kazier.mobile.data.remote.dto.LoginResponseDto import com.kazier.mobile.data.remote.dto.LoginResponseDto
import com.kazier.mobile.data.remote.dto.OcrJobDto import com.kazier.mobile.data.remote.dto.OcrJobDto
import com.kazier.mobile.data.remote.dto.OcrSubmitDto import com.kazier.mobile.data.remote.dto.OcrSubmitDto
import com.kazier.mobile.data.remote.dto.ResolvedUserDto import com.kazier.mobile.data.remote.dto.ResolvedUserDto
import com.kazier.mobile.data.remote.dto.ResourcePermissionDto import com.kazier.mobile.data.remote.dto.ResourcePermissionDto
import com.kazier.mobile.data.remote.dto.ShareGrantDto
import com.kazier.mobile.data.remote.dto.ShareLinkDto
import com.kazier.mobile.data.remote.dto.SyncOpDto import com.kazier.mobile.data.remote.dto.SyncOpDto
import com.kazier.mobile.data.remote.dto.SyncOpsRequest import com.kazier.mobile.data.remote.dto.SyncOpsRequest
import com.kazier.mobile.data.remote.dto.SyncOpsResult import com.kazier.mobile.data.remote.dto.SyncOpsResult
import kotlin.coroutines.cancellation.CancellationException
import okhttp3.MultipartBody import okhttp3.MultipartBody
import okhttp3.MediaType.Companion.toMediaType import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody import okhttp3.RequestBody
@@ -44,7 +52,12 @@ class ApiException(
* - non-2xx → `ApiException` (code du body si présent, sinon `HTTP_<status>`), * - non-2xx → `ApiException` (code du body si présent, sinon `HTTP_<status>`),
* et un 401 sur un endpoint protégé déclenche `onUnauthorized` (sauf si * et un 401 sur un endpoint protégé déclenche `onUnauthorized` (sauf si
* `skipUnauthorizedHandling` — cas du login, où 401 = identifiants erronés) ; * `skipUnauthorizedHandling` — cas du login, où 401 = identifiants erronés) ;
* - 2xx sans `data` (ou corps illisible) → `INVALID_RESPONSE`. * - 2xx sans `data` (ou corps illisible) → `INVALID_RESPONSE` ;
* - un corps non parsable (Moshi) → `INVALID_RESPONSE`, jamais
* `NETWORK_ERROR` (pas de `retry()` infini sur contrat cassé) ;
* - `CancellationException` n'est jamais avalée (scopes/Worker sains).
* Les routes publiques (`/devices`, `/auth/login`, `/shares/links/:token`)
* désactivent le handling 401 : y purger la session serait faux.
*/ */
@Singleton @Singleton
class ApiClient @Inject constructor( class ApiClient @Inject constructor(
@@ -55,7 +68,7 @@ class ApiClient @Inject constructor(
private val errorEnvelopeAdapter: JsonAdapter<ApiErrorEnvelope> = private val errorEnvelopeAdapter: JsonAdapter<ApiErrorEnvelope> =
moshi.adapter(ApiErrorEnvelope::class.java) moshi.adapter(ApiErrorEnvelope::class.java)
/** Callback 401 (expiration/révocation) — branché par AuthViewModel. */ /** Callback 401 (expiration/révocation) — branché par SessionManager. */
@Volatile @Volatile
var onUnauthorized: (() -> Unit)? = null var onUnauthorized: (() -> Unit)? = null
@@ -64,8 +77,20 @@ class ApiClient @Inject constructor(
suspend fun listFiles(folderId: String? = null, page: Int? = null, pageSize: Int? = null): List<FileDto> = suspend fun listFiles(folderId: String? = null, page: Int? = null, pageSize: Int? = null): List<FileDto> =
unwrap({ apiService.listFiles(folderId, page, pageSize) }) unwrap({ apiService.listFiles(folderId, page, pageSize) })
/**
* Variante paginée exposant `meta` (page/pageSize/total) — seule base
* saine pour drainer un dossier au-delà de la 1re page (M21).
*/
suspend fun listFilesPaged(
folderId: String? = null,
page: Int? = null,
pageSize: Int? = null,
): Pair<List<FileDto>, ApiMeta?> =
unwrapWithMeta({ apiService.listFiles(folderId, page, pageSize) })
suspend fun registerDevice(deviceId: String): String = suspend fun registerDevice(deviceId: String): String =
unwrap({ apiService.registerDevice(DeviceRegistrationDto(deviceId)) }).deviceId unwrap({ apiService.registerDevice(DeviceRegistrationDto(deviceId)) },
skipUnauthorizedHandling = true).deviceId
suspend fun login(username: String, password: String, deviceId: String): LoginResponseDto = suspend fun login(username: String, password: String, deviceId: String): LoginResponseDto =
unwrap({ apiService.login(LoginRequestDto(username, password, deviceId)) }, unwrap({ apiService.login(LoginRequestDto(username, password, deviceId)) },
@@ -110,16 +135,149 @@ class ApiClient @Inject constructor(
suspend fun getFileOcr(fileId: String): FileOcrDto = suspend fun getFileOcr(fileId: String): FileOcrDto =
unwrap({ apiService.getFileOcr(fileId) }) unwrap({ apiService.getFileOcr(fileId) })
/** Détail serveur d'un fichier visible — `GET /files/:id`. */
suspend fun getFile(fileId: String): FileDto =
unwrap({ apiService.getFile(fileId) })
/** Suppression serveur — `DELETE /files/:id`, retourne l'id supprimé. */
suspend fun deleteFile(fileId: String): String =
unwrap({ apiService.deleteFile(fileId) }).id
/** Recherche serveur paginée — `GET /files/search?q=…` (+ `meta`). */
suspend fun searchFilesPaged(
query: String,
page: Int? = null,
pageSize: Int? = null,
): Pair<List<FileDto>, ApiMeta?> =
unwrapWithMeta({ apiService.searchFiles(query, page, pageSize) })
/** Rotation du mot de passe — `PATCH /users/me/password`. */
suspend fun changePassword(currentPassword: String, newPassword: String): String =
unwrap({ apiService.changePassword(ChangePasswordDto(currentPassword, newPassword)) }).id
/**
* Résolution anonyme d'un lien de partage — `GET /shares/links/:token`
* (route publique : le 401 n'a aucun sens ici, handling désactivé).
*/
suspend fun getShareLink(token: String): ShareLinkDto =
unwrap({ apiService.getShareLink(token) }, skipUnauthorizedHandling = true)
/**
* Grants actifs d'une ressource possédée — `GET /files/:id/shares`
* (owner uniquement, 404 sinon).
*/
suspend fun listShares(fileId: String): List<ShareGrantDto> =
unwrap({ apiService.listShares(fileId) })
/**
* Liens publics actifs d'une ressource possédée — `GET /files/:id/links`
* (owner uniquement, 404 sinon).
*/
suspend fun listLinks(fileId: String): List<ShareLinkDto> =
unwrap({ apiService.listLinks(fileId) })
/**
* Octets physiques d'un fichier visible — `GET /files/:id/content`
* (binaire brut, hors enveloppe). Streaming sans cache : lecture bornée
* à [maxBytes] (+1 pour détecter le dépassement → `FILE_TOO_LARGE`),
* jamais persistée. 404 = invisible ou metadata-only sans octets.
*/
suspend fun downloadContentBytes(
fileId: String,
maxBytes: Long = MAX_CONTENT_BYTES,
): ByteArray {
val response = try {
apiService.downloadContent(fileId)
} catch (e: CancellationException) {
throw e
} catch (e: IOException) {
Timber.d(e, "api: transport error (content)")
throw ApiException("NETWORK_ERROR", "Serveur injoignable", 0)
} catch (e: Exception) {
if (e is CancellationException) throw e
Timber.d(e, "api: unexpected error (content)")
throw ApiException("NETWORK_ERROR", "Serveur injoignable", 0)
}
if (!response.isSuccessful) {
val status = response.code()
if (status == 401) {
onUnauthorized?.invoke()
}
val error = response.errorBody()?.use { body ->
body.string().let { raw ->
runCatching { errorEnvelopeAdapter.fromJson(raw)?.error }.getOrNull()
}
}
throw ApiException(
code = error?.code ?: if (status == 404) "NOT_FOUND" else "HTTP_$status",
message = error?.message ?: "HTTP $status",
httpCode = status,
)
}
val body = response.body()
?: throw ApiException("INVALID_RESPONSE", "Réponse serveur invalide (corps vide)", response.code())
if (body.contentLength() > maxBytes) {
body.close()
throw ApiException("FILE_TOO_LARGE", "Fichier trop volumineux pour le streaming", response.code())
}
try {
body.byteStream().use { input ->
val out = java.io.ByteArrayOutputStream()
val buf = ByteArray(32 * 1024)
var total = 0L
while (true) {
val read = input.read(buf)
if (read < 0) break
total += read
if (total > maxBytes) {
throw ApiException("FILE_TOO_LARGE", "Fichier trop volumineux pour le streaming", response.code())
}
out.write(buf, 0, read)
}
return out.toByteArray()
}
} catch (e: ApiException) {
throw e
} catch (e: CancellationException) {
throw e
} catch (e: IOException) {
throw ApiException("NETWORK_ERROR", "Serveur injoignable", 0)
} finally {
body.close()
}
}
companion object {
/** Borne streaming sans cache : 12 Mo (jamais en RAM au-delà). */
const val MAX_CONTENT_BYTES = 12 * 1024 * 1024L
}
private suspend fun <T> unwrap( private suspend fun <T> unwrap(
call: suspend () -> Response<ApiEnvelope<T>>, call: suspend () -> Response<ApiEnvelope<T>>,
skipUnauthorizedHandling: Boolean = false, skipUnauthorizedHandling: Boolean = false,
): T { ): T = unwrapWithMeta(call, skipUnauthorizedHandling).first
private suspend fun <T> unwrapWithMeta(
call: suspend () -> Response<ApiEnvelope<T>>,
skipUnauthorizedHandling: Boolean = false,
): Pair<T, ApiMeta?> {
val response = try { val response = try {
call() call()
} catch (e: CancellationException) {
// Ne jamais avaler l'annulation : la convertir en ApiException
// corromprait les scopes et le WorkManager (M22).
throw e
} catch (e: JsonDataException) {
Timber.w(e, "api: corps inattendu (parsing)")
throw ApiException("INVALID_RESPONSE", "Réponse serveur invalide", 0)
} catch (e: JsonEncodingException) {
Timber.w(e, "api: corps inencodable (parsing)")
throw ApiException("INVALID_RESPONSE", "Réponse serveur invalide", 0)
} catch (e: IOException) { } catch (e: IOException) {
Timber.d(e, "api: transport error") Timber.d(e, "api: transport error")
throw ApiException("NETWORK_ERROR", "Serveur injoignable", 0) throw ApiException("NETWORK_ERROR", "Serveur injoignable", 0)
} catch (e: Exception) { } catch (e: Exception) {
if (e is CancellationException) throw e
Timber.d(e, "api: unexpected error") Timber.d(e, "api: unexpected error")
throw ApiException("NETWORK_ERROR", "Serveur injoignable", 0) throw ApiException("NETWORK_ERROR", "Serveur injoignable", 0)
} }
@@ -151,6 +309,6 @@ class ApiClient @Inject constructor(
httpCode = response.code(), httpCode = response.code(),
) )
} }
return data return data to envelope.meta
} }
} }
@@ -1,28 +1,36 @@
package com.kazier.mobile.data.remote package com.kazier.mobile.data.remote
import com.kazier.mobile.data.remote.dto.ApiEnvelope import com.kazier.mobile.data.remote.dto.ApiEnvelope
import com.kazier.mobile.data.remote.dto.ChangePasswordDto
import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto
import com.kazier.mobile.data.remote.dto.FileDto import com.kazier.mobile.data.remote.dto.FileDto
import com.kazier.mobile.data.remote.dto.FileOcrDto import com.kazier.mobile.data.remote.dto.FileOcrDto
import com.kazier.mobile.data.remote.dto.FolderDto import com.kazier.mobile.data.remote.dto.FolderDto
import com.kazier.mobile.data.remote.dto.IdResultDto
import com.kazier.mobile.data.remote.dto.LoginRequestDto import com.kazier.mobile.data.remote.dto.LoginRequestDto
import com.kazier.mobile.data.remote.dto.LoginResponseDto import com.kazier.mobile.data.remote.dto.LoginResponseDto
import com.kazier.mobile.data.remote.dto.OcrJobDto import com.kazier.mobile.data.remote.dto.OcrJobDto
import com.kazier.mobile.data.remote.dto.OcrSubmitDto import com.kazier.mobile.data.remote.dto.OcrSubmitDto
import com.kazier.mobile.data.remote.dto.ResolvedUserDto import com.kazier.mobile.data.remote.dto.ResolvedUserDto
import com.kazier.mobile.data.remote.dto.ResourcePermissionDto import com.kazier.mobile.data.remote.dto.ResourcePermissionDto
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.SyncOpsRequest
import com.kazier.mobile.data.remote.dto.SyncOpsResult import com.kazier.mobile.data.remote.dto.SyncOpsResult
import okhttp3.MultipartBody import okhttp3.MultipartBody
import okhttp3.RequestBody import okhttp3.RequestBody
import okhttp3.ResponseBody
import retrofit2.Response import retrofit2.Response
import retrofit2.http.Body import retrofit2.http.Body
import retrofit2.http.DELETE
import retrofit2.http.GET import retrofit2.http.GET
import retrofit2.http.Multipart import retrofit2.http.Multipart
import retrofit2.http.PATCH
import retrofit2.http.POST import retrofit2.http.POST
import retrofit2.http.Part import retrofit2.http.Part
import retrofit2.http.Path import retrofit2.http.Path
import retrofit2.http.Query import retrofit2.http.Query
import retrofit2.http.Streaming
/** /**
* Contrat HTTP V1 — copie de `mobile/api/client.ts` (le client mobile est la * Contrat HTTP V1 — copie de `mobile/api/client.ts` (le client mobile est la
@@ -107,4 +115,76 @@ interface ApiService {
suspend fun getFileOcr( suspend fun getFileOcr(
@Path("id") fileId: String, @Path("id") fileId: String,
): Response<ApiEnvelope<FileOcrDto>> ): Response<ApiEnvelope<FileOcrDto>>
/** Détail d'un fichier visible (own ou shared) — `GET /files/:id`. */
@GET("files/{id}")
suspend fun getFile(
@Path("id") fileId: String,
): Response<ApiEnvelope<FileDto>>
/**
* Octets physiques d'un fichier visible (viewer+, own ou shared) —
* `GET /files/:id/content` (binaire brut, hors enveloppe `{data}`).
* Streaming lecture seule : le client ne persiste rien (V1 streaming).
* 404 = invisible OU metadata-only jamais uploadé (indistinguables).
*/
@Streaming
@GET("files/{id}/content")
suspend fun downloadContent(
@Path("id") fileId: String,
): Response<ResponseBody>
/** Suppression serveur d'un fichier possédé — `DELETE /files/:id`. */
@DELETE("files/{id}")
suspend fun deleteFile(
@Path("id") fileId: String,
): Response<ApiEnvelope<IdResultDto>>
/**
* Recherche serveur (`GET /files/search?q=…`, paginé `meta`). Non consommée
* en V1 (recherche 100 % locale via Room) — exposée pour parité contrat.
*/
@GET("files/search")
suspend fun searchFiles(
@Query("q") query: String,
@Query("page") page: Int?,
@Query("pageSize") pageSize: Int?,
): Response<ApiEnvelope<List<FileDto>>>
/**
* Rotation du mot de passe du compte connecté (`PATCH /users/me/password`,
* `current_password` requis). Limite V1 : les tokens déjà émis restent
* valides jusqu'à expiration (7 j, pas de révocation).
*/
@PATCH("users/me/password")
suspend fun changePassword(
@Body body: ChangePasswordDto,
): Response<ApiEnvelope<IdResultDto>>
/**
* Résolution anonyme d'un lien de partage (`GET /shares/links/:token`,
* route publique — jamais de `Bearer`, cf. `AuthInterceptor`).
*/
@GET("shares/links/{token}")
suspend fun getShareLink(
@Path("token") token: String,
): Response<ApiEnvelope<ShareLinkDto>>
/**
* Grants actifs d'une ressource possédée (`GET /files/:id/shares`,
* owner uniquement — 404 sinon, pas d'énumération).
*/
@GET("files/{id}/shares")
suspend fun listShares(
@Path("id") fileId: String,
): Response<ApiEnvelope<List<ShareGrantDto>>>
/**
* Liens publics actifs d'une ressource possédée (`GET /files/:id/links`,
* owner uniquement — même forme que `getShareLink`).
*/
@GET("files/{id}/links")
suspend fun listLinks(
@Path("id") fileId: String,
): Response<ApiEnvelope<List<ShareLinkDto>>>
} }
@@ -7,9 +7,12 @@ import javax.inject.Singleton
import com.kazier.mobile.auth.TokenProvider import com.kazier.mobile.auth.TokenProvider
/** /**
* Injecte `Authorization: Bearer <token>` sur chaque requête si un token est * Injecte `Authorization: Bearer <token>` sur chaque requête protégée si un
* disponible. Sans token (mode local / non connecté), aucune entête n'est posée * token est disponible. Les routes publiques (`POST /devices`,
* — le serveur répondra 401, géré proprement par `ApiClient`. * `POST /auth/login`, `GET /shares/links/:token`, `/health`) ne reçoivent
* jamais de `Bearer` (hygiène + pas d'amplification de fuite, cf. M26/m26).
* Sans token (mode local / non connecté), aucune entête n'est posée — le
* serveur répondra 401, géré proprement par `ApiClient`.
*/ */
@Singleton @Singleton
class AuthInterceptor @Inject constructor( class AuthInterceptor @Inject constructor(
@@ -17,11 +20,31 @@ class AuthInterceptor @Inject constructor(
) : Interceptor { ) : Interceptor {
override fun intercept(chain: Interceptor.Chain): Response { override fun intercept(chain: Interceptor.Chain): Response {
val request = chain.request()
val requestBuilder = request.newBuilder()
val token = tokenProvider.current val token = tokenProvider.current
val requestBuilder = chain.request().newBuilder() if (token != null && !isPublic(request.url.encodedPath)) {
if (token != null) {
requestBuilder.header("Authorization", "Bearer $token") requestBuilder.header("Authorization", "Bearer $token")
} }
return chain.proceed(requestBuilder.build()) return chain.proceed(requestBuilder.build())
} }
companion object {
/**
* Segments terminaux des routes publiques V1 (après réécriture par
* `ServerUrlInterceptor`, la base inclut `/api/v1` — on matche en
* suffixe pour rester indépendant du préfixe configuré).
*/
private val PUBLIC_SUFFIXES = listOf(
"/devices",
"/auth/login",
"/health",
)
fun isPublic(encodedPath: String): Boolean {
if (PUBLIC_SUFFIXES.any { encodedPath.endsWith(it) }) return true
// Lien de partage anonyme : /api/v1/shares/links/:token.
return encodedPath.contains("/shares/links/")
}
}
} }
@@ -3,6 +3,7 @@ package com.kazier.mobile.data.remote
import com.kazier.mobile.domain.ServerConfigStore import com.kazier.mobile.domain.ServerConfigStore
import javax.inject.Inject import javax.inject.Inject
import javax.inject.Singleton import javax.inject.Singleton
import kotlinx.coroutines.runBlocking
import okhttp3.HttpUrl.Companion.toHttpUrl import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.Interceptor import okhttp3.Interceptor
import okhttp3.Response import okhttp3.Response
@@ -13,6 +14,11 @@ import timber.log.Timber
* La base Retrofit n'est qu'un placeholder ; c'est cet interceptor qui décide * La base Retrofit n'est qu'un placeholder ; c'est cet interceptor qui décide
* du schéma/host/port réels, en préservant le préfixe de chemin de la base * du schéma/host/port réels, en préservant le préfixe de chemin de la base
* configurée (ex. `/api/v1`) ainsi que la query d'origine. * configurée (ex. `/api/v1`) ainsi que la query d'origine.
*
* Garde M26 : si le `load()` du cold start n'a pas encore restauré l'URL
* persistée, l'interceptor le fait lui-même (bloquant, thread OkHttp — jamais
* le Main) au lieu de laisser partir la requête vers l'hôte par défaut
* (avec le `Bearer` restauré — fuite).
*/ */
@Singleton @Singleton
class ServerUrlInterceptor @Inject constructor( class ServerUrlInterceptor @Inject constructor(
@@ -22,6 +28,10 @@ class ServerUrlInterceptor @Inject constructor(
override fun intercept(chain: Interceptor.Chain): Response { override fun intercept(chain: Interceptor.Chain): Response {
val request = chain.request() val request = chain.request()
if (!serverConfigStore.isLoaded) {
runBlocking { serverConfigStore.load() }
}
val targetUrl = runCatching { val targetUrl = runCatching {
(serverConfigStore.current.trimEnd('/') + "/").toHttpUrl() (serverConfigStore.current.trimEnd('/') + "/").toHttpUrl()
}.getOrNull() }.getOrNull()
@@ -32,8 +42,17 @@ class ServerUrlInterceptor @Inject constructor(
} }
val original = request.url val original = request.url
// La base Retrofit placeholder contient déjà le préfixe de chemin
// (`/api/v1`) : ne pas le dupliquer quand le chemin d'origine le porte.
val basePath = targetUrl.encodedPath.trimEnd('/')
val origPath = original.encodedPath
val mergedPath = if (basePath.isNotEmpty() && (origPath == basePath || origPath.startsWith("$basePath/"))) {
origPath
} else {
basePath + "/" + origPath.trimStart('/')
}
val rewritten = targetUrl.newBuilder() val rewritten = targetUrl.newBuilder()
.encodedPath(targetUrl.encodedPath.trimEnd('/') + "/" + original.encodedPath.trimStart('/')) .encodedPath(mergedPath)
.encodedQuery(original.encodedQuery) .encodedQuery(original.encodedQuery)
.build() .build()
@@ -88,6 +88,45 @@ data class LoginResponseDto(
@Json(name = "user") val user: UserDto, @Json(name = "user") val user: UserDto,
) )
/** Requête `PATCH /users/me/password` — `{ current_password, new_password }`. */
data class ChangePasswordDto(
@Json(name = "current_password") val currentPassword: String,
@Json(name = "new_password") val newPassword: String,
)
/** Réponse `PATCH /users/me/password` et `DELETE /files/:id` — `{ id }`. */
data class IdResultDto(
@Json(name = "id") val id: String,
)
/**
* Réponse `GET /shares/links/:token` — métadonnées publiques du lien
* (jamais d'identité du propriétaire au-delà du contrat).
*/
data class ShareLinkDto(
@Json(name = "token") val token: String,
@Json(name = "resource_id") val resourceId: String,
@Json(name = "resourceType") val resourceType: String,
@Json(name = "name") val name: String,
@Json(name = "access") val access: String,
@Json(name = "expiresAt") val expiresAt: String? = null,
)
/**
* Grant actif `GET /files/:id/shares` (owner uniquement) — miroir de
* `ShareGrantDTO` Go. `expiresAt` en ms epoch (null = jamais), même
* convention que le snapshot `ResourcePermissionDto` pour les comparaisons
* locales (`System.currentTimeMillis()`).
*/
data class ShareGrantDto(
@Json(name = "granteeUserId") val granteeUserId: String,
@Json(name = "username") val username: String,
@Json(name = "access") val access: String,
@Json(name = "inherit") val inherit: Boolean,
@Json(name = "expiresAt") val expiresAt: Long? = null,
@Json(name = "updatedAt") val updatedAt: Long = 0L,
)
/** Outbox — une op du batch `POST /sync/ops` (docs/api-v1.md §6.1). */ /** Outbox — une op du batch `POST /sync/ops` (docs/api-v1.md §6.1). */
data class SyncOpDto( data class SyncOpDto(
@Json(name = "operation_id") val operationId: String, @Json(name = "operation_id") val operationId: String,
@@ -116,15 +155,19 @@ data class SyncFailedDto(
@Json(name = "message") val message: String, @Json(name = "message") val message: String,
) )
/** Snapshot `GET /sync/permissions` (docs/api-v1.md §6.2). */ /**
* Snapshot `GET /sync/permissions` (docs/api-v1.md §6.2, miroir de
* `ResourcePermission` Go : `sharedById *string`, `expiresAt *int64` ms epoch).
* M27 : typés (fini les `Any?` jamais lus) — lus par le cache et `canAccess`.
*/
data class ResourcePermissionDto( data class ResourcePermissionDto(
@Json(name = "resource_id") val resourceId: String, @Json(name = "resource_id") val resourceId: String,
@Json(name = "resourceType") val resourceType: String, @Json(name = "resourceType") val resourceType: String,
@Json(name = "effectiveAccess") val effectiveAccess: String, @Json(name = "effectiveAccess") val effectiveAccess: String,
@Json(name = "inherit") val inherit: Boolean, @Json(name = "inherit") val inherit: Boolean,
@Json(name = "ownerId") val ownerId: String? = null, @Json(name = "ownerId") val ownerId: String? = null,
@Json(name = "sharedById") val sharedById: Any? = null, @Json(name = "sharedById") val sharedById: String? = null,
@Json(name = "expiresAt") val expiresAt: Any? = null, @Json(name = "expiresAt") val expiresAt: Long? = null,
@Json(name = "cachedAt") val cachedAt: Long, @Json(name = "cachedAt") val cachedAt: Long,
@Json(name = "updatedAt") val updatedAt: Long, @Json(name = "updatedAt") val updatedAt: Long,
@Json(name = "name") val name: String = "", @Json(name = "name") val name: String = "",
@@ -1,8 +1,10 @@
package com.kazier.mobile.data.repository package com.kazier.mobile.data.repository
import com.kazier.mobile.data.remote.ApiClient import com.kazier.mobile.data.remote.ApiClient
import com.kazier.mobile.data.remote.ApiException
import com.kazier.mobile.data.remote.dto.LoginResponseDto import com.kazier.mobile.data.remote.dto.LoginResponseDto
import com.kazier.mobile.domain.DeviceIdentity import com.kazier.mobile.domain.DeviceIdentity
import kotlin.coroutines.cancellation.CancellationException
import timber.log.Timber import timber.log.Timber
import javax.inject.Inject import javax.inject.Inject
import javax.inject.Singleton import javax.inject.Singleton
@@ -17,11 +19,25 @@ class AuthRepository @Inject constructor(
private val deviceIdentity: DeviceIdentity, private val deviceIdentity: DeviceIdentity,
) { ) {
/** Enregistrement best-effort du device (offline → ignoré). */ /**
* Enregistrement best-effort du device : seules les erreurs réseau et 5xx
* sont ignorées (offline → retry au prochain tick/login). Une 4xx
* (400 `INVALID_DEVICE_ID`, 429 `RATE_LIMITED`, …) est remontée — l'avaler
* rendrait le 401 du login incompréhensible (m23).
*/
suspend fun registerDevice(): String { suspend fun registerDevice(): String {
val deviceId = deviceIdentity.getOrCreate() val deviceId = deviceIdentity.getOrCreate()
runCatching { apiClient.registerDevice(deviceId) } try {
.onFailure { Timber.d(it, "auth: device registration failed (offline?)") } apiClient.registerDevice(deviceId)
} catch (e: CancellationException) {
throw e
} catch (e: ApiException) {
if (e.httpCode == 0 || e.httpCode >= 500) {
Timber.d(e, "auth: device registration failed (offline?)")
} else {
throw e
}
}
return deviceId return deviceId
} }
@@ -29,8 +45,18 @@ class AuthRepository @Inject constructor(
val deviceId = deviceIdentity.getOrCreate() val deviceId = deviceIdentity.getOrCreate()
// Re-registration idempotente juste avant le login : un device inconnu // Re-registration idempotente juste avant le login : un device inconnu
// du serveur (ex. restart de la base) répondrait INVALID_DEVICE_ID. // du serveur (ex. restart de la base) répondrait INVALID_DEVICE_ID.
runCatching { apiClient.registerDevice(deviceId) } // Même politique que registerDevice : 4xx remontée, réseau/5xx ignorés.
.onFailure { Timber.d(it, "auth: pre-login registration failed") } try {
apiClient.registerDevice(deviceId)
} catch (e: CancellationException) {
throw e
} catch (e: ApiException) {
if (e.httpCode == 0 || e.httpCode >= 500) {
Timber.d(e, "auth: pre-login registration failed")
} else {
throw e
}
}
return apiClient.login(username.trim(), password, deviceId) return apiClient.login(username.trim(), password, deviceId)
} }
} }
@@ -2,7 +2,10 @@ package com.kazier.mobile.data.repository
import androidx.room.withTransaction import androidx.room.withTransaction
import com.kazier.mobile.data.local.AppDatabase 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.FileDao
import com.kazier.mobile.data.local.dao.FolderDao
import com.kazier.mobile.data.local.entity.FileEntity import com.kazier.mobile.data.local.entity.FileEntity
import com.kazier.mobile.data.local.entity.FileStatus import com.kazier.mobile.data.local.entity.FileStatus
import com.kazier.mobile.data.remote.ApiClient import com.kazier.mobile.data.remote.ApiClient
@@ -27,6 +30,7 @@ import javax.inject.Singleton
@Singleton @Singleton
class FileRepository @Inject constructor( class FileRepository @Inject constructor(
private val fileDao: FileDao, private val fileDao: FileDao,
private val folderDao: FolderDao,
private val apiClient: ApiClient, private val apiClient: ApiClient,
private val generateId: GenerateId, private val generateId: GenerateId,
private val appDatabase: AppDatabase, private val appDatabase: AppDatabase,
@@ -44,12 +48,20 @@ class FileRepository @Inject constructor(
/** Fichiers visibles de toute l'arborescence — écran d'accueil (grille par date). */ /** Fichiers visibles de toute l'arborescence — écran d'accueil (grille par date). */
fun observeAllVisible(): Flow<List<FileEntity>> = fileDao.observeAllVisible() fun observeAllVisible(): Flow<List<FileEntity>> = fileDao.observeAllVisible()
/** Recherche/filtrage par nom et catégorie (utilisé par SearchViewModel). */ /**
fun searchFiles(query: String?, category: String?): Flow<List<FileEntity>> = * Recherche/filtrage par nom et catégorie (utilisé par SearchViewModel).
fileDao.searchWithFilters( * m7 : la saisie est échappée (`%`/`_` littéraux, pas des jokers) ;
query = query?.trim()?.takeIf { it.isNotEmpty() }, * 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<List<FileEntity>> {
val trimmed = query?.trim()?.takeIf { it.isNotEmpty() }
return fileDao.searchWithFilters(
query = trimmed?.escapeLike(),
normQuery = trimmed?.normalizeSearch()?.escapeLike(),
category = category, category = category,
) )
}
/** Les `limit` fichiers les plus récents (date de référence), filtrés par catégorie. */ /** 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<List<FileEntity>> = fun recentFiles(category: String?, limit: Int = RECENT_LIMIT): Flow<List<FileEntity>> =
@@ -154,7 +166,7 @@ class FileRepository @Inject constructor(
updatedAt = now, updatedAt = now,
) )
appDatabase.withTransaction { appDatabase.withTransaction {
fileDao.upsert(entity) upsertTolerant(entity)
outboxRepository.enqueueCreateResource( outboxRepository.enqueueCreateResource(
resourceId = entity.resourceId, resourceId = entity.resourceId,
resourceType = "file", resourceType = "file",
@@ -169,6 +181,10 @@ class FileRepository @Inject constructor(
suspend fun getAll(): List<FileEntity> = fileDao.getAll() suspend fun getAll(): List<FileEntity> = fileDao.getAll()
/** Lignes sous une racine SAF (m5) — voir `FolderRepository.getUnderRoot`. */
suspend fun getUnderRoot(rootUri: String): List<FileEntity> =
fileDao.getUnderRoot(rootUri, rootUri.escapeLike())
/** /**
* Upsert local d'un fichier SAF — miroir de `saveFile()` JS : déduplication * Upsert local d'un fichier SAF — miroir de `saveFile()` JS : déduplication
* par `resource_id` ou `uri`, conservation de l'identité/sync_status/owner. * par `resource_id` ou `uri`, conservation de l'identité/sync_status/owner.
@@ -184,11 +200,32 @@ class FileRepository @Inject constructor(
val category = computeCategory(input.mimeType, input.extension).dbValue val category = computeCategory(input.mimeType, input.extension).dbValue
// Garde anti-résurrection (C4) : un `delete_resource` déjà journalisé
// (ordre journal-first) interdit de réimporter la ressource — le
// serveur s'apprête à la supprimer et la repasse physique va suivre.
if (existing != null && outboxRepository.hasPendingDeleteOperation(existing.resourceId)) {
if (existing.exists != 0) fileDao.markMissing(existing.resourceId, now)
return existing.copy(exists = 0, updatedAt = now)
}
// Un `move_resource` encore en attente fait de la cible outbox la // 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é // 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. // avant le move) ne doit pas ré-attribuer le dossier à l'ancien parent.
val movePending = existing != null && outboxRepository.hasPendingMoveOperation(existing.resourceId) val movePending = existing != null && outboxRepository.hasPendingMoveOperation(existing.resourceId)
val effectiveFolder = if (movePending) existing.folderResourceId else folderResourceId val effectiveFolder = if (movePending) existing.folderResourceId else folderResourceId
// Pas de FK `files → folders` : le parent est validé ici (orphelin
// refusé au lieu d'une ligne fantôme jamais affichable).
require(folderDao.getByResourceId(effectiveFolder) != null) {
"unknown parent folder: $effectiveFolder"
}
// Un fichier cloud-only (snapshot serveur) réimporté en SAF devient
// `local-cloud` : le serveur le connaît déjà, la copie physique aussi.
val placement = if (existing != null && existing.uri == null && existing.syncStatus == FileStatus.CLOUD) {
SyncPlacement.confirmed(hasLocalUri = true)
} else {
existing?.syncStatus ?: input.syncStatus ?: FileStatus.LOCAL
}
val entity = FileEntity( val entity = FileEntity(
id = existing?.id ?: 0L, id = existing?.id ?: 0L,
@@ -203,7 +240,7 @@ class FileRepository @Inject constructor(
exists = if (input.exists) 1 else 0, exists = if (input.exists) 1 else 0,
lastModified = input.lastModified, lastModified = input.lastModified,
ownerId = ownerId ?: existing?.ownerId, ownerId = ownerId ?: existing?.ownerId,
syncStatus = existing?.syncStatus ?: input.syncStatus ?: FileStatus.LOCAL, syncStatus = placement,
// Une ligne existante liée reste à son état ; une nouvelle ligne est // Une ligne existante liée reste à son état ; une nouvelle ligne est
// « traitée » si la source l'a demandé (ex. scan), sinon à traiter. // « traitée » si la source l'a demandé (ex. scan), sinon à traiter.
processed = existing?.processed ?: input.processed, processed = existing?.processed ?: input.processed,
@@ -211,7 +248,7 @@ class FileRepository @Inject constructor(
updatedAt = now, updatedAt = now,
) )
appDatabase.withTransaction { appDatabase.withTransaction {
fileDao.upsert(entity) upsertTolerant(entity)
if (existing == null && entity.processed) { if (existing == null && entity.processed) {
// Nouveau fichier physique déjà « traité » (ex. scan export) : // Nouveau fichier physique déjà « traité » (ex. scan export) :
// poussé immédiatement. Un fichier SAF tout juste découvert // poussé immédiatement. Un fichier SAF tout juste découvert
@@ -234,13 +271,22 @@ class FileRepository @Inject constructor(
suspend fun markMissing(resourceId: String, updatedAt: Long) = suspend fun markMissing(resourceId: String, updatedAt: Long) =
fileDao.markMissing(resourceId, updatedAt) fileDao.markMissing(resourceId, updatedAt)
/** Met à jour la cible dossier d'un fichier (déplacement local / cloud-only). */ /** 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
* ressource (gate `create`) : déplacer un fichier jamais poussé est une
* opération purement locale, un move serveur serait `NOT_FOUND`/no-op et
* figerait la ligne derrière `hasPendingMoveOperation`. */
suspend fun applyMove(resourceId: String, folderId: String, newUri: String?) { suspend fun applyMove(resourceId: String, folderId: String, newUri: String?) {
require(folderDao.getByResourceId(folderId) != null) {
"unknown target folder: $folderId"
}
val now = System.currentTimeMillis() val now = System.currentTimeMillis()
appDatabase.withTransaction { appDatabase.withTransaction {
fileDao.moveToFolder(listOf(resourceId), folderId, now) fileDao.moveToFolder(listOf(resourceId), folderId, now)
if (newUri != null) fileDao.updateUri(resourceId, newUri) if (newUri != null) fileDao.updateUri(resourceId, newUri, now)
// Déplacement reflété localement ←→ poussé vers le serveur. // Déplacement reflété localement ←→ poussé vers le serveur.
if (outboxRepository.hasCreateOperation(resourceId)) {
outboxRepository.enqueueMoveResource( outboxRepository.enqueueMoveResource(
resourceId = resourceId, resourceId = resourceId,
resourceType = "file", resourceType = "file",
@@ -248,10 +294,12 @@ class FileRepository @Inject constructor(
) )
} }
} }
}
/** /**
* `GET /files?folderId=...` (1re page, tri serveur) puis upsert cloud de * `GET /files?folderId=...` drainé page par page en suivant `meta`
* chaque fichier. Ne supprime jamais de lignes locales. * (page/pageSize/total), puis upsert cloud de chaque fichier. Ne supprime
* jamais de lignes locales.
* *
* Garde-fou outbox : un fichier dont le `move_resource` n'a pas encore été * Garde-fou outbox : un fichier dont le `move_resource` n'a pas encore été
* poussé garde son placement local. Le serveur renvoie encore l'ancien * poussé garde son placement local. Le serveur renvoie encore l'ancien
@@ -259,15 +307,47 @@ class FileRepository @Inject constructor(
* du dossier cible (et réapparaître dans l'ancien). * du dossier cible (et réapparaître dans l'ancien).
*/ */
suspend fun refreshFromServer(folderResourceId: String) { suspend fun refreshFromServer(folderResourceId: String) {
val files = apiClient.listFiles(folderId = folderResourceId, pageSize = PAGE_SIZE)
if (files.isEmpty()) return
val now = System.currentTimeMillis() val now = System.currentTimeMillis()
var page = 1
while (page <= MAX_PAGES) {
val (files, meta) = apiClient.listFilesPaged(
folderId = folderResourceId,
page = page,
pageSize = PAGE_SIZE,
)
files.forEach { dto -> files.forEach { dto ->
if (outboxRepository.hasPendingMoveOperation(dto.id)) { if (outboxRepository.hasPendingMoveOperation(dto.id)) {
// L'antichambre outbox fait foi tant que le move n'est pas synced. // L'antichambre outbox fait foi tant que le move n'est pas synced.
return@forEach return@forEach
} }
fileDao.upsert(toEntity(dto, folderResourceId, now)) upsertTolerant(toEntity(dto, folderResourceId, now))
}
if (files.isEmpty()) break
val total = meta?.total
if (total != null) {
// `total` contractuel : arrêter dès la couverture atteinte.
if (page * PAGE_SIZE >= total) break
} else if (files.size < PAGE_SIZE) {
// Sans `meta` (vieux serveur) : dernière page partielle.
break
}
page++
}
}
/**
* Upsert résolu sur les contraintes uniques (`resource_id`, `uri`), pas
* sur la PK : insert-or-ignore puis update du gagnant en cas de conflit.
* Les courses walk/refresh ne lèvent jamais `SQLiteConstraintException`.
*/
private suspend fun upsertTolerant(entity: FileEntity) {
if (fileDao.insertIgnore(entity) != -1L) return
val winner = entity.uri?.let { fileDao.getByUri(it) }
?: fileDao.getByResourceId(entity.resourceId)
if (winner != null) {
fileDao.update(entity.copy(id = winner.id, resourceId = winner.resourceId))
} else {
fileDao.upsert(entity)
} }
} }
@@ -301,6 +381,8 @@ class FileRepository @Inject constructor(
companion object { companion object {
private const val PAGE_SIZE = 50 private const val PAGE_SIZE = 50
private const val RECENT_LIMIT = 5 private const val RECENT_LIMIT = 5
/** Garde anti-boucle si le serveur renvoie un `total` incohérent. */
private const val MAX_PAGES = 2000
} }
} }
@@ -2,12 +2,13 @@ package com.kazier.mobile.data.repository
import androidx.room.withTransaction import androidx.room.withTransaction
import com.kazier.mobile.data.local.AppDatabase import com.kazier.mobile.data.local.AppDatabase
import com.kazier.mobile.data.local.escapeLike
import com.kazier.mobile.data.local.dao.FolderDao import com.kazier.mobile.data.local.dao.FolderDao
import com.kazier.mobile.data.local.entity.FolderEntity import com.kazier.mobile.data.local.entity.FolderEntity
import com.kazier.mobile.data.local.entity.FolderStatus import com.kazier.mobile.data.local.entity.FolderStatus
import com.kazier.mobile.data.remote.ApiClient import com.kazier.mobile.data.remote.ApiClient
import com.kazier.mobile.data.remote.dto.FolderDto import com.kazier.mobile.data.remote.dto.FolderDto
import com.kazier.mobile.domain.DeviceIdentity import com.kazier.mobile.domain.ActiveUserStore
import com.kazier.mobile.domain.GenerateId import com.kazier.mobile.domain.GenerateId
import com.kazier.mobile.domain.SyncPlacement import com.kazier.mobile.domain.SyncPlacement
import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.Flow
@@ -26,7 +27,7 @@ class FolderRepository @Inject constructor(
private val folderDao: FolderDao, private val folderDao: FolderDao,
private val apiClient: ApiClient, private val apiClient: ApiClient,
private val generateId: GenerateId, private val generateId: GenerateId,
private val deviceIdentity: DeviceIdentity, private val activeUserStore: ActiveUserStore,
private val appDatabase: AppDatabase, private val appDatabase: AppDatabase,
private val outboxRepository: OutboxRepository, private val outboxRepository: OutboxRepository,
) { ) {
@@ -44,6 +45,13 @@ class FolderRepository @Inject constructor(
suspend fun getAll(): List<FolderEntity> = folderDao.getAll() suspend fun getAll(): List<FolderEntity> = folderDao.getAll()
/**
* Lignes sous une racine SAF (m5) : la racine est échappée pour le `LIKE`
* (les uris SAF contiennent des `%` d'encodage et parfois des `_`).
*/
suspend fun getUnderRoot(rootUri: String): List<FolderEntity> =
folderDao.getUnderRoot(rootUri, rootUri.escapeLike())
/** Snapshot des sous-dossiers visibles d'un dossier (opérations batch hors UI). */ /** Snapshot des sous-dossiers visibles d'un dossier (opérations batch hors UI). */
suspend fun getChildren(parentResourceId: String): List<FolderEntity> = suspend fun getChildren(parentResourceId: String): List<FolderEntity> =
folderDao.getByParentOnce(parentResourceId) folderDao.getByParentOnce(parentResourceId)
@@ -66,7 +74,14 @@ class FolderRepository @Inject constructor(
val folders = apiClient.listFolders() val folders = apiClient.listFolders()
if (folders.isEmpty()) return if (folders.isEmpty()) return
val now = System.currentTimeMillis() val now = System.currentTimeMillis()
folderDao.upsertAll(folders.map { toEntity(it, now) }) val rows = folders
.filterNot { dto ->
// L'antichambre outbox fait foi tant que le move n'est pas
// synced : le serveur renvoie encore l'ancien parent.
outboxRepository.hasPendingMoveOperation(dto.id)
}
.map { toEntity(it, now) }
if (rows.isNotEmpty()) folderDao.upsertAll(rows)
} }
private suspend fun toEntity(dto: FolderDto, now: Long): FolderEntity { private suspend fun toEntity(dto: FolderDto, now: Long): FolderEntity {
@@ -76,7 +91,8 @@ class FolderRepository @Inject constructor(
resourceId = dto.id, resourceId = dto.id,
uri = existing?.uri, uri = existing?.uri,
name = dto.name, name = dto.name,
exists = existing?.exists, // M13 : une ligne serveur nouvelle n'a pas d'`exists` local — 1 par défaut.
exists = existing?.exists ?: 1,
parentResourceId = dto.parentId, parentResourceId = dto.parentId,
ownerId = existing?.ownerId, ownerId = existing?.ownerId,
// Le snapshot serveur confirme la présence cloud : si une copie // Le snapshot serveur confirme la présence cloud : si une copie
@@ -93,8 +109,10 @@ class FolderRepository @Inject constructor(
* ajoute une ligne avec sa `uri` si absente, ou met à jour ses champs. * ajoute une ligne avec sa `uri` si absente, ou met à jour ses champs.
* *
* `parentResourceId` non-null écrase le parent existant (un déplacement dans * `parentResourceId` non-null écrase le parent existant (un déplacement dans
* l'arborescence SAF est reflété) ; null préserve le parent courant. `ownerId` * l'arborescence SAF est reflété) ; null préserve le parent courant — sauf
* optionnel évite de relire l'identité device à chaque ligne d'un walk. * `move_resource` en attente, qui fait de la cible outbox la source de
* vérité du placement (miroir du garde fichiers). `ownerId`
* optionnel évite de relire le compte actif à chaque ligne d'un walk.
*/ */
suspend fun saveFolder( suspend fun saveFolder(
input: SaveFolderInput, input: SaveFolderInput,
@@ -105,21 +123,49 @@ class FolderRepository @Inject constructor(
val existing = input.resourceId?.let { folderDao.getByResourceId(it) } val existing = input.resourceId?.let { folderDao.getByResourceId(it) }
?: input.uri?.let { folderDao.getByUri(it) } ?: input.uri?.let { folderDao.getByUri(it) }
// Garde anti-résurrection (C4) : voir `FileRepository.saveLocalFile`.
if (existing != null && outboxRepository.hasPendingDeleteOperation(existing.resourceId)) {
if (existing.exists != 0) folderDao.markMissing(existing.resourceId, now)
return existing.copy(exists = 0, updatedAt = now)
}
// 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)
val effectiveParent = if (movePending) existing.parentResourceId else (parentResourceId ?: existing?.parentResourceId)
// Pas de FK `files → folders` : le parent est validé ici (orphelin
// refusé au lieu d'une ligne fantôme jamais affichable).
if (effectiveParent != null && folderDao.getByResourceId(effectiveParent) == null) {
throw IllegalArgumentException("unknown parent folder: $effectiveParent")
}
// Un dossier cloud-only réimporté en SAF devient `local-cloud`.
val placement = if (existing != null && existing.uri == null && input.uri != null &&
existing.syncStatus == FolderStatus.CLOUD
) {
SyncPlacement.confirmed(hasLocalUri = true)
} else {
existing?.syncStatus ?: FolderStatus.LOCAL
}
val entity = FolderEntity( val entity = FolderEntity(
id = existing?.id ?: 0L, id = existing?.id ?: 0L,
resourceId = existing?.resourceId ?: input.resourceId ?: generateId.newResourceId(), resourceId = existing?.resourceId ?: input.resourceId ?: generateId.newResourceId(),
uri = input.uri, uri = input.uri,
name = input.name, name = input.name,
exists = input.exists?.let { if (it) 1 else 0 }, // M13 : `null` (défaut de `SaveFolderInput`) = présent, jamais NULL
parentResourceId = parentResourceId ?: existing?.parentResourceId, // en base — sinon la ligne disparaît des requêtes `exists = 1`.
ownerId = ownerId ?: existing?.ownerId ?: deviceIdentity.getOrCreate(), exists = if (input.exists != false) 1 else 0,
syncStatus = existing?.syncStatus ?: FolderStatus.LOCAL, parentResourceId = effectiveParent,
// `owner_id` Room = user_id du compte actif, jamais l'identité device.
ownerId = ownerId ?: existing?.ownerId ?: activeUserStore.get(),
syncStatus = placement,
createdInApp = existing?.createdInApp ?: input.createdInApp, createdInApp = existing?.createdInApp ?: input.createdInApp,
addedAt = existing?.addedAt ?: now, addedAt = existing?.addedAt ?: now,
updatedAt = now, updatedAt = now,
) )
appDatabase.withTransaction { appDatabase.withTransaction {
folderDao.upsert(entity) upsertTolerant(entity)
if (existing == null) { if (existing == null) {
// Nouvelle ressource physique → la pousser vers le serveur. // Nouvelle ressource physique → la pousser vers le serveur.
outboxRepository.enqueueCreateResource( outboxRepository.enqueueCreateResource(
@@ -140,13 +186,21 @@ class FolderRepository @Inject constructor(
/** /**
* Re-parente des sous-dossiers vers un nouveau parent (fusion de dossiers). * Re-parente des sous-dossiers vers un nouveau parent (fusion de dossiers).
* Transaction atomique : reparent Room + outbox `move_resource` par dossier. * Transaction atomique : reparent Room + outbox `move_resource` par dossier.
*
* Le `move_resource` n'est journalisé que si le serveur connaît déjà le
* dossier (gate `create`, miroir fichiers) : sinon le move serait
* `NOT_FOUND` et figerait la ligne derrière `hasPendingMoveOperation`.
*/ */
suspend fun reparentSubFolders(resourceIds: List<String>, newParentId: String) { suspend fun reparentSubFolders(resourceIds: List<String>, newParentId: String) {
if (resourceIds.isEmpty()) return if (resourceIds.isEmpty()) return
require(folderDao.getByResourceId(newParentId) != null) {
"unknown target folder: $newParentId"
}
val now = System.currentTimeMillis() val now = System.currentTimeMillis()
appDatabase.withTransaction { appDatabase.withTransaction {
folderDao.reparent(resourceIds, newParentId, now) folderDao.reparent(resourceIds, newParentId, now)
for (resourceId in resourceIds) { for (resourceId in resourceIds) {
if (outboxRepository.hasCreateOperationAnyType(resourceId)) {
outboxRepository.enqueueMoveResource( outboxRepository.enqueueMoveResource(
resourceId = resourceId, resourceId = resourceId,
resourceType = "folder", resourceType = "folder",
@@ -157,6 +211,22 @@ class FolderRepository @Inject constructor(
} }
} }
/**
* Upsert résolu sur les contraintes uniques (`resource_id`, `uri`), pas
* sur la PK : insert-or-ignore puis update du gagnant en cas de conflit.
*/
private suspend fun upsertTolerant(entity: FolderEntity) {
if (folderDao.insertIgnore(entity) != -1L) return
val winner = entity.uri?.let { folderDao.getByUri(it) }
?: folderDao.getByResourceId(entity.resourceId)
if (winner != null) {
folderDao.update(entity.copy(id = winner.id, resourceId = winner.resourceId))
} else {
folderDao.upsert(entity)
}
}
}
data class SaveFolderInput( data class SaveFolderInput(
val uri: String?, val uri: String?,
val name: String, val name: String,
@@ -62,12 +62,27 @@ class OcrRepository @Inject constructor(
/** /**
* Poll toutes les 3 s (docs §5) jusqu'à l'état terminal. [onProgress] est * Poll toutes les 3 s (docs §5) jusqu'à l'état terminal. [onProgress] est
* appelé à chaque réponse du serveur (état courant exposé à l'UI). * appelé à chaque réponse du serveur (état courant exposé à l'UI).
*
* m20 : borné (deadline + nombre max de polls) — un job resté `processing`
* (stale claim serveur) levait sinon une coroutine tenue indéfiniment.
* Le timeout remonte en `ApiException("OCR_TIMEOUT")`, géré comme échec
* par les appelants (`processAuto` → `Failed`, viewer → message d'erreur).
*/ */
suspend fun poll(jobId: String, onProgress: (OcrJobDto) -> Unit = {}): OcrJobDto { suspend fun poll(
jobId: String,
timeoutMs: Long = POLL_TIMEOUT_MS,
onProgress: (OcrJobDto) -> Unit = {},
): OcrJobDto {
val deadline = System.currentTimeMillis() + timeoutMs
var polls = 0
while (true) { while (true) {
val job = apiClient.getOcrJob(jobId) val job = apiClient.getOcrJob(jobId)
onProgress(job) onProgress(job)
if (job.status in OcrJobStatus.TERMINAL) return job if (job.status in OcrJobStatus.TERMINAL) return job
polls++
if (polls >= POLL_MAX_ATTEMPTS || System.currentTimeMillis() >= deadline) {
throw ApiException("OCR_TIMEOUT", "OCR sans réponse (job $jobId)", 0)
}
delay(POLL_INTERVAL_MS) delay(POLL_INTERVAL_MS)
} }
} }
@@ -144,6 +159,9 @@ class OcrRepository @Inject constructor(
companion object { companion object {
const val POLL_INTERVAL_MS = 3_000L const val POLL_INTERVAL_MS = 3_000L
/** Timeout du poll (m20) : 10 min ≈ 200 polls × 3 s. */
const val POLL_TIMEOUT_MS = 10 * 60 * 1_000L
const val POLL_MAX_ATTEMPTS = 200
} }
} }
@@ -7,6 +7,7 @@ import com.kazier.mobile.data.local.dao.PendingOperationDao
import com.kazier.mobile.data.local.entity.PendingOpStatus import com.kazier.mobile.data.local.entity.PendingOpStatus
import com.kazier.mobile.data.local.entity.PendingOperationEntity import com.kazier.mobile.data.local.entity.PendingOperationEntity
import com.kazier.mobile.data.local.entity.PendingOperationType import com.kazier.mobile.data.local.entity.PendingOperationType
import com.kazier.mobile.domain.DeviceIdentity
import com.kazier.mobile.domain.GenerateId import com.kazier.mobile.domain.GenerateId
import javax.inject.Inject import javax.inject.Inject
import javax.inject.Singleton import javax.inject.Singleton
@@ -23,6 +24,7 @@ import javax.inject.Singleton
class OutboxRepository @Inject constructor( class OutboxRepository @Inject constructor(
private val pendingOperationDao: PendingOperationDao, private val pendingOperationDao: PendingOperationDao,
private val generateId: GenerateId, private val generateId: GenerateId,
private val deviceIdentity: DeviceIdentity,
moshi: Moshi, moshi: Moshi,
) { ) {
@@ -46,6 +48,9 @@ class OutboxRepository @Inject constructor(
val now = System.currentTimeMillis() val now = System.currentTimeMillis()
pendingOperationDao.insert( pendingOperationDao.insert(
PendingOperationEntity( PendingOperationEntity(
// Clé d'idempotence locale UNIQUE(device_id, operation_id)
// (contrat docs/api-v1.md §6.1).
deviceId = deviceIdentity.getOrCreate(),
operationId = operationId, operationId = operationId,
refType = refType, refType = refType,
refId = refId, refId = refId,
@@ -53,6 +58,9 @@ class OutboxRepository @Inject constructor(
resourceType = resourceType, resourceType = resourceType,
operation = operation, operation = operation,
payload = payloadAdapter.toJson(payload), payload = payloadAdapter.toJson(payload),
// Lien parent→enfant dénormalisé pour la cascade (P8) —
// même clé que le payload JSON ci-dessous.
parentResourceId = payload[PARENT_PAYLOAD_KEY] as? String,
status = PendingOpStatus.PENDING, status = PendingOpStatus.PENDING,
createdAt = now, createdAt = now,
updatedAt = now, updatedAt = now,
@@ -138,9 +146,89 @@ class OutboxRepository @Inject constructor(
payload = mapOf("granteeUserId" to granteeUserId), payload = mapOf("granteeUserId" to granteeUserId),
) )
/**
* Raccourci `update_metadata` — payload `{ name }` (rename d'une ressource
* partagée, `editor+`, docs/api-v1.md §6.1). m21 : rend le rename partagé
* émissible — l'op n'avait aucun écrivain côté client.
*/
suspend fun enqueueUpdateMetadata(
resourceId: String,
resourceType: String,
name: String,
): String = enqueue(
operation = PendingOperationType.UPDATE_METADATA,
resourceId = resourceId,
resourceType = resourceType,
payload = mapOf("name" to name),
)
/**
* Raccourci `update_share` — même payload que `share` (m21 : update d'un
* partage existant inopérant sans écrivain).
*/
suspend fun enqueueUpdateShare(
resourceId: String,
resourceType: String,
granteeUserId: String,
access: String,
inherit: Boolean = true,
expiresAt: Long? = null,
): String = enqueue(
operation = PendingOperationType.UPDATE_SHARE,
resourceId = resourceId,
resourceType = resourceType,
payload = buildMap {
put("granteeUserId", granteeUserId)
put("access", access)
put("inherit", inherit)
expiresAt?.let { put("expiresAt", it) }
},
)
/**
* Raccourci `create_link` — payload `{ token, access, expiresAt? }`
* (m21 : liens publics inopérants sans écrivain). Le `token` 32-hex est
* généré côté client (`GenerateId`) : c'est l'identifiant du lien.
*/
suspend fun enqueueCreateLink(
resourceId: String,
resourceType: String,
token: String,
access: String,
expiresAt: Long? = null,
): String = enqueue(
operation = PendingOperationType.CREATE_LINK,
resourceId = resourceId,
resourceType = resourceType,
payload = buildMap {
put("token", token)
put("access", access)
expiresAt?.let { put("expiresAt", it) }
},
)
/** Raccourci `revoke_link` — payload `{ token }` (m21). */
suspend fun enqueueRevokeLink(
resourceId: String,
resourceType: String,
token: String,
): String = enqueue(
operation = PendingOperationType.REVOKE_LINK,
resourceId = resourceId,
resourceType = resourceType,
payload = mapOf("token" to token),
)
/** Nombre d'ops en attente de push (stats UI optionnelles). */ /** Nombre d'ops en attente de push (stats UI optionnelles). */
suspend fun countPending(): Int = pendingOperationDao.countPending() suspend fun countPending(): Int = pendingOperationDao.countPending()
/**
* Ops de partage en attente pour une ressource (sheet de partage :
* « en attente d'envoi », pas encore reflétées par les listes serveur).
*/
suspend fun pendingShareOps(resourceId: String): List<PendingOperationEntity> =
pendingOperationDao.pendingShareOps(resourceId)
/** /**
* Un `create_resource` (pending ou synced) existe-t-il déjà pour ce fichier ? * Un `create_resource` (pending ou synced) existe-t-il déjà pour ce fichier ?
* Utilisé par le gate « processed » : seuls les fichiers traités déclenchent * Utilisé par le gate « processed » : seuls les fichiers traités déclenchent
@@ -158,6 +246,27 @@ class OutboxRepository @Inject constructor(
suspend fun hasCreateOperationAnyType(resourceId: String): Boolean = suspend fun hasCreateOperationAnyType(resourceId: String): Boolean =
pendingOperationDao.countCreateOperationsAnyType(resourceId) > 0 pendingOperationDao.countCreateOperationsAnyType(resourceId) > 0
/**
* Le serveur connaît-il déjà ce fichier (create `synced`) ? Gate delete
* précis (M19) : après [cancelPendingCreates], un `delete_resource` n'est
* émis que dans ce cas — jamais pour une ressource que le serveur n'a
* jamais vue (ni bruit create-puis-delete, ni `NOT_FOUND`).
*/
suspend fun hasSyncedCreateOperation(resourceId: String): Boolean =
pendingOperationDao.countSyncedCreateOperations(resourceId) > 0
/** Variante dossiers de [hasSyncedCreateOperation]. */
suspend fun hasSyncedCreateOperationAnyType(resourceId: String): Boolean =
pendingOperationDao.countSyncedCreateOperationsAnyType(resourceId) > 0
/**
* Annulation (M19) : supprime les `create_resource` encore `pending` pour
* cette ressource qui disparaît localement avant que le serveur l'ait
* connue. Retourne le nombre d'ops annulées.
*/
suspend fun cancelPendingCreates(resourceId: String): Int =
pendingOperationDao.deletePendingCreates(resourceId)
/** /**
* Un `move_resource` est-il encore en attente de push ? Tant que l'op est * 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 * pendante, le `folder_resource_id` local reflète la cible future : ni le
@@ -167,6 +276,23 @@ class OutboxRepository @Inject constructor(
suspend fun hasPendingMoveOperation(resourceId: String): Boolean = suspend fun hasPendingMoveOperation(resourceId: String): Boolean =
pendingOperationDao.countPendingMoveOperations(resourceId) > 0 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.
*/
suspend fun hasPendingDeleteOperation(resourceId: String): Boolean =
pendingOperationDao.countPendingDeleteOperations(resourceId) > 0
companion object {
/**
* Clé du lien parent→enfant, à la fois dans le payload JSON
* `create_resource` (protocole, lu par `OutboxSyncWorker`) et dans la
* colonne dénormalisée `parent_resource_id` (cascade SQL).
*/
const val PARENT_PAYLOAD_KEY = "parentResourceId"
}
/** /**
* Un `move_resource` (pending ou synced) a-t-il jamais été journalisé ? * Un `move_resource` (pending ou synced) a-t-il jamais été journalisé ?
* Utilisé par la réconciliation du walk : une ligne en transition physique * Utilisé par la réconciliation du walk : une ligne en transition physique
@@ -0,0 +1,23 @@
package com.kazier.mobile.data.repository
import com.kazier.mobile.data.remote.ApiClient
import javax.inject.Inject
import javax.inject.Singleton
/**
* Contenu distant en streaming (V1 finitions, lot download).
*
* Lit les octets physiques d'un fichier visible via
* `GET /files/:id/content` (binaire brut, hors enveloppe) sans jamais les
* persister : ni Room, ni SAF, ni fichier durable. Seul le rendu PDF exige
* un fichier temporaire du `cacheDir`, créé à la volée par le viewer et
* supprimé à sa sortie (éphémère, pas un cache).
*/
@Singleton
class RemoteContentRepository @Inject constructor(
private val apiClient: ApiClient,
) {
/** Octets du fichier, bornés ([ApiClient.MAX_CONTENT_BYTES]). */
suspend fun fetch(fileId: String): ByteArray =
apiClient.downloadContentBytes(fileId)
}
@@ -9,6 +9,8 @@ import com.kazier.mobile.data.local.entity.ScanSessionEntity
import com.kazier.mobile.data.local.entity.ScanSessionStatus import com.kazier.mobile.data.local.entity.ScanSessionStatus
import com.kazier.mobile.domain.GenerateId import com.kazier.mobile.domain.GenerateId
import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import javax.inject.Inject import javax.inject.Inject
import javax.inject.Singleton import javax.inject.Singleton
@@ -24,8 +26,16 @@ class ScanRepository @Inject constructor(
private val generateId: GenerateId, private val generateId: GenerateId,
) { ) {
suspend fun getOrCreateActiveSession(rootFolderId: String?): ScanSessionEntity { /**
scanDao.getActiveSession()?.let { return it } * Single-flight de création de session : sans garde, deux appels
* concurrents créent deux sessions `active` (aucune unicité partielle
* côté Room) et orphelinent les pages de l'une d'elles.
*/
private val sessionMutex = Mutex()
suspend fun getOrCreateActiveSession(rootFolderId: String?): ScanSessionEntity =
sessionMutex.withLock {
scanDao.getActiveSession()?.let { return@withLock it }
val now = System.currentTimeMillis() val now = System.currentTimeMillis()
val sessionId = scanDao.insertSession( val sessionId = scanDao.insertSession(
ScanSessionEntity( ScanSessionEntity(
@@ -36,7 +46,7 @@ class ScanRepository @Inject constructor(
updatedAt = now, updatedAt = now,
), ),
) )
return checkNotNull(scanDao.getSession(sessionId)) checkNotNull(scanDao.getSession(sessionId))
} }
suspend fun setRootFolder(sessionId: Long, rootFolderId: String) { suspend fun setRootFolder(sessionId: Long, rootFolderId: String) {
@@ -61,7 +71,10 @@ class ScanRepository @Inject constructor(
height: Int, height: Int,
): ScanPageEntity { ): ScanPageEntity {
val now = System.currentTimeMillis() val now = System.currentTimeMillis()
val order = scanDao.pageCount(session.id) // MAX + 1, jamais COUNT : après suppression, COUNT réutilise un ordre
// existant (doublons → `ORDER BY sort_order` instable, `swapOrder`
// ambigu), MAX + 1 reste strictement unique et croissant.
val order = (scanDao.maxSortOrder(session.id) ?: -1) + 1
val page = ScanPageEntity( val page = ScanPageEntity(
resourceId = generateId.newResourceId(), resourceId = generateId.newResourceId(),
sessionId = session.id, sessionId = session.id,
@@ -73,8 +86,10 @@ class ScanRepository @Inject constructor(
status = ScanPageStatus.PENDING, status = ScanPageStatus.PENDING,
createdAt = now, createdAt = now,
) )
scanDao.insertPage(page) // L'id auto-généré est indispensable : sans lui, deletePage/movePage
return page // ciblent l'id 0 et ne touchent aucune ligne.
val rowId = scanDao.insertPage(page)
return page.copy(id = rowId)
} }
suspend fun deletePage(pageId: Long, sessionId: Long) { suspend fun deletePage(pageId: Long, sessionId: Long) {
@@ -83,6 +98,13 @@ class ScanRepository @Inject constructor(
} }
} }
/** Supprime une session abandonnée vide (jamais de session orpheline). */
suspend fun deleteSession(sessionId: Long) {
appDatabase.withTransaction {
scanDao.deleteSession(sessionId)
}
}
suspend fun movePage(sessionId: Long, pages: List<ScanPageEntity>, pageId: Long, delta: Int) { suspend fun movePage(sessionId: Long, pages: List<ScanPageEntity>, pageId: Long, delta: Int) {
val index = pages.indexOfFirst { it.id == pageId } val index = pages.indexOfFirst { it.id == pageId }
val target = index + delta val target = index + delta
@@ -4,11 +4,15 @@ import androidx.room.withTransaction
import com.kazier.mobile.data.local.AppDatabase import com.kazier.mobile.data.local.AppDatabase
import com.kazier.mobile.data.local.dao.FileDao import com.kazier.mobile.data.local.dao.FileDao
import com.kazier.mobile.data.local.dao.FolderDao import com.kazier.mobile.data.local.dao.FolderDao
import com.kazier.mobile.data.local.entity.AccessRank
import com.kazier.mobile.data.local.entity.FileEntity import com.kazier.mobile.data.local.entity.FileEntity
import com.kazier.mobile.data.local.entity.FolderEntity import com.kazier.mobile.data.local.entity.FolderEntity
import com.kazier.mobile.data.local.entity.ResourcePermissionEntity
import com.kazier.mobile.data.local.entity.UserPreferenceEntity
import com.kazier.mobile.data.remote.ApiClient import com.kazier.mobile.data.remote.ApiClient
import com.kazier.mobile.data.remote.dto.ResourcePermissionDto import com.kazier.mobile.data.remote.dto.ResourcePermissionDto
import com.kazier.mobile.domain.DeviceIdentity import com.kazier.mobile.domain.ActiveUserStore
import com.kazier.mobile.domain.PrefKeys
import com.kazier.mobile.domain.SyncPlacement import com.kazier.mobile.domain.SyncPlacement
import timber.log.Timber import timber.log.Timber
import javax.inject.Inject import javax.inject.Inject
@@ -21,41 +25,80 @@ import javax.inject.Singleton
* de l'utilisateur. Les ressources non possédées (viewer/commenter/editor) * de l'utilisateur. Les ressources non possédées (viewer/commenter/editor)
* sont importées en tant que lignes cloud-only (`uri = NULL`, `sync_status = "cloud"`). * sont importées en tant que lignes cloud-only (`uri = NULL`, `sync_status = "cloud"`).
* *
* Un pull complet (`after=0`) est effectué au login et à la restauration de * M27 — delta, expiration et `canAccess` :
* session pour garantir la convergence (révocations = disparition du snapshot). * - le `cachedAt` du dernier pull est persisté (`user_preferences`) : pull
* complet (`after = null`) au premier appel, au login/restauration
* (`forceFull = true`) et quand le cache dépasse le TTL 24h ; delta
* (`after = cachedAt`) sinon — la convergence (lignes absentes = révoquées)
* ne tourne que sur pull complet ;
* - chaque grant non-owner est persisté en `resource_permissions` (rang,
* expiration, fraîcheur) : un grant expiré (`expiresAt` passé) masque la
* ligne locale au lieu de rester visible jusqu'au prochain login ;
* - [canAccess] répond offline (ownership local, puis rang persisté, avec
* downgrade lecture seule après TTL sans reseed).
*/ */
@Singleton @Singleton
class ShareRepository @Inject constructor( class ShareRepository @Inject constructor(
private val apiClient: ApiClient, private val apiClient: ApiClient,
private val appDatabase: AppDatabase, private val appDatabase: AppDatabase,
private val deviceIdentity: DeviceIdentity, private val activeUserStore: ActiveUserStore,
) { ) {
/** /**
* Récupère le snapshot complet des permissions et hydrate Room. * Récupère le snapshot des permissions et hydrate Room + le cache.
* *
* Pour chaque permission non-owner : * Pour chaque permission non-owner non expirée :
* - Folders : upsert cloud-only (uri=null, name, parentId, ownerId) * - Folders : upsert cloud-only (uri=null, name, parentId, ownerId)
* - Files : upsert cloud-only (uri=null, name, folderResourceId, ownerId, processed=true) * - Files : upsert cloud-only (uri=null, name, folderResourceId, ownerId, processed=true)
* *
* Convergence : les lignes cloud-only absentes du snapshot complet sont * Convergence (pull complet uniquement) : les lignes cloud-only absentes
* marquées `exists = 0`. * du snapshot complet sont marquées `exists = 0`, et les grants du cache
* absents sont oubliés.
*/ */
suspend fun syncSnapshot() { suspend fun syncSnapshot(forceFull: Boolean = false) {
val currentUserId = deviceIdentity.getOrCreate() // `ownerId` serveur = user_id : comparer au compte actif, jamais au device.
val permissions = apiClient.syncPermissions() val currentUserId = activeUserStore.get()
val prefs = appDatabase.userPreferenceDao()
val permDao = appDatabase.resourcePermissionDao()
val now = System.currentTimeMillis() val now = System.currentTimeMillis()
val cachedAt = prefs.getValue(PrefKeys.PERMISSIONS_CACHED_AT)?.toLongOrNull()
val full = forceFull || cachedAt == null || now - cachedAt > PERMISSION_TTL_MS
val permissions = apiClient.syncPermissions(if (full) null else cachedAt)
val folderDao = appDatabase.folderDao() val folderDao = appDatabase.folderDao()
val fileDao = appDatabase.fileDao() val fileDao = appDatabase.fileDao()
val snapshotFolderIds = mutableSetOf<String>() val snapshotFolderIds = mutableSetOf<String>()
val snapshotFileIds = mutableSetOf<String>() val snapshotFileIds = mutableSetOf<String>()
val snapshotPermIds = mutableSetOf<String>()
appDatabase.withTransaction { appDatabase.withTransaction {
for (perm in permissions) { for (perm in permissions) {
if (perm.effectiveAccess == "owner") continue
snapshotPermIds += perm.resourceId
permDao.upsertAll(
listOf(
ResourcePermissionEntity(
resourceId = perm.resourceId,
resourceType = perm.resourceType,
effectiveAccess = perm.effectiveAccess,
ownerId = perm.ownerId,
sharedById = perm.sharedById,
expiresAt = perm.expiresAt,
// Fraîcheur = heure locale du pull (M27) : le TTL
// mesure « 24h sans reseed », pas l'horloge serveur
// (skew). `perm.cachedAt` sert au delta `after`.
cachedAt = now,
updatedAt = perm.updatedAt,
),
),
)
if (isExpired(perm.expiresAt, now)) {
// Grant expiré : masquer la ligne locale au lieu d'hydrater.
markSharedMissing(perm.resourceId, perm.resourceType, currentUserId, now, folderDao, fileDao)
continue
}
when { when {
perm.effectiveAccess == "owner" -> Unit
perm.resourceType == "folder" -> { perm.resourceType == "folder" -> {
snapshotFolderIds += perm.resourceId snapshotFolderIds += perm.resourceId
upsertSharedFolder(perm, now, folderDao) upsertSharedFolder(perm, now, folderDao)
@@ -67,31 +110,118 @@ class ShareRepository @Inject constructor(
} }
} }
// Convergence : marquer les lignes cloud-only absentes du snapshot if (full) {
// comme disparues (révocation / expiration côté serveur). // Convergence : marquer les lignes cloud-only d'autrui absentes du
// snapshot comme disparues (révocation / expiration côté serveur).
// Sans compte actif, impossible d'attribuer : ne rien masquer. Le
// snapshot exclut les ressources possédées → une ligne cloud-only
// au vrai ownerId=user ne doit jamais être markMissing.
for (folder in folderDao.getAll()) { for (folder in folderDao.getAll()) {
if (isCloudOnlyForOtherUser(folder.uri, folder.ownerId, currentUserId, folder.exists) if (currentUserId != null &&
&& folder.resourceId !in snapshotFolderIds isCloudOnlyForOtherUser(folder.uri, folder.ownerId, currentUserId, folder.exists) &&
folder.resourceId !in snapshotFolderIds
) { ) {
folderDao.markMissing(folder.resourceId, now) folderDao.markMissing(folder.resourceId, now)
} }
} }
for (file in fileDao.getAll()) { for (file in fileDao.getAll()) {
if (isCloudOnlyForOtherUser(file.uri, file.ownerId, currentUserId, file.exists) if (currentUserId != null &&
&& file.resourceId !in snapshotFileIds isCloudOnlyForOtherUser(file.uri, file.ownerId, currentUserId, file.exists) &&
file.resourceId !in snapshotFileIds
) { ) {
fileDao.markMissing(file.resourceId, now) fileDao.markMissing(file.resourceId, now)
} }
} }
// Oublie les grants du cache absents du snapshot complet.
if (snapshotPermIds.isEmpty()) {
permDao.clear()
} else {
permDao.deleteNotIn(snapshotPermIds.toList())
}
}
// Grants périmés connus du cache (delta ou TTL) : masquer localement.
for (expired in permDao.getExpired(now)) {
markSharedMissing(expired.resourceId, expired.resourceType, currentUserId, now, folderDao, fileDao)
}
prefs.upsert(
UserPreferenceEntity(
PrefKeys.PERMISSIONS_CACHED_AT,
now.toString(),
now,
),
)
} }
Timber.d( Timber.d(
"syncSnapshot: hydrated %d folders, %d files", "syncSnapshot: hydrated %d folders, %d files (full=%s)",
snapshotFolderIds.size, snapshotFolderIds.size,
snapshotFileIds.size, snapshotFileIds.size,
full,
) )
} }
/**
* Droit offline sur une ressource (docs/api-v1.md §6.2) : ownership local
* d'abord (`owner` implique tout), sinon rang persisté du snapshot.
* Grant expiré → refusé ; snapshot périmé (TTL 24h sans reseed) →
* downgrade lecture seule (`viewer` exigé au plus).
*/
suspend fun canAccess(resourceId: String, required: String = AccessRank.VIEWER): Boolean {
val requiredRank = AccessRank.rank(required)
if (requiredRank <= 0) return false
val currentUserId = activeUserStore.get()
val now = System.currentTimeMillis()
if (currentUserId != null) {
val folderOwner = appDatabase.folderDao().getByResourceId(resourceId)?.ownerId
val fileOwner = if (folderOwner == null) {
appDatabase.fileDao().getByResourceId(resourceId)?.ownerId
} else {
null
}
if (folderOwner == currentUserId || fileOwner == currentUserId) return true
}
val perm = appDatabase.resourcePermissionDao().getByResourceId(resourceId) ?: return false
if (isExpired(perm.expiresAt, now)) return false
val effective = if (now - perm.cachedAt > PERMISSION_TTL_MS) {
// Stale : downgrade lecture seule.
minOf(AccessRank.rank(perm.effectiveAccess), AccessRank.rank(AccessRank.VIEWER))
} else {
AccessRank.rank(perm.effectiveAccess)
}
return effective >= requiredRank
}
private fun isExpired(expiresAt: Long?, now: Long): Boolean =
expiresAt != null && expiresAt <= now
/**
* Masque une ligne partagée cloud-only d'autrui (`exists = 0`) — jamais
* une copie physique locale ni une ressource possédée.
*/
private suspend fun markSharedMissing(
resourceId: String,
resourceType: String,
currentUserId: String?,
now: Long,
folderDao: FolderDao,
fileDao: FileDao,
) {
if (currentUserId == null) return
if (resourceType == "folder") {
val folder = folderDao.getByResourceId(resourceId) ?: return
if (isCloudOnlyForOtherUser(folder.uri, folder.ownerId, currentUserId, folder.exists)) {
folderDao.markMissing(resourceId, now)
}
} else {
val file = fileDao.getByResourceId(resourceId) ?: return
if (isCloudOnlyForOtherUser(file.uri, file.ownerId, currentUserId, file.exists)) {
fileDao.markMissing(resourceId, now)
}
}
}
/** /**
* Ligne hébergée cloud (uri NULL), non possédée localement, encore visible. * Ligne hébergée cloud (uri NULL), non possédée localement, encore visible.
* Absente du snapshot → ressource partagée révoquée/expirée → marquer disparue. * Absente du snapshot → ressource partagée révoquée/expirée → marquer disparue.
@@ -99,9 +229,9 @@ class ShareRepository @Inject constructor(
private fun isCloudOnlyForOtherUser( private fun isCloudOnlyForOtherUser(
uri: String?, uri: String?,
ownerId: String?, ownerId: String?,
currentNodeId: String, currentUserId: String,
exists: Int?, exists: Int?,
): Boolean = uri == null && ownerId != null && ownerId != currentNodeId && exists != 0 ): Boolean = uri == null && ownerId != null && ownerId != currentUserId && exists != 0
private suspend fun upsertSharedFolder( private suspend fun upsertSharedFolder(
perm: ResourcePermissionDto, perm: ResourcePermissionDto,
@@ -158,4 +288,9 @@ class ShareRepository @Inject constructor(
) )
fileDao.upsert(entity) fileDao.upsert(entity)
} }
companion object {
/** TTL du snapshot permissions (docs/api-v1.md §6.2) : 24h. */
const val PERMISSION_TTL_MS = 24 * 60 * 60 * 1000L
}
} }
@@ -1,5 +1,8 @@
package com.kazier.mobile.di package com.kazier.mobile.di
import com.kazier.mobile.auth.SecureTokenStore
import com.kazier.mobile.auth.TokenStore
import dagger.Binds
import dagger.Module import dagger.Module
import dagger.hilt.InstallIn import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent import dagger.hilt.components.SingletonComponent
@@ -9,4 +12,8 @@ import dagger.hilt.components.SingletonComponent
*/ */
@Module @Module
@InstallIn(SingletonComponent::class) @InstallIn(SingletonComponent::class)
object AppModule abstract class AppModule {
@Binds
abstract fun bindTokenStore(impl: SecureTokenStore): TokenStore
}
@@ -6,6 +6,7 @@ import com.kazier.mobile.data.local.AppDatabase
import com.kazier.mobile.data.local.dao.FileDao import com.kazier.mobile.data.local.dao.FileDao
import com.kazier.mobile.data.local.dao.FolderDao import com.kazier.mobile.data.local.dao.FolderDao
import com.kazier.mobile.data.local.dao.PendingOperationDao import com.kazier.mobile.data.local.dao.PendingOperationDao
import com.kazier.mobile.data.local.dao.ResourcePermissionDao
import com.kazier.mobile.data.local.dao.ScanDao import com.kazier.mobile.data.local.dao.ScanDao
import com.kazier.mobile.data.local.dao.UserPreferenceDao import com.kazier.mobile.data.local.dao.UserPreferenceDao
import com.kazier.mobile.data.local.migration.Migrations import com.kazier.mobile.data.local.migration.Migrations
@@ -25,6 +26,13 @@ object DatabaseModule {
fun provideDatabase(@ApplicationContext context: Context): AppDatabase = fun provideDatabase(@ApplicationContext context: Context): AppDatabase =
Room.databaseBuilder(context, AppDatabase::class.java, "dot.db") Room.databaseBuilder(context, AppDatabase::class.java, "dot.db")
.addMigrations(*Migrations.ALL) .addMigrations(*Migrations.ALL)
// m15 : un APK plus ancien que la DB (downgrade) ne doit plus
// crasher en `IllegalStateException` brut — reconstruction
// destructive documentée : le miroir SAF se reconstruit au walk
// suivant, les données serveur restent la source de vérité.
// Perte acceptée : l'outbox non poussée (mutations locales) —
// cas rare (rollback d'APK), préféré au crash au démarrage.
.fallbackToDestructiveMigrationOnDowngrade()
.build() .build()
@Provides @Provides
@@ -41,4 +49,7 @@ object DatabaseModule {
@Provides @Provides
fun provideScanDao(db: AppDatabase): ScanDao = db.scanDao() fun provideScanDao(db: AppDatabase): ScanDao = db.scanDao()
@Provides
fun provideResourcePermissionDao(db: AppDatabase): ResourcePermissionDao = db.resourcePermissionDao()
} }
@@ -2,7 +2,6 @@ package com.kazier.mobile.di
import com.squareup.moshi.Moshi import com.squareup.moshi.Moshi
import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory
import com.kazier.mobile.BuildConfig
import com.kazier.mobile.data.remote.ApiService import com.kazier.mobile.data.remote.ApiService
import com.kazier.mobile.data.remote.AuthInterceptor import com.kazier.mobile.data.remote.AuthInterceptor
import com.kazier.mobile.data.remote.ServerUrlInterceptor import com.kazier.mobile.data.remote.ServerUrlInterceptor
@@ -34,12 +33,10 @@ object NetworkModule {
serverUrlInterceptor: ServerUrlInterceptor, serverUrlInterceptor: ServerUrlInterceptor,
authInterceptor: AuthInterceptor, authInterceptor: AuthInterceptor,
): OkHttpClient { ): OkHttpClient {
// Logging désactivé même en DEBUG : BASIC loggue les lignes de requête
// avec query PII (`GET /users/resolve?username=…`) dans logcat (m25).
val logging = HttpLoggingInterceptor().apply { val logging = HttpLoggingInterceptor().apply {
level = if (BuildConfig.DEBUG) { level = HttpLoggingInterceptor.Level.NONE
HttpLoggingInterceptor.Level.BASIC
} else {
HttpLoggingInterceptor.Level.NONE
}
} }
return OkHttpClient.Builder() return OkHttpClient.Builder()
.addInterceptor(serverUrlInterceptor) .addInterceptor(serverUrlInterceptor)
@@ -4,6 +4,8 @@ import com.kazier.mobile.data.local.dao.UserPreferenceDao
import com.kazier.mobile.data.local.entity.UserPreferenceEntity import com.kazier.mobile.data.local.entity.UserPreferenceEntity
import javax.inject.Inject import javax.inject.Inject
import javax.inject.Singleton import javax.inject.Singleton
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
/** /**
* Identité locale du device : 32-hex généré une seule fois à la première * Identité locale du device : 32-hex généré une seule fois à la première
@@ -15,13 +17,22 @@ class DeviceIdentity @Inject constructor(
private val generateId: GenerateId, private val generateId: GenerateId,
) { ) {
suspend fun getOrCreate(): String { /**
* Single-flight intra-processus : deux `getOrCreate()` concurrents ne
* génèrent/inserent qu'une seule fois (`insertIgnore` tranche, le perdant
* relit la valeur gagnante).
*/
private val mutex = Mutex()
suspend fun getOrCreate(): String = mutex.withLock {
userPreferenceDao.getValue(PrefKeys.DEVICE_USER_ID)?.let { return it } userPreferenceDao.getValue(PrefKeys.DEVICE_USER_ID)?.let { return it }
val id = generateId.newResourceId() val id = generateId.newResourceId()
userPreferenceDao.insertIgnore( userPreferenceDao.insertIgnore(
UserPreferenceEntity(PrefKeys.DEVICE_USER_ID, id, System.currentTimeMillis()), UserPreferenceEntity(PrefKeys.DEVICE_USER_ID, id, System.currentTimeMillis()),
) )
return userPreferenceDao.getValue(PrefKeys.DEVICE_USER_ID) // Jamais de fallback fantôme : si la rellecture échoue, échouer
?: generateId.newResourceId() // proprement plutôt que de renvoyer un ID non persisté.
userPreferenceDao.getValue(PrefKeys.DEVICE_USER_ID)
?: error("device identity not persisted")
} }
} }
@@ -13,6 +13,8 @@ enum class FileCategory {
} }
fun computeCategory(mimeType: String?, extension: String?): FileCategory { fun computeCategory(mimeType: String?, extension: String?): FileCategory {
// Le CSV est toujours TEXT (MIME `text/csv` comme extension `csv`) :
// un même fichier ne change jamais de catégorie selon le chemin d'entrée.
val mime = mimeType?.lowercase().orEmpty() val mime = mimeType?.lowercase().orEmpty()
val ext = extension?.lowercase().orEmpty() val ext = extension?.lowercase().orEmpty()
@@ -41,11 +43,11 @@ private val OFFICE_MIMES = setOf(
private val OFFICE_EXTENSIONS = setOf( private val OFFICE_EXTENSIONS = setOf(
"doc", "docx", "odt", "rtf", "doc", "docx", "odt", "rtf",
"xls", "xlsx", "ods", "csv", "xls", "xlsx", "ods",
"ppt", "pptx", "odp", "ppt", "pptx", "odp",
) )
private val TEXT_EXTENSIONS = setOf( private val TEXT_EXTENSIONS = setOf(
"txt", "md", "html", "xml", "json", "css", "js", "kt", "py", "java", "txt", "md", "html", "xml", "json", "css", "js", "kt", "py", "java",
"log", "ini", "cfg", "yaml", "yml", "toml", "log", "ini", "cfg", "yaml", "yml", "toml", "csv",
) )
@@ -16,6 +16,6 @@ class GenerateId @Inject constructor() {
fun newResourceId(): String { fun newResourceId(): String {
val bytes = ByteArray(16) val bytes = ByteArray(16)
random.nextBytes(bytes) random.nextBytes(bytes)
return bytes.joinToString("") { "%02x".format(it) } return bytes.joinToString("") { "%02x".format(it.toInt() and 0xFF) }
} }
} }
@@ -21,7 +21,7 @@ class LocalModeStore @Inject constructor(
) )
} }
suspend fun get(): Boolean = userPreferenceDao.getValue(PrefKeys.LOCAL_MODE) != null suspend fun get(): Boolean = userPreferenceDao.getValue(PrefKeys.LOCAL_MODE) == "1"
suspend fun clear() = userPreferenceDao.delete(PrefKeys.LOCAL_MODE) suspend fun clear() = userPreferenceDao.delete(PrefKeys.LOCAL_MODE)
} }
@@ -8,4 +8,6 @@ object PrefKeys {
const val SYNC_MODE = "sync_mode" const val SYNC_MODE = "sync_mode"
const val THEME = "theme" const val THEME = "theme"
const val SERVER_URL = "server_url" const val SERVER_URL = "server_url"
/** Dernier pull `GET /sync/permissions` réussi, ms epoch (M27 : delta + TTL 24h). */
const val PERMISSIONS_CACHED_AT = "permissions_cached_at"
} }
@@ -32,6 +32,10 @@ class ServerConfigStore @Inject constructor(
private val _baseUrl = MutableStateFlow(DEFAULT_BASE_URL) private val _baseUrl = MutableStateFlow(DEFAULT_BASE_URL)
val baseUrl: StateFlow<String> = _baseUrl.asStateFlow() val baseUrl: StateFlow<String> = _baseUrl.asStateFlow()
/** Vrai une fois [load] passé — lu par `ServerUrlInterceptor` (garde M26). */
val isLoaded: Boolean
get() = loaded.get()
/** Dernière base effective — lu par `ServerUrlInterceptor` (filaire, volatile). */ /** Dernière base effective — lu par `ServerUrlInterceptor` (filaire, volatile). */
val current: String val current: String
get() = _baseUrl.value get() = _baseUrl.value
@@ -43,12 +47,48 @@ class ServerConfigStore @Inject constructor(
_baseUrl.value = stored?.takeIf { it.isNotBlank() }?.let(::normalize) ?: DEFAULT_BASE_URL _baseUrl.value = stored?.takeIf { it.isNotBlank() }?.let(::normalize) ?: DEFAULT_BASE_URL
} }
suspend fun set(url: String) { /**
val normalized = normalize(url).ifEmpty { DEFAULT_BASE_URL } * Réarme le garde once-only pour permettre un rechargement (ex. après
_baseUrl.value = normalized * wipe/logout où la valeur en mémoire est périmée).
*/
fun invalidate() {
loaded.set(false)
}
/** Recharge depuis la DB même si déjà chargé (ex. après wipe/logout). */
suspend fun reload() {
loaded.set(false)
load()
}
/**
* Persiste la base serveur après validation (M28). Retourne `false` —
* sans rien persister ni publier — si l'URL est invalide (schéma non
* http/https, host vide, illisible par OkHttp) : l'appelant par frappe
* ([com.kazier.mobile.ui.settings.SettingsViewModel.onServerUrlChange])
* ne brique jamais l'app sur une saisie intermédiaire.
*/
suspend fun set(url: String): Boolean {
val normalized = validate(url) ?: return false
userPreferenceDao.upsert( userPreferenceDao.upsert(
UserPreferenceEntity(PrefKeys.SERVER_URL, normalized, System.currentTimeMillis()), UserPreferenceEntity(PrefKeys.SERVER_URL, normalized, System.currentTimeMillis()),
) )
// Publier après succès DB pour ne jamais diverger UI/DB si l'upsert échoue.
_baseUrl.value = normalized
return true
}
/**
* Normalise puis valide : schéma http/https et host non vide exigés.
* Retourne la base normalisée, ou `null` si invalide.
*/
fun validate(url: String): String? {
val normalized = normalize(url)
if (normalized.isEmpty()) return null
val parsed = runCatching { normalized.toHttpUrl() }.getOrNull() ?: return null
if (parsed.scheme != "http" && parsed.scheme != "https") return null
if (parsed.host.isBlank()) return null
return normalized
} }
/** Trim, ajoute `http://` si le schéma est absent, retire les `/` finaux. */ /** Trim, ajoute `http://` si le schéma est absent, retire les `/` finaux. */
@@ -31,10 +31,25 @@ class ThemePreferenceStore @Inject constructor(
_theme.value = ThemePreference.fromStored(stored) _theme.value = ThemePreference.fromStored(stored)
} }
/**
* Réarme le garde once-only pour permettre un rechargement (ex. après
* wipe/logout où la valeur en mémoire est périmée).
*/
fun invalidate() {
loaded.set(false)
}
/** Recharge depuis la DB même si déjà chargé (ex. après wipe/logout). */
suspend fun reload() {
loaded.set(false)
load()
}
suspend fun set(theme: ThemePreference) { suspend fun set(theme: ThemePreference) {
_theme.value = theme
userPreferenceDao.upsert( userPreferenceDao.upsert(
UserPreferenceEntity(PrefKeys.THEME, theme.storedValue, System.currentTimeMillis()), UserPreferenceEntity(PrefKeys.THEME, theme.storedValue, System.currentTimeMillis()),
) )
// Publier après succès DB pour ne jamais diverger UI/DB si l'upsert échoue.
_theme.value = theme
} }
} }
@@ -81,16 +81,27 @@ class FileDeleter @Inject constructor(
} }
/** /**
* Suppression cloud uniquement (outbox `delete_resource`). * Suppression cloud uniquement (outbox `delete_resource` + tombstone locale).
* Le fichier local n\'est pas touché. N\'a de sens que si la ressource a * Le fichier physique local n'est pas touché, mais la ligne Room passe
* déjà été poussée (gate « processed » : un fichier jamais envoyé est no-op). * `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 »).
*/ */
private suspend fun deleteInCloud(file: FileEntity): Boolean { private suspend fun deleteInCloud(file: FileEntity): Boolean {
var ok = false var ok = false
runCatching { runCatching {
if (outboxRepository.hasCreateOperation(file.resourceId)) { 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.
outboxRepository.cancelPendingCreates(file.resourceId)
if (outboxRepository.hasSyncedCreateOperation(file.resourceId)) {
outboxRepository.enqueueDeleteResource(file.resourceId, "file") outboxRepository.enqueueDeleteResource(file.resourceId, "file")
} }
fileRepository.markMissing(file.resourceId, now)
}
ok = true ok = true
Timber.d("enqueued cloud delete for %s", file.resourceId) Timber.d("enqueued cloud delete for %s", file.resourceId)
}.onFailure { e -> }.onFailure { e ->
@@ -100,34 +111,75 @@ class FileDeleter @Inject constructor(
} }
/** /**
* Suppression complète : physique + cloud. * Suppression complète : journal d'abord, physique ensuite (C4).
* Transaction atomique : SAF delete + markMissing + outbox. *
* Ordre crash-safe : la transaction Room (`exists = 0` + annulation du
* create pending + éventuel `delete_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).
*/ */
private suspend fun deleteFull(file: FileEntity): Boolean { private suspend fun deleteFull(file: FileEntity): Boolean {
val uri = file.uri val uri = file.uri
return if (uri != null) { return if (uri != null) {
runCatching {
DocumentsContract.deleteDocument(resolver, Uri.parse(uri))
}.onSuccess { deleted ->
if (deleted) {
val now = System.currentTimeMillis() val now = System.currentTimeMillis()
appDatabase.withTransaction { appDatabase.withTransaction {
fileRepository.markMissing(file.resourceId, now) fileRepository.markMissing(file.resourceId, now)
if (outboxRepository.hasCreateOperation(file.resourceId)) { outboxRepository.cancelPendingCreates(file.resourceId)
if (outboxRepository.hasSyncedCreateOperation(file.resourceId)) {
outboxRepository.enqueueDeleteResource(file.resourceId, "file") outboxRepository.enqueueDeleteResource(file.resourceId, "file")
} }
} }
val deleted = runCatching {
DocumentsContract.deleteDocument(resolver, Uri.parse(uri))
}.onFailure { e ->
Timber.w(e, "deleteDocument failed for %s (sweep will retry)", uri)
}.getOrDefault(false)
if (deleted) {
Timber.d("deleted full %s", uri) Timber.d("deleted full %s", uri)
thumbnailStore.delete(file.resourceId) thumbnailStore.delete(file.resourceId)
} else { } else {
Timber.w("deleteDocument returned false for %s", uri) Timber.w("deleteDocument returned false for %s (sweep will retry)", uri)
} }
}.onFailure { e -> deleted
Timber.w(e, "deleteDocument failed for %s", uri)
}.getOrDefault(false)
} else { } else {
// Cloud-only : outbox uniquement. // Cloud-only : outbox uniquement.
deleteInCloud(file) deleteInCloud(file)
} }
} }
/**
* Repasse C4 : retente la suppression physique des lignes déjà
* journalisées (`exists = 0`, `uri` présente) dont les octets ont survécu
* (kill entre journal et SAF, refus du provider). Bornée ([SWEEP_LIMIT])
* et best-effort — appelée à chaque tick de sync et après chaque import.
* Retourne le nombre d'octets effectivement supprimés.
*/
suspend fun sweepPendingPhysicalDeletes(limit: Int = SWEEP_LIMIT): Int {
var swept = 0
val stale = try {
appDatabase.fileDao().getMissingWithUri(limit)
} catch (e: Exception) {
Timber.w(e, "sweep: lecture impossible")
return 0
}
for (file in stale) {
val uri = file.uri ?: continue
val deleted = runCatching {
DocumentsContract.deleteDocument(resolver, Uri.parse(uri))
}.getOrDefault(false)
if (deleted) {
thumbnailStore.delete(file.resourceId)
swept++
}
}
return swept
}
companion object {
private const val SWEEP_LIMIT = 50
}
} }
@@ -18,11 +18,13 @@ import javax.inject.Singleton
* *
* - fichier physique (uri ≠ null) + dossier cible physique → relocation SAF * - fichier physique (uri ≠ null) + dossier cible physique → relocation SAF
* réelle via `DocumentsContract.moveDocument` (l'arborescence locale reste * réelle via `DocumentsContract.moveDocument` (l'arborescence locale reste
* cohérente avec Room) ; en cas d'échec (permission/edge provider), repli * cohérente avec Room) ; en cas d'échec (permission/edge provider), Room
* bas de gamme : métadonnée seule (`folderResourceId`), la marche suivante * est laissée INCHANGÉE — le repli « métadonnée seule » mentirait
* re-réconciliera. * durablement (nouveau parent + ancienne uri), et le garde pending-move
* bloquerait le walk. L'utilisateur peut réessayer, le walk réconciliera.
* - fichier cloud-only → mise à jour de la métadonnée de dossier uniquement * - fichier cloud-only → mise à jour de la métadonnée de dossier uniquement
* (`applyMove` journalise aussi un `move_resource` dans l'outbox). * (`applyMove` journalise aussi un `move_resource` dans l'outbox, sous gate
* `create`).
*/ */
@Singleton @Singleton
class FileMover @Inject constructor( class FileMover @Inject constructor(
@@ -42,21 +44,24 @@ class FileMover @Inject constructor(
withContext(Dispatchers.IO) { withContext(Dispatchers.IO) {
for (resourceId in resourceIds) { for (resourceId in resourceIds) {
val file = fileRepository.getFile(resourceId) ?: continue val file = fileRepository.getFile(resourceId) ?: continue
val physicalTarget = file.uri != null && targetDoc != null if (file.uri != null && targetDoc != null) {
// Refus du provider → on ne touche pas à Room (cohérence
val newUri = if (physicalTarget) { // disque/Room/serveur préservée, nouvel essai possible).
tryMove(file.uri, file.folderResourceId, targetDoc) val movedUri = tryMove(file.uri, file.folderResourceId, targetDoc)
?: continue
fileRepository.applyMove(resourceId, targetFolderId, movedUri)
} else { } else {
null fileRepository.applyMove(resourceId, targetFolderId, file.uri)
} }
fileRepository.applyMove(resourceId, targetFolderId, newUri ?: file.uri)
} }
} }
} }
/** /**
* Tente la relocation SAF. Retourne le nouvel uri du document (peut être * Tente la relocation SAF. Retourne le nouvel uri du document, ou null en
* identique à l'ancien), ou null en échec → repli métadonnée seule. * échec (exception, retour null, ou uri identique à la source — certains
* providers renvoient la source quand ils refusent ou déplacent sur place :
* sans preuve d'un nouvel emplacement, on ne touche pas à Room).
*/ */
private suspend fun tryMove(fileUri: String?, sourceFolderId: String, targetDoc: Uri): String? { private suspend fun tryMove(fileUri: String?, sourceFolderId: String, targetDoc: Uri): String? {
if (fileUri == null) return null if (fileUri == null) return null
@@ -71,7 +76,8 @@ class FileMover @Inject constructor(
targetDoc, targetDoc,
) )
}.onSuccess { moved -> Timber.d("moved %s -> %s (%s)", fileUri, targetDoc, moved) } }.onSuccess { moved -> Timber.d("moved %s -> %s (%s)", fileUri, targetDoc, moved) }
.onFailure { Timber.w(it, "physical move failed for %s (metadata-only)", fileUri) } .onFailure { Timber.w(it, "physical move failed for %s (Room unchanged)", fileUri) }
.getOrNull()?.toString() .getOrNull()?.toString()
.takeIf { it != fileUri }
} }
} }
@@ -87,12 +87,19 @@ class FolderDeleter @Inject constructor(
return false return false
} }
/** Suppression cloud uniquement (outbox `delete_resource`), physique intact. */ /**
* Suppression cloud uniquement (outbox `delete_resource` + tombstone locale,
* M5) : le dossier et toute sa descendance Room passent `exists = 0` 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`).
*/
private suspend fun deleteInCloud(folder: FolderEntity): Boolean { private suspend fun deleteInCloud(folder: FolderEntity): Boolean {
var ok = false var ok = false
runCatching { runCatching {
if (outboxRepository.hasCreateOperationAnyType(folder.resourceId)) { val tree = collectDescendants(folder.resourceId)
outboxRepository.enqueueDeleteResource(folder.resourceId, "folder") val now = System.currentTimeMillis()
appDatabase.withTransaction {
treeMarkMissing(folder, tree, now)
} }
ok = true ok = true
Timber.d("enqueued cloud delete for folder %s", folder.resourceId) Timber.d("enqueued cloud delete for folder %s", folder.resourceId)
@@ -102,43 +109,88 @@ class FolderDeleter @Inject constructor(
return ok return ok
} }
/** Suppression complète : physique + cloud. Transaction atomique Room. */ /**
* Suppression 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
* 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).
*/
private suspend fun deleteFull(folder: FolderEntity): Boolean { private suspend fun deleteFull(folder: FolderEntity): Boolean {
val uri = folder.uri val uri = folder.uri
if (uri != null) { if (uri != null) {
val tree = collectDescendants(folder.resourceId) val tree = collectDescendants(folder.resourceId)
if (deleteTreePhysically(folder, tree)) {
val now = System.currentTimeMillis() val now = System.currentTimeMillis()
appDatabase.withTransaction { appDatabase.withTransaction {
treeMarkMissing(folder, tree, now) treeMarkMissing(folder, tree, now)
} }
return if (deleteTreePhysically(folder, tree)) {
tree.files.forEach { thumbnailStore.delete(it.resourceId) } tree.files.forEach { thumbnailStore.delete(it.resourceId) }
Timber.d("deleted folder full %s", uri) Timber.d("deleted folder full %s", uri)
return true true
} else {
Timber.w("deleteDocument returned false for %s (sweep will retry)", uri)
false
} }
Timber.w("deleteDocument returned false for %s", uri)
return false
} }
// Cloud-only : outbox uniquement. // Cloud-only : outbox uniquement.
return deleteInCloud(folder) return deleteInCloud(folder)
} }
/**
* Repasse C4 (dossiers) : retente la suppression physique des arbres déjà
* journalisés (`exists = 0`, `uri` présente). Un dossier n'est retenté que
* si toute sa descendance Room est aussi `exists = 0` — jamais de
* suppression d'un arbre encore vivant. Bornée ([SWEEP_LIMIT]).
* Retourne le nombre d'arbres effectivement supprimés.
*/
suspend fun sweepPendingPhysicalDeletes(limit: Int = SWEEP_LIMIT): Int {
var swept = 0
val stale = try {
appDatabase.folderDao().getMissingWithUri(limit)
} catch (e: Exception) {
Timber.w(e, "sweep folders: lecture impossible")
return 0
}
for (folder in stale) {
val tree = collectDescendants(folder.resourceId)
val alive = tree.files.any { it.exists != 0 } || tree.folders.any { it.exists != 0 }
if (alive) continue
if (deleteTreePhysically(folder, tree)) {
tree.files.forEach { thumbnailStore.delete(it.resourceId) }
swept++
}
}
return swept
}
companion object {
private const val SWEEP_LIMIT = 50
}
/** Marque missing + outbox `delete_resource` pour toute la descendance, atomique. */ /** Marque missing + outbox `delete_resource` pour toute la descendance, atomique. */
private suspend fun treeMarkMissing(folder: FolderEntity, tree: FolderTree, now: Long) { private suspend fun treeMarkMissing(folder: FolderEntity, tree: FolderTree, now: Long) {
for (file in tree.files) { for (file in tree.files) {
fileRepository.markMissing(file.resourceId, now) fileRepository.markMissing(file.resourceId, now)
if (outboxRepository.hasCreateOperation(file.resourceId)) { outboxRepository.cancelPendingCreates(file.resourceId)
if (outboxRepository.hasSyncedCreateOperation(file.resourceId)) {
outboxRepository.enqueueDeleteResource(file.resourceId, "file") outboxRepository.enqueueDeleteResource(file.resourceId, "file")
} }
} }
for (desc in tree.folders) { for (desc in tree.folders) {
folderRepository.markMissing(desc.resourceId, now) folderRepository.markMissing(desc.resourceId, now)
if (outboxRepository.hasCreateOperationAnyType(desc.resourceId)) { outboxRepository.cancelPendingCreates(desc.resourceId)
if (outboxRepository.hasSyncedCreateOperationAnyType(desc.resourceId)) {
outboxRepository.enqueueDeleteResource(desc.resourceId, "folder") outboxRepository.enqueueDeleteResource(desc.resourceId, "folder")
} }
} }
folderRepository.markMissing(folder.resourceId, now) folderRepository.markMissing(folder.resourceId, now)
if (outboxRepository.hasCreateOperationAnyType(folder.resourceId)) { outboxRepository.cancelPendingCreates(folder.resourceId)
if (outboxRepository.hasSyncedCreateOperationAnyType(folder.resourceId)) {
outboxRepository.enqueueDeleteResource(folder.resourceId, "folder") outboxRepository.enqueueDeleteResource(folder.resourceId, "folder")
} }
} }
@@ -1,9 +1,12 @@
package com.kazier.mobile.features.saf package com.kazier.mobile.features.saf
import android.content.Context
import android.provider.DocumentsContract
import com.kazier.mobile.data.local.entity.FolderEntity import com.kazier.mobile.data.local.entity.FolderEntity
import com.kazier.mobile.data.repository.FileRepository import com.kazier.mobile.data.repository.FileRepository
import com.kazier.mobile.data.repository.FolderRepository import com.kazier.mobile.data.repository.FolderRepository
import com.kazier.mobile.data.repository.SaveFolderInput import com.kazier.mobile.data.repository.SaveFolderInput
import dagger.hilt.android.qualifiers.ApplicationContext
import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext import kotlinx.coroutines.withContext
import timber.log.Timber import timber.log.Timber
@@ -14,17 +17,28 @@ import javax.inject.Singleton
* Fusion de dossiers en mode multi-sélection. * Fusion de dossiers en mode multi-sélection.
* *
* 1. Crée un nouveau dossier nommé `newName` au même niveau que les dossiers * 1. Crée un nouveau dossier nommé `newName` au même niveau que les dossiers
* sélectionnés (même parent). * sélectionnés (même parent) — ou réutilise celui d'une tentative
* précédente (idempotence : un crash à mi-fusion ne duplique jamais le
* dossier fusionné à la relance).
* 2. Déplace tout le contenu de chaque dossier source (fichiers + sous-dossiers) * 2. Déplace tout le contenu de chaque dossier source (fichiers + sous-dossiers)
* vers le dossier fusionné — relocation SAF quand les deux côtés sont * vers le dossier fusionné — relocation SAF quand les deux côtés sont
* physiques, repli métadonnée seule sinon (`move_resource` outbox quand même). * physiques (fichiers via [FileMover], sous-dossiers via `moveDocument`),
* 3. Supprime les dossiers sources désormais vides (physique + outbox). * métadonnée seule sinon (`move_resource` outbox sous gate `create`).
* Un refus SAF laisse la source en place (ni reparent ni suppression).
* 3. Supprime les dossiers sources vidés avec succès (physique + outbox).
* *
* L'ordre outbox est garanti par l'insertion séquentielle : `create_resource` * L'ordre outbox est garanti par l'insertion séquentielle : `create_resource`
* du dossier fusionné avant les `move_resource`, avant les `delete_resource`. * du dossier fusionné avant les `move_resource`, avant les `delete_resource`.
*
* M9 — reprise après crash : chaque étape est transactionnelle et idempotente
* (dossier réutilisé, contenus déjà déplacés naturellement ignorés), et une
* source n'est supprimée que si elle est réellement vide après déplacement
* (gate de vidage) — jamais de suppression d'un dossier dont le contenu n'a
* pas pu être déplacé, jamais de doublon serveur à la relance.
*/ */
@Singleton @Singleton
class FolderMerger @Inject constructor( class FolderMerger @Inject constructor(
@ApplicationContext private val context: Context,
private val folderRepository: FolderRepository, private val folderRepository: FolderRepository,
private val fileRepository: FileRepository, private val fileRepository: FileRepository,
private val fileMover: FileMover, private val fileMover: FileMover,
@@ -45,35 +59,59 @@ class FolderMerger @Inject constructor(
suspend fun mergeSelectedFolders(folders: List<FolderEntity>, newName: String): MergeReport { suspend fun mergeSelectedFolders(folders: List<FolderEntity>, newName: String): MergeReport {
require(folders.size >= 2) { "merge requires at least 2 folders" } require(folders.size >= 2) { "merge requires at least 2 folders" }
// 1. Dossier fusionné au même niveau que les sources. // 1. Dossier fusionné au même niveau que les sources (réutilisé si une
// tentative précédente l'a déjà créé — relance idempotente).
val parentId = folders.first().parentResourceId val parentId = folders.first().parentResourceId
val merged = createMergedFolder(parentId, newName) val merged = createMergedFolder(parentId, newName)
// 2. Déplacement du contenu de chaque dossier source. // 2. Déplacement du contenu de chaque dossier source.
var movedFiles = 0 var movedFiles = 0
var stepFailures = 0 var stepFailures = 0
val readyToDelete = ArrayList<FolderEntity>()
withContext(Dispatchers.IO) { withContext(Dispatchers.IO) {
for (src in folders) { for (src in folders) {
val ok = runCatching { val ok = runCatching {
val files = fileRepository.getFilesInFolder(src.resourceId) val files = fileRepository.getFilesInFolder(src.resourceId)
if (files.isNotEmpty()) { if (files.isNotEmpty()) {
fileMover.moveFiles(files.map { it.resourceId }, merged.resourceId) fileMover.moveFiles(files.map { it.resourceId }, merged.resourceId)
movedFiles += files.size // Ne compte que les fichiers réellement partis (relecture :
// `moveFiles` ignore silencieusement les refus SAF, et une
// relance après crash ne doit pas recompter les déjà-déplacés).
movedFiles += files.size - fileRepository.getFilesInFolder(src.resourceId).size
} }
val subFolders = folderRepository.getChildren(src.resourceId) val subFolders = folderRepository.getChildren(src.resourceId)
if (subFolders.isNotEmpty()) { if (subFolders.isNotEmpty()) {
folderRepository.reparentSubFolders(subFolders.map { it.resourceId }, merged.resourceId) val movable = subFolders.filter { moveSubFolderPhysically(it, src, merged) }
if (movable.size < subFolders.size) {
error("refus SAF : ${subFolders.size - movable.size} sous-dossier(s) non déplaçables")
}
if (movable.isNotEmpty()) {
folderRepository.reparentSubFolders(movable.map { it.resourceId }, merged.resourceId)
}
}
// Gate de vidage (M9) : ne supprimer que les sources
// réellement vidées — un refus SAF silencieux ne doit jamais
// mener à la suppression d'un contenu non déplacé.
val filesLeft = fileRepository.getFilesInFolder(src.resourceId).size
val foldersLeft = folderRepository.getChildren(src.resourceId).size
if (filesLeft > 0 || foldersLeft > 0) {
error("source non vidée : $filesLeft fichier(s), $foldersLeft dossier(s) restants")
} }
}.isSuccess }.isSuccess
if (!ok) stepFailures++ if (ok) {
readyToDelete += src
} else {
stepFailures++
}
} }
} }
// 3. Suppression des dossiers sources (désormais sans contenu). // 3. Suppression des dossiers sources vidés avec succès (jamais ceux
// dont le contenu n'a pas pu être déplacé).
var deletedFolders = 0 var deletedFolders = 0
var failed = 0 var failed = 0
withContext(Dispatchers.IO) { withContext(Dispatchers.IO) {
for (src in folders) { for (src in readyToDelete) {
val report = folderDeleter.deleteFolders(listOf(src), FileDeleter.DeleteMode.FULL) val report = folderDeleter.deleteFolders(listOf(src), FileDeleter.DeleteMode.FULL)
if (report.failed == 0) deletedFolders++ else failed++ if (report.failed == 0) deletedFolders++ else failed++
} }
@@ -84,12 +122,38 @@ class FolderMerger @Inject constructor(
return MergeReport(movedFiles = movedFiles, deletedFolders = deletedFolders, failed = failed) return MergeReport(movedFiles = movedFiles, deletedFolders = deletedFolders, failed = failed)
} }
/**
* Déplace physiquement un sous-dossier vers le dossier fusionné.
* Retourne `true` si le reparent Room peut suivre : rien à déplacer
* (cloud-only) ou `moveDocument` accepté. `false` (refus SAF) → la source
* reste en place, ni reparentée ni supprimée (cohérence disque/Room).
*/
private fun moveSubFolderPhysically(sub: FolderEntity, src: FolderEntity, merged: FolderEntity): Boolean {
val subUri = SafUris.toDocumentUri(sub.uri) ?: return true
val mergedDoc = SafUris.toDocumentUri(merged.uri) ?: return true
val srcDoc = SafUris.toDocumentUri(src.uri) ?: return false
return runCatching {
DocumentsContract.moveDocument(
context.contentResolver,
subUri,
srcDoc,
mergedDoc,
)
}.onSuccess { moved -> Timber.d("moved folder %s -> %s (%s)", subUri, mergedDoc, moved) }
.onFailure { Timber.w(it, "physical folder move failed for %s", subUri) }
.getOrNull() != null
}
/** /**
* Crée (physique si le parent l'est, cloud-only sinon) et enregistre en Room * Crée (physique si le parent l'est, cloud-only sinon) et enregistre en Room
* le dossier fusionné. Retourne l'entité Room. La sauvegarde enqueue le * le dossier fusionné. Retourne l'entité Room. La sauvegarde enqueue le
* `create_resource` dans la même transaction. * `create_resource` dans la même transaction.
*
* Idempotence : si un frère du même nom existe déjà (crash à mi-fusion puis
* relance), il est réutilisé — aucun doublon, aucun `create_resource` bis.
*/ */
private suspend fun createMergedFolder(parentId: String?, newName: String): FolderEntity { private suspend fun createMergedFolder(parentId: String?, newName: String): FolderEntity {
findExistingMerged(parentId, newName)?.let { return it }
val parent = parentId?.let { folderRepository.getFolder(it) } val parent = parentId?.let { folderRepository.getFolder(it) }
val createdUri = parent?.uri?.let { safFolderCreator.createFolder(it, newName) }?.toString() val createdUri = parent?.uri?.let { safFolderCreator.createFolder(it, newName) }?.toString()
return folderRepository.saveFolder( return folderRepository.saveFolder(
@@ -102,4 +166,14 @@ class FolderMerger @Inject constructor(
parentResourceId = parentId, parentResourceId = parentId,
) )
} }
/** Frère existant du même nom (visible), ou null si première tentative. */
private suspend fun findExistingMerged(parentId: String?, newName: String): FolderEntity? {
val siblings = if (parentId == null) {
folderRepository.getRootFolders().filter { it.exists != 0 }
} else {
folderRepository.getChildren(parentId)
}
return siblings.firstOrNull { it.name == newName }
}
} }
@@ -41,32 +41,39 @@ class SafFileDeleter @Inject constructor(
private val resolver: ContentResolver get() = context.contentResolver private val resolver: ContentResolver get() = context.contentResolver
/**
* Suppression review (swipe ✗) : journal d'abord, physique ensuite (C4 —
* même contrat que `FileDeleter.deleteFull`, la repasse
* `FileDeleter.sweepPendingPhysicalDeletes` couvrant aussi ces lignes).
*/
suspend fun delete(file: FileEntity): Boolean { suspend fun delete(file: FileEntity): Boolean {
val uri = file.uri ?: return false val uri = file.uri ?: return false
return withContext(Dispatchers.IO) { return withContext(Dispatchers.IO) {
runCatching {
DocumentsContract.deleteDocument(resolver, Uri.parse(uri))
}.onSuccess { deleted ->
if (deleted) {
val now = System.currentTimeMillis() val now = System.currentTimeMillis()
appDatabase.withTransaction { appDatabase.withTransaction {
fileRepository.markMissing(file.resourceId, now) fileRepository.markMissing(file.resourceId, now)
// Gate « processed » : si le fichier n'a jamais été poussé // Gate « processed » + annulation (M19) : si le fichier
// (create_resource absent), le serveur n'en sait rien — // n'a jamais été poussé (create encore pending), on
// un delete_resource serait du bruit. On ne le journalise // annule le create au lieu d'un delete bruit ; le
// que pour les ressources déjà synchronisées. // delete n'est journalisé que si le serveur connaît
if (outboxRepository.hasCreateOperation(file.resourceId)) { // déjà la ressource (create synced).
outboxRepository.cancelPendingCreates(file.resourceId)
if (outboxRepository.hasSyncedCreateOperation(file.resourceId)) {
outboxRepository.enqueueDeleteResource(file.resourceId, "file") outboxRepository.enqueueDeleteResource(file.resourceId, "file")
} }
} }
val deleted = runCatching {
DocumentsContract.deleteDocument(resolver, Uri.parse(uri))
}.onFailure { e ->
Timber.w(e, "deleteDocument failed for %s (sweep will retry)", uri)
}.getOrDefault(false)
if (deleted) {
Timber.d("deleted %s", uri) Timber.d("deleted %s", uri)
thumbnailStore.delete(file.resourceId) thumbnailStore.delete(file.resourceId)
} else { } else {
Timber.w("deleteDocument returned false for %s", uri) Timber.w("deleteDocument returned false for %s (sweep will retry)", uri)
} }
}.onFailure { e -> deleted
Timber.w(e, "deleteDocument failed for %s", uri)
}.getOrDefault(false)
} }
} }
} }
@@ -36,11 +36,28 @@ object CornerGeometry {
return abs(sum) / 2f return abs(sum) / 2f
} }
/** Dimensions du document redressé (moyenne des côtés opposés). */ /** Dimensions du document redressé (plus grand des côtés opposés). */
fun outputSize(points: List<PointF>): Pair<Int, Int> { fun outputSize(points: List<PointF>): Pair<Int, Int> {
val (tl, tr, br, bl) = orderPoints(points) val (tl, tr, br, bl) = orderPoints(points)
val w = max(distance(tl, tr), distance(bl, br)) val w = max(distance(tl, tr), distance(bl, br))
val h = max(distance(tl, bl), distance(tr, br)) val h = max(distance(tl, bl), distance(tr, br))
return w.roundToInt() to h.roundToInt() return w.roundToInt() to h.roundToInt()
} }
/**
* Quad inexploitable (coins dupliqués, aire nulle, aplati) : le warp
* produirait une page blanche 1×1 validée par erreur — l'appelant doit
* refuser la page au lieu de la persister.
*/
fun isDegenerate(points: List<PointF>, epsilon: Float = 0.5f): Boolean {
if (points.size != 4) return true
for (i in points.indices) {
for (j in i + 1 until points.size) {
if (distance(points[i], points[j]) <= epsilon) return true
}
}
if (area(points) <= epsilon) return true
val (w, h) = outputSize(points)
return w <= 0 || h <= 0
}
} }
@@ -0,0 +1,30 @@
package com.kazier.mobile.features.scan
import com.kazier.mobile.data.local.entity.ScanPageEntity
import com.kazier.mobile.data.local.entity.ScanPageStatus
/**
* Décisions pures de l'export d'une session de scan (aucune IO) :
* - **retry idempotent** : seul le `PENDING` est (ré)exporté, jamais le
* `EXPORTED` (chaque retry créait sinon un nouvel URI SAF + ligne Room +
* op outbox en double) ;
* - **pas de DONE partiel** : la session ne passe `DONE` que si tout a
* réussi ; un temp manquant ou une page en échec reste `PENDING` pour
* reprise, la session reste active avec un message d'erreur.
*/
object ScanExport {
/** Pages à (ré)exporter : les `PENDING` dans l'ordre de la session. */
fun pendingForExport(pages: List<ScanPageEntity>): List<ScanPageEntity> =
pages.filter { it.status == ScanPageStatus.PENDING }
/** Pages effectivement embarquées (succès seuls, jamais les échecs). */
fun succeeded(
pages: List<ScanPageEntity>,
failedIds: Set<String>,
): List<ScanPageEntity> =
pages.filterNot { it.resourceId in failedIds }
/** La session ne se termine que si aucune page n'a échoué. */
fun shouldFinishSession(failedCount: Int): Boolean = failedCount == 0
}
@@ -39,7 +39,7 @@ class ScanImageProcessor @Inject constructor() {
fun isAvailable(): Boolean { fun isAvailable(): Boolean {
if (!loaded) { if (!loaded) {
loaded = OpenCVLoader.initLocal() loaded = runCatching { OpenCVLoader.initLocal() }.getOrDefault(false)
} }
return loaded return loaded
} }
@@ -83,9 +83,14 @@ class ScanImageProcessor @Inject constructor() {
/** /**
* Redresse (`warpPerspective`) selon `quad` puis applique le mode de rendu. * Redresse (`warpPerspective`) selon `quad` puis applique le mode de rendu.
* Sortie plafonnée à [MAX_OUTPUT_SIDE] px sur le grand côté. * Sortie plafonnée à [MAX_OUTPUT_SIDE] px sur le grand côté.
*
* Contrat alias : si OpenCV est indisponible, retourne l'instance d'entrée
* elle-même — l'appelant ne doit la recycler que s'il a reçu une nouvelle
* instance (`processed !== input`), jamais un alias du bitmap affiché.
*/ */
fun process(bitmap: Bitmap, quad: ScanQuad, mode: ScanRenderMode): Bitmap { fun process(bitmap: Bitmap, quad: ScanQuad, mode: ScanRenderMode): Bitmap {
if (!isAvailable()) return bitmap if (!isAvailable()) return bitmap
require(!CornerGeometry.isDegenerate(quad.points)) { "degenerate quad" }
val (targetW, targetH) = CornerGeometry.outputSize(quad.points) val (targetW, targetH) = CornerGeometry.outputSize(quad.points)
val maxSide = max(targetW, targetH) val maxSide = max(targetW, targetH)
val outScale = min(1f, MAX_OUTPUT_SIDE.toFloat() / maxSide) val outScale = min(1f, MAX_OUTPUT_SIDE.toFloat() / maxSide)
@@ -177,6 +182,9 @@ class ScanImageProcessor @Inject constructor() {
blur.release() blur.release()
edges.release() edges.release()
hierarchy.release() hierarchy.release()
// Contours non consommés (exception à mi-boucle) : `release()` est
// idempotent côté OpenCV, les déjà-libérés sont des no-ops.
contours.forEach { runCatching { it.release() } }
} }
} }
@@ -9,7 +9,7 @@ import com.kazier.mobile.data.repository.FolderRepository
import com.kazier.mobile.data.repository.OutboxRepository import com.kazier.mobile.data.repository.OutboxRepository
import com.kazier.mobile.data.repository.SaveFileInput import com.kazier.mobile.data.repository.SaveFileInput
import com.kazier.mobile.data.repository.SaveFolderInput import com.kazier.mobile.data.repository.SaveFolderInput
import com.kazier.mobile.domain.DeviceIdentity import com.kazier.mobile.domain.ActiveUserStore
import kotlinx.coroutines.sync.Mutex import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock import kotlinx.coroutines.sync.withLock
import timber.log.Timber import timber.log.Timber
@@ -36,7 +36,7 @@ class DeviceSync @Inject constructor(
private val folderRepository: FolderRepository, private val folderRepository: FolderRepository,
private val fileRepository: FileRepository, private val fileRepository: FileRepository,
private val outboxRepository: OutboxRepository, private val outboxRepository: OutboxRepository,
private val deviceIdentity: DeviceIdentity, private val activeUserStore: ActiveUserStore,
) { ) {
data class SyncResult( data class SyncResult(
@@ -66,22 +66,41 @@ class DeviceSync @Inject constructor(
private suspend fun doSyncRoot(root: FolderEntity): SyncResult { private suspend fun doSyncRoot(root: FolderEntity): SyncResult {
val rootUri = checkNotNull(root.uri) { "root '${root.name}' has no physical uri" } val rootUri = checkNotNull(root.uri) { "root '${root.name}' has no physical uri" }
val ownerId = deviceIdentity.getOrCreate() // `owner_id` Room = user_id du compte actif, jamais l'identité device.
val ownerId = activeUserStore.get()
// Phase 1 — listing SAF (I/O disque, HORS transaction). // Phase 1 — listing SAF (I/O disque, HORS transaction).
val folders = scanner.scanTree(Uri.parse(rootUri)) val folders = scanner.scanTree(Uri.parse(rootUri))
// Phase 2 — écritures Room (transaction courte, SQL pur). // Phase 2 — écritures Room par lots (m5) : chaque lot est sa propre
return appDatabase.withTransaction { // transaction courte au lieu d'une transaction géante (N upserts +
// full-table scans sous verrou écriture → lecteurs Room bloqués,
// jank/ANR). L'ordre parent-avant-enfant est préservé (itération
// séquentielle, seules les frontières de commit changent).
val seen = HashSet<String>() val seen = HashSet<String>()
val resourceIdByUri = HashMap<String, String>() val resourceIdByUri = HashMap<String, String>()
var fileCount = 0 var fileCount = 0
for (folder in folders) { for (chunk in folders.chunked(SYNC_BATCH)) {
appDatabase.withTransaction {
for (folder in chunk) {
seen += folder.uri seen += folder.uri
val parentResourceId = val parentResourceId = if (folder.parentUri == null) {
if (folder.parentUri == null) null null
else resourceIdByUri[folder.parentUri] ?: root.resourceId } else {
resourceIdByUri[folder.parentUri]
}
if (folder.parentUri != null && parentResourceId == null) {
// Violation parent-avant-enfant (snapshot incohérent) : on
// n'attache JAMAIS à la racine par défaut — le dossier est
// ignoré et journalisé, le prochain walk convergera.
Timber.w(
"walk: parent SAF inconnu, dossier ignoré (uri=%s parent=%s)",
folder.uri,
folder.parentUri,
)
continue
}
val saved = folderRepository.saveFolder( val saved = folderRepository.saveFolder(
SaveFolderInput(uri = folder.uri, name = folder.name, exists = true), SaveFolderInput(uri = folder.uri, name = folder.name, exists = true),
parentResourceId = parentResourceId, parentResourceId = parentResourceId,
@@ -89,10 +108,18 @@ class DeviceSync @Inject constructor(
) )
resourceIdByUri[folder.uri] = saved.resourceId resourceIdByUri[folder.uri] = saved.resourceId
} }
}
}
for (folder in folders) { val fileWrites = folders.flatMap { folder ->
val folderResourceId = resourceIdByUri[folder.uri] ?: root.resourceId // Dossier ignoré plus haut (parent manquant) : ses fichiers ne
for (file in folder.files) { // sont pas rattachés à la racine, ils attendent le walk suivant.
val folderResourceId = resourceIdByUri[folder.uri] ?: return@flatMap emptyList()
folder.files.map { file -> folderResourceId to file }
}
for (chunk in fileWrites.chunked(SYNC_BATCH)) {
appDatabase.withTransaction {
for ((folderResourceId, file) in chunk) {
seen += file.uri seen += file.uri
fileRepository.saveLocalFile( fileRepository.saveLocalFile(
input = SaveFileInput( input = SaveFileInput(
@@ -109,36 +136,49 @@ class DeviceSync @Inject constructor(
fileCount++ fileCount++
} }
} }
}
var missing = 0 var missing = 0
val now = System.currentTimeMillis() val now = System.currentTimeMillis()
for (folder in folderRepository.getAll()) { // Réconciliation scopée à la racine (m5) : fini les `getAll()`
// O(racines×DB) — le SQL filtre par préfixe d'uri (échappé).
for (folder in folderRepository.getUnderRoot(rootUri)) {
val folderUri = folder.uri val folderUri = folder.uri
if (folder.exists != 0 && folderUri != null && isChildOf(folderUri, rootUri) && folderUri !in seen) { if (folder.exists != 0 && folderUri != null && folderUri !in seen &&
!outboxRepository.hasPendingMoveOperation(folder.resourceId)
) {
folderRepository.markMissing(folder.resourceId, now) folderRepository.markMissing(folder.resourceId, now)
// Disparu avant push : annule le create pending (M19) —
// le serveur ne doit ni le créer ni l'oublier.
outboxRepository.cancelPendingCreates(folder.resourceId)
missing++ missing++
} }
} }
for (file in fileRepository.getAll()) { for (file in fileRepository.getUnderRoot(rootUri)) {
val fileUri = file.uri val fileUri = file.uri
// Un `move_resource` (pending ou synced) fait de l'outbox la // Un `move_resource` encore `pending` fait de l'outbox la
// source de vérité du placement : on ne masque jamais une ligne // source de vérité du placement : on ne masque jamais une ligne
// en transition vers une autre arborescence physique (le // en transition vers une autre arborescence physique (le
// snapshot peut être périmé par rapport au move en cours). // snapshot peut être périmé par rapport au move en cours).
if (file.exists != 0 && fileUri != null && isChildOf(fileUri, rootUri) && fileUri !in seen && // Un move déjà `synced` ne protège plus : si le fichier a
!outboxRepository.hasMoveOperation(file.resourceId) // 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 &&
!outboxRepository.hasPendingMoveOperation(file.resourceId)
) { ) {
fileRepository.markMissing(file.resourceId, now) fileRepository.markMissing(file.resourceId, now)
outboxRepository.cancelPendingCreates(file.resourceId)
missing++ missing++
} }
} }
SyncResult(rootUri = rootUri, folders = folders.size, files = fileCount, missing = missing) return SyncResult(rootUri = rootUri, folders = folders.size, files = fileCount, missing = missing)
}
} }
private fun isChildOf(uri: String, rootUri: String): Boolean = companion object {
uri == rootUri || uri.startsWith("$rootUri/") /** Taille des lots d'upserts Room du walk (m5 : transactions courtes). */
private const val SYNC_BATCH = 200
}
} }
private fun String.extensionOrNull(): String? { private fun String.extensionOrNull(): String? {
@@ -17,17 +17,53 @@ import com.kazier.mobile.auth.TokenProvider
import com.kazier.mobile.data.local.dao.FileDao import com.kazier.mobile.data.local.dao.FileDao
import com.kazier.mobile.data.local.dao.FolderDao import com.kazier.mobile.data.local.dao.FolderDao
import com.kazier.mobile.data.local.dao.PendingOperationDao import com.kazier.mobile.data.local.dao.PendingOperationDao
import com.kazier.mobile.data.local.entity.PendingOpStatus
import com.kazier.mobile.data.local.entity.PendingOperationEntity import com.kazier.mobile.data.local.entity.PendingOperationEntity
import com.kazier.mobile.data.local.entity.PendingOperationType import com.kazier.mobile.data.local.entity.PendingOperationType
import com.kazier.mobile.data.remote.ApiClient import com.kazier.mobile.data.remote.ApiClient
import com.kazier.mobile.data.remote.ApiException import com.kazier.mobile.data.remote.ApiException
import com.kazier.mobile.data.remote.dto.SyncOpDto import com.kazier.mobile.data.remote.dto.SyncOpDto
import com.kazier.mobile.data.repository.OutboxRepository
import com.kazier.mobile.features.ocr.OcrAutoWorker import com.kazier.mobile.features.ocr.OcrAutoWorker
import dagger.assisted.Assisted import dagger.assisted.Assisted
import dagger.assisted.AssistedInject import dagger.assisted.AssistedInject
import java.util.ArrayDeque
import java.util.concurrent.TimeUnit import java.util.concurrent.TimeUnit
import timber.log.Timber import timber.log.Timber
/**
* Normalise les nombres d'un payload décodé : Moshi parse tout nombre JSON
* en `Double` dans un `Map<String, Any?>` — les entiers (ex. `expiresAt` en
* ms) doivent repartir comme entiers exacts, sinon le serveur refuse
* `1.7E12` (M24). Récursif (maps/listes imbriquées).
*/
internal fun normalizePayloadNumbers(payload: Map<String, Any?>): Map<String, Any?> =
payload.mapValues { (_, value) -> normalizePayloadValue(value) }
private fun normalizePayloadValue(value: Any?): Any? = when (value) {
is Double ->
if (value % 1.0 == 0.0 && value >= Long.MIN_VALUE.toDouble() &&
value <= Long.MAX_VALUE.toDouble()
) {
value.toLong()
} else {
value
}
is Float ->
if (value % 1f == 0f && value >= Long.MIN_VALUE.toFloat() &&
value <= Long.MAX_VALUE.toFloat()
) {
value.toLong()
} else {
value
}
is Map<*, *> ->
@Suppress("UNCHECKED_CAST")
normalizePayloadNumbers(value as Map<String, Any?>)
is List<*> -> value.map { normalizePayloadValue(it) }
else -> value
}
/** /**
* Worker de push de l'outbox : applique les batchs `pending_operations` vers * Worker de push de l'outbox : applique les batchs `pending_operations` vers
* `POST /sync/ops`, séquentiellement et dans l'ordre d'entrée en file. * `POST /sync/ops`, séquentiellement et dans l'ordre d'entrée en file.
@@ -36,12 +72,16 @@ import timber.log.Timber
* - **single-flight** : enregistré via `enqueueUniqueWork(KEEP)` — jamais deux * - **single-flight** : enregistré via `enqueueUniqueWork(KEEP)` — jamais deux
* workers parallèles (ordonnancement chronologique préservé) ; * workers parallèles (ordonnancement chronologique préservé) ;
* - **no-op sans token** : mode local, rien à pousser (contrat syncOutbox) ; * - **no-op sans token** : mode local, rien à pousser (contrat syncOutbox) ;
* - **retry transient** : `NETWORK_ERROR`/5xx/timeout → `Result.retry()` * - **retry transient ou non-attribuable** : `NETWORK_ERROR`/5xx/429/408,
* (backoff exponentiel) sans bump du compteur d'attempts ; * `INVALID_RESPONSE` et toute erreur batch-level non-401 → `Result.retry()`
* - **dead-letter permanent** : erreur 4xx non-idempotente → op passée en * (backoff exponentiel) sans toucher aux ops — la faute ne peut pas être
* `failed` immédiatement (évite d'affamer la queue : le serveur s'arrête à * imputée à une op du batch, le rejeu est sûr (idempotence serveur) ;
* la 1re erreur), et cascade si `create_resource` a échoué (toutes les ops * - **dead-letter permanente** : seule l'erreur par-op (`failed` dans le
* filles en attente sur la même resource passent `failed`) ; * `200`) passe l'op en `failed` immédiatement (évite d'affamer la queue :
* le serveur s'arrête à la 1re erreur) puis **stoppe le run** — jamais de
* batch suivant dans le même run ; si un `create_resource` a échoué, les
* ops filles en attente (même ressource + enfants via
* `payload.parentResourceId`, transitif) passent `failed` ;
* - `attempts` est un compteur diagnostic (incrémenté à chaque dead-letter), * - `attempts` est un compteur diagnostic (incrémenté à chaque dead-letter),
* pas un seuil : une op `failed` n'est plus resélectionnée. * pas un seuil : une op `failed` n'est plus resélectionnée.
* - push **avant** pull : le pull `GET /sync/permissions` (V2) s'appliquera * - push **avant** pull : le pull `GET /sync/permissions` (V2) s'appliquera
@@ -90,26 +130,35 @@ class OutboxSyncWorker @AssistedInject constructor(
apiClient.syncOps(ops) apiClient.syncOps(ops)
} catch (e: ApiException) { } catch (e: ApiException) {
when { when {
e.code == "NETWORK_ERROR" || e.httpCode >= 500 -> {
// Transitoire : on retentera avec backoff, sans bump d'attempts.
return Result.retry()
}
e.httpCode == 401 -> { e.httpCode == 401 -> {
// Token expiré/révoqué : le re-login se fera via l'UI. // Token expiré/révoqué : `onUnauthorized` (scope
// applicatif) a purgé la session. Succès : le re-login
// ré-enqueue le drain (m3).
return Result.success() return Result.success()
} }
else -> { else -> {
// Erreur permanente : dead-letter la 1re op du batch. // Transitoire (NETWORK_ERROR/5xx/429/408) ou
val now = System.currentTimeMillis() // non-attribuable (INVALID_RESPONSE, 4xx batch-level) :
pendingOperationDao.markFailed(pending.first().id, now) // rejouer avec backoff SANS toucher aux ops. La faute
continue // ne peut pas être imputée à la 1re op du batch (C2) —
// le rejeu est sûr (idempotence serveur).
return Result.retry()
} }
} }
} }
val now = System.currentTimeMillis() val now = System.currentTimeMillis()
// Garde C7 : `applied` incohérent → clamp, jamais de crash.
val appliedCount = result.applied.coerceIn(0, pending.size)
if (appliedCount != result.applied) {
Timber.w(
"outbox applied incohérent (%d pour %d ops), clamp",
result.applied,
pending.size,
)
}
// Ops appliquées par le serveur (indices < applied). // Ops appliquées par le serveur (indices < applied).
for (i in 0 until result.applied) { for (i in 0 until appliedCount) {
pendingOperationDao.markSynced(pending[i].id, now) pendingOperationDao.markSynced(pending[i].id, now)
promotePlacement(pending[i]) promotePlacement(pending[i])
Timber.d("outbox synced %s", pending[i].operationId) Timber.d("outbox synced %s", pending[i].operationId)
@@ -118,16 +167,32 @@ class OutboxSyncWorker @AssistedInject constructor(
// Première erreur non-idempotente → dead-letter + cascade éventuelle. // Première erreur non-idempotente → dead-letter + cascade éventuelle.
result.failed?.let { fail -> result.failed?.let { fail ->
val failedIndex = pending.indexOfFirst { it.operationId == fail.operationId } val failedIndex = pending.indexOfFirst { it.operationId == fail.operationId }
if (failedIndex >= 0) { if (failedIndex < 0) {
// Garde C7 : `operation_id` inconnu → stop, pas de boucle
// serrée sur le même batch.
Timber.w("outbox failed inconnu %s, arrêt du run", fail.operationId)
return Result.success()
}
val failedOp = pending[failedIndex] val failedOp = pending[failedIndex]
pendingOperationDao.markFailed(failedOp.id, now) pendingOperationDao.markFailed(failedOp.id, now)
Timber.w("outbox failed %s (%s: %s)", fail.operationId, fail.code, fail.message) Timber.w("outbox failed %s (%s: %s)", fail.operationId, fail.code, fail.message)
if (failedOp.operation == PendingOperationType.CREATE_RESOURCE) { if (failedOp.operation == PendingOperationType.CREATE_RESOURCE) {
failedOp.resourceId?.let { resourceId -> failedOp.resourceId?.let { resourceId ->
pendingOperationDao.failDescendants(resourceId, now) pendingOperationDao.failDescendants(resourceId, now)
cascadeCreateFailure(resourceId, now)
} }
} }
// C6 : stop au 1er échec — le serveur s'est arrêté là, tout ce
// qui suit reste pending pour le prochain run (jamais de
// `continue` vers le batch suivant).
return Result.success()
} }
// Garde C7 : aucun progrès (`applied == 0`, `failed == null`) →
// sortie, sinon busy-loop sans backoff.
if (appliedCount == 0) {
Timber.w("outbox aucun progrès (applied=0, failed=null), arrêt du run")
return Result.success()
} }
// Boucle : d'autres batchs attendent → traité dans le même run. // Boucle : d'autres batchs attendent → traité dans le même run.
@@ -158,6 +223,7 @@ class OutboxSyncWorker @AssistedInject constructor(
private fun PendingOperationEntity.toSyncOpDto(): SyncOpDto { private fun PendingOperationEntity.toSyncOpDto(): SyncOpDto {
val payloadMap = runCatching { payloadAdapter.fromJson(payload) }.getOrNull() val payloadMap = runCatching { payloadAdapter.fromJson(payload) }.getOrNull()
?.let { normalizePayloadNumbers(it) }
return SyncOpDto( return SyncOpDto(
operationId = operationId, operationId = operationId,
refType = refType, refType = refType,
@@ -169,10 +235,50 @@ class OutboxSyncWorker @AssistedInject constructor(
) )
} }
/**
* Invalidation transitive après l'échec d'un `create_resource` : les
* enfants portent un autre `resource_id`, liés via
* `payload.parentResourceId` (le walk émet parent avant enfant). Parcours
* en largeur depuis la ressource fautive sur l'ensemble des ops en
* attente — chaque niveau est invalidé via `failDescendants`.
*/
private suspend fun cascadeCreateFailure(failedResourceId: String, now: Long) {
val visited = mutableSetOf(failedResourceId)
val frontier = ArrayDeque<String>().apply { add(failedResourceId) }
while (frontier.isNotEmpty()) {
val current = frontier.removeFirst()
val children = pendingOperationDao.selectPending(CASCADE_SCAN_LIMIT)
.mapNotNull { op ->
val childId = op.resourceId
if (op.status == PendingOpStatus.PENDING && childId != null &&
childId !in visited && parentResourceIdOf(op) == current
) {
childId
} else {
null
}
}
.distinct()
for (child in children) {
if (visited.add(child)) {
pendingOperationDao.failDescendants(child, now)
frontier.add(child)
}
}
}
}
/** Lien parent→enfant : colonne dénormalisée, repli parsing JSON (lignes pré-v14). */
private fun parentResourceIdOf(op: PendingOperationEntity): String? =
op.parentResourceId ?: runCatching { payloadAdapter.fromJson(op.payload) }
.getOrNull()?.get(OutboxRepository.PARENT_PAYLOAD_KEY) as? String
companion object { companion object {
const val NAME = "outbox_sync" const val NAME = "outbox_sync"
private const val BATCH_SIZE = 20 private const val BATCH_SIZE = 20
private const val PURGE_AGE_MS = 7 * 24 * 60 * 60 * 1000L private const val PURGE_AGE_MS = 7 * 24 * 60 * 60 * 1000L
/** Fenêtre de balayage de la cascade (au-delà, convergence au run suivant). */
private const val CASCADE_SCAN_LIMIT = 10_000
/** /**
* Enregistre (idempotent) le worker avec contrainte réseau + backoff. * Enregistre (idempotent) le worker avec contrainte réseau + backoff.
@@ -9,6 +9,7 @@ import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ensureActive import kotlinx.coroutines.ensureActive
import kotlinx.coroutines.withContext import kotlinx.coroutines.withContext
import kotlinx.coroutines.yield import kotlinx.coroutines.yield
import timber.log.Timber
import javax.inject.Inject import javax.inject.Inject
import javax.inject.Singleton import javax.inject.Singleton
@@ -51,7 +52,9 @@ class SafScanner @Inject constructor(
/** Marche la racine `treeUri` ; renvoie tous les dossiers en ordre préfixe (DFS). */ /** Marche la racine `treeUri` ; renvoie tous les dossiers en ordre préfixe (DFS). */
suspend fun scanTree(treeUri: Uri): List<FolderNode> = withContext(Dispatchers.IO) { suspend fun scanTree(treeUri: Uri): List<FolderNode> = withContext(Dispatchers.IO) {
val rootDocId = DocumentsContract.getTreeDocumentId(treeUri) val rootDocId = runCatching { DocumentsContract.getTreeDocumentId(treeUri) }
.onFailure { Timber.w(it, "scanTree: treeUri illisible %s", treeUri) }
.getOrNull() ?: return@withContext emptyList()
val root = ScanFolder( val root = ScanFolder(
uri = treeUri.toString(), uri = treeUri.toString(),
docId = rootDocId, docId = rootDocId,
@@ -110,6 +113,9 @@ class SafScanner @Inject constructor(
val folders = ArrayList<ChildDir>() val folders = ArrayList<ChildDir>()
val files = ArrayList<FileNode>() val files = ArrayList<FileNode>()
// Permission révoquée / provider KO : dossier vu vide, jamais de crash
// (le walk réessaiera au prochain tick, la réconciliation ne supprime rien).
runCatching {
resolver.query( resolver.query(
childrenUri, childrenUri,
arrayOf( arrayOf(
@@ -124,17 +130,22 @@ class SafScanner @Inject constructor(
"${DocumentsContract.Document.COLUMN_DISPLAY_NAME} ASC", "${DocumentsContract.Document.COLUMN_DISPLAY_NAME} ASC",
)?.use { cursor -> )?.use { cursor ->
val iDoc = cursor.getColumnIndex(DocumentsContract.Document.COLUMN_DOCUMENT_ID) val iDoc = cursor.getColumnIndex(DocumentsContract.Document.COLUMN_DOCUMENT_ID)
// Curseur dégénéré (colonne DOCUMENT_ID absente) : dossier vu
// vide plutôt que crash de tout le walk.
if (iDoc < 0) return@use
val iName = cursor.getColumnIndex(DocumentsContract.Document.COLUMN_DISPLAY_NAME) val iName = cursor.getColumnIndex(DocumentsContract.Document.COLUMN_DISPLAY_NAME)
val iMime = cursor.getColumnIndex(DocumentsContract.Document.COLUMN_MIME_TYPE) val iMime = cursor.getColumnIndex(DocumentsContract.Document.COLUMN_MIME_TYPE)
val iSize = cursor.getColumnIndex(DocumentsContract.Document.COLUMN_SIZE) val iSize = cursor.getColumnIndex(DocumentsContract.Document.COLUMN_SIZE)
val iLast = cursor.getColumnIndex(DocumentsContract.Document.COLUMN_LAST_MODIFIED) val iLast = cursor.getColumnIndex(DocumentsContract.Document.COLUMN_LAST_MODIFIED)
while (cursor.moveToNext()) { while (cursor.moveToNext()) {
val docId = cursor.getString(iDoc) val docId = if (!cursor.isNull(iDoc)) cursor.getString(iDoc) else null
if (docId.isNullOrEmpty()) continue
if (docId == dirDocId) continue // certains providers renvoient le dossier lui-même if (docId == dirDocId) continue // certains providers renvoient le dossier lui-même
val name = if (iName >= 0) cursor.getString(iName) var name = if (iName >= 0 && !cursor.isNull(iName)) cursor.getString(iName) else null
else docId.substringAfterLast('/') if (name.isNullOrEmpty()) name = docId.substringAfterLast('/')
val mime = if (iMime >= 0) cursor.getString(iMime) else null if (name.isNullOrEmpty()) continue
val mime = if (iMime >= 0 && !cursor.isNull(iMime)) cursor.getString(iMime) else null
if (name.startsWith(".")) continue if (name.startsWith(".")) continue
@@ -143,7 +154,8 @@ class SafScanner @Inject constructor(
folders += ChildDir(docId, uri, name) folders += ChildDir(docId, uri, name)
} else { } else {
val size = if (iSize >= 0 && !cursor.isNull(iSize)) cursor.getLong(iSize) else 0L val size = if (iSize >= 0 && !cursor.isNull(iSize)) cursor.getLong(iSize) else 0L
if (size == 0L) continue // Les fichiers 0-octet sont des documents légitimes
// (notes vides, exports) : importés et reviewés comme les autres.
if (KNOWN_NOISE_EXTENSIONS.any { name.endsWith(it, ignoreCase = true) }) continue if (KNOWN_NOISE_EXTENSIONS.any { name.endsWith(it, ignoreCase = true) }) continue
val uri = DocumentsContract.buildDocumentUriUsingTree(treeUri, docId).toString() val uri = DocumentsContract.buildDocumentUriUsingTree(treeUri, docId).toString()
@@ -157,6 +169,9 @@ class SafScanner @Inject constructor(
} }
} }
} }
}.onFailure { e ->
Timber.w(e, "scanTree: listing impossible pour %s", dirDocId)
}
return DirContents(folders, files) return DirContents(folders, files)
} }
@@ -12,6 +12,8 @@ import com.kazier.mobile.data.repository.FolderRepository
import com.kazier.mobile.data.repository.SaveFolderInput import com.kazier.mobile.data.repository.SaveFolderInput
import com.kazier.mobile.data.repository.ShareRepository import com.kazier.mobile.data.repository.ShareRepository
import com.kazier.mobile.features.ocr.OcrAutoWorker import com.kazier.mobile.features.ocr.OcrAutoWorker
import com.kazier.mobile.features.saf.FileDeleter
import com.kazier.mobile.features.saf.FolderDeleter
import dagger.hilt.android.lifecycle.HiltViewModel import dagger.hilt.android.lifecycle.HiltViewModel
import dagger.hilt.android.qualifiers.ApplicationContext import dagger.hilt.android.qualifiers.ApplicationContext
import kotlinx.coroutines.CancellationException import kotlinx.coroutines.CancellationException
@@ -49,6 +51,8 @@ class SyncViewModel @Inject constructor(
private val folderRepository: FolderRepository, private val folderRepository: FolderRepository,
private val pendingOperationDao: PendingOperationDao, private val pendingOperationDao: PendingOperationDao,
private val shareRepository: ShareRepository, private val shareRepository: ShareRepository,
private val fileDeleter: FileDeleter,
private val folderDeleter: FolderDeleter,
@ApplicationContext private val appContext: Context, @ApplicationContext private val appContext: Context,
) : ViewModel() { ) : ViewModel() {
@@ -102,21 +106,52 @@ class SyncViewModel @Inject constructor(
delay(FIRST_DELAY_MS) delay(FIRST_DELAY_MS)
while (isActive) { while (isActive) {
_walkInProgress.value = true _walkInProgress.value = true
try {
var changed = false
runCatching { deviceSync.syncAll() } runCatching { deviceSync.syncAll() }
.onSuccess { results -> .onSuccess { results ->
if (results.isNotEmpty()) Timber.d("syncAll: %s", results) if (results.isNotEmpty()) Timber.d("syncAll: %s", results)
// Les nouvelles ressources découvertes sont dans l'outbox changed = results.any { it.folders > 0 || it.files > 0 || it.missing > 0 }
// → drainer vers POST /sync/ops (single-flight via KEEP). // Repasse C4 : les suppressions journalisées dont les
OutboxSyncWorker.enqueue(appContext) // octets ont survécu (crash entre journal et SAF).
// OCR auto : uploader les octets des fichiers récemment promus (local-cloud). runCatching {
OcrAutoWorker.enqueue(appContext) fileDeleter.sweepPendingPhysicalDeletes() +
folderDeleter.sweepPendingPhysicalDeletes()
}.onSuccess { swept ->
if (swept > 0) {
Timber.d("sweep: %d suppressions physiques rattrapées", swept)
changed = true
}
}.onFailure { e ->
Timber.w(e, "sweep failed, retrying later")
}
}
.onFailure { e ->
if (e is CancellationException) throw e
Timber.w(e, "syncAll failed, retrying later")
} }
.onFailure { e -> Timber.w(e, "syncAll failed, retrying later") }
// Hydrate les ressources partagées depuis le snapshot serveur. // Hydrate les ressources partagées depuis le snapshot serveur.
// Échec réseau toléré : le prochain tick réessaiera. // Échec réseau toléré : le prochain tick réessaiera.
runCatching { shareRepository.syncSnapshot() } runCatching { shareRepository.syncSnapshot() }
.onFailure { e -> Timber.d("syncSnapshot failed, retrying later: %s", e.message) } .onFailure { e ->
if (e is CancellationException) throw e
Timber.d("syncSnapshot 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…).
// Les nouvelles ressources découvertes sont dans l'outbox
// → drainer vers POST /sync/ops (single-flight via KEEP) ;
// OCR auto : octets des fichiers récemment promus.
if (changed || pendingOperationDao.countPending() > 0) {
OutboxSyncWorker.enqueue(appContext)
OcrAutoWorker.enqueue(appContext)
}
} finally {
// m1 : le badge « syncing » retombe même si le scope est
// annulé ou si le snapshot réseau a échoué.
_walkInProgress.value = false _walkInProgress.value = false
}
delay(INTERVAL_MS) delay(INTERVAL_MS)
} }
} }
@@ -143,6 +178,14 @@ class SyncViewModel @Inject constructor(
) )
val result = deviceSync.syncRoot(saved.resourceId) val result = deviceSync.syncRoot(saved.resourceId)
Timber.d("syncRoot %s", result) Timber.d("syncRoot %s", result)
// Même drain qu'après `syncAll` (M7) : le `create_resource` de
// la racine ne doit pas dormir jusqu'au prochain tick.
OutboxSyncWorker.enqueue(appContext)
OcrAutoWorker.enqueue(appContext)
runCatching {
fileDeleter.sweepPendingPhysicalDeletes() +
folderDeleter.sweepPendingPhysicalDeletes()
}.onFailure { e -> Timber.w(e, "sweep failed, retrying later") }
} catch (e: CancellationException) { } catch (e: CancellationException) {
throw e throw e
} catch (e: Exception) { } catch (e: Exception) {
@@ -54,6 +54,19 @@ class ThumbnailStore @Inject constructor(
internal fun thumbnailFile(resourceId: String): File = internal fun thumbnailFile(resourceId: String): File =
File(dir(), "$resourceId.webp") File(dir(), "$resourceId.webp")
/**
* Fichier cible versionné `mtime + taille` de la source : après une
* édition rapide (mtime SAF à la seconde près), la taille différente
* invalide l'ancien fichier même si les mtime coïncident.
*/
internal fun thumbnailFile(resourceId: String, lastModified: Long?, size: Long?): File {
if (lastModified == null || size == null) return thumbnailFile(resourceId)
return File(dir(), "${resourceId}_${lastModified}_${size}.webp")
}
/** Nombre de verrous single-flight en cours (diagnostic/tests). */
internal fun lockCount(): Int = locks.size
/** /**
* Vignette du fichier, générée si absente ou périmée. `null` si le fichier * Vignette du fichier, générée si absente ou périmée. `null` si le fichier
* n'est ni image ni PDF, n'a pas d'uri, ou si la génération échoue * n'est ni image ni PDF, n'a pas d'uri, ou si la génération échoue
@@ -64,24 +77,57 @@ class ThumbnailStore @Inject constructor(
val category = file.categoryValue() val category = file.categoryValue()
if (category != FileCategory.IMAGE && category != FileCategory.PDF) return null if (category != FileCategory.IMAGE && category != FileCategory.PDF) return null
val target = thumbnailFile(file.resourceId) val target = thumbnailFile(file.resourceId, file.lastModified, file.size)
if (isUpToDate(target, file.lastModified)) return target if (isUpToDate(target, file.lastModified)) return target
// Ancienne version (legacy ou mtime/taille précédents) encore fraîche.
val legacy = thumbnailFile(file.resourceId)
if (legacy != target && isUpToDate(legacy, file.lastModified)) return legacy
val lock = locks.getOrPut(file.resourceId) { Mutex() } val lock = locks.getOrPut(file.resourceId) { Mutex() }
try {
return lock.withLock { return lock.withLock {
if (isUpToDate(target, file.lastModified)) target if (isUpToDate(target, file.lastModified)) {
else generateInto(context.contentResolver, uri, category, target) target
} else if (legacy != target && isUpToDate(legacy, file.lastModified)) {
legacy
} else {
generateInto(context.contentResolver, uri, category, target)?.also { generated ->
pruneSiblings(file.resourceId, keep = generated)
}
}
}
} finally {
// Pas de fuite lente : le Mutex est retiré dès la fin (un appelant
// arrivé entre-temps garde sa propre référence, toujours valide).
locks.remove(file.resourceId, lock)
} }
} }
/** Purge la vignette d'une resource (delete physique) — best-effort. */ /** Purge toutes les vignettes d'une resource (toutes versions + tmp). */
fun delete(resourceId: String) { fun delete(resourceId: String) {
runCatching { thumbnailFile(resourceId).delete() } runCatching {
dir().listFiles { f -> isOwnedThumb(resourceId, f.name) }
?.forEach { it.delete() }
}
} }
/** Cache-hit : fichier présent et au moins aussi récent que la source. */ /** Fichier possédé par une resource : version courante, legacy ou tmp. */
private fun isOwnedThumb(resourceId: String, name: String): Boolean {
if (name == "$resourceId.webp") return true
if (name.startsWith(resourceId + "_") && name.endsWith(".webp")) return true
if (name.startsWith(resourceId) && name.endsWith(".tmp")) return true
return false
}
/** Supprime les versions périmées et les `.tmp` orphelins (génération OK). */
private fun pruneSiblings(resourceId: String, keep: File) {
dir().listFiles { f -> f != keep && isOwnedThumb(resourceId, f.name) }
?.forEach { runCatching { it.delete() } }
}
/** Cache-hit : fichier présent, non vide, et au moins aussi récent que la source. */
internal fun isUpToDate(target: File, lastModified: Long?): Boolean { internal fun isUpToDate(target: File, lastModified: Long?): Boolean {
if (!target.isFile) return false if (!target.isFile || target.length() == 0L) return false
if (lastModified == null) return true if (lastModified == null) return true
return target.lastModified() >= lastModified return target.lastModified() >= lastModified
} }
@@ -99,9 +145,9 @@ class ThumbnailStore @Inject constructor(
else -> null else -> null
} }
bitmap ?: return@withContext null bitmap ?: return@withContext null
val tmp = File(target.parentFile, "${target.name}.tmp")
try { try {
dir().mkdirs() dir().mkdirs()
val tmp = File(target.parentFile, "${target.name}.tmp")
val ok = tmp.outputStream().use { out -> val ok = tmp.outputStream().use { out ->
bitmap.compress(Bitmap.CompressFormat.WEBP, WEBP_QUALITY, out) bitmap.compress(Bitmap.CompressFormat.WEBP, WEBP_QUALITY, out)
} }
@@ -109,10 +155,15 @@ class ThumbnailStore @Inject constructor(
// La source a bougé pendant notre génération : on garde la dernière. // La source a bougé pendant notre génération : on garde la dernière.
target.delete() target.delete()
} }
if (ok && tmp.renameTo(target)) target else null // Échec de renommage : pas de `.tmp` orphelin, pas de cible
// touchée (une version concurrente fraîche reste en place).
if (ok && tmp.renameTo(target)) target else {
runCatching { tmp.delete() }
null
}
} catch (e: Exception) { } catch (e: Exception) {
Timber.w(e, "thumbnail write failed for $uri") Timber.w(e, "thumbnail write failed for $uri")
runCatching { target.delete() } runCatching { tmp.delete() }
null null
} finally { } finally {
bitmap.recycle() bitmap.recycle()
@@ -121,7 +172,11 @@ class ThumbnailStore @Inject constructor(
/** Image : décodage en `inSampleSize` pour ne jamais matérialiser le full-res. */ /** Image : décodage en `inSampleSize` pour ne jamais matérialiser le full-res. */
private fun decodeImage(resolver: ContentResolver, uri: String): Bitmap? { private fun decodeImage(resolver: ContentResolver, uri: String): Bitmap? {
val stream = DocumentContent.openInputStream(resolver, uri) ?: return null // Le provider peut lever à l'ouverture (permission révoquée, fichier
// absent) : échec de génération, jamais de crash (même contrat que le
// walk SAF face aux providers dégénérés).
val stream = runCatching { DocumentContent.openInputStream(resolver, uri) }.getOrNull()
?: return null
return try { return try {
// Première passe : dimensions seulement, sans décodage pixels. // Première passe : dimensions seulement, sans décodage pixels.
val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true } val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
@@ -6,7 +6,17 @@ import com.kazier.mobile.data.remote.dto.UserDto
/** État global de connexion — équivalent de `AuthStatus` JS. */ /** État global de connexion — équivalent de `AuthStatus` JS. */
sealed interface AuthState { sealed interface AuthState {
data object Loading : AuthState data object Loading : AuthState
data object SignedOut : AuthState
/**
* Déconnecté. `expired` = la session précédente est tombée (401 / token
* expiré) plutôt qu'un sign-out volontaire — le login affiche un avis et
* pré-remplit `username` quand il est connu.
*/
data class SignedOut(
val expired: Boolean = false,
val username: String? = null,
) : AuthState
data object Local : AuthState data object Local : AuthState
data class SignedIn(val user: UserDto) : AuthState data class SignedIn(val user: UserDto) : AuthState
} }
@@ -3,8 +3,8 @@ package com.kazier.mobile.ui.auth
import android.content.Context import android.content.Context
import androidx.lifecycle.ViewModel import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope import androidx.lifecycle.viewModelScope
import com.kazier.mobile.auth.AuthEvent
import com.kazier.mobile.auth.SessionManager import com.kazier.mobile.auth.SessionManager
import com.kazier.mobile.data.remote.ApiClient
import com.kazier.mobile.data.remote.ApiException import com.kazier.mobile.data.remote.ApiException
import com.kazier.mobile.data.repository.AuthRepository import com.kazier.mobile.data.repository.AuthRepository
import com.kazier.mobile.data.repository.ShareRepository import com.kazier.mobile.data.repository.ShareRepository
@@ -26,7 +26,6 @@ import javax.inject.Inject
class AuthViewModel @Inject constructor( class AuthViewModel @Inject constructor(
private val authRepository: AuthRepository, private val authRepository: AuthRepository,
private val sessionManager: SessionManager, private val sessionManager: SessionManager,
private val apiClient: ApiClient,
private val shareRepository: ShareRepository, private val shareRepository: ShareRepository,
@ApplicationContext private val appContext: Context, @ApplicationContext private val appContext: Context,
) : ViewModel() { ) : ViewModel() {
@@ -38,24 +37,41 @@ class AuthViewModel @Inject constructor(
val loginUiState: StateFlow<LoginUiState> = _loginUiState.asStateFlow() val loginUiState: StateFlow<LoginUiState> = _loginUiState.asStateFlow()
init { init {
// 401 sur un endpoint protégé (token expiré/révoqué, compte supprimé) // Le 401 est géré par SessionManager (singleton) — jamais ici (M25) :
// → purge de la session. Le 401 du login est exonéré (skip dans ApiClient). // ce callback survivrait sinon à onCleared et figerait l'outbox. On ne
apiClient.onUnauthorized = { signOut() } // consomme que ses événements (re-login silencieux / expiration).
viewModelScope.launch {
sessionManager.events.collect { event ->
when (event) {
is AuthEvent.Reauthenticated -> enterSignedIn(event.user, reseed = true)
is AuthEvent.SessionExpired ->
_authState.value = AuthState.SignedOut(expired = true, username = event.username)
}
}
}
viewModelScope.launch { viewModelScope.launch {
val session = sessionManager.restore() val session = sessionManager.restore()
_authState.value = when { _authState.value = when {
session != null -> AuthState.SignedIn(session.user) session == null && sessionManager.isLocalMode() -> AuthState.Local
sessionManager.isLocalMode() -> AuthState.Local session == null -> AuthState.SignedOut()
else -> AuthState.SignedOut sessionManager.isTokenExpired() -> {
// Token périmé connu : re-login proactif avant tout 401.
// Échec → login avec avis d'expiration (username pré-rempli).
if (sessionManager.trySilentRelogin()) {
AuthState.SignedIn(session.user)
} else {
AuthState.SignedOut(expired = true, username = session.user.username)
}
}
else -> AuthState.SignedIn(session.user)
} }
authRepository.registerDevice() authRepository.registerDevice()
// Session restaurée → drainer l'outbox laissée en attente. // Session restaurée → drainer l'outbox laissée en attente.
OutboxSyncWorker.enqueue(appContext) OutboxSyncWorker.enqueue(appContext)
OcrAutoWorker.enqueue(appContext) OcrAutoWorker.enqueue(appContext)
if (session != null) { if (session != null && _authState.value is AuthState.SignedIn) {
// Snapshot complet des permissions partagées (convergence). // Snapshot complet des permissions partagées (convergence, M27).
runCatching { shareRepository.syncSnapshot() } runCatching { shareRepository.syncSnapshot(forceFull = true) }
.onFailure { e -> Timber.d("syncSnapshot on restore failed: %s", e.message) } .onFailure { e -> Timber.d("syncSnapshot on restore failed: %s", e.message) }
} }
} }
@@ -70,15 +86,9 @@ class AuthViewModel @Inject constructor(
_loginUiState.update { LoginUiState(isSubmitting = true) } _loginUiState.update { LoginUiState(isSubmitting = true) }
runCatching { authRepository.login(username, password) } runCatching { authRepository.login(username, password) }
.onSuccess { response -> .onSuccess { response ->
sessionManager.save(response.token, response.user) sessionManager.save(response.token, response.user, response.expiresAt, username.trim(), password)
_loginUiState.value = LoginUiState() _loginUiState.value = LoginUiState()
_authState.value = AuthState.SignedIn(response.user) enterSignedIn(response.user, reseed = true)
// Connexion réussie → pousser les mutations locales en attente.
OutboxSyncWorker.enqueue(appContext)
OcrAutoWorker.enqueue(appContext)
// Snapshot complet des permissions partagées (convergence).
runCatching { shareRepository.syncSnapshot() }
.onFailure { e -> Timber.d("syncSnapshot on login failed: %s", e.message) }
} }
.onFailure { e -> .onFailure { e ->
val error = when (e) { val error = when (e) {
@@ -90,6 +100,19 @@ class AuthViewModel @Inject constructor(
} }
} }
/** Session (re)connectée : état + drain + snapshot permissions. */
private fun enterSignedIn(user: com.kazier.mobile.data.remote.dto.UserDto, reseed: Boolean) {
_authState.value = AuthState.SignedIn(user)
if (reseed) {
OutboxSyncWorker.enqueue(appContext)
OcrAutoWorker.enqueue(appContext)
viewModelScope.launch {
runCatching { shareRepository.syncSnapshot(forceFull = true) }
.onFailure { e -> Timber.d("syncSnapshot on login failed: %s", e.message) }
}
}
}
fun continueWithoutAccount() { fun continueWithoutAccount() {
viewModelScope.launch { viewModelScope.launch {
sessionManager.setLocalMode() sessionManager.setLocalMode()
@@ -116,11 +139,7 @@ class AuthViewModel @Inject constructor(
sessionManager.clear() sessionManager.clear()
sessionManager.clearLocalMode() sessionManager.clearLocalMode()
} }
_authState.value = AuthState.SignedOut _authState.value = AuthState.SignedOut()
} }
} }
override fun onCleared() {
apiClient.onUnauthorized = null
}
} }
@@ -0,0 +1,133 @@
package com.kazier.mobile.ui.auth
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.text.KeyboardActions
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Visibility
import androidx.compose.material.icons.filled.VisibilityOff
import androidx.compose.material3.Button
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.input.ImeAction
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.text.input.VisualTransformation
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import com.kazier.mobile.R
/**
* Formulaire d'authentification partagé (Login + Réglages) : validation
* inline (champs non vides), touche Done = submit, œil voir/masquer le mot
* de passe, erreur centrée sous le bouton.
*/
@Composable
fun LoginForm(
username: String,
onUsernameChange: (String) -> Unit,
password: String,
onPasswordChange: (String) -> Unit,
submitting: Boolean,
errorRes: Int?,
submitLabel: String,
onSubmit: () -> Unit,
modifier: Modifier = Modifier,
) {
var passwordVisible by rememberSaveable { mutableStateOf(false) }
// Pas d'appel réseau pour des champs vides — validation pure UI.
val canSubmit = !submitting && username.isNotBlank() && password.isNotBlank()
val submitIfValid = { if (canSubmit) onSubmit() }
Column(
modifier = modifier,
verticalArrangement = Arrangement.spacedBy(12.dp),
) {
OutlinedTextField(
value = username,
onValueChange = onUsernameChange,
label = { Text(stringResource(R.string.login_username)) },
singleLine = true,
keyboardOptions = KeyboardOptions(
keyboardType = KeyboardType.Text,
imeAction = ImeAction.Next,
),
modifier = Modifier.fillMaxWidth(),
)
OutlinedTextField(
value = password,
onValueChange = onPasswordChange,
label = { Text(stringResource(R.string.login_password)) },
singleLine = true,
visualTransformation = if (passwordVisible) {
VisualTransformation.None
} else {
PasswordVisualTransformation()
},
trailingIcon = {
IconButton(onClick = { passwordVisible = !passwordVisible }) {
Icon(
imageVector = if (passwordVisible) {
Icons.Filled.VisibilityOff
} else {
Icons.Filled.Visibility
},
contentDescription = stringResource(
if (passwordVisible) {
R.string.login_hide_password
} else {
R.string.login_show_password
},
),
)
}
},
keyboardOptions = KeyboardOptions(
keyboardType = KeyboardType.Password,
imeAction = ImeAction.Done,
),
keyboardActions = KeyboardActions(onDone = { submitIfValid() }),
modifier = Modifier.fillMaxWidth(),
)
Spacer(Modifier.height(4.dp))
Button(
onClick = submitIfValid,
enabled = canSubmit,
modifier = Modifier.fillMaxWidth(),
) {
if (submitting) {
CircularProgressIndicator(
modifier = Modifier.size(20.dp),
strokeWidth = 2.dp,
)
} else {
Text(submitLabel)
}
}
if (errorRes != null) {
Text(
text = stringResource(errorRes),
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.error,
textAlign = TextAlign.Center,
modifier = Modifier.fillMaxWidth(),
)
}
}
}
@@ -8,42 +8,47 @@ import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.imePadding import androidx.compose.foundation.layout.imePadding
import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.rememberScrollState import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.foundation.verticalScroll import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.Button import androidx.compose.material3.Button
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.MaterialTheme import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Text import androidx.compose.material3.Text
import androidx.compose.material3.TextButton import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.saveable.rememberSaveable import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.input.ImeAction
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.text.style.TextAlign import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.lifecycle.compose.collectAsStateWithLifecycle
import com.kazier.mobile.R import com.kazier.mobile.R
/**
* Premier écran : choix explicite entre compte serveur et mode local, puis
* formulaire de connexion. Le mode local est expliqué avant d'être choisi
* (pas un petit lien d'esquive sous le formulaire).
*
* Après expiration de session (`expired`), le formulaire s'ouvre directement
* avec le username pré-rempli et un avis explicite — pas de repassage par
* l'écran de choix.
*/
@Composable @Composable
fun LoginScreen( fun LoginScreen(
viewModel: AuthViewModel = hiltViewModel(), viewModel: AuthViewModel = hiltViewModel(),
expired: Boolean = false,
initialUsername: String? = null,
) { ) {
val loginUi by viewModel.loginUiState.collectAsStateWithLifecycle() val loginUi by viewModel.loginUiState.collectAsStateWithLifecycle()
var username by rememberSaveable { mutableStateOf("") } var username by rememberSaveable { mutableStateOf(initialUsername.orEmpty()) }
var password by rememberSaveable { mutableStateOf("") } var password by rememberSaveable { mutableStateOf("") }
var showForm by rememberSaveable { mutableStateOf(expired) }
Column( Column(
modifier = Modifier modifier = Modifier
@@ -60,70 +65,68 @@ fun LoginScreen(
color = MaterialTheme.colorScheme.primary, color = MaterialTheme.colorScheme.primary,
) )
Spacer(Modifier.height(8.dp)) Spacer(Modifier.height(8.dp))
if (!showForm) {
Text( Text(
text = stringResource(R.string.login_subtitle), text = stringResource(R.string.login_choice_subtitle),
style = MaterialTheme.typography.bodyLarge, style = MaterialTheme.typography.bodyLarge,
color = MaterialTheme.colorScheme.onSurfaceVariant, color = MaterialTheme.colorScheme.onSurfaceVariant,
)
Spacer(Modifier.height(32.dp))
OutlinedTextField(
value = username,
onValueChange = { username = it },
label = { Text(stringResource(R.string.login_username)) },
singleLine = true,
keyboardOptions = KeyboardOptions(imeAction = ImeAction.Next),
modifier = Modifier.fillMaxWidth(),
)
Spacer(Modifier.height(12.dp))
OutlinedTextField(
value = password,
onValueChange = { password = it },
label = { Text(stringResource(R.string.login_password)) },
singleLine = true,
visualTransformation = PasswordVisualTransformation(),
keyboardOptions = KeyboardOptions(
keyboardType = KeyboardType.Password,
imeAction = ImeAction.Done,
),
modifier = Modifier.fillMaxWidth(),
)
Spacer(Modifier.height(24.dp))
Button(
onClick = { viewModel.signIn(username, password) },
enabled = !loginUi.isSubmitting,
modifier = Modifier.fillMaxWidth(),
) {
if (loginUi.isSubmitting) {
CircularProgressIndicator(
modifier = Modifier.size(20.dp),
strokeWidth = 2.dp,
)
} else {
Text(stringResource(R.string.login_submit))
}
}
loginUi.error?.let { error ->
Spacer(Modifier.height(12.dp))
Text(
text = stringResource(authErrorResFor(error)),
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.error,
textAlign = TextAlign.Center, textAlign = TextAlign.Center,
) )
Spacer(Modifier.height(32.dp))
Button(
onClick = { showForm = true },
modifier = Modifier.fillMaxWidth(),
) {
Text(stringResource(R.string.login_submit))
} }
Spacer(Modifier.height(12.dp))
Spacer(Modifier.height(16.dp)) OutlinedButton(
TextButton(onClick = viewModel::continueWithoutAccount) { onClick = viewModel::continueWithoutAccount,
modifier = Modifier.fillMaxWidth(),
) {
Text(stringResource(R.string.login_skip)) Text(stringResource(R.string.login_skip))
} }
Spacer(Modifier.height(16.dp))
Text( Text(
text = stringResource(R.string.skip_message), text = stringResource(R.string.skip_message),
style = MaterialTheme.typography.labelMedium, style = MaterialTheme.typography.labelMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant, color = MaterialTheme.colorScheme.onSurfaceVariant,
textAlign = TextAlign.Center, textAlign = TextAlign.Center,
) )
} else {
Text(
text = stringResource(R.string.login_subtitle),
style = MaterialTheme.typography.bodyLarge,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
if (expired) {
Spacer(Modifier.height(12.dp))
Text(
text = stringResource(R.string.login_session_expired),
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.error,
textAlign = TextAlign.Center,
)
}
Spacer(Modifier.height(32.dp))
LoginForm(
username = username,
onUsernameChange = { username = it },
password = password,
onPasswordChange = { password = it },
submitting = loginUi.isSubmitting,
errorRes = loginUi.error?.let(::authErrorResFor),
submitLabel = stringResource(R.string.login_submit),
onSubmit = { viewModel.signIn(username, password) },
modifier = Modifier.fillMaxWidth(),
)
Spacer(Modifier.height(16.dp))
TextButton(onClick = { showForm = false }) {
Text(stringResource(R.string.back))
}
}
} }
} }
@@ -17,25 +17,27 @@ import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.kazier.mobile.R import com.kazier.mobile.R
import com.kazier.mobile.data.local.entity.FileEntity import com.kazier.mobile.data.local.entity.FileEntity
import com.kazier.mobile.data.local.entity.FileStatus import com.kazier.mobile.data.local.entity.FileStatus
import com.kazier.mobile.features.saf.FileDeleter import com.kazier.mobile.features.saf.FileDeleter
import com.kazier.mobile.ui.theme.NavItemShape
import java.io.Serializable
/** Résultat de l\'analyse de compatibilité entre les fichiers et le mode choisi. */ /** Résultat de l'analyse de compatibilité entre les fichiers et le mode choisi. */
data class DeleteReview( data class DeleteReview(
val mode: FileDeleter.DeleteMode, val mode: FileDeleter.DeleteMode,
val total: Int, val total: Int,
val incompatibleCount: Int, val incompatibleCount: Int,
) { ) : Serializable {
val hasWarning: Boolean get() = incompatibleCount > 0 val hasWarning: Boolean get() = incompatibleCount > 0
} }
@@ -61,15 +63,16 @@ fun DeleteDropdownButton(
onModeSelected: (FileDeleter.DeleteMode) -> Unit, onModeSelected: (FileDeleter.DeleteMode) -> Unit,
modifier: Modifier = Modifier, modifier: Modifier = Modifier,
) { ) {
var expanded by remember { mutableStateOf(false) } var expanded by rememberSaveable { mutableStateOf(false) }
val tint = if (enabled) MaterialTheme.colorScheme.error val tint = if (enabled) MaterialTheme.colorScheme.error
else MaterialTheme.colorScheme.onSurfaceVariant else MaterialTheme.colorScheme.onSurfaceVariant
val deleteLabel = stringResource(R.string.delete)
Box(modifier = modifier) { Box(modifier = modifier) {
Surface( Surface(
onClick = { if (enabled) expanded = true }, onClick = { if (enabled) expanded = true },
enabled = enabled, enabled = enabled,
shape = androidx.compose.foundation.shape.RoundedCornerShape(20.dp), shape = NavItemShape,
color = if (enabled) MaterialTheme.colorScheme.errorContainer color = if (enabled) MaterialTheme.colorScheme.errorContainer
else MaterialTheme.colorScheme.surfaceVariant, else MaterialTheme.colorScheme.surfaceVariant,
modifier = modifier, modifier = modifier,
@@ -84,15 +87,16 @@ fun DeleteDropdownButton(
) { ) {
Icon( Icon(
imageVector = Icons.Filled.Delete, imageVector = Icons.Filled.Delete,
contentDescription = null, contentDescription = deleteLabel,
tint = tint, tint = tint,
modifier = Modifier.size(20.dp), modifier = Modifier.size(20.dp),
) )
Text( Text(
text = stringResource(R.string.delete), text = deleteLabel,
color = tint, color = tint,
fontSize = 11.sp, style = MaterialTheme.typography.labelSmall,
maxLines = 1, maxLines = 1,
overflow = TextOverflow.Ellipsis,
fontWeight = FontWeight.Bold, fontWeight = FontWeight.Bold,
) )
Icon( Icon(
@@ -9,12 +9,15 @@ import androidx.compose.material.icons.filled.Movie
import androidx.compose.material.icons.filled.MusicNote import androidx.compose.material.icons.filled.MusicNote
import androidx.compose.material.icons.filled.PictureAsPdf import androidx.compose.material.icons.filled.PictureAsPdf
import androidx.compose.material.icons.filled.TextSnippet import androidx.compose.material.icons.filled.TextSnippet
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.Icon import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.runtime.Composable import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.vector.ImageVector import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.unit.Dp import androidx.compose.ui.unit.Dp
import com.kazier.mobile.R
import com.kazier.mobile.data.local.entity.FileEntity import com.kazier.mobile.data.local.entity.FileEntity
import com.kazier.mobile.domain.FileCategory import com.kazier.mobile.domain.FileCategory
import com.kazier.mobile.domain.computeCategory import com.kazier.mobile.domain.computeCategory
@@ -31,16 +34,31 @@ val FileCategory.icon: ImageVector
FileCategory.OTHER -> Icons.Filled.InsertDriveFile FileCategory.OTHER -> Icons.Filled.InsertDriveFile
} }
/** Teinte dédiée à chaque catégorie de document. */ /** Teinte dédiée à chaque catégorie — déclinaison light/dark lisible sur les deux thèmes. */
val FileCategory.color: Color @Composable
get() = when (this) { fun FileCategory.color(): androidx.compose.ui.graphics.Color {
FileCategory.PDF -> Color(0xFFD32F2F) val dark = isSystemInDarkTheme()
FileCategory.OFFICE -> Color(0xFF1565C0) return when (this) {
FileCategory.IMAGE -> Color(0xFF2E7D32) FileCategory.PDF -> if (dark) androidx.compose.ui.graphics.Color(0xFFE57373) else androidx.compose.ui.graphics.Color(0xFFD32F2F)
FileCategory.TEXT -> Color(0xFF546E7A) FileCategory.OFFICE -> if (dark) androidx.compose.ui.graphics.Color(0xFF90CAF9) else androidx.compose.ui.graphics.Color(0xFF1565C0)
FileCategory.VIDEO -> Color(0xFF6A1B9A) FileCategory.IMAGE -> if (dark) androidx.compose.ui.graphics.Color(0xFF81C784) else androidx.compose.ui.graphics.Color(0xFF2E7D32)
FileCategory.AUDIO -> Color(0xFFAD1457) FileCategory.TEXT -> if (dark) androidx.compose.ui.graphics.Color(0xFFB0BEC5) else androidx.compose.ui.graphics.Color(0xFF546E7A)
FileCategory.OTHER -> Color(0xFF757575) FileCategory.VIDEO -> if (dark) androidx.compose.ui.graphics.Color(0xFFCE93D8) else androidx.compose.ui.graphics.Color(0xFF6A1B9A)
FileCategory.AUDIO -> if (dark) androidx.compose.ui.graphics.Color(0xFFF48FB1) else androidx.compose.ui.graphics.Color(0xFFAD1457)
FileCategory.OTHER -> if (dark) androidx.compose.ui.graphics.Color(0xFFBDBDBD) else androidx.compose.ui.graphics.Color(0xFF757575)
}
}
/** Libellé i18n de la catégorie — utilisé comme contentDescription. */
@Composable
fun FileCategory.label(): String = when (this) {
FileCategory.PDF -> stringResource(R.string.category_pdf)
FileCategory.OFFICE -> stringResource(R.string.category_office)
FileCategory.IMAGE -> stringResource(R.string.category_image)
FileCategory.TEXT -> stringResource(R.string.category_text)
FileCategory.VIDEO -> stringResource(R.string.category_video)
FileCategory.AUDIO -> stringResource(R.string.category_audio)
FileCategory.OTHER -> stringResource(R.string.category_other)
} }
/** /**
@@ -63,8 +81,8 @@ fun FileCategoryIcon(
val category = file.categoryValue() val category = file.categoryValue()
Icon( Icon(
imageVector = category.icon, imageVector = category.icon,
contentDescription = null, contentDescription = category.label(),
tint = category.color, tint = category.color(),
modifier = modifier.size(size), modifier = modifier.size(size),
) )
} }
@@ -7,7 +7,6 @@ import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.CircleShape import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.MaterialTheme import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface import androidx.compose.material3.Surface
import androidx.compose.material3.Text import androidx.compose.material3.Text
@@ -19,6 +18,7 @@ import androidx.compose.ui.res.stringResource
import androidx.compose.ui.unit.dp import androidx.compose.ui.unit.dp
import com.kazier.mobile.R import com.kazier.mobile.R
import com.kazier.mobile.data.local.entity.FileEntity import com.kazier.mobile.data.local.entity.FileEntity
import com.kazier.mobile.ui.theme.ThumbShape
/** /**
* Un fichier est « à traiter » s'il est présent physiquement et jamais encore * Un fichier est « à traiter » s'il est présent physiquement et jamais encore
@@ -41,7 +41,7 @@ fun FilePendingReviewBadge(
) { ) {
if (!file.isPendingReview()) return if (!file.isPendingReview()) return
Surface( Surface(
shape = RoundedCornerShape(8.dp), shape = ThumbShape,
color = MaterialTheme.colorScheme.tertiaryContainer, color = MaterialTheme.colorScheme.tertiaryContainer,
modifier = modifier, modifier = modifier,
) { ) {
@@ -5,12 +5,14 @@ import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Cloud import androidx.compose.material.icons.filled.Cloud
import androidx.compose.material.icons.filled.CloudDone import androidx.compose.material.icons.filled.CloudDone
import androidx.compose.material.icons.filled.CloudOff import androidx.compose.material.icons.filled.CloudOff
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.Icon import androidx.compose.material3.Icon
import androidx.compose.runtime.Composable import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.vector.ImageVector import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.unit.Dp import androidx.compose.ui.unit.Dp
import com.kazier.mobile.R
import com.kazier.mobile.data.local.entity.FileEntity import com.kazier.mobile.data.local.entity.FileEntity
import com.kazier.mobile.data.local.entity.FileStatus import com.kazier.mobile.data.local.entity.FileStatus
@@ -35,12 +37,22 @@ private val FileSyncPlacement.icon: ImageVector
FileSyncPlacement.LOCAL_CLOUD -> Icons.Filled.CloudDone FileSyncPlacement.LOCAL_CLOUD -> Icons.Filled.CloudDone
} }
/** Teinte dédiée à chaque placement. */ /** Teinte dédiée à chaque placement — déclinaison light/dark. */
private val FileSyncPlacement.color: Color @Composable
get() = when (this) { private fun FileSyncPlacement.color(): androidx.compose.ui.graphics.Color {
FileSyncPlacement.LOCAL -> Color(0xFFF57F17) val dark = isSystemInDarkTheme()
FileSyncPlacement.CLOUD -> Color(0xFF1565C0) return when (this) {
FileSyncPlacement.LOCAL_CLOUD -> Color(0xFF2E7D32) FileSyncPlacement.LOCAL -> if (dark) androidx.compose.ui.graphics.Color(0xFFFFB74D) else androidx.compose.ui.graphics.Color(0xFFB26A00)
FileSyncPlacement.CLOUD -> if (dark) androidx.compose.ui.graphics.Color(0xFF90CAF9) else androidx.compose.ui.graphics.Color(0xFF1565C0)
FileSyncPlacement.LOCAL_CLOUD -> if (dark) androidx.compose.ui.graphics.Color(0xFF81C784) else androidx.compose.ui.graphics.Color(0xFF2E7D32)
}
}
@Composable
private fun FileSyncPlacement.label(): String = when (this) {
FileSyncPlacement.LOCAL -> stringResource(R.string.sync_placement_local)
FileSyncPlacement.CLOUD -> stringResource(R.string.sync_placement_cloud)
FileSyncPlacement.LOCAL_CLOUD -> stringResource(R.string.sync_placement_local_cloud)
} }
/** Statut de sync d'un fichier — présence device / serveur distant. */ /** Statut de sync d'un fichier — présence device / serveur distant. */
@@ -53,8 +65,8 @@ fun FileSyncStatusIcon(
val placement = file.syncPlacement() val placement = file.syncPlacement()
Icon( Icon(
imageVector = placement.icon, imageVector = placement.icon,
contentDescription = null, contentDescription = placement.label(),
tint = placement.color, tint = placement.color(),
modifier = modifier.size(size), modifier = modifier.size(size),
) )
} }
@@ -2,7 +2,6 @@ package com.kazier.mobile.ui.components
import android.content.Context import android.content.Context
import androidx.compose.foundation.layout.size import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.runtime.Composable import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue import androidx.compose.runtime.getValue
import androidx.compose.runtime.produceState import androidx.compose.runtime.produceState
@@ -13,12 +12,12 @@ import androidx.compose.ui.graphics.Shape
import androidx.compose.ui.layout.ContentScale import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.platform.LocalContext import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.unit.Dp import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import coil.compose.AsyncImage import coil.compose.AsyncImage
import coil.request.ImageRequest import coil.request.ImageRequest
import com.kazier.mobile.data.local.entity.FileEntity import com.kazier.mobile.data.local.entity.FileEntity
import com.kazier.mobile.domain.FileCategory import com.kazier.mobile.domain.FileCategory
import com.kazier.mobile.features.thumbnails.ThumbnailStore import com.kazier.mobile.features.thumbnails.ThumbnailStore
import com.kazier.mobile.ui.theme.ThumbShape
import dagger.hilt.EntryPoint import dagger.hilt.EntryPoint
import dagger.hilt.InstallIn import dagger.hilt.InstallIn
import dagger.hilt.android.EntryPointAccessors import dagger.hilt.android.EntryPointAccessors
@@ -41,7 +40,7 @@ fun FileThumbnail(
file: FileEntity, file: FileEntity,
size: Dp, size: Dp,
modifier: Modifier = Modifier, modifier: Modifier = Modifier,
shape: Shape = RoundedCornerShape(8.dp), shape: Shape = ThumbShape,
) { ) {
val category = file.categoryValue() val category = file.categoryValue()
if (category != FileCategory.IMAGE && category != FileCategory.PDF) { if (category != FileCategory.IMAGE && category != FileCategory.PDF) {
@@ -8,7 +8,7 @@ import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource import androidx.compose.ui.res.stringResource
@@ -20,7 +20,7 @@ fun FolderNameDialog(
onDismiss: () -> Unit, onDismiss: () -> Unit,
onConfirm: (String) -> Unit, onConfirm: (String) -> Unit,
) { ) {
var name by remember { mutableStateOf("") } var name by rememberSaveable { mutableStateOf("") }
AlertDialog( AlertDialog(
onDismissRequest = onDismiss, onDismissRequest = onDismiss,
title = { Text(stringResource(R.string.new_folder_name_title)) }, title = { Text(stringResource(R.string.new_folder_name_title)) },
@@ -0,0 +1,36 @@
package com.kazier.mobile.ui.components
import androidx.compose.runtime.Composable
import androidx.compose.ui.res.stringResource
import com.kazier.mobile.R
import java.util.Locale
/**
* Formattage de taille centralisé (Phase 0) : remplace les 5 copies
* (`FolderList`, `FolderDetail`, `Search`, `Document`, `SwipeCardDeck`,
* `PdfBuilder`) dont 2 en français en dur (`o/ko/Mo`).
* Utilise les strings i18n `unit_bytes / unit_kilobytes / unit_megabytes`.
*/
@Composable
fun formatFileSize(bytes: Long): String {
val safe = bytes.coerceAtLeast(0)
if (safe < 1_024) {
return "$safe ${stringResource(R.string.unit_bytes)}"
}
if (safe < 1_024 * 1_024) {
val kb = safe / 1_024f
return String.format(
Locale.getDefault(),
"%.1f %s",
kb,
stringResource(R.string.unit_kilobytes),
)
}
val mb = safe / (1_024f * 1_024f)
return String.format(
Locale.getDefault(),
"%.1f %s",
mb,
stringResource(R.string.unit_megabytes),
)
}
@@ -0,0 +1,331 @@
package com.kazier.mobile.ui.components
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.ModalBottomSheet
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.material3.rememberModalBottomSheetState
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
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.draw.clip
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.semantics.Role
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import com.kazier.mobile.R
import com.kazier.mobile.features.connection.ConnectionStatusViewModel
import com.kazier.mobile.features.connection.ServerConnectionStatus
import com.kazier.mobile.features.sync.SyncViewModel
import com.kazier.mobile.ui.theme.PendingDark
import com.kazier.mobile.ui.theme.PendingLight
import com.kazier.mobile.ui.theme.PillShape
import com.kazier.mobile.ui.theme.SuccessDark
import com.kazier.mobile.ui.theme.SuccessLight
import com.kazier.mobile.ui.theme.SyncingDark
import com.kazier.mobile.ui.theme.SyncingLight
/**
* Pastille de statut unique du header : un point coloré (ou spinner pendant
* une synchro) + un libellé. Un appui ouvre le bottom-sheet « état » :
* statut serveur, bouton de test, résumé de la file d'envoi et accès à son
* détail.
*
* En mode local il n'y a rien à pousser : la pastille affiche « Mode local »
* et le sheet l'explique sans proposer de test (le tap-à-vérifier serait
* une impasse).
*/
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun HeaderStatusAction(
syncViewModel: SyncViewModel,
connectionStatusViewModel: ConnectionStatusViewModel,
modifier: Modifier = Modifier,
) {
val connectionStatus by connectionStatusViewModel.status.collectAsStateWithLifecycle()
val syncStatus by syncViewModel.syncStatus.collectAsStateWithLifecycle()
var showSheet by rememberSaveable { mutableStateOf(false) }
var showQueue by rememberSaveable { mutableStateOf(false) }
val isLocal = connectionStatus == ServerConnectionStatus.Local
val dark = isSystemInDarkTheme()
val onlineGreen = if (dark) SuccessDark else SuccessLight
val pendingAmber = if (dark) PendingDark else PendingLight
val syncingAccent = if (dark) SyncingDark else SyncingLight
val (dotColor, label, showSpinner) = when {
isLocal -> Triple(
MaterialTheme.colorScheme.onSurfaceVariant,
stringResource(R.string.status_local),
false,
)
connectionStatus == ServerConnectionStatus.Checking -> Triple(
pendingAmber,
stringResource(R.string.status_checking),
false,
)
syncStatus.syncing -> Triple(
syncingAccent,
stringResource(R.string.sync_syncing),
true,
)
syncStatus.pending > 0 -> {
val text = if (syncStatus.pending == 1) {
stringResource(R.string.sync_pending_count_one)
} else {
stringResource(R.string.sync_pending_count, syncStatus.pending)
}
val color = if (connectionStatus == ServerConnectionStatus.Offline) {
MaterialTheme.colorScheme.error
} else {
pendingAmber
}
Triple(color, text, false)
}
syncStatus.failed > 0 -> Triple(
MaterialTheme.colorScheme.error,
stringResource(R.string.sync_summary_failed, syncStatus.failed),
false,
)
connectionStatus == ServerConnectionStatus.Offline -> Triple(
MaterialTheme.colorScheme.error,
stringResource(R.string.status_offline),
false,
)
else -> Triple(
onlineGreen,
stringResource(R.string.status_online),
false,
)
}
val tapLabel = stringResource(R.string.sync_tap_to_view)
Row(
modifier = modifier
.clip(PillShape)
.clickable(
role = Role.Button,
onClickLabel = tapLabel,
onClick = { showSheet = true },
)
.padding(horizontal = 10.dp, vertical = 4.dp),
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(6.dp),
) {
if (showSpinner) {
CircularProgressIndicator(
modifier = Modifier.size(12.dp),
strokeWidth = 2.dp,
color = dotColor,
)
} else {
Box(
modifier = Modifier
.size(8.dp)
.background(dotColor, CircleShape),
)
}
Text(
text = label,
style = MaterialTheme.typography.labelMedium,
fontWeight = FontWeight.Medium,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
if (showSheet) {
ModalBottomSheet(
onDismissRequest = { showSheet = false },
sheetState = rememberModalBottomSheetState(),
) {
StatusSheetContent(
connectionStatus = connectionStatus,
syncStatus = syncStatus,
onTest = connectionStatusViewModel::checkNow,
onViewQueue = {
showSheet = false
showQueue = true
},
onDismiss = { showSheet = false },
)
}
}
if (showQueue) {
SyncOperationsDialog(
status = syncStatus,
onDismiss = { showQueue = false },
)
}
}
@Composable
private fun StatusSheetContent(
connectionStatus: ServerConnectionStatus,
syncStatus: SyncViewModel.SyncStatus,
onTest: () -> Unit,
onViewQueue: () -> Unit,
onDismiss: () -> Unit,
) {
val isLocal = connectionStatus == ServerConnectionStatus.Local
Column(
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 24.dp)
.padding(bottom = 32.dp),
verticalArrangement = Arrangement.spacedBy(16.dp),
) {
Text(
text = stringResource(R.string.status_sheet_title),
style = MaterialTheme.typography.titleLarge,
fontWeight = FontWeight.SemiBold,
)
StatusServerRow(
status = connectionStatus,
onTest = onTest,
)
if (isLocal) {
Text(
text = stringResource(R.string.skip_message),
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
} else {
HorizontalDivider()
StatusSyncSection(
status = syncStatus,
onViewQueue = onViewQueue,
)
}
TextButton(
onClick = onDismiss,
modifier = Modifier.align(Alignment.End),
) {
Text(stringResource(R.string.settings_close))
}
}
}
@Composable
private fun StatusServerRow(
status: ServerConnectionStatus,
onTest: () -> Unit,
) {
val dark = isSystemInDarkTheme()
val dotColor = when (status) {
ServerConnectionStatus.Checking -> if (dark) PendingDark else PendingLight
ServerConnectionStatus.Online -> if (dark) SuccessDark else SuccessLight
ServerConnectionStatus.Offline -> MaterialTheme.colorScheme.error
ServerConnectionStatus.Local -> MaterialTheme.colorScheme.onSurfaceVariant
}
val label = stringResource(
when (status) {
ServerConnectionStatus.Checking -> R.string.status_checking
ServerConnectionStatus.Online -> R.string.status_online
ServerConnectionStatus.Offline -> R.string.status_offline
ServerConnectionStatus.Local -> R.string.status_local
},
)
Row(
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(12.dp),
) {
Box(
modifier = Modifier
.size(12.dp)
.background(dotColor, CircleShape),
)
Column(modifier = Modifier.weight(1f)) {
Text(
text = stringResource(R.string.settings_server),
style = MaterialTheme.typography.labelMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
Text(
text = label,
style = MaterialTheme.typography.bodyLarge,
fontWeight = FontWeight.Medium,
)
}
if (status != ServerConnectionStatus.Local) {
OutlinedButton(
onClick = onTest,
enabled = status != ServerConnectionStatus.Checking,
) {
Text(stringResource(R.string.settings_test_connection))
}
}
}
}
@Composable
private fun StatusSyncSection(
status: SyncViewModel.SyncStatus,
onViewQueue: () -> Unit,
) {
Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
Text(
text = stringResource(R.string.dashboard_sync_title),
style = MaterialTheme.typography.labelMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
when {
status.syncing -> {
Text(
text = stringResource(R.string.sync_syncing),
style = MaterialTheme.typography.bodyLarge,
fontWeight = FontWeight.Medium,
)
}
status.pending > 0 -> {
Text(
text = if (status.pending == 1) {
stringResource(R.string.sync_pending_count_one)
} else {
stringResource(R.string.sync_pending_count, status.pending)
},
style = MaterialTheme.typography.bodyLarge,
fontWeight = FontWeight.Medium,
)
}
status.failed > 0 -> {
Text(
text = stringResource(R.string.sync_summary_failed, status.failed),
style = MaterialTheme.typography.bodyLarge,
fontWeight = FontWeight.Medium,
color = MaterialTheme.colorScheme.error,
)
}
else -> {
Text(
text = stringResource(R.string.sync_idle),
style = MaterialTheme.typography.bodyLarge,
fontWeight = FontWeight.Medium,
)
}
}
OutlinedButton(onClick = onViewQueue) {
Text(stringResource(R.string.status_sheet_view_queue))
}
}
}
@@ -0,0 +1,39 @@
package com.kazier.mobile.ui.components
import androidx.compose.foundation.BorderStroke
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.MaterialTheme
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import com.kazier.mobile.ui.theme.KazierDimens
import com.kazier.mobile.ui.theme.ListCardShape
/**
* Carte de liste unifiée (Phase 0) : remplace les 3 recettes dispersées
* (`surfaceVariant+elev 1dp`, `surface+elev 1dp`, `#F7F8FA + border #EAEAEA`).
* Couleurs 100% thème → lisible en dark mode.
*
* Le clic (simple ou combiné long) se gère via `modifier` pour préserver
* les `combinedClickable` de sélection — pas de `onClick` M3 ici.
*/
@Composable
fun KazierCard(
modifier: Modifier = Modifier,
content: @Composable () -> Unit,
) {
Card(
modifier = modifier,
shape = ListCardShape,
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.surfaceVariant,
contentColor = MaterialTheme.colorScheme.onSurfaceVariant,
),
border = BorderStroke(
KazierDimens.CardBorderWidth,
MaterialTheme.colorScheme.outlineVariant,
),
elevation = CardDefaults.cardElevation(defaultElevation = KazierDimens.CardElevation),
content = { content() },
)
}
@@ -0,0 +1,63 @@
package com.kazier.mobile.ui.components
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.padding
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.KeyboardArrowRight
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.semantics.Role
import androidx.compose.ui.unit.dp
import com.kazier.mobile.R
/**
* CTA « documents à traiter » partagé (dashboard + écran Fichiers) : la
* file review reste joignable même sans passer par le dashboard.
*/
@Composable
fun ReviewCtaCard(
count: Int,
onClick: () -> Unit,
modifier: Modifier = Modifier,
) {
val label = stringResource(R.string.dashboard_review_title, count)
KazierCard(
modifier = modifier.clickable(
role = Role.Button,
onClickLabel = label,
onClick = onClick,
),
) {
Row(
modifier = Modifier.padding(20.dp),
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(16.dp),
) {
Column(modifier = Modifier.weight(1f)) {
Text(
text = label,
style = MaterialTheme.typography.titleMedium,
)
Text(
text = stringResource(R.string.dashboard_review_hint),
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant,
modifier = Modifier.padding(top = 4.dp),
)
}
Icon(
imageVector = Icons.AutoMirrored.Filled.KeyboardArrowRight,
contentDescription = null,
tint = MaterialTheme.colorScheme.primary,
)
}
}
}
@@ -13,7 +13,11 @@ import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.semantics.selected
import androidx.compose.ui.semantics.semantics
import androidx.compose.ui.unit.dp import androidx.compose.ui.unit.dp
import com.kazier.mobile.R
/** /**
* État du mode multi-sélection (long-press pour entrer, tap pour cocher). * État du mode multi-sélection (long-press pour entrer, tap pour cocher).
@@ -50,12 +54,16 @@ fun rememberSelectionState(): SelectionState = remember { SelectionState() }
fun SelectionStatusIcon(selected: Boolean, modifier: Modifier = Modifier) { fun SelectionStatusIcon(selected: Boolean, modifier: Modifier = Modifier) {
Icon( Icon(
imageVector = if (selected) Icons.Filled.CheckCircle else Icons.Filled.RadioButtonUnchecked, imageVector = if (selected) Icons.Filled.CheckCircle else Icons.Filled.RadioButtonUnchecked,
contentDescription = null, contentDescription = stringResource(
if (selected) R.string.selection_selected else R.string.selection_unselected,
),
tint = if (selected) { tint = if (selected) {
MaterialTheme.colorScheme.primary MaterialTheme.colorScheme.primary
} else { } else {
MaterialTheme.colorScheme.onSurfaceVariant MaterialTheme.colorScheme.onSurfaceVariant
}, },
modifier = modifier.size(24.dp), modifier = modifier
.size(24.dp)
.semantics { this.selected = selected },
) )
} }
@@ -1,74 +0,0 @@
package com.kazier.mobile.ui.components
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.semantics.Role
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import com.kazier.mobile.R
import com.kazier.mobile.features.connection.ServerConnectionStatus
import com.kazier.mobile.ui.theme.InactiveGray
private val OnlineGreen = Color(0xFF2E7D32)
private val CheckingAmber = Color(0xFFF9A825)
/**
* Pilule de statut serveur affichée dans le header : cercle coloré + libellé.
* Un appui relance une vérification immédiate du serveur.
*/
@Composable
fun ServerStatusBadge(
status: ServerConnectionStatus,
onClick: () -> Unit,
modifier: Modifier = Modifier,
) {
val (dotColor, labelRes) = when (status) {
ServerConnectionStatus.Checking -> CheckingAmber to R.string.status_checking
ServerConnectionStatus.Online -> OnlineGreen to R.string.status_online
ServerConnectionStatus.Offline -> MaterialTheme.colorScheme.error to R.string.status_offline
ServerConnectionStatus.Local -> InactiveGray to R.string.status_local
}
val label = stringResource(labelRes)
val tapLabel = stringResource(R.string.status_tap_to_recheck)
val shape = RoundedCornerShape(percent = 50)
Row(
modifier = modifier
.clip(shape)
.clickable(
role = Role.Button,
onClickLabel = tapLabel,
onClick = onClick,
)
.padding(horizontal = 10.dp, vertical = 4.dp),
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(6.dp),
) {
Box(
modifier = Modifier
.size(8.dp)
.background(dotColor, CircleShape),
)
Text(
text = label,
style = MaterialTheme.typography.labelMedium,
fontWeight = FontWeight.Medium,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
}
@@ -2,6 +2,7 @@ package com.kazier.mobile.ui.components
import android.text.format.DateUtils import android.text.format.DateUtils
import androidx.compose.foundation.background import androidx.compose.foundation.background
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.Column
@@ -20,7 +21,6 @@ import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.stringResource import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp import androidx.compose.ui.unit.dp
@@ -28,10 +28,13 @@ import com.kazier.mobile.R
import com.kazier.mobile.data.local.entity.PendingOpStatus import com.kazier.mobile.data.local.entity.PendingOpStatus
import com.kazier.mobile.data.local.entity.PendingOperationEntity import com.kazier.mobile.data.local.entity.PendingOperationEntity
import com.kazier.mobile.features.sync.SyncViewModel import com.kazier.mobile.features.sync.SyncViewModel
import com.kazier.mobile.ui.theme.ErrorDark
private val StatusPending = Color(0xFF1E88E5) import com.kazier.mobile.ui.theme.ErrorLight
private val StatusSynced = Color(0xFF2E7D32) import com.kazier.mobile.ui.theme.KazierDimens
private val StatusFailed = Color(0xFFC62828) import com.kazier.mobile.ui.theme.SuccessDark
import com.kazier.mobile.ui.theme.SuccessLight
import com.kazier.mobile.ui.theme.SyncingDark
import com.kazier.mobile.ui.theme.SyncingLight
/** /**
* Dialogue « liste des sync » : dernières opérations de l'outbox (tous statuts), * Dialogue « liste des sync » : dernières opérations de l'outbox (tous statuts),
@@ -58,7 +61,7 @@ internal fun SyncOperationsDialog(
LazyColumn( LazyColumn(
modifier = Modifier modifier = Modifier
.fillMaxWidth() .fillMaxWidth()
.heightIn(max = 360.dp), .heightIn(max = KazierDimens.DialogListMaxHeight),
verticalArrangement = Arrangement.spacedBy(2.dp), verticalArrangement = Arrangement.spacedBy(2.dp),
) { ) {
items(status.operations, key = { it.id }) { op -> items(status.operations, key = { it.id }) { op ->
@@ -99,10 +102,11 @@ private fun SyncListSummary(status: SyncViewModel.SyncStatus) {
@Composable @Composable
private fun SyncOperationRow(op: PendingOperationEntity) { private fun SyncOperationRow(op: PendingOperationEntity) {
val dark = isSystemInDarkTheme()
val (dotColor, statusLabel) = when (op.status) { val (dotColor, statusLabel) = when (op.status) {
PendingOpStatus.PENDING -> StatusPending to stringResource(R.string.sync_status_pending) PendingOpStatus.PENDING -> (if (dark) SyncingDark else SyncingLight) to stringResource(R.string.sync_status_pending)
PendingOpStatus.SYNCED -> StatusSynced to stringResource(R.string.sync_status_synced) PendingOpStatus.SYNCED -> (if (dark) SuccessDark else SuccessLight) to stringResource(R.string.sync_status_synced)
else -> StatusFailed to stringResource(R.string.sync_status_failed) else -> (if (dark) ErrorDark else ErrorLight) to stringResource(R.string.sync_status_failed)
} }
val opLabel = operationLabel(op.operation) val opLabel = operationLabel(op.operation)
val time = DateUtils.getRelativeTimeSpanString(op.createdAt).toString() val time = DateUtils.getRelativeTimeSpanString(op.createdAt).toString()
@@ -1,143 +0,0 @@
package com.kazier.mobile.ui.components
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Check
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.semantics.Role
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import com.kazier.mobile.R
import com.kazier.mobile.features.sync.SyncViewModel
private val SyncingAccent = Color(0xFF1E88E5)
private val PendingAmber = Color(0xFFF9A825)
/**
* Pilule de statut de synchro affichée dans le header : spinner quand une marche
* SAF ou un drain outbox est en cours, compteur d'ops en attente sinon, coche
* quand tout est poussé. Un appui ouvre la « liste des sync » (dernières ops).
*/
@Composable
fun SyncStatusBadge(
status: SyncViewModel.SyncStatus,
onClick: () -> Unit,
modifier: Modifier = Modifier,
) {
val (accent, label, showSpinner) = when {
status.syncing -> {
Triple(SyncingAccent, stringResource(R.string.sync_syncing), true)
}
status.pending > 0 -> {
val label = if (status.pending == 1) {
stringResource(R.string.sync_pending_count_one)
} else {
stringResource(R.string.sync_pending_count, status.pending)
}
Triple(PendingAmber, label, false)
}
else -> Triple(
MaterialTheme.colorScheme.primary,
stringResource(R.string.sync_idle),
false,
)
}
val shape = RoundedCornerShape(percent = 50)
val tapLabel = stringResource(R.string.sync_tap_to_view)
Row(
modifier = modifier
.clip(shape)
.clickable(
role = Role.Button,
onClickLabel = tapLabel,
onClick = onClick,
)
.padding(horizontal = 10.dp, vertical = 4.dp),
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(6.dp),
) {
if (showSpinner) {
CircularProgressIndicator(
modifier = Modifier.size(12.dp),
strokeWidth = 2.dp,
color = accent,
)
} else if (status.pending > 0) {
Box(
modifier = Modifier
.size(14.dp)
.background(accent, CircleShape),
contentAlignment = Alignment.Center,
) {
Text(
text = status.pending.coerceAtMost(99).toString(),
style = MaterialTheme.typography.labelSmall,
color = Color.White,
fontWeight = FontWeight.Bold,
)
}
} else {
Icon(
imageVector = Icons.Filled.Check,
contentDescription = null,
modifier = Modifier.size(12.dp),
tint = accent,
)
}
Text(
text = label,
style = MaterialTheme.typography.labelMedium,
fontWeight = FontWeight.Medium,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
}
/**
* Composable prêt-à-poser dans un header : badge + dialogue « liste des sync ».
* Le dialogue est géré localement (état `showList`), aucun wiring externe.
*/
@Composable
fun SyncStatusAction(
syncViewModel: SyncViewModel,
modifier: Modifier = Modifier,
) {
val status by syncViewModel.syncStatus.collectAsStateWithLifecycle()
var showList by remember { mutableStateOf(false) }
SyncStatusBadge(
status = status,
onClick = { showList = true },
modifier = modifier,
)
if (showList) {
SyncOperationsDialog(
status = status,
onDismiss = { showList = false },
)
}
}
@@ -0,0 +1,63 @@
package com.kazier.mobile.ui.components
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.heightIn
import androidx.compose.foundation.layout.size
import androidx.compose.material3.Button
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import com.kazier.mobile.ui.theme.KazierDimens
/**
* Bouton d'action vertical (icône + libellé `labelSmall` ellipsé) : tient
* sur 360dp là où des boutons horizontaux icône+texte seraient tronqués
* (exports du scan, ajouts du PdfBuilder).
*/
@Composable
fun VerticalActionButton(
icon: ImageVector,
label: String,
onClick: () -> Unit,
modifier: Modifier = Modifier,
enabled: Boolean = true,
outlined: Boolean = true,
) {
val content: @Composable () -> Unit = {
Column(horizontalAlignment = Alignment.CenterHorizontally) {
Icon(
imageVector = icon,
contentDescription = null,
modifier = Modifier.size(20.dp),
)
Text(
text = label,
style = MaterialTheme.typography.labelSmall,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
)
}
}
if (outlined) {
OutlinedButton(
onClick = onClick,
enabled = enabled,
modifier = modifier.heightIn(min = KazierDimens.MinTouchTarget),
content = { content() },
)
} else {
Button(
onClick = onClick,
enabled = enabled,
modifier = modifier.heightIn(min = KazierDimens.MinTouchTarget),
content = { content() },
)
}
}
@@ -5,7 +5,6 @@ import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Visibility import androidx.compose.material.icons.filled.Visibility
import androidx.compose.material3.Icon import androidx.compose.material3.Icon
@@ -23,6 +22,7 @@ import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.lifecycle.compose.collectAsStateWithLifecycle
import com.kazier.mobile.R import com.kazier.mobile.R
import com.kazier.mobile.ui.theme.PillShape
import com.kazier.mobile.ui.watchedfolders.WatchedFoldersViewModel import com.kazier.mobile.ui.watchedfolders.WatchedFoldersViewModel
/** Seuil au-delà duquel le badge affiche « 99+ » au lieu du compte exact. */ /** Seuil au-delà duquel le badge affiche « 99+ » au lieu du compte exact. */
@@ -47,7 +47,7 @@ fun WatchedFoldersBadge(
Row( Row(
modifier = Modifier modifier = Modifier
.clip(RoundedCornerShape(percent = 50)) .clip(PillShape)
.clickable( .clickable(
role = Role.Button, role = Role.Button,
onClickLabel = contentDescription, onClickLabel = contentDescription,
@@ -9,20 +9,27 @@ import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size import androidx.compose.foundation.layout.size
import androidx.compose.material.icons.Icons import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.KeyboardArrowRight
import androidx.compose.material.icons.filled.CheckCircle import androidx.compose.material.icons.filled.CheckCircle
import androidx.compose.material.icons.filled.DocumentScanner import androidx.compose.material.icons.filled.DocumentScanner
import androidx.compose.material3.Card import androidx.compose.material.icons.filled.Sync
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.ExperimentalMaterial3Api import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.FloatingActionButton
import androidx.compose.material3.Icon import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold import androidx.compose.material3.Scaffold
import androidx.compose.material3.SmallFloatingActionButton import androidx.compose.material3.SmallFloatingActionButton
import androidx.compose.material3.Text import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar import androidx.compose.material3.TopAppBar
import androidx.compose.material3.pulltorefresh.PullToRefreshDefaults
import androidx.compose.material3.pulltorefresh.pullToRefresh
import androidx.compose.material3.pulltorefresh.rememberPullToRefreshState
import androidx.compose.runtime.Composable import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue 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.Alignment
import androidx.compose.ui.Modifier import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource import androidx.compose.ui.res.stringResource
@@ -32,9 +39,11 @@ import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.lifecycle.compose.collectAsStateWithLifecycle
import com.kazier.mobile.R import com.kazier.mobile.R
import com.kazier.mobile.features.connection.ConnectionStatusViewModel import com.kazier.mobile.features.connection.ConnectionStatusViewModel
import com.kazier.mobile.features.connection.ServerConnectionStatus
import com.kazier.mobile.features.sync.SyncViewModel import com.kazier.mobile.features.sync.SyncViewModel
import com.kazier.mobile.ui.components.ServerStatusBadge import com.kazier.mobile.ui.components.HeaderStatusAction
import com.kazier.mobile.ui.components.SyncStatusAction import com.kazier.mobile.ui.components.KazierCard
import com.kazier.mobile.ui.components.ReviewCtaCard
import com.kazier.mobile.ui.navigation.FloatingNavBar import com.kazier.mobile.ui.navigation.FloatingNavBar
import com.kazier.mobile.ui.navigation.NavTab import com.kazier.mobile.ui.navigation.NavTab
@@ -51,16 +60,27 @@ fun DashboardScreen(
) { ) {
val connectionStatus by connectionStatusViewModel.status.collectAsStateWithLifecycle() val connectionStatus by connectionStatusViewModel.status.collectAsStateWithLifecycle()
val unprocessed by viewModel.unprocessedCount.collectAsStateWithLifecycle() val unprocessed by viewModel.unprocessedCount.collectAsStateWithLifecycle()
val syncStatus by syncViewModel.syncStatus.collectAsStateWithLifecycle()
// Mode local : rien n'est poussé vers le serveur, la carte sync est inutile.
val isLocal = connectionStatus == ServerConnectionStatus.Local
val showSyncCard = !isLocal && (syncStatus.syncing || syncStatus.pending > 0 || syncStatus.failed > 0)
// Tirer-pour-actualiser = revérifier le serveur (review + file sont déjà
// temps réel via les flows, il n'y a rien d'autre à recharger ici).
var userRefresh by rememberSaveable { mutableStateOf(false) }
val isRefreshing = userRefresh && connectionStatus == ServerConnectionStatus.Checking
LaunchedEffect(connectionStatus) {
if (connectionStatus != ServerConnectionStatus.Checking) userRefresh = false
}
Scaffold( Scaffold(
topBar = { topBar = {
TopAppBar( TopAppBar(
title = { Text(stringResource(R.string.dashboard)) }, title = { Text(stringResource(R.string.dashboard)) },
actions = { actions = {
SyncStatusAction(syncViewModel = syncViewModel) HeaderStatusAction(
ServerStatusBadge( syncViewModel = syncViewModel,
status = connectionStatus, connectionStatusViewModel = connectionStatusViewModel,
onClick = connectionStatusViewModel::checkNow,
) )
}, },
) )
@@ -81,20 +101,43 @@ fun DashboardScreen(
} }
}, },
) { padding -> ) { padding ->
Column( val pullState = rememberPullToRefreshState()
Box(
modifier = Modifier modifier = Modifier
.fillMaxSize() .fillMaxSize()
.padding(padding) .padding(padding)
.pullToRefresh(
state = pullState,
// Mode local : rien à revérifier — geste désactivé, sinon
// l'indicateur resterait coincé (jamais de cycle vrai→faux).
enabled = !isLocal,
isRefreshing = isRefreshing,
onRefresh = {
userRefresh = true
connectionStatusViewModel.checkNow()
},
),
) {
Column(
modifier = Modifier
.fillMaxSize()
.padding(16.dp), .padding(16.dp),
verticalArrangement = Arrangement.spacedBy(16.dp), verticalArrangement = Arrangement.spacedBy(16.dp),
) { ) {
if (unprocessed > 0) { if (unprocessed > 0) {
ReviewCard( ReviewCtaCard(
count = unprocessed, count = unprocessed,
onClick = onOpenReview, onClick = onOpenReview,
modifier = Modifier.fillMaxWidth(), modifier = Modifier.fillMaxWidth(),
) )
} else { }
if (showSyncCard) {
SyncSummaryCard(
status = syncStatus,
modifier = Modifier.fillMaxWidth(),
)
}
if (unprocessed == 0 && !showSyncCard) {
Box( Box(
modifier = Modifier modifier = Modifier
.fillMaxSize() .fillMaxSize()
@@ -119,38 +162,70 @@ fun DashboardScreen(
} }
} }
} }
PullToRefreshDefaults.Indicator(
state = pullState,
isRefreshing = isRefreshing,
modifier = Modifier.align(Alignment.TopCenter),
)
}
} }
} }
/**
* Résumé de la file de synchro (état déjà exposé par [SyncViewModel]) :
* marche en cours, opérations en attente, échecs — sans nouveau ViewModel.
*/
@Composable @Composable
private fun ReviewCard( private fun SyncSummaryCard(
count: Int, status: SyncViewModel.SyncStatus,
onClick: () -> Unit,
modifier: Modifier = Modifier, modifier: Modifier = Modifier,
) { ) {
Card(onClick = onClick, modifier = modifier) { KazierCard(modifier = modifier) {
Row( Row(
modifier = Modifier.padding(20.dp), modifier = Modifier.padding(20.dp),
verticalAlignment = Alignment.CenterVertically, verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(16.dp), horizontalArrangement = Arrangement.spacedBy(16.dp),
) { ) {
if (status.syncing) {
CircularProgressIndicator(modifier = Modifier.size(28.dp))
} else {
Icon(
imageVector = Icons.Filled.Sync,
contentDescription = null,
tint = MaterialTheme.colorScheme.primary,
modifier = Modifier.size(28.dp),
)
}
Column(modifier = Modifier.weight(1f)) { Column(modifier = Modifier.weight(1f)) {
Text( Text(
text = stringResource(R.string.dashboard_review_title, count), text = stringResource(R.string.dashboard_sync_title),
style = MaterialTheme.typography.titleMedium, style = MaterialTheme.typography.titleMedium,
) )
if (status.syncing) {
Text( Text(
text = stringResource(R.string.dashboard_review_hint), text = stringResource(R.string.sync_syncing),
style = MaterialTheme.typography.bodyMedium, style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant, color = MaterialTheme.colorScheme.onSurfaceVariant,
modifier = Modifier.padding(top = 4.dp), modifier = Modifier.padding(top = 4.dp),
) )
} }
Icon( if (status.pending > 0) {
imageVector = Icons.AutoMirrored.Filled.KeyboardArrowRight, Text(
contentDescription = null, text = stringResource(R.string.sync_pending_count, status.pending),
tint = MaterialTheme.colorScheme.primary, style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant,
modifier = Modifier.padding(top = 4.dp),
)
}
if (status.failed > 0) {
Text(
text = stringResource(R.string.sync_summary_failed, status.failed),
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.error,
modifier = Modifier.padding(top = 4.dp),
) )
} }
} }
} }
}
}
@@ -18,7 +18,6 @@ import androidx.compose.foundation.pager.HorizontalPager
import androidx.compose.foundation.pager.rememberPagerState import androidx.compose.foundation.pager.rememberPagerState
import androidx.compose.foundation.rememberScrollState import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.shape.CircleShape import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.selection.SelectionContainer import androidx.compose.foundation.text.selection.SelectionContainer
import androidx.compose.foundation.verticalScroll import androidx.compose.foundation.verticalScroll
import androidx.compose.material.icons.Icons import androidx.compose.material.icons.Icons
@@ -29,12 +28,12 @@ import androidx.compose.material.icons.filled.Close
import androidx.compose.material.icons.filled.Delete import androidx.compose.material.icons.filled.Delete
import androidx.compose.material.icons.filled.DocumentScanner import androidx.compose.material.icons.filled.DocumentScanner
import androidx.compose.material3.AlertDialog import androidx.compose.material3.AlertDialog
import androidx.compose.material3.Card import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.CircularProgressIndicator import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.DropdownMenu import androidx.compose.material3.DropdownMenu
import androidx.compose.material3.DropdownMenuItem import androidx.compose.material3.DropdownMenuItem
import androidx.compose.material3.ExperimentalMaterial3Api import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.FilledTonalButton
import androidx.compose.material3.FloatingActionButton import androidx.compose.material3.FloatingActionButton
import androidx.compose.material3.Icon import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton import androidx.compose.material3.IconButton
@@ -70,7 +69,6 @@ import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextOverflow import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.core.view.WindowCompat import androidx.core.view.WindowCompat
import androidx.core.view.WindowInsetsCompat import androidx.core.view.WindowInsetsCompat
import androidx.core.view.WindowInsetsControllerCompat import androidx.core.view.WindowInsetsControllerCompat
@@ -86,14 +84,17 @@ import com.kazier.mobile.features.ocr.OcrViewModel
import com.kazier.mobile.features.saf.FileDeleter import com.kazier.mobile.features.saf.FileDeleter
import com.kazier.mobile.features.sync.SyncViewModel import com.kazier.mobile.features.sync.SyncViewModel
import com.kazier.mobile.ui.components.DeleteConfirmDialog import com.kazier.mobile.ui.components.DeleteConfirmDialog
import com.kazier.mobile.ui.components.ServerStatusBadge import com.kazier.mobile.ui.components.HeaderStatusAction
import com.kazier.mobile.ui.components.SyncStatusAction import com.kazier.mobile.ui.components.KazierCard
import com.kazier.mobile.ui.components.categoryValue import com.kazier.mobile.ui.components.categoryValue
import com.kazier.mobile.ui.components.formatFileSize
import com.kazier.mobile.ui.document.content.DocumentContentViewer import com.kazier.mobile.ui.document.content.DocumentContentViewer
import com.kazier.mobile.ui.document.content.ImageViewer import com.kazier.mobile.ui.document.content.ImageViewer
import com.kazier.mobile.ui.document.content.PdfFocusViewer import com.kazier.mobile.ui.document.content.PdfFocusViewer
import com.kazier.mobile.ui.document.content.TextFocusViewer import com.kazier.mobile.ui.document.content.TextFocusViewer
import com.kazier.mobile.ui.document.content.ZoomableContent import com.kazier.mobile.ui.document.content.ZoomableContent
import com.kazier.mobile.ui.theme.PillShape
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch import kotlinx.coroutines.launch
import java.time.Instant import java.time.Instant
import java.time.ZoneId import java.time.ZoneId
@@ -123,23 +124,40 @@ fun DocumentViewerScreen(
val documents by viewModel.documents.collectAsStateWithLifecycle() val documents by viewModel.documents.collectAsStateWithLifecycle()
val viewerState by viewModel.uiState.collectAsStateWithLifecycle() val viewerState by viewModel.uiState.collectAsStateWithLifecycle()
val ocrState by ocrViewModel.uiState.collectAsStateWithLifecycle() val ocrState by ocrViewModel.uiState.collectAsStateWithLifecycle()
val connectionStatus by connectionStatusViewModel.status.collectAsStateWithLifecycle()
val pagerState = rememberPagerState(pageCount = { documents.size }) val pagerState = rememberPagerState(pageCount = { documents.size })
// Démarre une seule fois sur le document demandé, dès que la liste est chargée. // M30 : survit à la rotation (`rememberSaveable`) — `savedPage` mémorise
var jumpPending by remember { mutableStateOf(true) } // l'index courant pour y revenir au lieu de retomber sur le document initial.
var jumpPending by rememberSaveable { mutableStateOf(true) }
var savedPage by rememberSaveable { mutableIntStateOf(-1) }
// Vrai dès qu'une liste non vide a été vue dans cette composition : garde
// contre un `onBack` intempestif pendant le (re)chargement initial.
var hadDocuments by remember { mutableStateOf(false) }
LaunchedEffect(documents) { LaunchedEffect(documents) {
if (documents.isNotEmpty()) hadDocuments = true
if (jumpPending) { if (jumpPending) {
// Démarre une seule fois sur le document demandé, dès que la liste est chargée.
val index = documents.indexOfFirst { it.resourceId == initialResourceId } val index = documents.indexOfFirst { it.resourceId == initialResourceId }
if (index >= 0) { if (index >= 0) {
pagerState.scrollToPage(index) pagerState.scrollToPage(index)
savedPage = index
jumpPending = false jumpPending = false
} }
} else if (documents.isEmpty()) { } else if (documents.isEmpty()) {
// Dernier document supprimé : plus rien à afficher → retour. // Dernier document supprimé : plus rien à afficher → retour.
onBack() if (shouldExitViewer(jumpPending, hadDocuments, documents.isEmpty())) onBack()
} else {
// M35 : clamp après suppression (ex. page 2/2 supprimée) +
// restauration de la page mémorisée après rotation.
val target = resolveViewerPage(pagerState.currentPage, savedPage, documents.size)
savedPage = target
if (target != pagerState.currentPage) pagerState.scrollToPage(target)
} }
} }
// Suit le swipe utilisateur pour mémoriser la page courante (rotation).
LaunchedEffect(pagerState.currentPage) {
if (!jumpPending) savedPage = pagerState.currentPage
}
val currentFile = documents.getOrNull(pagerState.currentPage) val currentFile = documents.getOrNull(pagerState.currentPage)
@@ -179,8 +197,8 @@ fun DocumentViewerScreen(
} }
// Confirmation avant suppression d'un document déjà traité. // Confirmation avant suppression d'un document déjà traité.
var pendingDeleteMode by remember { mutableStateOf<FileDeleter.DeleteMode?>(null) } var pendingDeleteMode by rememberSaveable { mutableStateOf<FileDeleter.DeleteMode?>(null) }
var showDeleteConfirm by remember { mutableStateOf(false) } var showDeleteConfirm by rememberSaveable { mutableStateOf(false) }
var fullscreen by rememberSaveable { mutableStateOf(false) } var fullscreen by rememberSaveable { mutableStateOf(false) }
val canFullscreen = currentFile?.canFocus() == true val canFullscreen = currentFile?.canFocus() == true
@@ -234,10 +252,9 @@ fun DocumentViewerScreen(
} }
}, },
actions = { actions = {
SyncStatusAction(syncViewModel = syncViewModel) HeaderStatusAction(
ServerStatusBadge( syncViewModel = syncViewModel,
status = connectionStatus, connectionStatusViewModel = connectionStatusViewModel,
onClick = connectionStatusViewModel::checkNow,
) )
}, },
) )
@@ -258,6 +275,17 @@ fun DocumentViewerScreen(
.fillMaxSize() .fillMaxSize()
.padding(padding), .padding(padding),
) { ) {
if (documents.isEmpty()) {
// Chargement initial : le pager serait vide sans repère.
Box(
modifier = Modifier
.fillMaxWidth()
.weight(1f),
contentAlignment = Alignment.Center,
) {
CircularProgressIndicator()
}
} else {
HorizontalPager( HorizontalPager(
state = pagerState, state = pagerState,
modifier = Modifier modifier = Modifier
@@ -275,6 +303,7 @@ fun DocumentViewerScreen(
) )
} }
} }
}
// Barre d'action fixe pilotée par le document affiché : garder // Barre d'action fixe pilotée par le document affiché : garder
// ou supprimer un document en attente de review, ou supprimer // ou supprimer un document en attente de review, ou supprimer
// (local / cloud / les deux) un document déjà traité. // (local / cloud / les deux) un document déjà traité.
@@ -338,6 +367,9 @@ fun DocumentViewerScreen(
* - IMAGE → document plein écran sur fond noir * - IMAGE → document plein écran sur fond noir
* - TEXT → lecture immersive (fond sombre, texte clair, sélectionnable) * - 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]. * Le retour (tap ou bouton système) est géré par le cadre commun [FocusScaffold].
*/ */
@Composable @Composable
@@ -347,6 +379,20 @@ private fun FocusDocumentReader(
onExitFullscreen: () -> Unit, onExitFullscreen: () -> Unit,
modifier: Modifier = Modifier, 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()) { when (file.categoryValue()) {
FileCategory.PDF -> PdfFullscreenReader( FileCategory.PDF -> PdfFullscreenReader(
file = file, file = file,
@@ -370,7 +416,8 @@ private fun FocusDocumentReader(
/** /**
* Cadre commun du mode focus : fond noir plein écran, un tap (l'indicatrice de * Cadre commun du mode focus : fond noir plein écran, un tap (l'indicatrice de
* position est optionnelle) quitte le mode. * position est optionnelle) quitte le mode. Un hint discret « toucher pour
* quitter » s'affiche 3 s à l'entrée pour lever l'ambiguïté tap / pinch.
*/ */
@Composable @Composable
private fun FocusScaffold( private fun FocusScaffold(
@@ -380,6 +427,11 @@ private fun FocusScaffold(
position: String? = null, position: String? = null,
content: @Composable () -> Unit, content: @Composable () -> Unit,
) { ) {
var showHint by remember(file.resourceId) { mutableStateOf(true) }
LaunchedEffect(file.resourceId) {
delay(3_000)
showHint = false
}
Box( Box(
modifier = modifier modifier = modifier
.fillMaxSize() .fillMaxSize()
@@ -389,12 +441,28 @@ private fun FocusScaffold(
}, },
) { ) {
content() content()
if (showHint) {
Surface(
modifier = Modifier
.align(Alignment.TopCenter)
.padding(top = 16.dp),
shape = PillShape,
color = MaterialTheme.colorScheme.inverseSurface.copy(alpha = 0.85f),
) {
Text(
text = stringResource(R.string.focus_tap_to_exit),
modifier = Modifier.padding(horizontal = 12.dp, vertical = 6.dp),
style = MaterialTheme.typography.labelMedium,
color = MaterialTheme.colorScheme.inverseOnSurface,
)
}
}
if (position != null) { if (position != null) {
Surface( Surface(
modifier = Modifier modifier = Modifier
.align(Alignment.BottomCenter) .align(Alignment.BottomCenter)
.padding(bottom = 16.dp), .padding(bottom = 16.dp),
shape = RoundedCornerShape(percent = 50), shape = PillShape,
color = MaterialTheme.colorScheme.inverseSurface.copy(alpha = 0.85f), color = MaterialTheme.colorScheme.inverseSurface.copy(alpha = 0.85f),
) { ) {
Text( Text(
@@ -531,14 +599,11 @@ private fun DocumentViewerPage(
Spacer(Modifier.height(16.dp)) Spacer(Modifier.height(16.dp))
Card( KazierCard(modifier = Modifier.fillMaxWidth()) {
colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceVariant),
elevation = CardDefaults.cardElevation(defaultElevation = 0.dp),
) {
Column(modifier = Modifier Column(modifier = Modifier
.fillMaxWidth() .fillMaxWidth()
.padding(16.dp)) { .padding(16.dp)) {
MetadataRow(stringResource(R.string.document_size), formatSize(file.size)) MetadataRow(stringResource(R.string.document_size), formatFileSize(file.size))
MetadataRow(stringResource(R.string.document_type), fileTypeLabel(file)) MetadataRow(stringResource(R.string.document_type), fileTypeLabel(file))
MetadataRow(stringResource(R.string.document_added_at), formatDateTime(file.addedAt)) MetadataRow(stringResource(R.string.document_added_at), formatDateTime(file.addedAt))
file.lastModified?.let { lastModified -> file.lastModified?.let { lastModified ->
@@ -581,7 +646,7 @@ private fun DocumentActionBar(
) { ) {
if (pendingReview) { if (pendingReview) {
Surface( Surface(
shape = RoundedCornerShape(percent = 50), shape = PillShape,
color = MaterialTheme.colorScheme.secondaryContainer, color = MaterialTheme.colorScheme.secondaryContainer,
) { ) {
Text( Text(
@@ -592,7 +657,10 @@ private fun DocumentActionBar(
) )
} }
Spacer(Modifier.height(12.dp)) Spacer(Modifier.height(12.dp))
Row(horizontalArrangement = Arrangement.spacedBy(48.dp)) { Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.spacedBy(16.dp, Alignment.CenterHorizontally),
) {
DocumentActionButton( DocumentActionButton(
icon = Icons.Filled.Close, icon = Icons.Filled.Close,
contentDescription = stringResource(R.string.review_delete), contentDescription = stringResource(R.string.review_delete),
@@ -635,7 +703,7 @@ private fun DocumentActionBar(
} }
} }
/** Bouton « OCR » — même gabarit que le menu Supprimer (Surface 88×48). */ /** Bouton « OCR » M3 — gabarit adaptatif (plus de Surface 88×48 fixe). */
@Composable @Composable
private fun DocumentOcrButton( private fun DocumentOcrButton(
label: Int, label: Int,
@@ -643,39 +711,24 @@ private fun DocumentOcrButton(
onClick: () -> Unit, onClick: () -> Unit,
modifier: Modifier = Modifier, modifier: Modifier = Modifier,
) { ) {
val tint = if (enabled) MaterialTheme.colorScheme.primary val labelText = stringResource(label)
else MaterialTheme.colorScheme.onSurfaceVariant FilledTonalButton(
onClick = onClick,
Surface(
onClick = { if (enabled) onClick() },
enabled = enabled, enabled = enabled,
shape = RoundedCornerShape(20.dp),
color = if (enabled) MaterialTheme.colorScheme.primaryContainer
else MaterialTheme.colorScheme.surfaceVariant,
modifier = modifier, modifier = modifier,
) { ) {
Box(
modifier = Modifier.size(width = 88.dp, height = 48.dp),
contentAlignment = Alignment.Center,
) {
Row(verticalAlignment = Alignment.CenterVertically) {
Icon( Icon(
imageVector = Icons.Filled.DocumentScanner, imageVector = Icons.Filled.DocumentScanner,
contentDescription = null, contentDescription = null,
tint = tint,
modifier = Modifier.size(20.dp), modifier = Modifier.size(20.dp),
) )
Spacer(Modifier.size(ButtonDefaults.IconSpacing))
Text( Text(
text = stringResource(label), text = labelText,
color = tint,
fontSize = 11.sp,
maxLines = 1, maxLines = 1,
fontWeight = FontWeight.Bold,
) )
} }
} }
}
}
/** /**
* Fenêtre OCR : progression (upload → queued → processing), texte extrait * Fenêtre OCR : progression (upload → queued → processing), texte extrait
@@ -797,45 +850,34 @@ private fun DocumentDeleteMenu(
modifier: Modifier = Modifier, modifier: Modifier = Modifier,
) { ) {
val modes = deleteModesFor(file) val modes = deleteModesFor(file)
var expanded by remember { mutableStateOf(false) } var expanded by rememberSaveable { mutableStateOf(false) }
val tint = if (enabled) MaterialTheme.colorScheme.error val deleteLabel = stringResource(R.string.delete)
else MaterialTheme.colorScheme.onSurfaceVariant
Box(modifier = modifier) { Box(modifier = modifier) {
Surface( FilledTonalButton(
onClick = { if (enabled) expanded = true }, onClick = { expanded = true },
enabled = enabled, enabled = enabled,
shape = RoundedCornerShape(20.dp), colors = ButtonDefaults.filledTonalButtonColors(
color = if (enabled) MaterialTheme.colorScheme.errorContainer containerColor = MaterialTheme.colorScheme.errorContainer,
else MaterialTheme.colorScheme.surfaceVariant, contentColor = MaterialTheme.colorScheme.onErrorContainer,
),
) { ) {
Box(
modifier = Modifier.size(width = 88.dp, height = 48.dp),
contentAlignment = Alignment.Center,
) {
Row(verticalAlignment = Alignment.CenterVertically) {
Icon( Icon(
imageVector = Icons.Filled.Delete, imageVector = Icons.Filled.Delete,
contentDescription = null, contentDescription = null,
tint = tint,
modifier = Modifier.size(20.dp), modifier = Modifier.size(20.dp),
) )
Spacer(Modifier.size(ButtonDefaults.IconSpacing))
Text( Text(
text = stringResource(R.string.delete), text = deleteLabel,
color = tint,
fontSize = 11.sp,
maxLines = 1, maxLines = 1,
fontWeight = FontWeight.Bold,
) )
Icon( Icon(
imageVector = Icons.Filled.ArrowDropDown, imageVector = Icons.Filled.ArrowDropDown,
contentDescription = null, contentDescription = deleteLabel,
tint = tint,
modifier = Modifier.size(16.dp), modifier = Modifier.size(16.dp),
) )
} }
}
}
DropdownMenu( DropdownMenu(
expanded = expanded, expanded = expanded,
@@ -894,9 +936,32 @@ private fun fileTypeLabel(file: FileEntity): String =
?: file.mimeType?.uppercase(Locale.getDefault()) ?: file.mimeType?.uppercase(Locale.getDefault())
?: "—" ?: "—"
/** Vrai si le fichier est local et appartient à une catégorie consultable en mode focus. */ /**
* Page cible du pager après évolution de la liste (rotation, suppression).
*
* - `restoredPage` (mémorisée, `rememberSaveable`) prime si elle reste valide
* → retour à la page lue avant rotation (M30) ;
* - sinon la page courante est clampée aux bornes (M35 : suppression du
* dernier document → retombe sur le précédent au lieu d'une page vide).
*/
internal fun resolveViewerPage(currentPage: Int, restoredPage: Int, itemCount: Int): Int {
if (itemCount <= 0) return 0
val lastIndex = itemCount - 1
if (restoredPage in 0..lastIndex) return restoredPage
return currentPage.coerceIn(0, lastIndex)
}
/**
* Retour arrière uniquement quand une liste a déjà été vue dans cette
* composition puis vidée hors saut initial : le vide transitoire du
* (re)chargement — y compris après rotation — ne quitte jamais l'écran.
*/
internal fun shouldExitViewer(jumpPending: Boolean, hadDocuments: Boolean, isEmpty: Boolean): Boolean =
!jumpPending && hadDocuments && isEmpty
/** Vrai si le fichier appartient à une catégorie consultable en mode focus. */
private fun FileEntity.canFocus(): Boolean = 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 * Vrai si le fichier est prêt pour l'OCR serveur : copie physique locale ET
@@ -923,17 +988,3 @@ private fun formatDateTime(millis: Long): String {
val time = DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT).withLocale(locale).format(dateTime) val time = DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT).withLocale(locale).format(dateTime)
return "$day $time" return "$day $time"
} }
/** Miroir de `formatSize` (app/index.tsx). */
@Composable
private fun formatSize(bytes: Long): String {
if (bytes < 1_024) {
return "$bytes ${stringResource(R.string.unit_bytes)}"
}
if (bytes < 1_024 * 1_024) {
val kb = bytes / 1_024f
return String.format(Locale.getDefault(), "%.1f %s", kb, stringResource(R.string.unit_kilobytes))
}
val mb = bytes / (1_024f * 1_024f)
return String.format(Locale.getDefault(), "%.1f %s", mb, stringResource(R.string.unit_megabytes))
}
@@ -0,0 +1,31 @@
package com.kazier.mobile.ui.document
import androidx.lifecycle.ViewModel
import com.kazier.mobile.data.remote.ApiException
import com.kazier.mobile.data.repository.RemoteContentRepository
import dagger.hilt.android.lifecycle.HiltViewModel
import javax.inject.Inject
/**
* Chargement streaming d'un fichier cloud-only (V1 finitions).
*
* Stateless : [load] lit les octets via `GET /files/:id/content` sans les
* persister. Le composant appelant garde l'état (idle/loading/loaded/error).
*/
@HiltViewModel
class RemoteContentViewModel @Inject constructor(
private val repository: RemoteContentRepository,
) : ViewModel() {
suspend fun load(fileId: String): Result<ByteArray> =
runCatching { repository.fetch(fileId) }
companion object {
/** Code quand le serveur n'a aucun octet (metadata-only jamais uploadé). */
fun isNoContent(e: Throwable): Boolean =
e is ApiException && e.code == "NOT_FOUND"
fun isTooLarge(e: Throwable): Boolean =
e is ApiException && e.code == "FILE_TOO_LARGE"
}
}
@@ -42,7 +42,7 @@ fun DocumentContentViewer(
} }
if (file.uri == null) { if (file.uri == null) {
CloudOnlyPlaceholder(file, modifier) RemoteDocumentViewer(file, onOpenExternalFailed, modifier)
return return
} }
@@ -55,6 +55,10 @@ import kotlinx.coroutines.withContext
* largeur cible borne les bitmaps et un cache LRU limite la mémoire. Le * 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 * `PdfRenderer` n'est pas thread-safe : toutes les lectures passent par un
* `Mutex` et un dispatcher IO. * `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 @Composable
fun PdfPageViewer( fun PdfPageViewer(
@@ -62,16 +66,17 @@ fun PdfPageViewer(
contentResolver: ContentResolver, contentResolver: ContentResolver,
onOpenExternalFailed: () -> Unit, onOpenExternalFailed: () -> Unit,
modifier: Modifier = Modifier, modifier: Modifier = Modifier,
openFd: (() -> ParcelFileDescriptor?)? = null,
) { ) {
val uri = file.uri val uri = file.uri
if (uri == null) { if (uri == null && openFd == null) {
CloudOnlyPlaceholder(file, modifier) CloudOnlyPlaceholder(file, modifier)
return return
} }
val document = remember(uri) { PdfDocumentState(contentResolver, uri) } val document = remember(file.resourceId, uri) { PdfDocumentState(contentResolver, uri, openFd) }
var pageCount by remember(uri) { mutableIntStateOf(0) } var pageCount by remember(file.resourceId) { mutableIntStateOf(0) }
var loadFailed by remember(uri) { mutableStateOf(false) } var loadFailed by remember(file.resourceId) { mutableStateOf(false) }
// Le state vit en mémoire (cache + dossier ouvert) tant que ce lecteur est // 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. // affiché ; il est fermé à la sortie ou au changement de document.
@@ -79,7 +84,7 @@ fun PdfPageViewer(
onDispose { document.close() } onDispose { document.close() }
} }
LaunchedEffect(uri) { LaunchedEffect(document) {
pageCount = 0 pageCount = 0
loadFailed = false loadFailed = false
if (document.load()) { if (document.load()) {
@@ -136,22 +141,23 @@ fun PdfFocusViewer(
modifier: Modifier = Modifier, modifier: Modifier = Modifier,
onPageCountChanged: ((Int) -> Unit)? = null, onPageCountChanged: ((Int) -> Unit)? = null,
renderScale: Float = 1f, renderScale: Float = 1f,
openFd: (() -> ParcelFileDescriptor?)? = null,
) { ) {
val uri = file.uri val uri = file.uri
if (uri == null) { if (uri == null && openFd == null) {
CloudOnlyPlaceholder(file, modifier) CloudOnlyPlaceholder(file, modifier)
return return
} }
val document = remember(uri) { PdfDocumentState(contentResolver, uri) } val document = remember(file.resourceId, uri) { PdfDocumentState(contentResolver, uri, openFd) }
var pageCount by remember(uri) { mutableIntStateOf(0) } var pageCount by remember(file.resourceId) { mutableIntStateOf(0) }
var loadFailed by remember(uri) { mutableStateOf(false) } var loadFailed by remember(file.resourceId) { mutableStateOf(false) }
DisposableEffect(document) { DisposableEffect(document) {
onDispose { document.close() } onDispose { document.close() }
} }
LaunchedEffect(uri) { LaunchedEffect(document) {
pageCount = 0 pageCount = 0
loadFailed = false loadFailed = false
if (document.load()) { if (document.load()) {
@@ -303,10 +309,15 @@ private fun PdfPageItem(
/** /**
* État d'un document PDF : ouvre le `PdfRenderer` à la demande, rend chaque * É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). * 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 class PdfDocumentState(
private val contentResolver: ContentResolver, private val contentResolver: ContentResolver,
private val uri: String, private val uri: String?,
private val openFd: (() -> ParcelFileDescriptor?)? = null,
) { ) {
@Volatile @Volatile
private var renderer: PdfRenderer? = null private var renderer: PdfRenderer? = null
@@ -329,7 +340,8 @@ private class PdfDocumentState(
if (closed) return@withLock false if (closed) return@withLock false
if (renderer != null) return@withLock true if (renderer != null) return@withLock true
val opened = runCatching { 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 if (pfd != null) PdfRenderer(pfd) else null
}.getOrNull() }.getOrNull()
if (opened != null) renderer = opened if (opened != null) renderer = opened

Some files were not shown because too many files have changed in this diff Show More