fix: remove some more unused things

Author: Fleeym

src/types/models/incompatibility.rs

@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use crate::types::api::ApiError;
 use crate::types::models::dependency::ModVersionCompare;
 use serde::{Deserialize, Serialize};
-use sqlx::{PgConnection, Postgres, QueryBuilder};
+use sqlx::{PgConnection, Postgres};
 
 use super::{
     dependency::ResponseDependency,

src/types/models/mod_version_status.rs

@@ -9,11 +9,3 @@ pub enum ModVersionStatusEnum {
     Rejected,
     Unlisted,
 }
-
-pub struct ModVersionStatus {
-    pub id: i32,
-    pub mod_version_id: i32,
-    pub status: ModVersionStatusEnum,
-    pub info: Option<String>,
-    pub admin_id: i32,
-}

src/types/models/tag.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use sqlx::{PgConnection, Postgres, QueryBuilder};
+use sqlx::PgConnection;
 
 use crate::types::api::ApiError;
 
@@ -19,134 +19,6 @@ pub struct Tag {
 }
 
 impl Tag {
-    pub async fn get_tag_ids(
-        tags: Vec<String>,
-        pool: &mut PgConnection,
-    ) -> Result<Vec<FetchedTag>, ApiError> {
-        let db_tags = match sqlx::query_as!(
-            FetchedTag,
-            "SELECT id, name FROM mod_tags WHERE is_readonly = false"
-        )
-        .fetch_all(&mut *pool)
-        .await
-        {
-            Ok(tags) => tags,
-            Err(e) => {
-                log::error!("{}", e);
-                return Err(ApiError::DbError);
-            }
-        };
-
-        let mut ret = Vec::new();
-        for tag in tags {
-            if let Some(t) = db_tags.iter().find(|t| t.name == tag.to_lowercase()) {
-                ret.push(t.clone())
-            } else {
-                return Err(ApiError::BadRequest(format!(
-                    "Tag '{}' isn't allowed. Only the following are allowed: '{}'",
-                    tag,
-                    db_tags
-                        .iter()
-                        .map(|t| t.name.clone())
-                        .collect::<Vec<String>>()
-                        .join(", ")
-                )));
-            }
-        }
-
-        Ok(ret)
-    }
-
-    pub async fn update_mod_tags(
-        mod_id: &str,
-        tags: Vec<i32>,
-        pool: &mut PgConnection,
-    ) -> Result<(), ApiError> {
-        let existing = match sqlx::query!(
-            "SELECT mod_id, tag_id FROM mods_mod_tags WHERE mod_id = $1",
-            mod_id,
-        )
-        .fetch_all(&mut *pool)
-        .await
-        {
-            Ok(existing) => existing,
-            Err(e) => {
-                log::error!("{}", e);
-                return Err(ApiError::DbError);
-            }
-        };
-
-        let insertable = tags
-            .iter()
-            .filter(|t| !existing.iter().any(|e| e.tag_id == **t))
-            .collect::<Vec<_>>();
-
-        let deletable = existing
-            .iter()
-            .filter(|e| !tags.iter().any(|t| e.tag_id == *t))
-            .map(|x| x.tag_id)
-            .collect::<Vec<_>>();
-
-        Tag::delete_tags_for_mod(mod_id, deletable, pool).await?;
-
-        if insertable.is_empty() {
-            return Ok(());
-        }
-
-        let mut query_builder: QueryBuilder<Postgres> =
-            QueryBuilder::new("INSERT INTO mods_mod_tags (mod_id, tag_id) VALUES (");
-
-        for (index, tag) in insertable.iter().enumerate() {
-            if existing.iter().any(|e| e.tag_id == **tag) {
-                continue;
-            }
-            let mut separated = query_builder.separated(", ");
-            separated.push_bind(mod_id);
-            separated.push_bind(tag);
-            query_builder.push(")");
-
-            if index != insertable.len() - 1 {
-                query_builder.push(", (");
-            }
-        }
-
-        if let Err(e) = query_builder.build().execute(&mut *pool).await {
-            log::error!("{}", e);
-            return Err(ApiError::DbError);
-        }
-        Ok(())
-    }
-
-    pub async fn delete_tags_for_mod(
-        mod_id: &str,
-        tags: Vec<i32>,
-        pool: &mut PgConnection,
-    ) -> Result<(), ApiError> {
-        if tags.is_empty() {
-            return Ok(());
-        }
-        let mut query_builder: QueryBuilder<Postgres> =
-            QueryBuilder::new("DELETE FROM mods_mod_tags WHERE (mod_id, tag_id) IN ((");
-
-        for (index, tag) in tags.iter().enumerate() {
-            let mut separated = query_builder.separated(", ");
-            separated.push_bind(mod_id);
-            separated.push_bind(tag);
-            query_builder.push(")");
-
-            if index != tags.len() - 1 {
-                query_builder.push(", (");
-            }
-        }
-        query_builder.push(")");
-
-        if let Err(e) = query_builder.build().execute(&mut *pool).await {
-            log::error!("{}", e);
-            return Err(ApiError::DbError);
-        }
-        Ok(())
-    }
-
     pub async fn get_tags_for_mod(
         mod_id: &str,
         pool: &mut PgConnection,