diff --git a/AGENTS.md b/AGENTS.md index 7054981..ad545e3 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -38,9 +38,9 @@ Tests mobiles : JVM unit tests dans `app/src/test` (JUnit + Robolectric + Room i - `config/` — env (`godotenv`, optionnel) + defaults: `PORT`, `DATABASE_URL`, `UPLOAD_DIR`, `MAX_FILE_SIZE_MB`, `OCR_LANG`, `AUTH_SECRET` (secret des tokens paseto), `ADMIN_USERNAME`/`ADMIN_PASSWORD` (bootstrap du premier admin) - `models/` — domain entities (users, devices, documents/resources, clients) - `service/` — business logic (permissions, upload, create folder, move, **sync outbox + snapshot**, bootstrap admin) -- `handlers/` — HTTP handlers (health, devices register, **auth/login**, **users resolve + change password**, files CRUD/upload/search, folders, **sync/ops + sync/permissions, ocr/jobs, files/:id/content, files/:id/shares, files/:id/links, files/:id/placements** — réels) ; middleware `RequireAuth` -- `repository/` — Postgres persistence (`repository.Resources` : insert/list/get/soft-delete scoping `owner_id`, search, move, rename, root-name unique index, `ListOwned` pour le snapshot, `OpenContent` (bytes streaming + lazy healing `has_content`), `ListShares`/`ListLinks` (owner-only), `SetHasContent` ; `repository.Devices` : Upsert, Exists, MarkUser ; `repository.Operations` : trace outbox idempotente `(device_id, operation_id)` ; `repository.OcrJobs` : jobs queued→processing→done/failed ; `repository.Users` : GetByUsernameNormalized, ResolveExact, UpdatePassword ; `repository.Shares` : Upsert/Revoke, CreateLink/RevokeLink, ListActiveForResource, ListActiveLinksForResource, snapshot `ListEffectivePermissions` ; `repository.Placements` : EnsureLocation/Report/ListForResource (V2 multi-device) ; IDs sont TEXT 32-hex, `NewID()` = `crypto/rand` 16 octets hex (jamais UUID conversion, cf. `docs/api-v1.md`) -- `db/` — package migrations (`golang-migrate/v4`, embarquées via `embed` dans `db/migrations/*.sql`, 000001→000015) : `db.MigrateDatabase(url)` au boot du serveur ; test harness `db/migrations_test.go` (up → assertions schéma → down, `TEST_DATABASE_URL`, skip si PG indisponible) ; `dbtest/` — helper cross-package pour les tests repo/handlers (crée la DB test si absente, reset schema, migrate ; skip si PG down) +- `handlers/` — HTTP handlers (health, devices register, **auth/login**, **users resolve + change password**, files CRUD/upload/search, folders, **sync/ops + sync/permissions, ocr/jobs, files/:id/content, files/:id/shares, files/:id/links, files/:id/placements, groups CRUD + membres** — réels) ; middleware `RequireAuth` +- `repository/` — Postgres persistence (`repository.Resources` : insert/list/get/soft-delete scoping `owner_id`, search, move, rename, root-name unique index, `ListOwned` pour le snapshot, `OpenContent` (bytes streaming + lazy healing `has_content`), `ListShares`/`ListLinks` (owner-only), `SetHasContent` ; `repository.Devices` : Upsert, Exists, MarkUser ; `repository.Operations` : trace outbox idempotente `(device_id, operation_id)` ; `repository.OcrJobs` : jobs queued→processing→done/failed ; `repository.Users` : GetByUsernameNormalized, ResolveExact, UpdatePassword ; `repository.Shares` : Upsert/UpsertGroup/Revoke, CreateLink/RevokeLink, ListActiveForResource, ListActiveLinksForResource, snapshot `ListEffectivePermissions` (grants user + groupe) ; `repository.Groups` : Create/ListForUser/AddMember/RemoveMember/Delete (V2-6, un niveau, sans imbrication) ; `repository.Placements` : EnsureLocation/Report/ListForResource (V2 multi-device) ; IDs sont TEXT 32-hex, `NewID()` = `crypto/rand` 16 octets hex (jamais UUID conversion, cf. `docs/api-v1.md`) +- `db/` — package migrations (`golang-migrate/v4`, embarquées via `embed` dans `db/migrations/*.sql`, 000001→000016) : `db.MigrateDatabase(url)` au boot du serveur ; test harness `db/migrations_test.go` (up → assertions schéma → down, `TEST_DATABASE_URL`, skip si PG indisponible) ; `dbtest/` — helper cross-package pour les tests repo/handlers (crée la DB test si absente, reset schema, migrate ; skip si PG down) - `ocr/` — OCR engine behind an interface (Tesseract system call, `OCR_LANG` défaut `fra+eng`) - `pkg/api/` — response helpers (`response.go`) ; `pkg/auth/` — tokens **paseto v4-local** (subject = `user_id`, claim = `device_id`, TTL 7j, voir `docs/api-v1.md`) ; `pkg/passwd/` — hashing/vérification argon2id (comparaison `subtle`, délai égalisé) - File uploads stored in `backend/uploads/` @@ -61,7 +61,7 @@ Tests mobiles : JVM unit tests dans `app/src/test` (JUnit + Robolectric + Room i - `sync/OutboxSyncWorker.kt` — worker WorkManager (`enqueueUniqueWork` KEEP, single-flight, `NetworkType.CONNECTED`, backoff 30s) qui draine `pending_operations` vers `POST /sync/ops` (batch 20, dead-letter immédiat `failed` sur erreur 4xx non-idempotente — `attempts` diagnostic, purge synced > 7 jours, **sauf `report_bytes` : dead-letter + suite du batch, jamais bloquant**) ; **schedulé** au login/restauration de session (`AuthViewModel`) et après chaque `syncAll()` (`SyncViewModel`) ; enchaîne `OcrAutoWorker` + `BytesUploadWorker` quand un fichier est promu (`DownloadWorker` sur demande hors-ligne) ; `RetentionWorker` (passe quotidienne, purge sûre des copies anciennes selon `RetentionStore`, sans réseau) - `sync/SyncViewModel.kt` — état du sync exposé à l'UI (`SyncStatus` : marche en cours, ops en attente, dernières opérations) via le badge header `ui/components/SyncStatusBadge.kt` + `SyncOperationsDialog.kt` (« liste des sync ») - `auth/` — session (login user + token paseto + **re-login silencieux** sur 401 via identifiants chiffrés persistés, single-flight, événements `Reauthenticated`/`SessionExpired`) : `SessionManager`, `SecureTokenStore`, `TokenProvider`, `TokenStore` (+ `Credentials`) -- `ui/` — écrans Compose : `folderlist`, `folderdetail`, `document` (contenu PDF/image/texte local + streaming distant image/texte/PDF multi-pages via `RemoteDocumentViewer`, autres types non supportés en streaming), `search` (**recherche locale** via Room, sans endpoint serveur), `settings` (URL serveur + thème + stockage/retention), `pdfbuilder` (multi-select → génération PDF), `auth` (login, mode local, avis d'expiration), `share` (`ShareBottomSheet` : grants + liens + ouverture de lien + copies V2 ; `OpenLinkScreen` + deep-link `kazier://share/`), `components`, `theme` +- `ui/` — écrans Compose : `folderlist`, `folderdetail`, `document` (contenu PDF/image/texte local + streaming distant image/texte/PDF multi-pages via `RemoteDocumentViewer`, autres types non supportés en streaming), `search` (**recherche locale** via Room, sans endpoint serveur), `settings` (URL serveur + thème + stockage/retention), `pdfbuilder` (multi-select → génération PDF), `auth` (login, mode local, avis d'expiration), `share` (`ShareBottomSheet` : grants + liens + ouverture de lien + copies V2 + groupes V2-6 ; `OpenLinkScreen` + deep-link `kazier://share/`), `components`, `theme` - `domain/` — stores de préférences: `DeviceIdentity`, `ActiveUserStore`, `LocalModeStore`, `ServerConfigStore`, `ThemePreferenceStore`, `RetentionStore` (`all` | `last_months:N`), `GenerateId` (identifiants 32-hex) - `di/` — modules Hilt (`AppModule`, `DatabaseModule`, `NetworkModule`) - Base URL serveur **configurée à l'exécution** dans les Réglages (`ServerConfigStore`, persistée en `user_preferences`), défaut `http://10.0.2.2:8080/api/v1` (pas de variable d'env) @@ -83,7 +83,7 @@ Tests mobiles : JVM unit tests dans `app/src/test` (JUnit + Robolectric + Room i - **Identity (user-first, V1 finale)**: le device s'enregistre (`POST /devices`, `{ "deviceId" }` seul, sans token), puis `POST /auth/login` (`username` + `password` + `device_id`) émet le seul token paseto **v4-local** — subject = `user_id` (autorise, scoping de toutes les ressources), claim `device_id` (porté, non autorisant seul), **TTL 7j sans refresh**. À expiration, le client re-logine **silencieusement** via les identifiants chiffrés persistés (`SecureTokenStore`, single-flight, événements `Reauthenticated`/`SessionExpired`), sans rejouer la requête en vol. - **Bootstrap**: au premier démarrage, si `users` est vide, `ADMIN_USERNAME`/`ADMIN_PASSWORD` (env) créent le premier admin ; absents → le serveur refuse de démarrer. L'env n'écrase jamais un compte existant. Usernames résolus sur `username_normalized` (lowercase + trim), `GET /users/resolve` exact uniquement (pas d'énumération). - **Identifiers**: `resource_id` / `device_user_id` / `user_id` / share-link `token` / `operation_id` sont des **lowercase 32-hex** TEXT (`^[0-9a-f]{32}$`, CHECK-enforced), stockés tels quels côté serveur (pas de conversion UUID). Le mobile génère toujours 32-hex. -- **Outbox idempotence + ordering**: le serveur applique les batchs de `pending_operations` **séquentiellement**, s'arrête à la première erreur non-idempotente et retourne l'index atteint. Consommé par le client Kotlin (`OutboxSyncWorker` → `POST /sync/ops`, batch 20, dead-letter immédiat sur 4xx non-idempotente, purge > 7 jours). `create_resource` porte le `parentResourceId` optionnel (racine si absent) ; `report_bytes` (`{ hasBytes }`, V2 placements, nouvel `operation_id` par changement d'état) — le walk SAF garantit parent avant enfant dans l'ordre d'`id`. +- **Outbox idempotence + ordering**: le serveur applique les batchs de `pending_operations` **séquentiellement**, s'arrête à la première erreur non-idempotente et retourne l'index atteint. Consommé par le client Kotlin (`OutboxSyncWorker` → `POST /sync/ops`, batch 20, dead-letter immédiat sur 4xx non-idempotente, purge > 7 jours). `create_resource` porte le `parentResourceId` optionnel (racine si absent) ; `report_bytes` (`{ hasBytes }`, V2 placements, nouvel `operation_id` par état) ; `share`/`update_share` acceptent `granteeUserId` XOR `granteeGroupId` (V2-6) — le walk SAF garantit parent avant enfant dans l'ordre d'`id`. - **Permissions snapshot**: le serveur pousse des snapshots `resource_permissions` (`effective_access` ranking viewer < commenter < editor < owner, `inherit`, `expires_at`, TTL 24h → read-only downgrade). Consommé par le client Kotlin (`ShareRepository` : hydratation + delta + `canAccess`). - **Lecture partagée** : `GET /files/:id/shares` + `GET /files/:id/links` (owner uniquement, 404 sinon) exposent grants et liens au propriétaire ; `GET /files/:id/content` streame les octets (viewer+, `Range` supporté). diff --git a/CHANGELOG.md b/CHANGELOG.md index e79dab4..f7216d8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,13 +5,17 @@ Le format suit [Keep a Changelog](https://keepachangelog.com/fr/1.1.0/) et le ve ## [Unreleased] +## [1.1.0] - 2026-09-25 + ### Ajouté - Upload V2 des octets : worker `BytesUploadWorker` (fichier par fichier, overwrite ciblée idempotente, cap 3 échecs, backoff), marqueurs `bytes_uploaded`/`bytes_upload_attempts` (Room v17, migration 16→17), multipart SAF mutualisé (`SafMultipart.kt`). -- Flag serveur `has_content` (migration `000014`, lazy healing : TRUE à l'upload / au `OpenContent` réussi, FALSE si octets disparus), exposé en `FileDto.hasContent` (persistance Room prévue en V2-2). +- Flag serveur `has_content` (migration `000014`, lazy healing : TRUE à l'upload / au `OpenContent` réussi, FALSE si octets disparus), exposé en `FileDto.hasContent` + miroir Room `has_content_server` (v18). - Download V2 hors-ligne : `DownloadWorker` (fichier par fichier, écriture SAF dossier propre sinon racine, rattachement même `resource_id`, walk convergent par URI), marqueurs `has_content_server`/`wanted_offline` (Room v18, migration 17→18), bouton « Rendre disponible hors-ligne » dans le viewer distant. - Purge sûre V2-3 « libérer de l'espace » : gate `isReleasable` (copie serveur connue), détachement cloud-only sans op outbox, bouton viewer + action multi-sélection. - Placements multi-device : tables `storage_locations` + `resource_placements` (migration `000015`), op outbox `report_bytes` (viewer+, nouvel `operation_id` par état, dead-letter sans bloquer la file), `GET /files/:id/placements` (owner-only), reporting auto (upload/download/release/delete locale), section copies dans le sheet de partage. - Rétention auto : règle `all` | `last_months:N` (`RetentionStore`), passe quotidienne `RetentionWorker` (purge sûre, sans réseau), réglages stockage (stats récupérables + libération manuelle). +- Groupes V2-6 (backend) : tables `groups` + `group_members` (migration `000016`, un niveau), CRUD + membres (owner-only), partage vers groupe via outbox (`granteeGroupId`, snapshot + enforcement étendus), `GROUP_NOT_FOUND`, lecture grants avec `granteeKind`. +- Groupes V2-6 (mobile) : section groupes du sheet (création, membres, suppression, partage au groupe), badge groupe sur les grants, endpoints CRUD + membres. ### Corrigé - 401 sans session (mode local / jamais connecté) : ignoré sans purge ni événement — un appel égaré n'éjecte plus vers le login. diff --git a/VERSION b/VERSION index 3eefcb9..9084fa2 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.0.0 +1.1.0 diff --git a/backend/.env.example b/backend/.env.example index 0c21c79..1b4eb86 100644 --- a/backend/.env.example +++ b/backend/.env.example @@ -8,7 +8,8 @@ MAX_FILE_SIZE_MB=50 OCR_LANG=fra+eng # Sécurité — à changer en production (jamais commité) -AUTH_SECRET=dev-secret-change-me +# ≥ 32 caractères, ex. `openssl rand -hex 32`. Doit matcher config.go (min 32). +AUTH_SECRET=dev-secret-change-me-please-set-in-prod # Premier admin (créé UNIQUEMENT si la table users est vide). Obligatoires au # premier démarrage ; ignorés ensuite (l'env n'écrase jamais un compte). diff --git a/backend/cmd/server/router_test.go b/backend/cmd/server/router_test.go index 838502b..a1f61bb 100644 --- a/backend/cmd/server/router_test.go +++ b/backend/cmd/server/router_test.go @@ -27,6 +27,13 @@ var expectedRoutes = []string{ "GET /api/v1/users/resolve", "PATCH /api/v1/users/me/password", + "POST /api/v1/groups", + "GET /api/v1/groups", + "POST /api/v1/groups/:id/members", + "GET /api/v1/groups/:id/members", + "DELETE /api/v1/groups/:id/members/:userId", + "DELETE /api/v1/groups/:id", + "POST /api/v1/ocr/jobs", "GET /api/v1/ocr/jobs/:id", diff --git a/backend/db/migrations/000016_groups.down.sql b/backend/db/migrations/000016_groups.down.sql new file mode 100644 index 0000000..11730d7 --- /dev/null +++ b/backend/db/migrations/000016_groups.down.sql @@ -0,0 +1,6 @@ +DROP INDEX IF EXISTS idx_shares_active_group; +ALTER TABLE shares DROP CONSTRAINT IF EXISTS shares_grantee_xor_check; +ALTER TABLE shares ALTER COLUMN grantee_user_id SET NOT NULL; +ALTER TABLE shares DROP COLUMN IF EXISTS grantee_group_id; +DROP TABLE IF EXISTS group_members; +DROP TABLE IF EXISTS groups; diff --git a/backend/db/migrations/000016_groups.up.sql b/backend/db/migrations/000016_groups.up.sql new file mode 100644 index 0000000..58343a2 --- /dev/null +++ b/backend/db/migrations/000016_groups.up.sql @@ -0,0 +1,32 @@ +-- V2-6 groupes : partage vers un ensemble d'utilisateurs (famille, équipe). +-- `groups` : identité nommée possédée (created_by) ; `group_members` : +-- appartenances (pas de groupes imbriqués — un niveau, documenté). +-- `shares` accepte une cible groupe : exactement une des deux cibles est +-- renseignée (CHECK), avec un index d'unicité active par cible. +CREATE TABLE groups ( + id TEXT PRIMARY KEY CHECK (id ~ '^[0-9a-f]{32}$'), + name TEXT NOT NULL CHECK (name <> '' AND char_length(name) <= 255), + created_by TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE, + created_at TIMESTAMPTZ DEFAULT NOW(), + updated_at TIMESTAMPTZ DEFAULT NOW() +); + +CREATE TABLE group_members ( + group_id TEXT NOT NULL REFERENCES groups(id) ON DELETE CASCADE, + user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE, + created_at TIMESTAMPTZ DEFAULT NOW(), + PRIMARY KEY (group_id, user_id) +); + +CREATE INDEX idx_group_members_user ON group_members(user_id); + +ALTER TABLE shares ADD COLUMN grantee_group_id TEXT REFERENCES groups(id) ON DELETE CASCADE; +ALTER TABLE shares ALTER COLUMN grantee_user_id DROP NOT NULL; +ALTER TABLE shares + ADD CONSTRAINT shares_grantee_xor_check + CHECK ( + (grantee_user_id IS NOT NULL AND grantee_group_id IS NULL) + OR (grantee_user_id IS NULL AND grantee_group_id IS NOT NULL) + ); +CREATE UNIQUE INDEX idx_shares_active_group + ON shares(resource_id, grantee_group_id) WHERE revoked_at IS NULL AND grantee_group_id IS NOT NULL; diff --git a/backend/db/migrations_test.go b/backend/db/migrations_test.go index bc5628b..3e547d9 100644 --- a/backend/db/migrations_test.go +++ b/backend/db/migrations_test.go @@ -349,6 +349,25 @@ func TestMigrationsUpDown(t *testing.T) { assertHexCheck(t, conn, "storage_locations", "id") assertHexCheck(t, conn, "storage_locations", "device_id") + assertHexCheck(t, conn, "groups", "id") + + // shares XOR : exactement une cible (user ou groupe). + var xorCheck int + err = conn.QueryRow(` + SELECT COUNT(*) FROM pg_constraint c + JOIN pg_class t ON t.oid = c.conrelid + WHERE t.relname = 'shares' + AND pg_get_constraintdef(c.oid) LIKE '%grantee_user_id%' + AND pg_get_constraintdef(c.oid) LIKE '%grantee_group_id%'`).Scan(&xorCheck) + if err != nil { + t.Fatalf("shares xor check: %v", err) + } + if xorCheck == 0 { + t.Error("CHECK XOR (grantee_user_id / grantee_group_id) manquant sur shares après 000016") + } + + // --- 000016 : groupes + cible groupe sur shares ------------------------- + assertTables(t, conn, "users", "devices", "resources", "operations", "ocr_jobs", "shares", "share_links", "storage_locations", "resource_placements", "groups", "group_members", "schema_migrations") if err := MigrateDownDatabase(url); err != nil { t.Fatalf("migrate down: %v", err) diff --git a/backend/handlers/groups.go b/backend/handlers/groups.go new file mode 100644 index 0000000..7b96ea0 --- /dev/null +++ b/backend/handlers/groups.go @@ -0,0 +1,143 @@ +package handlers + +import ( + "errors" + "net/http" + + "github.com/gin-gonic/gin" + + "github.com/kazier/backend/pkg/api" + "github.com/kazier/backend/service" +) + +// groupIDParam validates a 32-hex group id path param (404, never 400 — +// group ids are unguessable, no enumeration). +func groupIDParam(c *gin.Context, name string) (string, bool) { + id := c.Param(name) + if !deviceIDPattern.MatchString(id) { + api.Error(c, http.StatusNotFound, "NOT_FOUND", "group not found") + return "", false + } + return id, true +} + +// GroupsCreate stores an owned group : POST /groups {name}. +func GroupsCreate(c *gin.Context) { + if Store == nil { + api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized") + return + } + var body struct { + Name string `json:"name"` + } + if err := c.ShouldBindJSON(&body); err != nil { + api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid JSON body") + return + } + dto, err := Store.CreateGroup(c.GetString(UserIDKey), body.Name) + if err != nil { + if errors.Is(err, service.ErrInvalidUpload) { + api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid group name") + return + } + writeError(c, err) + return + } + api.OK(c, dto) +} + +// GroupsList returns owned + joined groups : GET /groups. +func GroupsList(c *gin.Context) { + if Store == nil { + api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized") + return + } + dtos, err := Store.ListGroups(c.GetString(UserIDKey)) + if err != nil { + writeError(c, err) + return + } + api.OK(c, dtos) +} + +// GroupMembersAdd adds an existing user : POST /groups/:id/members {userId}. +func GroupMembersAdd(c *gin.Context) { + if Store == nil { + api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized") + return + } + groupID, ok := groupIDParam(c, "id") + if !ok { + return + } + var body struct { + UserID string `json:"userId"` + } + if err := c.ShouldBindJSON(&body); err != nil || !deviceIDPattern.MatchString(body.UserID) { + api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid `userId`") + return + } + if err := Store.AddGroupMember(c.GetString(UserIDKey), groupID, body.UserID); err != nil { + writeError(c, err) + return + } + api.OK(c, gin.H{"id": groupID}) +} + +// GroupMembersRemove removes a membership : +// DELETE /groups/:id/members/:userId. +func GroupMembersRemove(c *gin.Context) { + if Store == nil { + api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized") + return + } + groupID, ok := groupIDParam(c, "id") + if !ok { + return + } + memberID, ok := groupIDParam(c, "userId") + if !ok { + return + } + if err := Store.RemoveGroupMember(c.GetString(UserIDKey), groupID, memberID); err != nil { + writeError(c, err) + return + } + api.OK(c, gin.H{"id": groupID}) +} + +// GroupsDelete removes an owned group : DELETE /groups/:id. +func GroupsDelete(c *gin.Context) { + if Store == nil { + api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized") + return + } + groupID, ok := groupIDParam(c, "id") + if !ok { + return + } + if err := Store.DeleteGroup(c.GetString(UserIDKey), groupID); err != nil { + writeError(c, err) + return + } + api.OK(c, gin.H{"id": groupID}) +} + +// GroupMembersList returns memberships of an owned group : +// GET /groups/:id/members. +func GroupMembersList(c *gin.Context) { + if Store == nil { + api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized") + return + } + groupID, ok := groupIDParam(c, "id") + if !ok { + return + } + members, err := Store.ListMembers(c.GetString(UserIDKey), groupID) + if err != nil { + writeError(c, err) + return + } + api.OK(c, members) +} diff --git a/backend/handlers/groups_test.go b/backend/handlers/groups_test.go new file mode 100644 index 0000000..2d0d66a --- /dev/null +++ b/backend/handlers/groups_test.go @@ -0,0 +1,108 @@ +package handlers_test + +import ( + "encoding/json" + "fmt" + "net/http" + "testing" + + "github.com/kazier/backend/repository" +) + +// V2-6 : CRUD groupes + membres via HTTP, scoping owner, 404 sans énumération. +func TestGroupsHttpFlow(t *testing.T) { + r, _, repo := setup(t) + ownerDevice := repository.NewID() + ownerToken, _ := registerAndLogin(t, r, repo, testUserUsername(ownerDevice, "go"), "groups-http-password", ownerDevice) + otherDevice := repository.NewID() + otherToken, _ := registerAndLogin(t, r, repo, testUserUsername(otherDevice, "gx"), "groups-http-password-b", otherDevice) + + // Création (nom trimé). + rec, _ := doRequest(t, r, http.MethodPost, "/api/v1/groups", ownerToken, []byte(`{"name":" Famille "}`), "application/json") + env := expectOK(t, rec, "groups-create") + var created struct { + ID string `json:"id"` + Name string `json:"name"` + Role string `json:"role"` + } + if err := json.Unmarshal(env.Data, &created); err != nil { + t.Fatalf("groups-create: unmarshal: %v", err) + } + if created.Name != "Famille" || created.Role != "owner" { + t.Errorf("groups-create = %+v", created) + } + // Nom vide → 400. + rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/groups", ownerToken, []byte(`{"name":" "}`), "application/json") + expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "groups-create-blank") + + // Liste owner (1, owner) ; tiers (0). + rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/groups", ownerToken, nil, "") + env = expectOK(t, rec, "groups-list-owner") + var listed []map[string]any + if err := json.Unmarshal(env.Data, &listed); err != nil { + t.Fatalf("groups-list: unmarshal: %v", err) + } + if len(listed) != 1 { + t.Errorf("groups-list-owner = %d, attendu 1", len(listed)) + } + rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/groups", otherToken, nil, "") + env = expectOK(t, rec, "groups-list-other") + listed = nil + if err := json.Unmarshal(env.Data, &listed); err != nil { + t.Fatalf("groups-list-other: unmarshal: %v", err) + } + if len(listed) != 0 { + t.Errorf("groups-list-other = %d, attendu 0", len(listed)) + } + + // Ajout membre : besoin d'un user existant — on le crée via un login. + memberDevice := repository.NewID() + _, memberID := registerAndLogin(t, r, repo, testUserUsername(memberDevice, "gm"), "groups-http-password-c", memberDevice) + rec, _ = doRequest( + t, r, http.MethodPost, "/api/v1/groups/"+created.ID+"/members", ownerToken, + []byte(fmt.Sprintf(`{"userId":%q}`, memberID)), "application/json", + ) + expectOK(t, rec, "groups-add-member") + // Liste membres (owner) : le membre ajouté ; tiers → 404. + rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/groups/"+created.ID+"/members", ownerToken, nil, "") + envMembers := expectOK(t, rec, "groups-list-members") + var members []map[string]any + if err := json.Unmarshal(envMembers.Data, &members); err != nil { + t.Fatalf("groups-list-members: unmarshal: %v", err) + } + if len(members) != 1 || members[0]["id"] != memberID { + t.Errorf("groups-list-members = %v, attendu 1 membre", members) + } + rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/groups/"+created.ID+"/members", otherToken, nil, "") + expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "groups-list-members-other") + // Non-owner → 404. + rec, _ = doRequest( + t, r, http.MethodPost, "/api/v1/groups/"+created.ID+"/members", otherToken, + []byte(fmt.Sprintf(`{"userId":%q}`, memberID)), "application/json", + ) + expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "groups-add-other") + // Membre inconnu → GRANTEE_NOT_FOUND. + rec, _ = doRequest( + t, r, http.MethodPost, "/api/v1/groups/"+created.ID+"/members", ownerToken, + []byte(fmt.Sprintf(`{"userId":%q}`, repository.NewID())), "application/json", + ) + expectError(t, rec, http.StatusNotFound, "GRANTEE_NOT_FOUND", "groups-add-unknown") + + // Groupe inconnu → 404 partout (pas d'énumération). + unknown := repository.NewID() + rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/groups/"+unknown+"/members", ownerToken, + []byte(fmt.Sprintf(`{"userId":%q}`, memberID)), "application/json") + expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "groups-add-unknown-group") + rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/groups/"+unknown, ownerToken, nil, "") + expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "groups-delete-unknown") + rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/groups/not-hex", ownerToken, nil, "") + expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "groups-invalid-id") + + // Retrait puis suppression. + rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/groups/"+created.ID+"/members/"+memberID, ownerToken, nil, "") + expectOK(t, rec, "groups-remove-member") + rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/groups/"+created.ID, otherToken, nil, "") + expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "groups-delete-other") + rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/groups/"+created.ID, ownerToken, nil, "") + expectOK(t, rec, "groups-delete") +} diff --git a/backend/handlers/router.go b/backend/handlers/router.go index bdf2e91..f573a0e 100644 --- a/backend/handlers/router.go +++ b/backend/handlers/router.go @@ -43,6 +43,13 @@ func RegisterRoutes(r *gin.Engine) { protected.GET("/users/resolve", ResolveUser) protected.PATCH("/users/me/password", ChangePassword) + protected.POST("/groups", GroupsCreate) + protected.GET("/groups", GroupsList) + protected.POST("/groups/:id/members", GroupMembersAdd) + protected.GET("/groups/:id/members", GroupMembersList) + protected.DELETE("/groups/:id/members/:userId", GroupMembersRemove) + protected.DELETE("/groups/:id", GroupsDelete) + protected.POST("/ocr/jobs", OcrJobsCreate) protected.GET("/ocr/jobs/:id", OcrJobsGet) diff --git a/backend/handlers/store.go b/backend/handlers/store.go index 62225f1..57d6d72 100644 --- a/backend/handlers/store.go +++ b/backend/handlers/store.go @@ -24,6 +24,8 @@ func writeError(c *gin.Context, err error) { api.Error(c, 404, "NOT_FOUND", "resource not found") case errors.Is(err, repository.ErrGranteeNotFound): api.Error(c, 404, "GRANTEE_NOT_FOUND", "the specified user does not exist") + case errors.Is(err, repository.ErrGroupNotFound): + api.Error(c, 404, "GROUP_NOT_FOUND", "the specified group does not exist") case errors.Is(err, repository.ErrNameConflict): api.Error(c, 409, "NAME_CONFLICT", "a resource with this name already exists here") case errors.Is(err, service.ErrFileTooLarge): diff --git a/backend/repository/groups.go b/backend/repository/groups.go new file mode 100644 index 0000000..6d5c84f --- /dev/null +++ b/backend/repository/groups.go @@ -0,0 +1,185 @@ +package repository + +import ( + "database/sql" + "errors" +) + +// Group is a named set of users (V2-6) : sharing to a group grants every +// member. One level only (no nested groups). The creator owns the group +// (member management + deletion) ; membership confers no admin rights. +type Group struct { + ID string + Name string + CreatedBy string +} + +// Groups implements group persistence. +type Groups struct { + DB *sql.DB +} + +// Create stores a group owned by ownerID and returns its id. +func (g *Groups) Create(name, ownerID string) (string, error) { + id := NewID() + _, err := g.DB.Exec( + `INSERT INTO groups (id, name, created_by) VALUES ($1, $2, $3)`, + id, name, ownerID, + ) + if err != nil { + return "", err + } + return id, nil +} + +// Get returns a group by id. No-rows → ErrNotFound. +func (g *Groups) Get(groupID string) (Group, error) { + var group Group + err := g.DB.QueryRow( + `SELECT id, name, created_by FROM groups WHERE id = $1`, + groupID, + ).Scan(&group.ID, &group.Name, &group.CreatedBy) + if errors.Is(err, sql.ErrNoRows) { + return Group{}, ErrNotFound + } + return group, err +} + +// IsOwner reports whether userID created the group. +func (g *Groups) IsOwner(groupID, userID string) (bool, error) { + var n int + err := g.DB.QueryRow( + `SELECT COUNT(*) FROM groups WHERE id = $1 AND created_by = $2`, + groupID, userID, + ).Scan(&n) + return n > 0, err +} + +// IsMember reports group membership (owner excluded : ownership is separate). +func (g *Groups) IsMember(groupID, userID string) (bool, error) { + var n int + err := g.DB.QueryRow( + `SELECT COUNT(*) FROM group_members WHERE group_id = $1 AND user_id = $2`, + groupID, userID, + ).Scan(&n) + return n > 0, err +} + +// GroupWithRole is a group listing row (owned or joined). +type GroupWithRole struct { + Group + Role string // "owner" | "member" +} + +// ListForUser returns groups the user owns or joins, owned first. +func (g *Groups) ListForUser(userID string) ([]GroupWithRole, error) { + rows, err := g.DB.Query( + `SELECT id, name, created_by, + CASE WHEN created_by = $1 THEN 'owner' ELSE 'member' END AS role + FROM groups + WHERE created_by = $1 OR id IN (SELECT group_id FROM group_members WHERE user_id = $1) + ORDER BY created_at ASC`, + userID, + ) + if err != nil { + return nil, err + } + defer rows.Close() + var out []GroupWithRole + for rows.Next() { + var gr GroupWithRole + if err := rows.Scan(&gr.ID, &gr.Name, &gr.CreatedBy, &gr.Role); err != nil { + return nil, err + } + out = append(out, gr) + } + return out, rows.Err() +} + +// AddMember inserts a membership. Idempotent on replay (ON CONFLICT DO +// NOTHING) ; returns rows-affected style via ErrNotFound when the group or +// the user does not exist (FK violation mapped). +func (g *Groups) AddMember(groupID, userID string) error { + _, err := g.DB.Exec( + `INSERT INTO group_members (group_id, user_id) VALUES ($1, $2) + ON CONFLICT DO NOTHING`, + groupID, userID, + ) + if isForeignKeyViolation(err) { + return ErrNotFound + } + return err +} + +// RemoveMember deletes a membership. Missing row → ErrNotFound. +func (g *Groups) RemoveMember(groupID, userID string) error { + result, err := g.DB.Exec( + `DELETE FROM group_members WHERE group_id = $1 AND user_id = $2`, + groupID, userID, + ) + if err != nil { + return err + } + affected, err := result.RowsAffected() + if err != nil { + return err + } + if affected == 0 { + return ErrNotFound + } + return nil +} + +// Member is a group membership row (owner view). +type Member struct { + UserID string + Username string +} + +// ListMembers returns memberships of a group, ordered by username. +func (g *Groups) ListMembers(groupID string) ([]Member, error) { + rows, err := g.DB.Query( + `SELECT u.id, COALESCE(u.username, u.id) + FROM group_members gm + JOIN users u ON u.id = gm.user_id AND u.deleted_at IS NULL + WHERE gm.group_id = $1 + ORDER BY COALESCE(u.username, u.id) ASC`, + groupID, + ) + if err != nil { + return nil, err + } + defer rows.Close() + var out []Member + for rows.Next() { + var m Member + if err := rows.Scan(&m.UserID, &m.Username); err != nil { + return nil, err + } + out = append(out, m) + } + return out, rows.Err() +} + +// Errors specific to groups. +var ErrGroupNotFound = errors.New("group not found") + +// Delete removes a group (owner only — caller checks). Shares targeting it +// cascade (FK), placements are untouched (device-scoped, not group-scoped). +func (g *Groups) Delete(groupID, ownerID string) error { + result, err := g.DB.Exec( + `DELETE FROM groups WHERE id = $1 AND created_by = $2`, + groupID, ownerID, + ) + 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/repository/repository.go b/backend/repository/repository.go index c99c696..2877490 100644 --- a/backend/repository/repository.go +++ b/backend/repository/repository.go @@ -13,6 +13,7 @@ type Repository struct { Users *Users Shares *Shares Placements *Placements + Groups *Groups } func NewRepository(conn *sql.DB) *Repository { @@ -24,5 +25,6 @@ func NewRepository(conn *sql.DB) *Repository { Users: &Users{DB: conn}, Shares: &Shares{DB: conn}, Placements: &Placements{DB: conn}, + Groups: &Groups{DB: conn}, } } diff --git a/backend/repository/resources.go b/backend/repository/resources.go index 518cce4..22a4fb8 100644 --- a/backend/repository/resources.go +++ b/backend/repository/resources.go @@ -113,7 +113,7 @@ const grantedCTE = ` sh.inherit, 0 FROM shares sh JOIN resources r ON r.resource_id = sh.resource_id - WHERE sh.grantee_user_id = $1 AND sh.revoked_at IS NULL + WHERE ` + granteeMatch + ` AND sh.revoked_at IS NULL AND (sh.expires_at IS NULL OR sh.expires_at > NOW()) AND r.deleted_at IS NULL ), diff --git a/backend/repository/shares.go b/backend/repository/shares.go index ae82f0f..911c3f2 100644 --- a/backend/repository/shares.go +++ b/backend/repository/shares.go @@ -71,11 +71,19 @@ type ResourceAccess struct { Inherit bool } -// Shares implements share persistence for user-to-user grants. +// Shares implements share persistence for user-to-user AND user-to-group +// grants (V2-6). A grant targets exactly one principal (shares XOR CHECK) : +// `grantee_user_id` for a user, `grantee_group_id` for a group (every member +// inherits, one level, no nesting). type Shares struct { DB *sql.DB } +// granteeMatch matches the grants visible to a user: direct user grants plus +// grants to any group they belong to. `$1` is always the user id in the +// enclosing query (snapshot, enforcement, visibility CTEs). +const granteeMatch = `(sh.grantee_user_id = $1 OR sh.grantee_group_id IN (SELECT group_id FROM group_members WHERE user_id = $1))` + // Upsert inserts or updates an active share. On conflict (active row for // same resource + grantee) the access, inherit, and expires_at are updated. func (s *Shares) Upsert(resourceID, granteeUserID, access string, inherit bool, expiresAt *time.Time, createdBy string) error { @@ -96,12 +104,13 @@ func (s *Shares) Upsert(resourceID, granteeUserID, access string, inherit bool, return err } -// Revoke soft-revokes the active share between a resource and a grantee. -func (s *Shares) Revoke(resourceID, granteeUserID string) error { +// Revoke soft-revokes the active share between a resource and a grantee +// (user id or group id — ids are unguessable 32-hex, globally unique). +func (s *Shares) Revoke(resourceID, granteeID string) error { result, err := s.DB.Exec( `UPDATE shares SET revoked_at = NOW(), updated_at = NOW() - WHERE resource_id = $1 AND grantee_user_id = $2 AND revoked_at IS NULL`, - resourceID, granteeUserID, + WHERE resource_id = $1 AND (grantee_user_id = $2 OR grantee_group_id = $2) AND revoked_at IS NULL`, + resourceID, granteeID, ) if err != nil { return err @@ -153,7 +162,7 @@ seeded(id, type, updated_at, parent_id, grant_rank, created_by, expires_at, gran sh.created_by, sh.expires_at, sh.inherit, r.name, TRUE FROM shares sh JOIN resources r ON r.resource_id = sh.resource_id - WHERE sh.grantee_user_id = $1 AND sh.revoked_at IS NULL + WHERE `+granteeMatch+` AND sh.revoked_at IS NULL AND (sh.expires_at IS NULL OR sh.expires_at > NOW()) AND r.deleted_at IS NULL ), @@ -263,7 +272,7 @@ direct AS ( SELECT CASE sh.access WHEN 'viewer' THEN 1 WHEN 'commenter' THEN 2 WHEN 'editor' THEN 3 ELSE 0 END AS rank FROM shares sh JOIN resources r ON r.resource_id = sh.resource_id - WHERE sh.resource_id = $2 AND sh.grantee_user_id = $1 + WHERE sh.resource_id = $2 AND `+granteeMatch+` AND sh.revoked_at IS NULL AND (sh.expires_at IS NULL OR sh.expires_at > NOW()) AND r.deleted_at IS NULL @@ -276,7 +285,7 @@ inherited(id, grant_rank, depth) AS ( SELECT r.parent_id, COALESCE((SELECT CASE sh.access WHEN 'viewer' THEN 1 WHEN 'commenter' THEN 2 WHEN 'editor' THEN 3 ELSE 0 END FROM shares sh - WHERE sh.resource_id = r.parent_id AND sh.grantee_user_id = $1 + WHERE sh.resource_id = r.parent_id AND `+granteeMatch+` AND sh.revoked_at IS NULL AND sh.inherit AND (sh.expires_at IS NULL OR sh.expires_at > NOW())), 0), 0 @@ -286,7 +295,7 @@ inherited(id, grant_rank, depth) AS ( SELECT r.parent_id, COALESCE((SELECT CASE sh.access WHEN 'viewer' THEN 1 WHEN 'commenter' THEN 2 WHEN 'editor' THEN 3 ELSE 0 END FROM shares sh - WHERE sh.resource_id = ag.id AND sh.grantee_user_id = $1 + WHERE sh.resource_id = ag.id AND `+granteeMatch+` AND sh.revoked_at IS NULL AND sh.inherit AND (sh.expires_at IS NULL OR sh.expires_at > NOW())), 0), ag.depth + 1 @@ -455,14 +464,44 @@ func (s *Shares) ListActiveLinksForResource(resourceID string) ([]LinkInfo, erro return links, rows.Err() } -// ShareGrant is one active user-to-user grant on a resource (owner view). +// ShareGrant is one active grant on a resource (owner view). Exactly one of +// GranteeUserID / GranteeGroupID is set (mirrors the shares XOR CHECK). type ShareGrant struct { - GranteeUserID string - Username string - Access string - Inherit bool - ExpiresAt *time.Time - UpdatedAt time.Time + GranteeUserID string + GranteeGroupID string + Username string + Access string + Inherit bool + ExpiresAt *time.Time + UpdatedAt time.Time +} + +// GrantKind returns "group" for group-targeted grants, "user" otherwise. +func (g ShareGrant) GrantKind() string { + if g.GranteeGroupID != "" { + return "group" + } + return "user" +} + +// UpsertGroup inserts or updates an active group-targeted share. Same +// idempotent semantics as Upsert, keyed by (resource, group). +func (s *Shares) UpsertGroup(resourceID, groupID, access string, inherit bool, expiresAt *time.Time, createdBy string) error { + var expires any + if expiresAt != nil { + expires = *expiresAt + } + _, err := s.DB.Exec( + `INSERT INTO shares (id, resource_id, grantee_group_id, access, inherit, created_by, expires_at) + VALUES ($1, $2, $3, $4, $5, $6, $7) + ON CONFLICT (resource_id, grantee_group_id) WHERE revoked_at IS NULL AND grantee_group_id IS NOT NULL + DO UPDATE SET access = EXCLUDED.access, + inherit = EXCLUDED.inherit, + expires_at = EXCLUDED.expires_at, + updated_at = NOW()`, + NewID(), resourceID, groupID, access, inherit, createdBy, expires, + ) + return err } // ListActiveForResource returns the active (non-revoked) grants on a resource, @@ -470,10 +509,12 @@ type ShareGrant struct { // the caller filters display. Empty (not error) when nothing is shared. func (s *Shares) ListActiveForResource(resourceID string) ([]ShareGrant, error) { rows, err := s.DB.Query( - `SELECT s.grantee_user_id, COALESCE(u.username, s.grantee_user_id), + `SELECT s.grantee_user_id, s.grantee_group_id, + COALESCE(u.username, gr.name, COALESCE(s.grantee_user_id, s.grantee_group_id)), s.access, s.inherit, s.expires_at, s.updated_at FROM shares s LEFT JOIN users u ON u.id = s.grantee_user_id AND u.deleted_at IS NULL + LEFT JOIN groups gr ON gr.id = s.grantee_group_id WHERE s.resource_id = $1 AND s.revoked_at IS NULL ORDER BY s.created_at ASC`, resourceID, @@ -485,12 +526,20 @@ func (s *Shares) ListActiveForResource(resourceID string) ([]ShareGrant, error) var grants []ShareGrant for rows.Next() { var ( - g ShareGrant - expiresAt sql.NullTime + g ShareGrant + granteeUser sql.NullString + granteeGrp sql.NullString + expiresAt sql.NullTime ) - if err := rows.Scan(&g.GranteeUserID, &g.Username, &g.Access, &g.Inherit, &expiresAt, &g.UpdatedAt); err != nil { + if err := rows.Scan(&granteeUser, &granteeGrp, &g.Username, &g.Access, &g.Inherit, &expiresAt, &g.UpdatedAt); err != nil { return nil, err } + if granteeUser.Valid { + g.GranteeUserID = granteeUser.String + } + if granteeGrp.Valid { + g.GranteeGroupID = granteeGrp.String + } if expiresAt.Valid { g.ExpiresAt = &expiresAt.Time } diff --git a/backend/service/groups.go b/backend/service/groups.go new file mode 100644 index 0000000..d769d0e --- /dev/null +++ b/backend/service/groups.go @@ -0,0 +1,114 @@ +package service + +import ( + "errors" + "strings" + + "github.com/kazier/backend/repository" +) + +// GroupDTO serializes a group for GET /groups. +type GroupDTO struct { + ID string `json:"id"` + Name string `json:"name"` + Role string `json:"role"` // "owner" | "member" +} + +// sanitizeGroupName trims + caps display names (same spirit as file names). +func sanitizeGroupName(name string) (string, error) { + n := strings.TrimSpace(name) + if n == "" || len(n) > 255 { + return "", ErrInvalidUpload + } + return n, nil +} + +// CreateGroup stores a group owned by userID. +func (s *Resources) CreateGroup(userID, name string) (GroupDTO, error) { + clean, err := sanitizeGroupName(name) + if err != nil { + return GroupDTO{}, err + } + id, err := s.Repository.Groups.Create(clean, userID) + if err != nil { + return GroupDTO{}, err + } + return GroupDTO{ID: id, Name: clean, Role: "owner"}, nil +} + +// ListGroups returns groups the user owns or joins. +func (s *Resources) ListGroups(userID string) ([]GroupDTO, error) { + groups, err := s.Repository.Groups.ListForUser(userID) + if err != nil { + return nil, err + } + out := make([]GroupDTO, 0, len(groups)) + for _, gr := range groups { + out = append(out, GroupDTO{ID: gr.ID, Name: gr.Name, Role: gr.Role}) + } + return out, nil +} + +// AddGroupMember adds an existing active user to a group the caller owns. +// Unknown group (or not owned) → ErrNotFound (no enumeration) ; unknown +// member → ErrGranteeNotFound (same code as share recipients). +func (s *Resources) AddGroupMember(userID, groupID, memberID string) error { + owner, err := s.Repository.Groups.IsOwner(groupID, userID) + if err != nil { + return err + } + if !owner { + return repository.ErrNotFound + } + if _, err := s.Repository.Users.GetByID(memberID); err != nil { + if errors.Is(err, repository.ErrNotFound) { + return repository.ErrGranteeNotFound + } + return err + } + return s.Repository.Groups.AddMember(groupID, memberID) +} + +// RemoveGroupMember removes a membership (group must be owned by caller). +// Missing membership → ErrNotFound (idempotent-safe callers treat as done). +func (s *Resources) RemoveGroupMember(userID, groupID, memberID string) error { + owner, err := s.Repository.Groups.IsOwner(groupID, userID) + if err != nil { + return err + } + if !owner { + return repository.ErrNotFound + } + return s.Repository.Groups.RemoveMember(groupID, memberID) +} + +// MemberDTO serializes a membership for GET /groups/:id/members. +type MemberDTO struct { + ID string `json:"id"` + Username string `json:"username"` +} + +// ListMembers returns memberships of a group the caller owns. +func (s *Resources) ListMembers(userID, groupID string) ([]MemberDTO, error) { + owner, err := s.Repository.Groups.IsOwner(groupID, userID) + if err != nil { + return nil, err + } + if !owner { + return nil, repository.ErrNotFound + } + members, err := s.Repository.Groups.ListMembers(groupID) + if err != nil { + return nil, err + } + out := make([]MemberDTO, 0, len(members)) + for _, m := range members { + out = append(out, MemberDTO{ID: m.UserID, Username: m.Username}) + } + return out, nil +} + +// DeleteGroup removes an owned group (member shares cascade via FK). +func (s *Resources) DeleteGroup(userID, groupID string) error { + return s.Repository.Groups.Delete(groupID, userID) +} diff --git a/backend/service/groups_test.go b/backend/service/groups_test.go new file mode 100644 index 0000000..e9dae63 --- /dev/null +++ b/backend/service/groups_test.go @@ -0,0 +1,195 @@ +package service + +import ( + "testing" + + "github.com/kazier/backend/repository" +) + +// V2-6 : partage vers un groupe — les membres voient la ressource +// (snapshot + enforcement), les non-membres non. Révocation et suppression +// du groupe convergent. +func TestGroupShareSnapshotAndEnforcement(t *testing.T) { + s := newServiceStore(t) + ownerID := mustCreateUser(t, s.Repository, "grp-owner") + memberID := mustCreateUser(t, s.Repository, "grp-member") + outsiderID := mustCreateUser(t, s.Repository, "grp-outsider") + deviceID := mustRegisterDevice(t, s.Repository, shareTestDeviceID) + + groupID, err := s.Repository.Groups.Create("Famille", ownerID) + if err != nil { + t.Fatalf("create group: %v", err) + } + if err := s.Repository.Groups.AddMember(groupID, memberID); err != nil { + t.Fatalf("add member: %v", err) + } + + fileID := repository.NewID() + if _, err := s.ApplyBatch(ownerID, deviceID, []SyncOperation{ + syncOp(repository.NewID(), fileID, OpCreateResource, "file", map[string]any{"name": "g.txt"}), + syncOp(repository.NewID(), fileID, OpShare, "file", map[string]any{ + "granteeGroupId": groupID, + "access": "editor", + }), + }); err != nil { + t.Fatalf("create+share-group: %v", err) + } + + // Snapshot membre : rang editor hérité du groupe. + perms, err := s.Snapshot(memberID, 0) + if err != nil { + t.Fatalf("Snapshot member: %v", err) + } + if len(perms) != 1 || perms[0].EffectiveAccess != "editor" { + t.Fatalf("snapshot membre = %+v, attendu 1 editor", perms) + } + + // Enforcement : le membre lit (GET file), l'outsider non. + ra, err := s.Repository.Shares.EffectiveAccess(memberID, fileID) + if err != nil || !ra.Accessible || ra.EffectiveRank != repository.AccessEditor { + t.Errorf("EffectiveAccess membre = %+v err=%v, attendu editor", ra, err) + } + row, err := s.Repo.GetFileVisible(memberID, fileID) + if err != nil || row.ID != fileID { + t.Errorf("membre doit voir le fichier : %+v err=%v", row, err) + } + if _, err := s.Repo.GetFileVisible(outsiderID, fileID); err == nil { + t.Errorf("outsider ne doit pas voir le fichier") + } + + // Owner listing : grant kind=group au nom du groupe. + grants, err := s.ListShares(ownerID, fileID) + if err != nil || len(grants) != 1 { + t.Fatalf("ListShares = %+v err=%v", grants, err) + } + if grants[0].GranteeKind != "group" || grants[0].GranteeUserID != groupID || grants[0].Username != "Famille" { + t.Errorf("grant groupe = %+v", grants[0]) + } + + // Retrait du membre → disparaît du snapshot au pull complet. + if err := s.Repository.Groups.RemoveMember(groupID, memberID); err != nil { + t.Fatalf("remove member: %v", err) + } + perms, err = s.Snapshot(memberID, 0) + if err != nil { + t.Fatalf("Snapshot après retrait: %v", err) + } + if len(perms) != 0 { + t.Errorf("snapshot après retrait = %+v, attendu vide", perms) + } + + // Suppression du groupe → plus de partage (cascade FK). + member2 := mustCreateUser(t, s.Repository, "grp-member2") + if err := s.Repository.Groups.AddMember(groupID, member2); err != nil { + t.Fatalf("add member2: %v", err) + } + if _, err := s.ApplyBatch(ownerID, deviceID, []SyncOperation{ + syncOp(repository.NewID(), fileID, OpShare, "file", map[string]any{ + "granteeGroupId": groupID, + "access": "viewer", + }), + }); err != nil { + t.Fatalf("re-share: %v", err) + } + if err := s.DeleteGroup(ownerID, groupID); err != nil { + t.Fatalf("delete group: %v", err) + } + perms, err = s.Snapshot(member2, 0) + if err != nil { + t.Fatalf("Snapshot après delete: %v", err) + } + if len(perms) != 0 { + t.Errorf("snapshot après delete groupe = %+v, attendu vide", perms) + } +} + +func TestGroupShareValidation(t *testing.T) { + s := newServiceStore(t) + ownerID := mustCreateUser(t, s.Repository, "grpval-owner") + deviceID := mustRegisterDevice(t, s.Repository, shareTestDeviceID) + + fileID := repository.NewID() + if _, err := s.ApplyBatch(ownerID, deviceID, []SyncOperation{ + syncOp(repository.NewID(), fileID, OpCreateResource, "file", map[string]any{"name": "v.txt"}), + }); err != nil { + t.Fatalf("create: %v", err) + } + + apply := func(payload map[string]any) (SyncResult, error) { + return s.ApplyBatch(ownerID, deviceID, []SyncOperation{ + syncOp(repository.NewID(), fileID, OpShare, "file", payload), + }) + } + + // Groupe inconnu → GROUP_NOT_FOUND. + denied, err := apply(map[string]any{"granteeGroupId": repository.NewID(), "access": "viewer"}) + if err != nil || denied.Applied != 0 || denied.Failed == nil || denied.Failed.Code != "GROUP_NOT_FOUND" { + t.Errorf("groupe inconnu: attendu halt GROUP_NOT_FOUND, got %+v err=%v", denied, err) + } + // Deux cibles → INVALID_REQUEST. + both, err := apply(map[string]any{ + "granteeUserId": ownerID, "granteeGroupId": repository.NewID(), "access": "viewer", + }) + if err != nil || both.Applied != 0 || both.Failed == nil || both.Failed.Code != "INVALID_REQUEST" { + t.Errorf("deux cibles: attendu halt INVALID_REQUEST, got %+v err=%v", both, err) + } + // Aucune cible → INVALID_REQUEST. + none, err := apply(map[string]any{"access": "viewer"}) + if err != nil || none.Applied != 0 || none.Failed == nil || none.Failed.Code != "INVALID_REQUEST" { + t.Errorf("sans cible: attendu halt INVALID_REQUEST, got %+v err=%v", none, err) + } +} + +func TestGroupManagementScoping(t *testing.T) { + s := newServiceStore(t) + ownerID := mustCreateUser(t, s.Repository, "gm-owner") + otherID := mustCreateUser(t, s.Repository, "gm-other") + memberID := mustCreateUser(t, s.Repository, "gm-member") + + group, err := s.CreateGroup(ownerID, " Équipe ") + if err != nil { + t.Fatalf("create: %v", err) + } + if group.Name != "Équipe" || group.Role != "owner" { + t.Errorf("groupe = %+v (nom trimé attendu)", group) + } + if _, err := s.CreateGroup(ownerID, " "); err == nil { + t.Errorf("nom vide attendu rejeté") + } + + // Non-owner ne peut ni ajouter ni supprimer. + if err := s.AddGroupMember(otherID, group.ID, memberID); err == nil { + t.Errorf("add par non-owner attendu refusé") + } + if err := s.AddGroupMember(ownerID, group.ID, memberID); err != nil { + t.Fatalf("add: %v", err) + } + // Membre inexistant → GRANTEE_NOT_FOUND. + if err := s.AddGroupMember(ownerID, group.ID, repository.NewID()); err != repository.ErrGranteeNotFound { + t.Errorf("membre inconnu: attendu ErrGranteeNotFound, got %v", err) + } + if err := s.RemoveGroupMember(otherID, group.ID, memberID); err == nil { + t.Errorf("remove par non-owner attendu refusé") + } + + // Listes : owner voit (owner), membre voit (member), tiers ne voit rien. + owned, _ := s.ListGroups(ownerID) + if len(owned) != 1 || owned[0].Role != "owner" { + t.Errorf("list owner = %+v", owned) + } + joined, _ := s.ListGroups(memberID) + if len(joined) != 1 || joined[0].Role != "member" { + t.Errorf("list member = %+v", joined) + } + none, _ := s.ListGroups(otherID) + if len(none) != 0 { + t.Errorf("list tiers = %+v, attendu vide", none) + } + + if err := s.DeleteGroup(otherID, group.ID); err == nil { + t.Errorf("delete par non-owner attendu refusé") + } + if err := s.DeleteGroup(ownerID, group.ID); err != nil { + t.Fatalf("delete: %v", err) + } +} diff --git a/backend/service/shares.go b/backend/service/shares.go index 0766be5..740c6b9 100644 --- a/backend/service/shares.go +++ b/backend/service/shares.go @@ -9,8 +9,11 @@ import ( // ShareGrantDTO serializes one active grant for GET /files/:id/shares. // Milliseconds epoch (null = never), mirroring the permissions snapshot // (docs/api-v1.md §6.2) for cheap client-side expiry checks. +// `granteeKind` is "user" or "group" (V2-6) ; `granteeUserId` carries the +// principal id either way, `username` its display name. type ShareGrantDTO struct { GranteeUserID string `json:"granteeUserId"` + GranteeKind string `json:"granteeKind"` Username string `json:"username"` Access string `json:"access"` Inherit bool `json:"inherit"` @@ -51,8 +54,13 @@ func (s *Resources) ListShares(userID, resourceID string) ([]ShareGrantDTO, erro ms := g.ExpiresAt.UnixMilli() expires = &ms } + granteeID := g.GranteeUserID + if g.GranteeGroupID != "" { + granteeID = g.GranteeGroupID + } out = append(out, ShareGrantDTO{ - GranteeUserID: g.GranteeUserID, + GranteeUserID: granteeID, + GranteeKind: g.GrantKind(), Username: g.Username, Access: g.Access, Inherit: g.Inherit, diff --git a/backend/service/sync.go b/backend/service/sync.go index 2a926e9..468dce5 100644 --- a/backend/service/sync.go +++ b/backend/service/sync.go @@ -67,10 +67,11 @@ type movePayload struct { } type sharePayload struct { - GranteeUserID string `json:"granteeUserId"` - Access string `json:"access"` - Inherit *bool `json:"inherit"` - ExpiresAt *int64 `json:"expiresAt"` + GranteeUserID string `json:"granteeUserId"` + GranteeGroupID string `json:"granteeGroupId"` + Access string `json:"access"` + Inherit *bool `json:"inherit"` + ExpiresAt *int64 `json:"expiresAt"` } type revokeSharePayload struct { @@ -99,6 +100,8 @@ func classifySyncError(err error) (string, string) { return "NOT_FOUND", "target resource or folder not found" case errors.Is(err, repository.ErrGranteeNotFound): return "GRANTEE_NOT_FOUND", "the specified user does not exist" + case errors.Is(err, repository.ErrGroupNotFound): + return "GROUP_NOT_FOUND", "the specified group does not exist" case errors.Is(err, repository.ErrPayloadMismatch): return "INVALID_REQUEST", "operation replayed with different payload" case errors.Is(err, errCycle): @@ -383,23 +386,22 @@ func (s *Resources) applyShareOp(ownerID, resourceID string, op *SyncOperation) if err := json.Unmarshal(op.Payload, &p); err != nil { return errors.New("invalid payload: " + err.Error()) } - if p.GranteeUserID == "" { - return errors.New("payload.granteeUserId required") + // Cible : exactement un principal (user XOR groupe, V2-6). + isUser := p.GranteeUserID != "" + isGroup := p.GranteeGroupID != "" + if isUser == isGroup { + return errors.New("payload requires exactly one of granteeUserId, granteeGroupId") } - if !resourceIDPattern.MatchString(p.GranteeUserID) { + if isUser && !resourceIDPattern.MatchString(p.GranteeUserID) { return errors.New("payload.granteeUserId must be 32 lowercase hex chars") } + if isGroup && !resourceIDPattern.MatchString(p.GranteeGroupID) { + return errors.New("payload.granteeGroupId must be 32 lowercase hex chars") + } rank := repository.AccessFromString(p.Access) if rank < repository.AccessViewer || rank > repository.AccessEditor { return errors.New("payload.access must be viewer, commenter, or editor") } - // Validate grantee exists and is active. - if _, err := s.Repository.Users.GetByID(p.GranteeUserID); err != nil { - if errors.Is(err, repository.ErrNotFound) { - return repository.ErrGranteeNotFound - } - return err - } inherit := true if p.Inherit != nil { inherit = *p.Inherit @@ -412,8 +414,28 @@ func (s *Resources) applyShareOp(ownerID, resourceID string, op *SyncOperation) } expiresAt = &t } - if err := s.Repository.Shares.Upsert(resourceID, p.GranteeUserID, p.Access, inherit, expiresAt, ownerID); err != nil { - return err + if isUser { + // Validate grantee exists and is active. + if _, err := s.Repository.Users.GetByID(p.GranteeUserID); err != nil { + if errors.Is(err, repository.ErrNotFound) { + return repository.ErrGranteeNotFound + } + return err + } + if err := s.Repository.Shares.Upsert(resourceID, p.GranteeUserID, p.Access, inherit, expiresAt, ownerID); err != nil { + return err + } + } else { + // Validate group exists (any group : ids are unguessable, no enum). + if _, err := s.Repository.Groups.Get(p.GranteeGroupID); err != nil { + if errors.Is(err, repository.ErrNotFound) { + return repository.ErrGroupNotFound + } + return err + } + if err := s.Repository.Shares.UpsertGroup(resourceID, p.GranteeGroupID, p.Access, inherit, expiresAt, ownerID); err != nil { + return err + } } // Bump resource updated_at so the grantee's delta snapshot picks it up. // Scopé owner (ExistsOwner vérifié plus haut) : TouchOwned, jamais le diff --git a/docker-compose.yml b/docker-compose.yml index 34b6fa2..e0c0427 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -30,9 +30,9 @@ services: UPLOAD_DIR: /app/uploads MAX_FILE_SIZE_MB: ${MAX_FILE_SIZE_MB:-50} OCR_LANG: ${OCR_LANG:-fra+eng} - AUTH_SECRET: ${AUTH_SECRET:?AUTH_SECRET requis (voir backend/.env.example)} - ADMIN_USERNAME: ${ADMIN_USERNAME:?ADMIN_USERNAME requis au premier démarrage} - ADMIN_PASSWORD: ${ADMIN_PASSWORD:?ADMIN_PASSWORD requis au premier démarrage} + AUTH_SECRET: ${AUTH_SECRET:-dev-secret-change-me-please-set-in-prod} + ADMIN_USERNAME: ${ADMIN_USERNAME:-admin} + ADMIN_PASSWORD: ${ADMIN_PASSWORD:-change-me} volumes: - backend-uploads:/app/uploads depends_on: diff --git a/docs/api-v1.md b/docs/api-v1.md index 096bf98..64c30ad 100644 --- a/docs/api-v1.md +++ b/docs/api-v1.md @@ -45,9 +45,15 @@ Références : `V2.md` (modèle cible), `mobile/services/db/` (conventions sync) | POST | `/ocr/jobs` | `{ "fileId": "…" }` | `OcrJob` | — | | GET | `/ocr/jobs/:id` | — | `OcrJob` | `NOT_FOUND` | | GET | `/files/:id/ocr` | — | `FileOcr` (`{ text, updatedAt }`) | `NOT_FOUND` | -| GET | `/files/:id/shares` | — (owner uniquement) | `ShareGrant[]` (`{ granteeUserId, username, access, inherit, expiresAt (ms\|null), updatedAt (ms) }`) | `NOT_FOUND` (non-owner ou inconnue — pas d'énumération) | +| GET | `/files/:id/shares` | — (owner uniquement) | `ShareGrant[]` (`{ granteeUserId, granteeKind: "user"|"group", username, access, inherit, expiresAt (ms|null), updatedAt (ms) }`) | `NOT_FOUND` (non-owner ou inconnue — pas d'énumération) | | GET | `/files/:id/links` | — (owner uniquement) | `ShareLink[]` (même forme que `GET /shares/links/:token`) | `NOT_FOUND` (non-owner ou inconnue) | | GET | `/files/:id/placements` | — (owner uniquement) | `Placement[]` (`{ locationType: "server"|"mobile", deviceId?, hasBytes, updatedAt }`, entrée serveur en premier) | `NOT_FOUND` (non-owner ou inconnue) | +| POST | `/groups` | `{ "name" }` | `{ "id", "name", "role": "owner" }` | `INVALID_REQUEST` (nom vide/trop long) | +| GET | `/groups` | — | `Group[]` (`{ "id", "name", "role": "owner"|"member" }`, possédés + rejoints) | — | +| POST | `/groups/:id/members` | `{ "userId": "…32-hex" }` | `{ "id": "…" }` | `NOT_FOUND` (groupe d'autrui/inconnu), `GRANTEE_NOT_FOUND` (membre inconnu) | +| GET | `/groups/:id/members` | — (owner uniquement) | `Member[]` (`{ "id", "username" }`) | `NOT_FOUND` | +| DELETE | `/groups/:id/members/:userId` | — | `{ "id": "…" }` | `NOT_FOUND` | +| DELETE | `/groups/:id` | — | `{ "id": "…" }` | `NOT_FOUND` (d'autrui/inconnu) | | POST | `/sync/ops` | voir §6 | voir §6 | — | | GET | `/sync/permissions` | query `after?` (cached_at ms) | `ResourcePermission[]` | — | @@ -118,7 +124,7 @@ type FileOcr = { text: string; updatedAt?: string | null }; - `create_resource` : crée la ressource ; **déjà présente → no-op** (rejeu idempotent). `payload.name` obligatoire ; `payload.parentResourceId` (32-hex, optionnel) = dossier parent — absent → racine. **Parent inexistant → `NOT_FOUND`** (cohérent avec `move_resource`). Ordre garanti par construction client : le walk SAF émet les `create` des dossiers (ordre préfixe) avant ceux des fichiers, dans la même transaction Room → `id ASC` = parent avant enfant. - `update_metadata` : ressource absente → **no-op** (état terminal atteint) ; **ressource partagée : nécessite `editor+`** (§6.2) — sinon `NOT_FOUND` (une ressource visible mais sans droit de mutation n'est pas renommée) ; une ressource sans relation applicable (ni owner, ni grant) reste un no-op (pas d'énumération). `move_resource` / `delete_resource` restent **owner-only** (scoping par `user_id`, les ops d'un non-owner sont des no-op). - `delete_resource` : **idempotent** — suppression d'une ressource absente = succès. - - **Partage** (`share` / `update_share`, même sémantique d'upsert) : `payload = { "granteeUserId": "…32-hex", "access": "viewer"|"commenter"|"editor", "inherit"?: bool, "expiresAt"?: ms }`. La ressource doit **appartenir** au user appelant (sinon `NOT_FOUND`) ; le grantee doit exister (sinon `GRANTEE_NOT_FOUND`) ; accès déjà partagé → mis à jour (idempotent). Privilégier `viewer` < `commenter` < `editor` (< `owner` réservé à l'ownership, non partageable → `INVALID_REQUEST`). + - **Partage** (`share` / `update_share`, même sémantique d'upsert) : `payload = { "granteeUserId"?: "…32-hex", "granteeGroupId"?: "…32-hex", "access": "viewer"|"commenter"|"editor", "inherit"?: bool, "expiresAt"?: ms }` — **exactement un** principal (user XOR groupe, V2-6). La ressource doit **appartenir** au user appelant (sinon `NOT_FOUND`) ; le grantee user doit exister (sinon `GRANTEE_NOT_FOUND`), le groupe doit exister (sinon `GROUP_NOT_FOUND`) ; accès déjà partagé → mis à jour (idempotent). Privilégier `viewer` < `commenter` < `editor` (< `owner` réservé à l'ownership, non partageable → `INVALID_REQUEST`). Les membres d'un groupe partagé héritent du grant (un niveau, sans imbrication) dans le snapshot comme dans l'enforcement. - `revoke_share` : `payload = { "granteeUserId": "…32-hex" }`. **Idempotent** (déjà révoqué/absent → no-op). - `create_link` : `payload = { "token": "…32-hex", "access": "viewer"|"commenter"|"editor", "expiresAt"?: ms }`. Le token est **généré côté client** (`GenerateId`), c'est l'identifiant du lien (colonne `id` de `share_links`). - `revoke_link` : `payload = { "token": "…32-hex" }`. **Idempotent**. @@ -165,7 +171,7 @@ type ResourcePermission = { - 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`). -- Partage : `GRANTEE_NOT_FOUND` (404 — grantee inexistant sur une op share), `NOT_FOUND` (404 — ressource non possédée sur une op share : scoping, pas d'énumération). +- 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). diff --git a/mise.toml b/mise.toml index 3f0c9e7..c03a278 100644 --- a/mise.toml +++ b/mise.toml @@ -1,7 +1,7 @@ [tasks.up_backend] description = "Start PostgreSQL + backend API (Go/Gin)" run = [ - "docker compose up -d postgres --wait", + "if [ -f backend/.env ]; then docker compose --env-file backend/.env up -d postgres --wait; else docker compose up -d postgres --wait; fi", "cd backend && go run cmd/server/main.go", ] 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 cb21657..21329e3 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 @@ -7,7 +7,11 @@ import com.squareup.moshi.Moshi import com.kazier.mobile.data.remote.dto.ApiEnvelope import com.kazier.mobile.data.remote.dto.ApiErrorEnvelope import com.kazier.mobile.data.remote.dto.ApiMeta +import com.kazier.mobile.data.remote.dto.AddGroupMemberDto import com.kazier.mobile.data.remote.dto.ChangePasswordDto +import com.kazier.mobile.data.remote.dto.CreateGroupDto +import com.kazier.mobile.data.remote.dto.GroupDto +import com.kazier.mobile.data.remote.dto.GroupMemberDto import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto import com.kazier.mobile.data.remote.dto.FileDto import com.kazier.mobile.data.remote.dto.FileOcrDto @@ -184,6 +188,30 @@ class ApiClient @Inject constructor( suspend fun listPlacements(fileId: String): List = unwrap({ apiService.listPlacements(fileId) }) + /** Crée un groupe possédé (`POST /groups`). */ + suspend fun createGroup(name: String): GroupDto = + unwrap({ apiService.createGroup(CreateGroupDto(name.trim())) }) + + /** Groupes possédés + rejoints (`GET /groups`). */ + suspend fun listGroups(): List = + unwrap({ apiService.listGroups() }) + + /** Ajoute un membre résolu (`POST /groups/:id/members`). */ + suspend fun addGroupMember(groupId: String, userId: String): String = + unwrap({ apiService.addGroupMember(groupId, AddGroupMemberDto(userId)) }).id + + /** Membres d'un groupe possédé (`GET /groups/:id/members`). */ + suspend fun listGroupMembers(groupId: String): List = + unwrap({ apiService.listGroupMembers(groupId) }) + + /** Retire un membre (`DELETE /groups/:id/members/:userId`). */ + suspend fun removeGroupMember(groupId: String, userId: String): String = + unwrap({ apiService.removeGroupMember(groupId, userId) }).id + + /** Supprime un groupe possédé (`DELETE /groups/:id`). */ + suspend fun deleteGroup(groupId: String): String = + unwrap({ apiService.deleteGroup(groupId) }).id + /** * Octets physiques d'un fichier visible — `GET /files/:id/content` * (binaire brut, hors enveloppe). Streaming sans cache : lecture bornée 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 05dd0fe..5e16804 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 @@ -6,6 +6,10 @@ import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto import com.kazier.mobile.data.remote.dto.FileDto import com.kazier.mobile.data.remote.dto.FileOcrDto import com.kazier.mobile.data.remote.dto.FolderDto +import com.kazier.mobile.data.remote.dto.AddGroupMemberDto +import com.kazier.mobile.data.remote.dto.CreateGroupDto +import com.kazier.mobile.data.remote.dto.GroupDto +import com.kazier.mobile.data.remote.dto.GroupMemberDto import com.kazier.mobile.data.remote.dto.IdResultDto import com.kazier.mobile.data.remote.dto.LoginRequestDto import com.kazier.mobile.data.remote.dto.LoginResponseDto @@ -198,4 +202,40 @@ interface ApiService { suspend fun listPlacements( @Path("id") fileId: String, ): Response>> + + /** Crée un groupe possédé (`POST /groups`). */ + @POST("groups") + suspend fun createGroup( + @Body body: CreateGroupDto, + ): Response> + + /** Groupes possédés + rejoints (`GET /groups`). */ + @GET("groups") + suspend fun listGroups(): Response>> + + /** Ajoute un membre (owner du groupe, `POST /groups/:id/members`). */ + @POST("groups/{id}/members") + suspend fun addGroupMember( + @Path("id") groupId: String, + @Body body: AddGroupMemberDto, + ): Response> + + /** Membres d'un groupe possédé (`GET /groups/:id/members`). */ + @GET("groups/{id}/members") + suspend fun listGroupMembers( + @Path("id") groupId: String, + ): Response>> + + /** Retire un membre (`DELETE /groups/:id/members/:userId`). */ + @DELETE("groups/{id}/members/{userId}") + suspend fun removeGroupMember( + @Path("id") groupId: String, + @Path("userId") userId: String, + ): Response> + + /** Supprime un groupe possédé (`DELETE /groups/:id`). */ + @DELETE("groups/{id}") + suspend fun deleteGroup( + @Path("id") groupId: String, + ): Response> } \ No newline at end of file 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 969f38e..26d214b 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 @@ -134,10 +134,12 @@ data class PlacementDto( * Grant actif `GET /files/:id/shares` (owner uniquement) — miroir de * `ShareGrantDTO` Go. `expiresAt` en ms epoch (null = jamais), même * convention que le snapshot `ResourcePermissionDto` pour les comparaisons - * locales (`System.currentTimeMillis()`). + * locales (`System.currentTimeMillis()`). `granteeKind` = "user" | "group" + * (V2-6) ; `granteeUserId` porte l'id du principal, `username` son nom. */ data class ShareGrantDto( @Json(name = "granteeUserId") val granteeUserId: String, + @Json(name = "granteeKind") val granteeKind: String = "user", @Json(name = "username") val username: String, @Json(name = "access") val access: String, @Json(name = "inherit") val inherit: Boolean, @@ -145,6 +147,31 @@ data class ShareGrantDto( @Json(name = "updatedAt") val updatedAt: Long = 0L, ) +/** + * Groupe V2-6 (`GET /groups`) — possédé ou rejoint (`role`). + */ +data class GroupDto( + @Json(name = "id") val id: String, + @Json(name = "name") val name: String, + @Json(name = "role") val role: String, +) + +/** Membre d'un groupe (`GET /groups/:id/members`, owner). */ +data class GroupMemberDto( + @Json(name = "id") val id: String, + @Json(name = "username") val username: String, +) + +/** Création de groupe (`POST /groups`). */ +data class CreateGroupDto( + @Json(name = "name") val name: String, +) + +/** Ajout d'un membre (`POST /groups/:id/members`). */ +data class AddGroupMemberDto( + @Json(name = "userId") val userId: String, +) + /** Outbox — une op du batch `POST /sync/ops` (docs/api-v1.md §6.1). */ data class SyncOpDto( @Json(name = "operation_id") val operationId: String, 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 b64be36..6a9bf26 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 @@ -112,13 +112,15 @@ class OutboxRepository @Inject constructor( ) /** - * Raccourci `share` — payload `{ granteeUserId, access }` (voir - * docs/api-v1.md §6.1). `access`: viewer | commenter | editor. + * Raccourci `share` — payload `{ granteeUserId|granteeGroupId, access }` + * (voir docs/api-v1.md §6.1). `access`: viewer | commenter | editor. + * Exactement un principal (le serveur rejette sinon). */ suspend fun enqueueShare( resourceId: String, resourceType: String, - granteeUserId: String, + granteeUserId: String? = null, + granteeGroupId: String? = null, access: String, inherit: Boolean = true, expiresAt: Long? = null, @@ -127,7 +129,8 @@ class OutboxRepository @Inject constructor( resourceId = resourceId, resourceType = resourceType, payload = buildMap { - put("granteeUserId", granteeUserId) + granteeUserId?.let { put("granteeUserId", it) } + granteeGroupId?.let { put("granteeGroupId", it) } put("access", access) put("inherit", inherit) expiresAt?.let { put("expiresAt", it) } @@ -164,12 +167,13 @@ class OutboxRepository @Inject constructor( /** * Raccourci `update_share` — même payload que `share` (m21 : update d'un - * partage existant inopérant sans écrivain). + * partage existant inopérant sans écrivain). Principal user ou groupe. */ suspend fun enqueueUpdateShare( resourceId: String, resourceType: String, - granteeUserId: String, + granteeUserId: String? = null, + granteeGroupId: String? = null, access: String, inherit: Boolean = true, expiresAt: Long? = null, @@ -178,7 +182,8 @@ class OutboxRepository @Inject constructor( resourceId = resourceId, resourceType = resourceType, payload = buildMap { - put("granteeUserId", granteeUserId) + granteeUserId?.let { put("granteeUserId", it) } + granteeGroupId?.let { put("granteeGroupId", it) } put("access", access) put("inherit", inherit) expiresAt?.let { put("expiresAt", it) } 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 7dd564d..1ed2f0a 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 @@ -14,9 +14,11 @@ import androidx.compose.foundation.rememberScrollState import androidx.compose.foundation.verticalScroll import androidx.compose.material.icons.Icons import androidx.compose.material.icons.filled.Check +import androidx.compose.material.icons.filled.Close import androidx.compose.material.icons.filled.Cloud import androidx.compose.material.icons.filled.ContentCopy import androidx.compose.material.icons.filled.Delete +import androidx.compose.material.icons.filled.Group import androidx.compose.material.icons.filled.Link import androidx.compose.material.icons.filled.Share import androidx.compose.material.icons.filled.Smartphone @@ -164,6 +166,17 @@ fun ShareBottomSheet( onCreate = { access -> viewModel.createLink(resourceId, resourceType, access) }, onRevoke = { link -> viewModel.revokeLink(resourceId, resourceType, link) }, ) + GroupsSection( + groups = state.groups, + groupError = state.groupError, + onCreate = { viewModel.createGroup(it) }, + onDelete = { viewModel.deleteGroup(it) }, + onAddMember = { group, username -> viewModel.addMember(group, username) }, + onRemoveMember = { group, member -> viewModel.removeMember(group, member) }, + onShareToGroup = { group, access -> + viewModel.shareToGroup(resourceId, resourceType, group, access) + }, + ) } } @@ -307,11 +320,15 @@ private fun GrantsSection( fontWeight = FontWeight.Medium, maxLines = 1, ) - if (grant.expired) { + if (grant.kind == "group" || grant.expired) { Text( - text = stringResource(R.string.share_expired), + text = listOfNotNull( + if (grant.kind == "group") stringResource(R.string.share_grant_group) else null, + if (grant.expired) stringResource(R.string.share_expired) else null, + ).joinToString(" · "), style = MaterialTheme.typography.labelSmall, - color = MaterialTheme.colorScheme.error, + color = if (grant.expired) MaterialTheme.colorScheme.error + else MaterialTheme.colorScheme.onSurfaceVariant, ) } } @@ -354,7 +371,7 @@ private fun GrantsSection( /** Sélecteur d'accès compact pour une ligne de grant existant. */ @OptIn(ExperimentalMaterial3Api::class) @Composable -private fun GrantAccessPicker(selected: String, onSelect: (String) -> Unit) { +internal fun GrantAccessPicker(selected: String, onSelect: (String) -> Unit) { var expanded by rememberSaveable { mutableStateOf(false) } val label = ACCESS_OPTIONS.firstOrNull { it.value == selected }?.labelRes ?: ACCESS_OPTIONS.first().labelRes @@ -589,6 +606,213 @@ private fun accessLabel(access: String): String = stringResource( }, ) +/** Groupes V2-6 : création, membres (owner), suppression, partage au groupe. */ +@Composable +private fun GroupsSection( + groups: List, + groupError: String?, + onCreate: (String) -> Unit, + onDelete: (GroupUi) -> Unit, + onAddMember: (GroupUi, String) -> Unit, + onRemoveMember: (GroupUi, GroupMemberUi) -> Unit, + onShareToGroup: (GroupUi, String) -> Unit, +) { + var newName by rememberSaveable { mutableStateOf("") } + var pendingDelete by rememberSaveable { mutableStateOf(null) } + + SectionTitle(stringResource(R.string.share_section_groups)) + Row( + modifier = Modifier.fillMaxWidth(), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(8.dp), + ) { + OutlinedTextField( + value = newName, + onValueChange = { newName = it }, + label = { Text(stringResource(R.string.share_group_name_hint)) }, + singleLine = true, + modifier = Modifier.weight(1f), + ) + Button( + onClick = { + onCreate(newName.trim()) + newName = "" + }, + enabled = newName.isNotBlank(), + ) { + Text(stringResource(R.string.share_group_create)) + } + } + + groupError?.let { code -> + Text( + text = stringResource( + if (code == "USER_NOT_FOUND") R.string.share_error_not_found + else R.string.share_error_generic, + ), + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.error, + modifier = Modifier.fillMaxWidth(), + ) + } + + if (groups.isEmpty()) { + Text( + text = stringResource(R.string.share_empty_groups), + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } else { + groups.forEach { group -> + GroupRow( + group = group, + onDelete = { pendingDelete = group }, + onAddMember = { onAddMember(group, it) }, + onRemoveMember = { onRemoveMember(group, it) }, + onShareToGroup = { onShareToGroup(group, it) }, + ) + } + } + + pendingDelete?.let { group -> + AlertDialog( + onDismissRequest = { pendingDelete = null }, + text = { Text(stringResource(R.string.share_group_delete_confirm, group.name)) }, + confirmButton = { + TextButton(onClick = { + onDelete(group) + pendingDelete = null + }) { + Text(stringResource(R.string.share_confirm)) + } + }, + dismissButton = { + TextButton(onClick = { pendingDelete = null }) { + Text(stringResource(R.string.share_cancel)) + } + }, + ) + } +} + +@Composable +private fun GroupRow( + group: GroupUi, + onDelete: () -> Unit, + onAddMember: (String) -> Unit, + onRemoveMember: (GroupMemberUi) -> Unit, + onShareToGroup: (String) -> Unit, +) { + var memberName by rememberSaveable(group.id) { mutableStateOf("") } + var shareAccess by rememberSaveable(group.id) { mutableStateOf(ShareAccessLevel.VIEWER) } + var showMembers by rememberSaveable(group.id) { mutableStateOf(false) } + + Column( + modifier = Modifier.fillMaxWidth(), + verticalArrangement = Arrangement.spacedBy(4.dp), + ) { + Row( + modifier = Modifier.fillMaxWidth(), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(4.dp), + ) { + Icon( + Icons.Filled.Group, + contentDescription = null, + tint = MaterialTheme.colorScheme.onSurfaceVariant, + modifier = Modifier.size(20.dp), + ) + Text( + text = group.name, + style = MaterialTheme.typography.bodyMedium, + fontWeight = FontWeight.Medium, + modifier = Modifier.weight(1f), + maxLines = 1, + ) + Text( + text = stringResource( + if (group.isOwner) R.string.share_group_role_owner + else R.string.share_group_role_member, + ), + style = MaterialTheme.typography.labelSmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + if (group.isOwner) { + IconButton(onClick = onDelete) { + Icon( + Icons.Filled.Delete, + contentDescription = stringResource(R.string.share_group_delete), + tint = MaterialTheme.colorScheme.error, + ) + } + } + } + // Partager la ressource courante à ce groupe. + Row( + modifier = Modifier.fillMaxWidth(), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(8.dp), + ) { + GrantAccessPicker( + selected = shareAccess, + onSelect = { shareAccess = it }, + ) + OutlinedButton(onClick = { onShareToGroup(shareAccess) }) { + Text(stringResource(R.string.share_group_share)) + } + if (group.isOwner) { + TextButton(onClick = { showMembers = !showMembers }) { + Text(stringResource(R.string.share_group_members, group.members.size)) + } + } + } + if (showMembers && group.isOwner) { + group.members.forEach { member -> + Row( + modifier = Modifier.fillMaxWidth().padding(start = 28.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + Text( + text = member.username, + style = MaterialTheme.typography.bodySmall, + modifier = Modifier.weight(1f), + ) + IconButton(onClick = { onRemoveMember(member) }) { + Icon( + Icons.Filled.Close, + contentDescription = stringResource(R.string.share_revoke), + tint = MaterialTheme.colorScheme.error, + modifier = Modifier.size(18.dp), + ) + } + } + } + Row( + modifier = Modifier.fillMaxWidth().padding(start = 28.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(8.dp), + ) { + OutlinedTextField( + value = memberName, + onValueChange = { memberName = it }, + label = { Text(stringResource(R.string.share_username_hint)) }, + singleLine = true, + modifier = Modifier.weight(1f), + ) + Button( + onClick = { + onAddMember(memberName.trim()) + memberName = "" + }, + enabled = memberName.isNotBlank(), + ) { + Text(stringResource(R.string.share_group_add)) + } + } + } + } +} + @Composable private fun OpenLinkSection( resolving: Boolean, 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 8477db6..c88d0a1 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 @@ -28,6 +28,8 @@ object ShareAccessLevel { /** Grant actif affiché dans le sheet (miroir `ShareGrantDto`). */ data class ShareGrantUi( val granteeUserId: String, + /** "user" | "group" (V2-6) — `granteeUserId` porte l'id du principal. */ + val kind: String = "user", val username: String, val access: String, val inherit: Boolean, @@ -60,6 +62,20 @@ data class PlacementUi( val hasBytes: Boolean, ) +/** Groupe affiché dans le sheet (V2-6) + membres si possédé. */ +data class GroupUi( + val id: String, + val name: String, + val role: String, + val members: List = emptyList(), + val isOwner: Boolean = role == "owner", +) + +data class GroupMemberUi( + val id: String, + val username: String, +) + data class ShareUiState( val loading: Boolean = false, /** Cible courante du sheet (resource partagée). */ @@ -69,6 +85,10 @@ data class ShareUiState( val links: List = emptyList(), /** Présence des octets (serveur + reports devices, V2). */ val placements: List = emptyList(), + /** Groupes possédés + rejoints (V2-6). */ + val groups: List = emptyList(), + /** Erreur transitoire des actions groupes. */ + val groupError: String? = null, /** Ops de partage en attente d'envoi (pas encore reflétées serveur). */ val pendingCount: Int = 0, /** Erreur de chargement des listes (`LOAD_FAILED`, `FORBIDDEN`). */ @@ -127,6 +147,8 @@ class ShareViewModel @Inject constructor( resourceType = resourceType, actionError = null, ) } + // Groupes (gestion + partage vers groupe) : global, rechargé avec le sheet. + loadGroups() viewModelScope.launch { runCatching { val shares = apiClient.listShares(resourceId) @@ -142,6 +164,7 @@ class ShareViewModel @Inject constructor( shares = shares.map { dto -> ShareGrantUi( granteeUserId = dto.granteeUserId, + kind = dto.granteeKind, username = dto.username, access = dto.access, inherit = dto.inherit, @@ -182,8 +205,7 @@ class ShareViewModel @Inject constructor( * 2. enqueue `share` dans l'outbox ; * 3. déclenche le drain du worker + recharge le compteur pending. */ - fun share(resourceId: String, resourceType: String, username: String, access: String) { - if (_uiState.value.sharing) return + fun share(resourceId: String, resourceType: String, username: String, access: String) { if (_uiState.value.sharing) return viewModelScope.launch { _uiState.update { it.copy(sharing = true, error = null, enqueued = false) } runCatching { @@ -216,12 +238,21 @@ class ShareViewModel @Inject constructor( viewModelScope.launch { _uiState.update { it.copy(actionError = null) } runCatching { - outboxRepository.enqueueUpdateShare( - resourceId = resourceId, - resourceType = resourceType, - granteeUserId = grant.granteeUserId, - access = access, - ) + if (grant.kind == "group") { + outboxRepository.enqueueUpdateShare( + resourceId = resourceId, + resourceType = resourceType, + granteeGroupId = grant.granteeUserId, + access = access, + ) + } else { + outboxRepository.enqueueUpdateShare( + resourceId = resourceId, + resourceType = resourceType, + granteeUserId = grant.granteeUserId, + access = access, + ) + } }.onSuccess { OutboxSyncWorker.enqueue(appContext) _uiState.update { state -> @@ -349,6 +380,116 @@ class ShareViewModel @Inject constructor( } } + /** Partage avec un groupe (`share` ciblant `granteeGroupId`, V2-6). */ + fun shareToGroup(resourceId: String, resourceType: String, group: GroupUi, access: String) { + viewModelScope.launch { + _uiState.update { it.copy(actionError = null) } + runCatching { + outboxRepository.enqueueShare( + resourceId = resourceId, + resourceType = resourceType, + granteeGroupId = group.id, + access = access, + ) + }.onSuccess { + OutboxSyncWorker.enqueue(appContext) + Timber.d("share: group op enqueued for %s", resourceId) + refreshPending(resourceId) + }.onFailure { e -> + Timber.w(e, "share to group failed") + _uiState.update { it.copy(actionError = "SHARE_FAILED") } + } + } + } + + /** Charge les groupes + membres des groupes possédés (section groupes). */ + fun loadGroups() { + viewModelScope.launch { + _uiState.update { it.copy(groupError = null) } + runCatching { + val groups = apiClient.listGroups() + groups.map { dto -> + val members = if (dto.role == "owner") { + runCatching { apiClient.listGroupMembers(dto.id) }.getOrDefault(emptyList()) + } else { + emptyList() + } + GroupUi( + id = dto.id, + name = dto.name, + role = dto.role, + members = members.map { GroupMemberUi(it.id, it.username) }, + ) + } + }.onSuccess { groups -> + _uiState.update { it.copy(groups = groups) } + }.onFailure { e -> + Timber.w(e, "share: load groups failed") + _uiState.update { it.copy(groupError = "SHARE_FAILED") } + } + } + } + + /** Crée un groupe possédé. */ + fun createGroup(name: String) { + if (name.isBlank()) return + viewModelScope.launch { + _uiState.update { it.copy(groupError = null) } + runCatching { apiClient.createGroup(name) } + .onSuccess { loadGroups() } + .onFailure { e -> + Timber.w(e, "share: create group failed") + _uiState.update { it.copy(groupError = "SHARE_FAILED") } + } + } + } + + /** Supprime un groupe possédé (partages vers lui cascadés serveur). */ + fun deleteGroup(group: GroupUi) { + viewModelScope.launch { + _uiState.update { it.copy(groupError = null) } + runCatching { apiClient.deleteGroup(group.id) } + .onSuccess { loadGroups() } + .onFailure { e -> + Timber.w(e, "share: delete group failed") + _uiState.update { it.copy(groupError = "SHARE_FAILED") } + } + } + } + + /** Ajoute un membre (username exact → resolve → add → recharge). */ + fun addMember(group: GroupUi, username: String) { + if (username.isBlank()) { + _uiState.update { it.copy(groupError = "USER_NOT_FOUND") } + return + } + viewModelScope.launch { + _uiState.update { it.copy(groupError = null) } + runCatching { + val user = apiClient.resolveUser(username) + apiClient.addGroupMember(group.id, user.id) + }.onSuccess { loadGroups() } + .onFailure { e -> + val code = if (e is ApiException && e.code == "NOT_FOUND") "USER_NOT_FOUND" else "SHARE_FAILED" + Timber.w(e, "share: add member failed") + _uiState.update { it.copy(groupError = code) } + } + } + } + + /** Retire un membre. */ + fun removeMember(group: GroupUi, member: GroupMemberUi) { + viewModelScope.launch { + _uiState.update { it.copy(groupError = null) } + runCatching { apiClient.removeGroupMember(group.id, member.id) } + .onSuccess { loadGroups() } + .onFailure { e -> + Timber.w(e, "share: remove member failed") + _uiState.update { it.copy(groupError = "SHARE_FAILED") } + } + } + } + /** Recharge les listes serveur (bouton réessayer / après drain). */ fun refresh() { val state = _uiState.value 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 5e9fde6..91db43f 100644 --- a/mobile-kotlin/app/src/main/res/values-en/strings.xml +++ b/mobile-kotlin/app/src/main/res/values-en/strings.xml @@ -355,6 +355,19 @@ You do not own this resource. Retry Confirm + + Groups + No groups — create one to share with many at once. + Group name + Create + Delete group + Delete group %1$s? Shares to it will stop. + owner + member + Members (%1$d) + Add + Share here + group Local storage diff --git a/mobile-kotlin/app/src/main/res/values/strings.xml b/mobile-kotlin/app/src/main/res/values/strings.xml index b1a1294..01d1a2d 100644 --- a/mobile-kotlin/app/src/main/res/values/strings.xml +++ b/mobile-kotlin/app/src/main/res/values/strings.xml @@ -356,6 +356,19 @@ Vous ne possédez pas cette ressource. Réessayer Confirmer + + Groupes + Aucun groupe — créez-en un pour partager à plusieurs d\'un coup. + Nom du groupe + Créer + Supprimer le groupe + Supprimer le groupe %1$s ? Les partages vers lui cesseront. + gérant + membre + Membres (%1$d) + Ajouter + Partager ici + groupe Stockage local 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 ea55ffc..1b06bb7 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 @@ -12,6 +12,10 @@ import com.kazier.mobile.data.local.AppDatabase import com.kazier.mobile.data.local.entity.PendingOpStatus import com.kazier.mobile.data.local.entity.PendingOperationType import com.kazier.mobile.data.remote.dto.ApiEnvelope +import com.kazier.mobile.data.remote.dto.AddGroupMemberDto +import com.kazier.mobile.data.remote.dto.CreateGroupDto +import com.kazier.mobile.data.remote.dto.GroupDto +import com.kazier.mobile.data.remote.dto.GroupMemberDto import com.kazier.mobile.data.remote.dto.ChangePasswordDto import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto import com.kazier.mobile.data.remote.dto.FileDto @@ -337,5 +341,30 @@ class Auth401Test { override suspend fun listPlacements( fileId: String, ): Response>> = Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun createGroup( + body: CreateGroupDto, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listGroups(): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun addGroupMember( + groupId: String, + body: AddGroupMemberDto, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listGroupMembers( + groupId: String, + ): Response>> = Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun removeGroupMember( + groupId: String, + userId: String, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun deleteGroup( + groupId: String, + ): Response> = Response.success(ApiEnvelope()) } } 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 b8736f9..0b07f0e 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 @@ -8,6 +8,10 @@ import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory import com.kazier.mobile.data.local.AppDatabase import com.kazier.mobile.data.remote.dto.ApiEnvelope import com.kazier.mobile.data.remote.dto.ApiMeta +import com.kazier.mobile.data.remote.dto.AddGroupMemberDto +import com.kazier.mobile.data.remote.dto.CreateGroupDto +import com.kazier.mobile.data.remote.dto.GroupDto +import com.kazier.mobile.data.remote.dto.GroupMemberDto import com.kazier.mobile.data.remote.dto.ChangePasswordDto import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto import com.kazier.mobile.data.remote.dto.FileDto @@ -211,5 +215,30 @@ class PaginationTest { override suspend fun listPlacements( fileId: String, ): Response>> = Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun createGroup( + body: CreateGroupDto, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listGroups(): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun addGroupMember( + groupId: String, + body: AddGroupMemberDto, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listGroupMembers( + groupId: String, + ): Response>> = Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun removeGroupMember( + groupId: String, + userId: String, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun deleteGroup( + groupId: String, + ): Response> = Response.success(ApiEnvelope()) } } 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 66aa475..d0a2f30 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 @@ -3,6 +3,10 @@ package com.kazier.mobile.data.remote import com.squareup.moshi.Moshi import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory import com.kazier.mobile.data.remote.dto.ApiEnvelope +import com.kazier.mobile.data.remote.dto.AddGroupMemberDto +import com.kazier.mobile.data.remote.dto.CreateGroupDto +import com.kazier.mobile.data.remote.dto.GroupDto +import com.kazier.mobile.data.remote.dto.GroupMemberDto import com.kazier.mobile.data.remote.dto.ChangePasswordDto import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto import com.kazier.mobile.data.remote.dto.FileDto @@ -150,5 +154,30 @@ class RemoteContentTest { override suspend fun listPlacements( fileId: String, ): Response>> = Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun createGroup( + body: CreateGroupDto, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listGroups(): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun addGroupMember( + groupId: String, + body: AddGroupMemberDto, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listGroupMembers( + groupId: String, + ): Response>> = Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun removeGroupMember( + groupId: String, + userId: String, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun deleteGroup( + groupId: String, + ): Response> = Response.success(ApiEnvelope()) } } 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 bb9a7da..028edf8 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 @@ -15,6 +15,10 @@ 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.data.remote.dto.ApiEnvelope +import com.kazier.mobile.data.remote.dto.AddGroupMemberDto +import com.kazier.mobile.data.remote.dto.CreateGroupDto +import com.kazier.mobile.data.remote.dto.GroupDto +import com.kazier.mobile.data.remote.dto.GroupMemberDto import com.kazier.mobile.data.remote.dto.ChangePasswordDto import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto import com.kazier.mobile.data.remote.dto.FileDto @@ -355,5 +359,30 @@ class SessionReloginTest { override suspend fun listPlacements( fileId: String, ): Response>> = Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun createGroup( + body: CreateGroupDto, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listGroups(): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun addGroupMember( + groupId: String, + body: AddGroupMemberDto, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listGroupMembers( + groupId: String, + ): Response>> = Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun removeGroupMember( + groupId: String, + userId: String, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun deleteGroup( + groupId: String, + ): Response> = Response.success(ApiEnvelope()) } } 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 ba254fa..87c2760 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 @@ -3,6 +3,10 @@ package com.kazier.mobile.data.remote import com.squareup.moshi.Moshi import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory import com.kazier.mobile.data.remote.dto.ApiEnvelope +import com.kazier.mobile.data.remote.dto.AddGroupMemberDto +import com.kazier.mobile.data.remote.dto.CreateGroupDto +import com.kazier.mobile.data.remote.dto.GroupDto +import com.kazier.mobile.data.remote.dto.GroupMemberDto import com.kazier.mobile.data.remote.dto.ChangePasswordDto import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto import com.kazier.mobile.data.remote.dto.FileDto @@ -50,8 +54,8 @@ class ShareManagementTest { @Test fun `listShares_retourne_les_grants`() = runTest { val grants = listOf( - ShareGrantDto("aa01", "alice", "editor", true, null, 1_700_000_000_000L), - ShareGrantDto("bb02", "bob", "viewer", false, 1_800_000_000_000L, 1_700_000_000_001L), + ShareGrantDto("aa01", "user", "alice", "editor", true, null, 1_700_000_000_000L), + ShareGrantDto("bb02", "group", "bob", "viewer", false, 1_800_000_000_000L, 1_700_000_000_001L), ) val fake = SharesFake(shares = grants) val got = client(fake).listShares("f".repeat(32)) @@ -102,10 +106,29 @@ class ShareManagementTest { assertEquals("d".repeat(32), got[1].deviceId) } + @Test + fun `groups_crud_mappe_dtos`() = runTest { + val groups = listOf( + GroupDto("g".repeat(32), "Famille", "owner"), + GroupDto("h".repeat(32), "Boulot", "member"), + ) + val members = listOf(GroupMemberDto("u".repeat(32), "alice")) + val fake = SharesFake(groups = groups, members = members) + val c = client(fake) + assertEquals(listOf("Famille", "Boulot"), c.listGroups().map { it.name }) + assertEquals("alice", c.listGroupMembers("g".repeat(32)).single().username) + assertEquals("g".repeat(32), c.createGroup("Famille").id) + assertEquals("g".repeat(32), c.addGroupMember("g".repeat(32), "u".repeat(32))) + assertEquals("g".repeat(32), c.removeGroupMember("g".repeat(32), "u".repeat(32))) + assertEquals("g".repeat(32), c.deleteGroup("g".repeat(32))) + } + private class SharesFake( private val shares: List = emptyList(), private val links: List = emptyList(), private val placements: List = emptyList(), + private val groups: List = emptyList(), + private val members: List = emptyList(), private val failShares: Boolean = false, private val failLink: Boolean = false, ) : ApiService { @@ -179,5 +202,31 @@ class ShareManagementTest { private fun errBody(code: String) = "{\"error\":{\"code\":\"$code\",\"message\":\"x\"}}".toResponseBody("application/json".toMediaType()) + + override suspend fun createGroup( + body: CreateGroupDto, + ): Response> = + Response.success(ApiEnvelope(data = GroupDto("g".repeat(32), body.name, "owner"))) + + override suspend fun listGroups(): Response>> = + Response.success(ApiEnvelope(data = groups)) + + override suspend fun addGroupMember( + groupId: String, + body: AddGroupMemberDto, + ): Response> = Response.success(ApiEnvelope(data = IdResultDto(groupId))) + + override suspend fun listGroupMembers( + groupId: String, + ): Response>> = Response.success(ApiEnvelope(data = members)) + + override suspend fun removeGroupMember( + groupId: String, + userId: String, + ): Response> = Response.success(ApiEnvelope(data = IdResultDto(groupId))) + + override suspend fun deleteGroup( + groupId: String, + ): Response> = Response.success(ApiEnvelope(data = IdResultDto(groupId))) } } 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 9a85c16..78cdc6c 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 @@ -18,6 +18,10 @@ 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.AddGroupMemberDto +import com.kazier.mobile.data.remote.dto.CreateGroupDto +import com.kazier.mobile.data.remote.dto.GroupDto +import com.kazier.mobile.data.remote.dto.GroupMemberDto import com.kazier.mobile.data.remote.dto.ChangePasswordDto import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto import com.kazier.mobile.data.remote.dto.FileDto @@ -282,5 +286,30 @@ class BytesUploadTest { override suspend fun listPlacements( fileId: String, ): Response>> = Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun createGroup( + body: CreateGroupDto, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listGroups(): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun addGroupMember( + groupId: String, + body: AddGroupMemberDto, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listGroupMembers( + groupId: String, + ): Response>> = Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun removeGroupMember( + groupId: String, + userId: String, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun deleteGroup( + groupId: String, + ): Response> = Response.success(ApiEnvelope()) } } 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 e698f6e..e3b0986 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 @@ -16,6 +16,10 @@ import com.kazier.mobile.data.local.entity.PendingOpStatus import com.kazier.mobile.data.remote.ApiClient import com.kazier.mobile.data.remote.ApiService import com.kazier.mobile.data.remote.dto.ApiEnvelope +import com.kazier.mobile.data.remote.dto.AddGroupMemberDto +import com.kazier.mobile.data.remote.dto.CreateGroupDto +import com.kazier.mobile.data.remote.dto.GroupDto +import com.kazier.mobile.data.remote.dto.GroupMemberDto import com.kazier.mobile.data.remote.dto.ChangePasswordDto import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto import com.kazier.mobile.data.remote.dto.IdResultDto @@ -397,4 +401,29 @@ private class FolderMergeApiService : ApiService { override suspend fun listPlacements( fileId: String, ): Response>> = Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun createGroup( + body: CreateGroupDto, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listGroups(): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun addGroupMember( + groupId: String, + body: AddGroupMemberDto, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listGroupMembers( + groupId: String, + ): Response>> = Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun removeGroupMember( + groupId: String, + userId: String, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun deleteGroup( + groupId: String, + ): Response> = Response.success(ApiEnvelope()) } \ No newline at end of file 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 c863ba3..d83ca68 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 @@ -22,6 +22,10 @@ import com.kazier.mobile.data.local.entity.PendingOpStatus import com.kazier.mobile.data.remote.ApiClient import com.kazier.mobile.data.remote.ApiService import com.kazier.mobile.data.remote.dto.ApiEnvelope +import com.kazier.mobile.data.remote.dto.AddGroupMemberDto +import com.kazier.mobile.data.remote.dto.CreateGroupDto +import com.kazier.mobile.data.remote.dto.GroupDto +import com.kazier.mobile.data.remote.dto.GroupMemberDto import com.kazier.mobile.data.remote.dto.ChangePasswordDto import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto import com.kazier.mobile.data.remote.dto.IdResultDto @@ -486,4 +490,29 @@ private class MoveProtectionApiService : ApiService { override suspend fun listPlacements( fileId: String, ): Response>> = Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun createGroup( + body: CreateGroupDto, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listGroups(): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun addGroupMember( + groupId: String, + body: AddGroupMemberDto, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listGroupMembers( + groupId: String, + ): Response>> = Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun removeGroupMember( + groupId: String, + userId: String, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun deleteGroup( + groupId: String, + ): Response> = Response.success(ApiEnvelope()) } \ No newline at end of file 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 a28190f..ead2e9f 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 @@ -14,6 +14,10 @@ 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.AddGroupMemberDto +import com.kazier.mobile.data.remote.dto.CreateGroupDto +import com.kazier.mobile.data.remote.dto.GroupDto +import com.kazier.mobile.data.remote.dto.GroupMemberDto import com.kazier.mobile.data.remote.dto.ChangePasswordDto import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto import com.kazier.mobile.data.remote.dto.IdResultDto @@ -404,4 +408,29 @@ private class OcrApiServiceFake : ApiService { override suspend fun listPlacements( fileId: String, ): Response>> = Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun createGroup( + body: CreateGroupDto, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listGroups(): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun addGroupMember( + groupId: String, + body: AddGroupMemberDto, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listGroupMembers( + groupId: String, + ): Response>> = Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun removeGroupMember( + groupId: String, + userId: String, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun deleteGroup( + groupId: String, + ): Response> = Response.success(ApiEnvelope()) } \ No newline at end of file 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 d24b157..c5b0c6e 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 @@ -17,6 +17,10 @@ import com.kazier.mobile.domain.GenerateId import com.kazier.mobile.data.remote.ApiClient import com.kazier.mobile.data.remote.ApiService import com.kazier.mobile.data.remote.dto.ApiEnvelope +import com.kazier.mobile.data.remote.dto.AddGroupMemberDto +import com.kazier.mobile.data.remote.dto.CreateGroupDto +import com.kazier.mobile.data.remote.dto.GroupDto +import com.kazier.mobile.data.remote.dto.GroupMemberDto import com.kazier.mobile.data.remote.dto.ChangePasswordDto import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto import com.kazier.mobile.data.remote.dto.FileDto @@ -296,5 +300,30 @@ class OfflineDownloadTest { override suspend fun listPlacements( fileId: String, ): Response>> = Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun createGroup( + body: CreateGroupDto, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listGroups(): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun addGroupMember( + groupId: String, + body: AddGroupMemberDto, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listGroupMembers( + groupId: String, + ): Response>> = Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun removeGroupMember( + groupId: String, + userId: String, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun deleteGroup( + groupId: String, + ): Response> = Response.success(ApiEnvelope()) } } 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 3d5dbc7..f400c13 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 @@ -15,6 +15,10 @@ import com.kazier.mobile.data.local.entity.PendingOpStatus import com.kazier.mobile.data.remote.ApiClient import com.kazier.mobile.data.remote.ApiService import com.kazier.mobile.data.remote.dto.ApiEnvelope +import com.kazier.mobile.data.remote.dto.AddGroupMemberDto +import com.kazier.mobile.data.remote.dto.CreateGroupDto +import com.kazier.mobile.data.remote.dto.GroupDto +import com.kazier.mobile.data.remote.dto.GroupMemberDto import com.kazier.mobile.data.remote.dto.ChangePasswordDto import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto import com.kazier.mobile.data.remote.dto.FileDto @@ -253,4 +257,29 @@ private class RefreshVsMoveApiService : ApiService { override suspend fun listPlacements( fileId: String, ): Response>> = Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun createGroup( + body: CreateGroupDto, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listGroups(): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun addGroupMember( + groupId: String, + body: AddGroupMemberDto, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listGroupMembers( + groupId: String, + ): Response>> = Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun removeGroupMember( + groupId: String, + userId: String, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun deleteGroup( + groupId: String, + ): Response> = Response.success(ApiEnvelope()) } 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 5fb1955..9f9d733 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 @@ -15,6 +15,10 @@ import com.kazier.mobile.data.local.entity.FolderEntity import com.kazier.mobile.data.remote.ApiClient import com.kazier.mobile.data.remote.ApiService import com.kazier.mobile.data.remote.dto.ApiEnvelope +import com.kazier.mobile.data.remote.dto.AddGroupMemberDto +import com.kazier.mobile.data.remote.dto.CreateGroupDto +import com.kazier.mobile.data.remote.dto.GroupDto +import com.kazier.mobile.data.remote.dto.GroupMemberDto import com.kazier.mobile.data.remote.dto.ChangePasswordDto import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto import com.kazier.mobile.data.remote.dto.IdResultDto @@ -507,4 +511,29 @@ private class FakeApiService : ApiService { override suspend fun listPlacements( fileId: String, ): Response>> = Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun createGroup( + body: CreateGroupDto, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listGroups(): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun addGroupMember( + groupId: String, + body: AddGroupMemberDto, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listGroupMembers( + groupId: String, + ): Response>> = Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun removeGroupMember( + groupId: String, + userId: String, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun deleteGroup( + groupId: String, + ): Response> = Response.success(ApiEnvelope()) } \ No newline at end of file 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 fbcfd13..21b88cc 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 @@ -162,5 +162,11 @@ class ReleaseLocalCopyTest { override suspend fun listShares(fileId: String): retrofit2.Response>> = TODO() override suspend fun listLinks(fileId: String): retrofit2.Response>> = TODO() override suspend fun listPlacements(fileId: String): retrofit2.Response>> = TODO() + override suspend fun createGroup(body: com.kazier.mobile.data.remote.dto.CreateGroupDto): retrofit2.Response> = TODO() + override suspend fun listGroups(): retrofit2.Response>> = TODO() + override suspend fun addGroupMember(groupId: String, body: com.kazier.mobile.data.remote.dto.AddGroupMemberDto): retrofit2.Response> = TODO() + override suspend fun listGroupMembers(groupId: String): retrofit2.Response>> = TODO() + override suspend fun removeGroupMember(groupId: String, userId: String): retrofit2.Response> = TODO() + override suspend fun deleteGroup(groupId: 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 913d27a..6334ff6 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,10 @@ 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.AddGroupMemberDto +import com.kazier.mobile.data.remote.dto.CreateGroupDto +import com.kazier.mobile.data.remote.dto.GroupDto +import com.kazier.mobile.data.remote.dto.GroupMemberDto import com.kazier.mobile.data.remote.dto.ChangePasswordDto import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto import com.kazier.mobile.data.remote.dto.FileDto @@ -302,7 +306,6 @@ class OutboxSyncWorkerTest { } // --- M22 : annulation ----------------------------------------------------- - @Test fun cancellation_exception_remonte() = runTest { insertOp(opId(1)) @@ -352,6 +355,27 @@ class OutboxSyncWorkerTest { ) } + @Test + fun share_groupe_payload_granteeGroupId() = runTest { + val outbox = OutboxRepository( + opsDao, GenerateId(), + DeviceIdentity(db.userPreferenceDao(), GenerateId()), moshi, + ) + val opId = outbox.enqueueShare( + resourceId = "a".repeat(32), + resourceType = "folder", + granteeGroupId = "b".repeat(32), + access = "editor", + ) + + val stored = opsDao.selectPending(10).first { it.operationId == opId } + assertTrue( + "payload groupe : granteeGroupId présent, pas de granteeUserId", + stored.payload.contains("\"granteeGroupId\":\"${"b".repeat(32)}\"") && + !stored.payload.contains("granteeUserId"), + ) + } + // --- fixtures -------------------------------------------------------------- private suspend fun insertOp( @@ -499,5 +523,30 @@ class OutboxSyncWorkerTest { override suspend fun listPlacements( fileId: String, ): Response>> = Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun createGroup( + body: CreateGroupDto, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listGroups(): Response>> = + Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun addGroupMember( + groupId: String, + body: AddGroupMemberDto, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun listGroupMembers( + groupId: String, + ): Response>> = Response.success(ApiEnvelope(data = emptyList())) + + override suspend fun removeGroupMember( + groupId: String, + userId: String, + ): Response> = Response.success(ApiEnvelope()) + + override suspend fun deleteGroup( + groupId: String, + ): Response> = Response.success(ApiEnvelope()) } }