Allow readonly tags in mod.json if mod has it serverside (#50)

* fix(tags): allow readonly tags on mod update if mod has the tag

* chore: sqlx prepare

Author: Fleeym

.sqlx/query-01959e9a4fdc1c6b0d9dbeff80c79a58e0bae2d79af6c2b9e53ead7d9b6e214d.json

@@ -30,6 +30,38 @@ pub async fn get_all_writable(conn: &mut PgConnection) -> Result<Vec<Tag>, ApiEr
     Ok(tags)
 }
 
+pub async fn get_allowed_for_mod(id: &str, conn: &mut PgConnection) -> Result<Vec<Tag>, ApiError> {
+    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}"))
+    .or(Err(ApiError::DbError))?
+    .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>, ApiError> {
     let tags = sqlx::query!(
         "SELECT
@@ -39,20 +71,20 @@ pub async fn get_all(conn: &mut PgConnection) -> Result<Vec<Tag>, ApiError> {
             is_readonly
         FROM mod_tags"
     )
-        .fetch_all(&mut *conn)
-        .await
-        .map_err(|e| {
-            log::error!("mod_tags::get_all failed: {}", e);
-            ApiError::DbError
-        })?
-        .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>>();
+    .fetch_all(&mut *conn)
+    .await
+    .map_err(|e| {
+        log::error!("mod_tags::get_all failed: {}", e);
+        ApiError::DbError
+    })?
+    .into_iter()
+    .map(|i| Tag {
+        id: i.id,
+        display_name: i.display_name.unwrap_or_else(|| i.name.clone()),
+        name: i.name,
+        is_readonly: i.is_readonly,
+    })
+    .collect::<Vec<Tag>>();
 
     Ok(tags)
 }
@@ -89,13 +121,14 @@ pub async fn get_for_mod(id: &str, conn: &mut PgConnection) -> Result<Vec<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 = get_all_writable(conn).await?;
+    let db_tags = get_allowed_for_mod(mod_id, conn).await?;
 
     let mut ret = Vec::new();
     for tag in tags {
@@ -126,13 +159,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_tags.rs

@@ -371,7 +371,7 @@ pub async fn create_version(
         }
         if let Some(tags) = &json.tags {
             if !tags.is_empty() {
-                let tags = mod_tags::parse_tag_list(tags, &mut tx).await?;
+                let tags = mod_tags::parse_tag_list(tags, &the_mod.id, &mut tx).await?;
                 mod_tags::update_for_mod(&the_mod.id, &tags, &mut tx).await?;
             }
         }
@@ -490,7 +490,7 @@ pub async fn update_version(
 
         // Update tags with data from mod.json
         let tags = if let Some(tags) = &json.tags {
-            mod_tags::parse_tag_list(tags, &mut tx).await?
+            mod_tags::parse_tag_list(tags, &the_mod.id, &mut tx).await?
         } else {
             vec![]
         };

src/endpoints/mod_versions.rs

@@ -198,7 +198,7 @@ pub async fn create(
     }
 
     if let Some(tags) = &json.tags {
-        let tag_list = mod_tags::parse_tag_list(tags, &mut tx).await?;
+        let tag_list = mod_tags::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() {