Add Waiting to import button for unimported resolved magnet

Author: Gabatxo1312

src/database/magnet.rs

@@ -61,6 +61,17 @@ impl MagnetOperator {
             .context(DBSnafu)
     }
 
+    /// List unresolved magnet
+    ///
+    /// Should not fail, unless SQLite was corrupted for some reason.
+    pub async fn resolved_list_unimported(&self) -> Result<Vec<Model>, MagnetError> {
+        Entity::find()
+            .filter(Column::Resolved.eq(true))
+            .all(&self.state.database)
+            .await
+            .context(DBSnafu)
+    }
+
     pub async fn get(&self, id: i32) -> Result<Model, MagnetError> {
         let db = &self.state.database;
 

src/lib.rs

@@ -34,7 +34,6 @@ pub fn router(state: state::AppState) -> Router {
         .route("/magnet/upload", post(routes::magnet::upload))
         .route("/magnet/upload", get(routes::magnet::get_upload))
         .route("/magnet", get(routes::magnet::list))
-        .route("/magnet/{id}", get(routes::magnet::show))
         // Register static assets routes
         .nest("/assets", static_router())
         // Insert request timing

src/routes/category.rs

@@ -7,9 +7,8 @@ use axum_extra::extract::CookieJar;
 use serde::{Deserialize, Serialize};
 use snafu::prelude::*;
 
-use crate::database::category;
 use crate::database::category::CategoryError;
-use crate::database::content_folder;
+use crate::database::{category, content_folder, magnet};
 use crate::extractors::normalized_path::*;
 use crate::state::flash_message::{OperationStatus, get_cookie};
 use crate::state::{AppStateContext, error::*};
@@ -29,13 +28,21 @@ pub struct NewCategoryTemplate {
     pub error: Option<CategoryError>,
     /// Default form with value
     pub category_form: Option<CategoryForm>,
+    /// all unimported and resolved Magnets
+    pub resolved_list_unimported: Vec<magnet::Model>,
 }
 
-pub async fn new(
-    app_state_context: AppStateContext,
-) -> Result<impl axum::response::IntoResponse, AppStateError> {
+pub async fn new(context: AppStateContext) -> Result<NewCategoryTemplate, AppStateError> {
+    let resolved_list_unimported = context
+        .db
+        .magnet()
+        .resolved_list_unimported()
+        .await
+        .context(MagnetUploadSnafu)?;
+
     Ok(NewCategoryTemplate {
-        state: app_state_context,
+        state: context,
+        resolved_list_unimported,
         category_form: None,
         error: None,
     })
@@ -105,6 +112,8 @@ pub struct CategoryShowTemplate {
     category: category::Model,
     /// Operation status for UI confirmation (Cookie)
     pub flash: Option<OperationStatus>,
+    /// all unimported and resolved Magnets
+    pub resolved_list_unimported: Vec<magnet::Model>,
 }
 
 pub async fn show(
@@ -114,6 +123,13 @@ pub async fn show(
 ) -> Result<impl IntoResponse, AppStateError> {
     let categories = context.db.category();
 
+    let resolved_list_unimported = context
+        .db
+        .magnet()
+        .resolved_list_unimported()
+        .await
+        .context(MagnetUploadSnafu)?;
+
     let category = categories
         .find_by_name(category_name.to_string())
         .await
@@ -130,6 +146,7 @@ pub async fn show(
     Ok((
         jar,
         CategoryShowTemplate {
+            resolved_list_unimported,
             content_folders,
             category,
             state: context,

src/routes/content_folder.rs

@@ -8,7 +8,7 @@ use serde::{Deserialize, Serialize};
 use snafu::prelude::*;
 
 use crate::database::content_folder::PathBreadcrumb;
-use crate::database::{category, content_folder};
+use crate::database::{category, content_folder, magnet};
 use crate::extractors::folder_request::FolderRequest;
 use crate::state::flash_message::{OperationStatus, get_cookie};
 use crate::state::{AppStateContext, error::*};
@@ -38,13 +38,22 @@ pub struct ContentFolderShowTemplate {
     pub parent_folder: Option<content_folder::Model>,
     /// Operation status for UI confirmation (Cookie)
     pub flash: Option<OperationStatus>,
+    /// all unimported and resolved Magnets
+    pub resolved_list_unimported: Vec<magnet::Model>,
 }
 
 pub async fn show(
     context: AppStateContext,
     folder: FolderRequest,
     jar: CookieJar,
 ) -> Result<(CookieJar, ContentFolderShowTemplate), AppStateError> {
+    let resolved_list_unimported = context
+        .db
+        .magnet()
+        .resolved_list_unimported()
+        .await
+        .context(MagnetUploadSnafu)?;
+
     let (jar, operation_status) = get_cookie(jar);
 
     Ok((
@@ -56,6 +65,7 @@ pub async fn show(
             current_content_folder: folder.folder,
             category: folder.category,
             state: context,
+            resolved_list_unimported,
             flash: operation_status,
         },
     ))

src/routes/index.rs

@@ -4,7 +4,7 @@ use axum_extra::extract::CookieJar;
 use snafu::prelude::*;
 
 // TUTORIAL: https://github.com/SeaQL/sea-orm/blob/master/examples/axum_example/
-use crate::database::category;
+use crate::database::{category, magnet};
 use crate::routes::magnet::MagnetForm;
 use crate::state::flash_message::{OperationStatus, get_cookie};
 use crate::state::{AppStateContext, error::*};
@@ -18,6 +18,8 @@ pub struct IndexTemplate {
     pub categories: Vec<category::Model>,
     /// Operation status for UI confirmation
     pub flash: Option<OperationStatus>,
+    /// all unimported and resolved Magnets
+    pub resolved_list_unimported: Vec<magnet::Model>,
 }
 
 #[derive(Template, WebTemplate)]
@@ -32,6 +34,8 @@ pub struct UploadTemplate {
     pub post: Option<MagnetForm>,
     /// Error with submitted magnet
     pub post_error: Option<AppStateError>,
+    /// all unimported and resolved Magnets
+    pub resolved_list_unimported: Vec<magnet::Model>,
 }
 
 impl IndexTemplate {
@@ -41,12 +45,22 @@ impl IndexTemplate {
     ) -> Result<(CookieJar, Self), AppStateError> {
         let categories = context.db.category().list().await.context(CategorySnafu)?;
 
+        let resolved_list_unimported = context
+            .db
+            .magnet()
+            .resolved_list_unimported()
+            .await
+            // TODO: this should probably not be a MagnetUploadSnafu because
+            // that's not the context in which we're performing the operation
+            .context(MagnetUploadSnafu)?;
+
         let (jar, operation_status) = get_cookie(jar);
 
         Ok((
             jar,
             IndexTemplate {
                 state: context,
+                resolved_list_unimported,
                 categories,
                 flash: operation_status,
             },
@@ -66,11 +80,19 @@ impl UploadTemplate {
             .map(|x| x.name.to_string())
             .collect();
 
+        let resolved_list_unimported = context
+            .db
+            .magnet()
+            .resolved_list_unimported()
+            .await
+            .context(MagnetUploadSnafu)?;
+
         Ok(UploadTemplate {
             state: context,
             categories,
             post: None,
             post_error: None,
+            resolved_list_unimported,
         })
     }
 }

src/routes/logs.rs

@@ -2,6 +2,7 @@ use askama::Template;
 use askama_web::WebTemplate;
 use snafu::prelude::*;
 
+use crate::database::magnet;
 use crate::database::operation::OperationLog;
 use crate::database::operation::OperationType;
 use crate::state::{AppStateContext, error::*};
@@ -11,13 +12,22 @@ use crate::state::{AppStateContext, error::*};
 pub struct LogTemplate {
     pub state: AppStateContext,
     pub logs: Vec<OperationLog>,
+    /// all unimported and resolved Magnets
+    pub resolved_list_unimported: Vec<magnet::Model>,
 }
 
 pub async fn index(context: AppStateContext) -> Result<LogTemplate, AppStateError> {
     let logs = context.state.logger.read().await.context(LoggerSnafu)?;
+    let resolved_list_unimported = context
+        .db
+        .magnet()
+        .resolved_list_unimported()
+        .await
+        .context(MagnetUploadSnafu)?;
 
     Ok(LogTemplate {
         state: context,
+        resolved_list_unimported,
         logs,
     })
 }

src/routes/magnet.rs

@@ -1,12 +1,11 @@
 use askama::Template;
 use askama_web::WebTemplate;
-use axum::extract::{Form, Path};
-use axum::response::{IntoResponse, Response};
+use axum::extract::Form;
+use axum::response::{IntoResponse, Redirect, Response};
 use serde::{Deserialize, Serialize};
 use snafu::prelude::*;
 
-use crate::database::category;
-use crate::database::magnet;
+use crate::database::{category, magnet};
 use crate::state::{AppStateContext, error::*};
 
 /// Multipart form submitted to /magnet/upload:
@@ -17,55 +16,25 @@ pub struct MagnetForm {
     pub magnet: String,
 }
 
-#[derive(Template, WebTemplate)]
-#[template(path = "magnet/show.html")]
-pub struct MagnetTemplate {
-    /// Global application state (errors/warnings)
-    pub state: AppStateContext,
-    /// Parsed magnet from form
-    pub magnet: magnet::Model,
-}
-
-pub async fn show(
-    context: AppStateContext,
-    Path(id): Path<i32>,
-) -> Result<impl IntoResponse, AppStateError> {
-    let magnet = context
-        .db
-        .magnet()
-        .get(id)
-        .await
-        .boxed()
-        .context(OtherSnafu)?;
-
-    Ok(MagnetTemplate {
-        state: context,
-        magnet,
-    })
-}
-
 pub async fn upload(
     context: AppStateContext,
     Form(form): Form<MagnetForm>,
 ) -> Result<Response, AppStateError> {
-    // Parse magnet
-    match context
+    // TODO: proper error type
+    if let Err(e) = context
         .db
         .magnet()
         .create(&form)
         .await
         .context(MagnetUploadSnafu)
     {
-        Ok(magnet_model) => Ok(MagnetTemplate {
-            state: context,
-            magnet: magnet_model,
-        }
-        .into_response()),
-        Err(e) => Ok(UploadMagnetTemplate::new(context)
+        return Ok(UploadMagnetTemplate::new(context)
             .await?
             .with_errored_form(form, e)
-            .into_response()),
+            .into_response());
     }
+
+    Ok(Redirect::to("/magnet").into_response())
 }
 
 #[derive(Template, WebTemplate)]
@@ -75,6 +44,8 @@ pub struct MagnetListTemplate {
     pub state: AppStateContext,
     /// Magnets stored in database
     pub magnets: Vec<magnet::Model>,
+    /// all unimported and resolved Magnets
+    pub resolved_list_unimported: Vec<magnet::Model>,
 }
 
 pub async fn list(context: AppStateContext) -> Result<impl IntoResponse, AppStateError> {
@@ -86,8 +57,16 @@ pub async fn list(context: AppStateContext) -> Result<impl IntoResponse, AppStat
         .boxed()
         .context(OtherSnafu)?;
 
+    let resolved_list_unimported = context
+        .db
+        .magnet()
+        .resolved_list_unimported()
+        .await
+        .context(MagnetUploadSnafu)?;
+
     Ok(MagnetListTemplate {
         state: context,
+        resolved_list_unimported,
         magnets,
     })
 }
@@ -102,6 +81,8 @@ pub struct UploadMagnetTemplate {
     /// Error with submitted magnet
     pub post_error: Option<AppStateError>,
     pub categories: Vec<category::Model>,
+    /// all unimported and resolved Magnets
+    pub resolved_list_unimported: Vec<magnet::Model>,
 }
 
 pub async fn get_upload(context: AppStateContext) -> Result<UploadMagnetTemplate, AppStateError> {
@@ -111,9 +92,16 @@ pub async fn get_upload(context: AppStateContext) -> Result<UploadMagnetTemplate
 impl UploadMagnetTemplate {
     pub async fn new(context: AppStateContext) -> Result<Self, AppStateError> {
         let categories = context.db.category().list().await.context(CategorySnafu)?;
+        let resolved_list_unimported = context
+            .db
+            .magnet()
+            .resolved_list_unimported()
+            .await
+            .context(MagnetUploadSnafu)?;
 
         Ok(UploadMagnetTemplate {
             state: context,
+            resolved_list_unimported,
             categories,
             post: None,
             post_error: None,