Copyrights and error handling.

Lots of removed unwraps and added copyright info for uploaded
images.

@@ -2,6 +2,7 @@ Cargo.lock
 **/*.rs.bk
 
 **/target
+/data/copyright.png
 /pkg
 /static/ui/
 /var

@@ -4,6 +4,3 @@ members = [ "common", "server" ]
 [profile.release]
 lto = true
 opt-level = "s"
-
-[patch.crates-io]
-diffy = { path = "./target/patch/diffy-0.2.1" }

@@ -39,7 +39,7 @@ start:
 		cargo watch -i static/ -i var/ \
 		-s "PROFILE=$(PROFILE) make run"
 
-run: build wasm
+run: build wasm data/copyright.png
 	$(call msgnl,RUN SERVER)
 	@PROFILE=$(PROFILE) cargo run $(CARGO_PROFILE) --bin artshop-server
 
@@ -54,6 +54,8 @@ clean:
 	@rm -Rf ./static/ui
 	$(call msgnl,CLEAN INSTALLED WASM)
 	@pushd ui; PROFILE=$(PROFILE) cargo clean; popd
+	$(call msgnl,CLEAN COPYRIGHT PNG)
+	@rm -Rf ./data/copyright.png
 
 $(WASM_TARGET): $(WASM_SOURCES)
 	$(call msgnl,BUILD WASM UI)
@@ -71,6 +73,12 @@ $(SERVER_TARGET): $(SERVER_SOURCES)
 	$(call msgnl,BUILD SERVER)
 	@PROFILE=$(PROFILE) cargo build $(CARGO_PROFILE) --bin artshop-server
 
+data/copyright.png: data/copyright.txt
+	$(call msgnl,CREATE COPYRIGHT PNG)
+	@cat $< | convert -pointsize 24 -font Helvetica \
+		-background transparent -fill "rgba(255,255,255,0.35)" \
+		text:- -trim +repage $@
+
 release:
 	docker build -t artshop -f build/Dockerfile .
 
@@ -99,6 +107,8 @@ downdb:
 	@docker stop mariadb-dev||true
 	$(call msgnl,REMOVE DB CONTAINER)
 	@docker rm -v mariadb-dev||true
+	$(call msgnl,REMOVE IMAGES)
+	@rm -Rf var/lib/artshop/images
 
 devdb:
 	$(call msgnl,CREATE DB CONTAINER)

@@ -5,5 +5,17 @@ namespace = "artshop.shome.steffers.org"
 # url = "./var/lib/artshop/database"
 
 [locations]
-upload = "/tmp/artshop/uploads"
+data = "./data"
 images = "./var/lib/artshop/images"
+upload = "/tmp/artshop/uploads"
+
+[sizes]
+large = { width = 1280, height = 1280 }
+medium = { width = 800, height = 800 }
+small = { width = 400, height = 400 }
+thumbnail = {width = 100, height = 100 }
+
+[copyright]
+image_path = "./data/copyright.png"
+steganography = "Copyright © 2022, Stefanies Artshop, All rights reserved"
+exiv = "Copyright, Stefanies Artshop, 2022. All rights reserved"

+Copyright © 2022, Stefanies Artshop

@@ -70,3 +70,12 @@ and parallel:
     https://api.github.com/users/xxxxxxx/events/public
 
 where xxxxxxx is the github username. Then search for email.
+
+# Create a Copyright Watermark ...
+
+    cat text.txt | convert -pointsize 24 -font Helvetica -background black \
+	-fill white text:- -trim +repage text.jpg
+
+    cat copyright.txt | convert -pointsize 24 -font Helvetica \
+    	-background transparent -fill "rgba(255,255,255,0.35)" \
+	text:- -trim +repage copyright.png

@@ -16,7 +16,7 @@ artshop-common = { path = "../common" }
 async-std = { version = "^1.10", features = ["unstable"] }
 chrono = "0.4.15"
 diesel = { version = "1.4.7", features = ["mysql", "sqlite", "r2d2"] }
-diffy = "0.2.1"
+diffy = "0.2.2"
 dotenv = "0.15.0"
 flate2 = "^1.0"
 futures = "^0.3"
@@ -26,13 +26,10 @@ listenfd = "0.3"
 once_cell = "^1.9"
 mime = "^0.3"
 r2d2 = "0.8.9"
+rexiv2 = "^0.9"
 serde = { version = "^1.0", features = ["derive"] }
 serde_derive = "1.0"
 serde_json = "1.0"
+steganography = { git = "https://github.com/teovoinea/steganography" }
 toml = "^0.5"
 uuid = { version = "^0.8", features = ["v4", "v5"] }
-
-[package.metadata.patch.diffy]
-version = "0.2.1"
-patches = ["./patches/diffy-0.2.1_fix-adjacent-hunk-parsing.patch"]
-

 use std::fs::File;
 use std::io::Read;
+use image::{ DynamicImage, io::Reader as ImageReader };
 use once_cell::sync::Lazy;
 use serde::Deserialize;
+use anyhow::Result;
+use crate::routes::image::Size as ImageSize;
 
 #[derive(Debug, Deserialize)]
 struct Database { url :Option<String> }
 
 #[derive(Debug, Deserialize)]
-struct Locations { upload :String
-                 , images :String }
+struct Locations { data   :String
+                 , images :String
+                 , upload :String }
 
 #[derive(Debug, Deserialize)]
-pub(crate) struct Config { namespace :String
-                         , database  :Database
-                         , locations :Locations }
+struct Size { width :u32
+            , height :u32 }
 
-pub(crate) static CONFIG :Lazy<Config> = Lazy::new(|| Config::load());
+#[derive(Debug, Deserialize)]
+struct Sizes { large :Size
+             , medium :Size
+             , small :Size
+             , thumbnail :Size }
+
+#[derive(Debug, Deserialize)]
+struct Copyright { image_path :String
+                 , steganography :String
+                 , exiv :String }
+
+#[derive(Debug, Deserialize)]
+pub(crate) struct ConfigFile { namespace :String
+                             , database  :Database
+                             , locations :Locations
+                             , sizes     :Sizes
+                             , copyright :Copyright }
+
+pub(crate) struct Config { config_file :ConfigFile
+                         , copyright_image :DynamicImage }
+
+pub(crate) static CONFIG :Lazy<Config> =
+    Lazy::new(|| Config::load().unwrap());
 
 impl Config {
-    pub fn load() -> Config {
-        let filename = std::env::var("CONFIG").unwrap();
+    pub fn load() -> Result<Self> {
+        let filename = std::env::var("CONFIG")?;
 
         let mut buffer = vec![];
-        let mut file = File::open(filename).unwrap();
+        let mut file = File::open(filename)?;
 
-        file.read_to_end(&mut buffer).unwrap();
-        let mut config :Config = toml::from_slice(&buffer).unwrap();
+        file.read_to_end(&mut buffer)?;
+        let mut config_file :ConfigFile = toml::from_slice(&buffer)?;
 
-        config.database.url = match config.database.url {
+        config_file.database.url = match config_file.database.url {
             Some(url) => Some(url),
             None => std::env::var("DATABASE_URL").ok()
         };
 
-        config
+        let copyright_image = ImageReader::open(&config_file.copyright.image_path)?
+                            . with_guessed_format()?
+                            . decode()?;
+
+        Ok(Self { config_file, copyright_image })
     }
 
     pub fn namespace(&self) -> &str {
-        self.namespace.as_str()
+        self.config_file.namespace.as_str()
     }
 
     pub fn upload_dir(&self) -> &str {
-        self.locations.upload.as_str()
+        self.config_file.locations.upload.as_str()
     }
 
     pub fn images_dir(&self) -> &str {
-        self.locations.images.as_str()
+        self.config_file.locations.images.as_str()
+    }
+
+    pub fn width(&self, size :ImageSize) -> Option<u32> {
+        match size {
+            ImageSize::Original => None,
+            ImageSize::Large => Some(self.config_file.sizes.large.width),
+            ImageSize::Medium => Some(self.config_file.sizes.medium.width),
+            ImageSize::Small => Some(self.config_file.sizes.small.width),
+            ImageSize::Thumbnail => Some(self.config_file.sizes.thumbnail.width),
+        }
+    }
+
+    pub fn height(&self, size :ImageSize) -> Option<u32> {
+        match size {
+            ImageSize::Original => None,
+            ImageSize::Large => Some(self.config_file.sizes.large.height),
+            ImageSize::Medium => Some(self.config_file.sizes.medium.height),
+            ImageSize::Small => Some(self.config_file.sizes.small.height),
+            ImageSize::Thumbnail => Some(self.config_file.sizes.thumbnail.height),
+        }
+    }
+
+    pub fn copyright_image(&self) -> &DynamicImage {
+        &self.copyright_image
+    }
+
+    pub fn copyright_steganography(&self) -> &str {
+        self.config_file.copyright.steganography.as_str()
+    }
+
+    pub fn copyright_exiv(&self) -> &str {
+        self.config_file.copyright.exiv.as_str()
     }
 }

-use std::{fmt::Display, pin::Pin};
+use std::{fmt::Display, pin::Pin, sync::Arc};
 
+use actix_rt::blocking::BlockingError;
+use actix_web::{http::{StatusCode, header::ToStrError}, ResponseError};
+use async_std::channel::SendError;
 use diesel::result;
-use diffy::ParsePatchError;
+use diffy::{ParsePatchError, ApplyError};
+use image::ImageError;
+use mime::FromStrError;
 use r2d2;
+use rexiv2::Rexiv2Error;
+
+use crate::{Pool, models::image::Image};
 
 type ParentError = Option<Pin<Box<dyn std::error::Error>>>;
 
 #[derive(Debug)]
 pub struct Error {
-    source: ParentError,
-    message: String,
+    source  :ParentError,
+    message :String,
+    status  :Option<StatusCode>
 }
 
 unsafe impl Send for Error {}
@@ -22,19 +31,36 @@ impl std::error::Error for Error {
     }
 }
 
+impl ResponseError for Error {
+    fn status_code(&self) -> StatusCode {
+        self.status.unwrap_or(StatusCode::INTERNAL_SERVER_ERROR)
+    }
+}
+
 impl Display for Error {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Error { source: Some(source), message } =>
-                write!(f, "{}: {}", message, source),
-            Error { source: None, message } => write!(f, "{}", message),
+            Error { source: Some(source), message, status } =>
+                write!( f
+                      , "[{}] {}: {}"
+                      , status.unwrap_or(StatusCode::INTERNAL_SERVER_ERROR)
+                      , message
+                      , source ),
+            Error { source: None, message, status } =>
+                write!( f
+                      , "[{}] {}"
+                      , status.unwrap_or(StatusCode::INTERNAL_SERVER_ERROR)
+                      , message ),
         }
     }
 }
 
-impl From<&str> for Error {
-    fn from(message: &str) -> Self {
-        Self { source: None, message: String::from(message) }
+impl Error {
+    pub(crate) fn new(message :&str, status :StatusCode) -> Self {
+        Self { source: None
+             , message: String::from(message)
+             , status: Some(status)
+        }
     }
 }
 
@@ -42,6 +68,7 @@ impl From<result::Error> for Error {
     fn from(source: result::Error) -> Self {
         Self { source: Some(Box::pin(source))
              , message: String::from("Diesel Result Error")
+             , status: Some(StatusCode::INTERNAL_SERVER_ERROR)
         }
     }
 }
@@ -49,7 +76,8 @@ impl From<result::Error> for Error {
 impl From<r2d2::Error> for Error {
     fn from(source: r2d2::Error) -> Self {
         Self { source: Some(Box::pin(source))
-             , message: String::from("Diesel Result Error")
+             , message: String::from("R2D2 Pool Error")
+             , status: Some(StatusCode::INTERNAL_SERVER_ERROR)
         }
     }
 }
@@ -58,6 +86,7 @@ impl From<std::io::Error> for Error {
     fn from(source: std::io::Error) -> Self {
         Self { source: Some(Box::pin(source))
              , message: String::from("IO Error")
+             , status: Some(StatusCode::INTERNAL_SERVER_ERROR)
         }
     }
 }
@@ -65,7 +94,8 @@ impl From<std::io::Error> for Error {
 impl From<std::str::Utf8Error> for Error {
     fn from(source: std::str::Utf8Error) -> Self {
         Self { source: Some(Box::pin(source))
-             , message: String::from("IO Error")
+             , message: String::from("UTF8 Error")
+             , status: Some(StatusCode::INTERNAL_SERVER_ERROR)
         }
     }
 }
@@ -73,7 +103,17 @@ impl From<std::str::Utf8Error> for Error {
 impl From<ParsePatchError> for Error {
     fn from(source: ParsePatchError) -> Self {
         Self { source: Some(Box::pin(source))
-             , message: String::from("IO Error")
+             , message: String::from("Diffy Error")
+             , status: Some(StatusCode::INTERNAL_SERVER_ERROR)
+        }
+    }
+}
+
+impl From<ApplyError> for Error {
+    fn from(source: ApplyError) -> Self {
+        Self { source: Some(Box::pin(source))
+             , message: String::from("Diffy Error")
+             , status: Some(StatusCode::INTERNAL_SERVER_ERROR)
         }
     }
 }
@@ -82,6 +122,61 @@ impl From<uuid::Error> for Error {
     fn from(source: uuid::Error) -> Self {
         Self { source: Some(Box::pin(source))
              , message: String::from("UUID error")
+             , status: Some(StatusCode::INTERNAL_SERVER_ERROR)
+        }
+    }
+}
+
+impl From<FromStrError> for Error {
+    fn from(source: FromStrError) -> Self {
+        Self { source: Some(Box::pin(source))
+             , message: String::from("Mime error")
+             , status: Some(StatusCode::INTERNAL_SERVER_ERROR)
+        }
+    }
+}
+
+impl From<ToStrError> for Error {
+    fn from(source: ToStrError) -> Self {
+        Self { source: Some(Box::pin(source))
+             , message: String::from("Header error")
+             , status: Some(StatusCode::INTERNAL_SERVER_ERROR)
+        }
+    }
+}
+
+impl From<SendError<(Arc<Pool>, Image)>> for Error {
+    fn from(source: SendError<(Arc<Pool>, Image)>) -> Self {
+        Self { source: Some(Box::pin(source))
+             , message: String::from("Image Worker send error")
+             , status: Some(StatusCode::INTERNAL_SERVER_ERROR)
+        }
+    }
+}
+
+impl From<ImageError> for Error {
+    fn from(source: ImageError) -> Self {
+        Self { source: Some(Box::pin(source))
+             , message: String::from("Image processing error")
+             , status: Some(StatusCode::INTERNAL_SERVER_ERROR)
+        }
+    }
+}
+
+impl From<Rexiv2Error> for Error {
+    fn from(source: Rexiv2Error) -> Self {
+        Self { source: Some(Box::pin(source))
+             , message: String::from("Exiv error")
+             , status: Some(StatusCode::INTERNAL_SERVER_ERROR)
+        }
+    }
+}
+
+impl From<BlockingError<Error>> for Error {
+    fn from(source: BlockingError<Error>) -> Self {
+        Self { source: Some(Box::pin(source))
+             , message: String::from("web::block error")
+             , status: Some(StatusCode::INTERNAL_SERVER_ERROR)
         }
     }
 }

 use std::convert::TryFrom;
+use std::io::SeekFrom;
 use std::sync::Arc;
 
 use crate::error::*;
 use crate::routes::image::Size;
 use crate::uuid::Uuid;
 use crate::{schema::*, Pool, config::CONFIG};
+use actix_web::http::StatusCode;
+use async_std::fs::File;
+use async_std::io::prelude::SeekExt;
 use async_std::path::PathBuf;
 use diesel::{Connection, insert_into, delete, update};
 use diesel::prelude::*;
 use serde::{Deserialize, Serialize};
 
+use async_std::io::ReadExt;
+
 #[derive(Clone, Debug, Serialize, Deserialize, Queryable, Identifiable)]
 pub struct Image {
     pub id           :i32,
@@ -54,6 +60,13 @@ pub struct ImagePatch {
     pub date_updated :String
 }
 
+pub struct ImageContext {
+    pub image       :Image,
+    base_path   :Option<PathBuf>,
+    uuid_string :Option<String>,
+    upload_path :Option<PathBuf>
+}
+
 impl From<Image> for ImagePatch {
     fn from(image: Image) -> Self {
         let now = chrono::Local::now().naive_local();
@@ -69,44 +82,117 @@ impl From<Image> for ImagePatch {
     }
 }
 
-#[macro_export]
-macro_rules! upload_uuid {
-    ($u:expr) => {
-        match &$u.upload_uuid {
-            Some(uuid) => $crate::uuid::Uuid::try_from(uuid.as_slice()).ok(),
-            None       => None,
-        }
-    };
+async fn read_at( f   :&mut File
+                , pos :SeekFrom
+                , buf :&mut [u8]) -> std::io::Result<()> {
+    f.seek(pos).await?;
+    f.read_exact(buf).await
 }
 
-#[macro_export]
-macro_rules! upload_filename {
-    ($u:expr) => {
-        $crate::upload_uuid!($u)
-            . and_then(|uuid| Some(format!( "{}/upload_{}"
-                                          , $crate::config::CONFIG.upload_dir()
-                                          , uuid )))
-    };
-}
+async fn get_sample( f   :&mut File
+                   , buf :&mut [u8]) -> std::io::Result<()> {
+    let file_len = f.metadata().await?.len();
+    let chunk_size = buf.len() / 3;
+
+    read_at(f, SeekFrom::Start(0), &mut buf[0..chunk_size]).await?;
+    if file_len >= 2 * chunk_size as u64 {
+        read_at( f
+               , SeekFrom::End(-(chunk_size as i64))
+               , &mut buf[2*chunk_size..]).await?;
+    }
+    if file_len >= 3 * chunk_size as u64 {
+        read_at( f
+               , SeekFrom::Start((file_len-chunk_size as u64) / 2)
+               , &mut buf[chunk_size..2*chunk_size]).await?;
+    }
 
+    Ok(())
+}
 
 impl Image {
-    // TODO some handling for files that are not processed now
-    // that is uuid is still None.
-    pub(crate) fn path(&self, size :Size) -> String {
-        let uuid = Uuid::try_from( self.uuid
-                                 . as_ref()
-                                 . unwrap()
-                                 . as_slice() ).unwrap();
+    pub(crate) fn context(self) -> ImageContext {
+        ImageContext { image       :self
+                     , base_path   :None
+                     , uuid_string :None
+                     , upload_path :None }
+    }
+}
+
+impl ImageContext {
+    pub(crate) async fn upload_path(&mut self) -> Option<&PathBuf> {
+        if self.upload_path.is_none() {
+            let uuid = Uuid::try_from(self.image.upload_uuid.clone()?).ok()?;
+            let uuid_string = format!("{}", uuid);
+
+            let mut upload_path = PathBuf::from(CONFIG.upload_dir());
+            upload_path.push(&uuid_string);
+
+            self.upload_path = Some(upload_path);
+        }
+
+        self.upload_path.as_ref()
+    }
+
+    async fn uuid_string(&mut self) -> Result<&String> {
+        if self.uuid_string.is_none() {
+            let uuid :Uuid;
+
+            if let Some(u) = &self.image.uuid {
+                uuid = Uuid::try_from(u.as_ref())?;
+            } else {
+                let path = self
+                         . upload_path().await
+                         . ok_or(Error::new( "No upload and no uuid"
+                                           , StatusCode::INTERNAL_SERVER_ERROR ))?;
+
+                let mut f = File::open(&path).await?;
+                let mut buf = vec!['.' as u8; 3 * 3 * 4096];
+
+                get_sample(&mut f, buf.as_mut()).await?;
+                uuid = Uuid::get(CONFIG.namespace(), buf.as_mut());
+
+                self.image.uuid = Some(uuid.0.as_bytes().to_vec());
+                self.image.upload_uuid = None;
+            }
+
+            self.uuid_string = Some(format!("{}", uuid));
+        }
+
+        Ok(self.uuid_string.as_ref().unwrap())
+    }
+
+    pub(crate) async fn base_path(&mut self) -> Option<&PathBuf> {
+        if self.upload_path.is_none() {
+            let uuid_string = self.uuid_string().await.ok()?;
+
+            let mut base_path = PathBuf::from(CONFIG.images_dir());
+            base_path.push(&uuid_string.as_str()[..1]);
+            base_path.push(&uuid_string.as_str()[..2]);
+            base_path.push(&uuid_string.as_str()[..3]);
+
+            self.base_path = Some(base_path);
+        }
+
+        self.base_path.as_ref()
+    }
+
+    pub(crate) async fn path(&mut self, size :Size) -> Option<PathBuf> {
+        let mut path = self.base_path().await?.to_owned();
+        path.push(&format!("{}_{}", &self.uuid_string().await.ok()?, size));
+
+        Some(path)
+    }
+}
+
+impl Upload {
+    pub(crate) async fn upload_path(&mut self) -> Option<PathBuf> {
+        let uuid = Uuid::try_from(self.upload_uuid.clone()?).ok()?;
         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));
+        let mut upload_path = PathBuf::from(CONFIG.upload_dir());
+        upload_path.push(&uuid_string);
 
-        image_path.into_os_string().into_string().unwrap()
+        Some(upload_path)
     }
 }
 
@@ -132,8 +218,8 @@ pub(crate) fn upload( pool: Arc<Pool>
     })?)
 }
 
-pub(crate) fn finalize( pool: Arc<Pool>
-                      , item: Image ) -> Result<Image> {
+pub(crate) fn finalize( pool :Arc<Pool>
+                      , item :Image ) -> Result<Image> {
     use crate::schema::images::dsl::*;
 
     let db_connection = pool.get()?;
@@ -154,8 +240,8 @@ pub(crate) fn finalize( pool: Arc<Pool>
     }
 }
 
-pub(crate) fn get_image( pool:  Arc<Pool>
-                       , ident: i32 ) -> Result<Image>
+pub(crate) fn get_image( pool  :Arc<Pool>
+                       , ident :i32 ) -> Result<Image>
 {
     use crate::schema::images::dsl::*;
 

@@ -162,7 +162,7 @@ pub(crate) fn get_markdown( pool:  Arc<Pool>
             let patch_data = patch.get_diff_as_string()?;
             let decomp = Patch::from_str(&patch_data)?;
 
-            markdown.content = apply(&markdown.content, &decomp).unwrap();
+            markdown.content = apply(&markdown.content, &decomp)?;
             markdown.date_updated = patch.date_created;
         }
     };
@@ -211,8 +211,8 @@ pub(crate) fn update_markdown( pool: Arc<Pool>
     let patch = format!( "{}", create_patch( item.content.as_str()
                                            , markdown.content.as_str() ));
     let mut encoder = DeflateEncoder::new(Vec::new(), Compression::best());
-    encoder.write_all(patch.as_bytes()).unwrap();
-    let compressed = encoder.finish().unwrap();
+    encoder.write_all(patch.as_bytes())?;
+    let compressed = encoder.finish()?;
 
     let last_diff = match markdown_diffs . filter(markdown_id.eq(markdown.id))
                                          . order(diff_id.desc())
@@ -240,7 +240,7 @@ pub(crate) fn update_markdown( pool: Arc<Pool>
         update(&markdown).set(MarkdownChange::from(&item)).execute(&db_connection)?;
 
         Ok(())
-    }).unwrap();
+    })?;
 
     markdown.name               = item.name;
     markdown.content            = item.content;

 use std::fmt::Display;
 
-use crate::{models::image, AppData};
+use crate::{models::image, AppData, error::Error};
 
-use actix_web::{Error, web};
+use actix_web::{Error as ActixError, web, http::StatusCode};
 use anyhow::Result;
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Clone, Copy, Debug, Deserialize, Serialize)]
 #[serde (rename_all = "lowercase")]
 pub enum Size {
     Original,
     Large,
     Medium,
-    Small
+    Small,
+    Thumbnail
 }
 
 #[derive(Debug, Deserialize, Serialize)]
@@ -26,7 +27,8 @@ impl Display for Size {
             Size::Original => "original",
             Size::Large => "large",
             Size::Medium => "medium",
-            Size::Small => "small"
+            Size::Small => "small",
+            Size::Thumbnail => "thumbnail"
         };
 
         write!(f, "{}", size_str)
@@ -36,16 +38,21 @@ impl Display for Size {
 pub async fn get_image( app_data: web::Data<AppData>
                       , ident: web::Path<i32>
                       , size: web::Query<SizeQuery>
-                      ) -> Result<actix_files::NamedFile, Error>
+                      ) -> Result<actix_files::NamedFile, ActixError>
 {
     let pool = app_data.database_pool.clone();
     let ident = ident.into_inner();
-    let size = size.into_inner().size.or(Some(Size::Large)).unwrap();
+    let size = size.into_inner().size.unwrap_or(Size::Large);
 
     let image = web::block(move || image::get_image(pool, ident)).await?;
-    let path = image.path(size);
+    let path = image.clone().context()
+             . path(size).await
+             . ok_or(Error::new( "Image not ready"
+                               , StatusCode::SERVICE_UNAVAILABLE ))?;
 
     Ok( actix_files::NamedFile::open(path)?
-      . set_content_type(image.mime_type.parse().unwrap())
+      . set_content_type( image.mime_type
+                        . parse()
+                        . map_err(|e| Error::from(e))? )
       . disable_content_disposition() )
 }

-use actix_web::{Error, HttpResponse, web};
+use actix_web::{Error as ActixError, HttpResponse, web, http::StatusCode};
 use anyhow::Result;
 use async_std::fs::DirBuilder;
 use futures::{stream::StreamExt, AsyncWriteExt};
 use async_std::fs::OpenOptions;
 
-use crate::{AppData, models::image::{Upload, self}, upload_filename};
+use crate::{AppData, models::image::{Upload, self}, error::Error};
 use crate::config::CONFIG;
-use std::convert::TryFrom;
 
 pub async fn upload( app_data :web::Data<AppData>
                    , mut body :web::Payload
-                   , request  :web::HttpRequest ) -> Result<HttpResponse, Error>
+                   , request  :web::HttpRequest
+                   ) -> Result<HttpResponse, ActixError>
 {
     let pool = app_data.database_pool.clone();
     let worker = app_data.tx_upload_worker.clone();
 
     let upload_uuid = Some(uuid::Uuid::new_v4().as_bytes().to_vec());
     let size = request.headers().get("content-length")
-             . and_then(|h| Some(h.to_str().unwrap().parse::<i32>()))
-             . unwrap().unwrap();
-    let mime_type = String::from( request.headers().get("content-type")
-                                . and_then(|h| Some(h.to_str().unwrap()))
-                                . unwrap() );
+             . and_then(|h| h.to_str().ok())
+             . and_then(|s| s.parse::<i32>().ok());
+    let mime_type = request.headers().get("content-type")
+                  . and_then(|h| h.to_str().ok())
+                  . ok_or(Error::new( "Upload expects content-type"
+                                    , StatusCode::BAD_REQUEST ))?;
+    let mime_type = String::from(mime_type);
 
-    let upload = Upload {
+    let mut upload = Upload {
         upload_uuid,
-        size,
+        size: size.unwrap_or(0),
         mime_type
     };
 
@@ -33,24 +35,33 @@ pub async fn upload( app_data :web::Data<AppData>
                       . create(CONFIG.upload_dir())
                       . await?;
 
-    let upload_filename = upload_filename!(upload).unwrap();
+    let mut upload_size = 0;
+    let upload_filename = upload.upload_path().await.unwrap();
     let mut output = OpenOptions::new();
     let mut output = output
                    . create(true)
                    . write(true)
                    . open(&upload_filename).await?;
     while let Some(item) = body.next().await {
-        output.write_all(&item?).await?;
+        let item = item?;
+        output.write_all(&item).await?;
+        upload_size += item.len() as i32;
+    }
+    output.flush().await?;
+
+    if let Some(size) = size {
+        if size != upload_size {
+            Err(Error::new( "Did not receive expected size"
+                          , StatusCode::BAD_REQUEST ))?
+        }
+    } else {
+        upload.size = upload_size;
     }
-    output.flush().await.unwrap();
 
     let pool_for_worker = pool.clone();
-    Ok( match web::block(move || image::upload(pool, upload)).await {
-        Ok(image) => {
-            // TODO handle this as error response...
-            worker.send((pool_for_worker, image.clone())).await.unwrap();
-            HttpResponse::Ok().json(image)
-        },
-        Err(_) => HttpResponse::InternalServerError().finish()
-    } )
+    let image = web::block(move || image::upload(pool, upload)).await?;
+    worker . send((pool_for_worker, image.clone())).await
+           . map_err(|e| Error::from(e))?;
+
+    Ok(HttpResponse::Accepted().json(image))
 }

-use std::{ io::{SeekFrom, ErrorKind}
-         , sync::Arc
-         , convert::TryFrom };
-use actix_web::web;
-use async_std::{ fs::{File, DirBuilder, copy, metadata, remove_file}
+use std::{ io::ErrorKind
+         , sync::Arc };
+use actix_web::{web, http::StatusCode};
+use async_std::{ fs::{DirBuilder, copy, metadata, remove_file}
                , channel::{Sender, Receiver, bounded}
-               , path::PathBuf
-               , io::Result, task::spawn_blocking };
-use futures::{ AsyncSeekExt, AsyncReadExt, FutureExt, StreamExt, select
+               , task::spawn_blocking };
+use futures::{ FutureExt, StreamExt, select
              , stream::FuturesUnordered};
+use rexiv2::Metadata;
+use steganography::encoder::Encoder;
 
-use crate::{ models::image::{Image, finalize}
-           , upload_filename
+use crate::{ models::image::{Image, finalize, ImageContext}
            , config::CONFIG
            , Pool
            , routes::image::Size
-           , uuid::Uuid };
+           , error::Error };
 
 use image::{ io::Reader as ImageReader
            , GenericImageView
-           , imageops::FilterType::Lanczos3
-           , ImageFormat::Jpeg };
+           , imageops::{FilterType::Lanczos3, overlay}
+           , ImageFormat::Jpeg, DynamicImage };
 
 pub fn launch() -> Sender<(Arc<Pool>, Image)> {
     let (tx_upload_worker, rx_upload_worker)
@@ -48,105 +47,99 @@ pub fn launch() -> Sender<(Arc<Pool>, Image)> {
     tx_upload_worker
 }
 
+async fn store_original(context :&mut ImageContext) -> Result<(), Error> {
+    let upload_path = context
+                    . upload_path().await
+                    . ok_or(Error::new( "Can't retreive upload path"
+                                      , StatusCode::INTERNAL_SERVER_ERROR ))?
+                    . to_owned();
+    let original_path = context
+                      . path(Size::Original).await
+                      . ok_or(Error::new( "No path for given size"
+                                        , StatusCode::INTERNAL_SERVER_ERROR ))?;
+
+    match metadata(&original_path).await {
+        Err(e) if e.kind() == ErrorKind::NotFound => {
+            copy(&upload_path, &original_path).await?;
+            remove_file(&upload_path).await?;
+            Ok(())
+        },
+        Err(e) => Err(e)?,
+        Ok(_) => Ok(()),
+    }
+}
 
-async fn worker(pool :Arc<Pool>, mut image :Image) {
-    let upload_filename = upload_filename!(image).unwrap();
-    let mut f = File::open(&upload_filename).await.unwrap();
+async fn load_original(context :&mut ImageContext) -> Result<DynamicImage, Error> {
+    let original_path = context
+                      . path(Size::Original).await
+                      . ok_or(Error::new( "Unable to load original image"
+                                        , StatusCode::INTERNAL_SERVER_ERROR ))?;
 
-    let mut buf = vec!['.' as u8; 3 * 3 * 4096];
-    get_sample(&mut f, buf.as_mut()).await.unwrap();
-    let uuid = Uuid::get(CONFIG.namespace(), buf.as_mut());
-    let uuid_string = format!("{}", uuid);
+    spawn_blocking(move || -> Result<DynamicImage, Error> {
+        Ok(ImageReader::open(&original_path)? . with_guessed_format()?
+                                              . decode()?)
+    }).await
+}
 
-    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();
+async fn save_resized( original :&DynamicImage
+                     , context :&mut ImageContext
+                     , size :Size ) -> Result<(), Error> {
+    let width = CONFIG.width(size)
+              . ok_or(Error::new( "Can't get width for size"
+                                , StatusCode::INTERNAL_SERVER_ERROR ))?;
+    let height = CONFIG.height(size)
+               . ok_or(Error::new( "Can't get height for size"
+                                 , StatusCode::INTERNAL_SERVER_ERROR ))?;
+
+    let path = context.path(size).await
+             . ok_or(Error::new( "Can't get path for size"
+                               , StatusCode::INTERNAL_SERVER_ERROR ))?;
+
+    let original = original.to_owned();
+
+    spawn_blocking(move || -> Result<(), Error> {
+        let mut scaled = original.resize(width, height, Lanczos3);
+        overlay(&mut scaled, CONFIG.copyright_image(), 0_u32, 0_u32);
+
+        if let Size::Thumbnail = size {
+            scaled.save_with_format(&path, Jpeg)?;
+        } else {
+            let stegonography = CONFIG.copyright_steganography().as_bytes();
+            let encoder = Encoder::new(stegonography, scaled);
+            let scaled = encoder.encode_alpha();
+            scaled.save_with_format(&path, Jpeg)?;
+        }
 
-    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]);
+        let exiv = Metadata::new_from_path(&path)?;
+        exiv.set_tag_string("Exif.Image.Copyright", CONFIG.copyright_exiv())?;
+        exiv.save_to_file(&path)?;
 
-            DirBuilder::new() . recursive(true)
-                              . create(&$p)
-                              . await
-                              . unwrap();
+        Ok(())
+    }).await
+}
 
-            $p.push(&format!("{}_{}", &uuid_string, $n));
-        )
-    }
+async fn worker(pool :Arc<Pool>, image :Image) -> Result<(), Error> {
+    let mut context = image.context();
 
-    prepare!(orig_path, Size::Original);
-    prepare!(large_path, Size::Large);
-    prepare!(medium_path, Size::Medium);
-    prepare!(small_path, Size::Small);
+    DirBuilder::new() . recursive(true)
+                      . create(context.base_path().await.unwrap())
+                      . await
+                      . unwrap();
 
-    image.upload_uuid = None;
-    image.uuid = Some(uuid.0.as_bytes().to_vec());
+    store_original(&mut context).await.unwrap();
 
-    match metadata(&orig_path).await {
-        Err(e) if e.kind() == ErrorKind::NotFound => {
-            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);
-            e.unwrap();
-        },
-        Ok(_) => {},
-    }
-
-    remove_file(&upload_filename).await.unwrap();
-    web::block(move || finalize(pool, image)).await.unwrap();
-}
+    let original = load_original(&mut context).await.unwrap();
+    let (dim_x, dim_y) = original.dimensions();
 
-async fn read_at( f   :&mut File
-                , pos :SeekFrom
-                , buf :&mut [u8]) -> std::io::Result<()> {
-    f.seek(pos).await?;
-    f.read_exact(buf).await
-}
+    context.image.dim_x = Some(dim_x as i32);
+    context.image.dim_y = Some(dim_y as i32);
 
-async fn get_sample( f   :&mut File
-                       , buf :&mut [u8]) -> std::io::Result<()> {
-    let file_len = f.metadata().await?.len();
-    let chunk_size = buf.len() / 3;
+    save_resized(&original, &mut context, Size::Large).await?;
+    save_resized(&original, &mut context, Size::Medium).await?;
+    save_resized(&original, &mut context, Size::Small).await?;
+    save_resized(&original, &mut context, Size::Thumbnail).await?;
 
-    read_at(f, SeekFrom::Start(0), &mut buf[0..chunk_size]).await?;
-    if file_len >= 2 * chunk_size as u64 {
-        read_at( f
-               , SeekFrom::End(-(chunk_size as i64))
-               , &mut buf[2*chunk_size..]).await?;
-    }
-    if file_len >= 3 * chunk_size as u64 {
-        read_at( f
-               , SeekFrom::Start((file_len-chunk_size as u64) / 2)
-               , &mut buf[chunk_size..2*chunk_size]).await?;
-    }
+    web::block(move || finalize(pool, context.image)).await?;
 
     Ok(())
 }

@@ -30,3 +30,11 @@ impl TryFrom<&[u8]> for Uuid {
         Ok(Self(uuid::Uuid::from_slice(value)?))
     }
 }
+
+impl TryFrom<Vec<u8>> for Uuid {
+    type Error = Error;
+
+    fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
+        Ok(Self(uuid::Uuid::from_slice(value.as_slice())?))
+    }
+}

@@ -21,7 +21,7 @@ impl UploadApi {
                                               , upload.size()
                                               , upload.data() ).await?;
         match response.status() {
-            200 => Ok(self),
+            202 => Ok(self),
             status => Err(Self::status_error(status)),
         }
     }