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/.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 }