feat: Magnet upload form on the content folder page

Author: amateurforger

src/database/category.rs

@@ -47,6 +47,8 @@ pub enum CategoryError {
     DB { source: sea_orm::DbErr },
     #[snafu(display("The category (ID: {id}) does not exist"))]
     IDNotFound { id: i32 },
+    #[snafu(display("The category id is invalid: {id}"))]
+    IDInvalid { id: String },
     #[snafu(display("The category (Name: {name}) does not exist"))]
     NameNotFound { name: String },
     #[snafu(display("Failed to save the operation log"))]
@@ -76,7 +78,7 @@ impl CategoryOperator {
 
     /// Find one category by ID
     ///
-    /// Should not fail, unless SQLite was corrupted for some reason.
+    /// Fails if the requested category ID does not exist.
     pub async fn find_by_id(&self, id: i32) -> Result<Model, CategoryError> {
         let category = Entity::find_by_id(id)
             .one(&self.state.database)
@@ -89,6 +91,19 @@ impl CategoryOperator {
         }
     }
 
+    /// Find one category by stringy ID
+    ///
+    /// Fails if:
+    ///
+    /// - the requested ID does not exist
+    /// - the requested ID could not be parsed
+    pub async fn find_by_id_str(&self, id: &str) -> Result<Model, CategoryError> {
+        let id: i32 = id
+            .parse()
+            .map_err(|_e| CategoryError::IDInvalid { id: id.to_string() })?;
+        self.find_by_id(id).await
+    }
+
     /// Find one category by Name
     ///
     /// Should not fail, unless SQLite was corrupted for some reason.

src/database/content_folder.rs

@@ -30,6 +30,8 @@ pub struct Model {
     pub parent_id: Option<i32>,
     #[sea_orm(self_ref, relation_enum = "Parent", from = "parent_id", to = "id")]
     pub parent: HasOne<Entity>,
+    #[sea_orm(has_many)]
+    pub magnets: HasMany<super::magnet::Entity>,
 }
 
 #[async_trait::async_trait]
@@ -44,6 +46,8 @@ pub enum ContentFolderError {
     PathTaken { path: String },
     #[snafu(display("The Content Folder (Path: {path}) does not exist"))]
     NotFound { path: String },
+    #[snafu(display("The content folder id is invalid: {id}"))]
+    IDInvalid { id: String },
     #[snafu(display("Database error"))]
     DB { source: sea_orm::DbErr },
     #[snafu(display("Failed to save the operation log"))]
@@ -109,6 +113,19 @@ impl ContentFolderOperator {
         }
     }
 
+    /// Find one category by stringy ID
+    ///
+    /// Fails if:
+    ///
+    /// - the requested ID does not exist
+    /// - the requested ID could not be parsed
+    pub async fn find_by_id_str(&self, id: &str) -> Result<Model, ContentFolderError> {
+        let id: i32 = id
+            .parse()
+            .map_err(|_e| ContentFolderError::IDInvalid { id: id.to_string() })?;
+        self.find_by_id(id).await
+    }
+
     /// Create a new content folder
     ///
     /// Fails if:

src/database/magnet.rs

@@ -4,6 +4,7 @@ use sea_orm::entity::prelude::*;
 use sea_orm::*;
 use snafu::prelude::*;
 
+use crate::database::content_folder;
 use crate::database::operation::*;
 use crate::extractors::user::User;
 use crate::routes::magnet::MagnetForm;
@@ -24,6 +25,9 @@ pub struct Model {
     pub link: MagnetLink,
     pub name: String,
     pub resolved: bool,
+    pub content_folder_id: i32,
+    #[sea_orm(belongs_to, from = "content_folder_id", to = "id")]
+    pub content_folder: HasOne<content_folder::Entity>,
 }
 
 #[async_trait::async_trait]
@@ -36,6 +40,10 @@ pub enum MagnetError {
     InvalidMagnet { source: MagnetLinkError },
     #[snafu(display("Database error"))]
     DB { source: sea_orm::DbErr },
+    #[snafu(display("Error with the requested content folder"))]
+    ContentFolder {
+        source: content_folder::ContentFolderError,
+    },
     #[snafu(display("The magnet (ID: {id}) does not exist"))]
     NotFound { id: i32 },
     #[snafu(display("The magnet (TorrentID: {id}) does not exist"))]
@@ -132,8 +140,22 @@ impl MagnetOperator {
     /// Fails if:
     ///
     /// - the magnet is invalid
+    /// - the requested content folder does not exist
     pub async fn create(&self, f: &MagnetForm) -> Result<Model, MagnetError> {
-        let magnet = MagnetLink::new(&f.magnet).context(InvalidMagnetSnafu)?;
+        let MagnetForm {
+            magnet,
+            content_folder_id,
+        } = f;
+
+        let magnet = MagnetLink::new(magnet).context(InvalidMagnetSnafu)?;
+
+        let content_folder = {
+            let operator = content_folder::ContentFolderOperator::new(self.state.clone(), None);
+            operator
+                .find_by_id_str(content_folder_id)
+                .await
+                .context(ContentFolderSnafu)?
+        };
 
         // Check duplicates
         let list = self.list().await?;
@@ -149,6 +171,7 @@ impl MagnetOperator {
             name: Set(magnet.name().to_string()),
             // TODO: check if we already have the torrent in which case it's already resolved!
             resolved: Set(false),
+            content_folder_id: Set(content_folder.id),
             ..Default::default()
         }
         .save(&self.state.database)

src/lib.rs

@@ -29,10 +29,12 @@ pub fn router(state: state::AppState) -> Router {
             "/folders/{category_name}/{*folder_path}",
             get(routes::content_folder::show),
         )
+        .route(
+            "/folders/{category_name}/{*folder_path}",
+            post(routes::content_folder::post_magnet),
+        )
         .route("/folders", post(routes::content_folder::create))
         .route("/logs", get(routes::logs::index))
-        .route("/magnet/upload", post(routes::magnet::upload))
-        .route("/magnet/upload", get(routes::magnet::get_upload))
         .route("/magnet", get(routes::magnet::list))
         // Register static assets routes
         .nest("/assets", static_router())

src/migration/m20251114_01_create_table_magnet.rs

@@ -18,11 +18,11 @@ impl MigrationTrait for Migration {
                     .col(string(Magnet::Name))
                     .col(string(Magnet::Link))
                     .col(boolean(Magnet::Resolved))
-                    .col(ColumnDef::new(ContentFolder::Id).integer())
+                    .col(ColumnDef::new(Magnet::ContentFolderId).integer())
                     .foreign_key(
                         ForeignKey::create()
-                            .name("fk-magnet-content-folder_id")
-                            .from(Magnet::ContentFolder, Magnet::ContentFolder)
+                            .name("fk-magnet-content_folder_id")
+                            .from(Magnet::Table, Magnet::ContentFolderId)
                             .to(ContentFolder::Table, ContentFolder::Id),
                     )
                     .to_owned(),
@@ -45,5 +45,5 @@ enum Magnet {
     Name,
     Link,
     Resolved,
-    ContentFolder,
+    ContentFolderId,
 }

src/routes/content_folder.rs

@@ -10,6 +10,7 @@ use snafu::prelude::*;
 use crate::database::content_folder::PathBreadcrumb;
 use crate::database::{category, content_folder};
 use crate::extractors::folder_request::FolderRequest;
+use crate::routes::magnet::MagnetForm;
 use crate::state::flash_message::{OperationStatus, get_cookie};
 use crate::state::{AppStateContext, error::*};
 
@@ -38,6 +39,33 @@ pub struct ContentFolderShowTemplate {
     pub parent_folder: Option<content_folder::Model>,
     /// Operation status for UI confirmation (Cookie)
     pub flash: Option<OperationStatus>,
+    // TODO: WIP
+    pub error: Option<AppStateError>,
+}
+
+impl ContentFolderShowTemplate {
+    fn new(context: AppStateContext, folder: FolderRequest) -> Self {
+        Self {
+            parent_folder: folder.parent,
+            breadcrumb_items: folder.ancestors,
+            sub_content_folders: folder.sub_folders,
+            current_content_folder: folder.folder,
+            category: folder.category,
+            state: context,
+            flash: None,
+            error: None,
+        }
+    }
+
+    fn with_flash(mut self, flash: Option<OperationStatus>) -> Self {
+        self.flash = flash;
+        self
+    }
+
+    fn with_errored_form(mut self, _form: MagnetForm, error: AppStateError) -> Self {
+        self.error = Some(error);
+        self
+    }
 }
 
 pub async fn show(
@@ -49,18 +77,30 @@ pub async fn show(
 
     Ok((
         jar,
-        ContentFolderShowTemplate {
-            parent_folder: folder.parent,
-            breadcrumb_items: folder.ancestors,
-            sub_content_folders: folder.sub_folders,
-            current_content_folder: folder.folder,
-            category: folder.category,
-            state: context,
-            flash: operation_status,
-        },
+        ContentFolderShowTemplate::new(context, folder).with_flash(operation_status),
     ))
 }
 
+pub async fn post_magnet(
+    context: AppStateContext,
+    folder: FolderRequest,
+    Form(form): Form<MagnetForm>,
+) -> Result<Redirect, ContentFolderShowTemplate> {
+    // TODO: proper error type
+    if let Err(e) = context
+        .db
+        .magnet()
+        .create(&form)
+        .await
+        .context(MagnetUploadSnafu)
+    {
+        return Err(ContentFolderShowTemplate::new(context, folder).with_errored_form(form, e));
+    }
+
+    // TODO: what to do when upload is successful?
+    Ok(Redirect::to("/magnet"))
+}
+
 pub async fn create(
     context: AppStateContext,
     jar: CookieJar,

src/routes/magnet.rs

@@ -1,52 +1,32 @@
 use askama::Template;
 use askama_web::WebTemplate;
-use axum::extract::Form;
-use axum::response::{IntoResponse, Redirect, Response};
 use serde::{Deserialize, Serialize};
 use snafu::prelude::*;
 
-use crate::database::{category, magnet};
+use sea_orm::LoaderTrait;
+
+use crate::database::{content_folder, magnet};
 use crate::state::{AppStateContext, error::*};
 
 /// Multipart form submitted to /magnet/upload:
 ///
 /// - magnet: the magnet link to upload
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct MagnetForm {
+    pub content_folder_id: String,
     pub magnet: String,
 }
 
-pub async fn upload(
-    context: AppStateContext,
-    Form(form): Form<MagnetForm>,
-) -> Result<Response, AppStateError> {
-    // TODO: proper error type
-    if let Err(e) = context
-        .db
-        .magnet()
-        .create(&form)
-        .await
-        .context(MagnetUploadSnafu)
-    {
-        return Ok(UploadMagnetTemplate::new(context)
-            .await?
-            .with_errored_form(form, e)
-            .into_response());
-    }
-
-    Ok(Redirect::to("/magnet").into_response())
-}
-
 #[derive(Template, WebTemplate)]
 #[template(path = "magnet/list.html")]
 pub struct MagnetListTemplate {
     /// Global application state (errors/warnings)
     pub state: AppStateContext,
     /// Magnets stored in database
-    pub magnets: Vec<magnet::Model>,
+    pub magnets: Vec<(magnet::Model, content_folder::Model)>,
 }
 
-pub async fn list(context: AppStateContext) -> Result<impl IntoResponse, AppStateError> {
+pub async fn list(context: AppStateContext) -> Result<MagnetListTemplate, AppStateError> {
     let magnets = context
         .db
         .magnet()
@@ -55,43 +35,22 @@ pub async fn list(context: AppStateContext) -> Result<impl IntoResponse, AppStat
         .boxed()
         .context(OtherSnafu)?;
 
+    // In the creation form we guarantee to set the content_folder so we can unwrap
+    let content_folders: Vec<content_folder::Model> = magnets
+        .load_one(content_folder::Entity, &context.state.database)
+        .await
+        .context(SqliteSnafu)?
+        .into_iter()
+        .map(|x| x.unwrap())
+        .collect();
+
+    let magnets = magnets
+        .into_iter()
+        .zip(content_folders.into_iter())
+        .collect();
+
     Ok(MagnetListTemplate {
         state: context,
         magnets,
     })
 }
-
-#[derive(Template, WebTemplate)]
-#[template(path = "magnet/upload.html")]
-pub struct UploadMagnetTemplate {
-    /// Global application state (errors/warnings)
-    pub state: AppStateContext,
-    /// Magnet upload form
-    pub post: Option<MagnetForm>,
-    /// Error with submitted magnet
-    pub post_error: Option<AppStateError>,
-    pub categories: Vec<category::Model>,
-}
-
-pub async fn get_upload(context: AppStateContext) -> Result<UploadMagnetTemplate, AppStateError> {
-    UploadMagnetTemplate::new(context).await
-}
-
-impl UploadMagnetTemplate {
-    pub async fn new(context: AppStateContext) -> Result<Self, AppStateError> {
-        let categories = context.db.category().list().await.context(CategorySnafu)?;
-
-        Ok(UploadMagnetTemplate {
-            state: context,
-            categories,
-            post: None,
-            post_error: None,
-        })
-    }
-
-    pub fn with_errored_form(mut self, form: MagnetForm, error: AppStateError) -> Self {
-        self.post = Some(form);
-        self.post_error = Some(error);
-        self
-    }
-}