thumbfix

src/thumbnail.rs

@@ -1,7 +1,9 @@
 use actix_web::error::ErrorInternalServerError;
-use image::{imageops::FilterType, DynamicImage};
+use image::{imageops::FilterType, DynamicImage, ImageFormat};
+use log::warn;
 use std::{collections::HashMap, io::Cursor};
-use image::guess_format;
+
+use crate::{app_state::AppState, s3_utils::upload_to_s3};
 
 pub const THUMB_WIDTHS: [u32; 7] = [10, 40, 110, 300, 600, 800, 1400];
 
@@ -70,23 +72,108 @@ pub fn parse_file_path(requested_path: &str) -> (String, u32, String) {
     (base_filename, width, extension)
 }
 
-
 /// Генерирует миниатюры изображения.
-pub async fn generate_thumbnails(image: &DynamicImage) -> Result<HashMap<u32, Vec<u8>>, actix_web::Error> {
+///
+/// Теперь функция принимает дополнительный параметр `format`, который определяет формат сохранения миниатюр.
+/// Это позволяет поддерживать различные форматы изображений без необходимости заранее предугадывать их.
+pub async fn generate_thumbnails(
+    image: &DynamicImage,
+    format: ImageFormat
+) -> Result<HashMap<u32, Vec<u8>>, actix_web::Error> {
     let mut thumbnails = HashMap::new();
-    let format = guess_format(&image.as_bytes()).unwrap();
+
     for &width in THUMB_WIDTHS.iter().filter(|&&w| w < image.width()) {
         let thumbnail = image.resize(width, u32::MAX, FilterType::Lanczos3); // Ресайз изображения по ширине
         let mut buffer = Vec::new();
         thumbnail
             .write_to(&mut Cursor::new(&mut buffer), format)
-            .map_err(|_| ErrorInternalServerError("Не удалось сгенерировать миниатюру"))?; // Сохранение изображения в указанном формате
+            .map_err(|e| {
+                log::error!("Ошибка при сохранении миниатюры: {}", e);
+                ErrorInternalServerError("Не удалось сгенерировать миниатюру")
+            })?; // Сохранение изображения в указанном формате
         thumbnails.insert(width, buffer);
     }
 
     Ok(thumbnails)
 }
 
+/// Определяет формат изображения на основе расширения файла.
+fn determine_image_format(extension: &str) -> Result<ImageFormat, actix_web::Error> {
+    match extension.to_lowercase().as_str() {
+        "jpg" | "jpeg" => Ok(ImageFormat::Jpeg),
+        "png" => Ok(ImageFormat::Png),
+        "gif" => Ok(ImageFormat::Gif),
+        "bmp" => Ok(ImageFormat::Bmp),
+        "ico" => Ok(ImageFormat::Ico),
+        "tiff" => Ok(ImageFormat::Tiff),
+        "webp" => Ok(ImageFormat::WebP),
+        _ => {
+            log::error!("Неподдерживаемый формат изображения: {}", extension);
+            Err(ErrorInternalServerError("Неподдерживаемый формат изображения"))
+        },
+    }
+}
+
+/// Сохраняет данные миниатюры.
+/// 
+/// Обновлена для передачи корректного формата изображения.
+pub async fn thumbdata_save(
+    original_data: Vec<u8>,
+    state: &AppState,
+    original_filename: &str,
+    content_type: String,
+) -> Result<(), actix_web::Error> {
+    if content_type.starts_with("image") {
+        warn!("original file name: {}", original_filename);
+        let (base_filename, _, extension) = parse_file_path(&original_filename);
+        warn!("detected file extension: {}", extension);
+        let ext = extension.to_lowercase();
+        let filename = format!("{}.{}", base_filename, ext);
+
+        let img = match image::load_from_memory(&original_data) {
+            Ok(img) => img,
+            Err(e) => {
+                warn!("cannot load image from memory: {}", e);
+                return Err(ErrorInternalServerError("cant load image"));
+            }
+        };
+
+        warn!("generate thumbnails for {}", filename);
+
+        // Определяем формат изображения
+        let format = determine_image_format(&ext)?;
+
+        // Генерация миниатюр с использованием определённого формата
+        match generate_thumbnails(&img, format).await {
+            Ok(thumbnails_bytes) => {
+                for (thumb_width, thumbnail) in thumbnails_bytes {
+                    let thumb_filename = format!("{}_{}.{}", base_filename, thumb_width, ext);
+                    // Загружаем миниатюру в S3
+                    if let Err(e) = upload_to_s3(
+                        &state.storj_client,
+                        &state.bucket,
+                        &thumb_filename,
+                        thumbnail,
+                        &content_type,
+                    )
+                    .await
+                    {
+                        warn!("cannot load thumb {}: {}", thumb_filename, e);
+                    } else {
+                        warn!("thumb {} uploaded to storj", thumb_filename);
+                    }
+                }
+            }
+            Err(e) => {
+                warn!("cannot generate thumbnails for {}: {}", filename, e);
+                return Err(e);
+            }
+        }
+    }
+
+    Ok(())
+}
+
 /// Выбирает ближайший подходящий размер из предопределённых.
 pub fn find_closest_width(requested_width: u32) -> u32 {
     *THUMB_WIDTHS