Merge pull request #952 from Chiffario/897-relax-vault

feat: initial API implementation for Relaxation Vault integration

Author: MaxOhn

bathbot-client/src/client.rs

@@ -26,7 +26,7 @@ pub struct Client {
     #[cfg(feature = "twitch")]
     twitch: bathbot_model::TwitchData,
     github_auth: Box<str>,
-    ratelimiters: [LeakyBucket; 16],
+    ratelimiters: [LeakyBucket; 17],
 }
 
 impl Client {
@@ -79,6 +79,7 @@ impl Client {
             ratelimiter(2),  // OsuStats
             ratelimiter(2),  // OsuTrack
             ratelimiter(2),  // OsuWorld
+            ratelimiter(2),  // Relaxation Vault
             ratelimiter(1),  // Respektive
             ratelimiter(5),  // Twitch
         ];

bathbot-client/src/lib.rs

@@ -15,6 +15,7 @@ mod osekai;
 mod osu;
 mod osustats;
 mod osutrack;
+mod relax;
 mod respektive;
 mod site;
 mod snipe;

bathbot-client/src/relax.rs

@@ -0,0 +1,99 @@
+use bathbot_model::{RelaxPlayersDataResponse, RelaxScore};
+use bathbot_util::constants::RELAX_API;
+use eyre::{Result, WrapErr};
+use rosu_v2::prelude::CountryCode;
+
+use crate::{Client, site::Site};
+
+impl Client {
+    /// /api/scores
+    /// GET relax score leaderboard (a.k.a. highest pp relax scores)
+    pub async fn get_relax_score_leaderboard(&self) -> Result<Vec<RelaxScore>> {
+        let url = format!("{RELAX_API}/scores");
+
+        let bytes = self.make_get_request(url, Site::Relax).await?;
+
+        serde_json::from_slice(&bytes).wrap_err_with(|| {
+            let body = String::from_utf8_lossy(&bytes);
+
+            format!("failed to deserialize relax top scores: {body}")
+        })
+    }
+
+    /// /api/scores/{id}
+    /// GET relax score by its ID
+    pub async fn get_relax_scores(&self, score_id: u32) -> Result<Vec<RelaxScore>> {
+        let url = format!("{RELAX_API}/scores/{score_id}");
+
+        let bytes = self.make_get_request(url, Site::Relax).await?;
+
+        serde_json::from_slice(&bytes).wrap_err_with(|| {
+            let body = String::from_utf8_lossy(&bytes);
+
+            format!("failed to deserialize player's relax scores: {body}")
+        })
+    }
+
+    /// /api/players
+    /// GET Relax player list
+    /// Ordered by total pp
+    /// page: page index
+    /// country_code: country code to get country leaderboards
+    /// search: search query
+    pub async fn get_relax_players(
+        &self,
+        page: Option<u32>,
+        country_code: Option<CountryCode>,
+        search: Option<String>,
+    ) -> Result<RelaxPlayersDataResponse> {
+        let mut url = format!("{RELAX_API}/players");
+
+        if let Some(p) = page {
+            url.push_str(&format!("page={p}&"));
+        }
+
+        if let Some(cc) = country_code {
+            url.push_str(&format!("countryCode={cc}&"));
+        }
+
+        if let Some(q) = search {
+            url.push_str(&format!("search={q}&"));
+        }
+
+        let bytes = self.make_get_request(url, Site::Relax).await?;
+
+        serde_json::from_slice(&bytes).wrap_err_with(|| {
+            let body = String::from_utf8_lossy(&bytes);
+
+            format!("failed to deserialize relax players: {body}")
+        })
+    }
+
+    /// /api/players/{id}
+    /// GET Relax player by osu! ID
+    pub async fn get_relax_player(&self, user_id: u32) -> Result<Option<RelaxPlayersDataResponse>> {
+        let url = format!("{RELAX_API}/players/{user_id}");
+
+        let bytes = self.make_get_request(url, Site::Relax).await?;
+
+        serde_json::from_slice(&bytes).wrap_err_with(|| {
+            let body = String::from_utf8_lossy(&bytes);
+
+            format!("failed to deserialize relax player: {body}")
+        })
+    }
+
+    /// /api/players/{id}/scores
+    /// GET all relax scores set by a player
+    pub async fn get_relax_player_scores(&self, user_id: u32) -> Result<Vec<RelaxScore>> {
+        let url = format!("{RELAX_API}/players/{user_id}/scores");
+
+        let bytes = self.make_get_request(url, Site::Relax).await?;
+
+        serde_json::from_slice(&bytes).wrap_err_with(|| {
+            let body = String::from_utf8_lossy(&bytes);
+
+            format!("failed to deserialize relax player scores: {body}")
+        })
+    }
+}

bathbot-client/src/site.rs

@@ -14,6 +14,7 @@ pub enum Site {
     OsuMapsetCover,
     OsuStats,
     OsuTrack,
+    Relax,
     Respektive,
     Twitch,
 }
@@ -35,6 +36,7 @@ impl Site {
             Self::OsuStats => "OsuStats",
             Self::OsuTrack => "OsuTrack",
             Self::Respektive => "Respektive",
+            Self::Relax => "Relax",
             Self::Twitch => "Twitch",
         }
     }

bathbot-model/src/deser.rs

@@ -217,7 +217,7 @@ pub(super) mod datetime_rfc3339 {
         d.deserialize_str(DateTimeVisitor)
     }
 
-    struct DateTimeVisitor;
+    pub(crate) struct DateTimeVisitor;
 
     impl Visitor<'_> for DateTimeVisitor {
         type Value = OffsetDateTime;
@@ -233,6 +233,40 @@ pub(super) mod datetime_rfc3339 {
         }
     }
 }
+pub(super) mod option_datetime_rfc3339 {
+    use super::{datetime_rfc3339::DateTimeVisitor, *};
+
+    pub fn deserialize<'de, D: Deserializer<'de>>(
+        d: D,
+    ) -> Result<Option<OffsetDateTime>, D::Error> {
+        d.deserialize_option(OptionDateTimeVisitor)
+    }
+
+    struct OptionDateTimeVisitor;
+
+    impl<'de> Visitor<'de> for OptionDateTimeVisitor {
+        type Value = Option<OffsetDateTime>;
+
+        fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.write_str("an optional RFC3339 datetime string ending on `Z`")
+        }
+
+        #[inline]
+        fn visit_some<D: Deserializer<'de>>(self, d: D) -> Result<Self::Value, D::Error> {
+            d.deserialize_str(DateTimeVisitor).map(Some)
+        }
+
+        #[inline]
+        fn visit_none<E: Error>(self) -> Result<Self::Value, E> {
+            self.visit_unit()
+        }
+
+        #[inline]
+        fn visit_unit<E: Error>(self) -> Result<Self::Value, E> {
+            Ok(None)
+        }
+    }
+}
 
 pub(super) mod datetime_rfc2822 {
     use time::format_description::well_known::Rfc2822;

bathbot-model/src/lib.rs

@@ -9,6 +9,7 @@ mod osekai;
 mod osu_stats;
 mod osutrack;
 mod ranking_entries;
+mod relax;
 mod respektive;
 mod score_slim;
 mod twitch;
@@ -24,5 +25,5 @@ pub mod rkyv_util;
 pub use self::{
     country_code::*, deser::ModeAsSeed, either::Either, games::*, github::*, huismetbenen::*,
     kittenroleplay::*, osekai::*, osu_stats::*, osutrack::RankAccPeaks, ranking_entries::*,
-    respektive::*, score_slim::*, twitch::*, user_stats::*,
+    relax::*, respektive::*, score_slim::*, twitch::*, user_stats::*,
 };

bathbot-model/src/relax.rs

@@ -0,0 +1,161 @@
+use std::fmt::{Formatter, Result as FmtResult};
+
+use rosu_mods::{GameMod, GameMode, GameMods};
+use rosu_v2::model::Grade;
+use serde::{Deserialize, Deserializer, de};
+use time::OffsetDateTime;
+
+use crate::deser::{adjust_acc, datetime_rfc3339, option_datetime_rfc3339};
+
+fn deserialize_mods<'de, D: Deserializer<'de>>(d: D) -> Result<GameMods, D::Error> {
+    struct Visitor;
+
+    impl<'de> de::Visitor<'de> for Visitor {
+        type Value = GameMods;
+
+        fn expecting(&self, f: &mut Formatter) -> FmtResult {
+            f.write_str("mods")
+        }
+
+        fn visit_seq<A: de::SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {
+            let mut mods = GameMods::new();
+
+            while let Some(s) = seq.next_element::<&'de str>()? {
+                let (acronym, clock_rate) = s.split_once('x').unwrap_or((s, ""));
+
+                let mut gamemod = GameMod::new(acronym, GameMode::Osu);
+
+                match (!clock_rate.is_empty()).then(|| clock_rate.parse()) {
+                    None => {}
+                    Some(Ok(clock_rate)) => match gamemod {
+                        GameMod::DoubleTimeOsu(ref mut m) => m.speed_change = Some(clock_rate),
+                        GameMod::NightcoreOsu(ref mut m) => m.speed_change = Some(clock_rate),
+                        GameMod::HalfTimeOsu(ref mut m) => m.speed_change = Some(clock_rate),
+                        GameMod::DaycoreOsu(ref mut m) => m.speed_change = Some(clock_rate),
+                        _ => {}
+                    },
+                    Some(Err(_)) => {
+                        return Err(de::Error::custom(format!(
+                            "expected clock rate; got `{clock_rate}`"
+                        )));
+                    }
+                }
+
+                mods.insert(gamemod);
+            }
+
+            Ok(mods)
+        }
+    }
+
+    d.deserialize_seq(Visitor)
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RelaxScore {
+    pub id: u64,
+    pub user_id: u32,
+    // Comes as a null from /api/players/{user_id}/scores
+    pub user: Option<RelaxUser>,
+    pub beatmap_id: u32,
+    pub beatmap: RelaxBeatmap,
+    pub grade: Grade,
+    #[serde(with = "adjust_acc")]
+    pub accuracy: f32,
+    pub combo: u32,
+    #[serde(deserialize_with = "deserialize_mods")]
+    pub mods: GameMods,
+    #[serde(with = "datetime_rfc3339")]
+    pub date: OffsetDateTime,
+    pub total_score: u32,
+    pub count_50: u32,
+    pub count_100: u32,
+    pub count_300: u32,
+    pub count_miss: u32,
+    pub spinner_bonus: Option<u32>,
+    pub spinner_spins: Option<u32>,
+    pub legacy_slider_ends: Option<u32>,
+    pub slider_ticks: Option<u32>,
+    pub slider_ends: Option<u32>,
+    pub legacy_slider_end_misses: Option<u32>,
+    pub slider_tick_misses: Option<u32>,
+    pub pp: Option<f64>,
+    pub is_best: bool,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RelaxUser {
+    pub id: u32,
+    pub country_code: Option<String>,
+    pub username: Option<String>,
+    pub total_pp: Option<f64>,
+    pub total_accuracy: Option<f64>,
+    #[serde(with = "option_datetime_rfc3339")]
+    pub updated_at: Option<OffsetDateTime>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RelaxBeatmap {
+    pub id: u32,
+    pub artist: Option<String>,
+    pub title: Option<String>,
+    pub creator_id: u32,
+    pub beatmap_set_id: u32,
+    pub difficulty_name: Option<String>,
+    pub approach_rate: f64,
+    pub overall_difficulty: f64,
+    pub circle_size: f64,
+    pub health_drain: f64,
+    pub beats_per_minute: f64,
+    pub circles: u32,
+    pub sliders: u32,
+    pub spinners: u32,
+    pub star_rating_normal: f64,
+    pub star_rating: Option<f64>,
+    pub status: RelaxBeatmapStatus,
+    pub max_combo: u32,
+}
+
+#[derive(Debug, Deserialize)]
+pub enum RelaxBeatmapStatus {
+    Graveyard,
+    Wip,
+    Pending,
+    Ranked,
+    Approved,
+    Qualified,
+    Loved,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RelaxPlaycountPerMonth {
+    #[serde(with = "datetime_rfc3339")]
+    pub date: OffsetDateTime,
+    pub playcount: u32,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RelaxPlayersDataResponse {
+    pub id: u32,
+    pub country_code: Option<String>,
+    pub username: Option<String>,
+    pub total_pp: Option<f64>,
+    pub total_accuracy: Option<f64>,
+    #[serde(with = "option_datetime_rfc3339")]
+    pub updated_at: Option<OffsetDateTime>,
+    pub rank: Option<u32>,
+    pub country_rank: Option<u32>,
+    pub playcount: u32,
+    #[serde(rename = "countSS")]
+    pub count_ss: u32,
+    #[serde(rename = "countS")]
+    pub count_s: u32,
+    #[serde(rename = "countA")]
+    pub count_a: u32,
+    pub playcounts_per_month: Vec<RelaxPlaycountPerMonth>,
+}

bathbot-util/src/constants.rs

@@ -14,6 +14,9 @@ pub const OSU_BASE: &str = "https://osu.ppy.sh/";
 pub const MAP_THUMB_URL: &str = "https://b.ppy.sh/thumb/";
 pub const AVATAR_URL: &str = "https://a.ppy.sh/";
 pub const HUISMETBENEN: &str = "https://api.snipe.huismetbenen.nl/";
+pub const RELAX_API: &str = "https://rx.stanr.info/api";
+pub const RELAX: &str = "https://rx.stanr.info";
+pub const RELAX_ICON_URL: &str = "https://rx.stanr.info/rv-yellowlight-192.png";
 
 // twitch
 pub const TWITCH_BASE: &str = "https://www.twitch.tv/";

bathbot/src/active/impls/mod.rs

@@ -60,6 +60,7 @@ mod profile;
 mod ranking;
 mod ranking_countries;
 mod recent_list;
+pub mod relax;
 mod render;
 mod simulate;
 mod single_score;

bathbot/src/active/impls/relax/mod.rs

@@ -0,0 +1 @@
+pub mod top;