about summary refs log tree commit diff stats
path: root/pkgs/by-name/mp/mpdpopm/src/messages.rs
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--pkgs/by-name/mp/mpdpopm/src/messages.rs197
1 files changed, 1 insertions, 196 deletions
diff --git a/pkgs/by-name/mp/mpdpopm/src/messages.rs b/pkgs/by-name/mp/mpdpopm/src/messages.rs
index ae356f34..c7c295c8 100644
--- a/pkgs/by-name/mp/mpdpopm/src/messages.rs
+++ b/pkgs/by-name/mp/mpdpopm/src/messages.rs
@@ -52,8 +52,6 @@ use crate::{
     clients::{Client, IdleClient, PlayerStatus},
     filters::ExpressionParser,
     filters_ast::{FilterStickerNames, evaluate},
-    ratings::{RatedTrack, RatingRequest},
-    storage::{self, last_played, play_count, rating_count},
 };
 
 use backtrace::Backtrace;
@@ -61,10 +59,8 @@ use boolinator::Boolinator;
 use tracing::debug;
 
 use std::collections::VecDeque;
-use std::convert::TryFrom;
 use std::path::PathBuf;
 
-
 #[derive(Debug)]
 pub enum Error {
     BadPath {
@@ -347,15 +343,7 @@ impl MessageProcessor {
         state: &PlayerStatus,
         stickers: &FilterStickerNames<'a>,
     ) -> Result<()> {
-        if let Some(stripped) = msg.strip_prefix("rate ") {
-            self.rate(stripped, client, state).await
-        } else if let Some(stripped) = msg.strip_prefix("inc-rate ") {
-            self.inc_rate(stripped, client, state).await
-        } else if let Some(stripped) = msg.strip_prefix("setpc ") {
-            self.setpc(stripped, client, state).await
-        } else if let Some(stripped) = msg.strip_prefix("setlp ") {
-            self.setlp(stripped, client, state).await
-        } else if let Some(stripped) = msg.strip_prefix("findadd ") {
+        if let Some(stripped) = msg.strip_prefix("findadd ") {
             self.findadd(stripped.to_string(), client, stickers, state)
                 .await
         } else if let Some(stripped) = msg.strip_prefix("searchadd ") {
@@ -366,189 +354,6 @@ impl MessageProcessor {
         }
     }
 
-    /// Handle rating message: "RATING( TRACK)?"
-    async fn rate(&self, msg: &str, client: &mut Client, state: &PlayerStatus) -> Result<()> {
-        let req = RatingRequest::try_from(msg).map_err(|err| Error::Ratings {
-            source: storage::Error::Rating {
-                source: err,
-                back: Backtrace::new(),
-            },
-            back: Backtrace::new(),
-        })?;
-
-        let pathb = match req.track {
-            RatedTrack::Current => match state {
-                PlayerStatus::Stopped => {
-                    return Err(Error::PlayerStopped {});
-                }
-                PlayerStatus::Play(curr) | PlayerStatus::Pause(curr) => curr.file.clone(),
-            },
-            RatedTrack::File(p) => p,
-            RatedTrack::Relative(_i) => {
-                return Err(Error::NotImplemented {
-                    feature: String::from("Relative track position"),
-                });
-            }
-        };
-        let path: &str = pathb
-            .to_str()
-            .ok_or_else(|| Error::BadPath { pth: pathb.clone() })?;
-
-        debug!("Setting a rating of {} for `{}'.", req.rating, path);
-
-        rating_count::set(client, path, req.rating)
-            .await
-            .map_err(|err| Error::Ratings {
-                source: err,
-                back: Backtrace::new(),
-            })?;
-
-        Ok(())
-    }
-
-    /// Handle inc-rating message: "( TRACK)?"
-    async fn inc_rate(&self, msg: &str, client: &mut Client, state: &PlayerStatus) -> Result<()> {
-        let pathb = if msg.is_empty() {
-            // We rate the current track
-            match state {
-                PlayerStatus::Stopped => {
-                    return Err(Error::PlayerStopped {});
-                }
-                PlayerStatus::Play(curr) | PlayerStatus::Pause(curr) => curr.file.clone(),
-            }
-        } else {
-            PathBuf::from(msg)
-        };
-
-        let path: &str = pathb
-            .to_str()
-            .ok_or_else(|| Error::BadPath { pth: pathb.clone() })?;
-
-        let rating = rating_count::get(client, path)
-            .await
-            .map_err(|err| Error::Ratings {
-                source: err,
-                back: Backtrace::new(),
-            })?
-            .unwrap_or(0)
-            .saturating_add(1);
-
-        debug!(
-            "Incrementing a rating for `{}' (new value: {}).",
-            path, rating
-        );
-
-        rating_count::set(client, path, rating)
-            .await
-            .map_err(|err| Error::Ratings {
-                source: err,
-                back: Backtrace::new(),
-            })?;
-
-        Ok(())
-    }
-
-    /// Handle `setpc': "PC( TRACK)?"
-    async fn setpc(&self, msg: &str, client: &mut Client, state: &PlayerStatus) -> Result<()> {
-        let text = msg.trim();
-        let (pc, track) = match text.find(char::is_whitespace) {
-            Some(idx) => (
-                text[..idx]
-                    .parse::<usize>()
-                    .map_err(|err| Error::ExpectedInt {
-                        source: err,
-                        text: String::from(text),
-                        back: Backtrace::new(),
-                    })?,
-                &text[idx + 1..],
-            ),
-            None => (
-                text.parse::<usize>().map_err(|err| Error::ExpectedInt {
-                    source: err,
-                    text: String::from(text),
-                    back: Backtrace::new(),
-                })?,
-                "",
-            ),
-        };
-        let file = if track.is_empty() {
-            match state {
-                PlayerStatus::Stopped => {
-                    return Err(Error::PlayerStopped {});
-                }
-                PlayerStatus::Play(curr) | PlayerStatus::Pause(curr) => curr
-                    .file
-                    .to_str()
-                    .ok_or_else(|| Error::BadPath {
-                        pth: curr.file.clone(),
-                    })?
-                    .to_string(),
-            }
-        } else {
-            track.to_string()
-        };
-
-        play_count::set(client, &file, pc)
-            .await
-            .map_err(|err| Error::Playcount {
-                source: err,
-                back: Backtrace::new(),
-            })?;
-
-        Ok(())
-    }
-
-    /// Handle `setlp': "LASTPLAYED( TRACK)?"
-    async fn setlp(&self, msg: &str, client: &mut Client, state: &PlayerStatus) -> Result<()> {
-        let text = msg.trim();
-        let (lp, track) = match text.find(char::is_whitespace) {
-            Some(idx) => (
-                text[..idx]
-                    .parse::<u64>()
-                    .map_err(|err| Error::ExpectedInt {
-                        source: err,
-                        text: String::from(text),
-                        back: Backtrace::new(),
-                    })?,
-                &text[idx + 1..],
-            ),
-            None => (
-                text.parse::<u64>().map_err(|err| Error::ExpectedInt {
-                    source: err,
-                    text: String::from(text),
-                    back: Backtrace::new(),
-                })?,
-                "",
-            ),
-        };
-
-        let file = if track.is_empty() {
-            match state {
-                PlayerStatus::Stopped => {
-                    return Err(Error::PlayerStopped {});
-                }
-                PlayerStatus::Play(curr) | PlayerStatus::Pause(curr) => curr
-                    .file
-                    .to_str()
-                    .ok_or_else(|| Error::BadPath {
-                        pth: curr.file.clone(),
-                    })?
-                    .to_string(),
-            }
-        } else {
-            track.to_string()
-        };
-
-        last_played::set(client, &file, lp)
-            .await
-            .map_err(|err| Error::Playcount {
-                source: err,
-                back: Backtrace::new(),
-            })?;
-
-        Ok(())
-    }
-
     /// Handle `findadd': "FILTER [sort TYPE] [window START:END]"
     async fn findadd<'a>(
         &self,