Add mod status badges + abbreviate query param on mod info (#63)

Author: TreehouseFalcon

Cargo.lock

@@ -43,4 +43,5 @@ thiserror = "2.0.12"
 moka = { version = "0.12.13", features = ["future"] }
 utoipa = { version = "5.4.0", features = ["actix_extras", "chrono", "uuid"] }
 utoipa-swagger-ui = { version = "9.0.2", features = ["actix-web"] }
+urlencoding = "2.1.3"
 validator = { version = "0.20.0", features = ["derive"] }

Cargo.toml

@@ -0,0 +1,16 @@
+const ONE_THOUSAND: f64 = 1_000.0;
+const ONE_MILLION: f64 = 1_000_000.0;
+const ONE_BILLION: f64 = 1_000_000_000.0;
+
+pub fn abbreviate_number(n: i32) -> String {
+    let n = n as f64;
+    if n.abs() >= ONE_BILLION {
+        format!("{:.1}B", n / ONE_BILLION)
+    } else if n.abs() >= ONE_MILLION {
+        format!("{:.1}M", n / ONE_MILLION)
+    } else if n.abs() >= ONE_THOUSAND {
+        format!("{:.1}K", n / ONE_THOUSAND)
+    } else {
+        format!("{:.0}", n)
+    }
+}

src/abbreviate.rs

@@ -43,7 +43,7 @@ impl ModVersionRow {
             geode: self.geode,
             early_load: self.early_load,
             requires_patching: self.requires_patching,
-            download_count: self.download_count,
+            download_count: self.download_count.into(),
             api: self.api,
             mod_id: self.mod_id,
             status: self.status,
@@ -224,7 +224,7 @@ pub async fn create_from_json(
         download_link: row.download_link,
         hash: row.hash,
         geode: geode.to_string(),
-        download_count: 0,
+        download_count: 0.into(),
         early_load: row.early_load,
         requires_patching: row.requires_patching,
         api: row.api,
@@ -333,7 +333,7 @@ pub async fn update_pending_version(
         download_link: row.download_link,
         hash: row.hash,
         geode: geode.to_string(),
-        download_count: row.download_count,
+        download_count: row.download_count.into(),
         early_load: row.early_load,
         requires_patching: row.requires_patching,
         api: row.api,

src/database/repository/mod_versions.rs

@@ -26,7 +26,7 @@ impl ModRecordGetOne {
             id: self.id,
             repository: self.repository,
             featured: self.featured,
-            download_count: self.download_count,
+            download_count: self.download_count.into(),
             versions: Default::default(),
             tags: Default::default(),
             developers: Default::default(),

src/database/repository/mods.rs

@@ -9,6 +9,7 @@ pub mod developers;
 pub mod health;
 pub mod loader;
 pub mod mod_versions;
+pub mod mod_status_badge;
 pub mod mods;
 pub mod stats;
 pub mod tags;

src/endpoints/mod.rs

@@ -0,0 +1,88 @@
+use crate::config::AppData;
+use crate::endpoints::ApiError;
+use actix_web::{HttpResponse, Responder, get, web};
+use serde::Deserialize;
+use utoipa::{IntoParams, ToSchema};
+
+use std::fs;
+use std::path::Path;
+use urlencoding;
+
+const LABEL_COLOR: &str = "#0c0811";
+const STAT_COLOR: &str = "#5f3d84";
+
+#[derive(Deserialize, Clone, Copy, PartialEq, Eq, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum StatusBadgeStat {
+    Version,
+    GdVersion,
+    GeodeVersion,
+    Downloads,
+}
+
+#[derive(Deserialize, IntoParams)]
+pub struct StatusBadgeQuery {
+    pub stat: StatusBadgeStat,
+}
+
+#[utoipa::path(
+    get,
+    path = "/v1/mods/{id}/status_badge",
+    tag = "mods",
+    params(
+        ("id" = String, Path, description = "Mod ID"),
+        StatusBadgeQuery
+    ),
+    responses(
+        (status = 302, description = "Redirect to Shields.io badge"),
+        (status = 400, description = "Invalid stat or missing parameter"),
+        (status = 404, description = "Mod not found")
+    )
+)]
+#[get("/v1/mods/{id}/status_badge")]
+pub async fn status_badge(
+    data: web::Data<AppData>,
+    id: web::Path<String>,
+    query: web::Query<StatusBadgeQuery>,
+) -> Result<impl Responder, ApiError> {
+    let (stat, label, svg_path) = match query.stat {
+        StatusBadgeStat::Version => (
+            "payload.versions[0].version",
+            "Version",
+            "storage/public/shields/mod_version.svg",
+        ),
+        StatusBadgeStat::GdVersion => (
+            "payload.versions[0].gd.win",
+            "Geometry Dash",
+            "storage/public/shields/mod_gd_version.svg",
+        ),
+        StatusBadgeStat::GeodeVersion => (
+            "payload.versions[0].geode",
+            "Geode",
+            "storage/public/shields/mod_geode_version.svg",
+        ),
+        StatusBadgeStat::Downloads => (
+            "payload.download_count",
+            "Downloads",
+            "storage/public/shields/mod_downloads.svg",
+        ),
+    };
+    let svg = fs::read_to_string(Path::new(svg_path))
+        .map_err(|_| ApiError::BadRequest(format!("Could not read SVG file: {}", svg_path)))?;
+    let api_url = format!("{}/v1/mods/{}?abbreviate=true", data.app_url(), id);
+    let mod_link = format!("{}/mods/{}", data.front_url(), id);
+    let svg_data_url = format!("data:image/svg+xml;utf8,{}", urlencoding::encode(&svg));
+    let shields_url = format!(
+        "https://img.shields.io/badge/dynamic/json?url={}&query={}&label={}&labelColor={}&color={}&link={}&style=plastic&logo={}",
+        urlencoding::encode(&api_url),
+        urlencoding::encode(stat),
+        label,
+        urlencoding::encode(LABEL_COLOR),
+        urlencoding::encode(STAT_COLOR),
+        urlencoding::encode(&mod_link),
+        urlencoding::encode(&svg_data_url)
+    );
+    Ok(HttpResponse::Found()
+        .append_header(("Location", shields_url))
+        .finish())
+}

src/endpoints/mod_status_badge.rs

@@ -1,3 +1,7 @@
+#[derive(Deserialize, ToSchema)]
+pub struct ModGetQueryParams {
+    pub abbreviate: Option<bool>,
+}
 use crate::config::AppData;
 use crate::database::repository::developers;
 use crate::database::repository::incompatibilities;
@@ -126,6 +130,7 @@ pub async fn index(
 pub async fn get(
     data: web::Data<AppData>,
     id: web::Path<String>,
+    query: web::Query<ModGetQueryParams>,
     auth: Auth,
 ) -> Result<impl Responder, ApiError> {
     let dev = auth.developer().ok();
@@ -171,6 +176,8 @@ pub async fn get(
         i.modify_metadata(data.app_url(), has_extended_permissions);
     }
 
+    the_mod.set_abbreviated_download_counts(query.abbreviate.unwrap_or(false));
+
     Ok(web::Json(ApiResponse {
         error: "".into(),
         payload: the_mod,

src/endpoints/mods.rs

@@ -9,6 +9,7 @@ use actix_web::{
 use utoipa::OpenApi;
 use utoipa_swagger_ui::SwaggerUi;
 
+mod abbreviate;
 mod auth;
 mod cli;
 mod config;
@@ -65,6 +66,7 @@ async fn main() -> anyhow::Result<()> {
             .service(endpoints::mods::create)
             .service(endpoints::mods::update_mod)
             .service(endpoints::mods::get_logo)
+            .service(endpoints::mod_status_badge::status_badge)
             .service(endpoints::mod_versions::get_version_index)
             .service(endpoints::mod_versions::get_one)
             .service(endpoints::mod_versions::download_version)

src/main.rs

@@ -0,0 +1,40 @@
+use crate::abbreviate::abbreviate_number;
+use serde::{Serialize, Serializer};
+
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub struct DownloadCount {
+    count: i32,
+    abbreviate: bool,
+}
+
+impl DownloadCount {
+    pub const fn new(count: i32) -> Self {
+        Self {
+            count,
+            abbreviate: false,
+        }
+    }
+
+    pub fn set_abbreviated(&mut self, abbreviate: bool) {
+        self.abbreviate = abbreviate;
+    }
+}
+
+impl From<i32> for DownloadCount {
+    fn from(count: i32) -> Self {
+        Self::new(count)
+    }
+}
+
+impl Serialize for DownloadCount {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        if self.abbreviate {
+            serializer.serialize_str(&abbreviate_number(self.count))
+        } else {
+            serializer.serialize_i32(self.count)
+        }
+    }
+}