feat: Start supporting magnet upload

Author: angrynode

Cargo.lock

@@ -15,7 +15,7 @@ path = "src/main.rs"
 askama = "0.14.0"
 # askama_web::WebTemplate implements axum::IntoResponse
 askama_web = { version = "0.14.6", features = ["axum-0.8"] }
-axum = { version = "0.8.4", features = ["macros"] }
+axum = { version = "0.8.4", features = ["macros","multipart"] }
 axum-extra = { version = "0.12.1", features = ["cookie"] }
 # UTF-8 paths for easier String/PathBuf interop
 camino = { version = "1.1.12", features = ["serde1"] }
@@ -36,13 +36,15 @@ env_logger = "0.11.8"
 # Interactions with the torrent client
 # Comment/uncomment below for development version
 # hightorrent_api = { path = "../hightorrent_api" }
-hightorrent_api = { git = "https://github.com/angrynode/hightorrent_api" }
+hightorrent_api = { git = "https://github.com/angrynode/hightorrent_api", branch = "feat-sea-orm", features = [ "sea_orm" ]}
 # hightorrent_api = "0.2"
 log = "0.4.27"
 # SQLite ORM
-sea-orm = { version = "2.0.0-rc.21", features = [ "runtime-tokio", "debug-print", "sqlx-sqlite"] }
+# sea-orm = { git = "https://github.com/SeaQL/sea-orm/", features = [ "runtime-tokio", "debug-print", "sqlx-sqlite"] }
+sea-orm = { version = "=2.0.0-rc.28", features = [ "runtime-tokio", "debug-print", "sqlx-sqlite"] }
 # SQLite migrations
-sea-orm-migration = { version = "2.0.0-rc.21" }
+sea-orm-migration = { version = "=2.0.0-rc.28" }
+# sea-orm-migration = { git = "https://github.com/SeaQL/sea-orm" }
 # Serialization/deserialization, for example in path extractors
 serde = { version = "1.0.219", features = ["derive", "rc"] }
 # (De)serialization for operations log

Cargo.toml

@@ -0,0 +1,160 @@
+use chrono::Utc;
+use hightorrent_api::hightorrent::{MagnetLink, MagnetLinkError, TorrentID};
+use sea_orm::entity::prelude::*;
+use sea_orm::*;
+use snafu::prelude::*;
+
+use crate::database::operation::*;
+use crate::extractors::user::User;
+use crate::routes::magnet::MagnetForm;
+use crate::state::AppState;
+use crate::state::logger::LoggerError;
+
+/// A category to store associated files.
+///
+/// Each category has a name and an associated path on disk, where
+/// symlinks to the content will be created.
+// TODO: typed model fields
+// see https://github.com/SeaQL/sea-orm/issues/2811
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
+#[sea_orm(table_name = "magnet")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub torrent_id: TorrentID,
+    pub magnet: MagnetLink,
+    pub name: String,
+    pub resolved: bool,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {}
+
+#[async_trait::async_trait]
+impl ActiveModelBehavior for ActiveModel {}
+
+#[derive(Debug, Snafu)]
+#[snafu(visibility(pub))]
+pub enum MagnetError {
+    #[snafu(display("The magnet is invalid"))]
+    InvalidMagnet { source: MagnetLinkError },
+    // TODO: this is not an error
+    // we should redirect to the magnet page (eg. progress)
+    #[snafu(display("There is already a magnet with the TorrentID `{torrent_id}`"))]
+    TorrentIDTaken { torrent_id: String },
+    #[snafu(display("Database error"))]
+    DB { source: sea_orm::DbErr },
+    #[snafu(display("The magnet (ID: {id}) does not exist"))]
+    NotFound { id: i32 },
+    #[snafu(display("Failed to save the operation log"))]
+    Logger { source: LoggerError },
+}
+
+#[derive(Clone, Debug)]
+pub struct MagnetOperator {
+    pub state: AppState,
+    pub user: Option<User>,
+}
+
+impl MagnetOperator {
+    pub fn new(state: AppState, user: Option<User>) -> Self {
+        Self { state, user }
+    }
+
+    /// List categories
+    ///
+    /// Should not fail, unless SQLite was corrupted for some reason.
+    pub async fn list(&self) -> Result<Vec<Model>, MagnetError> {
+        Entity::find()
+            .all(&self.state.database)
+            .await
+            .context(DBSnafu)
+    }
+
+    /// Delete an uploaded magnet
+    pub async fn delete(&self, id: i32) -> Result<String, MagnetError> {
+        let db = &self.state.database;
+
+        let uploaded_magnet = Entity::find_by_id(id)
+            .one(db)
+            .await
+            .context(DBSnafu)?
+            .ok_or(MagnetError::NotFound { id })?;
+
+        let clone: Model = uploaded_magnet.clone();
+        uploaded_magnet.delete(db).await.context(DBSnafu)?;
+
+        let operation_log = OperationLog {
+            user: self.user.clone(),
+            date: Utc::now(),
+            table: Table::Magnet,
+            operation: OperationType::Delete,
+            operation_id: OperationId {
+                object_id: clone.id,
+                name: clone.name.to_owned(),
+            },
+            operation_form: None,
+        };
+
+        self.state
+            .logger
+            .write(operation_log)
+            .await
+            .context(LoggerSnafu)?;
+
+        Ok(clone.name)
+    }
+
+    /// Create a new uploaded magnet
+    ///
+    /// Fails if:
+    ///
+    /// - the magnet is invalid
+    pub async fn create(&self, f: &MagnetForm) -> Result<Model, MagnetError> {
+        let magnet = MagnetLink::new(&f.magnet).context(InvalidMagnetSnafu)?;
+
+        // Check duplicates
+        let list = self.list().await?;
+
+        if list.iter().any(|x| x.torrent_id == magnet.id()) {
+            return Err(MagnetError::TorrentIDTaken {
+                torrent_id: magnet.id().to_string(),
+            });
+        }
+
+        let model = ActiveModel {
+            torrent_id: Set(magnet.id()),
+            magnet: Set(magnet.clone()),
+            name: Set(magnet.name().to_string()),
+            // TODO: check if we already have the torrent in which case it's already resolved!
+            resolved: Set(false),
+            ..Default::default()
+        }
+        .save(&self.state.database)
+        .await
+        .context(DBSnafu)?;
+
+        // Should not fail
+        let model = model.try_into_model().unwrap();
+
+        let operation_log = OperationLog {
+            user: self.user.clone(),
+            date: Utc::now(),
+            table: Table::Magnet,
+            operation: OperationType::Create,
+            operation_id: OperationId {
+                object_id: model.id.to_owned(),
+                name: model.name.to_string(),
+            },
+            operation_form: Some(Operation::Magnet(f.clone())),
+        };
+
+        self.state
+            .logger
+            .write(operation_log)
+            .await
+            .context(LoggerSnafu)?;
+
+        Ok(model)
+    }
+}

src/database/magnet.rs

@@ -1,4 +1,5 @@
 // sea_orm example: https://github.com/SeaQL/sea-orm/blob/master/examples/axum_example/
 pub mod category;
 pub mod content_folder;
+pub mod magnet;
 pub mod operation;

src/database/mod.rs

@@ -5,6 +5,7 @@ use serde::{Deserialize, Serialize};
 use crate::extractors::user::User;
 use crate::routes::category::CategoryForm;
 use crate::routes::content_folder::ContentFolderForm;
+use crate::routes::magnet::MagnetForm;
 
 /// Type of operation applied to the database.
 #[derive(Clone, Debug, Display, Serialize, Deserialize)]
@@ -24,6 +25,7 @@ pub struct OperationId {
 pub enum Table {
     Category,
     ContentFolder,
+    Magnet,
 }
 
 /// Operation applied to the database.
@@ -34,6 +36,7 @@ pub enum Table {
 pub enum Operation {
     Category(CategoryForm),
     ContentFolder(ContentFolderForm),
+    Magnet(MagnetForm),
 }
 
 impl std::fmt::Display for Operation {

src/database/operation.rs

@@ -33,6 +33,8 @@ pub fn router(state: state::AppState) -> Router {
         )
         .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))
         // Register static assets routes
         .nest("/assets", static_router())
         // Insert request timing

src/lib.rs

@@ -0,0 +1,39 @@
+use sea_orm_migration::{prelude::*, schema::*};
+
+#[derive(DeriveMigrationName)]
+pub struct Migration;
+
+#[async_trait::async_trait]
+impl MigrationTrait for Migration {
+    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .create_table(
+                Table::create()
+                    .table(Magnet::Table)
+                    .if_not_exists()
+                    .col(pk_auto(Magnet::Id))
+                    .col(string(Magnet::TorrentID).unique_key())
+                    .col(string(Magnet::Name))
+                    .col(string(Magnet::Link))
+                    .col(boolean(Magnet::Resolved))
+                    .to_owned(),
+            )
+            .await
+    }
+
+    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .drop_table(Table::drop().table(Magnet::Table).to_owned())
+            .await
+    }
+}
+
+#[derive(DeriveIden)]
+enum Magnet {
+    Table,
+    Id,
+    TorrentID,
+    Name,
+    Link,
+    Resolved,
+}

src/migration/m20251114_01_create_table_magnet.rs

@@ -3,6 +3,7 @@ pub use sea_orm_migration::prelude::*;
 mod m20251110_01_create_table_category;
 mod m20251113_203047_add_content_folder;
 mod m20251113_203899_add_uniq_to_content_folder;
+mod m20251114_01_create_table_magnet;
 
 pub struct Migrator;
 
@@ -13,6 +14,8 @@ impl MigratorTrait for Migrator {
             Box::new(m20251110_01_create_table_category::Migration),
             Box::new(m20251113_203047_add_content_folder::Migration),
             Box::new(m20251113_203899_add_uniq_to_content_folder::Migration),
+            Box::new(m20251110_01_create_table_category::Migration),
+            Box::new(m20251114_01_create_table_magnet::Migration),
         ]
     }
 }

src/migration/mod.rs

@@ -6,6 +6,7 @@ use snafu::prelude::*;
 // TUTORIAL: https://github.com/SeaQL/sea-orm/blob/master/examples/axum_example/
 use crate::database::category::{self, CategoryOperator};
 use crate::extractors::user::User;
+use crate::routes::magnet::MagnetForm;
 use crate::state::{AppState, AppStateContext, error::*};
 
 #[derive(Template, WebTemplate)]
@@ -28,6 +29,11 @@ pub struct UploadTemplate {
     pub user: Option<User>,
     /// Categories
     pub categories: Vec<String>,
+    // TODO: also support torrent upload
+    /// Magnet upload form
+    pub post: Option<MagnetForm>,
+    /// Error with submitted magnet
+    pub post_error: Option<AppStateError>,
 }
 
 impl IndexTemplate {
@@ -61,8 +67,16 @@ impl UploadTemplate {
             state: app_state.context().await?,
             user,
             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
+    }
 }
 
 pub async fn index(