V3 S7 : preview cloud + export chiffré + release 1.2.0
Release / release-apk (push) Successful in 8m58s
Release / release-docker (push) Successful in 3m47s
CI / docker (push) Successful in 7s
CI / lint-backend (push) Successful in 1m44s
CI / lint-mobile (push) Failing after 18m59s
CI / test-backend (push) Successful in 2m12s
CI / test-mobile (push) Successful in 8m50s
CI / build-backend (push) Successful in 45s

Backend : resource_previews (000024), GET /files/:id/preview (JPEG
512, images pur Go, PDF page 1 via pdftoppm + poppler au Dockerfile,
cache régénéré sur changement, 404 NO_PREVIEW sinon), POST /export
{password 8+} -> zip AES-256 streamé (fichiers vifs possédés +
manifest.json avec faits, metadata-only sans octets). Deps :
alexmullins/zip, x/image directs. Tests service + handlers + migrations.

Mobile : vignettes distantes (une requête/session puis cache WebP
versionné, garde tried, icône sinon), FileThumbnail cloud-only,
export (mot de passe jamais persisté, cache + partage FileProvider),
bouton Partager ACTION_SEND. Impression papier reportée V4. FR/EN.

Contrat docs/api-v1.md, V3.md (S7 livré, V3 close), AGENTS.md,
VERSION 1.2.0 + CHANGELOG.
This commit is contained in:
venture
2026-09-26 15:08:31 +02:00
parent 1e38e6e4ee
commit 4316da578f
56 changed files with 2004 additions and 37 deletions
+4 -2
View File
@@ -17,14 +17,16 @@ RUN CGO_ENABLED=0 GOOS=linux go build \
-o /out/kazier-server \
./cmd/server/main.go
# --- runtime: mince, Tesseract (fra+eng) embarqué pour l'OCR ---
# --- runtime: mince, Tesseract (fra+eng) embarqué pour l'OCR + poppler
# (pdftoppm) pour les vignettes PDF page 1 (V3 S7, best-effort) ---
FROM alpine:3.20
RUN apk add --no-cache \
ca-certificates \
tzdata \
tesseract-ocr \
tesseract-ocr-data-eng \
tesseract-ocr-data-fra
tesseract-ocr-data-fra \
poppler-utils
WORKDIR /app
+2
View File
@@ -20,6 +20,7 @@ var expectedRoutes = []string{
"GET /api/v1/files/:id/facts",
"PATCH /api/v1/files/:id/facts",
"GET /api/v1/files/:id/content",
"GET /api/v1/files/:id/preview",
"GET /api/v1/files/:id/shares",
"GET /api/v1/files/:id/links",
"GET /api/v1/files/:id/placements",
@@ -27,6 +28,7 @@ var expectedRoutes = []string{
"GET /api/v1/files/:id/relations",
"POST /api/v1/files/:id/relations/verdict",
"GET /api/v1/duplicates",
"POST /api/v1/export",
"POST /api/v1/files/:id/restore",
"POST /api/v1/files/:id/versions/:n/restore",
"GET /api/v1/trash",
@@ -0,0 +1 @@
DROP TABLE IF EXISTS resource_previews;
@@ -0,0 +1,13 @@
-- V3 S7 : vignettes serveur pour les fichiers cloud-only (la galerie reste
-- < 1 s sans rapatrier les octets). `resource_previews` mémorise la
-- génération servie (taille + updated_at sources) pour ne régénérer que sur
-- changement ; le fichier vit sous UPLOAD_DIR/.previews/<resource_id>.jpg
-- (jamais versionné, reconstruit à la demande). Images : pur Go (stdlib +
-- x/image). PDF : `pdftoppm` (poppler, cf. Dockerfile) page 1 ; sans l'outil
-- ou autre type → pas de preview (404 NO_PREVIEW, l'UI montre l'icône).
CREATE TABLE resource_previews (
resource_id TEXT PRIMARY KEY REFERENCES resources(resource_id) ON DELETE CASCADE,
src_size_bytes BIGINT NOT NULL,
src_updated_at TIMESTAMPTZ NOT NULL,
created_at TIMESTAMPTZ DEFAULT NOW()
);
+3
View File
@@ -515,6 +515,9 @@ func TestMigrationsUpDown(t *testing.T) {
t.Error("colonne users.storage_quota_bytes manquante après 000023")
}
// --- 000024 : vignettes serveur ------------------------------------------
assertTables(t, conn, "users", "devices", "resources", "operations", "ocr_jobs", "shares", "share_links", "storage_locations", "resource_placements", "groups", "group_members", "resource_versions", "resource_facts", "resource_links", "resource_previews", "schema_migrations")
if err := MigrateDownDatabase(url); err != nil {
t.Fatalf("migrate down: %v", err)
}
+6 -4
View File
@@ -7,11 +7,15 @@ require (
github.com/gin-gonic/gin v1.12.0
github.com/golang-migrate/migrate/v4 v4.19.1
github.com/joho/godotenv v1.5.1
github.com/ledongthuc/pdf v0.0.0-20260907135840-6c8c28e0e8a0
github.com/lib/pq v1.12.3
golang.org/x/crypto v0.52.0
golang.org/x/image v0.46.0
)
require (
aidanwoods.dev/go-result v0.3.1 // indirect
github.com/alexmullins/zip v0.0.0-20180717182244-4affb64b04d0 // indirect
github.com/bytedance/gopkg v0.1.3 // indirect
github.com/bytedance/sonic v1.15.0 // indirect
github.com/bytedance/sonic/loader v0.5.0 // indirect
@@ -25,7 +29,6 @@ require (
github.com/goccy/go-yaml v1.19.2 // indirect
github.com/json-iterator/go v1.1.12 // indirect
github.com/klauspost/cpuid/v2 v2.3.0 // indirect
github.com/ledongthuc/pdf v0.0.0-20260907135840-6c8c28e0e8a0 // indirect
github.com/leodido/go-urn v1.4.0 // indirect
github.com/mattn/go-isatty v0.0.20 // indirect
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
@@ -37,9 +40,8 @@ require (
github.com/ugorji/go/codec v1.3.1 // indirect
go.mongodb.org/mongo-driver/v2 v2.5.0 // indirect
golang.org/x/arch v0.22.0 // indirect
golang.org/x/crypto v0.52.0 // indirect
golang.org/x/net v0.54.0 // indirect
golang.org/x/sys v0.45.0 // indirect
golang.org/x/text v0.37.0 // indirect
golang.org/x/sys v0.48.0 // indirect
golang.org/x/text v0.42.0 // indirect
google.golang.org/protobuf v1.36.10 // indirect
)
+8 -4
View File
@@ -6,6 +6,8 @@ github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 h1:L/gRVlceqvL25
github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY=
github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU=
github.com/alexmullins/zip v0.0.0-20180717182244-4affb64b04d0 h1:BVts5dexXf4i+JX8tXlKT0aKoi38JwTXSe+3WUneX0k=
github.com/alexmullins/zip v0.0.0-20180717182244-4affb64b04d0/go.mod h1:FDIQmoMNJJl5/k7upZEnGvgWVZfFeE6qHeN7iCMbCsA=
github.com/bytedance/gopkg v0.1.3 h1:TPBSwH8RsouGCBcMBktLt1AymVo2TVsBVCY4b6TnZ/M=
github.com/bytedance/gopkg v0.1.3/go.mod h1:576VvJ+eJgyCzdjS+c4+77QF3p7ubbtiKARP3TxducM=
github.com/bytedance/sonic v1.15.0 h1:/PXeWFaR5ElNcVE84U0dOHjiMHQOwNIx3K4ymzh/uSE=
@@ -136,13 +138,15 @@ golang.org/x/arch v0.22.0 h1:c/Zle32i5ttqRXjdLyyHZESLD/bB90DCU1g9l/0YBDI=
golang.org/x/arch v0.22.0/go.mod h1:dNHoOeKiyja7GTvF9NJS1l3Z2yntpQNzgrjh1cU103A=
golang.org/x/crypto v0.52.0 h1:RMs7fP2rXdep0CftQlK8Uf+kibLm7qkCcradZWYz988=
golang.org/x/crypto v0.52.0/go.mod h1:1QgfPxDqh0T2M/elOJtp9RvuR95kVjir0e6/BvEmGbc=
golang.org/x/image v0.46.0 h1:b1+oYj0Jbp6K5MDT4i4/eZpYlk3V8SJhhDKh6LBHAyQ=
golang.org/x/image v0.46.0/go.mod h1:3B3W05VGVQyuXucLINLjXKrqISASfi4Xj+iCVkLMwew=
golang.org/x/net v0.54.0 h1:2zJIZAxAHV/OHCDTCOHAYehQzLfSXuf/5SoL/Dv6w/w=
golang.org/x/net v0.54.0/go.mod h1:Sj4oj8jK6XmHpBZU/zWHw3BV3abl4Kvi+Ut7cQcY+cQ=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.45.0 h1:dO4czNzziLiiXplLQgBCEpCvXQ3dnkn0SdaZSYdQ+FY=
golang.org/x/sys v0.45.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
golang.org/x/text v0.37.0 h1:Cqjiwd9eSg8e0QAkyCaQTNHFIIzWtidPahFWR83rTrc=
golang.org/x/text v0.37.0/go.mod h1:a5sjxXGs9hsn/AJVwuElvCAo9v8QYLzvavO5z2PiM38=
golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo=
golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
golang.org/x/text v0.42.0 h1:JbOZXgfeCPU9gacVtYliJqOhD+zhrEqK4LfdpmlUZqI=
golang.org/x/text v0.42.0/go.mod h1:ojzP1Z+2QtioaF8DTtO8K5q7JWVVYwZKenzujK0Zd0E=
google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=
google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+46
View File
@@ -0,0 +1,46 @@
package handlers
import (
"fmt"
"net/http"
"time"
"github.com/gin-gonic/gin"
"github.com/kazier/backend/pkg/api"
)
type exportRequest struct {
Password string `json:"password"`
}
// ExportFull streame un zip AES-256 du compte (V3 S7 C3) :
// `POST /export { password }` (mot de passe en corps JSON, jamais en query
// — pas de fuite dans les logs). Chaque entrée (fichiers + manifest.json)
// est chiffrée. Scope : fichiers vifs possédés uniquement.
// Le mot de passe exige 8+ caractères (400 sinon) ; le zip peut être long
// (pas de cap S7 — donnée de l'utilisateur, self-hosté).
func ExportFull(c *gin.Context) {
if Store == nil || Store.Repository == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
return
}
userID := c.GetString(UserIDKey)
var req exportRequest
if err := c.ShouldBindJSON(&req); err != nil {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "invalid JSON body (expected { password })")
return
}
if len(req.Password) < 8 {
api.Error(c, http.StatusBadRequest, "INVALID_REQUEST", "password must be at least 8 characters")
return
}
filename := fmt.Sprintf("kazier-export-%s.zip", time.Now().UTC().Format("20060102-150405"))
c.Header("Content-Type", "application/zip")
c.Header("Content-Disposition", "attachment; filename=\""+filename+"\"")
// Erreur mid-stream : headers déjà partis — log + abort (zip tronqué,
// documenté ; le manifest chiffré en fin d'archive manque alors).
if err := Store.Export(c.Writer, userID, req.Password); err != nil {
c.Abort()
return
}
}
+38
View File
@@ -0,0 +1,38 @@
package handlers_test
import (
"net/http"
"testing"
"github.com/kazier/backend/repository"
)
// TestExportEndpoint : POST /export exige un mot de passe 8+ (400 sinon) et
// streame un zip (200 + application/zip).
func TestExportEndpoint(t *testing.T) {
r, _, repo := setup(t)
device := repository.NewID()
token, _ := registerAndLogin(t, r, repo, testUserUsername(device, "ex"), "export-test-password", device)
for _, body := range []string{`{}`, `{"password":"court"}`, `not-json`} {
rec, _ := doRequest(t, r, http.MethodPost, "/api/v1/export", token, []byte(body), "application/json")
expectError(t, rec, http.StatusBadRequest, "INVALID_REQUEST", "export-400:"+body)
}
rec, _ := doRequest(t, r, http.MethodPost, "/api/v1/export", token, []byte(`{"password":"motdepasse-8"}`), "application/json")
if rec.Code != http.StatusOK {
t.Fatalf("export: attendu 200, got %d %s", rec.Code, rec.Body.String())
}
if ct := rec.Header().Get("Content-Type"); ct != "application/zip" {
t.Fatalf("content-type = %q", ct)
}
if cd := rec.Header().Get("Content-Disposition"); cd == "" {
t.Fatal("content-disposition manquant")
}
if rec.Body.Len() == 0 {
t.Fatal("zip vide")
}
if rec.Body.Bytes()[0] != 'P' || rec.Body.Bytes()[1] != 'K' {
t.Fatal("pas une archive zip (signature PK manquante)")
}
}
+28
View File
@@ -299,6 +299,34 @@ func FilesContent(c *gin.Context) {
c.File(info.Path)
}
// FilesPreview sert la vignette JPEG d'un fichier visible (V3 S7) :
// `GET /files/:id/preview` (binaire brut, hors enveloppe, `inline`).
// Générée à la demande (images pur Go, PDF page 1 via `pdftoppm`) et cachée
// jusqu'au prochain changement (taille/`updated_at`). 404 NOT_FOUND si
// invisible/metadata-only (indistinguables, pas d'énumération), 404
// NO_PREVIEW si le type ne se prévisualise pas (l'UI montre l'icône).
func FilesPreview(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
}
path, err := Store.OpenPreview(userID, id)
if err != nil {
writeError(c, err)
return
}
c.Header("Content-Type", "image/jpeg")
c.Header("Content-Disposition", "inline; filename=\""+id+".jpg\"")
c.Header("Cache-Control", "private, max-age=3600")
c.File(path)
}
func FilesDelete(c *gin.Context) {
if Store == nil {
api.Error(c, http.StatusServiceUnavailable, "SERVICE_UNAVAILABLE", "backend not initialized")
+108
View File
@@ -0,0 +1,108 @@
package handlers_test
import (
"bytes"
"image"
"image/color"
"image/jpeg"
"net/http"
"os"
"path/filepath"
"strings"
"testing"
"github.com/kazier/backend/repository"
)
// previewImageBytes génère un JPEG 640x480 uni (décodable sans fixture).
func previewImageBytes(t *testing.T) []byte {
t.Helper()
img := image.NewRGBA(image.Rect(0, 0, 640, 480))
for y := 0; y < 480; y++ {
for x := 0; x < 640; x++ {
img.Set(x, y, color.RGBA{uint8(x % 256), 128, 64, 255})
}
}
var buf bytes.Buffer
if err := jpeg.Encode(&buf, img, nil); err != nil {
t.Fatal(err)
}
return buf.Bytes()
}
// TestFilesPreview : JPEG 200 + image/jpeg pour une image, NO_PREVIEW pour
// un txt, NOT_FOUND si trashé/étranger. L'upload HTTP de test est capé à
// 10 o : le physique est écrit directement (même layout UPLOAD_DIR).
func TestFilesPreview(t *testing.T) {
r, store, repo := setup(t)
device := repository.NewID()
token, userID := registerAndLogin(t, r, repo, testUserUsername(device, "pv"), "preview-test-password", device)
createdID := seedPhysical(t, store.UploadDir, repo, userID, "photo.jpg", previewImageBytes(t))
rec, _ := doRequest(t, r, http.MethodGet, "/api/v1/files/"+createdID+"/preview", token, nil, "")
if rec.Code != http.StatusOK {
t.Fatalf("preview: attendu 200, got %d %s", rec.Code, rec.Body.String())
}
if ct := rec.Header().Get("Content-Type"); ct != "image/jpeg" {
t.Fatalf("content-type = %q, attendu image/jpeg", ct)
}
if _, err := jpeg.Decode(bytes.NewReader(rec.Body.Bytes())); err != nil {
t.Fatalf("corps non-JPEG: %v", err)
}
// Txt → NO_PREVIEW (404 typé, l'UI montre l'icône).
txtID := seedPhysical(t, store.UploadDir, repo, userID, "notes.txt", []byte("hello"))
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+txtID+"/preview", token, nil, "")
expectError(t, rec, http.StatusNotFound, "NO_PREVIEW", "preview-txt")
// Trashé → NOT_FOUND (invisible d'abord, pas NO_PREVIEW).
if err := repo.Resources.TrashResource(userID, createdID); err != nil {
t.Fatalf("trash: %v", err)
}
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+createdID+"/preview", token, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "preview-trashed")
// Étranger → NOT_FOUND.
deviceB := repository.NewID()
tokenB, _ := registerAndLogin(t, r, repo, testUserUsername(deviceB, "pb"), "preview-test-password", deviceB)
rec, _ = doRequest(t, r, http.MethodGet, "/api/v1/files/"+txtID+"/preview", tokenB, nil, "")
expectError(t, rec, http.StatusNotFound, "NOT_FOUND", "preview-foreign")
}
// seedPhysical insère la métadonnée + écrit les octets (même layout que
// l'upload, sans passer par le multipart capé des tests).
func seedPhysical(t *testing.T, uploadDir string, repo *repository.Repository, userID, name string, content []byte) string {
t.Helper()
id := repository.NewID()
ext := ""
if i := strings.LastIndex(name, "."); i >= 0 {
ext = name[i+1:]
}
var extPtr *string
if ext != "" {
extPtr = &ext
}
mime := "application/octet-stream"
if ext == "jpg" {
mime = "image/jpeg"
}
if err := repo.Resources.InsertFile(userID, id, name, "", int64(len(content)), &mime, extPtr); err != nil {
t.Fatalf("insert: %v", err)
}
dir := filepath.Join(uploadDir, userID)
if err := os.MkdirAll(dir, 0o700); err != nil {
t.Fatalf("mkdir: %v", err)
}
dest := id
if ext != "" {
dest = id + "." + ext
}
if err := os.WriteFile(filepath.Join(dir, dest), content, 0o600); err != nil {
t.Fatalf("write: %v", err)
}
if err := repo.Resources.SetHasContent(userID, id, true); err != nil {
t.Fatalf("has_content: %v", err)
}
return id
}
+2
View File
@@ -36,6 +36,7 @@ func RegisterRoutes(r *gin.Engine) {
protected.GET("/files/:id/facts", FilesGetFacts)
protected.PATCH("/files/:id/facts", FilesCorrectFacts)
protected.GET("/files/:id/content", FilesContent)
protected.GET("/files/:id/preview", FilesPreview)
protected.GET("/files/:id/shares", SharesList)
protected.GET("/files/:id/links", LinksList)
protected.GET("/files/:id/placements", PlacementsList)
@@ -43,6 +44,7 @@ func RegisterRoutes(r *gin.Engine) {
protected.GET("/files/:id/relations", RelationsList)
protected.POST("/files/:id/relations/verdict", RelationVerdict)
protected.GET("/duplicates", DuplicatesList)
protected.POST("/export", ExportFull)
protected.POST("/files/:id/restore", FilesRestore)
protected.POST("/files/:id/versions/:n/restore", VersionRestore)
protected.GET("/trash", TrashList)
+2
View File
@@ -32,6 +32,8 @@ func writeError(c *gin.Context, err error) {
api.Error(c, 413, "FILE_TOO_LARGE", "file exceeds the maximum allowed size")
case errors.Is(err, service.ErrQuotaExceeded):
api.Error(c, 413, "QUOTA_EXCEEDED", "storage quota exceeded")
case errors.Is(err, service.ErrNoPreview):
api.Error(c, 404, "NO_PREVIEW", "no preview available for this file")
default:
// Jamais de err.Error() brut au client (fuite SQL/FS/paths, cf.
// FEEDBACK #8) : message générique, détail au log serveur.
+39
View File
@@ -0,0 +1,39 @@
package repository
import (
"database/sql"
"time"
)
// PreviewRow mémorise la vignette servie (V3 S7, migration 000024).
type PreviewRow struct {
SrcSize int64
SrcUpdatedAt time.Time
}
// GetPreview lit la génération servie. Absente → sql.ErrNoRows (régénérer).
func (r *Resources) GetPreview(resourceID string) (PreviewRow, error) {
var row PreviewRow
err := r.DB.QueryRow(
`SELECT src_size_bytes, src_updated_at FROM resource_previews WHERE resource_id = $1`,
resourceID,
).Scan(&row.SrcSize, &row.SrcUpdatedAt)
if err == sql.ErrNoRows {
return PreviewRow{}, err
}
return row, err
}
// UpsertPreview mémorise la génération servie (taille + updated_at sources).
func (r *Resources) UpsertPreview(resourceID string, srcSize int64, srcUpdatedAt time.Time) error {
_, err := r.DB.Exec(
`INSERT INTO resource_previews (resource_id, src_size_bytes, src_updated_at)
VALUES ($1, $2, $3)
ON CONFLICT (resource_id)
DO UPDATE SET src_size_bytes = EXCLUDED.src_size_bytes,
src_updated_at = EXCLUDED.src_updated_at,
created_at = NOW()`,
resourceID, srcSize, srcUpdatedAt,
)
return err
}
+65
View File
@@ -831,3 +831,68 @@ func (r *Resources) ListRootFoldersVisible(userID string) ([]FolderRow, error) {
}
return folders, rows.Err()
}
// ExportFileRow is one live file for full export (V3 S7 C3).
type ExportFileRow struct {
ID string
Name string
ParentID string
Size int64
MimeType string
Extension string
Hash string
OcrText string
HasContent bool
}
// ExportFiles returns ALL live files of a user (bounded — full export).
func (r *Resources) ExportFiles(ownerID string, limit int) ([]ExportFileRow, error) {
rows, err := r.DB.Query(
`SELECT resource_id, name, COALESCE(parent_id, ''), COALESCE(size_bytes, 0),
COALESCE(mime_type, ''), COALESCE(extension, ''),
COALESCE(content_hash, ''), COALESCE(ocr_text, ''),
COALESCE(has_content, FALSE)
FROM resources
WHERE user_id = $1 AND type = 'file' AND deleted_at IS NULL
ORDER BY created_at ASC LIMIT $2`,
ownerID, limit,
)
if err != nil {
return nil, err
}
defer rows.Close()
out := make([]ExportFileRow, 0)
for rows.Next() {
var row ExportFileRow
if err := rows.Scan(&row.ID, &row.Name, &row.ParentID, &row.Size, &row.MimeType,
&row.Extension, &row.Hash, &row.OcrText, &row.HasContent); err != nil {
return nil, err
}
out = append(out, row)
}
return out, rows.Err()
}
// ExportFolders returns ALL live folders of a user (bounded — full export).
func (r *Resources) ExportFolders(ownerID string, limit int) ([]FolderRow, error) {
rows, err := r.DB.Query(
`SELECT resource_id, name, COALESCE(parent_id, '')
FROM resources
WHERE user_id = $1 AND type = 'folder' AND deleted_at IS NULL
ORDER BY created_at ASC LIMIT $2`,
ownerID, limit,
)
if err != nil {
return nil, err
}
defer rows.Close()
out := make([]FolderRow, 0)
for rows.Next() {
var folder FolderRow
if err := rows.Scan(&folder.ID, &folder.Name, &folder.ParentID); err != nil {
return nil, err
}
out = append(out, folder)
}
return out, rows.Err()
}
+155
View File
@@ -0,0 +1,155 @@
package service
import (
"encoding/json"
"fmt"
"io"
"log"
"os"
"time"
"github.com/alexmullins/zip"
)
// Export password floor (V3 S7 C3) : un backup chiffré avec "1234" est un
// placebo — même seuil que les mots de passe compte (8).
const exportMinPasswordLength = 8
// ExportMaxResources bounds a full export (V3 S7 C3) : au-delà, l'export est
// tronqué honnêtement (manifest.truncated = true) plutôt que de gonfler sans
// fin la mémoire/temps d'une requête HTTP.
const ExportMaxResources = 20000
// ExportManifestFile is the encrypted manifest inside the zip.
type ExportManifestFile struct {
Version int `json:"version"`
ExportedAt string `json:"exportedAt"`
UserID string `json:"userId"`
Truncated bool `json:"truncated"`
Folders []ExportFolderEntry `json:"folders"`
Files []ExportFileEntry `json:"files"`
}
// ExportFolderEntry mirrors a live folder (tree rebuilt via parentId).
type ExportFolderEntry struct {
ID string `json:"id"`
Name string `json:"name"`
ParentID string `json:"parentId,omitempty"`
}
// ExportFileEntry mirrors a live file (+ extracted knowledge for re-import).
type ExportFileEntry struct {
ID string `json:"id"`
Name string `json:"name"`
ParentID string `json:"parentId,omitempty"`
Size int64 `json:"size"`
MimeType string `json:"mimeType,omitempty"`
Extension string `json:"extension,omitempty"`
Hash string `json:"hash,omitempty"`
OcrText string `json:"ocrText,omitempty"`
Facts []FactDTO `json:"facts,omitempty"`
Path string `json:"path,omitempty"` // files/<id>.<ext> — absent si metadata-only
HasBytes bool `json:"hasBytes"`
}
// Export streams an AES-256 encrypted zip of the account (V3 S7 C3) : every
// entry — files AND manifest — is encrypted with password (WinZip AES, cf.
// alexmullins/zip). Scope : own live resources only (ni trashés, ni
// partagés d'autrui). Metadata-only files appear in the manifest without
// bytes (Path vide, HasBytes false). Password < 8 → error (400 côté handler).
func (s *Resources) Export(w io.Writer, ownerID, password string) error {
if len(password) < exportMinPasswordLength {
return fmt.Errorf("export password must be at least %d characters", exportMinPasswordLength)
}
folders, err := s.Repo.ExportFolders(ownerID, ExportMaxResources)
if err != nil {
return err
}
files, err := s.Repo.ExportFiles(ownerID, ExportMaxResources)
if err != nil {
return err
}
truncated := len(folders) == ExportMaxResources || len(files) == ExportMaxResources
manifest := ExportManifestFile{
Version: 1, ExportedAt: time.Now().UTC().Format(time.RFC3339),
UserID: ownerID, Truncated: truncated,
Folders: make([]ExportFolderEntry, 0, len(folders)),
Files: make([]ExportFileEntry, 0, len(files)),
}
for _, f := range folders {
manifest.Folders = append(manifest.Folders, ExportFolderEntry{
ID: f.ID, Name: f.Name, ParentID: f.ParentID,
})
}
zw := zip.NewWriter(w)
writeEncrypted := func(name string, data []byte) error {
fh := &zip.FileHeader{Name: name, Method: zip.Deflate}
fh.SetPassword(password)
fw, err := zw.CreateHeader(fh)
if err != nil {
return err
}
_, err = fw.Write(data)
return err
}
for _, f := range files {
entry := ExportFileEntry{
ID: f.ID, Name: f.Name, ParentID: f.ParentID, Size: f.Size,
MimeType: f.MimeType, Extension: f.Extension, Hash: f.Hash,
OcrText: f.OcrText,
}
// Faits joints (auto + corrections — la connaissance voyage avec).
if facts, ferr := s.Repository.Resources.ListFacts(f.ID); ferr == nil {
for _, fact := range facts {
entry.Facts = append(entry.Facts, FactDTO{
FactType: fact.Type, ValueText: fact.ValueText,
ValueNum: fact.ValueNum, ValueDate: derefString(fact.ValueDate),
Confidence: fact.Confidence, Origin: fact.Origin,
})
}
}
src, serr := s.resolvePhysical(ownerID, f.ID)
if serr != nil {
entry.HasBytes = false
manifest.Files = append(manifest.Files, entry)
continue
}
zipName := "files/" + f.ID
if f.Extension != "" {
zipName += "." + f.Extension
}
entry.Path = zipName
entry.HasBytes = true
manifest.Files = append(manifest.Files, entry)
in, err := os.Open(src)
if err != nil {
log.Printf("export: open %s: %v", f.ID, err)
continue
}
fh := &zip.FileHeader{Name: zipName, Method: zip.Deflate}
fh.SetPassword(password)
fw, err := zw.CreateHeader(fh)
if err != nil {
in.Close()
return err
}
if _, err := io.Copy(fw, in); err != nil {
in.Close()
return err
}
in.Close()
}
raw, err := json.MarshalIndent(manifest, "", " ")
if err != nil {
return err
}
if err := writeEncrypted("manifest.json", raw); err != nil {
return err
}
return zw.Close()
}
+163
View File
@@ -0,0 +1,163 @@
package service
import (
"archive/zip"
"bytes"
"encoding/json"
"testing"
azip "github.com/alexmullins/zip"
"github.com/kazier/backend/repository"
)
// TestExportRoundTrip : zip déchiffrable avec le mot de passe, manifest
// cohérent (fichiers + faits + dossiers), octets intacts, trashés exclus.
func TestExportRoundTrip(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "export-roundtrip")
folderID := repository.NewID()
if err := s.Repository.Resources.InsertFolder(userID, folderID, "Papiers", ""); err != nil {
t.Fatalf("insert folder: %v", err)
}
a, err := s.Upload(userID, multipartFileHeader(t, "a.txt", []byte("contenu-a")), folderID, "")
if err != nil {
t.Fatalf("upload a: %v", err)
}
b, err := s.Upload(userID, multipartFileHeader(t, "b.txt", []byte("contenu-b")), "", "")
if err != nil {
t.Fatalf("upload b: %v", err)
}
// Trashé : exclu de l'export.
if _, err := s.Trash(userID, b.ID); err != nil {
t.Fatalf("trash: %v", err)
}
// Metadata-only (jamais uploadé) : manifest sans octets.
metaID := repository.NewID()
if err := s.Repository.Resources.InsertFile(userID, metaID, "fantome.txt", "", 0, nil, nil); err != nil {
t.Fatalf("insert meta: %v", err)
}
var buf bytes.Buffer
if err := s.Export(&buf, userID, "motdepasse-8"); err != nil {
t.Fatalf("export: %v", err)
}
if buf.Len() == 0 {
t.Fatal("zip vide")
}
// Lecture avec le bon mot de passe (lib standard : échoue sur AES —
// on relit avec la même lib, comme un outil compatible WinZip AES).
zr, err := azip.NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
if err != nil {
t.Fatalf("open zip: %v", err)
}
names := map[string]bool{}
var manifestRaw []byte
for _, f := range zr.File {
names[f.Name] = true
if !f.IsEncrypted() {
t.Errorf("entrée non chiffrée: %s", f.Name)
}
f.SetPassword("motdepasse-8")
rc, err := f.Open()
if err != nil {
t.Fatalf("open %s: %v", f.Name, err)
}
var content bytes.Buffer
if _, err := content.ReadFrom(rc); err != nil {
rc.Close()
t.Fatalf("read %s: %v", f.Name, err)
}
rc.Close()
switch {
case f.Name == "manifest.json":
manifestRaw = content.Bytes()
case len(content.Bytes()) > 0 && f.Name != "manifest.json":
_ = content
}
}
var manifest ExportManifestFile
if err := json.Unmarshal(manifestRaw, &manifest); err != nil {
t.Fatalf("manifest: %v", err)
}
if manifest.Version != 1 || manifest.UserID != userID || manifest.Truncated {
t.Fatalf("manifest inattendu: %+v", manifest)
}
if len(manifest.Folders) != 1 || manifest.Folders[0].Name != "Papiers" {
t.Fatalf("dossiers: %+v", manifest.Folders)
}
if len(manifest.Files) != 2 {
t.Fatalf("fichiers manifest: %+v (attendu a + fantome, b trashé exclu)", manifest.Files)
}
byID := map[string]ExportFileEntry{}
for _, f := range manifest.Files {
byID[f.ID] = f
}
if byID[a.ID].Path == "" || !byID[a.ID].HasBytes {
t.Errorf("a doit avoir des octets: %+v", byID[a.ID])
}
if byID[metaID].Path != "" || byID[metaID].HasBytes {
t.Errorf("fantome sans octets: %+v", byID[metaID])
}
if !names["manifest.json"] || !names[byID[a.ID].Path] {
t.Fatalf("entrées zip manquantes: %v", names)
}
// Contenu chiffré : illisible sans mot de passe (lib standard échoue),
// et mauvais mot de passe refusé.
stdReader, err := zip.NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
if err != nil {
t.Fatalf("open std: %v", err)
}
for _, f := range stdReader.File {
rc, err := f.Open()
if err == nil {
var tmp bytes.Buffer
_, copyErr := tmp.ReadFrom(rc)
rc.Close()
if copyErr == nil && tmp.Len() > 0 {
t.Errorf("contenu lisible sans mot de passe: %s", f.Name)
}
}
}
zr2, err := azip.NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
if err != nil {
t.Fatalf("reopen: %v", err)
}
for _, f := range zr2.File {
if f.Name != "manifest.json" {
continue
}
f.SetPassword("mauvais-mot-de-passe")
rc, err := f.Open()
if err == nil {
var tmp bytes.Buffer
_, copyErr := tmp.ReadFrom(rc)
rc.Close()
if copyErr == nil {
t.Error("manifest déchiffré avec un mauvais mot de passe")
}
}
}
}
func TestExportPasswordFloor(t *testing.T) {
s := newServiceStore(t)
userID := mustCreateUser(t, s.Repository, "export-pw")
var buf bytes.Buffer
if err := s.Export(&buf, userID, "court"); err == nil {
t.Fatal("mot de passe court accepté")
}
// Compte vide : zip valide avec manifest seul.
if err := s.Export(&buf, userID, "motdepasse-8"); err != nil {
t.Fatalf("export vide: %v", err)
}
zr, err := azip.NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
if err != nil {
t.Fatalf("open: %v", err)
}
if len(zr.File) != 1 || zr.File[0].Name != "manifest.json" {
t.Fatalf("export vide inattendu: %v", zr.File)
}
}
+21 -11
View File
@@ -129,6 +129,26 @@ var ErrInvalidLinkType = errors.New("invalid link type or pair")
// hashPhysical computes the SHA-256 of the live bytes (safe resolution,
// same pattern as OpenContent). Absent → ErrNotFound.
func (s *Resources) hashPhysical(ownerID, resourceID string) (string, error) {
resolved, err := s.resolvePhysical(ownerID, resourceID)
if err != nil {
return "", err
}
f, err := os.Open(resolved)
if err != nil {
return "", err
}
defer f.Close()
h := sha256.New()
if _, err := io.Copy(h, f); err != nil {
return "", err
}
return hex.EncodeToString(h.Sum(nil)), nil
}
// resolvePhysical returns the absolute path of the live bytes (safe :
// 32-hex only, regular file, symlink contained in UploadDir).
// Absent → repository.ErrNotFound.
func (s *Resources) resolvePhysical(ownerID, resourceID string) (string, error) {
if !idPattern.MatchString(ownerID) || !idPattern.MatchString(resourceID) {
return "", repository.ErrNotFound
}
@@ -156,17 +176,7 @@ func (s *Resources) hashPhysical(ownerID, resourceID string) (string, error) {
if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(os.PathSeparator)) {
continue
}
f, err := os.Open(resolved)
if err != nil {
return "", err
}
h := sha256.New()
if _, err := io.Copy(h, f); err != nil {
f.Close()
return "", err
}
f.Close()
return hex.EncodeToString(h.Sum(nil)), nil
return resolved, nil
}
return "", repository.ErrNotFound
}
+220
View File
@@ -0,0 +1,220 @@
package service
import (
"bytes"
"context"
"errors"
"fmt"
"image"
"image/gif"
"image/jpeg"
"image/png"
"io"
"log"
"os"
"os/exec"
"path/filepath"
"strings"
"time"
"golang.org/x/image/draw"
"golang.org/x/image/webp"
)
// ErrNoPreview signale qu'aucune vignette n'est possible (type non supporté,
// outil absent, octets illisibles). Handlers → 404 NO_PREVIEW (l'UI montre
// l'icône de catégorie au lieu de réessayer).
var ErrNoPreview = errors.New("no preview available")
// MaxPreviewEdge borne la vignette (miroir ThumbnailStore mobile, 512 px).
const MaxPreviewEdge = 512
// previewJPEGQuality compresse les vignettes (galerie rapide, artefacts invisibles à 512 px).
const previewJPEGQuality = 80
// pdftoppmTimeout borne le rendu PDF (binaire externe, jamais bloquant).
const pdftoppmTimeout = 30 * time.Second
// OpenPreview résout la vignette JPEG d'un fichier visible (viewer+, own ou
// shared) : cache `.previews/<resource_id>.jpg` régénéré quand la source a
// changé (taille ou updated_at), sinon servi tel quel. Images : pur Go.
// PDF page 1 : `pdftoppm` (poppler, cf. Dockerfile) ; absent → ErrNoPreview.
func (s *Resources) OpenPreview(userID, resourceID string) (string, error) {
row, err := s.Repo.GetFileVisible(userID, resourceID)
if err != nil {
return "", err
}
dir := filepath.Join(s.UploadDir, ".previews")
cached := filepath.Join(dir, resourceID+".jpg")
if prev, err := s.Repo.GetPreview(resourceID); err == nil {
if prev.SrcSize == row.Size && prev.SrcUpdatedAt.Equal(row.UpdatedAt) {
if fi, serr := os.Stat(cached); serr == nil && fi.Mode().IsRegular() {
return cached, nil
}
}
}
info, err := s.OpenContent(userID, resourceID)
if err != nil {
return "", err
}
kind := previewKind(row.MimeType, info.Path)
var data []byte
switch kind {
case "image":
data, err = renderImagePreview(info.Path)
case "pdf":
data, err = renderPDFPreview(info.Path)
default:
return "", ErrNoPreview
}
if err != nil {
return "", err
}
if err := os.MkdirAll(dir, 0o700); err != nil {
return "", fmt.Errorf("preview dir: %w", err)
}
tmp, err := os.CreateTemp(dir, ".tmp-"+resourceID+".*.jpg")
if err != nil {
return "", fmt.Errorf("preview tmp: %w", err)
}
tmpName := tmp.Name()
if _, err := tmp.Write(data); err != nil {
tmp.Close()
_ = os.Remove(tmpName)
return "", fmt.Errorf("preview write: %w", err)
}
if err := tmp.Close(); err != nil {
_ = os.Remove(tmpName)
return "", fmt.Errorf("preview close: %w", err)
}
if err := os.Chmod(tmpName, 0o600); err != nil {
_ = os.Remove(tmpName)
return "", fmt.Errorf("preview chmod: %w", err)
}
if err := os.Rename(tmpName, cached); err != nil {
_ = os.Remove(tmpName)
return "", fmt.Errorf("preview commit: %w", err)
}
if err := s.Repo.UpsertPreview(resourceID, row.Size, row.UpdatedAt); err != nil {
log.Printf("preview: upsert(%s): %v", resourceID, err)
}
return cached, nil
}
// previewKind classe la source : images décodables Go vs PDF vs le reste.
func previewKind(mimeType, path string) string {
mime := strings.ToLower(mimeType)
if strings.HasPrefix(mime, "image/") {
return "image"
}
ext := strings.ToLower(strings.TrimPrefix(filepath.Ext(path), "."))
switch ext {
case "jpg", "jpeg", "png", "gif", "webp", "bmp":
return "image"
case "pdf":
return "pdf"
}
if mime == "application/pdf" {
return "pdf"
}
return ""
}
// renderImagePreview décode (jpeg/png/gif/webp) et réduit au plus grand côté
// MaxPreviewEdge, sortie JPEG. Source déjà à taille → ré-encodée telle quelle
// (uniformité du cache, coût négligeable à cette échelle).
func renderImagePreview(path string) ([]byte, error) {
f, err := os.Open(path)
if err != nil {
return nil, ErrNoPreview
}
defer f.Close()
var img image.Image
lower := strings.ToLower(path)
switch {
case strings.HasSuffix(lower, ".png"):
img, err = png.Decode(f)
case strings.HasSuffix(lower, ".gif"):
img, err = gif.Decode(f)
case strings.HasSuffix(lower, ".webp"):
img, err = webp.Decode(f)
default:
img, err = jpeg.Decode(f)
if err != nil {
// Extension menteuse (ex. .jpg contenant du PNG) : tente le PNG.
if _, serr := f.Seek(0, io.SeekStart); serr == nil {
img, err = png.Decode(f)
}
}
}
if err != nil {
return nil, ErrNoPreview
}
return encodeScaled(img)
}
// renderPDFPreview rend la page 1 via `pdftoppm` (poppler) puis réduit.
// Binaire absent ou PDF illisible → ErrNoPreview (jamais 500).
func renderPDFPreview(path string) ([]byte, error) {
if _, err := exec.LookPath("pdftoppm"); err != nil {
return nil, ErrNoPreview
}
dir, err := os.MkdirTemp("", "kazier-preview-*")
if err != nil {
return nil, fmt.Errorf("preview tmpdir: %w", err)
}
defer os.RemoveAll(dir)
prefix := filepath.Join(dir, "page")
ctx, cancel := context.WithTimeout(context.Background(), pdftoppmTimeout)
defer cancel()
// -r 50 : assez pour 512 px après réduction, sans pic mémoire.
cmd := exec.CommandContext(ctx, "pdftoppm", "-jpeg", "-r", "50", "-f", "1", "-l", "1", "-singlefile", path, prefix)
if out, err := cmd.CombinedOutput(); err != nil {
log.Printf("preview: pdftoppm: %v (%s)", err, strings.TrimSpace(string(out)))
return nil, ErrNoPreview
}
rendered := prefix + ".jpg"
f, err := os.Open(rendered)
if err != nil {
return nil, ErrNoPreview
}
defer f.Close()
img, err := jpeg.Decode(f)
if err != nil {
return nil, ErrNoPreview
}
return encodeScaled(img)
}
// encodeScaled réduit au plus grand côté MaxPreviewEdge (ratio préservé) et
// encode en JPEG. Images déjà petites : recopiées à l'identique.
func encodeScaled(img image.Image) ([]byte, error) {
bounds := img.Bounds()
w, h := bounds.Dx(), bounds.Dy()
if w <= 0 || h <= 0 {
return nil, ErrNoPreview
}
scaled := img
max := w
if h > max {
max = h
}
if max > MaxPreviewEdge {
ratio := float64(MaxPreviewEdge) / float64(max)
nw, nh := int(float64(w)*ratio+0.5), int(float64(h)*ratio+0.5)
if nw < 1 {
nw = 1
}
if nh < 1 {
nh = 1
}
dst := image.NewRGBA(image.Rect(0, 0, nw, nh))
draw.CatmullRom.Scale(dst, dst.Bounds(), img, bounds, draw.Over, nil)
scaled = dst
}
var buf bytes.Buffer
if err := jpeg.Encode(&buf, scaled, &jpeg.Options{Quality: previewJPEGQuality}); err != nil {
return nil, fmt.Errorf("preview encode: %w", err)
}
return buf.Bytes(), nil
}
+160
View File
@@ -0,0 +1,160 @@
package service
import (
"bytes"
"image"
"image/color"
"image/jpeg"
"image/png"
"os"
"os/exec"
"path/filepath"
"testing"
"github.com/kazier/backend/dbtest"
"github.com/kazier/backend/repository"
)
// newPreviewStore : comme newServiceStore mais avec un quota d'upload réaliste
// (les images de test dépassent les 100 octets du store par défaut).
func newPreviewStore(t *testing.T) *Resources {
t.Helper()
conn := dbtest.OpenTestDatabase(t, serviceTestURL)
repo := repository.NewRepository(conn)
return NewResources(repo, t.TempDir(), 10<<20)
}
// testImageBytes génère un JPEG 800x600 uni (décodable sans fixture).
func testImageBytes(t *testing.T) []byte {
t.Helper()
img := image.NewRGBA(image.Rect(0, 0, 800, 600))
for y := 0; y < 600; y++ {
for x := 0; x < 800; x++ {
img.Set(x, y, color.RGBA{uint8(x % 256), uint8(y % 256), 128, 255})
}
}
var buf bytes.Buffer
if err := jpeg.Encode(&buf, img, nil); err != nil {
t.Fatal(err)
}
return buf.Bytes()
}
func TestOpenPreviewImage(t *testing.T) {
s := newPreviewStore(t)
userID := mustCreateUser(t, s.Repository, "preview-img")
dto, err := s.Upload(userID, multipartFileHeader(t, "photo.jpg", testImageBytes(t)), "", "")
if err != nil {
t.Fatalf("upload: %v", err)
}
path, err := s.OpenPreview(userID, dto.ID)
if err != nil {
t.Fatalf("preview: %v", err)
}
f, err := os.Open(path)
if err != nil {
t.Fatalf("open preview: %v", err)
}
defer f.Close()
img, err := jpeg.Decode(f)
if err != nil {
t.Fatalf("preview n'est pas un JPEG: %v", err)
}
b := img.Bounds()
if b.Dx() > MaxPreviewEdge || b.Dy() > MaxPreviewEdge {
t.Fatalf("vignette trop grande: %dx%d", b.Dx(), b.Dy())
}
if b.Dx() != MaxPreviewEdge {
t.Fatalf("plus grand côté = %d, attendu %d", b.Dx(), MaxPreviewEdge)
}
// Second appel : cache (même fichier, pas de régénération).
fi1, _ := os.Stat(path)
path2, err := s.OpenPreview(userID, dto.ID)
if err != nil {
t.Fatalf("preview 2: %v", err)
}
fi2, _ := os.Stat(path2)
if !os.SameFile(fi1, fi2) {
t.Fatal("le cache aurait dû être servi")
}
// Overwrite → la vignette suit les nouveaux octets.
dto2, err := s.Upload(userID, multipartFileHeader(t, "photo.jpg", testImageBytes(t)), "", dto.ID)
if err != nil {
t.Fatalf("overwrite: %v", err)
}
_ = dto2
path3, err := s.OpenPreview(userID, dto.ID)
if err != nil {
t.Fatalf("preview 3: %v", err)
}
fi3, _ := os.Stat(path3)
if os.SameFile(fi2, fi3) {
t.Fatal("la vignette aurait dû être régénérée après overwrite")
}
}
func TestOpenPreviewUnsupported(t *testing.T) {
s := newPreviewStore(t)
userID := mustCreateUser(t, s.Repository, "preview-no")
dto, err := s.Upload(userID, multipartFileHeader(t, "notes.txt", []byte("hello")), "", "")
if err != nil {
t.Fatalf("upload: %v", err)
}
if _, err := s.OpenPreview(userID, dto.ID); err != ErrNoPreview {
t.Fatalf("txt : attendu ErrNoPreview, got %v", err)
}
// Trashé → NOT_FOUND (pas NO_PREVIEW : invisible d'abord).
if _, err := s.Trash(userID, dto.ID); err != nil {
t.Fatalf("trash: %v", err)
}
if _, err := s.OpenPreview(userID, dto.ID); err != repository.ErrNotFound {
t.Fatalf("trashé : attendu NOT_FOUND, got %v", err)
}
// Étranger → NOT_FOUND.
other := mustCreateUser(t, s.Repository, "preview-no-x")
dto2, err := s.Upload(other, multipartFileHeader(t, "img.png", testPNGBytes(t)), "", "")
if err != nil {
t.Fatalf("upload other: %v", err)
}
if _, err := s.OpenPreview(userID, dto2.ID); err != repository.ErrNotFound {
t.Fatalf("étranger : attendu NOT_FOUND, got %v", err)
}
}
func testPNGBytes(t *testing.T) []byte {
t.Helper()
img := image.NewRGBA(image.Rect(0, 0, 100, 100))
var buf bytes.Buffer
if err := png.Encode(&buf, img); err != nil {
t.Fatal(err)
}
return buf.Bytes()
}
func TestOpenPreviewPDF(t *testing.T) {
if _, err := exec.LookPath("pdftoppm"); err != nil {
t.Skip("pdftoppm absent (hors Docker) — rendu PDF non testé ici")
}
s := newPreviewStore(t)
userID := mustCreateUser(t, s.Repository, "preview-pdf")
pdf := []byte("%PDF-1.4\n1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj\n2 0 obj<</Type/Pages/Kids[3 0 R]/Count 1>>endobj\n3 0 obj<</Type/Page/Parent 2 0 R/MediaBox[0 0 200 200]>>endobj\ntrailer<</Root 1 0 R>>\n")
dto, err := s.Upload(userID, multipartFileHeader(t, "doc.pdf", pdf), "", "")
if err != nil {
t.Fatalf("upload: %v", err)
}
path, err := s.OpenPreview(userID, dto.ID)
if err != nil {
t.Fatalf("preview pdf: %v", err)
}
if fi, err := os.Stat(path); err != nil || fi.Size() == 0 {
t.Fatalf("vignette pdf absente: %v", err)
}
_ = filepath.Separator
}