feat: [#453] new console command

New console command to upload torrent to the Index remotely by using the
API client.

```console
cargo run --bin seeder -- --api-base-url <API_BASE_URL> --number-of-torrents <NUMBER_OF_TORRENTS> --user <USER> --password <PASSWORD> --interval <INTERVAL>
```

For example:

```console
cargo run --bin seeder -- --api-base-url "localhost:3001" --number-of-torrents 1000 --user admin --password 12345678 --interval 0
```

That command would upload 1000 random torrents to the Index using the user
account `admin` with password `123456` and waiting `1` second between uploads.

src/bin/seeder.rs

@@ -1,6 +1,7 @@
 //! Program to upload random torrents to a live Index API.
 use torrust_index::console::commands::seeder::app;
 
-fn main() -> anyhow::Result<()> {
-    app::run()
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    app::run().await
 }

src/console/commands/seeder/api_request.rs

@@ -0,0 +1,103 @@
+use crate::web::api::client::v1::client::Client;
+use crate::web::api::client::v1::contexts::category::forms::AddCategoryForm;
+use crate::web::api::client::v1::contexts::category::responses::{ListItem, ListResponse};
+use crate::web::api::client::v1::contexts::torrent::forms::UploadTorrentMultipartForm;
+use crate::web::api::client::v1::contexts::torrent::responses::{UploadedTorrent, UploadedTorrentResponse};
+use crate::web::api::client::v1::contexts::user::forms::LoginForm;
+use crate::web::api::client::v1::contexts::user::responses::{LoggedInUserData, SuccessfulLoginResponse};
+use crate::web::api::client::v1::responses::TextResponse;
+
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum Error {
+    #[error("Torrent with the same info-hash already exist in the database")]
+    TorrentInfoHashAlreadyExists,
+    #[error("Torrent with the same title already exist in the database")]
+    TorrentTitleAlreadyExists,
+}
+
+/// It uploads a torrent file to the Torrust Index.
+///
+/// # Errors
+///
+/// It returns an error if the torrent already exists in the database.
+///
+/// # Panics
+///
+/// Panics if the response body is not a valid JSON.
+pub async fn upload_torrent(client: &Client, upload_torrent_form: UploadTorrentMultipartForm) -> Result<UploadedTorrent, Error> {
+    let categories = get_categories(client).await;
+
+    if !contains_category_with_name(&categories, &upload_torrent_form.category) {
+        add_category(client, &upload_torrent_form.category).await;
+    }
+
+    let response = client.upload_torrent(upload_torrent_form.into()).await;
+
+    println!("response: {}", response.status);
+
+    if response.status == 400 {
+        if response.body.contains("This torrent already exists in our database") {
+            return Err(Error::TorrentInfoHashAlreadyExists);
+        }
+
+        if response.body.contains("This torrent title has already been used") {
+            return Err(Error::TorrentTitleAlreadyExists);
+        }
+    }
+
+    assert!(response.is_json_and_ok(), "Error uploading torrent: {}", response.body);
+
+    let uploaded_torrent_response: UploadedTorrentResponse =
+        serde_json::from_str(&response.body).expect("a valid JSON response should be returned from the Torrust Index API");
+
+    Ok(uploaded_torrent_response.data)
+}
+
+/// It logs in the user and returns the user data.
+///
+/// # Panics
+///
+/// Panics if the response body is not a valid JSON.
+pub async fn login(client: &Client, username: &str, password: &str) -> LoggedInUserData {
+    let response = client
+        .login_user(LoginForm {
+            login: username.to_owned(),
+            password: password.to_owned(),
+        })
+        .await;
+
+    let res: SuccessfulLoginResponse =
+        serde_json::from_str(&response.body).expect("a valid JSON response should be returned after login");
+
+    res.data
+}
+
+/// It returns all the index categories.
+///
+/// # Panics
+///
+/// Panics if the response body is not a valid JSON.
+pub async fn get_categories(client: &Client) -> Vec<ListItem> {
+    let response = client.get_categories().await;
+
+    let res: ListResponse = serde_json::from_str(&response.body).unwrap();
+
+    res.data
+}
+
+/// It adds a new category.
+pub async fn add_category(client: &Client, name: &str) -> TextResponse {
+    client
+        .add_category(AddCategoryForm {
+            name: name.to_owned(),
+            icon: None,
+        })
+        .await
+}
+
+/// It checks if the category list contains the given category.
+fn contains_category_with_name(items: &[ListItem], category_name: &str) -> bool {
+    items.iter().any(|item| item.name == category_name)
+}

src/console/commands/seeder/app.rs

@@ -3,19 +3,39 @@
 //! Run with:
 //!
 //! ```text
-//! cargo run --bin seeder -- --number-of-torrents <NUMBER_OF_TORRENTS> --user <USER> --password <PASSWORD> --interval <INTERVAL>
+//! cargo run --bin seeder -- --api-base-url <API_BASE_URL> --number-of-torrents <NUMBER_OF_TORRENTS> --user <USER> --password <PASSWORD> --interval <INTERVAL>
 //! ```
 //!
 //! For example:
 //!
 //! ```text
-//! cargo run --bin seeder -- --number-of-torrents 1000 --user admin --password 12345678 --interval 0
+//! cargo run --bin seeder -- --api-base-url "localhost:3001" --number-of-torrents 1000 --user admin --password 12345678 --interval 0
 //! ```
 //!
 //! That command would upload 100o random torrents to the Index using the user
 //! account admin with password 123456 and waiting 1 second between uploads.
 use clap::Parser;
-use log::{debug, LevelFilter};
+use log::{debug, info, LevelFilter};
+use text_colorizer::Colorize;
+use uuid::Uuid;
+
+use crate::{
+    console::commands::seeder::api_request::{login, upload_torrent},
+    services::torrent_file::generate_random_torrent,
+    utils::parse_torrent,
+    web::api::client::v1::{
+        client::Client,
+        contexts::{
+            torrent::{
+                forms::{BinaryFile, UploadTorrentMultipartForm},
+                responses::UploadedTorrent,
+            },
+            user::responses::LoggedInUserData,
+        },
+    },
+};
+
+use super::api_request::Error;
 
 #[derive(Parser, Debug)]
 #[clap(author, version, about, long_about = None)]
@@ -36,7 +56,7 @@ struct Args {
 /// # Errors
 ///
 /// Will not return any errors for the time being.
-pub fn run() -> anyhow::Result<()> {
+pub async fn run() -> anyhow::Result<()> {
     setup_logging(LevelFilter::Info);
 
     let args = Args::parse();
@@ -46,9 +66,18 @@ pub fn run() -> anyhow::Result<()> {
     println!("Password: {}", args.password);
     println!("Interval: {:?}", args.interval);
 
-    /* todo:
-        - Use a client to upload a random torrent every "interval" seconds.
-    */
+    let api_url = "localhost:3001".to_string();
+
+    let api_user = log_in_target_api(&api_url, &args.user, &args.password).await;
+
+    let api_client = Client::authenticated(&api_url, &api_user.token);
+
+    println!("Uploading the torrent to the Torrust Index ...");
+
+    match upload_random_torrent(&api_client).await {
+        Ok(uploaded_torrent) => print!("Uploaded torrent {uploaded_torrent:?}"),
+        Err(err) => print!("Error uploading torrent {err:?}"),
+    };
 
     Ok(())
 }
@@ -73,3 +102,44 @@ fn setup_logging(level: LevelFilter) {
 
     debug!("logging initialized.");
 }
+
+/// It logs in a user in the target Index API.
+pub async fn log_in_target_api(api_url: &str, username: &str, password: &str) -> LoggedInUserData {
+    let unauthenticated_client = Client::unauthenticated(api_url);
+
+    info!("API login with username {} ...", username.green());
+
+    let user: LoggedInUserData = login(&unauthenticated_client, username, password).await;
+
+    if user.admin {
+        println!("Logged as admin with account {} ", username.green());
+    } else {
+        println!("Logged as {} ", username.green());
+    }
+
+    user
+}
+
+async fn upload_random_torrent(api_client: &Client) -> Result<UploadedTorrent, Error> {
+    let uuid = Uuid::new_v4();
+
+    let torrent = generate_random_torrent(uuid);
+
+    let bytes = parse_torrent::encode_torrent(&torrent).expect("msg:the torrent should be bencoded");
+
+    println!("Uploading new random torrent to the Torrust Index ...");
+
+    let torrent_file = BinaryFile::from_bytes("torrent-file-name".to_string(), bytes);
+
+    let torrent_index_info = UploadTorrentMultipartForm {
+        title: "title".to_string(),
+        description: "title".to_string(),
+        category: "test".to_string(),
+        torrent_file,
+    };
+
+    match upload_torrent(api_client, torrent_index_info).await {
+        Ok(uploaded_torrent) => Ok(uploaded_torrent),
+        Err(error) => Err(error),
+    }
+}

src/console/commands/seeder/mod.rs

@@ -1 +1,2 @@
 pub mod app;
+pub mod api_request;

src/web/api/client/v1/client.rs

@@ -4,7 +4,7 @@ use serde::Serialize;
 use super::connection_info::ConnectionInfo;
 use super::contexts::category::forms::{AddCategoryForm, DeleteCategoryForm};
 use super::contexts::tag::forms::{AddTagForm, DeleteTagForm};
-use super::contexts::torrent::forms::UpdateTorrentFrom;
+use super::contexts::torrent::forms::UpdateTorrentForm;
 use super::contexts::torrent::requests::InfoHash;
 use super::contexts::user::forms::{LoginForm, RegistrationForm, TokenRenewalForm, TokenVerificationForm, Username};
 use super::http::{Query, ReqwestQuery};
@@ -119,7 +119,7 @@ impl Client {
         self.http_client.delete(&format!("/torrent/{info_hash}")).await
     }
 
-    pub async fn update_torrent(&self, info_hash: &InfoHash, update_torrent_form: UpdateTorrentFrom) -> TextResponse {
+    pub async fn update_torrent(&self, info_hash: &InfoHash, update_torrent_form: UpdateTorrentForm) -> TextResponse {
         self.http_client
             .put(&format!("/torrent/{info_hash}"), &update_torrent_form)
             .await

src/web/api/client/v1/contexts/torrent/forms.rs

@@ -4,7 +4,7 @@ use std::path::Path;
 use serde::{Deserialize, Serialize};
 
 #[derive(Deserialize, Serialize)]
-pub struct UpdateTorrentFrom {
+pub struct UpdateTorrentForm {
     pub title: Option<String>,
     pub description: Option<String>,
     pub category: Option<i64>,
@@ -28,9 +28,9 @@ pub struct BinaryFile {
 
 impl BinaryFile {
     /// # Panics
-    /// 
+    ///
     /// Will panic if:
-    /// 
+    ///
     /// - The path is not a file.
     /// - The path can't be converted into string.
     /// - The file can't be read.
@@ -41,6 +41,12 @@ impl BinaryFile {
             contents: fs::read(path).unwrap(),
         }
     }
+
+    /// Build the binary file directly from the binary data provided.
+    #[must_use]
+    pub fn from_bytes(name: String, contents: Vec<u8>) -> Self {
+        BinaryFile { name, contents }
+    }
 }
 
 impl From<UploadTorrentMultipartForm> for Form {