Fix #5 - Use mysql/mariadb now and finish upload

Because the sqlite was no longer able to handle the concurrency
even one user produces during a multi- file- upload.

 CONFIG=artshop.toml
-DATABASE_URL=crud.db
+#DATABASE_URL=crud.db
+DATABASE_URL="mysql://artshop:123456@127.0.0.1/artshop"

@@ -4,3 +4,4 @@ Cargo.lock
 **/target
 /pkg
 /static/ui/
+/var

@@ -17,7 +17,7 @@ endef
 
 start:
 	systemfd --no-pid -s 0.0.0.0:3000 -- \
-		cargo watch -i static/ -s "PROFILE=$(PROFILE) make run"
+		cargo watch -i static/ -i var/ -s "PROFILE=$(PROFILE) make run"
 
 wasm:
 	$(call msg,BUILD WASM UI)
@@ -35,6 +35,22 @@ run: build wasm
 release:
 	docker build -t artshop -f build/Dockerfile .
 
+devdb:
+	docker network create mariadb-dev-network
+	docker run --detach --network mariadb-dev-network --name mariadb-dev \
+		-p 3306:3306 \
+		--env MARIADB_USER=artshop \
+		--env MARIADB_PASSWORD=123456 \
+		--env MARIADB_ROOT_PASSWORD=123456 mariadb:latest
+
+enterdb:
+	docker exec -it mariadb-dev mysql -D artshop -u artshop -p
+#	docker run -it --network mariadb-dev-network --rm mariadb:latest \
+#		mysql -h mariadb-dev -u artshop -p
+
+rootdb:
+	docker exec -it mariadb-dev mysql -p
+
 clean:
 	cargo clean
 	rm -Rf ./static/ui

+# This is the base namespace used for uuid generation.
+namespace = "artshop.shome.steffers.org"
+
 [database]
 # url = "./var/lib/artshop/database"
 

@@ -59,3 +59,8 @@ web::block already for write actions.
 Simple explanation on technical terms synchronous, asynchronous, concurrent
 and parallel:
 [synchronous vs. asynchronous vs. concurrent vs. parallel](https://medium.com/plain-and-simple/synchronous-vs-asynchronous-vs-concurrent-vs-parallel-4342bfb8b9f2, 'synchronous vs. asynchronous vs. concurrent vs. parallel')
+
+# Docker mariadb preparation
+
+    GRANT ALL PRIVILEGES ON artshop.* TO 'artshop'@'%';
+    CREATE DATABASE artshop CHARACTER SET = 'utf8mb3' COLLATE = 'utf8mb3_general_ci';

--- This file should undo anything in `up.sql`
\ No newline at end of file
+-- This file should undo anything in `up.sql`
+DROP TABLE users;

 -- Your SQL goes here
-CREATE TABLE "users" (
-	id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+CREATE TABLE users (
+	id INTEGER PRIMARY KEY AUTO_INCREMENT NOT NULL,
 	name TEXT NOT NULL,
 	address TEXT NOT NULL,
 	date_created TEXT NOT NULL
 );
 
-INSERT INTO
-	"users"(name, address, date_created)
+INSERT INTO users
+	(name, address, date_created)
 VALUES
-	("John", "123 Av Q", "Today");
+	('John', '123 Av Q', 'Today');

 -- This file should undo anything in `up.sql`
-DROP INDEX "markdown_diffs_id";
-DROP TABLE "markdown_diffs";
-DROP TABLE "markdowns";
+DROP TABLE markdown_diffs;
+DROP TABLE markdowns;

-CREATE TABLE "markdowns" (
-	id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+CREATE TABLE markdowns (
+	id INTEGER PRIMARY KEY AUTO_INCREMENT NOT NULL,
 	name VARCHAR(256) NOT NULL,
 	content TEXT NOT NULL,
 	number_of_versions INTEGER NOT NULL DEFAULT (1),
@@ -13,7 +13,7 @@ CREATE TABLE "markdowns" (
 -- The date_created here should be set to the value of
 -- markdown.date_updated when the patch was created. This diff_id
 -- is always current last max diff_id for given markdown_id plus 1.
-CREATE TABLE "markdown_diffs" (
+CREATE TABLE markdown_diffs (
 	markdown_id INTEGER NOT NULL,
 	diff_id INTEGER NOT NULL,
 	diff BLOB NOT NULL,
@@ -21,84 +21,120 @@ CREATE TABLE "markdown_diffs" (
 	PRIMARY KEY (markdown_id, diff_id)
 );
 
-INSERT INTO
-	"markdowns"(name, content, date_created, date_updated)
+INSERT INTO markdowns
+	(name, content, date_created, date_updated)
 VALUES
-	( "md-example"
-        , "# Ein sehr schöner Titel
+	( 'md-example'
+        , "# Markdown Cheatsheat
 
-## Ein sinnloser Text
+## Überschriften
+---
 
-Hier kommt ganz viel Text der irgendwie auch was machen soll, aber Zeilen
-sollen auch im <pre> Eingabefeld automatisch umbrechen.
+# # <H1>
+## ## <H2>
+### ### <H3>
+#### #### <H4>
+##### ##### <H5>
+###### ###### <H6>
 
-Ein neuner Paragraph beginnt nach einer Leerzeile.  
-Ein Umbruch entsteht wie gewohnt durch 2 spaces am Ende einer
-Zeile.
+## Absätze und Umbrüche
+---
 
-## Fußnoten
+Ein einfacher Zeilenumbruch
+verändert den Textfluss nicht. Spaces             haben           auch keinen Einfluss auf den Textfluss. Es ist selten eine gute Idee große Abstände innerhalb eines Textes zu habe, sollte man diese aber wirklich brauchen kann man auf        inline html        zurückgreifen.
 
-Vllt. kann man sogar so was wie Fussnoten[^1] in den Markdown Text
-einbinden... diese kann man dann irgendwo einbauen...
+Leerzeilen erzeugen neue Paragraphen. Um im formatierten Text einen Zeilenumbruch zu erzeugen verwendet man zwei Spaces vor einem Zeilenumbruch im Eingabetext.  
+Dies führt nicht zu einem Paragraphen.
 
+## Hervorhebungen
 ---
 
-[^1]: Zum Beispiel so...
-
-[^2]: Oder so...
-
-## inline html ist im Moment auch ok.
+- *kursive (schwache) Hervorhebung*
+- **fette (starke) Hervorhebung**
+- ***kursiv und fette (sehr starke) Hervorhebung***
+- *schwache mit **eingebetteter starker** Hervorhebung*
+- **starke mit *eingebetteter schwacher* Hervorhebung**
+- ~~durchgestrichen~~
+- <u>unterstreichen nur mit HTML</u>
+- ~~*durchgestrichen kursiv*~~
+- **~~fett durchgestrichen~~**
+- *<u>kursiv unterstrichen</u>*
+- <u>**unterstrichen fett**</u>
+
+## Gedanken- und Binde--strich
+---
 
-<pre>Lustigerweise geht auch inline html</pre>
+Ein Einfaches Minus bildet im Text den Gedankenstrich *hyphen* (-). Zwei oder mehr Minus werden zu verschieden langen Bindestrichen *dash* (--, ---). In regulärem
+Text kommen zwei Minuszeichen hintereinander in der Regel nicht vor. In
+Programmcode, der in ASCII geschrieben ist allerdings schon. Will man also zwei
+Minuszeichen separat darstellen kann man diese in inline code packen (`--, ---`).
 
-## Listen for fun
+## Listen
+---
 
-- ein Liste
-    - mehr Liste
-    - diesmal als Subliste.
-- und was auch immer...
-    1. und nun Verschachtelt.
-        1. Numeriert.
-        2. huhuhu
-        3. wie bitte.
-    2. juhu
-- noch mehr Liste
+- erster Listeneintrag
+    - erster Unterlisteneintrag
+    - zweiter Unterlisteneintrag
+- zweiter Listeneintrag
+    1. erster nummerierter Listeneintrag
+        1. erster nummerierter Unterlisteneintrag
+        2. zweiter nummerierter Unterlisteneintrag
+        3. dritter nummerierter Unterlisteneintrag
+    2. zweiter nummerierter Listeneintrag
+- dritter Listeneintrag
+    - [x] erster Auswahllisteneintrag
+    - [ ] zweiter Auswahllisteneintrag
+    - [x] dritter Auswahllisteneintrag
+- vierter Listeneintrag
+    1. [ ] erster nummerierter Auswahllisteneintrag
+    2. [x] zweiter nummerierter Auswahllisteneintrag
+
+## Code Blöcke
+---
 
-## Preformated Text
+    Dies ist ein codeblock durch Einrückung.
+      In diesem werden    keine Formatierungen
+        vorgenommen.
 
-```Hier kommt der code```
+Mit backticks lassen sich Codeblöcke mit Sprachinformation
+erstellen. Theoretisch könnte für solche Böcke dann Syntax-Highliting eingebaut werden.
 
-Und hier der Paragraph mit `inline code` der auch sehr schön aussehen kann.
+```shell
+#!/bin/env sh
 
-## Hervorhebungen
+FOO="foo"
 
-Man kann Text auch sehr schön formatieren. So ist es z.B. möglich
-*Worte kursiv zu stellen* oder man kann **sie auch fett schreiben**.
-Als spezielles feature kann der von mir verwendete Parser auch
-~~Texte durchstreichen~~.
+function func() {
+  local BAR=bar
+}
+```
 
-Nur wenn man Text <u>unterstreichen</u> will muss man auf inline html
-zurückgreifen.
+Auch in den Fließtext lassen sich `inline code` Elemente einfügen um z.B. einzelne Kommandos hervorzuheben.
 
-## Blockquotes und horizontale Linie
+## Zitate und horizontale Linie
+---
 
-> Dies sollte jetzt als quote erkennbar sein.
+> Dies ist ein Zitat.
 >
->> Auch diese sind schachtelbar
+>> Zitate können verschachtelt sein.
 >
-> Und weiter gehts.
+> Wir können also zitieren was jemand zitiert hat.
+> Solange die Zeilen ohne Unterbrechung mit einem >
+> beginnen bleibt es ein Zitat
 
----
 
-> Aber dies ist ein neuer quote.
+> Sobald eine Zeile ohne führendes > auftaucht endet ein
+> Zitat.
 
 ## Links
+---
 
-Ein link kann inline geschrieben werden, so wie diese zu
+Ein Link kann inline geschrieben werden, so wie diese zu
 [Heise.de](https://heise.de/ 'Heise.de') oder als Referenz am Ende des Textes
 wie diese nach [Telepolis][lnk1].
 
-## Bilder koennte man auch einbinden.
+## Bilder
+---
 
 Wie Links lassen sich auch Bilder wie mein
 ![Gravatar](https://www.gravatar.com/avatar/fd016c954ec4ed3a4315eeed6c8b97b8)
@@ -106,36 +142,57 @@ in den Text ein.
 
 Im Fließtext sieht das allerdings ein bisschen dumm aus es sei denn man hat
 entsprechend angepasste styles. Besser scheint mir daher Bilder nur zwischen
-Paragraphen zu plazieren.
+Paragraphen zu platzieren.
 
 ![Gravatar](https://www.gravatar.com/avatar/fd016c954ec4ed3a4315eeed6c8b97b8)
 
 Etwas so wie hier.
 
-## Tabellen sollten auch gehen...
+## Tabellen
+---
 
 Die folgenden Beispiele kommen von [markdown.land][lnk2]:
 
-| Item         | Price     | # In stock |
-|--------------|-----------|------------|
-| Juicy Apples | 1.99      | *8*        |
-| Bananas      | **1.89**  | 5234       |
+| Artikel       | Preis     | Bestand    |
+|---------------|-----------|------------|
+| Saftige Äpfel | 1.99      | *8*        |
+| Bananen       | **1.89**  | 5234       |
 
 Man braucht sie nicht schön zu formatieren.
 
-Item | Price | # In stock
+Artikel | Preis | Bestand
 ---|---|---
-Juicy Apples | 1.99 | 739
-Bananas | 1.89 | 6
+Saftige Äpfel | 1.99 | 739
+Bananen | 1.89 | 6
 
 und die Spaltenausrichtung kann man auch einstellen:
 
-| Item         | Price | # In stock |
-|--------------|:-----:|-----------:|
-| Juicy Apples |  1.99 |        739 |
-| Bananas      |  1.8900 |          6 |
+| Artikel       | Preis   | Bestand    |
+|---------------|:-------:|-----------:|
+| Saftige Äpfel |  1.99   |        739 |
+| Bananen       |  1.8900 |          6 |
+
+## Fußnoten
+---
+
+Man kann auch verlinkte Fußnoten[^1] in den Text
+einbinden. Die Fußnote selber kann dann an beliebige stelle im Text stehen.
+
+---
+[^1]: Zum Beispiel so.
+
+[^2]: Diese Fußnote hat keine Verlinkung im Text.
+
+## HTML einbetten
+
+<ul>
+<li>
+<pre>Man kann auch direkt HTML tags einbetten,
+wie hier.</pre>
+</li>
+</ul>
 
 [lnk1]: https://heise.de/tp/ 'Telepolis'
-[lnk2]: https://markdown.land/markdown-table 'markdown.land'"
-	, "Today"
-	, "Today" );
+[lnk2]: https://arkdown.land/markdown-table 'markdown.land' "
+	, '2022-01-29 21:33:34.000'
+	, '2022-01-29 21:33:34.000' );

 -- This file should undo anything in `up.sql`
-DROP TABLE "images";
+DROP TABLE images;

-CREATE TABLE "images" (
-	id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+CREATE TABLE images (
+	id INTEGER PRIMARY KEY AUTO_INCREMENT NOT NULL,
 	-- identical uuid means identical file.
 	upload_uuid BLOB(16) UNIQUE,
 	uuid BLOB(16) UNIQUE,

@@ -15,12 +15,13 @@ anyhow = "1.0"
 artshop-common = { path = "../common" }
 async-std = "^1.10"
 chrono = "0.4.15"
-diesel = { version = "1.4.7", features = ["sqlite", "r2d2"]}
+diesel = { version = "1.4.7", features = ["mysql", "sqlite", "r2d2"]}
 diffy = "0.2"
 dotenv = "0.15.0"
 flate2 = "^1.0"
 futures = "^0.3"
 futures-util = { version = "0", features = ["std"] }
+image = "^0.23"
 listenfd = "0.3"
 once_cell = "^1.9"
 r2d2 = "0.8.9"

@@ -11,7 +11,8 @@ struct Locations { upload :String
                  , images :String }
 
 #[derive(Debug, Deserialize)]
-pub(crate) struct Config { database  :Database
+pub(crate) struct Config { namespace :String
+                         , database  :Database
                          , locations :Locations }
 
 pub(crate) static CONFIG :Lazy<Config> = Lazy::new(|| Config::load());
@@ -34,6 +35,10 @@ impl Config {
         config
     }
 
+    pub fn namespace(&self) -> &str {
+        self.namespace.as_str()
+    }
+
     pub fn upload_dir(&self) -> &str {
         self.locations.upload.as_str()
     }

@@ -18,17 +18,17 @@ use routes::upload::*;
 use actix_web::{guard, web, App, HttpResponse, HttpServer};
 use async_std::channel::Sender;
 use diesel::r2d2::{self, ConnectionManager};
-use diesel::SqliteConnection;
+use diesel::MysqlConnection;
 use listenfd::ListenFd;
 use std::sync::Arc;
 use std::ops::Deref;
 
-pub(crate) type Pool = r2d2::Pool<ConnectionManager<SqliteConnection>>;
+pub(crate) type Pool = r2d2::Pool<ConnectionManager<MysqlConnection>>;
 
 #[derive(Clone)]
 pub struct AppData {
     pub database_pool: Arc<Pool>,
-    pub tx_upload_worker: Sender<Image>,
+    pub tx_upload_worker: Sender<(Arc<Pool>, Image)>,
 }
 
 #[actix_rt::main]

@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use crate::error::*;
 use crate::{schema::*, Pool};
-use diesel::{Connection, insert_into};
+use diesel::{Connection, insert_into, delete, update};
 use diesel::prelude::*;
 use serde::{Deserialize, Serialize};
 
@@ -32,16 +32,44 @@ pub struct ImageNew<'a> {
 #[derive(Clone, Debug, Serialize, Deserialize, AsChangeset)]
 #[table_name = "images"]
 pub struct Upload {
+    pub upload_uuid :Option<Vec<u8>>,
+    pub size        :i32,
+    pub mime_type   :String,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, AsChangeset)]
+#[table_name = "images"]
+#[changeset_options(treat_none_as_null = "true")]
+pub struct ImagePatch {
     pub upload_uuid  :Option<Vec<u8>>,
+    pub uuid         :Option<Vec<u8>>,
     pub size         :i32,
+    pub dim_x        :Option<i32>,
+    pub dim_y        :Option<i32>,
     pub mime_type    :String,
+    pub date_updated :String
+}
+
+impl From<Image> for ImagePatch {
+    fn from(image: Image) -> Self {
+        let now = chrono::Local::now().naive_local();
+
+        Self { upload_uuid  :image.upload_uuid
+             , uuid         :image.uuid
+             , size         :image.size
+             , dim_x        :image.dim_x
+             , dim_y        :image.dim_y
+             , mime_type    :image.mime_type
+             , date_updated :format!("{}", now)
+        }
+    }
 }
 
 #[macro_export]
 macro_rules! upload_uuid {
     ($u:expr) => {
         match &$u.upload_uuid {
-            Some(uuid) => Uuid::try_from(uuid.as_slice()).ok(),
+            Some(uuid) => $crate::uuid::Uuid::try_from(uuid.as_slice()).ok(),
             None       => None,
         }
     };
@@ -50,10 +78,10 @@ macro_rules! upload_uuid {
 #[macro_export]
 macro_rules! upload_filename {
     ($u:expr) => {
-        upload_uuid!($u).and_then(|uuid|
-                                  Some(format!( "{}/upload_{}"
-                                              , CONFIG.upload_dir()
-                                              , uuid)))
+        $crate::upload_uuid!($u)
+            . and_then(|uuid| Some(format!( "{}/upload_{}"
+                                          , $crate::config::CONFIG.upload_dir()
+                                          , uuid )))
     };
 }
 
@@ -79,3 +107,25 @@ pub(crate) fn upload( pool: Arc<Pool>
                . first::<Image>(&db_connection)
     })?)
 }
+
+pub(crate) fn finalize( pool: Arc<Pool>
+                      , item: Image ) -> Result<Image> {
+    use crate::schema::images::dsl::*;
+
+    let db_connection = pool.get()?;
+    let item_uuid = item.uuid.clone();
+
+    match images . filter(uuid.eq(item_uuid))
+                 . first::<Image>(&db_connection) {
+        Ok(image) => {
+            delete(images.find(item.id)).execute(&db_connection)?;
+            Ok(image)
+        },
+        Err(_) => {
+            let image = images.find(item.id);
+            let patch = ImagePatch::from(item.clone());
+            update(image).set(&patch).execute(&db_connection)?;
+            Ok(item)
+        },
+    }
+}

 use actix_web::{Error, HttpResponse, web};
 use anyhow::Result;
 use async_std::fs::DirBuilder;
-use futures::stream::StreamExt;
-use async_std::{fs::OpenOptions, io::WriteExt};
-use crate::uuid::Uuid;
+use futures::{stream::StreamExt, AsyncWriteExt};
+use async_std::fs::OpenOptions;
 
-use crate::{AppData, models::image::{Upload, self}, upload_filename, upload_uuid};
+use crate::{AppData, models::image::{Upload, self}, upload_filename};
 use crate::config::CONFIG;
 use std::convert::TryFrom;
 
@@ -43,11 +42,13 @@ pub async fn upload( app_data :web::Data<AppData>
     while let Some(item) = body.next().await {
         output.write_all(&item?).await?;
     }
+    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(image.clone()).await.unwrap();
+            worker.send((pool_for_worker, image.clone())).await.unwrap();
             HttpResponse::Ok().json(image)
         },
         Err(_) => HttpResponse::InternalServerError().finish()

 table! {
     images (id) {
         id -> Integer,
-        upload_uuid -> Nullable<Binary>,
-        uuid -> Nullable<Binary>,
+        upload_uuid -> Nullable<Tinyblob>,
+        uuid -> Nullable<Tinyblob>,
         size -> Integer,
         dim_x -> Nullable<Integer>,
         dim_y -> Nullable<Integer>,
-        mime_type -> Text,
+        mime_type -> Varchar,
         date_created -> Text,
         date_updated -> Text,
     }
 }
 
 table! {
-    markdown_diffs (markdown_id, diff_id) {
-        markdown_id -> Integer,
-        diff_id -> Integer,
-        diff -> Binary,
-        date_created -> Text,
-    }
-}
-
-table! {
     markdowns (id) {
         id -> Integer,
-        name -> Text,
+        name -> Varchar,
         content -> Text,
         number_of_versions -> Integer,
         date_created -> Text,
@@ -33,6 +24,15 @@ table! {
 }
 
 table! {
+    markdown_diffs (markdown_id, diff_id) {
+        markdown_id -> Integer,
+        diff_id -> Integer,
+        diff -> Blob,
+        date_created -> Text,
+    }
+}
+
+table! {
     users (id) {
         id -> Integer,
         name -> Text,
@@ -43,7 +43,7 @@ table! {
 
 allow_tables_to_appear_in_same_query!(
     images,
-    markdown_diffs,
     markdowns,
+    markdown_diffs,
     users,
 );

-use std::io::SeekFrom;
-use async_std::{fs::File, channel::{Sender, Receiver, bounded}};
+use std::{io::{SeekFrom, ErrorKind}, sync::Arc};
+use actix_web::web;
+use async_std::{ fs::{File, DirBuilder, copy, metadata, remove_file}
+               , channel::{Sender, Receiver, bounded}
+               , path::PathBuf
+               , io::Result };
 use futures::{ AsyncSeekExt, AsyncReadExt, FutureExt, StreamExt, select
              , stream::FuturesUnordered};
 
-use crate::{models::image::Image, upload_filename, upload_uuid};
+use crate::{models::image::{Image, finalize}, upload_filename, config::CONFIG, Pool};
 use crate::uuid::Uuid;
 
 use std::convert::TryFrom;
-use crate::config::CONFIG;
+use image::{io::Reader as ImageReader, GenericImageView};
 
-pub fn launch() -> Sender<Image> {
+pub fn launch() -> Sender<(Arc<Pool>, Image)> {
     let (tx_upload_worker, rx_upload_worker)
-        : (Sender<Image>, Receiver<Image>) = bounded(32);
+        : (Sender<(Arc<Pool>, Image)>, Receiver<(Arc<Pool>, Image)>) = bounded(32);
 
     actix_rt::spawn(async move {
         let mut workers = FuturesUnordered::new();
@@ -21,7 +25,7 @@ pub fn launch() -> Sender<Image> {
                 image = rx_upload_worker.recv().fuse() => {
                     match image {
                         Err(_) => break,
-                        Ok(image) => workers.push(worker(image)),
+                        Ok((pool, image)) => workers.push(worker(pool, image)),
                     }
                 },
                 _result = workers.next() => {},
@@ -37,16 +41,50 @@ pub fn launch() -> Sender<Image> {
 }
 
 
-async fn worker(image :Image) {
+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();
-    let mut buf = vec!['.' as u8; 3 * 4096];
+
+    let mut buf = vec!['.' as u8; 3 * 3 * 4096];
     get_sample(&mut f, buf.as_mut()).await.unwrap();
-    println!( "[upload worker] filename: {}"
-            , upload_filename );
-    println!( "[upload worker] uuid: {}"
-            , Uuid::get( "some.unique.namespace"
-                       , buf.as_mut() ) );
+    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();
+
+    image_path.push(&uuid_string);
+
+    image.upload_uuid = None;
+    image.uuid = Some(uuid.0.as_bytes().to_vec());
+
+    match metadata(&image_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);
+        },
+        Err(e) => {
+            let e :Result<()> = Err(e);
+            e.unwrap();
+        },
+        Ok(_) => {},
+    }
+
+    remove_file(&upload_filename).await.unwrap();
+    web::block(move || finalize(pool, image)).await.unwrap();
 }
 
 async fn read_at( f   :&mut File