Maintenant capter les URL des documents didl parser et les stocker dans le cache...

pmocover/cache.go

@@ -5,12 +5,17 @@ import (
 	"crypto/sha1"
 	"encoding/hex"
 	"errors"
+	"fmt"
 	"image"
+	_ "image/jpeg" // support JPEG
+	_ "image/png"  // support PNG
 	"io"
 	"net/http"
 	"os"
 	"path/filepath"
 	"sync"
+
+	_ "golang.org/x/image/webp" // support WebP
 )
 
 // CacheEntry représente une image stockée (original + dérivés)
@@ -65,6 +70,34 @@ func (c *Cache) AddFromURL(url string) (string, error) {
 	return c.Add(url, data)
 }
 
+// EnsureFromURL vérifie si l'URL est déjà dans le cache et que le fichier existe.
+func (c *Cache) EnsureFromURL(url string) (string, error) {
+	pk := pkFromURL(url)
+
+	// Vérifie si une entrée existe déjà en base
+	_, err := c.db.Get(pk)
+	if err == nil {
+		// Vérifie aussi que le fichier original existe
+		origPath := filepath.Join(c.dir, pk+".orig.webp")
+		if _, statErr := os.Stat(origPath); statErr == nil {
+			return pk, nil
+		}
+		// Si le fichier a disparu → on retélécharge
+	}
+
+	// Sinon, on télécharge et on ajoute
+	return c.AddFromURL(url)
+}
+
+// decodeImage essaie de décoder une image depuis un []byte en utilisant les formats connus
+func decodeImage(data []byte) (image.Image, string, error) {
+	img, format, err := image.Decode(bytes.NewReader(data))
+	if err != nil {
+		return nil, "", fmt.Errorf("échec de décodage image: %w", err)
+	}
+	return img, format, nil
+}
+
 // Add ajoute une image déjà téléchargée
 func (c *Cache) Add(url string, data []byte) (string, error) {
 	pk := pkFromURL(url)
@@ -74,10 +107,12 @@ func (c *Cache) Add(url string, data []byte) (string, error) {
 	defer c.mu.Unlock()
 
 	if _, err := os.Stat(origPath); errors.Is(err, os.ErrNotExist) {
-		img, _, err := image.Decode(bytes.NewReader(data))
+		img, format, err := decodeImage(data)
 		if err != nil {
 			return "", err
 		}
+		fmt.Printf("Décodage réussi : format %s depuis %s\n", format, url)
+
 		buf, err := encodeWebP(img)
 		if err != nil {
 			return "", err
@@ -127,3 +162,48 @@ func pkFromURL(url string) string {
 	h := sha1.Sum([]byte(url))
 	return hex.EncodeToString(h[:8])
 }
+
+// Consolidate parcourt la base et corrige les incohérences
+func (c *Cache) Consolidate() error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	entries, err := c.db.GetAll()
+	if err != nil {
+		return err
+	}
+
+	// Vérifie chaque entrée de la base
+	for _, e := range entries {
+		origPath := filepath.Join(c.dir, e.PK+".orig.webp")
+		if _, err := os.Stat(origPath); os.IsNotExist(err) {
+			// Fichier absent → on retente un download
+			resp, err := http.Get(e.SourceURL)
+			if err != nil || resp.StatusCode != http.StatusOK {
+				// Impossible de retélécharger → suppression de l’entrée
+				_ = c.db.Delete(e.PK)
+				continue
+			}
+			defer resp.Body.Close()
+			data, _ := io.ReadAll(resp.Body)
+			if _, err := c.Add(e.SourceURL, data); err != nil {
+				// Si on échoue quand même → suppression
+				_ = c.db.Delete(e.PK)
+			}
+		}
+	}
+
+	// Vérifie les fichiers orphelins (qui n’ont pas d’entrée en DB)
+	files, _ := filepath.Glob(filepath.Join(c.dir, "*.orig.webp"))
+	for _, f := range files {
+		pk := filepath.Base(f)
+		pk = pk[:len(pk)-len(".orig.webp")]
+		_, err := c.db.Get(pk)
+		if err != nil {
+			// Pas d’entrée en DB → supprimer le fichier
+			_ = os.Remove(f)
+		}
+	}
+
+	return nil
+}