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,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
|
||||
}
|
||||
Reference in New Issue
Block a user