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,6 +29,10 @@ 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))

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

@@ -5,14 +5,17 @@ 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::{category, 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,
 }
 
@@ -43,7 +46,7 @@ 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> {
@@ -55,6 +58,20 @@ 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,

templates/content_folders/dropdown_actions.html

@@ -4,7 +4,46 @@
   </button>
   <ul class="dropdown-menu">
     <li><a class="dropdown-item" href="#" data-bs-toggle="modal" data-bs-target="#createSubFolder">Create a subfolder</a></li>
-    <li><a class="dropdown-item" href="/magnet/upload">Import magnet link</a></li>
-    <li><a class="dropdown-item" href="#">Import torrent file</a></li>
+    
+    <li><a class="dropdown-item" data-bs-toggle="modal" data-bs-target="#importMagnetLink" href="#">Import magnet link</a></li>
   </ul>
 </div>
+
+<div class="modal fade" id="importMagnetLink" tabindex="-1" aria-labelledby="importMagnetLink" aria-hidden="false">
+  <div class="modal-dialog">
+    <div class="modal-content">
+      <div class="modal-header">
+        <h1 class="modal-title fs-5" id="staticBackdropLabel">Import Magnet Link</h1>
+      </div>
+      <div class="modal-body">
+        <form method="POST" accept-charset="utf-8">
+          <div class="alert alert-info text-start">
+            <p>
+              You are about to import a magnet into the category <strong>{{ category.name }}</strong>, in the folder
+              <code class="ms-2"><span><small>{{ category.name }}{% if current_content_folder is defined %}{{current_content_folder.path }}{% endif %}/</small></span></code>.
+            </p>
+
+            <p>
+              You will be able to reorganize the torrent content later, once the magnet has been resolved.
+            </p>
+          </div>
+          <div class="row align-items-center">
+            <div class="col-md-12 text-center">
+              <img src="/assets/images/magnet.png" class="img-64">
+            </div>
+            <div class="col-md-12 mt-3">
+              {% if current_content_folder is defined %}
+                <input type="hidden" name="content_folder_id" value="{{ current_content_folder.id }}">
+              {% endif %}
+              <input type="text" name="magnet" class="form-control" placeholder="Magnet link to download" id="magnet">
+
+              <div class="text-center mt-4">
+                <input type="Submit" class="btn btn-success btn-lg" value="Add to resolving list">
+              </div>
+            </div>
+          </div>
+        </form>          
+      </div>
+    </div>
+  </div>
+</div>

templates/content_folders/show.html

@@ -46,6 +46,14 @@
 
 {% block alert_message %}
   {% include "shared/alert_operation_status.html" %}
+  {% if let Some(error) = error %}
+  <div class="alert alert-danger mt-4">
+    <p class="mb-0">{{ error }}</p>
+    {% for inner_error in error.inner_errors() %}
+    <p>→ {{ inner_error }}</p>
+    {% endfor %}
+  </div>
+  {% endif %}
 {% endblock %}
 
 

templates/magnet/list.html

@@ -11,12 +11,14 @@ <h1>List of uploaded magnets not yet resolved</h1>
             <thead>
               <tr>
                 <th>Name</th>
+                <th>Content folder</th>
                 <th>Actions</th>
               </tr>
             </thead>
-            {% for magnet in magnets %}
+            {% for (magnet, content_folder) in magnets %}
             <tr>
               <td class="is-left" align="left"><a href="/magnet/{{ magnet.id }}">{{ magnet.name }}</a></td>
+              <td><a href="/folder/{{ content_folder.category_id }}/{{ content_folder.id }}">{{ content_folder.path }}</a></td>
               <td>
                 {% if magnet.resolved %}
                   <!-- TODO: mettre le lien vers la page des d'import d'un torrent -->