Files
venture 4316da578f
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
V3 S7 : preview cloud + export chiffré + release 1.2.0
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.
2026-09-26 15:08:31 +02:00

221 lines
6.2 KiB
Go

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
}