Merge pull request #20 from geode-sdk/unlisted-mods

Unlisted mods

Author: Fleeym

.sqlx/query-159785d4a225f320a514c42f4f5c6140e25272a5c6838135a5ebbd306da5d471.json

@@ -207,7 +207,7 @@ paths:
       tags:
         - mods
       summary: Get info for a mod
-      description: Returns info for the mod, without dependencies and incompatibilities
+      description: Returns info for the mod, without dependencies and incompatibilities.
       parameters:
         - $ref: "#/components/parameters/ModID"
       responses:
@@ -281,14 +281,13 @@ paths:
       tags:
         - mods
       summary: Get info for the latest version of a mod
-      description: Returns info for the current latest version of the mod
+      description: Returns info for the current latest approved version of the mod
       parameters:
         - $ref: "#/components/parameters/ModID"
         - $ref: "#/components/parameters/Platforms"
         - name: gd
           in: query
           description: Geometry Dash version
-          required: true
           schema:
             $ref: "#/components/schemas/GDVersionString"
 
@@ -410,7 +409,7 @@ paths:
     get:
       tags:
         - mods
-      summary: Download the latest version of a mod
+      summary: Download the latest available version of a mod
       parameters:
         - $ref: "#/components/parameters/ModID"
       responses:

.sqlx/query-7b359410b3aa72262d162f0eb3d154fcd26368c7b59478f240235b8a49a4e61e.json

@@ -14,13 +14,18 @@ use crate::{
             download,
             mod_entity::{download_geode_file, Mod},
             mod_gd_version::{GDVersionEnum, VerPlatform},
-            mod_version::ModVersion,
+            mod_version::{self, ModVersion},
             mod_version_status::ModVersionStatusEnum,
         },
     },
     AppData,
 };
 
+#[derive(Deserialize)]
+struct IndexPath {
+    id: String,
+}
+
 #[derive(Deserialize)]
 pub struct GetOnePath {
     id: String,
@@ -56,6 +61,46 @@ struct GetOneQuery {
     major: Option<u32>,
 }
 
+#[derive(Deserialize)]
+struct IndexQuery {
+    page: Option<i64>,
+    per_page: Option<i64>,
+    #[serde(default)]
+    gd: Option<GDVersionEnum>,
+    platforms: Option<String>,
+    status: Option<ModVersionStatusEnum>,
+}
+
+#[get("v1/mods/{id}/versions")]
+pub async fn get_version_index(
+    path: web::Path<IndexPath>,
+    data: web::Data<AppData>,
+    query: web::Query<IndexQuery>,
+) -> Result<impl Responder, ApiError> {
+    let platforms = VerPlatform::parse_query_string(&query.platforms.clone().unwrap_or_default());
+    let mut pool = data.db.acquire().await.or(Err(ApiError::DbAcquireError))?;
+    let mut result = ModVersion::get_index(
+        mod_version::IndexQuery {
+            mod_id: path.id.clone(),
+            page: query.page.unwrap_or(1),
+            per_page: query.per_page.unwrap_or(10),
+            gd: query.gd,
+            platforms,
+            status: query.status.unwrap_or(ModVersionStatusEnum::Accepted),
+        },
+        &mut pool,
+    )
+    .await?;
+    for i in &mut result.data {
+        i.modify_download_link(&data.app_url);
+    }
+
+    Ok(web::Json(ApiResponse {
+        payload: result,
+        error: "".to_string(),
+    }))
+}
+
 #[get("v1/mods/{id}/versions/{version}")]
 pub async fn get_one(
     path: web::Path<GetOnePath>,
@@ -74,29 +119,12 @@ pub async fn get_one(
                 None => None,
             };
 
-            let mut platforms: Vec<VerPlatform> = vec![];
-
-            if let Some(p) = &query.platforms {
-                for x in p.split(',') {
-                    match VerPlatform::from_str(x) {
-                        Ok(v) => {
-                            if v == VerPlatform::Android {
-                                platforms.push(VerPlatform::Android32);
-                                platforms.push(VerPlatform::Android64);
-                            } else {
-                                platforms.push(v);
-                            }
-                        }
-                        Err(_) => {
-                            return Err(ApiError::BadRequest("Invalid platform".to_string()));
-                        }
-                    }
-                }
-            };
+            let platform_string = query.platforms.clone().unwrap_or_default();
+            let platforms = VerPlatform::parse_query_string(&platform_string);
 
             ModVersion::get_latest_for_mod(&path.id, gd, platforms, query.major, &mut pool).await?
         } else {
-            ModVersion::get_one(&path.id, &path.version, true, &mut pool).await?
+            ModVersion::get_one(&path.id, &path.version, true, false, &mut pool).await?
         }
     };
 
@@ -107,15 +135,33 @@ pub async fn get_one(
     }))
 }
 
+#[derive(Deserialize)]
+struct DownloadQuery {
+    gd: Option<GDVersionEnum>,
+    // platform1,platform2,...
+    platforms: Option<String>,
+    major: Option<u32>,
+}
+
 #[get("v1/mods/{id}/versions/{version}/download")]
 pub async fn download_version(
     path: web::Path<GetOnePath>,
     data: web::Data<AppData>,
+    query: web::Query<DownloadQuery>,
     info: ConnectionInfo,
 ) -> Result<impl Responder, ApiError> {
     let mut pool = data.db.acquire().await.or(Err(ApiError::DbAcquireError))?;
-    let mod_version = ModVersion::get_one(&path.id, &path.version, false, &mut pool).await?;
-    let url = ModVersion::get_download_url(&path.id, &path.version, &mut pool).await?;
+    let mod_version = {
+        if path.version == "latest" {
+            let platform_str = query.platforms.clone().unwrap_or_default();
+            let platforms = VerPlatform::parse_query_string(&platform_str);
+            ModVersion::get_latest_for_mod(&path.id, query.gd, platforms, query.major, &mut pool)
+                .await?
+        } else {
+            ModVersion::get_one(&path.id, &path.version, false, false, &mut pool).await?
+        }
+    };
+    let url = mod_version.download_link;
 
     let ip = match info.realip_remote_addr() {
         None => return Err(ApiError::InternalError),
@@ -124,8 +170,25 @@ pub async fn download_version(
     let net: IpNetwork = ip.parse().or(Err(ApiError::InternalError))?;
 
     if download::create_download(net, mod_version.id, &mut pool).await? {
-        ModVersion::calculate_cached_downloads(mod_version.id, &mut pool).await?;
-        Mod::calculate_cached_downloads(&mod_version.mod_id, &mut pool).await?;
+        let name = mod_version.mod_id.clone();
+        let version = mod_version.version.clone();
+        tokio::spawn(async move {
+            if let Err(e) = ModVersion::calculate_cached_downloads(mod_version.id, &mut pool).await
+            {
+                log::error!(
+                    "Failed to calculate cached downloads for mod version {}. Error: {}",
+                    version,
+                    e
+                );
+            }
+            if let Err(e) = Mod::calculate_cached_downloads(&mod_version.mod_id, &mut pool).await {
+                log::error!(
+                    "Failed to calculate cached downloads for mod {}. Error: {}",
+                    name,
+                    e
+                );
+            }
+        });
     }
 
     Ok(HttpResponse::Found()

.sqlx/query-4abc4f3d4ecd6ccb07948086234a24bceacc1c2516b3a524b19b68dc871805bd.json renamed to .sqlx/query-8766c857a28fd2da53b8cc0182c2d810f6aaf5ecf31fe6099e08400ecc9a3045.json

@@ -99,6 +99,7 @@ async fn main() -> anyhow::Result<()> {
             .service(endpoints::mods::create)
             .service(endpoints::mods::update_mod)
             .service(endpoints::mods::get_logo)
+            .service(endpoints::mod_versions::get_version_index)
             .service(endpoints::mod_versions::get_one)
             .service(endpoints::mod_versions::download_version)
             .service(endpoints::mod_versions::create_version)

.sqlx/query-b20b4b54a01407e33d467b1704b8cf28e81735de37096b319e5d91f31a917526.json

@@ -690,11 +690,16 @@ impl Mod {
         id: &str,
         pool: &mut PgConnection,
     ) -> Result<Option<Vec<u8>>, ApiError> {
-        match sqlx::query!(
-            "SELECT DISTINCT m.image FROM mods m
-        INNER JOIN mod_versions mv ON mv.mod_id = m.id 
-        INNER JOIN mod_version_statuses mvs ON mvs.mod_version_id = mv.id
-        WHERE m.id = $1 AND mvs.status = 'accepted'",
+        struct QueryResult {
+            image: Option<Vec<u8>>
+        }
+        match sqlx::query_as!(
+            QueryResult,
+            "SELECT m.image 
+            FROM mods m
+            INNER JOIN mod_versions mv ON mv.mod_id = m.id 
+            INNER JOIN mod_version_statuses mvs ON mvs.mod_version_id = mv.id
+            WHERE m.id = $1",
             id
         )
         .fetch_optional(&mut *pool)
@@ -704,10 +709,8 @@ impl Mod {
                 log::error!("{}", e);
                 Err(ApiError::DbError)
             }
-            Ok(r) => match r {
-                Some(r) => Ok(r.image),
-                None => Ok(None),
-            },
+            Ok(Some(r)) => Ok(r.image),
+            Ok(None) => Ok(None)
         }
     }
 

openapi.yml

@@ -26,6 +26,9 @@ pub enum GDVersionEnum {
     #[serde(rename = "2.205")]
     #[sqlx(rename = "2.205")]
     GD2205,
+    #[serde(rename = "2.206")]
+    #[sqlx(rename = "2.206")]
+    GD2206,
 }
 
 impl FromStr for GDVersionEnum {
@@ -74,6 +77,32 @@ impl FromStr for VerPlatform {
     }
 }
 
+impl VerPlatform {
+    pub fn parse_query_string(s: &str) -> Vec<VerPlatform> {
+        let mut ret = vec![];
+        if s.is_empty() {
+            return ret;
+        }
+
+        for x in s.split(',') {
+            match VerPlatform::from_str(x) {
+                Ok(v) => {
+                    if v == VerPlatform::Android {
+                        ret.push(VerPlatform::Android32);
+                        ret.push(VerPlatform::Android64);
+                    } else {
+                        ret.push(v);
+                    }
+                }
+                Err(_) => {
+                    log::error!("invalid platform {}", x);
+                }
+            }
+        }
+        ret
+    }
+}
+
 #[derive(sqlx::FromRow, Clone, Copy, Debug, Serialize)]
 pub struct ModGDVersion {
     id: i32,