Add images api end point

@@ -8,14 +8,14 @@ repository = "https://gitlab.weird-web-workers.org/rust/artshop"
 license = "GPL-3.0-or-later"
 
 [dependencies]
-actix-files = "0.2"
-actix-rt = "1.1.1"
-actix-web = "2.0"
+actix-files = "^0.5"
+actix-rt = "^1.1"
+actix-web = "^3.3"
 anyhow = "1.0"
 artshop-common = { path = "../common" }
-async-std = "^1.10"
+async-std = { version = "^1.10", features = ["unstable"] }
 chrono = "0.4.15"
-diesel = { version = "1.4.7", features = ["mysql", "sqlite", "r2d2"]}
+diesel = { version = "1.4.7", features = ["mysql", "sqlite", "r2d2"] }
 diffy = "0.2"
 dotenv = "0.15.0"
 flate2 = "^1.0"
@@ -24,6 +24,7 @@ futures-util = { version = "0", features = ["std"] }
 image = "^0.23"
 listenfd = "0.3"
 once_cell = "^1.9"
+mime = "^0.3"
 r2d2 = "0.8.9"
 serde = { version = "^1.0", features = ["derive"] }
 serde_derive = "1.0"

@@ -14,6 +14,8 @@ use routes::markdown::*;
 use routes::other::*;
 use routes::user::*;
 use routes::upload::*;
+use routes::image::*;
+
 
 use actix_web::{guard, web, App, HttpResponse, HttpServer};
 use async_std::channel::Sender;
@@ -21,7 +23,6 @@ use diesel::r2d2::{self, ConnectionManager};
 use diesel::MysqlConnection;
 use listenfd::ListenFd;
 use std::sync::Arc;
-use std::ops::Deref;
 
 pub(crate) type Pool = r2d2::Pool<ConnectionManager<MysqlConnection>>;
 
@@ -37,8 +38,6 @@ async fn main() -> std::io::Result<()> {
 
     dotenv::dotenv().ok();
 
-    println!("CONFIG: {:?}", config::CONFIG.deref());
-
     let tx_upload_worker = upload_worker::launch();
 
     let database_url = std::env::var("DATABASE_URL").expect("NOT FOUND");
@@ -56,6 +55,9 @@ async fn main() -> std::io::Result<()> {
                             . service( web::resource("/upload")
                                      . route(web::post().to(upload))
                                      )
+                            . service( web::resource("/images/{id}")
+                                     . route(web::get().to(get_image))
+                                     )
                             . service( web::resource("/markdowns")
                                      . route(web::get().to(get_markdowns))
                                      )

+use std::convert::TryFrom;
 use std::sync::Arc;
 
 use crate::error::*;
-use crate::{schema::*, Pool};
+use crate::routes::image::Size;
+use crate::uuid::Uuid;
+use crate::{schema::*, Pool, config::CONFIG};
+use async_std::path::PathBuf;
 use diesel::{Connection, insert_into, delete, update};
 use diesel::prelude::*;
 use serde::{Deserialize, Serialize};
@@ -86,6 +90,24 @@ macro_rules! upload_filename {
 }
 
 
+impl Image {
+    pub(crate) fn path(&self, size :Size) -> String {
+        let uuid = Uuid::try_from( self.uuid
+                                 . as_ref()
+                                 . unwrap()
+                                 . as_slice() ).unwrap();
+        let uuid_string = format!("{}", uuid);
+
+        let mut image_path = PathBuf::from(CONFIG.images_dir());
+        image_path.push(&uuid_string.as_str()[..1]);
+        image_path.push(&uuid_string.as_str()[..2]);
+        image_path.push(&uuid_string.as_str()[..3]);
+        image_path.push(&format!("{}_{}", &uuid_string, size));
+
+        image_path.into_os_string().into_string().unwrap()
+    }
+}
+
 pub(crate) fn upload( pool: Arc<Pool>
                     , item: Upload ) -> Result<Image> {
     use crate::schema::images::dsl::*;
@@ -129,3 +151,15 @@ pub(crate) fn finalize( pool: Arc<Pool>
         },
     }
 }
+
+pub(crate) fn get_image( pool:  Arc<Pool>
+                       , ident: i32 ) -> Result<Image>
+{
+    use crate::schema::images::dsl::*;
+
+    let db_connection = pool.get()?;
+
+    Ok( images
+      . filter(id.eq(ident))
+      . first::<Image>(&db_connection)? )
+}

+use std::fmt::Display;
+
+use crate::{models::image, AppData};
+
+use actix_web::{Error, web};
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde (rename_all = "lowercase")]
+pub enum Size {
+    Original,
+    Large,
+    Medium,
+    Small
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct SizeQuery {
+    size :Option<Size>,
+}
+
+impl Display for Size {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let size_str = match self {
+            Size::Original => "original",
+            Size::Large => "large",
+            Size::Medium => "medium",
+            Size::Small => "small"
+        };
+
+        write!(f, "{}", size_str)
+    }
+}
+
+pub async fn get_image( app_data: web::Data<AppData>
+                      , ident: web::Path<i32>
+                      , size: web::Query<SizeQuery>
+                      ) -> Result<actix_files::NamedFile, Error>
+{
+    let pool = app_data.database_pool.clone();
+    let ident = ident.into_inner();
+    let size = size.into_inner().size.or(Some(Size::Large)).unwrap();
+
+    let image = web::block(move || image::get_image(pool, ident)).await?;
+    let path = image.path(size);
+
+    Ok( actix_files::NamedFile::open(path)?
+      . set_content_type(image.mime_type.parse().unwrap())
+      . disable_content_disposition() )
+}

+pub(crate) mod image;
 pub(crate) mod markdown;
 pub(crate) mod other;
 pub(crate) mod upload;

-use std::{io::{SeekFrom, ErrorKind}, sync::Arc};
+use std::{ io::{SeekFrom, ErrorKind}
+         , sync::Arc
+         , convert::TryFrom };
 use actix_web::web;
 use async_std::{ fs::{File, DirBuilder, copy, metadata, remove_file}
                , channel::{Sender, Receiver, bounded}
                , path::PathBuf
-               , io::Result };
+               , io::Result, task::spawn_blocking };
 use futures::{ AsyncSeekExt, AsyncReadExt, FutureExt, StreamExt, select
              , stream::FuturesUnordered};
 
-use crate::{models::image::{Image, finalize}, upload_filename, config::CONFIG, Pool};
-use crate::uuid::Uuid;
+use crate::{ models::image::{Image, finalize}
+           , upload_filename
+           , config::CONFIG
+           , Pool
+           , routes::image::Size
+           , uuid::Uuid };
 
-use std::convert::TryFrom;
-use image::{io::Reader as ImageReader, GenericImageView};
+use image::{ io::Reader as ImageReader
+           , GenericImageView
+           , imageops::FilterType::Lanczos3
+           , ImageFormat::Jpeg };
 
 pub fn launch() -> Sender<(Arc<Pool>, Image)> {
     let (tx_upload_worker, rx_upload_worker)
@@ -50,31 +58,60 @@ async fn worker(pool :Arc<Pool>, mut image :Image) {
     let uuid = Uuid::get(CONFIG.namespace(), buf.as_mut());
     let uuid_string = format!("{}", uuid);
 
-    let mut image_path = PathBuf::from(CONFIG.images_dir());
-    image_path.push(&uuid_string.as_str()[..2]);
-    image_path.push(&uuid_string.as_str()[..5]);
-
-    DirBuilder::new() . recursive(true)
-                      . create(&image_path)
-                      . await
-                      . unwrap();
+    let image_path = PathBuf::from(CONFIG.images_dir());
+    let mut orig_path = image_path.clone();
+    let mut large_path = image_path.clone();
+    let mut medium_path = image_path.clone();
+    let mut small_path = image_path.clone();
+
+    macro_rules! prepare {
+        ($p:expr, $n:expr) => (
+            $p.push(&uuid_string.as_str()[..1]);
+            $p.push(&uuid_string.as_str()[..2]);
+            $p.push(&uuid_string.as_str()[..3]);
+
+            DirBuilder::new() . recursive(true)
+                              . create(&$p)
+                              . await
+                              . unwrap();
+
+            $p.push(&format!("{}_{}", &uuid_string, $n));
+        )
+    }
 
-    image_path.push(&uuid_string);
+    prepare!(orig_path, Size::Original);
+    prepare!(large_path, Size::Large);
+    prepare!(medium_path, Size::Medium);
+    prepare!(small_path, Size::Small);
 
     image.upload_uuid = None;
     image.uuid = Some(uuid.0.as_bytes().to_vec());
 
-    match metadata(&image_path).await {
+    match metadata(&orig_path).await {
         Err(e) if e.kind() == ErrorKind::NotFound => {
-            copy(&upload_filename, &image_path).await.unwrap();
-
-            let img = ImageReader::open(&image_path).unwrap()
-                    . with_guessed_format().unwrap()
-                    . decode().unwrap();
-            let (dim_x, dim_y) = img.dimensions();
-
-            image.dim_x = Some(dim_x as i32);
-            image.dim_y = Some(dim_y as i32);
+            copy(&upload_filename, &orig_path).await.unwrap();
+
+            let (dim_x, dim_y) = spawn_blocking(move || {
+                let img = ImageReader::open(&orig_path).unwrap()
+                        . with_guessed_format().unwrap()
+                        . decode().unwrap();
+                let (dim_x, dim_y) = img.dimensions();
+
+                img . resize(1280, 1280, Lanczos3)
+                    . save_with_format(&large_path, Jpeg)
+                    . unwrap();
+                img . resize(800, 800, Lanczos3)
+                    . save_with_format(&medium_path, Jpeg)
+                    . unwrap();
+                img . resize(400, 400, Lanczos3)
+                    . save_with_format(&small_path, Jpeg)
+                    . unwrap();
+
+                (dim_x as i32, dim_y as i32)
+            }).await;
+
+            image.dim_x = Some(dim_x);
+            image.dim_y = Some(dim_y);
         },
         Err(e) => {
             let e :Result<()> = Err(e);