feature: endpoint save video, with url param is estableç

0nSystem · 0nSystem · commit 2a761d7552f9 · 2024-08-15T21:30:02.000+02:00
diff --git a/document_manager/Cargo.toml b/document_manager/Cargo.toml
@@ -31,3 +31,7 @@ utoipa = { version = "4.2.3", features = ["actix_extras", "non_strict_integers",
 utoipa-swagger-ui = { version = "7.1.0", features = ["actix-web"] }
 actix-web-lab = "0.20.2"
 
+reqwest = { version = "0.11", features = ["blocking", "json"] }
+bytes = "1.7.1"
+mime_guess = "2.0.5"
+
diff --git a/document_manager/src/config.rs b/document_manager/src/config.rs
@@ -31,7 +31,7 @@ pub fn config_logger(target: Target) -> Result<()> {
         .format_module_path(false)
         .format_timestamp_millis()
         .write_style(env_logger::WriteStyle::Always)
-        .filter(None, LevelFilter::Debug)
+        .filter(None, LevelFilter::Info)
         .try_init()
         .with_context(|| "Wasn't unable to set up the logger")
 }
diff --git a/document_manager/src/endpoints/save.rs b/document_manager/src/endpoints/save.rs
@@ -1,13 +1,15 @@
 use actix_multipart::form::{tempfile::TempFile, text::Text};
 use actix_multipart::form::MultipartForm;
 use actix_web::{HttpResponse, post, Responder, web};
+use actix_web::web::Json;
 use log::info;
+use serde::Deserialize;
 use utoipa::{IntoParams, ToSchema};
 
 
 use crate::config::DbPool;
 use crate::EnvironmentState;
-use crate::operations::save_document;
+use crate::operations::{save_document, save_document_by_url};
 
 #[derive(Debug, MultipartForm, ToSchema, IntoParams)]
 pub struct SaveDocumentRequest {
@@ -50,4 +52,35 @@ pub async fn upload_document(
             HttpResponse::InternalServerError().finish()
         }
     }
+}
+
+
+#[derive(Debug, Deserialize, ToSchema, IntoParams)]
+pub struct SaveDocumentByUrlRequest {
+    pub url_file: String,
+    pub application: String,
+    pub is_private_document: bool,
+    pub username: String,
+}
+
+#[utoipa::path(
+    post,
+    path = "/upload_document_by_url",
+    request_body(content = SaveDocumentByUrlRequest),
+    responses(
+        (status = 200, description = "Successful", body = Uuid)
+    ),
+)]
+#[post("/upload_document_by_url")]
+pub async fn upload_document_by_url(body: Json<SaveDocumentByUrlRequest>,
+                                    env_state: web::Data<EnvironmentState>,
+                                    conn: web::Data<DbPool>,
+) -> impl Responder {
+    match save_document_by_url(body.into_inner(), env_state, &conn).await {
+        Ok(uuid) => HttpResponse::Ok().json(uuid),
+        Err(error) => {
+            info!("{error}");
+            HttpResponse::InternalServerError().finish()
+        }
+    }
 }
diff --git a/document_manager/src/main.rs b/document_manager/src/main.rs
@@ -10,7 +10,8 @@ use utoipa_swagger_ui::SwaggerUi;
 
 use crate::config::{config_logger, configure_storage_directory, EnvConfig, establish_connection};
 use crate::endpoints::{delete::delete_document, filter::find_documents, save::upload_document};
-use crate::endpoints::{delete::DeleteDocumentRequest, filter::{DocumentContentResponse, DocumentFilterRequest, FoundContentResponse, FoundDocumentResponse}, save::SaveDocumentRequest};
+use crate::endpoints::{delete::DeleteDocumentRequest, filter::{DocumentContentResponse, DocumentFilterRequest, FoundContentResponse, FoundDocumentResponse}, save::{SaveDocumentByUrlRequest, SaveDocumentRequest}};
+use crate::endpoints::save::upload_document_by_url;
 
 mod config;
 mod models;
@@ -39,14 +40,16 @@ impl TryFrom<EnvConfig> for EnvironmentState {
 #[openapi(
     paths(
         endpoints::save::upload_document,
+        endpoints::save::upload_document_by_url,
         endpoints::delete::delete_document,
         endpoints::filter::find_documents
     ),
     components(schemas(
         SaveDocumentRequest,
+        SaveDocumentByUrlRequest,
         DeleteDocumentRequest,
         DocumentFilterRequest,
-        FoundDocumentResponse, FoundContentResponse, DocumentContentResponse
+        FoundDocumentResponse, FoundContentResponse, DocumentContentResponse,
     ))
 )]
 struct ApiDoc;
@@ -76,6 +79,7 @@ async fn main() -> Result<()> {
                     .url("/api-docs/openapi.json", ApiDoc::openapi()),
             )
             .service(upload_document)
+            .service(upload_document_by_url)
             .service(delete_document)
             .service(find_documents)
     })
diff --git a/document_manager/src/operations/fs.rs b/document_manager/src/operations/fs.rs
@@ -9,6 +9,8 @@ use base64::engine::{GeneralPurpose, GeneralPurposeConfig};
 use color_eyre::{Report, Result};
 use color_eyre::eyre::ContextCompat;
 use log::debug;
+use tokio::fs::{File, remove_file};
+use tokio::io::AsyncWriteExt;
 use uuid::Uuid;
 
 pub struct PathFile(PathBuf, String);
@@ -80,6 +82,21 @@ pub async fn read_content_file_to_base64(path: &Path) -> Result<String> {
     let engine = GeneralPurpose::new(&STANDARD, GeneralPurposeConfig::default());
     Ok(engine.encode(buffer_read_content_file))
 }
+pub async fn read_content_bytes_to_base64(b: &[u8]) -> Result<String> {
+    let engine = GeneralPurpose::new(&STANDARD, GeneralPurposeConfig::default());
+    Ok(engine.encode(b))
+}
+
+fn create_parent_directories(to: &Path) -> Result<()> {
+    if let Some(path_directory) = to.parent() {
+        debug!(
+            "Creating directories required to path: {:?}",
+            path_directory
+        );
+        create_dir_all(path_directory)?;
+    }
+    Ok(())
+}
 
 pub fn move_file(from: &Path, to: PathBuf) -> Result<()> {
     debug!("Moving file from: {:?}, to: {:?}", from, to);
@@ -88,22 +105,44 @@ pub fn move_file(from: &Path, to: PathBuf) -> Result<()> {
         return Err(Report::msg("From path is a directory"));
     }
 
-    if let Some(path_directory) = to.parent() {
-        debug!(
-            "Creating directories required to path: {:?}",
-            path_directory
-        );
-        create_dir_all(path_directory)?
-    }
+    create_parent_directories(&to)?;
     //Error using fs::rename, because error by temp files
     copy(from, to)?;
     Ok(())
 }
 
+
+pub async fn save_file(to: PathBuf, content: &[u8]) -> Result<()> {
+    if to.is_dir() {
+        return Err(Report::msg("Path is a directory"));
+    }
+    create_parent_directories(&to)?;
+
+    debug!("Saving file in: {:?}", to);
+    let mut f = File::create(to).await?;
+    let _ = f.write(content).await?;
+
+    Ok(())
+}
+
+pub async fn delete_file(p: &Path) -> Result<()> {
+    remove_file(p).await?;
+    Ok(())
+}
+
 pub fn get_extension_and_file_name(file_name: &str) -> (&str, Option<&str>) {
     if let Some(index) = file_name.rfind('.') {
         (&file_name[..index], Some(&file_name[index..]))
     } else {
         (file_name, None)
     }
 }
+
+
+pub fn get_file_name_in_url(url: &str) -> Option<&str> {
+    if let Some(index) = url.rfind('/') {
+        Some(&url[index + 1..])
+    } else {
+        None
+    }
+}
diff --git a/document_manager/src/operations/mod.rs b/document_manager/src/operations/mod.rs
@@ -1,26 +1,29 @@
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use actix_multipart::form::MultipartForm;
 use actix_web::web;
+use bytes::Bytes;
 use chrono::Local;
 use color_eyre::{Report, Result};
-use color_eyre::eyre::Context;
+use color_eyre::eyre::{Context, OptionExt};
 use diesel::{ExpressionMethods, insert_into, update};
 use diesel::prelude::*;
 use diesel_async::{AsyncConnection, RunQueryDsl};
 use diesel_async::scoped_futures::ScopedFutureExt;
 use itertools::Itertools;
-use log::debug;
+use log::{debug, error, info};
+use mime_guess::from_ext;
+use reqwest::Client;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
 use crate::config::DbPool;
 use crate::endpoints::delete::DeleteDocumentRequest;
 use crate::endpoints::filter::DocumentFilterRequest;
-use crate::endpoints::save::SaveDocumentRequest;
+use crate::endpoints::save::{SaveDocumentByUrlRequest, SaveDocumentRequest};
 use crate::EnvironmentState;
 use crate::models::{Content, DeleteContent, DeleteDocument, Document, NewContent, NewDocument};
-use crate::operations::fs::{generate_path_by_uuid, generate_url_by_uuid, get_extension_and_file_name, move_file, read_content_file_to_base64};
+use crate::operations::fs::{delete_file, generate_path_by_uuid, generate_url_by_uuid, get_extension_and_file_name, get_file_name_in_url, move_file, read_content_bytes_to_base64, read_content_file_to_base64, save_file};
 use crate::schema::{content, document};
 
 mod fs;
@@ -86,6 +89,101 @@ pub async fn save_document(
         .await
 }
 
+pub async fn save_document_by_url(params: SaveDocumentByUrlRequest,
+                                  env_state: web::Data<EnvironmentState>,
+                                  conn: &DbPool) -> Result<Uuid> {
+    let conn = &mut conn.get().await?;
+    let uuid_document = Uuid::new_v4();
+    debug!("Generate UUID: {uuid_document}, to save document");
+
+
+    let r = conn.transaction::<Uuid, Report, _>(|conn| {
+        async move {
+            let url_file = params.url_file.clone();
+            let file_name_in_url = get_file_name_in_url(&url_file)
+                .ok_or_eyre(format!("Error not match filename in url: {:?} ", url_file))?;
+            let (filename, extension) = get_extension_and_file_name(file_name_in_url);
+
+            let mime_type = extension
+                .map(|x| from_ext(x).first_or_octet_stream().to_string());
+            let info_download = download_file(&params.url_file).await?;
+            let new_document = NewDocument {
+                id_document: &uuid_document,
+                name: filename,
+                extension: extension.map(|x| x.to_string()),
+                content_type: mime_type,
+                application: &params.application,
+                create_username: &params.username,
+            };
+            insert_into(document::table)
+                .values(new_document)
+                .execute(conn)
+                .await
+                .with_context(|| "Error create document")?;
+
+            if params.is_private_document {
+                debug!("Document is private saving in database");
+                let content_file = read_content_bytes_to_base64(&info_download.content).await?;
+                let content = NewContent {
+                    id_document: &uuid_document,
+                    data: &content_file,
+                    create_username: &params.username,
+                };
+                insert_into(content::table)
+                    .values(content)
+                    .execute(conn)
+                    .await
+                    .with_context(|| "Error save row in table content")?;
+            } else {
+                let new_path = PathBuf::from(generate_path_by_uuid(
+                    env_state.disk_storage_directory_path.clone(),
+                    extension.unwrap_or(""),
+                    uuid_document,
+                )?);
+                debug!("Document is public saving in {:?}", new_path);
+                save_file(new_path, &info_download.content).await?;
+            }
+            debug!("Finish procces save document");
+            Ok(uuid_document)
+        }
+            .scope_boxed()
+    })
+        .await;
+
+
+    match r {
+        Ok(e) => Ok(e),
+        Err(e) => {
+            //delete_file(&clone_new_path).await?;
+
+            Err(e)
+        }
+    }
+}
+
+
+struct DownloadFileInfo {
+    pub content: Bytes,
+}
+async fn download_file(url: &str) -> Result<DownloadFileInfo> {
+    let client = Client::new();
+    let response = client.get(url).send().await?;
+
+    if response.status().is_success() {
+        let content = response.bytes().await?;
+        info!("File downloaded");
+        Ok(
+            DownloadFileInfo {
+                content,
+            }
+        )
+    } else {
+        error!("Error download file: {}", response.status());
+        Err(Report::msg("Error download file"))
+    }
+}
+
+
 pub async fn delete_document_and_content(
     document_delete: web::Query<DeleteDocumentRequest>,
     conn: web::Data<DbPool>,

Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ pub fn config_logger(target: Target) -> Result<()> {`
`31`	`31`	`.format_module_path(false)`
`32`	`32`	`.format_timestamp_millis()`
`33`	`33`	`.write_style(env_logger::WriteStyle::Always)`
`34`		`- .filter(None, LevelFilter::Debug)`
	`34`	`+ .filter(None, LevelFilter::Info)`
`35`	`35`	`.try_init()`
`36`	`36`	`.with_context(\|\| "Wasn't unable to set up the logger")`
`37`	`37`	`}`