feat: add image for medal icons (#1039)

Author: MaxOhn

Cargo.lock

@@ -24,6 +24,7 @@ http-body-util = { version = "0.1.2" }
 hyper = { version = "1.6.0", default-features = false }
 hyper-rustls = { version = "0.27.5", default-features = false, features = ["http2", "tls12", "webpki-roots"] }
 hyper-util = { version = "0.1.10", default-features = false, features = ["client", "client-legacy", "http2", "tokio"] }
+memchr = { version = "2.7.4" }
 metrics = { version = "0.24.1" }
 metrics-exporter-prometheus = { version = "0.16.2", default-features = false }
 metrics-util = { version = "0.19.0" }

Cargo.toml

@@ -42,6 +42,22 @@ impl Cache {
         Ok(Ok(CachedArchive::new(bytes)?))
     }
 
+    pub async fn fetch_raw<K>(
+        &self,
+        key: &K,
+    ) -> Result<Result<Vec<u8>, CacheConnection>, FetchError>
+    where
+        K: ToCacheKey + ?Sized,
+    {
+        let mut conn = self.connection().await?;
+
+        let Some(bytes) = conn.get(RedisKey::from(key)).await? else {
+            return Ok(Err(CacheConnection(conn)));
+        };
+
+        Ok(Ok(bytes))
+    }
+
     async fn fetch_discord_type<T>(&self, key: RedisKey<'_>) -> FetchResult<T>
     where
         T: Portable + Portable + for<'a> CheckBytes<ValidatorStrategy<'a>>,

bathbot-cache/src/cache/fetch.rs

@@ -56,6 +56,17 @@ impl Cache {
         Self::store(&mut conn, key, bytes, expire_seconds).await
     }
 
+    /// Store bytes through a new connection without expiration.
+    pub async fn store_forever<K>(&self, key: &K, bytes: &[u8]) -> Result<()>
+    where
+        K: ToCacheKey + ?Sized,
+    {
+        let mut conn = self.connection().await?;
+        let key = RedisKey::from(key);
+
+        conn.set(key, bytes).await.map_err(Report::new)
+    }
+
     /// Insert a value into a set.
     ///
     /// Returns whether the value was newly inserted. That is:

bathbot-cache/src/cache/store.rs

@@ -16,6 +16,7 @@ hyper-rustls = { workspace = true }
 hyper-util = { workspace = true }
 itoa = { version = "1.0.9", default-features = false }
 leaky-bucket-lite = { version = "0.5", features = ["parking_lot"] }
+memchr = { workspace = true }
 metrics = { workspace = true }
 rand = { version = "0.8" }
 rosu-v2 = { workspace = true }
@@ -33,4 +34,4 @@ twilight-model = { workspace = true }
 
 [features]
 default = []
-twitch = []
+twitch = []

bathbot-client/Cargo.toml

@@ -1,6 +1,7 @@
-use bathbot_util::constants::OSU_BASE;
+use bathbot_model::{ScrapedMedal, ScrapedUser};
+use bathbot_util::{constants::OSU_BASE, html::decode_html_entities};
 use bytes::Bytes;
-use eyre::{Report, Result, WrapErr};
+use eyre::{ContextCompat, Report, Result, WrapErr};
 use http::response::Parts;
 use hyper::{Request, header::USER_AGENT};
 
@@ -50,6 +51,38 @@ impl Client {
             .map_err(Report::new)
     }
 
+    pub async fn get_medal_icon(&self, url: &str) -> Result<Bytes> {
+        self.make_get_request(url, Site::OsuMedalIcon)
+            .await
+            .map_err(Report::new)
+    }
+
+    /// Don't use this; use `RedisManager::scraped_medals` instead.
+    pub async fn get_medals(&self) -> Result<Box<[ScrapedMedal]>> {
+        const KEY: &str = "data-initial-data=";
+
+        let bytes = self.peppy_profile().await?;
+        let data = std::str::from_utf8(&bytes)?;
+        let start = data.find(KEY).wrap_err("missing key")? + KEY.len() + 1;
+        let end = memchr::memchr(b'"', &bytes[start..]).wrap_err("missing end quote")? + start;
+
+        let data_initial_data = &data[start..end];
+        let decoded = decode_html_entities(data_initial_data);
+
+        let ScrapedUser { medals } = serde_json::from_str(&decoded)
+            .wrap_err_with(|| format!("Failed to deserialize: {decoded}"))?;
+
+        Ok(medals)
+    }
+
+    async fn peppy_profile(&self) -> Result<Bytes> {
+        let url = "https://osu.ppy.sh/users/2";
+
+        self.make_get_request(url, Site::OsuProfile)
+            .await
+            .map_err(Report::new)
+    }
+
     /// Make sure you provide a valid url to a mapset cover
     pub async fn get_mapset_cover(&self, cover: &str) -> Result<Bytes> {
         self.make_get_request(&cover, Site::OsuMapsetCover)

bathbot-client/src/osu.rs

@@ -62,6 +62,8 @@ sites! {
     OsuBadge -> 10,
     OsuMapFile -> 2,
     OsuMapsetCover -> 10,
+    OsuMedalIcon -> 25,
+    OsuProfile -> 1,
     OsuStats -> 2,
     OsuTrack -> 2,
     Relax -> 2,

bathbot-client/src/site.rs

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

bathbot-model/src/lib.rs

@@ -0,0 +1,32 @@
+use rkyv::{niche::niching::Null, with::NicheInto};
+use serde::{Deserialize, Deserializer};
+
+#[derive(Deserialize)]
+pub struct ScrapedUser {
+    #[serde(rename = "achievements")]
+    pub medals: Box<[ScrapedMedal]>,
+}
+
+#[derive(Debug, Deserialize, rkyv::Archive, rkyv::Serialize)]
+pub struct ScrapedMedal {
+    pub icon_url: Box<str>,
+    pub id: u16,
+    pub name: Box<str>,
+    pub grouping: Box<str>,
+    pub ordering: u8,
+    pub description: Box<str>,
+    #[serde(default, deserialize_with = "deser_mode")]
+    #[rkyv(with = NicheInto<Null>)]
+    pub mode: Option<Box<str>>,
+    #[rkyv(with = NicheInto<Null>)]
+    pub instructions: Option<Box<str>>,
+}
+
+fn deser_mode<'de, D: Deserializer<'de>>(d: D) -> Result<Option<Box<str>>, D::Error> {
+    match Option::<&str>::deserialize(d) {
+        Ok(Some("fruits")) => Ok(Some(Box::from("catch"))),
+        Ok(Some(mode)) => Ok(Some(Box::from(mode))),
+        Ok(None) => Ok(None),
+        Err(err) => Err(err),
+    }
+}

bathbot-model/src/osu.rs

@@ -5,6 +5,7 @@ authors.workspace = true
 edition.workspace = true
 
 [dependencies]
+memchr = { workspace = true }
 metrics = { workspace = true }
 metrics-util = { workspace = true }
 regex = { version = "1.0" }