fix: osekai api (#1115)

* fix: new badges endpoint

* perf: use compact format

* fix: new ranking endpoint

* fix: separate type for medal count entries

* fix: use inex subdomain

* refactor: rarity embed

* refactor: medal count embed

* refactor: remove unused ranking kinds

* perf: use compact medals

* feat: osekai ranking pagination

* fix: supposed incorrect page

* fix: medal retrieval

* chore: cargo fmt

* chore: cargo clippy

* test: remove

* chore: cargo clippy --all-targets

Author: MaxOhn

Cargo.lock

@@ -57,7 +57,7 @@ You can also join its [discord server](https://discord.gg/n9fFstG) to keep up wi
 - [5joshi](https://osu.ppy.sh/users/4279650) for these CRAZY GOOD button emotes :)
 - [Mr Helix](https://osu.ppy.sh/users/2330619) and his website [huismetbenen](https://snipe.huismetbenen.nl/) for providing snipe data (honorable mention [molneya](https://osu.ppy.sh/users/8945180))
 - [Piotrekol](https://osu.ppy.sh/users/304520) and [Ezoda](https://osu.ppy.sh/users/1231180) and their website [osustats](https://osustats.ppy.sh/) for providing leaderboard data
-- [mulraf](https://osu.ppy.sh/users/1309242), [Tanza](https://osu.ppy.sh/users/10379965), and the rest of the [osekai](https://osekai.net/) team for providing medal data
+- [mulraf](https://osu.ppy.sh/users/1309242), [Tanza](https://osu.ppy.sh/users/10379965), and the rest of the [osekai](https://inex.osekai.net/) team for providing medal data
 - [OMKelderman](https://osu.ppy.sh/users/2756335) and his [flag conversion](https://osuflags.omkserver.nl/) service
 - [respektive](https://osu.ppy.sh/users/1023489) for his [score rank api](https://github.com/respektive/osu-profile#score-rank-api), [osustats api](https://github.com/respektive/osustats), and various other contributions
 - [MasterIO](https://osu.ppy.sh/users/12297980) and [Wieku](https://osu.ppy.sh/users/2584698) for providing the option to render scores via [ordr](https://ordr.issou.best/)
@@ -105,4 +105,4 @@ The bot also has various features that can be enabled in compilation:
 - `server`: Runs a server on `localhost:{SERVER_PORT}` (specified in `.env`) and enables the link command. In order for linking and its authentication to succeed, you must configure the redirect URL in your osu! (and twitch) settings and set `PUBLIC_URL` in the `.env` accordingly. E.g for osu! you go to your profile settings, check the oauth section for your own clients, edit the Application Callback URL to `http://localhost:27272/auth/osu` and in your `.env` make sure you have `SERVER_PORT=27272` and `PUBLIC_URL="http://localhost:27272"`. The server also exposes a `/metrics` endpoint providing prometheus data. If you're interested in visualizing them, you need to install [prometheus](https://prometheus.io/download/), [configure it](https://prometheus.io/docs/introduction/first_steps/), install and configure [grafana](https://grafana.com/grafana/), then create a dashboard in grafana for the bathbot metrics.
 - `full`: Enables all of the above
 
-To enable these features, use e.g. `cargo run --features global_slash,server`
+To enable these features, use e.g. `cargo run --features global_slash,server`

README.md

@@ -32,6 +32,9 @@ tracing = { workspace = true }
 twilight-interactions = { workspace = true }
 twilight-model = { workspace = true }
 
+[dev-dependencies]
+dotenvy = { workspace = true }
+
 [features]
 default = []
 twitch = []

bathbot-client/Cargo.toml

@@ -1,49 +1,47 @@
+use std::num::NonZeroU8;
+
 use bathbot_model::{
-    OsekaiBadge, OsekaiBadgeOwner, OsekaiBadgeOwners, OsekaiComment, OsekaiInex, OsekaiMap,
-    OsekaiMedal, OsekaiRanking, OsekaiRankingEntries,
+    CompactWrap, MedalCount, OsekaiBadge, OsekaiBadges, OsekaiComment, OsekaiInex, OsekaiMap,
+    OsekaiMedal, OsekaiRanking, OsekaiRankingEntries, OsekaiRankingEntry, OsekaiRarityEntry,
+    OsekaiUserEntry, Rarity,
 };
 use eyre::{Result, WrapErr};
+use serde::Serialize;
+
+use crate::{Client, site::Site};
 
-use crate::{Client, multipart::Multipart, site::Site};
+const RANKING_PER_PAGE: usize = 50;
 
 impl Client {
     /// Don't use this; use `RedisManager::badges` instead.
+    ///
+    /// When `compress` is `true`, the API returns a compressed object format:
+    /// `{"content": {"_t":true,"k":[...],"d":[...]}}`
     pub async fn get_osekai_badges(&self) -> Result<Vec<OsekaiBadge>> {
-        let url = "https://osekai.net/badges/api/getBadges.php";
-
-        let bytes = self.make_get_request(url, Site::Osekai).await?;
-
-        serde_json::from_slice(&bytes).wrap_err_with(|| {
-            let body = String::from_utf8_lossy(&bytes);
-
-            format!("Failed to deserialize: {body}")
-        })
-    }
+        let url = "https://inex.osekai.net/api/badges/get_all?compress=true";
 
-    pub async fn get_osekai_badge_owners(&self, badge_id: u32) -> Result<Vec<OsekaiBadgeOwner>> {
-        let url = format!("https://osekai.net/badges/api/getUsers.php?badge_id={badge_id}");
         let bytes = self.make_get_request(url, Site::Osekai).await?;
 
-        let OsekaiBadgeOwners(owners) = serde_json::from_slice(&bytes).wrap_err_with(|| {
-            let body = String::from_utf8_lossy(&bytes);
-
-            format!("Failed to deserialize: {body}")
-        })?;
+        serde_json::from_slice::<OsekaiInex<OsekaiBadges>>(&bytes)
+            .map(|inex| inex.content.0)
+            .wrap_err_with(|| {
+                let body = String::from_utf8_lossy(&bytes);
 
-        Ok(owners)
+                format!("Failed to deserialize: {body}")
+            })
     }
 
     /// Don't use this; use `RedisManager::medals` instead.
     ///
     /// Medals will be sorted by medal id.
     pub async fn get_osekai_medals(&self) -> Result<Vec<OsekaiMedal>> {
-        let url = "https://inex.osekai.net/api/medals/get_all";
+        let url = "https://inex.osekai.net/api/medals/get_all?compress=true";
 
         let bytes = self.make_get_request(url, Site::Osekai).await?;
 
-        serde_json::from_slice::<OsekaiInex<Vec<OsekaiMedal>>>(&bytes)
+        serde_json::from_slice::<OsekaiInex<CompactWrap<OsekaiMedal>>>(&bytes)
             .map(|inex| {
-                let mut medals = inex.content;
+                let mut medals = inex.content.0;
                 medals.sort_unstable_by_key(|medal| medal.medal_id);
 
                 medals
@@ -56,12 +54,12 @@ impl Client {
     }
 
     pub async fn get_osekai_beatmaps(&self, medal_id: u32) -> Result<Vec<OsekaiMap>> {
-        let url = format!("https://inex.osekai.net/api/medals/{medal_id}/beatmaps");
+        let url = format!("https://inex.osekai.net/api/medals/{medal_id}/beatmaps?compress=true");
 
         let bytes = self.make_get_request(url, Site::Osekai).await?;
 
-        serde_json::from_slice::<OsekaiInex<Vec<OsekaiMap>>>(&bytes)
-            .map(|inex| inex.content)
+        serde_json::from_slice::<OsekaiInex<CompactWrap<OsekaiMap>>>(&bytes)
+            .map(|inex| inex.content.0)
             .wrap_err_with(|| {
                 let body = String::from_utf8_lossy(&bytes);
 
@@ -70,12 +68,14 @@ impl Client {
     }
 
     pub async fn get_osekai_comments(&self, medal_id: u32) -> Result<Vec<OsekaiComment>> {
-        let url = format!("https://inex.osekai.net/api/comments/Medals_Data/{medal_id}/get");
+        let url = format!(
+            "https://inex.osekai.net/api/comments/Medals_Data/{medal_id}/get?compress=true"
+        );
 
         let bytes = self.make_get_request(url, Site::Osekai).await?;
 
-        serde_json::from_slice::<OsekaiInex<Vec<OsekaiComment>>>(&bytes)
-            .map(|inex| inex.content)
+        serde_json::from_slice::<OsekaiInex<CompactWrap<OsekaiComment>>>(&bytes)
+            .map(|inex| inex.content.0)
             .wrap_err_with(|| {
                 let body = String::from_utf8_lossy(&bytes);
 
@@ -84,22 +84,163 @@ impl Client {
     }
 
     /// Don't use this; use `RedisManager::osekai_ranking` instead.
-    pub async fn get_osekai_ranking<R: OsekaiRanking>(&self) -> Result<Vec<R::Entry>> {
-        let url = "https://osekai.net/rankings/api/api.php";
+    pub async fn get_osekai_ranking(
+        &self,
+        ranking_kind: &str,
+        ranking_options_kind: Option<&str>,
+        country: Option<&str>,
+        page: NonZeroU8,
+    ) -> Result<OsekaiRankingEntries<OsekaiRankingEntry>> {
+        let url = "https://inex.osekai.net/api/rankings/get";
+
+        let mut body = OsekaiRankingBody::new(ranking_kind);
+
+        if let Some(options_kind) = ranking_options_kind {
+            body.with_option_kind(options_kind);
+        }
+
+        if let Some(country) = country {
+            body.with_country(country);
+        }
+
+        let offset = usize::from(page.get() - 1) * RANKING_PER_PAGE;
+        let json = serde_json::to_vec(body.with_offset(offset)).unwrap();
+        let bytes = self.make_json_post_request(url, Site::Osekai, json).await?;
+
+        serde_json::from_slice::<OsekaiInex<OsekaiRankingEntries<OsekaiRankingEntry>>>(&bytes)
+            .map(|inex| inex.content)
+            .wrap_err_with(|| {
+                let body = String::from_utf8_lossy(&bytes);
+
+                format!("Failed to deserialize: {body}")
+            })
+    }
 
-        let mut form = Multipart::new();
-        form.push_text("App", R::FORM);
+    /// Don't use this; use `RedisManager::osekai_medal_count` instead.
+    pub async fn get_osekai_medal_count(
+        &self,
+        country: Option<&str>,
+        page: NonZeroU8,
+    ) -> Result<OsekaiRankingEntries<OsekaiUserEntry>> {
+        let url = "https://inex.osekai.net/api/rankings/get";
 
-        let bytes = self
-            .make_multipart_post_request(url, Site::Osekai, form)
-            .await?;
+        let mut body = OsekaiRankingBody::new(MedalCount::KIND);
 
-        serde_json::from_slice::<OsekaiRankingEntries<R>>(&bytes)
-            .map(Vec::from)
+        if let Some(country) = country {
+            body.with_country(country);
+        }
+
+        let offset = usize::from(page.get() - 1) * RANKING_PER_PAGE;
+        let json = serde_json::to_vec(body.with_offset(offset)).unwrap();
+        let bytes = self.make_json_post_request(url, Site::Osekai, json).await?;
+
+        serde_json::from_slice::<OsekaiInex<OsekaiRankingEntries<OsekaiUserEntry>>>(&bytes)
+            .map(|inex| inex.content)
             .wrap_err_with(|| {
                 let body = String::from_utf8_lossy(&bytes);
 
                 format!("Failed to deserialize: {body}")
             })
     }
+
+    /// Don't use this; use `RedisManager::osekai_rarity` instead.
+    ///
+    /// Requests *all* pages and returns the full list. This is acceptable
+    /// because there are only ~400 medals which means 8-9 requests if there are
+    /// 50 medals per page.
+    pub async fn get_osekai_rarity(&self) -> Result<Vec<OsekaiRarityEntry>> {
+        let url = "https://inex.osekai.net/api/rankings/get";
+
+        let mut entries = Vec::with_capacity(512);
+
+        let mut offset = 0;
+        let mut body = OsekaiRankingBody::new(Rarity::KIND);
+
+        let mut json_buf = Vec::with_capacity(128);
+
+        loop {
+            body.with_offset(offset);
+            serde_json::to_writer(&mut json_buf, &body).unwrap();
+
+            let bytes = self
+                .make_json_post_request(url, Site::Osekai, json_buf.clone())
+                .await?;
+
+            let inex: OsekaiInex<OsekaiRankingEntries<OsekaiRarityEntry>> =
+                serde_json::from_slice(&bytes).wrap_err_with(|| {
+                    let body = String::from_utf8_lossy(&bytes);
+
+                    format!("Failed to deserialize: {body}")
+                })?;
+
+            if inex.content.data.is_empty() {
+                break;
+            }
+
+            offset += inex.content.data.len();
+
+            entries.extend(inex.content.data);
+
+            if entries.len() >= inex.content.max as usize {
+                break;
+            }
+
+            json_buf.clear();
+        }
+
+        Ok(entries)
+    }
+}
+
+#[derive(Serialize)]
+struct OsekaiRankingBody<'a> {
+    compress: bool,
+    offset: usize,
+    options: OsekaiRankingBodyOptions<'a>,
+    #[serde(rename = "type")]
+    kind: &'a str,
+}
+
+#[derive(Serialize)]
+struct OsekaiRankingBodyOptions<'a> {
+    #[serde(rename = "queryColumn", skip_serializing_if = "Option::is_none")]
+    query_column: Option<&'static str>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    query: Option<&'a str>,
+    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
+    kind: Option<&'a str>,
+}
+
+impl<'a> OsekaiRankingBody<'a> {
+    const fn new(kind: &'a str) -> Self {
+        Self {
+            compress: true,
+            offset: 0,
+            options: OsekaiRankingBodyOptions {
+                query_column: None,
+                query: None,
+                kind: None,
+            },
+            kind,
+        }
+    }
+
+    const fn with_offset(&mut self, offset: usize) -> &mut Self {
+        self.offset = offset;
+
+        self
+    }
+
+    const fn with_country(&mut self, country: &'a str) -> &mut Self {
+        self.options.query = Some(country);
+        self.options.query_column = Some("Country");
+
+        self
+    }
+
+    const fn with_option_kind(&mut self, kind: &'a str) -> &mut Self {
+        self.options.kind = Some(kind);
+
+        self
+    }
 }

bathbot-client/src/osekai.rs

@@ -290,6 +290,7 @@ pub(super) mod datetime_rfc3339 {
         }
     }
 }
+
 pub(super) mod option_datetime_rfc3339 {
     use super::{datetime_rfc3339::DateTimeVisitor, *};