From 412d0b12f077d8a624d3d872285532809ee7fc0c Mon Sep 17 00:00:00 2001
From: Nimer Farahty <nimer@farahty.com>
Date: Fri, 9 May 2025 14:19:13 +0300
Subject: [PATCH] update process image

---
 processor.go | 115 +++++++++++++++++++++++----------------------------
 1 file changed, 52 insertions(+), 63 deletions(-)

diff --git a/processor.go b/processor.go
index 3f5e094..7817c81 100644
--- a/processor.go
+++ b/processor.go
@@ -20,19 +20,13 @@ func ProcessImage(ctx context.Context, client *minio.Client, bucket, key string)
 		return err
 	}
 
-	contentType := stat.ContentType
-	if !strings.HasPrefix(contentType, "image/") {
+	if !strings.HasPrefix(stat.ContentType, "image/") {
 		log.Printf("⏭️ Skipping non-image file: %s", key)
 		return nil
 	}
 
-	if processed := stat.UserMetadata["X-Amz-Meta-Processed"]; processed == "true" {
-		log.Printf("♻️ Already processed: %s", key)
-		return nil
-	}
-
-	if processed := stat.UserMetadata["Processed"]; processed == "true" {
-		log.Printf("♻️ Already processed: %s", key)
+	if stat.UserMetadata["Processed"] == "true" || stat.UserMetadata["X-Amz-Meta-Processed"] == "true" {
+		log.Printf("⏭️ Skipping already processed image: %s", key)
 		return nil
 	}
 
@@ -44,8 +38,7 @@ func ProcessImage(ctx context.Context, client *minio.Client, bucket, key string)
 	defer object.Close()
 
 	sourceBuffer := new(bytes.Buffer)
-	_, err = sourceBuffer.ReadFrom(object)
-	if err != nil {
+	if _, err := sourceBuffer.ReadFrom(object); err != nil {
 		log.Printf("🚨 Failed to read object: %s, error: %v", key, err)
 		return err
 	}
@@ -59,67 +52,63 @@ func ProcessImage(ctx context.Context, client *minio.Client, bucket, key string)
 		"Processed": "true",
 	}
 
-	// Generate optimized JPEG: just convert without resizing, keep quality high
-	jpegBuf, err := img.Process(bimg.Options{
-		Quality:       90,
-		Type:          bimg.JPEG,
-		StripMetadata: true,
-		NoAutoRotate:  false,
-	})
-
-	if err != nil {
-		return fmt.Errorf("failed to generate optimized jpeg: %w", err)
+	if err := generateAndUploadJPEG(ctx, client, img, bucket, filePath, fileName, meta); err != nil {
+		return err
 	}
 
-	// Generate optimized WebP: just convert without resizing, keep quality high
-	webpBuf, err := img.Process(bimg.Options{
-		Quality:       90,
-		Type:          bimg.WEBP,
-		StripMetadata: true,
-		NoAutoRotate:  false,
-	})
-	if err != nil {
-		return fmt.Errorf("failed to generate webp: %w", err)
+	if err := generateAndUploadWebP(ctx, client, img, bucket, filePath, fileName, meta); err != nil {
+		return err
 	}
 
-	// Generate thumbnail: resize to 400px width
-	thumbBuf, err := img.Process(bimg.Options{
-		Width:         400,
-		Quality:       85,
-		Type:          bimg.JPEG,
-		StripMetadata: true,
-		NoAutoRotate:  false,
-	})
-
-	if err != nil {
-		return fmt.Errorf("failed to generate thumbnail: %w", err)
+	if err := generateAndUploadThumbnail(ctx, client, img, bucket, filePath, fileName, meta); err != nil {
+		return err
 	}
 
-	// Upload optimized JPEG
-	err = UploadToMinIO(ctx, client, bucket, path.Join(filePath, "optimized", fileName), "image/jpeg", jpegBuf, meta)
-	if err != nil {
-		return fmt.Errorf("failed to upload optimized jpeg: %w", err)
-	}
-
-	// Upload WebP
-	webpName := strings.TrimSuffix(fileName, filepath.Ext(fileName)) + ".webp"
-	err = UploadToMinIO(ctx, client, bucket, path.Join(filePath, "webp", webpName), "image/webp", webpBuf, meta)
-	if err != nil {
-		return fmt.Errorf("failed to upload webp image: %w", err)
-	}
-
-	// Upload thumbnail
-	err = UploadToMinIO(ctx, client, bucket, path.Join(filePath, "thumbs", fileName), "image/jpeg", thumbBuf, meta)
-	if err != nil {
-		return fmt.Errorf("failed to upload thumbnail: %w", err)
-	}
-
-	// Reupload original with processed=true metadata (unchanged)
-	err = UploadToMinIO(ctx, client, bucket, key, contentType, sourceBuffer.Bytes(), meta)
-	if err != nil {
+	if err := UploadToMinIO(ctx, client, bucket, key, stat.ContentType, sourceBuffer.Bytes(), meta); err != nil {
 		return fmt.Errorf("failed to reupload original image: %w", err)
 	}
 
 	log.Printf("✅ Image processed: %s", key)
 	return nil
 }
+
+func generateAndUploadJPEG(ctx context.Context, client *minio.Client, img *bimg.Image, bucket, filePath, fileName string, meta map[string]string) error {
+	jpegBuf, err := img.Process(bimg.Options{
+		Quality:       90,
+		Type:          bimg.JPEG,
+		StripMetadata: true,
+	})
+	if err != nil {
+		return fmt.Errorf("failed to generate optimized JPEG: %w", err)
+	}
+
+	return UploadToMinIO(ctx, client, bucket, path.Join(filePath, "optimized", fileName), "image/jpeg", jpegBuf, meta)
+}
+
+func generateAndUploadWebP(ctx context.Context, client *minio.Client, img *bimg.Image, bucket, filePath, fileName string, meta map[string]string) error {
+	webpBuf, err := img.Process(bimg.Options{
+		Quality:       90,
+		Type:          bimg.WEBP,
+		StripMetadata: true,
+	})
+	if err != nil {
+		return fmt.Errorf("failed to generate WebP: %w", err)
+	}
+
+	webpName := strings.TrimSuffix(fileName, filepath.Ext(fileName)) + ".webp"
+	return UploadToMinIO(ctx, client, bucket, path.Join(filePath, "webp", webpName), "image/webp", webpBuf, meta)
+}
+
+func generateAndUploadThumbnail(ctx context.Context, client *minio.Client, img *bimg.Image, bucket, filePath, fileName string, meta map[string]string) error {
+	thumbBuf, err := img.Process(bimg.Options{
+		Width:         400,
+		Quality:       85,
+		Type:          bimg.JPEG,
+		StripMetadata: true,
+	})
+	if err != nil {
+		return fmt.Errorf("failed to generate thumbnail: %w", err)
+	}
+
+	return UploadToMinIO(ctx, client, bucket, path.Join(filePath, "thumbs", fileName), "image/jpeg", thumbBuf, meta)
+}