Address pr + improve serialization

Author: TreehouseFalcon

src/database/repository/mod_versions.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/mods.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/endpoints/mod.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_status_badge.rs

@@ -2,6 +2,7 @@ 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;
@@ -10,9 +11,18 @@ use urlencoding;
 const LABEL_COLOR: &str = "#0c0811";
 const STAT_COLOR: &str = "#5f3d84";
 
-#[derive(Deserialize)]
+#[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: String,
+    pub stat: StatusBadgeStat,
 }
 
 #[utoipa::path(
@@ -21,7 +31,7 @@ pub struct StatusBadgeQuery {
     tag = "mods",
     params(
         ("id" = String, Path, description = "Mod ID"),
-        ("stat" = String, Query, description = "Stat to display: version, gd_version, geode_version, downloads")
+        StatusBadgeQuery
     ),
     responses(
         (status = 302, description = "Redirect to Shields.io badge"),
@@ -31,40 +41,36 @@ pub struct StatusBadgeQuery {
 )]
 #[get("/v1/mods/{id}/status_badge")]
 pub async fn status_badge(
-    _data: web::Data<AppData>,
+    data: web::Data<AppData>,
     id: web::Path<String>,
     query: web::Query<StatusBadgeQuery>,
 ) -> Result<impl Responder, ApiError> {
-    let (stat, label, svg_path) = match query.stat.as_str() {
-        "version" => (
+    let (stat, label, svg_path) = match query.stat {
+        StatusBadgeStat::Version => (
             "payload.versions[0].version",
             "Version",
             "static/mod_version.svg",
         ),
-        "gd_version" => (
+        StatusBadgeStat::GdVersion => (
             "payload.versions[0].gd.win",
             "Geometry Dash",
             "static/mod_gd_version.svg",
         ),
-        "geode_version" => (
+        StatusBadgeStat::GeodeVersion => (
             "payload.versions[0].geode",
             "Geode",
             "static/mod_geode_version.svg",
         ),
-        "downloads" => (
+        StatusBadgeStat::Downloads => (
             "payload.download_count",
             "Downloads",
             "static/mod_downloads.svg",
         ),
-        _ => return Err(ApiError::BadRequest("Invalid stat parameter".into())),
     };
     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",
-        "http://api.geode-sdk.org", id
-    );
-    let mod_link = format!("https://geode-sdk.org/mods/{}", id);
+    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={}",

src/endpoints/mods.rs

@@ -2,7 +2,6 @@
 pub struct ModGetQueryParams {
     pub abbreviate: Option<bool>,
 }
-use crate::abbreviate::abbreviate_number;
 use crate::config::AppData;
 use crate::database::repository::developers;
 use crate::database::repository::incompatibilities;
@@ -27,9 +26,9 @@ use crate::types::models::mod_version_status::ModVersionStatusEnum;
 use crate::webhook::discord::DiscordWebhook;
 use actix_web::{HttpResponse, Responder, get, post, put, web};
 use serde::Deserialize;
-use serde::Serialize;
 use sqlx::Acquire;
 use utoipa::{IntoParams, ToSchema};
+use serde::Serialize;
 
 #[derive(Deserialize, Default, Hash, Eq, PartialEq, ToSchema)]
 #[serde(rename_all = "snake_case")]
@@ -176,31 +175,11 @@ pub async fn get(
         i.modify_metadata(data.app_url(), has_extended_permissions);
     }
 
-    // If abbreviate param is set, abbreviate download_count fields
-    let mut payload = serde_json::to_value(&the_mod).unwrap();
-    if query.abbreviate.unwrap_or(false) {
-        if let Some(obj) = payload.as_object_mut() {
-            obj.insert(
-                "download_count".to_string(),
-                serde_json::Value::String(abbreviate_number(the_mod.download_count)),
-            );
-            if let Some(versions) = obj.get_mut("versions").and_then(|v| v.as_array_mut()) {
-                for (i, v) in versions.iter_mut().enumerate() {
-                    if let Some(version_obj) = v.as_object_mut() {
-                        if let Some(dc) = the_mod.versions.get(i) {
-                            version_obj.insert(
-                                "download_count".to_string(),
-                                serde_json::Value::String(abbreviate_number(dc.download_count)),
-                            );
-                        }
-                    }
-                }
-            }
-        }
-    }
+    the_mod.set_abbreviated_download_counts(query.abbreviate.unwrap_or(false));
+
     Ok(web::Json(ApiResponse {
         error: "".into(),
-        payload,
+        payload: the_mod,
     }))
 }
 

src/main.rs

@@ -1,4 +1,3 @@
-use crate::endpoints::mod_status_badge::status_badge;
 use crate::openapi::ApiDoc;
 use crate::types::api;
 use actix_cors::Cors;
@@ -66,7 +65,7 @@ async fn main() -> anyhow::Result<()> {
             .service(endpoints::mods::create)
             .service(endpoints::mods::update_mod)
             .service(endpoints::mods::get_logo)
-            .service(status_badge)
+            .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/types/models/download_count.rs

@@ -0,0 +1,61 @@
+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)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::DownloadCount;
+
+    #[test]
+    fn serializes_as_number_by_default() {
+        let serialized = serde_json::to_string(&DownloadCount::new(1234)).unwrap();
+
+        assert_eq!(serialized, "1234");
+    }
+
+    #[test]
+    fn serializes_as_abbreviated_string_when_enabled() {
+        let mut count = DownloadCount::new(1234);
+        count.set_abbreviated(true);
+        let serialized = serde_json::to_string(&count).unwrap();
+
+        assert_eq!(serialized, "\"1.2K\"");
+    }
+}

src/types/models/mod.rs

@@ -1,4 +1,5 @@
 pub mod dependency;
+pub mod download_count;
 pub mod developer;
 pub mod github_login_attempt;
 pub mod incompatibility;

src/types/models/mod_entity.rs

@@ -1,5 +1,6 @@
 use super::{
     dependency::ResponseDependency,
+    download_count::DownloadCount,
     developer::ModDeveloper,
     incompatibility::{Replacement, ResponseIncompatibility},
     mod_gd_version::{DetailedGDVersion, GDVersionEnum, ModGDVersion, VerPlatform},
@@ -22,20 +23,21 @@ use crate::{
     },
 };
 use semver::Version;
-use serde::Serialize;
-use utoipa::ToSchema;
 use sqlx::{
     PgConnection,
     types::chrono::{DateTime, Utc},
 };
 use std::collections::HashMap;
+use serde::Serialize;
+use utoipa::ToSchema;
 
-#[derive(Serialize, Debug, Clone, sqlx::FromRow, ToSchema)]
+#[derive(Serialize, Debug, Clone, ToSchema)]
 pub struct Mod {
     pub id: String,
     pub repository: Option<String>,
     pub featured: bool,
-    pub download_count: i32,
+    #[schema(value_type = i32)]
+    pub download_count: DownloadCount,
     pub developers: Vec<ModDeveloper>,
     pub versions: Vec<ModVersion>,
     pub tags: Vec<String>,
@@ -107,6 +109,13 @@ pub struct ModStats {
 }
 
 impl Mod {
+    pub fn set_abbreviated_download_counts(&mut self, abbreviate: bool) {
+        self.download_count.set_abbreviated(abbreviate);
+        for version in &mut self.versions {
+            version.set_abbreviated_download_count(abbreviate);
+        }
+    }
+
     pub async fn get_stats(pool: &mut PgConnection) -> Result<ModStats, DatabaseError> {
         let result = sqlx::query!(
             "
@@ -356,7 +365,7 @@ impl Mod {
                 Mod {
                     id: x.id,
                     repository: x.repository,
-                    download_count: x.download_count,
+                    download_count: x.download_count.into(),
                     featured: x.featured,
                     versions: vec![version],
                     tags,
@@ -403,7 +412,7 @@ impl Mod {
                 Mod {
                     id: x.id.clone(),
                     repository: x.repository.clone(),
-                    download_count: x.download_count,
+                    download_count: x.download_count.into(),
                     featured: x.featured,
                     versions: version,
                     tags,
@@ -548,7 +557,7 @@ impl Mod {
                 description: x.description.clone(),
                 version: x.version.clone(),
                 download_link: x.download_link.clone(),
-                download_count: x.mod_version_download_count,
+                download_count: x.mod_version_download_count.into(),
                 hash: x.hash.clone(),
                 geode: x.geode.clone(),
                 early_load: x.early_load,
@@ -592,7 +601,7 @@ impl Mod {
             id: records[0].id.clone(),
             repository: records[0].repository.clone(),
             featured: records[0].featured,
-            download_count: records[0].mod_download_count,
+            download_count: records[0].mod_download_count.into(),
             versions,
             tags,
             developers: devs,