WIP

Author: amateurforger

Cargo.lock

@@ -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.18", features = [ "runtime-tokio", "debug-print", "sqlx-sqlite"] }
+# SQLite ORM (latest RC is broken)
+# 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.18" }
+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

@@ -1,5 +1,5 @@
 use chrono::Utc;
-use hightorrent_api::hightorrent::{MagnetLink, MagnetLinkError};
+use hightorrent_api::hightorrent::{MagnetLink, MagnetLinkError, TorrentID};
 use sea_orm::entity::prelude::*;
 use sea_orm::*;
 use snafu::prelude::*;
@@ -21,8 +21,8 @@ use crate::state::logger::LoggerError;
 pub struct Model {
     #[sea_orm(primary_key)]
     pub id: i32,
-    pub torrent_id: String,
-    pub magnet: String,
+    pub torrent_id: TorrentID,
+    pub magnet: MagnetLink,
     pub name: String,
     pub resolved: bool,
 }
@@ -72,7 +72,7 @@ impl MagnetOperator {
     }
 
     /// Delete an uploaded magnet
-    pub async fn delete(&self, id: i32, user: Option<User>) -> Result<String, MagnetError> {
+    pub async fn delete(&self, id: i32) -> Result<String, MagnetError> {
         let db = &self.state.database;
 
         let uploaded_magnet = Entity::find_by_id(id)
@@ -85,7 +85,7 @@ impl MagnetOperator {
         uploaded_magnet.delete(db).await.context(DBSnafu)?;
 
         let operation_log = OperationLog {
-            user,
+            user: self.user.clone(),
             date: Utc::now(),
             table: Table::Magnet,
             operation: OperationType::Delete,
@@ -110,21 +110,21 @@ impl MagnetOperator {
     /// Fails if:
     ///
     /// - the magnet is invalid
-    pub async fn create(&self, f: &MagnetForm, user: Option<User>) -> Result<Model, MagnetError> {
+    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().as_str()) {
+        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().to_string()),
-            magnet: Set(magnet.to_string()),
+            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),
@@ -138,7 +138,7 @@ impl MagnetOperator {
         let model = model.try_into_model().unwrap();
 
         let operation_log = OperationLog {
-            user,
+            user: self.user.clone(),
             date: Utc::now(),
             table: Table::Magnet,
             operation: OperationType::Create,

src/database/magnet.rs

@@ -22,8 +22,7 @@ pub struct IndexTemplate {
     /// Magnet upload form
     pub post: Option<MagnetForm>,
     /// Error with submitted magnet
-    /// TODO: typed error
-    pub post_error: Option<String>,
+    pub post_error: Option<AppStateError>,
 }
 
 impl IndexTemplate {
@@ -45,7 +44,7 @@ impl IndexTemplate {
         })
     }
 
-    pub fn with_errored_form(mut self, form: MagnetForm, error: String) -> Self {
+    pub fn with_errored_form(mut self, form: MagnetForm, error: AppStateError) -> Self {
         self.post = Some(form);
         self.post_error = Some(error);
         self

src/routes/index.rs

@@ -1,13 +1,15 @@
 use askama::Template;
 use askama_web::WebTemplate;
-use axum::extract::{Multipart, State};
-use axum::response::{IntoResponse, Redirect};
+use axum::extract::{Form, State};
+use axum::response::{IntoResponse, Response};
 use hightorrent_api::hightorrent::MagnetLink;
 use serde::{Deserialize, Serialize};
+use snafu::prelude::*;
 
+use crate::database::magnet::{MagnetOperator, Model as Magnet};
 use crate::extractors::user::User;
 use crate::routes::index::IndexTemplate;
-use crate::state::{AppState, AppStateContext, error::AppStateError};
+use crate::state::{AppState, AppStateContext, error::*};
 
 /// Multipart form submitted to /magnet/upload:
 ///
@@ -31,42 +33,44 @@ pub struct MagnetTemplate {
 pub async fn upload(
     State(app_state): State<AppState>,
     user: Option<User>,
-    mut form: Multipart,
-) -> Result<impl IntoResponse, AppStateError> {
-    let mut magnet: Option<String> = None;
-
-    while let Some(field) = form.next_field().await.unwrap() {
-        let name = field.name().unwrap().to_string();
-        let data = field.text().await.unwrap();
-
-        if name == "magnet" && !data.is_empty() {
-            magnet = Some(data);
-        }
-    }
-
-    if magnet.is_none() {
-        // No magnet was submitted. This is not an error, simply display the form again
-        return Ok(Redirect::to("/").into_response());
-    }
-
-    let magnet = magnet.unwrap();
-
+    Form(form): Form<MagnetForm>,
+) -> Result<Response, AppStateError> {
     // Parse magnet
-    match MagnetLink::new(&magnet) {
-        Ok(magnet) => Ok(MagnetTemplate {
+    let operator = MagnetOperator::new(app_state.clone(), user.clone());
+
+    match operator.create(&form).await.context(MagnetUploadSnafu) {
+        Ok(magnet_model) => Ok(MagnetTemplate {
             state: app_state.context().await?,
             user,
-            magnet,
+            magnet: magnet_model.magnet,
         }
         .into_response()),
-        Err(e) => {
-            let form = MagnetForm { magnet };
-
-            // TODO: typed error
-            Ok(IndexTemplate::new(app_state, user)
-                .await?
-                .with_errored_form(form, e.to_string())
-                .into_response())
-        }
+        Err(e) => Ok(IndexTemplate::new(app_state, user)
+            .await?
+            .with_errored_form(form, e)
+            .into_response()),
     }
 }
+
+#[derive(Template, WebTemplate)]
+#[template(path = "magnet_list.html")]
+pub struct MagnetListTemplate {
+    /// Global application state (errors/warnings)
+    pub state: AppStateContext,
+    /// Logged-in user.
+    pub user: Option<User>,
+    /// Magnets stored in database
+    pub magnets: Vec<Magnet>,
+}
+
+// pub async fn list(
+//     State(app_state): State<AppState>,
+//     user: Option<User>
+// ) -> Result<impl IntoResponse, AppStateError> {
+
+//     Ok(MagnetTemplate {
+//         state: app_state.context().await?,
+//         user,
+//         magnet,
+//     })
+// }

src/routes/magnet.rs

@@ -31,6 +31,10 @@ pub enum AppStateError {
     Category { source: CategoryError },
     #[snafu(display("Error during migration"))]
     Migration { source: MigrationError },
+    #[snafu(display("Magnet upload error"))]
+    MagnetUpload {
+        source: crate::database::magnet::MagnetError,
+    },
 }
 
 impl AppStateError {

src/state/error.rs

@@ -11,8 +11,15 @@ <h1>Download files</h1>
     {% endif %}
 
     {% if let Some(error) = post_error %}
-    <div class="alert alert-danger mt-4">
-      <p class="mb-0">{{ error }}</p>
+    <div class="notification is-danger alert alert-danger">
+      <details>
+        <summary>{{ error }}</summary>
+        <ul class="ml-5">
+          {% for inner_error in error.inner_errors() %}
+          <li>→ {{ inner_error }}</li>
+          {% endfor %}
+        </ul>
+      </details>
     </div>
     {% endif %}
 
@@ -69,5 +76,9 @@ <h1 class="modal-title fs-5" id="staticBackdropLabel">Oops, you don't have any c
         });
       </script>
     {% endif %}
+    <div class="card mt-4">
+      <div class="card-body">
+      </div>
+    </div>
   </div>
 {% endblock %}

templates/index.html

@@ -0,0 +1,7 @@
+{% extends "base.html" %}
+
+{% block main %}
+<div class="card mb-4">
+<h2>List of uploaded magnets not yet resolved</h2>
+</div>
+{% endblock main %}

templates/magnet_list.html

@@ -4,7 +4,7 @@ <h2 class="text-center">
       <label for="magnet">Magnet link</label>
     </h2>
 
-    <form method="POST" action="/magnet/upload" enctype="multipart/form-data" accept-charset="utf-8">
+    <form method="POST" action="/magnet/upload" accept-charset="utf-8">
       <div class="row align-items-center">
         <div class="col-md-3 text-center">
           <img src="/assets/images/magnet.png" class="img-64">