Some fixes in upload handling

@@ -51,7 +51,7 @@ pub fn launch() -> Sender<(Arc<Pool>, Image)> {
     tx_upload_worker
 }
 
-async fn store_original(context :&mut ImageContext) -> Result<(), Error> {
+async fn store_original(context :&mut ImageContext) -> Result<u64, Error> {
     let upload_path = context
                     . upload_path().await
                     . ok_or(Error::new( "Can't retreive upload path"
@@ -62,16 +62,21 @@ async fn store_original(context :&mut ImageContext) -> Result<(), Error> {
                       . ok_or(Error::new( "No path for given size"
                                         , StatusCode::INTERNAL_SERVER_ERROR ))?;
 
-    match metadata(&original_path).await {
+    let result = match metadata(&original_path).await {
         Err(e) if e.kind() == ErrorKind::NotFound => {
-            copy(&upload_path, &original_path).await?;
-            remove_file(&upload_path).await?;
-            Ok(())
+            match copy(&upload_path, &original_path).await {
+                Ok(size) => Ok(size),
+                Err(e) => Err(Error::from(e)),
+            }
         },
-        Err(e) => Err(e)?,
+        Err(e) => Err(Error::from(e)),
         Ok(_) => Err(Error::new( "File already exists"
                                , StatusCode::CONFLICT )),
-    }
+    };
+
+    remove_file(&upload_path).await?;
+
+    result
 }
 
 async fn load_original(context :&mut ImageContext) -> Result<DynamicImage, Error> {
@@ -139,7 +144,7 @@ async fn worker(pool :Arc<Pool>, image :Image) -> Result<(), Error> {
                       . create(base_path)
                       . await?;
 
-    store_original(&mut context).await.unwrap_or(());
+    store_original(&mut context).await.unwrap_or(0);
 
     if let Ok(original) = load_original(&mut context).await {
         let (dim_x, dim_y) = original.dimensions();

@@ -104,28 +104,23 @@ pub(super) async fn upload_logic( mut rx_logic :broadcast::Receiver<UploadLogic>
                 }
             },
             UploadLogic::Upload => {
-                let mut remove_ids = vec![];
+                let mut uploads_vec = vec![];
+                let mut index = 0;
 
                 for upload in uploads.read().await.iter() {
-                    match api.store(upload).await {
-                        Ok(_) => remove_ids.push(upload.id),
-                        Err(e) => log::error!("{:?}", e),
-                    }
+                    uploads_vec.push(upload.clone());
                 }
 
-                for id in remove_ids.iter() {
-                    let mut found = None;
-
-                    for (upload, index) in uploads.read().await.iter().zip(0..) {
-                        if upload.id == *id {
-                            found = Some(index);
-                            break;
+                for upload in uploads_vec.iter() {
+                    match api.store(upload).await {
+                        Ok(_) => {
+                            uploads.list_patch_remove(index).unwrap();
+                        },
+                        Err(e) => {
+                            log::error!("{:?}", e);
+                            index += 1;
                         }
                     }
-
-                    if let Some(index) = found {
-                        uploads.list_patch_remove(index).unwrap();
-                    }
                 }
             }
         }

-mod logic;
+pub(crate) mod logic;
 pub(crate) mod upload;
 mod view;