Merge branch 'create-basic-upload-endpoint-in-server-4' into 'master'

Fixes #4 Basic upload endpoint done

Closes #4

See merge request !3

@@ -25,17 +25,21 @@ edition = "2018"
 
 
 [dependencies]
 [dependencies]
 actix-files = "0.2"
 actix-files = "0.2"
-actix-web = "2.0"
 actix-rt = "1.1.1"
 actix-rt = "1.1.1"
+actix-web = "2.0"
+anyhow = "1.0"
 artshop-common = { path = "../common" }
 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 = ["sqlite", "r2d2"]}
-r2d2 = "0.8.9"
+diffy = "0.2"
 dotenv = "0.15.0"
 dotenv = "0.15.0"
+flate2 = "^1.0"
+futures = "^0.3"
+listenfd = "0.3"
+r2d2 = "0.8.9"
 serde = "1.0"
 serde = "1.0"
 serde_derive = "1.0"
 serde_derive = "1.0"
 serde_json = "1.0"
 serde_json = "1.0"
-anyhow = "1.0"
-chrono = "0.4.15"
-listenfd = "0.3"
-diffy = "0.2"
-flate2 = "^1.0"
+#tokio = { version = "1", features = ["full"] }
+uuid = { version = "^0.8", features = ["v4"] }

@@ -15,6 +15,7 @@ use diesel::r2d2::{self, ConnectionManager};
 use diesel::SqliteConnection;
 use diesel::SqliteConnection;
 use listenfd::ListenFd;
 use listenfd::ListenFd;
 use routes::markdown::get_markdown;
 use routes::markdown::get_markdown;
+use routes::upload::upload;
 
 
 pub(crate) type Pool = r2d2::Pool<ConnectionManager<SqliteConnection>>;
 pub(crate) type Pool = r2d2::Pool<ConnectionManager<SqliteConnection>>;
 
 
@@ -33,6 +34,9 @@ async fn main() -> std::io::Result<()> {
         App::new() . data(database_pool.clone())
         App::new() . data(database_pool.clone())
                    . service(actix_files::Files::new("/static", "./static"))
                    . service(actix_files::Files::new("/static", "./static"))
                    . service( web::scope("/api/v0")
                    . service( web::scope("/api/v0")
+                            . service( web::resource("/upload")
+                                     . route(web::post().to(upload))
+                                     )
                             . service( web::resource("/markdowns")
                             . service( web::resource("/markdowns")
                                      . route(web::get().to(get_markdowns))
                                      . route(web::get().to(get_markdowns))
                                      )
                                      )

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

+use actix_web::{Error, HttpResponse, web};
+use anyhow::Result;
+use futures::stream::StreamExt;
+use async_std::{fs::OpenOptions, io::WriteExt};
+use uuid::Uuid;
+
+pub async fn upload(mut body: web::Payload) -> Result<HttpResponse, Error>
+{
+    let mut output = OpenOptions::new();
+    output . create(true)
+           . write(true);
+    let mut output = output
+                   . open(format!("/tmp/upload_{}", Uuid::new_v4()))
+                   . await
+                   . unwrap();
+
+    while let Some(item) = body.next().await {
+        output.write_all(&item?).await.unwrap();
+    }
+
+    Ok(HttpResponse::Ok().finish())
+}

@@ -43,6 +43,7 @@ features = [
 	"File",
 	"File",
 	"FileList",
 	"FileList",
 	"FileReader",
 	"FileReader",
+	"FormData",
 	"ImageBitmap",
 	"ImageBitmap",
 	"Headers",
 	"Headers",
 	"HtmlCanvasElement",
 	"HtmlCanvasElement",

@@ -18,6 +18,7 @@ impl UploadApi {
     pub(crate) async fn store(&self, upload :&Upload) -> Result<&UploadApi> {
     pub(crate) async fn store(&self, upload :&Upload) -> Result<&UploadApi> {
         let response = self.client.post_stream( "/api/v0/upload"
         let response = self.client.post_stream( "/api/v0/upload"
                                               , &upload.mime_type()
                                               , &upload.mime_type()
+                                              , upload.size()
                                               , upload.data() ).await?;
                                               , upload.data() ).await?;
         match response.status() {
         match response.status() {
             200 => Ok(self),
             200 => Ok(self),

 use js_sys::JsString;
 use js_sys::JsString;
 use mogwai::prelude::*;
 use mogwai::prelude::*;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen::prelude::*;
-use web_sys::{Window, window, Response, Request, RequestInit, RequestMode, ReadableStream};
+use web_sys::{Window, window, Response, Request, RequestInit, RequestMode, Headers};
 use super::error::*;
 use super::error::*;
 
 
 use std::result::Result as StdResult;
 use std::result::Result as StdResult;
@@ -63,17 +63,20 @@ impl Client {
     }
     }
 
 
     pub async fn post_stream( &self
     pub async fn post_stream( &self
-                            , url :&str
+                            , url       :&str
                             , mime_type :&str
                             , mime_type :&str
-                            , data :ReadableStream) -> Result<Response> {
+                            , length    :usize
+                            , data      :&JsValue ) -> Result<Response> {
+        let headers = Headers::new()?;
+        headers.set("Content-Type", mime_type)?;
+        headers.set("Content-Length", &format!("{}", length))?;
+
         let mut init = RequestInit::new();
         let mut init = RequestInit::new();
         let request = REQUEST( url
         let request = REQUEST( url
                              , init . method("POST")
                              , init . method("POST")
                                     . mode(RequestMode::Cors)
                                     . mode(RequestMode::Cors)
-                                    . body(Some(&data.into())) )?;
-
-        request . headers()
-                . set("Content-Type", mime_type)?;
+                                    . headers(&headers.into())
+                                    . body(Some(data)) )?;
 
 
         let response = JsFuture::from( self.window
         let response = JsFuture::from( self.window
                                      . fetch_with_request(&request))
                                      . fetch_with_request(&request))

@@ -85,12 +85,29 @@ pub(super) async fn upload_logic( mut rx_logic :broadcast::Receiver<UploadLogic>
                 }
                 }
             },
             },
             UploadLogic::Upload => {
             UploadLogic::Upload => {
+                let mut remove_ids = vec![];
+
                 for upload in uploads.read().await.iter() {
                 for upload in uploads.read().await.iter() {
                     match api.store(upload).await {
                     match api.store(upload).await {
-                        Ok(_) => (),
+                        Ok(_) => remove_ids.push(upload.id),
                         Err(e) => log::error!("{:?}", e),
                         Err(e) => log::error!("{:?}", e),
                     }
                     }
                 }
                 }
+
+                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;
+                        }
+                    }
+
+                    if let Some(index) = found {
+                        uploads.list_patch_remove(index).unwrap();
+                    }
+                }
             }
             }
         }
         }
     }
     }

 use mogwai::{prelude::*, utils::window};
 use mogwai::{prelude::*, utils::window};
-use web_sys::{File, ImageBitmap, ReadableStream};
+use web_sys::{File, ImageBitmap};
+use wasm_bindgen::prelude::*;
 
 
 use super::{view::upload_preview_view, logic::{upload_preview_logic, UploadLogic}};
 use super::{view::upload_preview_view, logic::{upload_preview_logic, UploadLogic}};
 
 
@@ -30,8 +31,12 @@ impl Upload {
         self.file.type_()
         self.file.type_()
     }
     }
 
 
-    pub(crate) fn data(&self) -> ReadableStream {
-        self.file.stream()
+    pub(crate) fn data(&self) -> &JsValue {
+        &self.file
+    }
+
+    pub(crate) fn size(&self) -> usize {
+        self.file.size() as usize
     }
     }
 
 
     pub(super) fn bitmap(&self) -> ImageBitmap {
     pub(super) fn bitmap(&self) -> ImageBitmap {