Merge branch 'main' into errors-patch

Author: Fleeym

.sqlx/query-01959e9a4fdc1c6b0d9dbeff80c79a58e0bae2d79af6c2b9e53ead7d9b6e214d.json

@@ -1,6 +1,6 @@
 [package]
 name = "geode-index"
-version = "0.44.1"
+version = "0.45.0"
 edition = "2021"
 
 [dependencies]

Cargo.lock

@@ -113,8 +113,9 @@ impl GithubClient {
 
         if !res.status().is_success() {
             log::error!(
-                "GitHub OAuth device flow start request failed with code {}",
-                res.status()
+                "GitHub OAuth device flow failed to start. Error code: {}. Body: {}",
+                res.status(),
+                res.text().await.unwrap_or("No body received".into())
             );
             return Err(AuthenticationError::InternalError(
                 "Failed to start GitHub device flow".into(),

Cargo.toml

@@ -1,4 +1,4 @@
-use crate::types::api::ApiError;
+use crate::database::DatabaseError;
 use chrono::{Days, Utc};
 use sqlx::types::ipnetwork::IpNetwork;
 use sqlx::PgConnection;
@@ -7,7 +7,7 @@ pub async fn create(
     ip: IpNetwork,
     mod_version_id: i32,
     conn: &mut PgConnection,
-) -> Result<bool, ApiError> {
+) -> Result<bool, DatabaseError> {
     let result = sqlx::query!(
         "INSERT INTO mod_downloads (mod_version_id, ip)
         VALUES ($1, $2)
@@ -17,13 +17,8 @@ pub async fn create(
     )
     .execute(&mut *conn)
     .await
-    .map_err(|e| {
-        log::error!(
-            "Failed to insert new download for mod_version id {}: {}",
-            mod_version_id,
-            e
-        );
-        ApiError::DbError
+    .inspect_err(|e| {
+        log::error!("Failed to insert new download for mod_version id {mod_version_id}: {e}");
     })?;
 
     Ok(result.rows_affected() > 0)
@@ -33,8 +28,8 @@ pub async fn has_downloaded_mod(
     ip: IpNetwork,
     mod_id: &str,
     conn: &mut PgConnection,
-) -> Result<bool, ApiError> {
-    Ok(sqlx::query!(
+) -> Result<bool, DatabaseError> {
+    sqlx::query!(
         "SELECT ip FROM mod_downloads md
         INNER JOIN mod_versions mv ON md.mod_version_id = mv.id
         WHERE mv.mod_id = $1
@@ -45,14 +40,12 @@ pub async fn has_downloaded_mod(
     )
     .fetch_optional(&mut *conn)
     .await
-    .map_err(|e| {
-        log::error!("Failed to check if mod has been downloaded: {}", e);
-        ApiError::DbError
-    })?
-    .is_some())
+    .inspect_err(|e| log::error!("mod_downloads::has_downloaded_mod query error: {e}"))
+    .map_err(|e| e.into())
+    .map(|x| x.is_some())
 }
 
-pub async fn cleanup(conn: &mut PgConnection) -> Result<(), ApiError> {
+pub async fn cleanup(conn: &mut PgConnection) -> Result<(), DatabaseError> {
     let date = Utc::now().checked_sub_days(Days::new(30)).unwrap();
     sqlx::query!(
         "DELETE FROM mod_downloads md
@@ -61,10 +54,7 @@ pub async fn cleanup(conn: &mut PgConnection) -> Result<(), ApiError> {
     )
     .execute(&mut *conn)
     .await
-    .map_err(|e| {
-        log::error!("Failed to cleanup downloads: {}", e);
-        ApiError::DbError
-    })?;
+    .inspect_err(|e| log::error!("mod_downloads::cleanup query failed: {e}"))?;
 
     Ok(())
 }

src/auth/github.rs

@@ -27,6 +27,40 @@ pub async fn get_all_writable(conn: &mut PgConnection) -> Result<Vec<Tag>, Datab
     Ok(tags)
 }
 
+pub async fn get_allowed_for_mod(
+    id: &str,
+    conn: &mut PgConnection,
+) -> Result<Vec<Tag>, DatabaseError> {
+    let mut writable = get_all_writable(&mut *conn).await?;
+    let allowed_readonly = sqlx::query!(
+        "SELECT DISTINCT
+            t.id,
+            t.name,
+            t.display_name,
+            t.is_readonly
+        FROM mod_tags t
+        INNER JOIN mods_mod_tags mmt ON mmt.tag_id = t.id
+        WHERE t.is_readonly = true
+        AND mmt.mod_id = $1",
+        id
+    )
+    .fetch_all(&mut *conn)
+    .await
+    .inspect_err(|e| log::error!("mod_tags::get_allowed_for_mod failed: {e}"))?
+    .into_iter()
+    .map(|i| Tag {
+        id: i.id,
+        display_name: i.display_name.unwrap_or(i.name.clone()),
+        name: i.name,
+        is_readonly: i.is_readonly,
+    })
+    .collect::<Vec<Tag>>();
+
+    writable.extend(allowed_readonly);
+
+    return Ok(writable);
+}
+
 pub async fn get_all(conn: &mut PgConnection) -> Result<Vec<Tag>, DatabaseError> {
     let tags = sqlx::query!(
         "SELECT
@@ -88,13 +122,13 @@ pub async fn update_for_mod(
 
     let insertable = tags
         .iter()
-        .filter(|t| !existing.iter().any(|e| e.id == t.id))
+        .filter(|t| !t.is_readonly && !existing.iter().any(|e| e.id == t.id))
         .map(|x| x.id)
         .collect::<Vec<_>>();
 
     let deletable = existing
         .iter()
-        .filter(|e| !e.is_readonly && !tags.iter().any(|t| e.id == t.id))
+        .filter(|i| !i.is_readonly && !tags.iter().any(|j| i.id == j.id))
         .map(|x| x.id)
         .collect::<Vec<_>>();
 

src/database/repository/mod_downloads.rs

@@ -211,23 +211,25 @@ pub async fn download_version(
         ));
     };
 
-    let net: IpNetwork = ip.parse().or(Err(ApiError::InternalError))?;
+    let net = ip.parse::<IpNetwork>().ok();
 
-    let mut tx = pool.begin().await?;
+    if let Some(net) = net {
+        let mut tx = pool.begin().await?;
 
-    let downloaded_mod_previously =
-        mod_downloads::has_downloaded_mod(net, &mod_version.mod_id, &mut tx).await?;
-    let inserted = mod_downloads::create(net, mod_version.id, &mut tx).await?;
+        let downloaded_mod_previously =
+            mod_downloads::has_downloaded_mod(net, &mod_version.mod_id, &mut tx).await?;
+        let inserted = mod_downloads::create(net, mod_version.id, &mut tx).await?;
 
-    if inserted {
-        mod_versions::increment_downloads(mod_version.id, &mut tx).await?;
+        if inserted {
+            mod_versions::increment_downloads(mod_version.id, &mut tx).await?;
 
-        if !downloaded_mod_previously {
-            mods::increment_downloads(&mod_version.mod_id, &mut tx).await?;
+            if !downloaded_mod_previously {
+                mods::increment_downloads(&mod_version.mod_id, &mut tx).await?;
+            }
         }
-    }
 
-    let _ = tx.commit().await;
+        let _ = tx.commit().await;
+    }
 
     Ok(HttpResponse::Found()
         .append_header(("Location", url))
@@ -363,7 +365,7 @@ pub async fn create_version(
         }
         if let Some(tags) = &json.tags {
             if !tags.is_empty() {
-                let tags = models::tag::parse_tag_list(tags, &mut tx).await?;
+                let tags = models::tag::parse_tag_list(tags, &the_mod.id, &mut tx).await?;
                 mod_tags::update_for_mod(&the_mod.id, &tags, &mut tx).await?;
             }
         }
@@ -480,7 +482,7 @@ pub async fn update_version(
 
         // Update tags with data from mod.json
         let tags = if let Some(tags) = &json.tags {
-            models::tag::parse_tag_list(tags, &mut tx).await?
+            models::tag::parse_tag_list(tags, &the_mod.id, &mut tx).await?
         } else {
             vec![]
         };

src/database/repository/mod_tags.rs

@@ -13,6 +13,7 @@ use crate::extractors::auth::Auth;
 use crate::mod_zip;
 use crate::types::api::{create_download_link, ApiResponse};
 use crate::types::mod_json::ModJson;
+use crate::types::models;
 use crate::types::models::incompatibility::Incompatibility;
 use crate::types::models::mod_entity::{Mod, ModUpdate};
 use crate::types::models::mod_gd_version::{GDVersionEnum, VerPlatform};
@@ -22,7 +23,6 @@ use crate::webhook::discord::DiscordWebhook;
 use actix_web::{get, post, put, web, HttpResponse, Responder};
 use serde::Deserialize;
 use sqlx::Acquire;
-use crate::types::models;
 
 #[derive(Deserialize, Default)]
 #[serde(rename_all = "snake_case")]
@@ -185,7 +185,7 @@ pub async fn create(
     }
 
     if let Some(tags) = &json.tags {
-        let tag_list = models::tag::parse_tag_list(tags, &mut tx).await?;
+        let tag_list = models::tag::parse_tag_list(tags, &the_mod.id, &mut tx).await?;
         mod_tags::update_for_mod(&the_mod.id, &tag_list, &mut tx).await?;
     }
     if let Some(l) = json.links.clone() {
@@ -348,8 +348,8 @@ pub async fn update_mod(
                         base_url: data.app_url().to_string(),
                         featured: payload.featured,
                     }
-                        .to_discord_webhook()
-                        .send(data.webhook_url());
+                    .to_discord_webhook()
+                    .send(data.webhook_url());
                 }
             }
         }

src/endpoints/mod_versions.rs

@@ -9,8 +9,6 @@ use image::{DynamicImage, GenericImageView};
 use zip::read::ZipFile;
 use zip::ZipArchive;
 
-use crate::types::api::ApiError;
-
 pub fn extract_mod_logo(file: &mut ZipFile<Cursor<Bytes>>) -> Result<Vec<u8>, ApiError> {
     let mut logo: Vec<u8> = Vec::with_capacity(file.size() as usize);
     file.read_to_end(&mut logo)

src/endpoints/mods.rs

@@ -99,13 +99,14 @@ impl Tag {
 
 pub async fn parse_tag_list(
     tags: &[String],
+    mod_id: &str,
     conn: &mut PgConnection,
 ) -> Result<Vec<Tag>, ApiError> {
     if tags.is_empty() {
         return Ok(vec![]);
     }
 
-    let db_tags = mod_tags::get_all_writable(&mut *conn).await?;
+    let db_tags = mod_tags::get_allowed_for_mod(mod_id, &mut *conn).await?;
 
     let mut ret = Vec::with_capacity(tags.len());
     for tag in tags {
@@ -119,7 +120,8 @@ pub async fn parse_tag_list(
                 .join(", ");
 
             return Err(ApiError::BadRequest(format!(
-                "Tag '{tags}' isn't allowed. Only the following are allowed: '{taglist}'"
+                "Tag '{}' isn't allowed. Only the following are allowed: '{}'",
+                tag, taglist
             )));
         }
     }