Merge pull request #884 from RustyNova016/move_bumps

refactor: moved bump commands

Author: RustyNova016

alistral_cli/src/models/cli/mod.rs

@@ -19,8 +19,8 @@ use unstable::UnstableCommand;
 use crate::models::cli::interzic::InterzicCommand;
 #[cfg(feature = "radio")]
 use crate::models::cli::radio::RadioCommand;
-use crate::tools::bumps::bump_command;
-use crate::tools::bumps::bump_down_command;
+use crate::tools::bump::BumpCommand;
+use crate::tools::bump::bump_down::BumpDownCommand;
 use crate::tools::cache::CacheCommand;
 use crate::tools::compatibility::compatibility_command;
 use crate::tools::daily::DailyCommand;
@@ -90,38 +90,16 @@ impl Cli {
     }
 }
 
-/// bump a recording to show up more frequently in radios that uses scores. By default, it uses the lastest listen as target.
-///
-/// bump-down is an alias for `bump <RECORDING> <DURATION> 0.9`
-///
-/// All the bumps are added multiplicatively, so a recording won't disapear. Use the blacklist to remove them.
-#[derive(Parser, Debug, Clone)]
-pub struct BumpCLI {
-    /// The recording to bump
-    pub recording: Option<String>,
-
-    /// The duration the bump last for (Default: 3 months)
-    #[arg(short, long)]
-    pub duration: Option<String>,
-
-    /// The multiplier added to the score (Default: 1.1)
-    #[arg(short, long)]
-    pub multiplier: Option<String>,
-
-    #[arg(short, long)]
-    pub username: Option<String>,
-}
-
 #[derive(Subcommand, Debug, Clone)]
 pub enum Commands {
-    Bump(BumpCLI),
+    Bump(BumpCommand),
 
     /// bump a recording to show up more frequently in radios that uses scores. By default, it uses the lastest listen as target.
     ///
     /// bump-down is an alias for `bump <RECORDING> <DURATION> 0.9`
     ///    
     /// All the bumps are added multiplicatively, so a recording won't disapear. Use the blacklist to remove them.
-    BumpDown(BumpCLI),
+    BumpDown(BumpDownCommand),
 
     /// Commands to deal with the local cache
     Cache(CacheCommand),
@@ -176,6 +154,8 @@ pub enum Commands {
 impl Commands {
     pub async fn run(&self, conn: &mut sqlx::SqliteConnection) -> Result<(), FatalError> {
         match self {
+            Self::Bump(val) => val.run().await,
+            Self::BumpDown(val) => val.run().await,
             Self::Cache(val) => val.run().await,
 
             #[cfg(feature = "stats")]
@@ -207,11 +187,6 @@ impl Commands {
 
             #[cfg(feature = "interzicf")]
             Self::Playlist(val) => val.run(conn).await?,
-
-            Self::Bump(val) => bump_command(conn, val.clone()).await,
-
-            Self::BumpDown(val) => bump_down_command(conn, val.clone()).await,
-
             Self::Unstable(val) => val.command.run(conn).await,
         }
 

alistral_cli/src/models/client.rs alistral_cli/src/models/client/mod.rsalistral_cli/src/models/client.rs renamed to alistral_cli/src/models/client/mod.rs

@@ -0,0 +1,38 @@
+use clap::Parser;
+
+use crate::tools::bump::BumpCommand;
+
+/// bump a recording to show up more frequently in radios that uses scores. By default, it uses the lastest listen as target.
+///
+/// bump-down is an alias for `bump <RECORDING> <DURATION> 0.9`
+///
+/// All the bumps are added multiplicatively, so a recording won't disapear. Use the blacklist to remove them.
+#[derive(Parser, Debug, Clone)]
+pub struct BumpDownCommand {
+    /// The recording to bump
+    pub recording: Option<String>,
+
+    /// The duration the bump last for (Default: 3 months)
+    #[arg(short, long)]
+    pub duration: Option<String>,
+
+    /// The multiplier added to the score (Default: 1.1)
+    #[arg(short, long)]
+    pub multiplier: Option<String>,
+
+    #[arg(short, long)]
+    pub username: Option<String>,
+}
+
+impl BumpDownCommand {
+    pub async fn run(&self) {
+        let cmd = BumpCommand {
+            duration: self.duration.clone(),
+            multiplier: self.multiplier.clone().or_else(|| Some("0.9".to_string())),
+            recording: self.recording.clone(),
+            username: self.username.clone(),
+        };
+
+        cmd.run().await
+    }
+}

alistral_cli/src/tools/bump/bump_down.rs

@@ -0,0 +1,92 @@
+use std::str::FromStr;
+
+use alistral_core::datastructures::listen_collection::traits::ListenCollectionReadable as _;
+use alistral_core::models::listen_statistics_data::ListenStatisticsData;
+use chrono::Duration;
+use chrono::Utc;
+use clap::Parser;
+use rust_decimal::Decimal;
+use tuillez::extensions::chrono_exts::DurationExt as _;
+use tuillez::formatter::FormatWithAsync;
+
+use crate::ALISTRAL_CLIENT;
+use crate::models::config::Config;
+use crate::utils::constants::LISTENBRAINZ_FMT;
+use crate::utils::user_inputs::UserInputParser;
+
+pub mod bump_down;
+
+/// bump a recording to show up more frequently in radios that uses scores. By default, it uses the lastest listen as target.
+///
+/// bump-down is an alias for `bump <RECORDING> <DURATION> 0.9`
+///
+/// All the bumps are added multiplicatively, so a recording won't disapear. Use the blacklist to remove them.
+#[derive(Parser, Debug, Clone)]
+pub struct BumpCommand {
+    /// The recording to bump
+    pub recording: Option<String>,
+
+    /// The duration the bump last for (Default: 3 months)
+    #[arg(short, long)]
+    pub duration: Option<String>,
+
+    /// The multiplier added to the score (Default: 1.1)
+    #[arg(short, long)]
+    pub multiplier: Option<String>,
+
+    #[arg(short, long)]
+    pub username: Option<String>,
+}
+
+impl BumpCommand {
+    pub async fn run(&self) {
+        let username = UserInputParser::username_or_default(&self.username);
+
+        let recording = match &self.recording {
+            Some(mbid) => UserInputParser::parse_recording(mbid).await,
+            None => {
+                let user_data = ListenStatisticsData::new_from_user_listens(
+                    ALISTRAL_CLIENT.core.clone(),
+                    UserInputParser::username_or_default(&self.username),
+                )
+                .await
+                .unwrap();
+                user_data
+                    .listens()
+                    .get_latest_listen()
+                    .unwrap()
+                    .get_recording_or_fetch_with_task(ALISTRAL_CLIENT.musicbrainz_db.clone())
+                    .await
+                    .unwrap()
+                    .unwrap()
+            }
+        };
+
+        let multiplier = Decimal::from_str(self.multiplier.as_deref().unwrap_or("1.1"))
+            .expect("Couldn't parse the multiplier");
+
+        let duration = match &self.duration {
+            Some(dur) => Duration::from_human_string(dur).expect("Couldn't parse the duration."),
+            None => Duration::from_human_string("3 months").expect("Couldn't parse the duration."),
+        };
+
+        let conf = Config::load_or_panic();
+
+        println!(
+            "Adding bump to {}, giving a {} multiplier for {}",
+            recording
+                .format_with_async(&LISTENBRAINZ_FMT)
+                .await
+                .expect("Error while getting recording credits"),
+            multiplier,
+            duration.to_humantime().unwrap()
+        );
+
+        conf.write_or_panic().bumps.add_bump(
+            recording.mbid.clone(),
+            username,
+            multiplier,
+            Utc::now() + duration,
+        );
+    }
+}

alistral_cli/src/tools/bump/mod.rs

@@ -1,4 +1,4 @@
-pub mod bumps;
+pub mod bump;
 pub mod cache;
 pub mod compatibility;
 pub mod daily;

alistral_cli/src/tools/bumps.rs

@@ -5,10 +5,10 @@ use std::io;
 #[cfg(feature = "lookup")]
 use clap::CommandFactory as _;
 
-use super::regex::is_string_mbid;
 #[cfg(feature = "lookup")]
 use crate::models::cli::Cli;
 use crate::utils::regex::get_raw_mbid_from_url;
+use crate::utils::user_inputs::UserInputParser;
 
 pub mod formating;
 #[cfg(feature = "lookup")]
@@ -21,7 +21,7 @@ pub fn await_next() {
 }
 
 pub fn read_mbid_from_input(input: &str) -> Option<String> {
-    if is_string_mbid(input) {
+    if UserInputParser::is_uuid(input) {
         return Some(input.to_string());
     }
 

alistral_cli/src/tools/mod.rs

@@ -8,5 +8,7 @@ pub mod extensions;
 pub mod listenbrainz_api;
 pub mod radio;
 pub mod regex;
+/// Holds all of the user input parsers and sanitasation
+pub mod user_inputs;
 #[cfg(feature = "musicbrainz")]
 pub mod whitelist_blacklist;

alistral_cli/src/utils/cli/mod.rs

@@ -1,17 +1,5 @@
 use regex::Regex;
 
-pub fn is_string_mbid(string: &str) -> bool {
-    let regex = Regex::new(
-        r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$",
-    )
-    .unwrap();
-
-    // result will be a tuple containing the start and end indices for the first match in the string
-    let result = regex.captures(string);
-
-    result.is_some()
-}
-
 pub fn get_raw_mbid_from_url(string: &str) -> Option<String> {
     let regex = Regex::new(r"(area|instrument|recording|release|album|work|release-group|url|track)/([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})").unwrap();
 

alistral_cli/src/utils/mod.rs

@@ -0,0 +1,26 @@
+use musicbrainz_db_lite::GetOrFetch;
+use musicbrainz_db_lite::Recording;
+
+use crate::ALISTRAL_CLIENT;
+use crate::utils::user_inputs::UserInputParser;
+
+impl UserInputParser {
+    /// Parse a recording from the input. End the program with no panics if the data is wrong
+    pub async fn parse_recording(mbid: &str) -> Recording {
+        let Some(mbid) = Self::read_mbid_from_input(mbid) else {
+            tracing::error!("Couldn't read mbid from input");
+            std::process::exit(2);
+        };
+
+        match Recording::get_or_fetch_as_task(ALISTRAL_CLIENT.musicbrainz_db.clone(), &mbid)
+            .await
+            .unwrap()
+        {
+            Some(val) => val,
+            None => {
+                tracing::error!("Couldn't find a recording with mbid {mbid}");
+                std::process::exit(2);
+            }
+        }
+    }
+}