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

S1 filet (backend + mobile) : corbeille 30j (deleted_at réutilisé,
trash/restore récursifs, purge auto serveur), versions N=3 à chaque
overwrite, ops outbox trash/restore/purge (delete legacy mappé), Room
v19 (trashed_at), Deleters -> trash, écran Corbeille, walk guards.

S2 extract (backend) : package extract (règles FR stdlib, corpus
testé), resource_facts 000019 (origin auto/user), hook worker OCR +
backfill boot, GET /files/:id/facts (viewer+).

Contrat docs/api-v1.md étendu, V3.md (vision + plan).
This commit is contained in:
venture
2026-09-26 10:14:07 +02:00
parent a34220bf2d
commit 95b4cf79cf
75 changed files with 5220 additions and 119 deletions
+83
View File
@@ -0,0 +1,83 @@
package handlers_test
import (
"encoding/json"
"net/http"
"testing"
"github.com/kazier/backend/repository"
"github.com/kazier/backend/service"
)
// TestFactsEndpoint : GET /files/:id/facts — faits auto visibles (viewer+),
// [] si rien d'extractible, 404 si trashé/absent/étranger.
func TestFactsEndpoint(t *testing.T) {
r, store, repo := setup(t)
device := repository.NewID()
token, userID := registerAndLogin(t, r, repo, testUserUsername(device, "fa"), "facts-test-password", device)
fileID := repository.NewID()
if err := repo.Resources.InsertFile(userID, fileID, "facture.pdf", "", 0, nil, nil); err != nil {
t.Fatalf("insert: %v", err)
}
if err := repo.Resources.UpdateOcrText(userID, fileID, "EDF\nFacture n° F-1 du 01/02/2026\nTotal : 10,00 €\n"); err != nil {
t.Fatalf("ocr text: %v", err)
}
extractSvc := service.NewExtract(repo)
if err := extractSvc.ProcessText(fileID, "EDF\nFacture n° F-1 du 01/02/2026\nTotal : 10,00 €\n"); err != nil {
t.Fatalf("extract: %v", err)
}
_ = store
rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/facts", token, nil, "")
env := expectOK(t, rec, "facts-get")
var facts []struct {
FactType string `json:"factType"`
ValueText string `json:"valueText"`
ValueNum *float64 `json:"valueNum"`
Confidence float64 `json:"confidence"`
Origin string `json:"origin"`
}
if err := json.Unmarshal(env.Data, &facts); err != nil {
t.Fatalf("facts unmarshal: %v", err)
}
if len(facts) == 0 {
t.Fatal("faits attendus, got []")
}
types := map[string]bool{}
for _, f := range facts {
types[f.FactType] = true
if f.Origin != "auto" {
t.Errorf("origine = %q, attendu auto", f.Origin)
}
}
for _, want := range []string{"reference", "amount", "date", "doc_type"} {
if !types[want] {
t.Errorf("fait %q manquant: %+v", want, facts)
}
}
// Fichier visible sans faits → [] (200, jamais 404).
emptyID := repository.NewID()
if err := repo.Resources.InsertFile(userID, emptyID, "vide.txt", "", 0, nil, nil); err != nil {
t.Fatalf("insert empty: %v", err)
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+emptyID+"/facts", token, nil, "")
env = expectOK(t, rec, "facts-empty")
if string(env.Data) != "[]" {
t.Fatalf("sans faits : attendu [], got %s", env.Data)
}
// Trashé → 404 (comme l'OCR).
if _, err := store.Trash(userID, fileID); err != nil {
t.Fatalf("trash: %v", err)
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID+"/facts", token, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "facts-trashed")
// Étranger → 404.
deviceB := repository.NewID()
tokenB, _ := registerAndLogin(t, r, repo, testUserUsername(deviceB, "fb"), "facts-test-password", deviceB)
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+emptyID+"/facts", tokenB, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "facts-foreign")
}
+127 -2
View File
@@ -107,7 +107,32 @@ func FilesGetOcr(c *gin.Context) {
api.OK(c, dto)
}
// FilesContent streame les octets physiques d'un fichier visible (viewer+,
// FilesGetFacts expose les faits génériques d'un fichier visible (V3 S2) :
// GET /files/:id/facts. Même portée que l'OCR (viewer+, own ou shared) —
// les faits dérivent du texte. `[]` si rien d'extractible (jamais 404 pour
// un fichier visible sans faits) ; 404 si trashé/absent/étranger.
func FilesGetFacts(c *gin.Context) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
userID := c.GetString(UserIDKey)
id := c.Param("id")
if !deviceIDPattern.MatchString(id) {
api.Error(c, http.StatusNotFound, "NOT_FOUND", "file not found")
return
}
facts, err := Store.GetFacts(userID, id)
if err != nil {
writeError(c, err)
return
}
if facts == nil {
facts = []service.FactDTO{}
}
api.OK(c, facts)
}
// own ou shared) : GET /files/:id/content. Réponse binaire (Content-Type du
// fichier, Content-Disposition inline) — jamais d'enveloppe {data}. Supporte
// Range via http.ServeContent (Gin c.File). Sans bytes serveur (ressource
@@ -145,7 +170,19 @@ func FilesDelete(c *gin.Context) {
api.Error(c, http.StatusNotFound, "NOT_FOUND", "file not found")
return
}
deletedID, err := Store.DeleteFile(userID, id)
// V3 corbeille : DELETE = trash par défaut ; ?mode=purge = destruction
// définitive (lignes + versions + octets). Mode inconnu → 400.
var deletedID string
var err error
switch c.Query("mode") {
case "", "trash":
deletedID, err = Store.Trash(userID, id)
case "purge":
deletedID, err = Store.Purge(userID, id)
default:
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid query param `mode` (trash|purge)")
return
}
if err != nil {
writeError(c, err)
return
@@ -153,6 +190,94 @@ func FilesDelete(c *gin.Context) {
api.OK(c, gin.H{"id": deletedID})
}
// FilesRestore restaure une ressource trashée (POST /files/:id/restore).
// Absente/étrangère → 404 NOT_FOUND ; déjà vivante → succès idempotent.
func FilesRestore(c *gin.Context) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
userID := c.GetString(UserIDKey)
id := c.Param("id")
if !deviceIDPattern.MatchString(id) {
api.Error(c, http.StatusNotFound, "NOT_FOUND", "file not found")
return
}
restoredID, err := Store.Restore(userID, id)
if err != nil {
writeError(c, err)
return
}
api.OK(c, gin.H{"id": restoredID})
}
// TrashList expose la corbeille (GET /trash) : ressources trashées du user,
// les plus récentes d'abord, paginé comme les autres listes.
func TrashList(c *gin.Context) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
userID := c.GetString(UserIDKey)
page, pageSize, ok := parsePageParams(c)
if !ok {
return
}
items, total, err := Store.ListTrashed(userID, page, pageSize)
if err != nil {
writeError(c, err)
return
}
api.OKList(c, items, page, pageSize, total)
}
// VersionsList expose l'historique des octets (GET /files/:id/versions),
// le plus récent d'abord. Ressource trashée/absente/étrangère → 404.
func VersionsList(c *gin.Context) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
userID := c.GetString(UserIDKey)
id := c.Param("id")
if !deviceIDPattern.MatchString(id) {
api.Error(c, http.StatusNotFound, "NOT_FOUND", "file not found")
return
}
versions, err := Store.ListVersions(userID, id)
if err != nil {
writeError(c, err)
return
}
api.OK(c, versions)
}
// VersionRestore recopie la génération n vers le live
// (POST /files/:id/versions/:n/restore). Génération inconnue → 404.
func VersionRestore(c *gin.Context) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
userID := c.GetString(UserIDKey)
id := c.Param("id")
if !deviceIDPattern.MatchString(id) {
api.Error(c, http.StatusNotFound, "NOT_FOUND", "file not found")
return
}
n, err := strconv.Atoi(c.Param("n"))
if err != nil || n < 1 {
api.Error(c, http.StatusNotFound, "NOT_FOUND", "version not found")
return
}
dto, err := Store.RestoreVersion(userID, id, n)
if err != nil {
writeError(c, err)
return
}
api.OK(c, dto)
}
func FilesUpload(c *gin.Context) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
+5
View File
@@ -33,10 +33,15 @@ func RegisterRoutes(r *gin.Engine) {
protected.GET("/files/folders", FoldersList)
protected.GET("/files/:id", FilesGet)
protected.GET("/files/:id/ocr", FilesGetOcr)
protected.GET("/files/:id/facts", FilesGetFacts)
protected.GET("/files/:id/content", FilesContent)
protected.GET("/files/:id/shares", SharesList)
protected.GET("/files/:id/links", LinksList)
protected.GET("/files/:id/placements", PlacementsList)
protected.GET("/files/:id/versions", VersionsList)
protected.POST("/files/:id/restore", FilesRestore)
protected.POST("/files/:id/versions/:n/restore", VersionRestore)
protected.GET("/trash", TrashList)
protected.DELETE("/files/:id", FilesDelete)
protected.POST("/files/upload", FilesUpload)
+160
View File
@@ -0,0 +1,160 @@
package handlers_test
import (
"encoding/json"
"net/http"
"testing"
"github.com/kazier/backend/repository"
)
// TestTrashEndpoints couvre le cycle corbeille via HTTP : DELETE (trash) →
// 404 en lecture → GET /trash → POST /files/:id/restore → visible →
// DELETE ?mode=purge → corbeille vide, restore → 404.
func TestTrashEndpoints(t *testing.T) {
r, _, repo := setup(t)
device := repository.NewID()
token, userID := registerAndLogin(t, r, repo, testUserUsername(device, "tr"), "trash-test-password", device)
fileID := repository.NewID()
if err := repo.Resources.InsertFile(userID, fileID, "acte.pdf", "", 0, nil, nil); err != nil {
t.Fatalf("insert: %v", err)
}
rec, _ := doRequest(t, r, http.MethodDelete, "/api/v1/files/"+fileID, token, nil, "")
expectOK(t, rec, "trash-delete")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID, token, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "trash-get-hidden")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/trash", token, nil, "")
env := expectOK(t, rec, "trash-list")
var items []struct {
ID string `json:"id"`
Type string `json:"type"`
TrashedAt string `json:"trashedAt"`
}
if err := json.Unmarshal(env.Data, &items); err != nil {
t.Fatalf("trash list unmarshal: %v", err)
}
if len(items) != 1 || items[0].ID != fileID || items[0].TrashedAt == "" {
t.Fatalf("corbeille inattendue: %+v", items)
}
if env.Meta == nil || env.Meta.Total != 1 {
t.Fatalf("meta corbeille: %+v", env.Meta)
}
rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/files/"+fileID+"/restore", token, nil, "")
expectOK(t, rec, "trash-restore")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID, token, nil, "")
expectOK(t, rec, "trash-get-restored")
rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/files/"+fileID+"?mode=purge", token, nil, "")
expectOK(t, rec, "trash-purge")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/trash", token, nil, "")
env = expectOK(t, rec, "trash-list-empty")
if env.Meta == nil || env.Meta.Total != 0 {
t.Fatalf("corbeille doit être vide: %+v", env.Meta)
}
rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/files/"+fileID+"/restore", token, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "trash-restore-purged")
}
// TestTrashInvalidMode : ?mode inconnu → 400, la ressource reste vivante.
func TestTrashInvalidMode(t *testing.T) {
r, _, repo := setup(t)
device := repository.NewID()
token, userID := registerAndLogin(t, r, repo, testUserUsername(device, "tm"), "trash-test-password", device)
fileID := repository.NewID()
if err := repo.Resources.InsertFile(userID, fileID, "doc.pdf", "", 0, nil, nil); err != nil {
t.Fatalf("insert: %v", err)
}
rec, _ := doRequest(t, r, http.MethodDelete, "/api/v1/files/"+fileID+"?mode=bogus", token, nil, "")
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "trash-bad-mode")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+fileID, token, nil, "")
expectOK(t, rec, "trash-bad-mode-keeps-live")
}
// TestTrashIsolation : un user ne voit ni ne touche la corbeille d'autrui.
func TestTrashIsolation(t *testing.T) {
r, _, repo := setup(t)
deviceA := repository.NewID()
deviceB := repository.NewID()
tokenA, userA := registerAndLogin(t, r, repo, testUserUsername(deviceA, "ta"), "trash-test-password", deviceA)
tokenB, _ := registerAndLogin(t, r, repo, testUserUsername(deviceB, "tb"), "trash-test-password", deviceB)
fileID := repository.NewID()
if err := repo.Resources.InsertFile(userA, fileID, "prive.pdf", "", 0, nil, nil); err != nil {
t.Fatalf("insert: %v", err)
}
rec, _ := doRequest(t, r, http.MethodDelete, "/api/v1/files/"+fileID, tokenB, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "trash-foreign")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/trash", tokenB, nil, "")
env := expectOK(t, rec, "trash-foreign-list")
if env.Meta == nil || env.Meta.Total != 0 {
t.Fatalf("corbeille d'autrui doit être vide: %+v", env.Meta)
}
rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/files/"+fileID, tokenA, nil, "")
expectOK(t, rec, "trash-owner")
}
// TestVersionsEndpoints : upload miniature (MaxFileSize=10 en test) puis
// re-upload ciblé → GET /files/:id/versions (1 entrée) → restore → contenu
// d'origine. Trashée → versions en 404.
func TestVersionsEndpoints(t *testing.T) {
r, _, repo := setup(t)
device := repository.NewID()
token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "ve"), "trash-test-password", device)
rec := uploadMultipart(t, r, token, "", "doc.txt", []byte("AAA"))
env := expectOK(t, rec, "versions-upload")
var created fileDTO
if err := json.Unmarshal(env.Data, &created); err != nil {
t.Fatalf("upload unmarshal: %v", err)
}
rec = uploadMultipartToResource(t, r, token, created.ID, "doc.txt", []byte("BBBB"))
expectOK(t, rec, "versions-overwrite")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+created.ID+"/versions", token, nil, "")
env = expectOK(t, rec, "versions-list")
var vers []struct {
VersionNo int `json:"versionNo"`
Size int64 `json:"size"`
CreatedAt string `json:"createdAt"`
}
if err := json.Unmarshal(env.Data, &vers); err != nil {
t.Fatalf("versions unmarshal: %v", err)
}
if len(vers) != 1 || vers[0].Size != 3 {
t.Fatalf("versions inattendues: %+v", vers)
}
rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/files/"+created.ID+"/versions/1/restore", token, nil, "")
env = expectOK(t, rec, "versions-restore")
var restored fileDTO
if err := json.Unmarshal(env.Data, &restored); err != nil {
t.Fatalf("restore unmarshal: %v", err)
}
if restored.Size != 3 {
t.Fatalf("live restauré taille=%d, attendu 3", restored.Size)
}
rec, _ = doRequest(t, r, http.MethodPost, "/api/v1/files/"+created.ID+"/versions/99/restore", token, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "versions-restore-unknown")
rec, _ = doRequest(t, r, http.MethodDelete, "/api/v1/files/"+created.ID, token, nil, "")
expectOK(t, rec, "versions-trash")
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+created.ID+"/versions", token, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "versions-trashed-hidden")
}