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
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:
@@ -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()
|
||||
}
|
||||
@@ -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
@@ -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
|
||||
}
|
||||
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
Reference in New Issue
Block a user