diff --git a/CHANGELOG.md b/CHANGELOG.md index 788f89f..a5bed32 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -14,6 +14,7 @@ Le format suit [Keep a Changelog](https://keepachangelog.com/fr/1.1.0/) et le ve - Corrections V3 (S3) : `PATCH /files/:id/facts` + op `correct_facts` (full-replace du jeu `user`, editor+, validation Go → 400 jamais 500), Room v20 (`resource_facts` + `FactsDao`, migration 19→20), fiche « Ce qu'on a compris » sur le viewer (chips, confiance grisée + suggéré, édition par type, reset auto), `FactsRepository` (sync remplace-en-bloc, correction optimiste + outbox atomique), `GET /files/:id/facts` consommé côté client. - Recherche V3 (S4) : colonne `search_tsv` (migration `000020`, `french`, index GIN) + `SearchDocumentsVisible` (nom LIKE + TS + faits, rang nom > TS > fait sûr > fait douteux, facettes émetteur/type/montant/période), `GET /files/search` étendu (400 si facette malformée), Room v21 (FTS4 `files_fts` + triggers partagés fresh-install/migration, entité déclarée pour KSP), `searchDocuments` offline (même rang, accents préservés) + UI filtres (émetteur, types chips, montants, période ISO, compteur, effacer). - Relations V3 (S5) : table `resource_links` + `scan_session_id` (migration `000021`), réconciliation déterministe (same_scan via outbox, doublons via SHA-256 posé à l'upload + backfill boot, same_issuer/référence via faits effectifs, verdicts préservés, élagage auto), `GET /files/:id/relations` + verdict (owner-only), `GET /duplicates` (groupes + gain récupérable), Room v22 (links + collections), « Voir aussi » dans la fiche (verdicts en ligne), écran Doublons (garder le plus récent), collections locales (sauver/rejouer/supprimer depuis la recherche), `scanSessionId` dans les creates de scan. +- Confiance V3 (S6) : `token_version` (migration `000022`, claim `tv`, 401 si révoqué, bump au changement de mot de passe — fin de la limite V1), quota (colonne héritée de `000001`, `000023` idempotente, 413 `QUOTA_EXCEEDED` sur créations, `GET /users/me/usage`), appareils (`GET /devices`, `DELETE /devices/:id`, `EnforceDeviceExists` en prod, écran Appareils + quota), renames concurrents transparents (`baseUpdatedAt` + `conflicts[]` non-fataux, gracieuseté 2 s, pipeline mobile persistance + dialogue), liens à expiration 7j par défaut, import « classeur » unifié (scan/note/dossier), onboarding cercle Famille. - Corbeille V3 (S1 mobile, Room v19) : colonne `trashed_at` (files + folders, migration 18→19), tombstone `exists = 0` (requêtes `exists = 1` inchangées), `FileDeleter`/`FolderDeleter`/`SafFileDeleter` → ops `trash_resource` (plus de `delete_resource` émis), garde walk anti-résurrection + reconcile, `TrashRepository` (restore/purge/convergence `GET /trash`/expiration locale 31j), écran Corbeille (Réglages → restore/purge avec confirmation), expiration tombstones dans `RetentionWorker`, dialogue de suppression rewordé (corbeille 30j, plus « irréversible »). ## [1.1.0] - 2026-09-25 diff --git a/V3.md b/V3.md index 2739ed9..ce55340 100644 --- a/V3.md +++ b/V3.md @@ -113,7 +113,7 @@ Sans ces 4 items, les piliers grincent. Ils sont petits et intégrés aux slices 3. **S3 — Fiche + correction** (livré : `PATCH /files/:id/facts` + op `correct_facts` editor+ + Room v20 facts + fiche viewer + `FactsRepository` + B4 a11y fiche) — done quand : corriger en un tap converge serveur ↔ 2e device. 4. **S4 — Recherche** (livré : `000020` FTS + facettes serveur + Room FTS v21 + UI filtres + B4 a11y) — done quand : « facture edf mars » trouve `scan_042.pdf` offline ET online. 5. **S5 — Relations + B2** (livré : `000021` links + doublons SHA-256 + same_scan outbox + `GET /relations` + verdict + `GET /duplicates` + Room v22 + « Voir aussi » + Doublons + collections locales) — done quand : fiche CNI → verso + doublon listés, invalidables ; doublons chiffrés en Mo récupérables. -6. **S6 — Partage sobre + A1/A2/A4 + B1 (+B5 si temps)** (expiration défaut 7j + `000022` token_version + `000023` quota + `413 QUOTA_EXCEEDED` + `GET /devices` + écran Appareils + `update_metadata{baseUpdatedAt}` + flag `conflict` + import « classeur » unifié B1 + onboarding cercle B5) — done quand : lien RIB expiré → `NOT_FOUND`, password changé → autres devices re-logués, device perdu révoqué, quota plein → 413 propre, rename concurrent → badge « renommé ailleurs ». +6. **S6 — Partage sobre + A1/A2/A4 + B1 (+B5 si temps)** (livré : expiration liens 7j défaut + `000022` token_version + `000023` quota idempotente + `413 QUOTA_EXCEEDED` + `GET /devices` + `DELETE /devices/:id` + `EnforceDeviceExists` prod + écran Appareils + quota/usage + `update_metadata{baseUpdatedAt}` + `conflicts[]` + pipeline mobile + import « classeur » unifié + onboarding cercle Famille) — done quand : lien RIB expiré → `NOT_FOUND`, password changé → autres devices re-logués, device perdu révoqué, quota plein → 413 propre, rename concurrent → badge « renommé ailleurs ». 7. **S7 — Preview 1ère page** (`pdf_preview` V2.md §3.3, une seule taille) + **C3 export chiffré** (`GET /export` zip + manifest) + B3 impression si temps + polish + release 1.2.0. Arbitrage stretch : **export > embeddings** (vrai 3-2-1 perçu, zéro GPU). ## 6. Tests (mêmes harnais, pas de nouveau framework) diff --git a/backend/cmd/server/main.go b/backend/cmd/server/main.go index 9eec831..cbed73b 100644 --- a/backend/cmd/server/main.go +++ b/backend/cmd/server/main.go @@ -61,6 +61,9 @@ func main() { log.Fatalln(err) } handlers.Auth = authManager + // V3 S6 A1 : les tokens d'un device révoqué (ligne `devices` supprimée) + // sont rejetés en 401 — révocation réelle, pas décorative. + handlers.EnforceDeviceExists = true repo := repository.NewRepository(conn) diff --git a/backend/cmd/server/router_test.go b/backend/cmd/server/router_test.go index e7dc8fb..1ca9453 100644 --- a/backend/cmd/server/router_test.go +++ b/backend/cmd/server/router_test.go @@ -35,6 +35,10 @@ var expectedRoutes = []string{ "GET /api/v1/users/resolve", "PATCH /api/v1/users/me/password", + "GET /api/v1/users/me/usage", + + "GET /api/v1/devices", + "DELETE /api/v1/devices/:id", "POST /api/v1/groups", "GET /api/v1/groups", diff --git a/backend/db/migrations/000022_token_version.down.sql b/backend/db/migrations/000022_token_version.down.sql new file mode 100644 index 0000000..42c3ac4 --- /dev/null +++ b/backend/db/migrations/000022_token_version.down.sql @@ -0,0 +1 @@ +ALTER TABLE users DROP COLUMN IF EXISTS token_version; diff --git a/backend/db/migrations/000022_token_version.up.sql b/backend/db/migrations/000022_token_version.up.sql new file mode 100644 index 0000000..3cf9178 --- /dev/null +++ b/backend/db/migrations/000022_token_version.up.sql @@ -0,0 +1,6 @@ +-- V3 S6 : révocation des tokens au changement de mot de passe. +-- `token_version` est bumpé par PATCH /users/me/password ; le middleware +-- rejette les tokens dont le claim `tv` diffère (401). Défaut 0 : les tokens +-- pré-V3 (sans claim `tv`, lus comme 0) restent valides jusqu'au premier +-- changement de mot de passe — montée en version sans coupure. +ALTER TABLE users ADD COLUMN token_version INT NOT NULL DEFAULT 0; diff --git a/backend/db/migrations/000023_quota.down.sql b/backend/db/migrations/000023_quota.down.sql new file mode 100644 index 0000000..5de1c71 --- /dev/null +++ b/backend/db/migrations/000023_quota.down.sql @@ -0,0 +1,2 @@ +-- No-op : la colonne prédate cette migration (000001), on ne la supprime pas. +SELECT 1; diff --git a/backend/db/migrations/000023_quota.up.sql b/backend/db/migrations/000023_quota.up.sql new file mode 100644 index 0000000..617779e --- /dev/null +++ b/backend/db/migrations/000023_quota.up.sql @@ -0,0 +1,6 @@ +-- V3 S6 (A2) : quota de stockage par compte (10 Go par défaut, V2.md §3.1). +-- Garde-fou à l'upload (413 QUOTA_EXCEEDED) + affichage `GET /users/me/usage`. +-- L'usage est calculé (somme `size_bytes` des fichiers vifs), jamais stocké. +-- Note : la colonne existe depuis 000001 (modèle V2) — IF NOT EXISTS pour +-- les bases créées avant/après, sans double ajout. +ALTER TABLE users ADD COLUMN IF NOT EXISTS storage_quota_bytes BIGINT NOT NULL DEFAULT 10737418240; diff --git a/backend/db/migrations_test.go b/backend/db/migrations_test.go index b653180..d1f106e 100644 --- a/backend/db/migrations_test.go +++ b/backend/db/migrations_test.go @@ -491,6 +491,30 @@ func TestMigrationsUpDown(t *testing.T) { t.Error("colonne resources.scan_session_id manquante après 000021") } + // --- 000022 : révocation tokens ------------------------------------------ + var tvCol int + err = conn.QueryRow(` + SELECT COUNT(*) FROM information_schema.columns + WHERE table_schema = 'public' AND table_name = 'users' AND column_name = 'token_version'`).Scan(&tvCol) + if err != nil { + t.Fatalf("token_version column: %v", err) + } + if tvCol == 0 { + t.Error("colonne users.token_version manquante après 000022") + } + + // --- 000023 : quota (colonne héritée de 000001, IF NOT EXISTS) ------------ + var quotaCol int + err = conn.QueryRow(` + SELECT COUNT(*) FROM information_schema.columns + WHERE table_schema = 'public' AND table_name = 'users' AND column_name = 'storage_quota_bytes'`).Scan("aCol) + if err != nil { + t.Fatalf("storage_quota_bytes column: %v", err) + } + if quotaCol == 0 { + t.Error("colonne users.storage_quota_bytes manquante après 000023") + } + if err := MigrateDownDatabase(url); err != nil { t.Fatalf("migrate down: %v", err) } diff --git a/backend/handlers/auth.go b/backend/handlers/auth.go index 10b0859..fe5bebe 100644 --- a/backend/handlers/auth.go +++ b/backend/handlers/auth.go @@ -2,6 +2,7 @@ package handlers import ( "errors" + "log" "net/http" "strings" "sync" @@ -156,7 +157,7 @@ func AuthLogin(c *gin.Context) { return } - token, expiresAt, err := Auth.IssueWithExpiry(user.ID, req.DeviceID) + token, expiresAt, err := Auth.IssueWithExpiry(user.ID, req.DeviceID, user.TokenVersion) if err != nil { api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not issue token") return @@ -179,8 +180,9 @@ type changePasswordRequest struct { } // ChangePassword met à jour le hash du compte connecté. Le mot de passe -// courant est requis. Limite connue V1 : les tokens déjà émis restent valides -// jusqu'à expiration (7 j, pas de révocation) — cf. docs/api-v1.md §7. +// courant est requis. V3 S6 : le changement bumpe `token_version` — tous les +// autres tokens (autres devices, sessions volées) sont révoqués aussitôt +// (le token courant aussi : le client doit se reconnecter). func ChangePassword(c *gin.Context) { if Store == nil || Store.Repository == nil { api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized") @@ -217,6 +219,11 @@ func ChangePassword(c *gin.Context) { api.Error(c, http.StatusInternalServerError, "INTERNAL", "could not update password") return } + // Révocation (V3 S6) : bump best-effort — un échec ici ne doit pas faire + // croire que le password n'a pas changé (il l'est, ligne ci-dessus). + if err := Store.Repository.Users.BumpTokenVersion(userID); err != nil { + log.Printf("auth: bump token_version(%s): %v", userID, err) + } api.OK(c, gin.H{"id": userID}) } diff --git a/backend/handlers/devices.go b/backend/handlers/devices.go index 2048f62..23172f5 100644 --- a/backend/handlers/devices.go +++ b/backend/handlers/devices.go @@ -105,3 +105,51 @@ func DevicesRegister(c *gin.Context) { api.OK(c, gin.H{"deviceId": req.DeviceID}) } + +// DeviceDTO expose un device du compte (A1 — voir / révoquer). +type DeviceDTO struct { + DeviceID string `json:"deviceId"` + LastSeenAt *int64 `json:"lastSeenAt"` +} + +// DevicesList renvoie les devices du compte connecté (`GET /devices`, +// dernier login = ce compte, les plus récemment vus d'abord). +func DevicesList(c *gin.Context) { + if Store == nil || Store.Repository == nil { + api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized") + return + } + userID := c.GetString(UserIDKey) + rows, err := Store.Repository.Devices.ListByUser(userID) + if err != nil { + writeError(c, err) + return + } + out := make([]DeviceDTO, 0, len(rows)) + for _, row := range rows { + out = append(out, DeviceDTO{DeviceID: row.DeviceID, LastSeenAt: row.LastSeenAt}) + } + api.OK(c, out) +} + +// DeviceRevoke révoque un device du compte (`DELETE /devices/:id`, A1 — +// téléphone perdu). Avec EnforceDeviceExists, ses tokens deviennent 401 et +// son login est refusé (ré-enregistrement explicite requis). Ligne absente +// ou d'un autre compte → 404 (pas d'énumération). +func DeviceRevoke(c *gin.Context) { + if Store == nil || Store.Repository == 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", "device not found") + return + } + if err := Store.Repository.Devices.Revoke(userID, id); err != nil { + writeError(c, err) + return + } + api.OK(c, gin.H{"id": id}) +} diff --git a/backend/handlers/middleware.go b/backend/handlers/middleware.go index 20cc19e..4d4b4f2 100644 --- a/backend/handlers/middleware.go +++ b/backend/handlers/middleware.go @@ -60,7 +60,7 @@ func RequireAuth(c *gin.Context) { // Le store peut être nil dans les tests middleware purs ; sinon on vérifie // que le compte existe toujours (supprimé → accès refusé). if Store != nil && Store.Repository != nil { - _, err := Store.Repository.Users.GetByID(identity.UserID) + user, err := Store.Repository.Users.GetByID(identity.UserID) if errors.Is(err, repository.ErrNotFound) { api.Error(c, http.StatusUnauthorized, "UNAUTHORIZED", "account no longer exists") c.Abort() @@ -71,6 +71,14 @@ func RequireAuth(c *gin.Context) { c.Abort() return } + // V3 S6 : révocation — un changement de mot de passe (bump de + // token_version) invalide tous les tokens antérieurs, même non expirés. + if identity.TokenVersion != user.TokenVersion { + log.Printf("auth: token révoqué rejeté (user=%s tv=%d, attendu %d)", identity.UserID, identity.TokenVersion, user.TokenVersion) + api.Error(c, http.StatusUnauthorized, "UNAUTHORIZED", "token revoked") + c.Abort() + return + } } if EnforceDeviceExists && Store != nil && Store.Repository != nil { diff --git a/backend/handlers/router.go b/backend/handlers/router.go index 1d917ba..e3edb8f 100644 --- a/backend/handlers/router.go +++ b/backend/handlers/router.go @@ -51,6 +51,10 @@ func RegisterRoutes(r *gin.Engine) { protected.GET("/users/resolve", ResolveUser) protected.PATCH("/users/me/password", ChangePassword) + protected.GET("/users/me/usage", UsersUsage) + + protected.GET("/devices", DevicesList) + protected.DELETE("/devices/:id", DeviceRevoke) protected.POST("/groups", GroupsCreate) protected.GET("/groups", GroupsList) diff --git a/backend/handlers/s6_test.go b/backend/handlers/s6_test.go new file mode 100644 index 0000000..7f8880c --- /dev/null +++ b/backend/handlers/s6_test.go @@ -0,0 +1,152 @@ +package handlers_test + +import ( + "encoding/json" + "fmt" + "net/http" + "testing" + + "github.com/kazier/backend/handlers" + "github.com/kazier/backend/repository" +) + +// TestPasswordChangeRevokesTokens : le bump de token_version invalide tous +// les tokens antérieurs (V3 S6) — l'ancien token devient 401, un nouveau +// login fonctionne. +func TestPasswordChangeRevokesTokens(t *testing.T) { + r, _, repo := setup(t) + device := repository.NewID() + token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "rv"), "revoke-test-password", device) + + rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/files", token, nil, "") + if rec.Code != http.StatusOK { + t.Fatalf("token initial rejeté: %d %s", rec.Code, rec.Body.String()) + } + + body := `{"current_password":"revoke-test-password","new_password":"revoke-test-password-2"}` + rec, _ = doRequest(t, r, http.MethodPatch, "/api/v1/users/me/password", token, []byte(body), "application/json") + expectOK(t, rec, "password-change") + + rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files", token, nil, "") + expectError(t, rec, http.StatusUnauthorized, "UNAUTHORIZED", "revoked-token") + + // Nouveau login (nouvelle version) : fonctionne. + body = fmt.Sprintf(`{"username":%q,"password":"revoke-test-password-2","device_id":%q}`, + testUserUsername(device, "rv"), device) + rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/auth/login", "", []byte(body), "application/json") + expectOK(t, rec, "relogin") + var login struct { + Data struct { + Token string `json:"token"` + } `json:"data"` + } + if err := json.Unmarshal(rec.Body.Bytes(), &login); err != nil || login.Data.Token == "" { + t.Fatalf("relogin sans token: %s", rec.Body.String()) + } + rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files", login.Data.Token, nil, "") + if rec.Code != http.StatusOK { + t.Fatalf("nouveau token rejeté: %d %s", rec.Code, rec.Body.String()) + } +} + +// TestDevicesListAndRevoke : liste les devices du compte, révoque (A1) — +// avec EnforceDeviceExists, le token du device révoqué devient 401 et son +// login est refusé (ré-enregistrement requis). +func TestDevicesListAndRevoke(t *testing.T) { + r, _, repo := setup(t) + handlers.EnforceDeviceExists = true + defer func() { handlers.EnforceDeviceExists = false }() + device := repository.NewID() + token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "dv"), "devices-test-password", device) + + rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/devices", token, nil, "") + env := expectOK(t, rec, "devices-list") + var devices []struct { + DeviceID string `json:"deviceId"` + LastSeenAt *int64 `json:"lastSeenAt"` + } + if err := json.Unmarshal(env.Data, &devices); err != nil { + t.Fatalf("unmarshal: %v", err) + } + found := false + for _, d := range devices { + if d.DeviceID == device { + found = true + } + } + if !found { + t.Fatalf("device absent de la liste: %+v", devices) + } + + rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/devices/"+device, token, nil, "") + expectOK(t, rec, "devices-revoke") + + // Token existant → 401 (device inconnu). + rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files", token, nil, "") + expectError(t, rec, http.StatusUnauthorized, "UNAUTHORIZED", "revoked-device-token") + + // Login refusé (device inconnu, indistinguable — 401). + body := fmt.Sprintf(`{"username":%q,"password":"devices-test-password","device_id":%q}`, + testUserUsername(device, "dv"), device) + rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/auth/login", "", []byte(body), "application/json") + expectError(t, rec, http.StatusUnauthorized, "UNAUTHORIZED", "revoked-device-login") + + // Révoquer l'inexistant / malformé → 404 (avec un token encore valide). + deviceB := repository.NewID() + tokenB, _ := registerAndLogin(t, r, repo, testUserUsername(deviceB, "dv2"), "devices-test-password", deviceB) + rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/devices/"+repository.NewID(), tokenB, nil, "") + expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "revoke-unknown") + rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/devices/nope", tokenB, nil, "") + expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "revoke-malformed") +} + +// TestUsageAndQuota : GET /users/me/usage reflète l'état, et un upload +// au-delà du quota est rejeté en 413 QUOTA_EXCEEDED (V3 S6 A2). +func TestUsageAndQuota(t *testing.T) { + r, store, repo := setup(t) + _ = store + device := repository.NewID() + token, userID := registerAndLogin(t, r, repo, testUserUsername(device, "qu"), "quota-test-password", device) + + rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/users/me/usage", token, nil, "") + env := expectOK(t, rec, "usage-empty") + var usage struct { + UsedBytes int64 `json:"usedBytes"` + QuotaBytes int64 `json:"quotaBytes"` + FileCount int `json:"fileCount"` + TrashCount int `json:"trashCount"` + TrashedBytes int64 `json:"trashedBytes"` + } + if err := json.Unmarshal(env.Data, &usage); err != nil { + t.Fatalf("unmarshal: %v", err) + } + if usage.UsedBytes != 0 || usage.QuotaBytes != 10737418240 || usage.FileCount != 0 { + t.Fatalf("usage initial inattendu: %+v", usage) + } + + // Quota miniature (10 octets) → l'upload passe sous le seuil puis casse. + if _, err := repo.Users.DB.Exec(`UPDATE users SET storage_quota_bytes = 10 WHERE id = $1`, userID); err != nil { + t.Fatalf("shrink quota: %v", err) + } + rec = uploadMultipart(t, r, token, "", "a.txt", []byte("12345")) + expectOK(t, rec, "usage-under-quota") + + rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/users/me/usage", token, nil, "") + env = expectOK(t, rec, "usage-after") + usage = struct { + UsedBytes int64 `json:"usedBytes"` + QuotaBytes int64 `json:"quotaBytes"` + FileCount int `json:"fileCount"` + TrashCount int `json:"trashCount"` + TrashedBytes int64 `json:"trashedBytes"` + }{} + if err := json.Unmarshal(env.Data, &usage); err != nil { + t.Fatalf("unmarshal: %v", err) + } + if usage.UsedBytes != 5 || usage.FileCount != 1 { + t.Fatalf("usage après upload: %+v", usage) + } + + rec = uploadMultipart(t, r, token, "", "b.txt", []byte("123456")) + expectError(t, rec, http.StatusRequestEntityTooLarge, "QUOTA_EXCEEDED", "usage-over-quota") +} diff --git a/backend/handlers/store.go b/backend/handlers/store.go index 57d6d72..680daec 100644 --- a/backend/handlers/store.go +++ b/backend/handlers/store.go @@ -30,6 +30,8 @@ func writeError(c *gin.Context, err error) { api.Error(c, 409, "NAME_CONFLICT", "a resource with this name already exists here") case errors.Is(err, service.ErrFileTooLarge): api.Error(c, 413, "FILE_TOO_LARGE", "file exceeds the maximum allowed size") + case errors.Is(err, service.ErrQuotaExceeded): + api.Error(c, 413, "QUOTA_EXCEEDED", "storage quota exceeded") default: // Jamais de err.Error() brut au client (fuite SQL/FS/paths, cf. // FEEDBACK #8) : message générique, détail au log serveur. diff --git a/backend/handlers/users.go b/backend/handlers/users.go new file mode 100644 index 0000000..a3e1b19 --- /dev/null +++ b/backend/handlers/users.go @@ -0,0 +1,25 @@ +package handlers + +import ( + "net/http" + + "github.com/gin-gonic/gin" + "github.com/kazier/backend/pkg/api" +) + +// UsersUsage expose l'empreinte du compte (V3 S6 A2) : `GET /users/me/usage` +// `{ usedBytes, quotaBytes, fileCount, trashCount, trashedBytes }` — +// calculé, jamais stocké. La corbeille est détaillée (octets récupérables). +func UsersUsage(c *gin.Context) { + if Store == nil || Store.Repository == nil { + api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized") + return + } + userID := c.GetString(UserIDKey) + usage, err := Store.Usage(userID) + if err != nil { + writeError(c, err) + return + } + api.OK(c, usage) +} diff --git a/backend/pkg/auth/auth.go b/backend/pkg/auth/auth.go index b8e784d..e37808b 100644 --- a/backend/pkg/auth/auth.go +++ b/backend/pkg/auth/auth.go @@ -4,6 +4,7 @@ import ( "crypto/sha256" "errors" "regexp" + "strconv" "time" "aidanwoods.dev/go-paseto" @@ -17,11 +18,14 @@ var ErrInvalidToken = errors.New("invalid token") var hex32Pattern = regexp.MustCompile(`^[0-9a-f]{32}$`) -// Identity est le résultat de Verify : l'utilisateur (sujet du token, autorisant) -// et le device (claim secondaire, porté mais NON autorisant seul). +// Identity est le résultat de Verify : l'utilisateur (sujet du token, autorisant), +// le device (claim secondaire, porté mais NON autorisant seul) et la version +// de révocation (claim `tv`, V3 S6 — le middleware la compare à +// users.token_version). type Identity struct { - UserID string - DeviceID string + UserID string + DeviceID string + TokenVersion int } // Manager issues and verifies paseto v4-local bearer tokens. @@ -40,16 +44,19 @@ func NewManager(secret string) (*Manager, error) { return &Manager{key: key}, nil } -// Issue émet un token lié à un utilisateur ET à un device. +// Issue émet un token lié à un utilisateur ET à un device (version 0 — +// compat pré-V3, cf. IssueWithExpiry). func (m *Manager) Issue(userID, deviceID string) (string, error) { - token, _, err := m.IssueWithExpiry(userID, deviceID) + token, _, err := m.IssueWithExpiry(userID, deviceID, 0) return token, err } // IssueWithExpiry émet un token et retourne son expiration réelle (le `exp` // embarqué). Les appelants doivent exposer expiresAt, jamais le recalculer -// via Now()+TTL (dérive d'horloge, cf. FEEDBACK A7). -func (m *Manager) IssueWithExpiry(userID, deviceID string) (string, time.Time, error) { +// via Now()+TTL (dérive d'horloge, cf. FEEDBACK A7). `tokenVersion` est le +// compteur de révocation du compte (V3 S6) — bumpé à chaque changement de +// mot de passe, vérifié par le middleware. +func (m *Manager) IssueWithExpiry(userID, deviceID string, tokenVersion int) (string, time.Time, error) { now := time.Now() expiresAt := now.Add(TokenTTL) token := paseto.NewToken() @@ -59,12 +66,14 @@ func (m *Manager) IssueWithExpiry(userID, deviceID string) (string, time.Time, e token.SetSubject(userID) // v1.6.0 : SetString n'expose pas d'erreur (panic si non sérialisable). token.SetString("device_id", deviceID) + token.SetString("tv", strconv.Itoa(tokenVersion)) return token.V4Encrypt(m.key, nil), expiresAt, nil } -// Verify décode et contrôle le token, retourne l'identité (user + device). -// Les deux identifiants doivent être 32-hex (cf. docs/api-v1.md) — rejet -// sinon pour préserver les invariants UNIQUE(device_id,operation_id)/CHECK. +// Verify décode et contrôle le token, retourne l'identité (user + device + +// version). Les deux identifiants doivent être 32-hex (cf. docs/api-v1.md) — +// rejet sinon pour préserver les invariants UNIQUE(device_id,operation_id)/CHECK. +// `tv` absent (tokens pré-V3) → 0 ; non numérique → rejet. func (m *Manager) Verify(signed string) (Identity, error) { parsed, err := paseto.NewParserForValidNow().ParseV4Local(m.key, signed, nil) if err != nil { @@ -78,5 +87,12 @@ func (m *Manager) Verify(signed string) (Identity, error) { if err != nil || !hex32Pattern.MatchString(deviceID) { return Identity{}, ErrInvalidToken } - return Identity{UserID: userID, DeviceID: deviceID}, nil + tv := 0 + if raw, err := parsed.GetString("tv"); err == nil && raw != "" { + tv, err = strconv.Atoi(raw) + if err != nil || tv < 0 { + return Identity{}, ErrInvalidToken + } + } + return Identity{UserID: userID, DeviceID: deviceID, TokenVersion: tv}, nil } diff --git a/backend/pkg/auth/auth_test.go b/backend/pkg/auth/auth_test.go index 0f6edc2..685ca86 100644 --- a/backend/pkg/auth/auth_test.go +++ b/backend/pkg/auth/auth_test.go @@ -159,7 +159,7 @@ func TestIssueSetsExpiration(t *testing.T) { func TestIssueWithExpiryMatchesTokenExp(t *testing.T) { m, _ := NewManager("test-secret") - signed, expiresAt, err := m.IssueWithExpiry(testUserID, testDeviceID) + signed, expiresAt, err := m.IssueWithExpiry(testUserID, testDeviceID, 3) if err != nil { t.Fatalf("IssueWithExpiry: %v", err) } @@ -177,4 +177,28 @@ func TestIssueWithExpiryMatchesTokenExp(t *testing.T) { if exp.Unix() != expiresAt.Unix() { t.Errorf("expiresAt = %v, exp token = %v", expiresAt, exp) } + id, err := m.Verify(signed) + if err != nil { + t.Fatalf("Verify: %v", err) + } + if id.TokenVersion != 3 { + t.Errorf("tv = %d, attendu 3", id.TokenVersion) + } +} + +func TestVerifyLegacyTokenWithoutTv(t *testing.T) { + m, _ := NewManager("test-secret") + // Tokens pré-V3 (Issue, tv=0) : Verify lit 0 — valides tant que le + // compte n'a jamais bumpé (montée en version sans coupure). + signed, err := m.Issue(testUserID, testDeviceID) + if err != nil { + t.Fatalf("Issue: %v", err) + } + id, err := m.Verify(signed) + if err != nil { + t.Fatalf("Verify legacy: %v", err) + } + if id.TokenVersion != 0 { + t.Errorf("tv legacy = %d, attendu 0", id.TokenVersion) + } } diff --git a/backend/repository/devices.go b/backend/repository/devices.go index c2409ed..ef82fdf 100644 --- a/backend/repository/devices.go +++ b/backend/repository/devices.go @@ -52,3 +52,61 @@ func (d *Devices) MarkUser(deviceID, userID string) error { } return nil } + +// DeviceRow is one registered device of an account (A1 — voir / révoquer). +type DeviceRow struct { + DeviceID string + LastSeenAt *int64 // ms epoch, NULL si jamais vu depuis l'enregistrement +} + +// ListByUser returns the devices whose last login was this account +// (devices.user_id informatif, jamais autorisant). +func (d *Devices) ListByUser(userID string) ([]DeviceRow, error) { + rows, err := d.DB.Query( + `SELECT device_id, (EXTRACT(EPOCH FROM last_seen_at) * 1000)::bigint + FROM devices WHERE user_id = $1 ORDER BY last_seen_at DESC NULLS LAST`, + userID, + ) + if err != nil { + return nil, err + } + defer rows.Close() + out := []DeviceRow{} + for rows.Next() { + var row DeviceRow + if err := rows.Scan(&row.DeviceID, &row.LastSeenAt); err != nil { + return nil, err + } + out = append(out, row) + } + return out, rows.Err() +} + +// Revoke deletes a device registration of this account (A1 — téléphone +// perdu). Avec EnforceDeviceExists, les tokens du device deviennent 401 et +// le login refuse le device (ré-enregistrement explicite requis). +// Ligne absente ou d'un autre compte → ErrNotFound (pas d'énumération). +// Les hints de présence (`storage_locations`) suivent. +func (d *Devices) Revoke(userID, deviceID string) error { + result, err := d.DB.Exec( + `DELETE FROM devices WHERE device_id = $1 AND user_id = $2`, + deviceID, userID, + ) + if err != nil { + return err + } + affected, err := result.RowsAffected() + if err != nil { + return err + } + if affected == 0 { + return ErrNotFound + } + if _, err := d.DB.Exec( + `DELETE FROM storage_locations WHERE device_id = $1 AND user_id = $2`, + deviceID, userID, + ); err != nil { + return err + } + return nil +} diff --git a/backend/repository/resources.go b/backend/repository/resources.go index 6e7205d..221c044 100644 --- a/backend/repository/resources.go +++ b/backend/repository/resources.go @@ -124,6 +124,39 @@ func (r *Resources) ListMissingHashes(limit int) ([]MissingHash, error) { return out, rows.Err() } +// StorageUsage aggregates a user's footprint (V3 S6 A2 — calculé, jamais +// stocké). Les trashés sont exclus (octets récupérables à la purge). +type StorageUsage struct { + UsedBytes int64 + FileCount int + TrashCount int + TrashedBytes int64 +} + +// StorageUsage sums live file bytes + counts (live + trashed) for a user. +func (r *Resources) StorageUsage(ownerID string) (StorageUsage, error) { + var u StorageUsage + err := r.DB.QueryRow( + `SELECT COALESCE(SUM(size_bytes), 0), COUNT(*) + FROM resources + WHERE user_id = $1 AND type = 'file' AND deleted_at IS NULL`, + ownerID, + ).Scan(&u.UsedBytes, &u.FileCount) + if err != nil { + return StorageUsage{}, err + } + err = r.DB.QueryRow( + `SELECT COUNT(*), COALESCE(SUM(size_bytes), 0) + FROM resources + WHERE user_id = $1 AND deleted_at IS NOT NULL`, + ownerID, + ).Scan(&u.TrashCount, &u.TrashedBytes) + if err != nil { + return StorageUsage{}, err + } + return u, nil +} + type FileRow struct { ID string Name string @@ -700,6 +733,24 @@ func (r *Resources) TouchResource(resourceID string) error { return err } +// LiveNameAndUpdatedAt returns the current name and updated_at (ms epoch) of +// a live resource, any type, unscoped — the caller (sync) has already +// verified effective access. Absent/trashed → ErrNotFound. Sert à la +// détection de conflits de rename (S6 A4 : baseUpdatedAt périmé). +func (r *Resources) LiveNameAndUpdatedAt(resourceID string) (string, int64, error) { + var name string + var ms int64 + err := r.DB.QueryRow( + `SELECT name, (EXTRACT(EPOCH FROM updated_at) * 1000)::bigint + FROM resources WHERE resource_id = $1 AND deleted_at IS NULL`, + resourceID, + ).Scan(&name, &ms) + if err == sql.ErrNoRows { + return "", 0, ErrNotFound + } + return name, ms, err +} + // OwnedRow is a snapshot row: resource identity + freshness. type OwnedRow struct { ID string diff --git a/backend/repository/users.go b/backend/repository/users.go index 6356a35..7ac75f9 100644 --- a/backend/repository/users.go +++ b/backend/repository/users.go @@ -13,6 +13,10 @@ type UserRow struct { PasswordHash string IsAdmin bool CreatedAt time.Time + // V3 S6 : révocation des tokens (bump au changement de password) et + // quota de stockage (garde-fou upload). + TokenVersion int + QuotaBytes int64 } // Users persiste les comptes utilisateurs (auth par login, cf. tranche identité). @@ -33,7 +37,8 @@ func (u *Users) Count() (int, error) { // (lowercase, unique). Absent → ErrNotFound. func (u *Users) GetByUsernameNormalized(normalized string) (*UserRow, error) { row := u.DB.QueryRow( - `SELECT id, username, username_normalized, password_hash, is_admin, created_at + `SELECT id, username, username_normalized, password_hash, is_admin, created_at, + token_version, storage_quota_bytes FROM users WHERE username_normalized = $1 AND deleted_at IS NULL`, normalized, @@ -48,7 +53,8 @@ func (u *Users) GetByUsernameNormalized(normalized string) (*UserRow, error) { // GetByID charge un compte actif par id. Absent → ErrNotFound. func (u *Users) GetByID(id string) (*UserRow, error) { row := u.DB.QueryRow( - `SELECT id, username, username_normalized, password_hash, is_admin, created_at + `SELECT id, username, username_normalized, password_hash, is_admin, created_at, + token_version, storage_quota_bytes FROM users WHERE id = $1 AND deleted_at IS NULL`, id, @@ -131,6 +137,27 @@ func (u *Users) MarkDeleted(id string) error { func scanUser(scan func(...any) error) (*UserRow, error) { var user UserRow - err := scan(&user.ID, &user.Username, &user.UsernameNormalized, &user.PasswordHash, &user.IsAdmin, &user.CreatedAt) + err := scan(&user.ID, &user.Username, &user.UsernameNormalized, &user.PasswordHash, &user.IsAdmin, &user.CreatedAt, &user.TokenVersion, &user.QuotaBytes) return &user, err } + +// BumpTokenVersion invalide tous les tokens émis (V3 S6) : le middleware +// rejette les tokens dont le claim `tv` diffère. Compte absent → ErrNotFound. +func (u *Users) BumpTokenVersion(id string) error { + result, err := u.DB.Exec( + `UPDATE users SET token_version = token_version + 1, updated_at = NOW() + WHERE id = $1 AND deleted_at IS NULL`, + id, + ) + if err != nil { + return err + } + affected, err := result.RowsAffected() + if err != nil { + return err + } + if affected == 0 { + return ErrNotFound + } + return nil +} diff --git a/backend/service/resources.go b/backend/service/resources.go index 715a20f..ed192cf 100644 --- a/backend/service/resources.go +++ b/backend/service/resources.go @@ -18,6 +18,10 @@ import ( // ErrFileTooLarge signals an upload above MaxFileSize. var ErrFileTooLarge = errors.New("file too large") +// ErrQuotaExceeded signals an upload that would overflow the account quota +// (V3 S6 A2). Handlers map it to 413 QUOTA_EXCEEDED (never 500). +var ErrQuotaExceeded = errors.New("storage quota exceeded") + // ErrInvalidUpload signals a rejected upload (display name or path component). // Handlers map it to 400 INVALID_REQUEST (never 500). var ErrInvalidUpload = errors.New("invalid upload name") @@ -343,6 +347,14 @@ func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID, if ferr != nil { return FileDTO{}, ferr } + } else { + // V3 S6 A2 : garde-fou quota sur les créations (les overwrites + // ciblées remplacent des octets existants — gain net ~nul, pas de + // check). Vérifié au header (rejet rapide) PUIS aux octets réels + // (vérité, le header peut mentir, cf. A2). + if err := s.checkQuotaFor(ownerID, file.Size); err != nil { + return FileDTO{}, err + } } written, err := copyMultipartAtomic(file, destDir, destPath, s.MaxFileSize) @@ -352,6 +364,14 @@ func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID, } return FileDTO{}, err } + if !targetExisting { + // Vérité aux octets réels (le header `file.Size` peut mentir) : + // dépassement → fichier supprimé + 413 (pas d'orphelin). + if err := s.checkQuotaFor(ownerID, written); err != nil { + _ = os.Remove(destPath) + return FileDTO{}, err + } + } mimeType := sanitizeMimeType(file.Header.Get("Content-Type")) var extPtr *string @@ -486,3 +506,48 @@ func toFileDTO(row repository.FileRow) FileDTO { UpdatedAt: row.UpdatedAt.UTC().Format(time.RFC3339), } } + +// UsageDTO serializes GET /users/me/usage (V3 S6 A2) : quota + empreinte, +// dont la corbeille (octets récupérables à la purge). +type UsageDTO struct { + UsedBytes int64 `json:"usedBytes"` + QuotaBytes int64 `json:"quotaBytes"` + FileCount int `json:"fileCount"` + TrashCount int `json:"trashCount"` + TrashedBytes int64 `json:"trashedBytes"` +} + +// Usage returns the account footprint (computed, never stored). +func (s *Resources) Usage(ownerID string) (UsageDTO, error) { + user, err := s.Repository.Users.GetByID(ownerID) + if err != nil { + return UsageDTO{}, err + } + usage, err := s.Repo.StorageUsage(ownerID) + if err != nil { + return UsageDTO{}, err + } + return UsageDTO{ + UsedBytes: usage.UsedBytes, QuotaBytes: user.QuotaBytes, + FileCount: usage.FileCount, TrashCount: usage.TrashCount, + TrashedBytes: usage.TrashedBytes, + }, nil +} + +// checkQuotaFor rejects a creation of incoming bytes that would overflow the +// account quota (V3 S6 A2). Compte absent → l'erreur remonte (jamais de +// défaut silencieux qui laisserait passer). +func (s *Resources) checkQuotaFor(ownerID string, incoming int64) error { + user, err := s.Repository.Users.GetByID(ownerID) + if err != nil { + return err + } + usage, err := s.Repo.StorageUsage(ownerID) + if err != nil { + return err + } + if usage.UsedBytes+incoming > user.QuotaBytes { + return ErrQuotaExceeded + } + return nil +} diff --git a/backend/service/sync.go b/backend/service/sync.go index e29202a..da5e4c3 100644 --- a/backend/service/sync.go +++ b/backend/service/sync.go @@ -53,10 +53,22 @@ type FailedOperation struct { Message string `json:"message"` } -// SyncResult is the outbox response: applied = index of the next op to send. +// ConflictInfo reports a last-writer-wins rename applied over a concurrent +// change (V3 S6 A4). Non-fatal : le batch continue, le client affiche +// « renommé ailleurs » avec le nom serveur gagnant. +type ConflictInfo struct { + OperationID string `json:"operation_id"` + ResourceID string `json:"resource_id"` + ServerName string `json:"serverName"` + ServerUpdatedAt int64 `json:"serverUpdatedAt"` +} + +// SyncResult is the outbox response: applied = index of the next op to send, +// conflicts = renames concurrents appliqués quand même (non-fataux, S6 A4). type SyncResult struct { - Applied int `json:"applied"` - Failed *FailedOperation `json:"failed,omitempty"` + Applied int `json:"applied"` + Failed *FailedOperation `json:"failed,omitempty"` + Conflicts []ConflictInfo `json:"conflicts,omitempty"` } type createResourcePayload struct { @@ -71,6 +83,11 @@ type createResourcePayload struct { type renamePayload struct { Name string `json:"name"` + // V3 S6 A4 : `updated_at` (ms epoch) vu par le client au moment du + // rename. Si la ressource a bougé depuis (concurrent), le rename + // s'applique quand même (last-writer-wins) mais est signalé en + // `conflicts` (transparence, pas de CRDT). + BaseUpdatedAt *int64 `json:"baseUpdatedAt"` } type movePayload struct { @@ -156,33 +173,39 @@ var errCycle = errors.New("cannot move a resource into its own subtree") // explicite avec code INTERNAL, jamais en erreur Go nue (500 nu) — le client // sait exactement où reprendre. func (s *Resources) ApplyBatch(userID, deviceID string, ops []SyncOperation) (SyncResult, error) { + // Conflits de rename (S6 A4) : non-fataux, collectés tout au long du + // batch et renvoyés avec le résultat (le batch continue). + var conflicts []ConflictInfo + fail := func(i int, op *SyncOperation, code, message string) (SyncResult, error) { + return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: code, Message: message}, Conflicts: conflicts}, nil + } for i := range ops { op := &ops[i] if err := validateSyncOp(op); err != nil { - return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INVALID_REQUEST", Message: err.Error()}}, nil + return fail(i, op, "INVALID_REQUEST", err.Error()) } claimed, err := s.Repository.Operations.Claim(deviceID, op.OperationID, op.Operation, derefString(op.RefType), nullableInt64(derefInt64(op.RefID)), derefString(op.ResourceID), op.Payload) if err != nil { // Faute client (clé ou payload malformé) → INVALID_REQUEST halt, // message statique sûr ; panne persistance → INTERNAL explicite. if errors.Is(err, repository.ErrInvalidOperationID) { - return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INVALID_REQUEST", Message: "operation_id must be 32 lowercase hex chars"}}, nil + return fail(i, op, "INVALID_REQUEST", "operation_id must be 32 lowercase hex chars") } if errors.Is(err, repository.ErrInvalidPayload) { - return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INVALID_REQUEST", Message: "invalid payload JSON"}}, nil + return fail(i, op, "INVALID_REQUEST", "invalid payload JSON") } log.Printf("sync: claim device=%s op=%s: %v", deviceID, op.OperationID, err) - return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INTERNAL", Message: "failed to persist operation state"}}, nil + return fail(i, op, "INTERNAL", "failed to persist operation state") } if !claimed { // Rejeu : même (device, op) déjà tracé — comparer (A9). stored, err := s.Repository.Operations.Get(deviceID, op.OperationID) if err != nil { log.Printf("sync: replay read device=%s op=%s: %v", deviceID, op.OperationID, err) - return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INTERNAL", Message: "failed to read operation state"}}, nil + return fail(i, op, "INTERNAL", "failed to read operation state") } if err := stored.MatchesReplay(op.Operation, derefString(op.ResourceID), op.Payload); err != nil { - return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INVALID_REQUEST", Message: "operation replayed with different payload"}}, nil + return fail(i, op, "INVALID_REQUEST", "operation replayed with different payload") } if stored.Status == repository.OpStatusApplied { continue // déjà appliquée à l'identique → skip idempotent @@ -190,16 +213,18 @@ func (s *Resources) ApplyBatch(userID, deviceID string, ops []SyncOperation) (Sy // Trace 'failed' à payload identique : la première tentative est // morte avant MarkApplied (crash) → on ré-applique (recovery). } - if err := s.applySyncOp(userID, deviceID, op); err != nil { + if conflict, err := s.applySyncOpWithConflict(userID, deviceID, op); err != nil { code, message := classifySyncError(err) - return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: code, Message: message}}, nil + return fail(i, op, code, message) + } else if conflict != nil { + conflicts = append(conflicts, *conflict) } if err := s.Repository.Operations.MarkApplied(deviceID, op.OperationID); err != nil { log.Printf("sync: promote device=%s op=%s: %v", deviceID, op.OperationID, err) - return SyncResult{Applied: i, Failed: &FailedOperation{OperationID: op.OperationID, Code: "INTERNAL", Message: "operation applied but trace update failed; safe to retry"}}, nil + return fail(i, op, "INTERNAL", "operation applied but trace update failed; safe to retry") } } - return SyncResult{Applied: len(ops)}, nil + return SyncResult{Applied: len(ops), Conflicts: conflicts}, nil } func validateSyncOp(op *SyncOperation) error { @@ -226,6 +251,48 @@ func validateSyncOp(op *SyncOperation) error { return nil } +// conflictToleranceMs absorbe le skew d'horloge client/serveur ET la +// troncation à la seconde des `updatedAt` RFC3339 lus par le client : un +// écart ≤ 2 s n'est pas un conflit (ex. create suivi d'un rename immédiat +// par le même device). Au-delà, quelqu'un d'autre a écrit entre-temps. +const conflictToleranceMs = 2000 + +// applySyncOpWithConflict applique une op et détecte les renames concurrents +// (S6 A4) : si `baseUpdatedAt` est fourni et que la ressource a bougé depuis +// (au-delà de la tolérance), le rename s'applique quand même (LWW) mais est +// signalé. Sans base (vieux clients) : aucun signalement, comportement V1. +func (s *Resources) applySyncOpWithConflict(ownerID, deviceID string, op *SyncOperation) (*ConflictInfo, error) { + var base *int64 + resID := derefString(op.ResourceID) + if op.Operation == OpUpdateMetadata { + var p renamePayload + if err := json.Unmarshal(op.Payload, &p); err == nil && p.BaseUpdatedAt != nil { + base = p.BaseUpdatedAt + } + } + var preMs int64 + havePre := false + if base != nil { + if _, ms, err := s.Repo.LiveNameAndUpdatedAt(resID); err == nil { + preMs, havePre = ms, true + } + } + if err := s.applySyncOp(ownerID, deviceID, op); err != nil { + return nil, err + } + if base != nil && havePre && preMs > *base+conflictToleranceMs { + name, ms, err := s.Repo.LiveNameAndUpdatedAt(resID) + if err != nil { + return nil, nil // renommé puis supprimé dans le même batch : rien à signaler. + } + return &ConflictInfo{ + OperationID: op.OperationID, ResourceID: resID, + ServerName: name, ServerUpdatedAt: ms, + }, nil + } + return nil, nil +} + func (s *Resources) applySyncOp(ownerID, deviceID string, op *SyncOperation) error { resourceID := derefString(op.ResourceID) switch op.Operation { diff --git a/backend/service/sync_conflicts_test.go b/backend/service/sync_conflicts_test.go new file mode 100644 index 0000000..18fb6be --- /dev/null +++ b/backend/service/sync_conflicts_test.go @@ -0,0 +1,83 @@ +package service + +import ( + "testing" + + "github.com/kazier/backend/repository" +) + +// TestRenameConflictReporting : un rename avec baseUpdatedAt périmée +// s'applique quand même (LWW) mais est signalé en conflicts[] (S6 A4) ; +// avec une base fraîche, aucun signalement. +func TestRenameConflictReporting(t *testing.T) { + s := newServiceStore(t) + userID := mustCreateUser(t, s.Repository, "conflict-user") + deviceA := mustRegisterDevice(t, s.Repository, "c0000000000000000000000000000001") + fileID := repository.NewID() + if err := s.Repository.Resources.InsertFile(userID, fileID, "origine.txt", "", 0, nil, nil); err != nil { + t.Fatalf("insert: %v", err) + } + + // Base fraîche : pas de conflit. + name, ms, err := s.Repository.Resources.LiveNameAndUpdatedAt(fileID) + if err != nil || name != "origine.txt" { + t.Fatalf("live: %q %d %v", name, ms, err) + } + res, err := s.ApplyBatch(userID, deviceA, []SyncOperation{ + syncOp(repository.NewID(), fileID, OpUpdateMetadata, "file", map[string]any{ + "name": "v2.txt", "baseUpdatedAt": ms, + }), + }) + if err != nil { + t.Fatalf("apply: %v", err) + } + if res.Applied != 1 || res.Failed != nil || len(res.Conflicts) != 0 { + t.Fatalf("rename frais doit être silencieux: %+v", res) + } + + // Base périmée (concurrent théorique entre-temps) : appliqué + signalé. + stale := ms - 60_000 + res, err = s.ApplyBatch(userID, deviceA, []SyncOperation{ + syncOp(repository.NewID(), fileID, OpUpdateMetadata, "file", map[string]any{ + "name": "v3.txt", "baseUpdatedAt": stale, + }), + }) + if err != nil { + t.Fatalf("apply: %v", err) + } + if res.Applied != 1 || res.Failed != nil { + t.Fatalf("rename concurrent doit s'appliquer (LWW): %+v", res) + } + if len(res.Conflicts) != 1 { + t.Fatalf("conflit manquant: %+v", res) + } + c := res.Conflicts[0] + if c.ResourceID != fileID || c.ServerName != "v3.txt" || c.ServerUpdatedAt <= 0 { + t.Fatalf("conflit inattendu: %+v", c) + } + + // Sans base (vieux client) : appliqué, jamais signalé. + res, err = s.ApplyBatch(userID, deviceA, []SyncOperation{ + syncOp(repository.NewID(), fileID, OpUpdateMetadata, "file", map[string]any{"name": "v4.txt"}), + }) + if err != nil { + t.Fatalf("apply: %v", err) + } + if res.Applied != 1 || res.Failed != nil || len(res.Conflicts) != 0 { + t.Fatalf("sans base : silencieux: %+v", res) + } + + // Tolérance 2 s : un écart d'1 s (skew/troncation) n'est pas un conflit. + _, nowMs, _ := s.Repository.Resources.LiveNameAndUpdatedAt(fileID) + res, err = s.ApplyBatch(userID, deviceA, []SyncOperation{ + syncOp(repository.NewID(), fileID, OpUpdateMetadata, "file", map[string]any{ + "name": "v5.txt", "baseUpdatedAt": nowMs - 1000, + }), + }) + if err != nil { + t.Fatalf("apply: %v", err) + } + if len(res.Conflicts) != 0 { + t.Fatalf("écart 1 s ne doit pas signaler: %+v", res) + } +} diff --git a/docs/api-v1.md b/docs/api-v1.md index 56fcadf..3cb9300 100644 --- a/docs/api-v1.md +++ b/docs/api-v1.md @@ -18,8 +18,8 @@ Références : `V2.md` (modèle cible), `mobile/services/db/` (conventions sync) - **User-first (V1 finale)** : le device s'enregistre d'abord (`POST /devices`) avec son identité **générée localement** (`device_user_id` 32-hex mobile) — **réponse `{ "deviceId" }` uniquement, sans token**. Puis le client appelle `POST /auth/login` (`username` + `password` + `device_id`) pour obtenir son token **paseto** v4-local. Requêtes suivantes : `Authorization: Bearer ` (toutes les routes **sauf `/health`, `/devices`, `/auth/login`**). - **Claims du token** : le **subject = `user_id`** (AUTORISE, clé de scoping de toutes les ressources) ; `device_id` est un **claim secondaire, porté mais NON autorisant seul** (idempotence outbox + jobs OCR). Résolu par middleware `RequireAuth` qui vérifie aussi que le compte existe toujours (`deleted_at IS NULL`). -- **TTL : 7 jours, sans refresh.** À expiration, le client re-logine (`POST /auth/login`). Le changement de mot de passe (`PATCH /users/me/password`) **n'invalide pas** les tokens déjà émis — limite V1 assumée (pas de liste de révocation) jusqu'à l'expiration. -- Au login, `devices.user_id` mémorise le **dernier user connecté** (INFORMATIF uniquement, jamais autorisant — recommande `POST /devices` → `POST /auth/login` pour un nouveau device, sans réutiliser le device d'un autre compte). +- **TTL : 7 jours, sans refresh.** À expiration, le client re-logine (`POST /auth/login`). **Révocation V3 (S6)** : `PATCH /users/me/password` bumpe `users.token_version` — tous les tokens antérieurs deviennent 401 (`token revoked`), y compris non expirés ; le client doit se reconnecter (le claim `tv` porte la version, les tokens pré-V3 sans `tv` valent 0 et survivent jusqu'au premier changement de mot de passe). +- Au login, `devices.user_id` mémorise le **dernier user connecté** (INFORMATIF uniquement, jamais autorisant — recommande `POST /devices` → `POST /auth/login` pour un nouveau device, sans réutiliser le device d'un autre compte). **Révocation V3 (S6 A1)** : `DELETE /devices/:id` supprime l'enregistrement (téléphone perdu) — avec `EnforceDeviceExists` (prod), les tokens du device deviennent 401 et son login est refusé ; seule une ré-inscription explicite (`POST /devices`) restaure l'accès. `GET /devices` liste les devices du compte (dernier login = ce compte). - **Identifiants** : `resource_id`, `device_user_id`, `user_id`, `is_admin`… = **TEXT opaque 32-hex minuscule**, `^[0-9a-f]{32}$`. Le mobile génère toujours `lower(hex(randomblob(16)))` ; le serveur stocke **tel quel**, sans conversion UUID (cf. note V2.md). Contrainte serveur : `CHECK (col ~ '^[0-9a-f]{32}$')` sur toutes les colonnes id + FK. - **Usernames** : `username` = forme affichée ; l'unicité et la résolution portent sur `username_normalized` (lowercase + trim). Résolution d'un destinataire : `GET /users/resolve?username=` (exact uniquement, jamais de listing ni de préfixe — pas d'énumération de comptes). - **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. @@ -34,7 +34,10 @@ Références : `V2.md` (modèle cible), `mobile/services/db/` (conventions sync) | POST | `/auth/login` | `{ "username", "password", "device_id" }` | `{ "token", "expires_at" (ms), "user": { "id", "username", "is_admin" } }` | `UNAUTHORIZED` / `INVALID_DEVICE_ID` | | GET | `/shares/links/:token` | — (public, sans auth) | `{ "token", "resource_id", "resourceType", "name", "access", "expiresAt" }` | `NOT_FOUND` (inconnu/révoqué/expiré) | | GET | `/users/resolve` | query `username` (obligatoire) | `{ "id", "username" }` | `NOT_FOUND` | -| PATCH | `/users/me/password` | `{ "current_password", "new_password" }` | `{ "id" }` | `INVALID_PASSWORD` (403) | +| PATCH | `/users/me/password` | `{ "current_password", "new_password" }` | `{ "id" }` (+ révocation globale des tokens) | `INVALID_PASSWORD` (403) | +| GET | `/users/me/usage` | — | `{ usedBytes, quotaBytes, fileCount, trashCount, trashedBytes }` (calculé, corbeille détaillée) | — | +| GET | `/devices` | — | `[{ deviceId, lastSeenAt }]` (dernier login = ce compte) | — | +| DELETE | `/devices/:id` | — (téléphone perdu, A1) | `{ "id" }` | `NOT_FOUND` (absent/autre compte — pas d'énumération) | | GET | `/files` | query `folderId?`, `page?`, `pageSize?`, `sort?` | `FileDto[]` (+ `meta`) | — | | GET | `/files/:id` | — | `FileDto` | `NOT_FOUND` | | GET | `/files/:id/content` | — (binaire brut, hors enveloppe `{data}` ; `Range` supporté) | octets physiques (`Content-Type` du fichier, `Content-Disposition: inline`) — streaming lecture seule, jamais persisté côté client | `NOT_FOUND` (invisible OU metadata-only jamais uploadé — indistinguables) | @@ -128,11 +131,11 @@ type FileOcr = { text: string; updatedAt?: string | null }; - `operation` ∈ `create_resource | update_metadata | delete_resource | move_resource | share | revoke_share | update_share | create_link | revoke_link | report_bytes | trash_resource | restore_resource | purge_resource | correct_facts` (cf. `PendingOperationType` mobile). - **Identifiants** : `operation_id` est un **TEXT 32-hex** généré par le client (`^[0-9a-f]{32}$`, CHECK-enforced depuis la migration `000008`), distinct de `resource_id`. L'idempotence outbox reste **par device** : `UNIQUE(device_id, operation_id)` (la réinscription d'un device avec un login différent ne réutilise pas l'historique outbox d'un autre compte). Pour chaque op : si déjà traitée → **no-op** (comptée comme appliquée, les doublons arrivent à cause du backoff/retry). Sinon appliquée si valide. - **Ordre** : les opérations sont appliquées **séquentiellement**, dans l'ordre du batch. Le serveur **s'arrête à la première erreur non-idempotente** et renvoie l'index atteint — le client reprend à cet index. -- Réponse : `2xx` avec `{ "applied": int, "failed": { "operation_id": "…32-hex", "code": string, "message": string } | null }` (`applied` = index de la prochaine op à envoyer). +- Réponse : `2xx` avec `{ "applied": int, "failed": { "operation_id": "…32-hex", "code": string, "message": string } | null, "conflicts"?: [{ "operation_id", "resource_id", "serverName", "serverUpdatedAt" }] }` (`applied` = index de la prochaine op à envoyer ; `conflicts` = renames LWW appliqués malgré une `baseUpdatedAt` périmée — non-fataux, le batch continue). - Côté client, le `pushStatus` (pending/synced/failed) des shares/share_links est **dérivé** de l'état des opérations de l'outbox ; **dead-letter immédiat** sur erreur 4xx non-idempotente (`failed`, non resélectionné ; `attempts` reste un compteur diagnostic, pas un seuil) — seul le transitoire (`NETWORK_ERROR`/5xx) est rejoué avec backoff. **Côté serveur, les ops partage créent un état réel** (tables `shares`/`share_links`, migration `000009`) — l'outbox est le seul chemin d'écriture des droits. - Sémantique d'application (côté serveur) : - `create_resource` : crée la ressource ; **déjà présente → no-op** (rejeu idempotent). `payload.name` obligatoire ; `payload.parentResourceId` (32-hex, optionnel) = dossier parent — absent → racine. **Parent inexistant → `NOT_FOUND`** (cohérent avec `move_resource`). Ordre garanti par construction client : le walk SAF émet les `create` des dossiers (ordre préfixe) avant ceux des fichiers, dans la même transaction Room → `id ASC` = parent avant enfant. `payload.scanSessionId` (32-hex, optionnel, V3 S5) = session de scan opaque — le serveur en déduit les arêtes `same_scan` (même session, même compte) ; format invalide → `INVALID_REQUEST`. - - `update_metadata` : ressource absente → **no-op** (état terminal atteint) ; **ressource partagée : nécessite `editor+`** (§6.2) — sinon `NOT_FOUND` (une ressource visible mais sans droit de mutation n'est pas renommée) ; une ressource sans relation applicable (ni owner, ni grant) reste un no-op (pas d'énumération). `move_resource` / `delete_resource` restent **owner-only** (scoping par `user_id`, les ops d'un non-owner sont des no-op). + - `update_metadata` : ressource absente → **no-op** (état terminal atteint) ; **ressource partagée : nécessite `editor+`** (§6.2) — sinon `NOT_FOUND` (une ressource visible mais sans droit de mutation n'est pas renommée) ; une ressource sans relation applicable (ni owner, ni grant) reste un no-op (pas d'énumération). `payload = { "name", "baseUpdatedAt"? }` (V3 S6 A4 : `updated_at` ms vu par le client — périmé au-delà de 2 s de tolérance → rename appliqué quand même + signalé en `conflicts`, transparence sans CRDT). `move_resource` / `delete_resource` restent **owner-only** (scoping par `user_id`, les ops d'un non-owner sont des no-op). - `delete_resource` : **legacy → mappé vers `trash_resource`** (corbeille, restaurable, même idempotence : absent/déjà trashé = succès, vivant d'autrui = `NOT_FOUND` halt). - **Corbeille V3** (`trash_resource` / `restore_resource` / `purge_resource`, owner-only) : `trash` pose `deleted_at` sur la ressource **et son subtree** (dossier → contenu) ; `restore` lève le flag sur la ressource, son subtree **et sa chaîne d'ancêtres** (un fichier restauré dont le dossier est encore trashé resterait injoignable) ; `purge` détruit lignes + versions + octets. Sémantique : absent → no-op (`trash`/`restore`/`purge`), vivant d'autrui → `NOT_FOUND` halt, `restore` d'un live → no-op succès. Une ressource trashée reste `NOT_FOUND` en lecture normale, visible seulement via `GET /trash`. Passe serveur : destruction définitive après 30j (`TrashRetention`). - **Corrections V3** (`correct_facts`, editor+) : `payload = { "facts": [{ "factType", "valueText"?, "valueNum"?, "valueDate"? (ISO `YYYY-MM-DD`), "confidence"? }] }` — remplace le jeu `user` complet (full-replace, jamais de diff ; jeu vide = efface les corrections, l'auto survit). Mêmes gardes qu'`update_metadata` (viewer- → `NOT_FOUND` halt) ; fait invalide (type inconnu, date non ISO, sans valeur) → `INVALID_REQUEST` avec arrêt du batch. Le client corrige en un tap depuis la fiche document et pousse dans la même transaction Room que l'écriture optimiste. @@ -183,8 +186,8 @@ type ResourcePermission = { ## 7. Codes d'erreur courants -- Authentification : `UNAUTHORIZED` (**401** — token manquant/invalide/expiré, compte supprimé, OU identifiants de login erronés : **indistinguables par design**, même code+message), `INVALID_DEVICE_ID` (**400** — device non enregistré au login). -- Ressources : `NOT_FOUND` (404), `NAME_CONFLICT` (409 — même nom dans le même parent, cf. `UNIQUE(parent_id, name)`, **ou à la racine**, index partiel `(user_id, name) WHERE parent_id IS NULL`), `FILE_TOO_LARGE` (413), `INVALID_PASSWORD` (403 sur `PATCH /users/me/password`). +- Authentification : `UNAUTHORIZED` (**401** — token manquant/invalide/expiré/**révoqué** (mot de passe changé, device révoqué), compte supprimé, OU identifiants de login erronés : **indistinguables par design**, même code+message), `INVALID_DEVICE_ID` (**400** — device non enregistré au login). +- Ressources : `NOT_FOUND` (404), `NAME_CONFLICT` (409 — même nom dans le même parent, cf. `UNIQUE(parent_id, name)`, **ou à la racine**, index partiel `(user_id, name) WHERE parent_id IS NULL`), `FILE_TOO_LARGE` (413), `QUOTA_EXCEEDED` (413 — créations au-delà de `storage_quota_bytes`, 10 Go par défaut ; overwrites ciblées exemptées, gain net ~nul), `INVALID_PASSWORD` (403 sur `PATCH /users/me/password`). - Partage : `GRANTEE_NOT_FOUND` (404 — grantee inexistant sur une op share), `GROUP_NOT_FOUND` (404 — groupe inexistant sur une op share ou un endpoint membres), `NOT_FOUND` (404 — ressource non possédée sur une op share : scoping, pas d'énumération). - Client-only : `NETWORK_ERROR`, `INVALID_RESPONSE` (2xx mais corps d'enveloppe invalide), `HTTP_` (fallback). Statut `SERVICE_UNAVAILABLE` (503) si le backend n'est pas initialisé. - **V1 finale : toutes les routes sont réelles** (pas de 501 restant). @@ -193,4 +196,4 @@ type ResourcePermission = { - `POST /auth/login` : le **device doit exister** (`POST /devices` d'abord, sinon 400 `INVALID_DEVICE_ID`). La vérification du mot de passe est **constant-time** (`argon2id`, comparaison `subtle`) et le délai est **égalisé** entre « username inconnu » et « mauvais mot de passe » (vérification contre un dummy-hash) — les deux produisent exactement la même réponse 401. - `GET /users/resolve` : résolution **exacte** du `username_normalized` uniquement ; ne renvoie **jamais** `email` ni `is_admin` (ni listing, ni préfixe → pas d'énumération de comptes). -- `PATCH /users/me/password` : exige `current_password` (mauvais curl → 403). Minimum 8 caractères. **Limite V1** : tokens émis non révoqués (validité 7 j), et `is_admin`/`ADMIN_*` non modifiables par API. \ No newline at end of file +- `PATCH /users/me/password` : exige `current_password` (mauvais curl → 403). Minimum 8 caractères. **V3 S6** : bumpe `token_version` (tous les tokens antérieurs révoqués — le client se reconnecte) ; `is_admin`/`ADMIN_*` non modifiables par API. \ No newline at end of file diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/ApiClient.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/ApiClient.kt index 49b4180..02aa2ab 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/ApiClient.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/ApiClient.kt @@ -30,11 +30,13 @@ import com.kazier.mobile.data.remote.dto.SyncOpDto import com.kazier.mobile.data.remote.dto.SyncOpsRequest import com.kazier.mobile.data.remote.dto.SyncOpsResult import com.kazier.mobile.data.remote.dto.CorrectFactsDto +import com.kazier.mobile.data.remote.dto.DeviceDto import com.kazier.mobile.data.remote.dto.DuplicateGroupDto import com.kazier.mobile.data.remote.dto.FactDto import com.kazier.mobile.data.remote.dto.RelationDto import com.kazier.mobile.data.remote.dto.RelationVerdictDto import com.kazier.mobile.data.remote.dto.TrashDto +import com.kazier.mobile.data.remote.dto.UsageDto import com.kazier.mobile.data.remote.dto.VersionDto import kotlin.coroutines.cancellation.CancellationException import okhttp3.MultipartBody @@ -190,6 +192,18 @@ class ApiClient @Inject constructor( suspend fun listDuplicates(): List = unwrap({ apiService.listDuplicates() }) + /** Devices du compte — `GET /devices`. */ + suspend fun listDevices(): List = + unwrap({ apiService.listDevices() }) + + /** Révoque un device — `DELETE /devices/:id`. */ + suspend fun revokeDevice(deviceId: String): String = + unwrap({ apiService.revokeDevice(deviceId) }).id + + /** Empreinte du compte — `GET /users/me/usage`. */ + suspend fun getUsage(): UsageDto = + unwrap({ apiService.getUsage() }) + /** Recherche serveur paginée — `GET /files/search?q=…` (+ `meta`). */ suspend fun searchFilesPaged( query: String, diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/ApiService.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/ApiService.kt index 9de7e08..c865e5a 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/ApiService.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/ApiService.kt @@ -23,11 +23,13 @@ import com.kazier.mobile.data.remote.dto.ShareLinkDto import com.kazier.mobile.data.remote.dto.SyncOpsRequest import com.kazier.mobile.data.remote.dto.SyncOpsResult import com.kazier.mobile.data.remote.dto.CorrectFactsDto +import com.kazier.mobile.data.remote.dto.DeviceDto import com.kazier.mobile.data.remote.dto.DuplicateGroupDto import com.kazier.mobile.data.remote.dto.FactDto import com.kazier.mobile.data.remote.dto.RelationDto import com.kazier.mobile.data.remote.dto.RelationVerdictDto import com.kazier.mobile.data.remote.dto.TrashDto +import com.kazier.mobile.data.remote.dto.UsageDto import com.kazier.mobile.data.remote.dto.VersionDto import okhttp3.MultipartBody import okhttp3.RequestBody @@ -223,6 +225,20 @@ interface ApiService { @GET("duplicates") suspend fun listDuplicates(): Response>> + /** Devices du compte (`GET /devices`, dernier login = ce compte). */ + @GET("devices") + suspend fun listDevices(): Response>> + + /** Révoque un device (`DELETE /devices/:id`, A1 — téléphone perdu). */ + @DELETE("devices/{id}") + suspend fun revokeDevice( + @Path("id") deviceId: String, + ): Response> + + /** Empreinte du compte (`GET /users/me/usage`, calculée serveur). */ + @GET("users/me/usage") + suspend fun getUsage(): Response> + /** * Recherche serveur (`GET /files/search?q=…`, paginé `meta`). Non consommée * en V1 (recherche 100 % locale via Room) — exposée pour parité contrat. diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/dto/Dtos.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/dto/Dtos.kt index 7cd1766..bf205ce 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/dto/Dtos.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/remote/dto/Dtos.kt @@ -191,6 +191,19 @@ data class SyncOpsRequest( data class SyncOpsResult( @Json(name = "applied") val applied: Int, @Json(name = "failed") val failed: SyncFailedDto? = null, + /** + * Renames LWW appliqués malgré une base périmée (V3 S6 A4) — non-fataux, + * le batch continue. Absent (vieux serveur) = liste vide. + */ + @Json(name = "conflicts") val conflicts: List? = null, +) + +/** Rename concurrent appliqué quand même (transparence, pas de CRDT). */ +data class SyncConflictDto( + @Json(name = "operation_id") val operationId: String, + @Json(name = "resource_id") val resourceId: String, + @Json(name = "serverName") val serverName: String = "", + @Json(name = "serverUpdatedAt") val serverUpdatedAt: Long = 0L, ) /** Première erreur non-idempotente du batch (arrêt du serveur). */ @@ -335,4 +348,25 @@ data class DuplicateGroupDto( @Json(name = "totalBytes") val totalBytes: Long = 0L, @Json(name = "reclaimableBytes") val reclaimableBytes: Long = 0L, @Json(name = "files") val files: List = emptyList(), +) + +/** + * Device du compte `GET /devices` (V3 S6 A1) — dernier login = ce compte. + * `lastSeenAt` ms epoch (null si jamais revu depuis l'enregistrement). + */ +data class DeviceDto( + @Json(name = "deviceId") val deviceId: String, + @Json(name = "lastSeenAt") val lastSeenAt: Long? = null, +) + +/** + * Empreinte du compte `GET /users/me/usage` (V3 S6 A2) — calculée serveur, + * corbeille détaillée (octets récupérables à la purge). + */ +data class UsageDto( + @Json(name = "usedBytes") val usedBytes: Long = 0L, + @Json(name = "quotaBytes") val quotaBytes: Long = 0L, + @Json(name = "fileCount") val fileCount: Int = 0, + @Json(name = "trashCount") val trashCount: Int = 0, + @Json(name = "trashedBytes") val trashedBytes: Long = 0L, ) \ No newline at end of file diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/DevicesRepository.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/DevicesRepository.kt new file mode 100644 index 0000000..79b4e60 --- /dev/null +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/DevicesRepository.kt @@ -0,0 +1,48 @@ +package com.kazier.mobile.data.repository + +import com.kazier.mobile.data.remote.ApiClient +import com.kazier.mobile.data.remote.dto.DeviceDto +import com.kazier.mobile.data.remote.dto.UsageDto +import com.kazier.mobile.domain.DeviceIdentity +import javax.inject.Inject +import javax.inject.Singleton + +/** + * Appareils + empreinte du compte (V3 S6 A1/A2). + * + * - `listDevices` : devices dont le dernier login est ce compte ; + * `isCurrent` repère ce téléphone (via `DeviceIdentity`) — le bouton + * révoquer n'apparaît jamais dessus (pas de suicide) ; + * - `revoke` : `DELETE /devices/:id` (téléphone perdu) — avec + * `EnforceDeviceExists`, ses tokens deviennent 401 ; + * - `usage` : `GET /users/me/usage` (quota + corbeille détaillée). + */ +@Singleton +class DevicesRepository @Inject constructor( + private val apiClient: ApiClient, + private val deviceIdentity: DeviceIdentity, +) { + + data class DeviceUi( + val deviceId: String, + val lastSeenAt: Long?, + val isCurrent: Boolean, + ) + + suspend fun listDevices(): List { + val current = runCatching { deviceIdentity.getOrCreate() }.getOrNull() + return apiClient.listDevices().map { dto: DeviceDto -> + DeviceUi( + deviceId = dto.deviceId, + lastSeenAt = dto.lastSeenAt, + isCurrent = current != null && dto.deviceId == current, + ) + } + } + + suspend fun revoke(deviceId: String) { + apiClient.revokeDevice(deviceId) + } + + suspend fun usage(): UsageDto = apiClient.getUsage() +} diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/OutboxRepository.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/OutboxRepository.kt index f6ccd16..2ad6e54 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/OutboxRepository.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/repository/OutboxRepository.kt @@ -185,19 +185,25 @@ class OutboxRepository @Inject constructor( ) /** - * 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. + * Raccourci `update_metadata` — payload `{ name, baseUpdatedAt? }` + * (rename d'une ressource partagée, `editor+`, docs/api-v1.md §6.1). + * `baseUpdatedAt` (ms epoch, V3 S6 A4) = `updated_at` vu par le client : + * périmé au-delà de 2 s de tolérance → rename appliqué quand même (LWW) + * mais signalé en `conflicts` (« renommé ailleurs »). */ suspend fun enqueueUpdateMetadata( resourceId: String, resourceType: String, name: String, + baseUpdatedAt: Long? = null, ): String = enqueue( operation = PendingOperationType.UPDATE_METADATA, resourceId = resourceId, resourceType = resourceType, - payload = mapOf("name" to name), + payload = buildMap { + put("name", name) + baseUpdatedAt?.let { put("baseUpdatedAt", it) } + }, ) /** diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/domain/PrefKeys.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/domain/PrefKeys.kt index 4a875d4..cfc83b4 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/domain/PrefKeys.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/domain/PrefKeys.kt @@ -12,4 +12,6 @@ object PrefKeys { const val PERMISSIONS_CACHED_AT = "permissions_cached_at" /** Règle de rétention locale V2-5 : `all` | `last_months:N`. */ const val RETENTION_RULE = "retention_rule" + /** Conflits de rename LWW (S6 A4) : JSON `[{operationId,…}]`, max 10. */ + const val SYNC_CONFLICTS = "sync_conflicts" } \ No newline at end of file diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/domain/SyncConflictStore.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/domain/SyncConflictStore.kt new file mode 100644 index 0000000..87ec2ac --- /dev/null +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/domain/SyncConflictStore.kt @@ -0,0 +1,70 @@ +package com.kazier.mobile.domain + +import com.squareup.moshi.JsonAdapter +import com.squareup.moshi.Moshi +import com.squareup.moshi.Types +import com.kazier.mobile.data.local.dao.UserPreferenceDao +import com.kazier.mobile.data.local.entity.UserPreferenceEntity +import javax.inject.Inject +import javax.inject.Singleton +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow + +/** + * Conflit de rename LWW signalé par le serveur (V3 S6 A4) : un + * `update_metadata` appliqué malgré une `baseUpdatedAt` périmée — « renommé + * ailleurs », nom serveur gagnant. Persisté en `user_preferences` + * (JSON, max 10, dédupliqué par `operationId`), exposé en [StateFlow] pour + * la « liste des sync », effaçable en un tap. + */ +data class SyncConflict( + val operationId: String, + val resourceId: String, + val serverName: String, + val serverUpdatedAt: Long, + val seenAt: Long, +) + +@Singleton +class SyncConflictStore @Inject constructor( + private val userPreferenceDao: UserPreferenceDao, + moshi: Moshi, +) { + + private val adapter: JsonAdapter> = moshi.adapter( + Types.newParameterizedType(List::class.java, SyncConflict::class.java), + ) + + private val _conflicts = MutableStateFlow>(emptyList()) + val conflicts: StateFlow> = _conflicts.asStateFlow() + + suspend fun load() { + val raw = userPreferenceDao.getValue(PrefKeys.SYNC_CONFLICTS) ?: return + _conflicts.value = runCatching { adapter.fromJson(raw).orEmpty() }.getOrDefault(emptyList()) + } + + suspend fun addAll(incoming: List) { + if (incoming.isEmpty()) return + val merged = (incoming + _conflicts.value) + .distinctBy { it.operationId } + .take(MAX_CONFLICTS) + _conflicts.value = merged + persist(merged) + } + + suspend fun clear() { + _conflicts.value = emptyList() + userPreferenceDao.delete(PrefKeys.SYNC_CONFLICTS) + } + + private suspend fun persist(conflicts: List) { + userPreferenceDao.upsert( + UserPreferenceEntity(PrefKeys.SYNC_CONFLICTS, adapter.toJson(conflicts), System.currentTimeMillis()), + ) + } + + companion object { + private const val MAX_CONFLICTS = 10 + } +} diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/OutboxSyncWorker.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/OutboxSyncWorker.kt index 43fff7f..e6b42ea 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/OutboxSyncWorker.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/OutboxSyncWorker.kt @@ -20,6 +20,8 @@ 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.PendingOperationType +import com.kazier.mobile.domain.SyncConflict +import com.kazier.mobile.domain.SyncConflictStore import com.kazier.mobile.data.remote.ApiClient import com.kazier.mobile.data.remote.ApiException import com.kazier.mobile.data.remote.dto.SyncOpDto @@ -96,6 +98,7 @@ class OutboxSyncWorker @AssistedInject constructor( private val fileDao: FileDao, private val folderDao: FolderDao, private val tokenProvider: TokenProvider, + private val conflictStore: SyncConflictStore, moshi: Moshi, ) : CoroutineWorker(appContext, workerParams) { @@ -151,6 +154,23 @@ class OutboxSyncWorker @AssistedInject constructor( } val now = System.currentTimeMillis() + // Conflits de rename LWW (S6 A4) : non-fataux, persistés pour la + // « liste des sync » (« renommé ailleurs », nom serveur gagnant). + result.conflicts.orEmpty().takeIf { it.isNotEmpty() }?.let { batchConflicts -> + runCatching { + conflictStore.addAll( + batchConflicts.map { + SyncConflict( + operationId = it.operationId, + resourceId = it.resourceId, + serverName = it.serverName, + serverUpdatedAt = it.serverUpdatedAt, + seenAt = now, + ) + }, + ) + }.onFailure { e -> Timber.w(e, "outbox: conflits non persistés") } + } // Garde C7 : `applied` incohérent → clamp, jamais de crash. val appliedCount = result.applied.coerceIn(0, pending.size) if (appliedCount != result.applied) { diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/SyncViewModel.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/SyncViewModel.kt index 960a2be..c127dbf 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/SyncViewModel.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/SyncViewModel.kt @@ -12,6 +12,8 @@ import com.kazier.mobile.data.repository.FolderRepository import com.kazier.mobile.data.repository.SaveFolderInput import com.kazier.mobile.data.repository.ShareRepository import com.kazier.mobile.data.repository.TrashRepository +import com.kazier.mobile.domain.SyncConflict +import com.kazier.mobile.domain.SyncConflictStore import com.kazier.mobile.features.ocr.OcrAutoWorker import com.kazier.mobile.features.saf.FileDeleter import com.kazier.mobile.features.saf.FolderDeleter @@ -53,6 +55,7 @@ class SyncViewModel @Inject constructor( private val pendingOperationDao: PendingOperationDao, private val shareRepository: ShareRepository, private val trashRepository: TrashRepository, + private val conflictStore: SyncConflictStore, private val fileDeleter: FileDeleter, private val folderDeleter: FolderDeleter, @ApplicationContext private val appContext: Context, @@ -75,6 +78,8 @@ class SyncViewModel @Inject constructor( val failed: Int = 0, /** Dernières opérations (tous statuts) — « liste des sync ». */ val operations: List = emptyList(), + /** Renames LWW concurrents (S6 A4) — « renommé ailleurs ». */ + val conflicts: List = emptyList(), ) private val _importState = MutableStateFlow(ImportState()) @@ -88,7 +93,8 @@ class SyncViewModel @Inject constructor( WorkManager.getInstance(appContext).getWorkInfosForUniqueWorkFlow(OutboxSyncWorker.NAME), pendingOperationDao.observePendingCount(), pendingOperationDao.observeRecent(RECENT_LIMIT), - ) { walking, workInfos, pending, operations -> + conflictStore.conflicts, + ) { walking, workInfos, pending, operations, conflicts -> // RUNNING = drain en cours ; ENQUEUED = planifié (attente réseau/backoff). val draining = workInfos.any { it.state == WorkInfo.State.RUNNING || it.state == WorkInfo.State.ENQUEUED } SyncStatus( @@ -96,12 +102,22 @@ class SyncViewModel @Inject constructor( pending = pending, failed = operations.count { it.status == PendingOpStatus.FAILED }, operations = operations, + conflicts = conflicts, ) }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), SyncStatus()) + /** Efface les conflits affichés (lus et assumés). */ + fun clearConflicts() { + viewModelScope.launch { + runCatching { conflictStore.clear() } + } + } + /** Démarre la boucle une seule fois (idempotent). */ fun ensureStarted() { if (loopJob?.isActive == true) return + // Conflits persistés (S6 A4) : chargés pour la « liste des sync ». + viewModelScope.launch { runCatching { conflictStore.load() } } // Rétention auto V2-5 : passe quotidienne périodique (KEEP). RetentionWorker.enqueuePeriodic(appContext) loopJob = viewModelScope.launch { diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/components/HeaderStatusAction.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/components/HeaderStatusAction.kt index 4ca6a68..4f2f491 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/components/HeaderStatusAction.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/components/HeaderStatusAction.kt @@ -175,6 +175,7 @@ fun HeaderStatusAction( SyncOperationsDialog( status = syncStatus, onDismiss = { showQueue = false }, + onClearConflicts = syncViewModel::clearConflicts, ) } } diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/components/SyncOperationsDialog.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/components/SyncOperationsDialog.kt index 4a3d32c..3132add 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/components/SyncOperationsDialog.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/components/SyncOperationsDialog.kt @@ -27,6 +27,7 @@ import androidx.compose.ui.unit.dp import com.kazier.mobile.R import com.kazier.mobile.data.local.entity.PendingOpStatus import com.kazier.mobile.data.local.entity.PendingOperationEntity +import com.kazier.mobile.domain.SyncConflict import com.kazier.mobile.features.sync.SyncViewModel import com.kazier.mobile.ui.theme.ErrorDark import com.kazier.mobile.ui.theme.ErrorLight @@ -38,12 +39,14 @@ import com.kazier.mobile.ui.theme.SyncingLight /** * Dialogue « liste des sync » : dernières opérations de l'outbox (tous statuts), - * avec un résumé (en attente / échouées) en tête de liste. + * avec un résumé (en attente / échouées) en tête de liste — plus les renames + * concurrents LWW (S6 A4, « renommé ailleurs », effaçables). */ @Composable internal fun SyncOperationsDialog( status: SyncViewModel.SyncStatus, onDismiss: () -> Unit, + onClearConflicts: () -> Unit = {}, ) { AlertDialog( onDismissRequest = onDismiss, @@ -51,6 +54,12 @@ internal fun SyncOperationsDialog( text = { Column { SyncListSummary(status) + if (status.conflicts.isNotEmpty()) { + ConflictsSection( + conflicts = status.conflicts, + onClear = onClearConflicts, + ) + } if (status.operations.isEmpty()) { Text( text = stringResource(R.string.sync_list_empty), @@ -158,4 +167,57 @@ private fun operationLabel(operation: String): String = when (operation) { "delete_resource" -> stringResource(R.string.sync_op_delete) "update_metadata" -> stringResource(R.string.sync_op_update) else -> operation +} + +/** + * Renames concurrents LWW (S6 A4) : nom serveur gagnant + effacement en un + * tap (lus et assumés). La liste est courte (max 10, persistée). + */ +@Composable +private fun ConflictsSection( + conflicts: List, + onClear: () -> Unit, +) { + Column(modifier = Modifier.padding(bottom = 8.dp)) { + Row( + modifier = Modifier.fillMaxWidth(), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(8.dp), + ) { + Text( + text = stringResource(R.string.sync_conflicts_title, conflicts.size), + style = MaterialTheme.typography.bodyMedium, + fontWeight = FontWeight.SemiBold, + modifier = Modifier.weight(1f), + ) + TextButton(onClick = onClear) { + Text(stringResource(R.string.sync_conflicts_clear)) + } + } + LazyColumn( + modifier = Modifier + .fillMaxWidth() + .heightIn(max = KazierDimens.DialogListMaxHeight / 2), + verticalArrangement = Arrangement.spacedBy(2.dp), + ) { + items(conflicts, key = { it.operationId }) { conflict -> + Column(modifier = Modifier.padding(vertical = 4.dp)) { + Text( + text = stringResource( + R.string.sync_conflict_renamed, + conflict.serverName, + ), + style = MaterialTheme.typography.bodyMedium, + fontWeight = FontWeight.Medium, + ) + Text( + text = android.text.format.DateUtils + .getRelativeTimeSpanString(conflict.serverUpdatedAt).toString(), + style = MaterialTheme.typography.labelSmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } + } + } } \ No newline at end of file diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/dashboard/DashboardScreen.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/dashboard/DashboardScreen.kt index 878e8d0..1679dee 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/dashboard/DashboardScreen.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/dashboard/DashboardScreen.kt @@ -11,11 +11,14 @@ import androidx.compose.foundation.layout.size import androidx.compose.material.icons.Icons import androidx.compose.material.icons.filled.CheckCircle import androidx.compose.material.icons.filled.DocumentScanner +import androidx.compose.material.icons.filled.Group import androidx.compose.material.icons.filled.Sync +import androidx.compose.material3.Button import androidx.compose.material3.CircularProgressIndicator import androidx.compose.material3.ExperimentalMaterial3Api import androidx.compose.material3.Icon import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.OutlinedTextField import androidx.compose.material3.Scaffold import androidx.compose.material3.SmallFloatingActionButton import androidx.compose.material3.Text @@ -60,10 +63,15 @@ fun DashboardScreen( ) { val connectionStatus by connectionStatusViewModel.status.collectAsStateWithLifecycle() val unprocessed by viewModel.unprocessedCount.collectAsStateWithLifecycle() + val groupCount by viewModel.groupCount.collectAsStateWithLifecycle() + val creatingCircle by viewModel.creatingCircle.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) + // Onboarding foyer B5 : en ligne, aucun cercle → proposition « Famille ». + val showFamilyCard = !isLocal && + connectionStatus == ServerConnectionStatus.Online && groupCount == 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). @@ -131,6 +139,13 @@ fun DashboardScreen( modifier = Modifier.fillMaxWidth(), ) } + if (showFamilyCard) { + FamilyCircleCard( + creating = creatingCircle, + onCreate = { viewModel.createFamilyCircle(it) }, + modifier = Modifier.fillMaxWidth(), + ) + } if (showSyncCard) { SyncSummaryCard( status = syncStatus, @@ -229,3 +244,75 @@ private fun SyncSummaryCard( } } } + +/** + * Onboarding foyer B5 : aucun cercle et en ligne → proposition de créer le + * cercle « Famille » en un tap (nom éditable, pré-rempli). Disparaît après + * création (compteur rechargé) ou hors-ligne. + */ +@Composable +private fun FamilyCircleCard( + creating: Boolean, + onCreate: (String) -> Unit, + modifier: Modifier = Modifier, +) { + var name by rememberSaveable { mutableStateOf("") } + // Pré-remplissage paresseux une fois (pas d'écrasement de la saisie). + val defaultName = stringResource(R.string.family_default_name) + LaunchedEffect(defaultName) { + if (name.isBlank()) name = defaultName + } + KazierCard(modifier = modifier) { + Column( + modifier = Modifier.padding(20.dp), + verticalArrangement = Arrangement.spacedBy(12.dp), + ) { + Row( + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(16.dp), + ) { + Icon( + imageVector = Icons.Filled.Group, + contentDescription = null, + tint = MaterialTheme.colorScheme.primary, + modifier = Modifier.size(28.dp), + ) + Column(modifier = Modifier.weight(1f)) { + Text( + text = stringResource(R.string.family_title), + style = MaterialTheme.typography.titleMedium, + ) + Text( + text = stringResource(R.string.family_hint), + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + modifier = Modifier.padding(top = 4.dp), + ) + } + } + Row( + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(8.dp), + ) { + OutlinedTextField( + value = name, + onValueChange = { name = it }, + label = { Text(stringResource(R.string.family_name)) }, + singleLine = true, + enabled = !creating, + modifier = Modifier.weight(1f), + ) + Button( + onClick = { onCreate(name.trim()) }, + enabled = !creating && name.trim().isNotEmpty(), + ) { + if (creating) { + CircularProgressIndicator(modifier = Modifier.size(20.dp)) + } else { + Text(stringResource(R.string.family_create)) + } + } + } + } + } +} diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/dashboard/DashboardViewModel.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/dashboard/DashboardViewModel.kt index 5f119d6..42f2331 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/dashboard/DashboardViewModel.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/dashboard/DashboardViewModel.kt @@ -2,19 +2,61 @@ package com.kazier.mobile.ui.dashboard import androidx.lifecycle.ViewModel import androidx.lifecycle.viewModelScope +import com.kazier.mobile.data.remote.ApiClient import com.kazier.mobile.data.repository.FileRepository import dagger.hilt.android.lifecycle.HiltViewModel +import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.SharingStarted import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow import kotlinx.coroutines.flow.stateIn +import kotlinx.coroutines.flow.update +import kotlinx.coroutines.launch +import timber.log.Timber import javax.inject.Inject @HiltViewModel class DashboardViewModel @Inject constructor( fileRepository: FileRepository, + private val apiClient: ApiClient, ) : ViewModel() { /** Nombre de documents locaux restant à traiter (mode review). */ val unprocessedCount: StateFlow = fileRepository.observeUnprocessedCount() .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), initialValue = 0) + + /** + * Onboarding foyer B5 : nombre de groupes (cercles) du compte, NULL tant + * que non chargé ou hors-ligne (best-effort — jamais bloquant, jamais + * d'erreur visible : la carte s'affiche seulement si 0 avéré en ligne). + */ + private val _groupCount = MutableStateFlow(null) + val groupCount: StateFlow = _groupCount.asStateFlow() + + private val _creatingCircle = MutableStateFlow(false) + val creatingCircle: StateFlow = _creatingCircle.asStateFlow() + + init { + refreshGroups() + } + + fun refreshGroups() { + viewModelScope.launch { + runCatching { apiClient.listGroups() } + .onSuccess { groups -> _groupCount.update { groups.size } } + .onFailure { e -> Timber.d("dashboard groups skipped: %s", e.message) } + } + } + + /** Crée le cercle « Famille » en un tap (puis recharge le compteur). */ + fun createFamilyCircle(name: String) { + if (_creatingCircle.value) return + viewModelScope.launch { + _creatingCircle.value = true + runCatching { apiClient.createGroup(name) } + .onSuccess { refreshGroups() } + .onFailure { e -> Timber.w(e, "dashboard create circle failed") } + _creatingCircle.value = false + } + } } \ No newline at end of file diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/devices/DevicesScreen.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/devices/DevicesScreen.kt new file mode 100644 index 0000000..c051c33 --- /dev/null +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/devices/DevicesScreen.kt @@ -0,0 +1,219 @@ +package com.kazier.mobile.ui.devices + +import android.text.format.DateUtils +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.automirrored.filled.ArrowBack +import androidx.compose.material.icons.filled.Delete +import androidx.compose.material.icons.filled.PhoneAndroid +import androidx.compose.material3.AlertDialog +import androidx.compose.material3.Card +import androidx.compose.material3.CircularProgressIndicator +import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.Icon +import androidx.compose.material3.IconButton +import androidx.compose.material3.LinearProgressIndicator +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Scaffold +import androidx.compose.material3.SnackbarHost +import androidx.compose.material3.SnackbarHostState +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.material3.TopAppBar +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.saveable.rememberSaveable +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.unit.dp +import androidx.hilt.navigation.compose.hiltViewModel +import androidx.lifecycle.compose.collectAsStateWithLifecycle +import com.kazier.mobile.R +import com.kazier.mobile.data.repository.DevicesRepository +import com.kazier.mobile.ui.components.formatFileSize + +/** + * Appareils du compte (V3 S6 A1) : ce téléphone repéré (« cet appareil », + * jamais révocable), les autres révocables après confirmation (téléphone + * perdu — leurs tokens deviennent 401). Tête : quota utilisé. + */ +@OptIn(ExperimentalMaterial3Api::class) +@Composable +fun DevicesScreen( + onBack: () -> Unit, + viewModel: DevicesViewModel = hiltViewModel(), +) { + val state by viewModel.uiState.collectAsStateWithLifecycle() + val snackbarHostState = remember { SnackbarHostState() } + LaunchedEffect(state.error) { + state.error?.let { + snackbarHostState.showSnackbar(it) + viewModel.clearError() + } + } + var pendingRevoke by rememberSaveable { mutableStateOf(null) } + + pendingRevoke?.let { deviceId -> + AlertDialog( + onDismissRequest = { pendingRevoke = null }, + title = { Text(stringResource(R.string.devices_revoke_confirm_title)) }, + text = { Text(stringResource(R.string.devices_revoke_confirm_message)) }, + confirmButton = { + TextButton(onClick = { + pendingRevoke = null + viewModel.revoke(deviceId) + }) { Text(stringResource(R.string.devices_revoke_confirm)) } + }, + dismissButton = { + TextButton(onClick = { pendingRevoke = null }) { + Text(stringResource(R.string.delete_cancel)) + } + }, + ) + } + + Scaffold( + topBar = { + TopAppBar( + title = { Text(stringResource(R.string.devices_title)) }, + navigationIcon = { + IconButton(onClick = onBack) { + Icon( + Icons.AutoMirrored.Filled.ArrowBack, + contentDescription = stringResource(R.string.back), + ) + } + }, + ) + }, + snackbarHost = { SnackbarHost(hostState = snackbarHostState) }, + ) { padding -> + LazyColumn( + modifier = Modifier.fillMaxSize().padding(padding), + contentPadding = PaddingValues(16.dp), + verticalArrangement = Arrangement.spacedBy(12.dp), + ) { + state.usage?.let { usage -> + item(key = "usage") { + UsageCard( + usedBytes = usage.usedBytes, + quotaBytes = usage.quotaBytes, + fileCount = usage.fileCount, + ) + } + } + if (state.isLoading && state.devices.isEmpty()) { + item(key = "loading") { + Column( + modifier = Modifier.fillMaxWidth().padding(32.dp), + horizontalAlignment = Alignment.CenterHorizontally, + ) { + CircularProgressIndicator() + } + } + } + items(state.devices, key = { it.deviceId }) { device -> + DeviceRow( + device = device, + onRevoke = { pendingRevoke = device.deviceId }, + ) + } + if (!state.isLoading && state.devices.isEmpty()) { + item(key = "empty") { + Text( + text = stringResource(R.string.devices_empty), + style = MaterialTheme.typography.bodyLarge, + color = MaterialTheme.colorScheme.onSurfaceVariant, + textAlign = TextAlign.Center, + modifier = Modifier.fillMaxWidth().padding(32.dp), + ) + } + } + } + } +} + +@Composable +private fun UsageCard(usedBytes: Long, quotaBytes: Long, fileCount: Int) { + val fraction = if (quotaBytes > 0) (usedBytes.toFloat() / quotaBytes).coerceIn(0f, 1f) else 0f + Card(modifier = Modifier.fillMaxWidth()) { + Column(modifier = Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) { + Text( + text = stringResource( + R.string.devices_usage, + formatFileSize(usedBytes), + formatFileSize(quotaBytes), + fileCount, + ), + style = MaterialTheme.typography.bodyMedium, + fontWeight = FontWeight.Medium, + ) + LinearProgressIndicator( + progress = { fraction }, + modifier = Modifier.fillMaxWidth(), + ) + } + } +} + +@Composable +private fun DeviceRow( + device: DevicesRepository.DeviceUi, + onRevoke: () -> Unit, +) { + Row( + modifier = Modifier.fillMaxWidth(), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(12.dp), + ) { + Icon( + Icons.Filled.PhoneAndroid, + contentDescription = null, + tint = MaterialTheme.colorScheme.primary, + modifier = Modifier.size(28.dp), + ) + Column(modifier = Modifier.weight(1f)) { + Text( + text = if (device.isCurrent) { + stringResource(R.string.devices_current) + } else { + stringResource(R.string.devices_other, device.deviceId.take(8)) + }, + style = MaterialTheme.typography.bodyLarge, + fontWeight = FontWeight.Medium, + ) + device.lastSeenAt?.let { seen -> + Text( + text = DateUtils.getRelativeTimeSpanString(seen).toString(), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } + if (!device.isCurrent) { + IconButton(onClick = onRevoke) { + Icon( + Icons.Filled.Delete, + contentDescription = stringResource(R.string.devices_revoke), + tint = MaterialTheme.colorScheme.error, + ) + } + } + } +} diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/devices/DevicesViewModel.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/devices/DevicesViewModel.kt new file mode 100644 index 0000000..6dd3b48 --- /dev/null +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/devices/DevicesViewModel.kt @@ -0,0 +1,74 @@ +package com.kazier.mobile.ui.devices + +import androidx.lifecycle.ViewModel +import androidx.lifecycle.viewModelScope +import com.kazier.mobile.data.remote.dto.UsageDto +import com.kazier.mobile.data.repository.DevicesRepository +import dagger.hilt.android.lifecycle.HiltViewModel +import javax.inject.Inject +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.update +import kotlinx.coroutines.launch +import timber.log.Timber + +/** + * Appareils du compte + empreinte (V3 S6 A1/A2) : liste (ce téléphone + * repéré, jamais révocable), révocation d'un device perdu (avec confirmation), + * quota utilisé affiché en tête. + */ +@HiltViewModel +class DevicesViewModel @Inject constructor( + private val devicesRepository: DevicesRepository, +) : ViewModel() { + + data class DevicesUiState( + val isLoading: Boolean = false, + val devices: List = emptyList(), + val usage: UsageDto? = null, + val error: String? = null, + ) + + private val _uiState = MutableStateFlow(DevicesUiState()) + val uiState: StateFlow = _uiState.asStateFlow() + + init { + refresh() + } + + fun refresh() { + viewModelScope.launch { + _uiState.update { it.copy(isLoading = true, error = null) } + val devices = runCatching { devicesRepository.listDevices() } + val usage = runCatching { devicesRepository.usage() } + devices.onFailure { e -> Timber.d("devices list failed: %s", e.message) } + usage.onFailure { e -> Timber.d("usage failed: %s", e.message) } + _uiState.update { + it.copy( + isLoading = false, + devices = devices.getOrDefault(emptyList()), + usage = usage.getOrNull(), + error = (devices.exceptionOrNull() ?: usage.exceptionOrNull()) + ?.let { e -> e.message ?: e.javaClass.simpleName }, + ) + } + } + } + + fun clearError() { + _uiState.update { it.copy(error = null) } + } + + /** Révoque un device perdu (jamais celui-ci — le bouton est masqué). */ + fun revoke(deviceId: String) { + viewModelScope.launch { + runCatching { devicesRepository.revoke(deviceId) } + .onSuccess { refresh() } + .onFailure { e -> + Timber.w(e, "devices revoke failed") + _uiState.update { it.copy(error = e.message ?: e.javaClass.simpleName) } + } + } + } +} diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/folderlist/FolderListScreen.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/folderlist/FolderListScreen.kt index edb33ac..f39de23 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/folderlist/FolderListScreen.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/folderlist/FolderListScreen.kt @@ -229,6 +229,23 @@ fun FolderListScreen( syncViewModel.importRoot(uri = uri.toString(), name = rootName) } + // B1 : « classeur » unifié — le menu + accueille aussi l'ajout d'un + // dossier surveillé (même importRoot que l'onboarding, sans la création + // du sous-dossier « Kazier » réservée à la racine par défaut). + val pickWatchLauncher = rememberLauncherForActivityResult( + ActivityResultContracts.OpenDocumentTree(), + ) { uri: Uri? -> + if (uri == null) return@rememberLauncherForActivityResult + runCatching { + context.contentResolver.takePersistableUriPermission( + uri, + Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_GRANT_WRITE_URI_PERMISSION, + ) + }.onFailure { Timber.w(it, "persistable permission absent on watch pick") } + val rootName = uri.safDisplayName(context) ?: uri.lastPathSegment ?: folderLabel + syncViewModel.importRoot(uri = uri.toString(), name = rootName) + } + // Attend la création de la racine (importRoot la sauvegarde puis lance le // walk), crée le sous-dossier « Kazier » et l'enregistre comme racine. LaunchedEffect(pendingDefaultPick) { @@ -450,6 +467,14 @@ fun FolderListScreen( showNoteDialog = true }, ) + DropdownMenuItem( + text = { Text(stringResource(R.string.create_option_watch)) }, + leadingIcon = { Icon(Icons.Filled.Folder, contentDescription = null) }, + onClick = { + showCreateMenu = false + pickWatchLauncher.launch(null) + }, + ) } } } diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/navigation/NavGraph.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/navigation/NavGraph.kt index 6c5fafc..50f4693 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/navigation/NavGraph.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/navigation/NavGraph.kt @@ -31,6 +31,7 @@ import com.kazier.mobile.ui.settings.SettingsScreen import com.kazier.mobile.ui.share.OpenLinkScreen import com.kazier.mobile.ui.trash.TrashScreen import com.kazier.mobile.ui.duplicates.DuplicatesScreen +import com.kazier.mobile.ui.devices.DevicesScreen import com.kazier.mobile.ui.watchedfolders.WatchedFoldersScreen object Routes { @@ -42,6 +43,7 @@ object Routes { const val WATCHED_FOLDERS = "watched" const val TRASH = "trash" const val DUPLICATES = "duplicates" + const val DEVICES = "devices" const val FOLDER_DETAIL = "folder/{folderResourceId}" const val ARG_FOLDER = "folderResourceId" const val DOCUMENT = "document/{documentResourceId}" @@ -152,6 +154,7 @@ fun NavGraph( onOpenWatchedFolders = onOpenWatchedFolders, onOpenTrash = { navController.navigate(Routes.TRASH) }, onOpenDuplicates = { navController.navigate(Routes.DUPLICATES) }, + onOpenDevices = { navController.navigate(Routes.DEVICES) }, authViewModel = authViewModel, connectionStatusViewModel = connectionStatusViewModel, syncViewModel = syncViewModel, @@ -195,6 +198,11 @@ fun NavGraph( onBack = { navController.popBackStack() }, ) } + composable(Routes.DEVICES) { + DevicesScreen( + onBack = { navController.popBackStack() }, + ) + } composable( route = Routes.FOLDER_DETAIL, arguments = listOf( diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/settings/SettingsScreen.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/settings/SettingsScreen.kt index b5ca80f..93beca0 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/settings/SettingsScreen.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/settings/SettingsScreen.kt @@ -18,6 +18,7 @@ import androidx.compose.material.icons.Icons import androidx.compose.material.icons.filled.CloudOff import androidx.compose.material.icons.filled.ContentCopy import androidx.compose.material.icons.filled.DarkMode +import androidx.compose.material.icons.filled.PhoneAndroid import androidx.compose.material.icons.filled.Delete import androidx.compose.material.icons.filled.Dns import androidx.compose.material.icons.filled.Folder @@ -73,6 +74,7 @@ fun SettingsScreen( onOpenWatchedFolders: () -> Unit, onOpenTrash: () -> Unit, onOpenDuplicates: () -> Unit, + onOpenDevices: () -> Unit, authViewModel: AuthViewModel, connectionStatusViewModel: ConnectionStatusViewModel, syncViewModel: SyncViewModel, @@ -173,6 +175,14 @@ fun SettingsScreen( onClick = onOpenDuplicates, ) + HorizontalDivider() + SettingsRow( + icon = { Icon(Icons.Filled.PhoneAndroid, contentDescription = null) }, + title = stringResource(R.string.devices_title), + subtitle = stringResource(R.string.devices_hint), + onClick = onOpenDevices, + ) + HorizontalDivider() SettingsRow( icon = { Icon(Icons.Filled.Dns, contentDescription = null) }, diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/share/ShareBottomSheet.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/share/ShareBottomSheet.kt index 1ed2f0a..6b4408a 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/share/ShareBottomSheet.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/share/ShareBottomSheet.kt @@ -519,6 +519,13 @@ private fun LinksSection( style = MaterialTheme.typography.bodySmall, maxLines = 2, ) + link.expiresAt?.let { expiry -> + Text( + text = stringResource(R.string.share_link_expires, expiry), + style = MaterialTheme.typography.labelSmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } OutlinedButton(onClick = { clipboard.setText(AnnotatedString(link.url)) Toast.makeText(context, context.getString(R.string.share_link_copied), Toast.LENGTH_SHORT).show() diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/share/ShareViewModel.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/share/ShareViewModel.kt index c88d0a1..0f48b0c 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/share/ShareViewModel.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/share/ShareViewModel.kt @@ -295,23 +295,30 @@ class ShareViewModel @Inject constructor( /** * Crée un lien public (`create_link`, token 32-hex généré localement). - * Le lien est exposé en [ShareUiState.lastCreatedLink] pour copie. + * Expiration par défaut 7j (V3 S6 — un lien permanent est un RIB qui + * traîne ; révocable à tout moment). Le lien est exposé en + * [ShareUiState.lastCreatedLink] pour copie. */ fun createLink(resourceId: String, resourceType: String, access: String) { viewModelScope.launch { _uiState.update { it.copy(actionError = null, lastCreatedLink = null) } val token = generateId.newResourceId() + val expiresAt = System.currentTimeMillis() + LINK_DEFAULT_TTL_MS runCatching { outboxRepository.enqueueCreateLink( resourceId = resourceId, resourceType = resourceType, token = token, access = access, + expiresAt = expiresAt, ) }.onSuccess { OutboxSyncWorker.enqueue(appContext) + val expiryLabel = java.text.DateFormat + .getDateInstance(java.text.DateFormat.SHORT) + .format(java.util.Date(expiresAt)) _uiState.update { - it.copy(lastCreatedLink = ShareLinkUi(token, access, null, ShareLinkParser.shareUrl(token))) + it.copy(lastCreatedLink = ShareLinkUi(token, access, expiryLabel, ShareLinkParser.shareUrl(token))) } refreshPending(resourceId) }.onFailure { e -> @@ -521,6 +528,11 @@ class ShareViewModel @Inject constructor( override fun onCleared() { super.onCleared() } + + companion object { + /** Expiration par défaut des liens créés : 7 jours (V3 S6). */ + const val LINK_DEFAULT_TTL_MS = 7L * 24 * 60 * 60 * 1000 + } } /** Quadruplet local (pas de Tuple4 stdlib en Kotlin). */ diff --git a/mobile-kotlin/app/src/main/res/values-en/strings.xml b/mobile-kotlin/app/src/main/res/values-en/strings.xml index a28597a..4484df2 100644 --- a/mobile-kotlin/app/src/main/res/values-en/strings.xml +++ b/mobile-kotlin/app/src/main/res/values-en/strings.xml @@ -43,6 +43,7 @@ Could not create the folder. Scan a document Add a note + Watch a folder Add New note Title @@ -344,6 +345,7 @@ Link created — copy it before closing. Copy Link copied. + Expires %1$s (7 days by default). Revoke this link? It will stop working. Paste a received link or token Open @@ -453,4 +455,25 @@ Delete “%1$s”? The collection disappears from this device. Delete + + Renamed elsewhere (%1$d) + Clear + “%1$s” (server name kept) + + Devices + View and revoke connected devices + No registered devices. + This device + Device %1$s… + Revoke this device + Revoke this device? + Its sessions will be signed out and it must re-register. + Revoke + %1$s / %2$s (%3$d files) + + Create your Family circle + Share your papers with loved ones in one tap. + Circle name + Family + Create \ No newline at end of file diff --git a/mobile-kotlin/app/src/main/res/values/strings.xml b/mobile-kotlin/app/src/main/res/values/strings.xml index 66c48d8..3c4407b 100644 --- a/mobile-kotlin/app/src/main/res/values/strings.xml +++ b/mobile-kotlin/app/src/main/res/values/strings.xml @@ -43,6 +43,7 @@ Impossible de créer le dossier. Scanner un document Ajouter une note + Surveiller un dossier Ajouter Nouvelle note Titre @@ -345,6 +346,7 @@ Lien créé — copiez-le avant de fermer. Copier Lien copié. + Expire le %1$s (7 jours par défaut). Révoquer ce lien ? Il ne fonctionnera plus. Collez un lien ou un token reçu Ouvrir @@ -454,4 +456,25 @@ Supprimer « %1$s » ? La collection disparaît de cet appareil. Supprimer + + Renommés ailleurs (%1$d) + Effacer + « %1$s » (nom serveur conservé) + + Appareils + Voir et révoquer les appareils connectés + Aucun appareil enregistré. + Cet appareil + Appareil %1$s… + Révoquer cet appareil + Révoquer cet appareil ? + Ses sessions seront déconnectées et il devra se ré-enregistrer. + Révoquer + %1$s / %2$s (%3$d fichiers) + + Crée ton cercle Famille + Partage tes papiers avec tes proches en un tap. + Nom du cercle + Famille + Créer \ No newline at end of file diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/Auth401Test.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/Auth401Test.kt index edff3ad..1c8c4a5 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/Auth401Test.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/Auth401Test.kt @@ -357,6 +357,15 @@ class Auth401Test { override suspend fun listDuplicates(): Response>> = Response.success(ApiEnvelope(data = emptyList())) + override suspend fun listDevices(): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun revokeDevice(deviceId: String): Response> = + Response.success(ApiEnvelope()) + + override suspend fun getUsage(): Response> = + Response.success(ApiEnvelope(data = com.kazier.mobile.data.remote.dto.UsageDto())) + override suspend fun searchFiles( query: String, page: Int?, diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/PaginationTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/PaginationTest.kt index cff14d5..7ee080f 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/PaginationTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/PaginationTest.kt @@ -231,6 +231,15 @@ class PaginationTest { override suspend fun listDuplicates(): Response>> = Response.success(ApiEnvelope(data = emptyList())) + override suspend fun listDevices(): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun revokeDevice(deviceId: String): Response> = + Response.success(ApiEnvelope()) + + override suspend fun getUsage(): Response> = + Response.success(ApiEnvelope(data = com.kazier.mobile.data.remote.dto.UsageDto())) + override suspend fun searchFiles( query: String, page: Int?, diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/RemoteContentTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/RemoteContentTest.kt index 16db95c..366a0de 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/RemoteContentTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/RemoteContentTest.kt @@ -159,6 +159,15 @@ class RemoteContentTest { override suspend fun listDuplicates(): Response>> = Response.success(ApiEnvelope(data = emptyList())) + override suspend fun listDevices(): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun revokeDevice(deviceId: String): Response> = + Response.success(ApiEnvelope()) + + override suspend fun getUsage(): Response> = + Response.success(ApiEnvelope(data = com.kazier.mobile.data.remote.dto.UsageDto())) + override suspend fun searchFiles(query: String, page: Int?, pageSize: Int?): Response>> = Response.success(ApiEnvelope(data = emptyList())) diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/SessionReloginTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/SessionReloginTest.kt index cb80574..40fe0e2 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/SessionReloginTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/SessionReloginTest.kt @@ -365,6 +365,15 @@ class SessionReloginTest { override suspend fun listDuplicates(): Response>> = Response.success(ApiEnvelope(data = emptyList())) + override suspend fun listDevices(): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun revokeDevice(deviceId: String): Response> = + Response.success(ApiEnvelope()) + + override suspend fun getUsage(): Response> = + Response.success(ApiEnvelope(data = com.kazier.mobile.data.remote.dto.UsageDto())) + override suspend fun searchFiles(query: String, page: Int?, pageSize: Int?): Response>> = Response.success(ApiEnvelope(data = emptyList())) diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/ShareManagementTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/ShareManagementTest.kt index 363e949..684a03f 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/ShareManagementTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/remote/ShareManagementTest.kt @@ -198,6 +198,15 @@ class ShareManagementTest { override suspend fun listDuplicates(): Response>> = Response.success(ApiEnvelope(data = emptyList())) + override suspend fun listDevices(): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun revokeDevice(deviceId: String): Response> = + Response.success(ApiEnvelope()) + + override suspend fun getUsage(): Response> = + Response.success(ApiEnvelope(data = com.kazier.mobile.data.remote.dto.UsageDto())) + override suspend fun searchFiles(query: String, page: Int?, pageSize: Int?): Response>> = Response.success(ApiEnvelope(data = emptyList())) diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/BytesUploadTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/BytesUploadTest.kt index 76e395a..ac2564e 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/BytesUploadTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/BytesUploadTest.kt @@ -292,6 +292,15 @@ class BytesUploadTest { override suspend fun listDuplicates(): Response>> = Response.success(ApiEnvelope(data = emptyList())) + override suspend fun listDevices(): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun revokeDevice(deviceId: String): Response> = + Response.success(ApiEnvelope()) + + override suspend fun getUsage(): Response> = + Response.success(ApiEnvelope(data = com.kazier.mobile.data.remote.dto.UsageDto())) + override suspend fun searchFiles(query: String, page: Int?, pageSize: Int?): Response>> = Response.success(ApiEnvelope(data = emptyList())) diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/FactsRepositoryTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/FactsRepositoryTest.kt index 6c91c60..f32bde7 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/FactsRepositoryTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/FactsRepositoryTest.kt @@ -195,6 +195,9 @@ class FactsRepositoryTest { override suspend fun listRelations(fileId: String): Response>> = TODO() override suspend fun verdictRelation(fileId: String, body: com.kazier.mobile.data.remote.dto.RelationVerdictDto): Response>> = TODO() override suspend fun listDuplicates(): Response>> = TODO() + override suspend fun listDevices(): Response>> = TODO() + override suspend fun revokeDevice(deviceId: String): Response> = TODO() + override suspend fun getUsage(): Response> = TODO() override suspend fun searchFiles(query: String, page: Int?, pageSize: Int?): Response>> = TODO() override suspend fun changePassword(body: com.kazier.mobile.data.remote.dto.ChangePasswordDto): Response> = TODO() override suspend fun getShareLink(token: String): Response> = TODO() diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/FolderMergeDataTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/FolderMergeDataTest.kt index 4924657..0f760e0 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/FolderMergeDataTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/FolderMergeDataTest.kt @@ -417,6 +417,15 @@ private class FolderMergeApiService : ApiService { override suspend fun listDuplicates(): Response>> = Response.success(ApiEnvelope(data = emptyList())) + override suspend fun listDevices(): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun revokeDevice(deviceId: String): Response> = + Response.success(ApiEnvelope()) + + override suspend fun getUsage(): Response> = + Response.success(ApiEnvelope(data = com.kazier.mobile.data.remote.dto.UsageDto())) + override suspend fun searchFiles( query: String, page: Int?, diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/LinksRepositoryTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/LinksRepositoryTest.kt index e2affe9..924908c 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/LinksRepositoryTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/LinksRepositoryTest.kt @@ -155,6 +155,9 @@ class LinksRepositoryTest { override suspend fun listFacts(fileId: String): Response>> = TODO() override suspend fun correctFacts(fileId: String, body: com.kazier.mobile.data.remote.dto.CorrectFactsDto): Response>> = TODO() override suspend fun listDuplicates(): Response>> = TODO() + override suspend fun listDevices(): Response>> = TODO() + override suspend fun revokeDevice(deviceId: String): Response> = TODO() + override suspend fun getUsage(): Response> = TODO() override suspend fun searchFiles(query: String, page: Int?, pageSize: Int?): Response>> = TODO() override suspend fun changePassword(body: com.kazier.mobile.data.remote.dto.ChangePasswordDto): Response> = TODO() override suspend fun getShareLink(token: String): Response> = TODO() diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/MoveProtectionTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/MoveProtectionTest.kt index 88215ee..ee83e65 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/MoveProtectionTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/MoveProtectionTest.kt @@ -506,6 +506,15 @@ private class MoveProtectionApiService : ApiService { override suspend fun listDuplicates(): Response>> = Response.success(ApiEnvelope(data = emptyList())) + override suspend fun listDevices(): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun revokeDevice(deviceId: String): Response> = + Response.success(ApiEnvelope()) + + override suspend fun getUsage(): Response> = + Response.success(ApiEnvelope(data = com.kazier.mobile.data.remote.dto.UsageDto())) + override suspend fun searchFiles( query: String, page: Int?, diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/OcrRepositoryTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/OcrRepositoryTest.kt index b85a6db..f0767cf 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/OcrRepositoryTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/OcrRepositoryTest.kt @@ -418,6 +418,15 @@ private class OcrApiServiceFake : ApiService { override suspend fun listDuplicates(): Response>> = Response.success(ApiEnvelope(data = emptyList())) + override suspend fun listDevices(): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun revokeDevice(deviceId: String): Response> = + Response.success(ApiEnvelope()) + + override suspend fun getUsage(): Response> = + Response.success(ApiEnvelope(data = com.kazier.mobile.data.remote.dto.UsageDto())) + override suspend fun searchFiles( query: String, page: Int?, diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/OfflineDownloadTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/OfflineDownloadTest.kt index 4a5e52e..9ce6580 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/OfflineDownloadTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/OfflineDownloadTest.kt @@ -300,6 +300,15 @@ class OfflineDownloadTest { override suspend fun listDuplicates(): Response>> = Response.success(ApiEnvelope(data = emptyList())) + override suspend fun listDevices(): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun revokeDevice(deviceId: String): Response> = + Response.success(ApiEnvelope()) + + override suspend fun getUsage(): Response> = + Response.success(ApiEnvelope(data = com.kazier.mobile.data.remote.dto.UsageDto())) + override suspend fun searchFiles(query: String, page: Int?, pageSize: Int?): Response>> = Response.success(ApiEnvelope(data = emptyList())) diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/RefreshVsMoveTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/RefreshVsMoveTest.kt index 139078a..2cf94e9 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/RefreshVsMoveTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/RefreshVsMoveTest.kt @@ -273,6 +273,15 @@ private class RefreshVsMoveApiService : ApiService { override suspend fun listDuplicates(): Response>> = Response.success(ApiEnvelope(data = emptyList())) + override suspend fun listDevices(): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun revokeDevice(deviceId: String): Response> = + Response.success(ApiEnvelope()) + + override suspend fun getUsage(): Response> = + Response.success(ApiEnvelope(data = com.kazier.mobile.data.remote.dto.UsageDto())) + override suspend fun searchFiles( query: String, page: Int?, diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/ShareRepositoryTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/ShareRepositoryTest.kt index 3470b89..0cd1a2f 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/ShareRepositoryTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/data/repository/ShareRepositoryTest.kt @@ -527,6 +527,15 @@ private class FakeApiService : ApiService { override suspend fun listDuplicates(): Response>> = Response.success(ApiEnvelope(data = emptyList())) + override suspend fun listDevices(): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun revokeDevice(deviceId: String): Response> = + Response.success(ApiEnvelope()) + + override suspend fun getUsage(): Response> = + Response.success(ApiEnvelope(data = com.kazier.mobile.data.remote.dto.UsageDto())) + override suspend fun searchFiles( query: String, page: Int?, diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/domain/SyncConflictStoreTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/domain/SyncConflictStoreTest.kt new file mode 100644 index 0000000..ed40ae1 --- /dev/null +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/domain/SyncConflictStoreTest.kt @@ -0,0 +1,84 @@ +package com.kazier.mobile.domain + +import android.content.Context +import androidx.room.Room +import androidx.test.core.app.ApplicationProvider +import com.squareup.moshi.Moshi +import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory +import com.kazier.mobile.data.local.AppDatabase +import kotlinx.coroutines.flow.first +import kotlinx.coroutines.test.runTest +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +/** + * Conflits LWW (S6 A4) : persistance JSON (max 10, dédupliqués), rechargement, + * effacement. + */ +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [34]) +class SyncConflictStoreTest { + + private lateinit var db: AppDatabase + private lateinit var store: SyncConflictStore + + @Before + fun setUp() { + val context = ApplicationProvider.getApplicationContext() + db = Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java) + .allowMainThreadQueries() + .build() + val moshi = Moshi.Builder().add(KotlinJsonAdapterFactory()).build() + store = SyncConflictStore(db.userPreferenceDao(), moshi) + } + + @After + fun tearDown() { + db.close() + } + + @Test + fun ajout_persiste_et_recharge() = runTest { + store.addAll( + listOf( + SyncConflict("op1", "res1", "v3.txt", 1000L, 2000L), + SyncConflict("op2", "res2", "w.txt", 1000L, 2000L), + ), + ) + assertEquals(2, store.conflicts.first().size) + + // Nouveau store sur la même DB : recharge. + val moshi = Moshi.Builder().add(KotlinJsonAdapterFactory()).build() + val reloaded = SyncConflictStore(db.userPreferenceDao(), moshi) + reloaded.load() + val list = reloaded.conflicts.first() + assertEquals(2, list.size) + assertEquals("v3.txt", list[0].serverName) + } + + @Test + fun dedupe_par_operation_et_plafond() = runTest { + val many = (1..12).map { SyncConflict("op$it", "r$it", "n$it", 1L, 2L) } + store.addAll(many) + assertEquals(10, store.conflicts.first().size) + + // Re-ajout du même : pas de doublon, ordre conservé (récents d'abord). + store.addAll(listOf(SyncConflict("op1", "r1", "n1", 1L, 3L))) + val list = store.conflicts.first() + assertEquals(10, list.size) + assertEquals("op1", list[0].operationId) + } + + @Test + fun effacement() = runTest { + store.addAll(listOf(SyncConflict("op1", "r1", "n", 1L, 2L))) + store.clear() + assertTrue(store.conflicts.first().isEmpty()) + } +} diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/features/saf/ReleaseLocalCopyTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/features/saf/ReleaseLocalCopyTest.kt index 2631bec..75d660c 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/features/saf/ReleaseLocalCopyTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/features/saf/ReleaseLocalCopyTest.kt @@ -164,6 +164,9 @@ class ReleaseLocalCopyTest { override suspend fun listRelations(fileId: String): retrofit2.Response>> = TODO() override suspend fun verdictRelation(fileId: String, body: com.kazier.mobile.data.remote.dto.RelationVerdictDto): retrofit2.Response>> = TODO() override suspend fun listDuplicates(): retrofit2.Response>> = TODO() + override suspend fun listDevices(): retrofit2.Response>> = TODO() + override suspend fun revokeDevice(deviceId: String): retrofit2.Response> = TODO() + override suspend fun getUsage(): retrofit2.Response> = TODO() override suspend fun searchFiles(query: String, page: Int?, pageSize: Int?): retrofit2.Response>> = TODO() override suspend fun changePassword(body: com.kazier.mobile.data.remote.dto.ChangePasswordDto): retrofit2.Response> = TODO() override suspend fun getShareLink(token: String): retrofit2.Response> = TODO() diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/features/sync/OutboxSyncWorkerTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/features/sync/OutboxSyncWorkerTest.kt index 8930783..1937cc8 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/features/sync/OutboxSyncWorkerTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/features/sync/OutboxSyncWorkerTest.kt @@ -27,6 +27,8 @@ import com.kazier.mobile.data.remote.ApiClient import com.kazier.mobile.data.remote.ApiException import com.kazier.mobile.data.remote.ApiService import com.kazier.mobile.data.remote.dto.ApiEnvelope +import com.kazier.mobile.data.remote.dto.SyncConflictDto +import com.kazier.mobile.domain.SyncConflictStore import com.kazier.mobile.data.remote.dto.AddGroupMemberDto import com.kazier.mobile.data.remote.dto.CreateGroupDto import com.kazier.mobile.data.remote.dto.GroupDto @@ -95,6 +97,7 @@ class OutboxSyncWorkerTest { private lateinit var fake: FakeApiService private lateinit var apiClient: ApiClient private lateinit var tokenProvider: TokenProvider + private lateinit var conflictStore: SyncConflictStore private lateinit var worker: OutboxSyncWorker @Before @@ -114,9 +117,10 @@ class OutboxSyncWorkerTest { fake = FakeApiService() apiClient = ApiClient(fake, moshi) tokenProvider = TokenProvider().apply { current = "test-token" } + conflictStore = SyncConflictStore(db.userPreferenceDao(), moshi) worker = OutboxSyncWorker( context, workerParams(), apiClient, opsDao, fileDao, folderDao, - tokenProvider, moshi, + tokenProvider, conflictStore, moshi, ) } @@ -252,8 +256,7 @@ class OutboxSyncWorkerTest { assertEquals(0, opsDao.countPending()) } - // --- C7 : gardes ---------------------------------------------------------- - @Test + // --- C7 : gardes ---------------------------------------------------------- @Test fun failed_inconnu_pas_de_boucle() = runTest { insertOp(opId(1)) insertOp(opId(2)) @@ -376,6 +379,34 @@ class OutboxSyncWorkerTest { ) } + // --- S6 A4 : conflits LWW persistés, batch non bloqué --------------------- + + @Test + fun conflits_rename_persites_sans_bloquer() = runTest { + insertOp(opId(1)) + val conflict = SyncConflictDto(opId(1), resId(1), "v3.txt", 1_700_000_000_1000L) + fake.syncOpsHandler = { + Response.success( + ApiEnvelope( + data = com.kazier.mobile.data.remote.dto.SyncOpsResult( + applied = 1, + failed = null, + conflicts = listOf(conflict), + ), + ), + ) + } + + val result = worker.doWork() + + assertTrue(result is ListenableWorker.Result.Success) + assertEquals(PendingOpStatus.SYNCED, opsDao.observeRecent(100).first().first().status) + val stored = conflictStore.conflicts.first() + assertEquals(1, stored.size) + assertEquals(opId(1), stored[0].operationId) + assertEquals("v3.txt", stored[0].serverName) + } + // --- fixtures -------------------------------------------------------------- private suspend fun insertOp( @@ -522,6 +553,15 @@ class OutboxSyncWorkerTest { override suspend fun listDuplicates(): Response>> = throw UnsupportedOperationException() + override suspend fun listDevices(): Response>> = + throw UnsupportedOperationException() + + override suspend fun revokeDevice(deviceId: String): Response> = + throw UnsupportedOperationException() + + override suspend fun getUsage(): Response> = + throw UnsupportedOperationException() + override suspend fun searchFiles( query: String, page: Int?, diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/ui/search/SearchFieldTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/ui/search/SearchFieldTest.kt index 4e3fc2d..d9f10a8 100644 --- a/mobile-kotlin/app/src/test/java/com/kazier/mobile/ui/search/SearchFieldTest.kt +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/ui/search/SearchFieldTest.kt @@ -215,8 +215,88 @@ class SearchFieldTest { ) } + /** + * S6 facettes : la saisie émetteur filtre les résultats FTS après + * debounce (triggers posés à la main — hors migration en in-memory). + */ + @Test + fun facette_emetteur_filtre_les_resultats() = runTest { + Dispatchers.setMain(StandardTestDispatcher(testScheduler)) + try { + val raw = db.openHelper.writableDatabase + for (trigger in com.kazier.mobile.data.local.fts.FtsTriggers.TRIGGERS) { + raw.execSQL(trigger) + } + fileRepository.saveLocalFile( + input = SaveFileInput( + uri = "content://tree/a", + name = "a.pdf", + extension = "pdf", + size = 10, + mimeType = "application/pdf", + resourceId = RESOURCE_A, + processed = true, + ), + folderResourceId = FOLDER, + ) + fileRepository.saveLocalFile( + input = SaveFileInput( + uri = "content://tree/b", + name = "b.pdf", + extension = "pdf", + size = 10, + mimeType = "application/pdf", + resourceId = RESOURCE_B, + processed = true, + ), + folderResourceId = FOLDER, + ) + db.fileDao().updateOcrText(RESOURCE_A, "facture EDF", 1L) + db.fileDao().updateOcrText(RESOURCE_B, "facture ENGIE", 1L) + db.factsDao().insertAll( + listOf( + com.kazier.mobile.data.local.entity.ResourceFact( + resourceId = RESOURCE_A, factType = "issuer", + valueText = "EDF", confidence = 0.9, + origin = "auto", updatedAt = 1L, + ), + com.kazier.mobile.data.local.entity.ResourceFact( + resourceId = RESOURCE_B, factType = "issuer", + valueText = "ENGIE", confidence = 0.9, + origin = "auto", updatedAt = 1L, + ), + ), + ) + + val viewModel = newViewModel() + backgroundScope.launch { viewModel.uiState.collect {} } + viewModel.onQueryChange("facture") + advanceTimeBy(400) + withContext(Dispatchers.IO) { + withTimeout(10_000) { + viewModel.uiState.first { it.results.size == 2 } + } + } + + viewModel.onIssuerChange("edf") + advanceTimeBy(400) + val filtered = withContext(Dispatchers.IO) { + withTimeout(10_000) { + viewModel.uiState.first { + it.results.size == 1 && it.results[0].resourceId == RESOURCE_A + } + } + } + assertEquals(1, filtered.activeFacetCount) + } finally { + Dispatchers.resetMain() + } + } + private companion object { const val FOLDER = "f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0" const val RESOURCE_ID = "aabbccddeeff11223344556677889900" + const val RESOURCE_A = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + const val RESOURCE_B = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" } }