move to monorepo dir

apps/labrinth/src/routes/v2/mod.rs

@@ -0,0 +1,40 @@
+mod moderation;
+mod notifications;
+pub(crate) mod project_creation;
+mod projects;
+mod reports;
+mod statistics;
+pub mod tags;
+mod teams;
+mod threads;
+mod users;
+mod version_creation;
+pub mod version_file;
+mod versions;
+
+pub use super::ApiError;
+use crate::util::cors::default_cors;
+
+pub fn config(cfg: &mut actix_web::web::ServiceConfig) {
+    cfg.service(
+        actix_web::web::scope("v2")
+            .wrap(default_cors())
+            .configure(super::internal::admin::config)
+            // Todo: separate these- they need to also follow v2-v3 conversion
+            .configure(super::internal::session::config)
+            .configure(super::internal::flows::config)
+            .configure(super::internal::pats::config)
+            .configure(moderation::config)
+            .configure(notifications::config)
+            .configure(project_creation::config)
+            .configure(projects::config)
+            .configure(reports::config)
+            .configure(statistics::config)
+            .configure(tags::config)
+            .configure(teams::config)
+            .configure(threads::config)
+            .configure(users::config)
+            .configure(version_file::config)
+            .configure(versions::config),
+    );
+}

apps/labrinth/src/routes/v2/moderation.rs

@@ -0,0 +1,51 @@
+use super::ApiError;
+use crate::models::projects::Project;
+use crate::models::v2::projects::LegacyProject;
+use crate::queue::session::AuthQueue;
+use crate::routes::internal;
+use crate::{database::redis::RedisPool, routes::v2_reroute};
+use actix_web::{get, web, HttpRequest, HttpResponse};
+use serde::Deserialize;
+use sqlx::PgPool;
+
+pub fn config(cfg: &mut web::ServiceConfig) {
+    cfg.service(web::scope("moderation").service(get_projects));
+}
+
+#[derive(Deserialize)]
+pub struct ResultCount {
+    #[serde(default = "default_count")]
+    pub count: i16,
+}
+
+fn default_count() -> i16 {
+    100
+}
+
+#[get("projects")]
+pub async fn get_projects(
+    req: HttpRequest,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    count: web::Query<ResultCount>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let response = internal::moderation::get_projects(
+        req,
+        pool.clone(),
+        redis.clone(),
+        web::Query(internal::moderation::ResultCount { count: count.count }),
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)?;
+
+    // Convert to V2 projects
+    match v2_reroute::extract_ok_json::<Vec<Project>>(response).await {
+        Ok(project) => {
+            let legacy_projects = LegacyProject::from_many(project, &**pool, &redis).await?;
+            Ok(HttpResponse::Ok().json(legacy_projects))
+        }
+        Err(response) => Ok(response),
+    }
+}

apps/labrinth/src/routes/v2/notifications.rs

@@ -0,0 +1,146 @@
+use crate::database::redis::RedisPool;
+use crate::models::ids::NotificationId;
+use crate::models::notifications::Notification;
+use crate::models::v2::notifications::LegacyNotification;
+use crate::queue::session::AuthQueue;
+use crate::routes::v2_reroute;
+use crate::routes::v3;
+use crate::routes::ApiError;
+use actix_web::{delete, get, patch, web, HttpRequest, HttpResponse};
+use serde::{Deserialize, Serialize};
+use sqlx::PgPool;
+
+pub fn config(cfg: &mut web::ServiceConfig) {
+    cfg.service(notifications_get);
+    cfg.service(notifications_delete);
+    cfg.service(notifications_read);
+
+    cfg.service(
+        web::scope("notification")
+            .service(notification_get)
+            .service(notification_read)
+            .service(notification_delete),
+    );
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct NotificationIds {
+    pub ids: String,
+}
+
+#[get("notifications")]
+pub async fn notifications_get(
+    req: HttpRequest,
+    web::Query(ids): web::Query<NotificationIds>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let resp = v3::notifications::notifications_get(
+        req,
+        web::Query(v3::notifications::NotificationIds { ids: ids.ids }),
+        pool,
+        redis,
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error);
+    match v2_reroute::extract_ok_json::<Vec<Notification>>(resp?).await {
+        Ok(notifications) => {
+            let notifications: Vec<LegacyNotification> = notifications
+                .into_iter()
+                .map(LegacyNotification::from)
+                .collect();
+            Ok(HttpResponse::Ok().json(notifications))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+#[get("{id}")]
+pub async fn notification_get(
+    req: HttpRequest,
+    info: web::Path<(NotificationId,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let response = v3::notifications::notification_get(req, info, pool, redis, session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)?;
+    match v2_reroute::extract_ok_json::<Notification>(response).await {
+        Ok(notification) => {
+            let notification = LegacyNotification::from(notification);
+            Ok(HttpResponse::Ok().json(notification))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+#[patch("{id}")]
+pub async fn notification_read(
+    req: HttpRequest,
+    info: web::Path<(NotificationId,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // Returns NoContent, so no need to convert
+    v3::notifications::notification_read(req, info, pool, redis, session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)
+}
+
+#[delete("{id}")]
+pub async fn notification_delete(
+    req: HttpRequest,
+    info: web::Path<(NotificationId,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // Returns NoContent, so no need to convert
+    v3::notifications::notification_delete(req, info, pool, redis, session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)
+}
+
+#[patch("notifications")]
+pub async fn notifications_read(
+    req: HttpRequest,
+    web::Query(ids): web::Query<NotificationIds>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // Returns NoContent, so no need to convert
+    v3::notifications::notifications_read(
+        req,
+        web::Query(v3::notifications::NotificationIds { ids: ids.ids }),
+        pool,
+        redis,
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)
+}
+
+#[delete("notifications")]
+pub async fn notifications_delete(
+    req: HttpRequest,
+    web::Query(ids): web::Query<NotificationIds>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // Returns NoContent, so no need to convert
+    v3::notifications::notifications_delete(
+        req,
+        web::Query(v3::notifications::NotificationIds { ids: ids.ids }),
+        pool,
+        redis,
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)
+}

apps/labrinth/src/routes/v2/project_creation.rs

@@ -0,0 +1,259 @@
+use crate::database::models::version_item;
+use crate::database::redis::RedisPool;
+use crate::file_hosting::FileHost;
+use crate::models;
+use crate::models::ids::ImageId;
+use crate::models::projects::{Loader, Project, ProjectStatus};
+use crate::models::v2::projects::{DonationLink, LegacyProject, LegacySideType};
+use crate::queue::session::AuthQueue;
+use crate::routes::v3::project_creation::default_project_type;
+use crate::routes::v3::project_creation::{CreateError, NewGalleryItem};
+use crate::routes::{v2_reroute, v3};
+use actix_multipart::Multipart;
+use actix_web::web::Data;
+use actix_web::{post, HttpRequest, HttpResponse};
+use serde::{Deserialize, Serialize};
+use serde_json::json;
+use sqlx::postgres::PgPool;
+
+use std::collections::HashMap;
+use std::sync::Arc;
+use validator::Validate;
+
+use super::version_creation::InitialVersionData;
+
+pub fn config(cfg: &mut actix_web::web::ServiceConfig) {
+    cfg.service(project_create);
+}
+
+pub fn default_requested_status() -> ProjectStatus {
+    ProjectStatus::Approved
+}
+
+#[derive(Serialize, Deserialize, Validate, Clone)]
+struct ProjectCreateData {
+    #[validate(
+        length(min = 3, max = 64),
+        custom(function = "crate::util::validate::validate_name")
+    )]
+    #[serde(alias = "mod_name")]
+    /// The title or name of the project.
+    pub title: String,
+    #[validate(length(min = 1, max = 64))]
+    #[serde(default = "default_project_type")]
+    /// The project type of this mod
+    pub project_type: String,
+    #[validate(
+        length(min = 3, max = 64),
+        regex = "crate::util::validate::RE_URL_SAFE"
+    )]
+    #[serde(alias = "mod_slug")]
+    /// The slug of a project, used for vanity URLs
+    pub slug: String,
+    #[validate(length(min = 3, max = 255))]
+    #[serde(alias = "mod_description")]
+    /// A short description of the project.
+    pub description: String,
+    #[validate(length(max = 65536))]
+    #[serde(alias = "mod_body")]
+    /// A long description of the project, in markdown.
+    pub body: String,
+
+    /// The support range for the client project
+    pub client_side: LegacySideType,
+    /// The support range for the server project
+    pub server_side: LegacySideType,
+
+    #[validate(length(max = 32))]
+    #[validate]
+    /// A list of initial versions to upload with the created project
+    pub initial_versions: Vec<InitialVersionData>,
+    #[validate(length(max = 3))]
+    /// A list of the categories that the project is in.
+    pub categories: Vec<String>,
+    #[validate(length(max = 256))]
+    #[serde(default = "Vec::new")]
+    /// A list of the categories that the project is in.
+    pub additional_categories: Vec<String>,
+
+    #[validate(
+        custom(function = "crate::util::validate::validate_url"),
+        length(max = 2048)
+    )]
+    /// An optional link to where to submit bugs or issues with the project.
+    pub issues_url: Option<String>,
+    #[validate(
+        custom(function = "crate::util::validate::validate_url"),
+        length(max = 2048)
+    )]
+    /// An optional link to the source code for the project.
+    pub source_url: Option<String>,
+    #[validate(
+        custom(function = "crate::util::validate::validate_url"),
+        length(max = 2048)
+    )]
+    /// An optional link to the project's wiki page or other relevant information.
+    pub wiki_url: Option<String>,
+    #[validate(
+        custom(function = "crate::util::validate::validate_url"),
+        length(max = 2048)
+    )]
+    /// An optional link to the project's license page
+    pub license_url: Option<String>,
+    #[validate(
+        custom(function = "crate::util::validate::validate_url"),
+        length(max = 2048)
+    )]
+    /// An optional link to the project's discord.
+    pub discord_url: Option<String>,
+    /// An optional list of all donation links the project has\
+    #[validate]
+    pub donation_urls: Option<Vec<DonationLink>>,
+
+    /// An optional boolean. If true, the project will be created as a draft.
+    pub is_draft: Option<bool>,
+
+    /// The license id that the project follows
+    pub license_id: String,
+
+    #[validate(length(max = 64))]
+    #[validate]
+    /// The multipart names of the gallery items to upload
+    pub gallery_items: Option<Vec<NewGalleryItem>>,
+    #[serde(default = "default_requested_status")]
+    /// The status of the mod to be set once it is approved
+    pub requested_status: ProjectStatus,
+
+    // Associations to uploaded images in body/description
+    #[validate(length(max = 10))]
+    #[serde(default)]
+    pub uploaded_images: Vec<ImageId>,
+
+    /// The id of the organization to create the project in
+    pub organization_id: Option<models::ids::OrganizationId>,
+}
+
+#[post("project")]
+pub async fn project_create(
+    req: HttpRequest,
+    payload: Multipart,
+    client: Data<PgPool>,
+    redis: Data<RedisPool>,
+    file_host: Data<Arc<dyn FileHost + Send + Sync>>,
+    session_queue: Data<AuthQueue>,
+) -> Result<HttpResponse, CreateError> {
+    // Convert V2 multipart payload to V3 multipart payload
+    let payload = v2_reroute::alter_actix_multipart(
+        payload,
+        req.headers().clone(),
+        |legacy_create: ProjectCreateData, _| async move {
+            // Side types will be applied to each version
+            let client_side = legacy_create.client_side;
+            let server_side = legacy_create.server_side;
+
+            let project_type = legacy_create.project_type;
+
+            let initial_versions = legacy_create
+                .initial_versions
+                .into_iter()
+                .map(|v| {
+                    let mut fields = HashMap::new();
+                    fields.extend(v2_reroute::convert_side_types_v3(client_side, server_side));
+                    fields.insert("game_versions".to_string(), json!(v.game_versions));
+
+                    // Modpacks now use the "mrpack" loader, and loaders are converted to loader fields.
+                    // Setting of 'project_type' directly is removed, it's loader-based now.
+                    if project_type == "modpack" {
+                        fields.insert("mrpack_loaders".to_string(), json!(v.loaders));
+                    }
+
+                    let loaders = if project_type == "modpack" {
+                        vec![Loader("mrpack".to_string())]
+                    } else {
+                        v.loaders
+                    };
+
+                    v3::version_creation::InitialVersionData {
+                        project_id: v.project_id,
+                        file_parts: v.file_parts,
+                        version_number: v.version_number,
+                        version_title: v.version_title,
+                        version_body: v.version_body,
+                        dependencies: v.dependencies,
+                        release_channel: v.release_channel,
+                        loaders,
+                        featured: v.featured,
+                        primary_file: v.primary_file,
+                        status: v.status,
+                        file_types: v.file_types,
+                        uploaded_images: v.uploaded_images,
+                        ordering: v.ordering,
+                        fields,
+                    }
+                })
+                .collect();
+
+            let mut link_urls = HashMap::new();
+            if let Some(issue_url) = legacy_create.issues_url {
+                link_urls.insert("issues".to_string(), issue_url);
+            }
+            if let Some(source_url) = legacy_create.source_url {
+                link_urls.insert("source".to_string(), source_url);
+            }
+            if let Some(wiki_url) = legacy_create.wiki_url {
+                link_urls.insert("wiki".to_string(), wiki_url);
+            }
+            if let Some(discord_url) = legacy_create.discord_url {
+                link_urls.insert("discord".to_string(), discord_url);
+            }
+            if let Some(donation_urls) = legacy_create.donation_urls {
+                for donation_url in donation_urls {
+                    link_urls.insert(donation_url.platform, donation_url.url);
+                }
+            }
+
+            Ok(v3::project_creation::ProjectCreateData {
+                name: legacy_create.title,
+                slug: legacy_create.slug,
+                summary: legacy_create.description, // Description becomes summary
+                description: legacy_create.body,    // Body becomes description
+                initial_versions,
+                categories: legacy_create.categories,
+                additional_categories: legacy_create.additional_categories,
+                license_url: legacy_create.license_url,
+                link_urls,
+                is_draft: legacy_create.is_draft,
+                license_id: legacy_create.license_id,
+                gallery_items: legacy_create.gallery_items,
+                requested_status: legacy_create.requested_status,
+                uploaded_images: legacy_create.uploaded_images,
+                organization_id: legacy_create.organization_id,
+            })
+        },
+    )
+    .await?;
+
+    // Call V3 project creation
+    let response = v3::project_creation::project_create(
+        req,
+        payload,
+        client.clone(),
+        redis.clone(),
+        file_host,
+        session_queue,
+    )
+    .await?;
+
+    // Convert response to V2 format
+    match v2_reroute::extract_ok_json::<Project>(response).await {
+        Ok(project) => {
+            let version_item = match project.versions.first() {
+                Some(vid) => version_item::Version::get((*vid).into(), &**client, &redis).await?,
+                None => None,
+            };
+            let project = LegacyProject::from(project, version_item);
+            Ok(HttpResponse::Ok().json(project))
+        }
+        Err(response) => Ok(response),
+    }
+}

apps/labrinth/src/routes/v2/projects.rs

@@ -0,0 +1,907 @@
+use crate::database::models::categories::LinkPlatform;
+use crate::database::models::{project_item, version_item};
+use crate::database::redis::RedisPool;
+use crate::file_hosting::FileHost;
+use crate::models::projects::{
+    Link, MonetizationStatus, Project, ProjectStatus, SearchRequest, Version,
+};
+use crate::models::v2::projects::{DonationLink, LegacyProject, LegacySideType, LegacyVersion};
+use crate::models::v2::search::LegacySearchResults;
+use crate::queue::moderation::AutomatedModerationQueue;
+use crate::queue::session::AuthQueue;
+use crate::routes::v3::projects::ProjectIds;
+use crate::routes::{v2_reroute, v3, ApiError};
+use crate::search::{search_for_project, SearchConfig, SearchError};
+use actix_web::{delete, get, patch, post, web, HttpRequest, HttpResponse};
+use serde::{Deserialize, Serialize};
+use sqlx::PgPool;
+use std::collections::HashMap;
+use std::sync::Arc;
+use validator::Validate;
+
+pub fn config(cfg: &mut web::ServiceConfig) {
+    cfg.service(project_search);
+    cfg.service(projects_get);
+    cfg.service(projects_edit);
+    cfg.service(random_projects_get);
+
+    cfg.service(
+        web::scope("project")
+            .service(project_get)
+            .service(project_get_check)
+            .service(project_delete)
+            .service(project_edit)
+            .service(project_icon_edit)
+            .service(delete_project_icon)
+            .service(add_gallery_item)
+            .service(edit_gallery_item)
+            .service(delete_gallery_item)
+            .service(project_follow)
+            .service(project_unfollow)
+            .service(super::teams::team_members_get_project)
+            .service(
+                web::scope("{project_id}")
+                    .service(super::versions::version_list)
+                    .service(super::versions::version_project_get)
+                    .service(dependency_list),
+            ),
+    );
+}
+
+#[get("search")]
+pub async fn project_search(
+    web::Query(info): web::Query<SearchRequest>,
+    config: web::Data<SearchConfig>,
+) -> Result<HttpResponse, SearchError> {
+    // Search now uses loader_fields instead of explicit 'client_side' and 'server_side' fields
+    // While the backend for this has changed, it doesnt affect much
+    // in the API calls except that 'versions:x' is now 'game_versions:x'
+    let facets: Option<Vec<Vec<String>>> = if let Some(facets) = info.facets {
+        let facets = serde_json::from_str::<Vec<Vec<String>>>(&facets)?;
+
+        // These loaders specifically used to be combined with 'mod' to be a plugin, but now
+        // they are their own loader type. We will convert 'mod' to 'mod' OR 'plugin'
+        // as it essentially was before.
+        let facets = v2_reroute::convert_plugin_loader_facets_v3(facets);
+
+        Some(
+            facets
+                .into_iter()
+                .map(|facet| {
+                    facet
+                        .into_iter()
+                        .map(|facet| {
+                            if let Some((key, operator, val)) = parse_facet(&facet) {
+                                format!(
+                                    "{}{}{}",
+                                    match key.as_str() {
+                                        "versions" => "game_versions",
+                                        "project_type" => "project_types",
+                                        "title" => "name",
+                                        x => x,
+                                    },
+                                    operator,
+                                    val
+                                )
+                            } else {
+                                facet.to_string()
+                            }
+                        })
+                        .collect::<Vec<_>>()
+                })
+                .collect(),
+        )
+    } else {
+        None
+    };
+
+    let info = SearchRequest {
+        facets: facets.and_then(|x| serde_json::to_string(&x).ok()),
+        ..info
+    };
+
+    let results = search_for_project(&info, &config).await?;
+
+    let results = LegacySearchResults::from(results);
+
+    Ok(HttpResponse::Ok().json(results))
+}
+
+/// Parses a facet into a key, operator, and value
+fn parse_facet(facet: &str) -> Option<(String, String, String)> {
+    let mut key = String::new();
+    let mut operator = String::new();
+    let mut val = String::new();
+
+    let mut iterator = facet.chars();
+    while let Some(char) = iterator.next() {
+        match char {
+            ':' | '=' => {
+                operator.push(char);
+                val = iterator.collect::<String>();
+                return Some((key, operator, val));
+            }
+            '<' | '>' => {
+                operator.push(char);
+                if let Some(next_char) = iterator.next() {
+                    if next_char == '=' {
+                        operator.push(next_char);
+                    } else {
+                        val.push(next_char);
+                    }
+                }
+                val.push_str(&iterator.collect::<String>());
+                return Some((key, operator, val));
+            }
+            ' ' => continue,
+            _ => key.push(char),
+        }
+    }
+
+    None
+}
+
+#[derive(Deserialize, Validate)]
+pub struct RandomProjects {
+    #[validate(range(min = 1, max = 100))]
+    pub count: u32,
+}
+
+#[get("projects_random")]
+pub async fn random_projects_get(
+    web::Query(count): web::Query<RandomProjects>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+) -> Result<HttpResponse, ApiError> {
+    let count = v3::projects::RandomProjects { count: count.count };
+
+    let response =
+        v3::projects::random_projects_get(web::Query(count), pool.clone(), redis.clone())
+            .await
+            .or_else(v2_reroute::flatten_404_error)
+            .or_else(v2_reroute::flatten_404_error)?;
+    // Convert response to V2 format
+    match v2_reroute::extract_ok_json::<Vec<Project>>(response).await {
+        Ok(project) => {
+            let legacy_projects = LegacyProject::from_many(project, &**pool, &redis).await?;
+            Ok(HttpResponse::Ok().json(legacy_projects))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+#[get("projects")]
+pub async fn projects_get(
+    req: HttpRequest,
+    web::Query(ids): web::Query<ProjectIds>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // Call V3 project creation
+    let response = v3::projects::projects_get(
+        req,
+        web::Query(ids),
+        pool.clone(),
+        redis.clone(),
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)
+    .or_else(v2_reroute::flatten_404_error)?;
+
+    // Convert response to V2 format
+    match v2_reroute::extract_ok_json::<Vec<Project>>(response).await {
+        Ok(project) => {
+            let legacy_projects = LegacyProject::from_many(project, &**pool, &redis).await?;
+            Ok(HttpResponse::Ok().json(legacy_projects))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+#[get("{id}")]
+pub async fn project_get(
+    req: HttpRequest,
+    info: web::Path<(String,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // Convert V2 data to V3 data
+    // Call V3 project creation
+    let response = v3::projects::project_get(req, info, pool.clone(), redis.clone(), session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)?;
+
+    // Convert response to V2 format
+    match v2_reroute::extract_ok_json::<Project>(response).await {
+        Ok(project) => {
+            let version_item = match project.versions.first() {
+                Some(vid) => version_item::Version::get((*vid).into(), &**pool, &redis).await?,
+                None => None,
+            };
+            let project = LegacyProject::from(project, version_item);
+            Ok(HttpResponse::Ok().json(project))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+//checks the validity of a project id or slug
+#[get("{id}/check")]
+pub async fn project_get_check(
+    info: web::Path<(String,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+) -> Result<HttpResponse, ApiError> {
+    // Returns an id only, do not need to convert
+    v3::projects::project_get_check(info, pool, redis)
+        .await
+        .or_else(v2_reroute::flatten_404_error)
+}
+
+#[derive(Serialize)]
+struct DependencyInfo {
+    pub projects: Vec<LegacyProject>,
+    pub versions: Vec<LegacyVersion>,
+}
+
+#[get("dependencies")]
+pub async fn dependency_list(
+    req: HttpRequest,
+    info: web::Path<(String,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // TODO: tests, probably
+    let response =
+        v3::projects::dependency_list(req, info, pool.clone(), redis.clone(), session_queue)
+            .await
+            .or_else(v2_reroute::flatten_404_error)?;
+
+    match v2_reroute::extract_ok_json::<crate::routes::v3::projects::DependencyInfo>(response).await
+    {
+        Ok(dependency_info) => {
+            let converted_projects =
+                LegacyProject::from_many(dependency_info.projects, &**pool, &redis).await?;
+            let converted_versions = dependency_info
+                .versions
+                .into_iter()
+                .map(LegacyVersion::from)
+                .collect();
+
+            Ok(HttpResponse::Ok().json(DependencyInfo {
+                projects: converted_projects,
+                versions: converted_versions,
+            }))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+#[derive(Serialize, Deserialize, Validate)]
+pub struct EditProject {
+    #[validate(
+        length(min = 3, max = 64),
+        custom(function = "crate::util::validate::validate_name")
+    )]
+    pub title: Option<String>,
+    #[validate(length(min = 3, max = 256))]
+    pub description: Option<String>,
+    #[validate(length(max = 65536))]
+    pub body: Option<String>,
+    #[validate(length(max = 3))]
+    pub categories: Option<Vec<String>>,
+    #[validate(length(max = 256))]
+    pub additional_categories: Option<Vec<String>>,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        with = "::serde_with::rust::double_option"
+    )]
+    #[validate(
+        custom(function = "crate::util::validate::validate_url"),
+        length(max = 2048)
+    )]
+    pub issues_url: Option<Option<String>>,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        with = "::serde_with::rust::double_option"
+    )]
+    #[validate(
+        custom(function = "crate::util::validate::validate_url"),
+        length(max = 2048)
+    )]
+    pub source_url: Option<Option<String>>,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        with = "::serde_with::rust::double_option"
+    )]
+    #[validate(
+        custom(function = "crate::util::validate::validate_url"),
+        length(max = 2048)
+    )]
+    pub wiki_url: Option<Option<String>>,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        with = "::serde_with::rust::double_option"
+    )]
+    #[validate(
+        custom(function = "crate::util::validate::validate_url"),
+        length(max = 2048)
+    )]
+    pub license_url: Option<Option<String>>,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        with = "::serde_with::rust::double_option"
+    )]
+    #[validate(
+        custom(function = "crate::util::validate::validate_url"),
+        length(max = 2048)
+    )]
+    pub discord_url: Option<Option<String>>,
+    #[validate]
+    pub donation_urls: Option<Vec<DonationLink>>,
+    pub license_id: Option<String>,
+    pub client_side: Option<LegacySideType>,
+    pub server_side: Option<LegacySideType>,
+    #[validate(
+        length(min = 3, max = 64),
+        regex = "crate::util::validate::RE_URL_SAFE"
+    )]
+    pub slug: Option<String>,
+    pub status: Option<ProjectStatus>,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        with = "::serde_with::rust::double_option"
+    )]
+    pub requested_status: Option<Option<ProjectStatus>>,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        with = "::serde_with::rust::double_option"
+    )]
+    #[validate(length(max = 2000))]
+    pub moderation_message: Option<Option<String>>,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        with = "::serde_with::rust::double_option"
+    )]
+    #[validate(length(max = 65536))]
+    pub moderation_message_body: Option<Option<String>>,
+    pub monetization_status: Option<MonetizationStatus>,
+}
+
+#[patch("{id}")]
+#[allow(clippy::too_many_arguments)]
+pub async fn project_edit(
+    req: HttpRequest,
+    info: web::Path<(String,)>,
+    pool: web::Data<PgPool>,
+    search_config: web::Data<SearchConfig>,
+    new_project: web::Json<EditProject>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+    moderation_queue: web::Data<AutomatedModerationQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let v2_new_project = new_project.into_inner();
+    let client_side = v2_new_project.client_side;
+    let server_side = v2_new_project.server_side;
+    let new_slug = v2_new_project.slug.clone();
+
+    // TODO: Some kind of handling here to ensure project type is fine.
+    // We expect the version uploaded to be of loader type modpack, but there might  not be a way to check here for that.
+    // After all, theoretically, they could be creating a genuine 'fabric' mod, and modpack no longer carries information on whether its a mod or modpack,
+    // as those are out to the versions.
+
+    // Ideally this would, if the project 'should' be a modpack:
+    // - change the loaders to mrpack only
+    // - add categories to the project for the corresponding loaders
+
+    let mut new_links = HashMap::new();
+    if let Some(issues_url) = v2_new_project.issues_url {
+        if let Some(issues_url) = issues_url {
+            new_links.insert("issues".to_string(), Some(issues_url));
+        } else {
+            new_links.insert("issues".to_string(), None);
+        }
+    }
+
+    if let Some(source_url) = v2_new_project.source_url {
+        if let Some(source_url) = source_url {
+            new_links.insert("source".to_string(), Some(source_url));
+        } else {
+            new_links.insert("source".to_string(), None);
+        }
+    }
+
+    if let Some(wiki_url) = v2_new_project.wiki_url {
+        if let Some(wiki_url) = wiki_url {
+            new_links.insert("wiki".to_string(), Some(wiki_url));
+        } else {
+            new_links.insert("wiki".to_string(), None);
+        }
+    }
+
+    if let Some(discord_url) = v2_new_project.discord_url {
+        if let Some(discord_url) = discord_url {
+            new_links.insert("discord".to_string(), Some(discord_url));
+        } else {
+            new_links.insert("discord".to_string(), None);
+        }
+    }
+
+    // In v2, setting donation links resets all other donation links
+    // (resetting to the new ones)
+    if let Some(donation_urls) = v2_new_project.donation_urls {
+        // Fetch current donation links from project so we know what to delete
+        let fetched_example_project = project_item::Project::get(&info.0, &**pool, &redis).await?;
+        let donation_links = fetched_example_project
+            .map(|x| {
+                x.urls
+                    .into_iter()
+                    .filter_map(|l| {
+                        if l.donation {
+                            Some(Link::from(l)) // TODO: tests
+                        } else {
+                            None
+                        }
+                    })
+                    .collect::<Vec<_>>()
+            })
+            .unwrap_or_default();
+
+        // Set existing donation links to None
+        for old_link in donation_links {
+            new_links.insert(old_link.platform, None);
+        }
+
+        // Add new donation links
+        for donation_url in donation_urls {
+            new_links.insert(donation_url.id, Some(donation_url.url));
+        }
+    }
+
+    let new_project = v3::projects::EditProject {
+        name: v2_new_project.title,
+        summary: v2_new_project.description, // Description becomes summary
+        description: v2_new_project.body,    // Body becomes description
+        categories: v2_new_project.categories,
+        additional_categories: v2_new_project.additional_categories,
+        license_url: v2_new_project.license_url,
+        link_urls: Some(new_links),
+        license_id: v2_new_project.license_id,
+        slug: v2_new_project.slug,
+        status: v2_new_project.status,
+        requested_status: v2_new_project.requested_status,
+        moderation_message: v2_new_project.moderation_message,
+        moderation_message_body: v2_new_project.moderation_message_body,
+        monetization_status: v2_new_project.monetization_status,
+    };
+
+    // This returns 204 or failure so we don't need to do anything with it
+    let project_id = info.clone().0;
+    let mut response = v3::projects::project_edit(
+        req.clone(),
+        info,
+        pool.clone(),
+        search_config,
+        web::Json(new_project),
+        redis.clone(),
+        session_queue.clone(),
+        moderation_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)?;
+
+    // If client and server side were set, we will call
+    // the version setting route for each version to set the side types for each of them.
+    if response.status().is_success() && (client_side.is_some() || server_side.is_some()) {
+        let project_item =
+            project_item::Project::get(&new_slug.unwrap_or(project_id), &**pool, &redis).await?;
+        let version_ids = project_item.map(|x| x.versions).unwrap_or_default();
+        let versions = version_item::Version::get_many(&version_ids, &**pool, &redis).await?;
+        for version in versions {
+            let version = Version::from(version);
+            let mut fields = version.fields;
+            let (current_client_side, current_server_side) =
+                v2_reroute::convert_side_types_v2(&fields, None);
+            let client_side = client_side.unwrap_or(current_client_side);
+            let server_side = server_side.unwrap_or(current_server_side);
+            fields.extend(v2_reroute::convert_side_types_v3(client_side, server_side));
+
+            response = v3::versions::version_edit_helper(
+                req.clone(),
+                (version.id,),
+                pool.clone(),
+                redis.clone(),
+                v3::versions::EditVersion {
+                    fields,
+                    ..Default::default()
+                },
+                session_queue.clone(),
+            )
+            .await?;
+        }
+    }
+    Ok(response)
+}
+
+#[derive(Deserialize, Validate)]
+pub struct BulkEditProject {
+    #[validate(length(max = 3))]
+    pub categories: Option<Vec<String>>,
+    #[validate(length(max = 3))]
+    pub add_categories: Option<Vec<String>>,
+    pub remove_categories: Option<Vec<String>>,
+
+    #[validate(length(max = 256))]
+    pub additional_categories: Option<Vec<String>>,
+    #[validate(length(max = 3))]
+    pub add_additional_categories: Option<Vec<String>>,
+    pub remove_additional_categories: Option<Vec<String>>,
+
+    #[validate]
+    pub donation_urls: Option<Vec<DonationLink>>,
+    #[validate]
+    pub add_donation_urls: Option<Vec<DonationLink>>,
+    #[validate]
+    pub remove_donation_urls: Option<Vec<DonationLink>>,
+
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        with = "::serde_with::rust::double_option"
+    )]
+    #[validate(
+        custom(function = "crate::util::validate::validate_url"),
+        length(max = 2048)
+    )]
+    pub issues_url: Option<Option<String>>,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        with = "::serde_with::rust::double_option"
+    )]
+    #[validate(
+        custom(function = "crate::util::validate::validate_url"),
+        length(max = 2048)
+    )]
+    pub source_url: Option<Option<String>>,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        with = "::serde_with::rust::double_option"
+    )]
+    #[validate(
+        custom(function = "crate::util::validate::validate_url"),
+        length(max = 2048)
+    )]
+    pub wiki_url: Option<Option<String>>,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        with = "::serde_with::rust::double_option"
+    )]
+    #[validate(
+        custom(function = "crate::util::validate::validate_url"),
+        length(max = 2048)
+    )]
+    pub discord_url: Option<Option<String>>,
+}
+
+#[patch("projects")]
+pub async fn projects_edit(
+    req: HttpRequest,
+    web::Query(ids): web::Query<ProjectIds>,
+    pool: web::Data<PgPool>,
+    bulk_edit_project: web::Json<BulkEditProject>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let bulk_edit_project = bulk_edit_project.into_inner();
+
+    let mut link_urls = HashMap::new();
+
+    // If we are *setting* donation links, we will set every possible donation link to None, as
+    // setting will delete all of them then 're-add' the ones we want to keep
+    if let Some(donation_url) = bulk_edit_project.donation_urls {
+        let link_platforms = LinkPlatform::list(&**pool, &redis).await?;
+        for link in link_platforms {
+            if link.donation {
+                link_urls.insert(link.name, None);
+            }
+        }
+        // add
+        for donation_url in donation_url {
+            link_urls.insert(donation_url.id, Some(donation_url.url));
+        }
+    }
+
+    // For every delete, we will set the link to None
+    if let Some(donation_url) = bulk_edit_project.remove_donation_urls {
+        for donation_url in donation_url {
+            link_urls.insert(donation_url.id, None);
+        }
+    }
+
+    // For every add, we will set the link to the new url
+    if let Some(donation_url) = bulk_edit_project.add_donation_urls {
+        for donation_url in donation_url {
+            link_urls.insert(donation_url.id, Some(donation_url.url));
+        }
+    }
+
+    if let Some(issue_url) = bulk_edit_project.issues_url {
+        if let Some(issue_url) = issue_url {
+            link_urls.insert("issues".to_string(), Some(issue_url));
+        } else {
+            link_urls.insert("issues".to_string(), None);
+        }
+    }
+
+    if let Some(source_url) = bulk_edit_project.source_url {
+        if let Some(source_url) = source_url {
+            link_urls.insert("source".to_string(), Some(source_url));
+        } else {
+            link_urls.insert("source".to_string(), None);
+        }
+    }
+
+    if let Some(wiki_url) = bulk_edit_project.wiki_url {
+        if let Some(wiki_url) = wiki_url {
+            link_urls.insert("wiki".to_string(), Some(wiki_url));
+        } else {
+            link_urls.insert("wiki".to_string(), None);
+        }
+    }
+
+    if let Some(discord_url) = bulk_edit_project.discord_url {
+        if let Some(discord_url) = discord_url {
+            link_urls.insert("discord".to_string(), Some(discord_url));
+        } else {
+            link_urls.insert("discord".to_string(), None);
+        }
+    }
+
+    // This returns NoContent or failure so we don't need to do anything with it
+    v3::projects::projects_edit(
+        req,
+        web::Query(ids),
+        pool.clone(),
+        web::Json(v3::projects::BulkEditProject {
+            categories: bulk_edit_project.categories,
+            add_categories: bulk_edit_project.add_categories,
+            remove_categories: bulk_edit_project.remove_categories,
+            additional_categories: bulk_edit_project.additional_categories,
+            add_additional_categories: bulk_edit_project.add_additional_categories,
+            remove_additional_categories: bulk_edit_project.remove_additional_categories,
+            link_urls: Some(link_urls),
+        }),
+        redis,
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Extension {
+    pub ext: String,
+}
+
+#[patch("{id}/icon")]
+#[allow(clippy::too_many_arguments)]
+pub async fn project_icon_edit(
+    web::Query(ext): web::Query<Extension>,
+    req: HttpRequest,
+    info: web::Path<(String,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    file_host: web::Data<Arc<dyn FileHost + Send + Sync>>,
+    payload: web::Payload,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // Returns NoContent, so no need to convert
+    v3::projects::project_icon_edit(
+        web::Query(v3::projects::Extension { ext: ext.ext }),
+        req,
+        info,
+        pool,
+        redis,
+        file_host,
+        payload,
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)
+}
+
+#[delete("{id}/icon")]
+pub async fn delete_project_icon(
+    req: HttpRequest,
+    info: web::Path<(String,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    file_host: web::Data<Arc<dyn FileHost + Send + Sync>>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // Returns NoContent, so no need to convert
+    v3::projects::delete_project_icon(req, info, pool, redis, file_host, session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)
+}
+
+#[derive(Serialize, Deserialize, Validate)]
+pub struct GalleryCreateQuery {
+    pub featured: bool,
+    #[validate(length(min = 1, max = 255))]
+    pub title: Option<String>,
+    #[validate(length(min = 1, max = 2048))]
+    pub description: Option<String>,
+    pub ordering: Option<i64>,
+}
+
+#[post("{id}/gallery")]
+#[allow(clippy::too_many_arguments)]
+pub async fn add_gallery_item(
+    web::Query(ext): web::Query<Extension>,
+    req: HttpRequest,
+    web::Query(item): web::Query<GalleryCreateQuery>,
+    info: web::Path<(String,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    file_host: web::Data<Arc<dyn FileHost + Send + Sync>>,
+    payload: web::Payload,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // Returns NoContent, so no need to convert
+    v3::projects::add_gallery_item(
+        web::Query(v3::projects::Extension { ext: ext.ext }),
+        req,
+        web::Query(v3::projects::GalleryCreateQuery {
+            featured: item.featured,
+            name: item.title,
+            description: item.description,
+            ordering: item.ordering,
+        }),
+        info,
+        pool,
+        redis,
+        file_host,
+        payload,
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)
+}
+
+#[derive(Serialize, Deserialize, Validate)]
+pub struct GalleryEditQuery {
+    /// The url of the gallery item to edit
+    pub url: String,
+    pub featured: Option<bool>,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        with = "::serde_with::rust::double_option"
+    )]
+    #[validate(length(min = 1, max = 255))]
+    pub title: Option<Option<String>>,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        with = "::serde_with::rust::double_option"
+    )]
+    #[validate(length(min = 1, max = 2048))]
+    pub description: Option<Option<String>>,
+    pub ordering: Option<i64>,
+}
+
+#[patch("{id}/gallery")]
+pub async fn edit_gallery_item(
+    req: HttpRequest,
+    web::Query(item): web::Query<GalleryEditQuery>,
+    info: web::Path<(String,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // Returns NoContent, so no need to convert
+    v3::projects::edit_gallery_item(
+        req,
+        web::Query(v3::projects::GalleryEditQuery {
+            url: item.url,
+            featured: item.featured,
+            name: item.title,
+            description: item.description,
+            ordering: item.ordering,
+        }),
+        info,
+        pool,
+        redis,
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct GalleryDeleteQuery {
+    pub url: String,
+}
+
+#[delete("{id}/gallery")]
+pub async fn delete_gallery_item(
+    req: HttpRequest,
+    web::Query(item): web::Query<GalleryDeleteQuery>,
+    info: web::Path<(String,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    file_host: web::Data<Arc<dyn FileHost + Send + Sync>>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // Returns NoContent, so no need to convert
+    v3::projects::delete_gallery_item(
+        req,
+        web::Query(v3::projects::GalleryDeleteQuery { url: item.url }),
+        info,
+        pool,
+        redis,
+        file_host,
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)
+}
+
+#[delete("{id}")]
+pub async fn project_delete(
+    req: HttpRequest,
+    info: web::Path<(String,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    search_config: web::Data<SearchConfig>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // Returns NoContent, so no need to convert
+    v3::projects::project_delete(req, info, pool, redis, search_config, session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)
+}
+
+#[post("{id}/follow")]
+pub async fn project_follow(
+    req: HttpRequest,
+    info: web::Path<(String,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // Returns NoContent, so no need to convert
+    v3::projects::project_follow(req, info, pool, redis, session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)
+}
+
+#[delete("{id}/follow")]
+pub async fn project_unfollow(
+    req: HttpRequest,
+    info: web::Path<(String,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // Returns NoContent, so no need to convert
+    v3::projects::project_unfollow(req, info, pool, redis, session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)
+}

apps/labrinth/src/routes/v2/reports.rs

@@ -0,0 +1,188 @@
+use crate::database::redis::RedisPool;
+use crate::models::reports::Report;
+use crate::models::v2::reports::LegacyReport;
+use crate::queue::session::AuthQueue;
+use crate::routes::{v2_reroute, v3, ApiError};
+use actix_web::{delete, get, patch, post, web, HttpRequest, HttpResponse};
+use serde::Deserialize;
+use sqlx::PgPool;
+use validator::Validate;
+
+pub fn config(cfg: &mut web::ServiceConfig) {
+    cfg.service(reports_get);
+    cfg.service(reports);
+    cfg.service(report_create);
+    cfg.service(report_edit);
+    cfg.service(report_delete);
+    cfg.service(report_get);
+}
+
+#[post("report")]
+pub async fn report_create(
+    req: HttpRequest,
+    pool: web::Data<PgPool>,
+    body: web::Payload,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let response = v3::reports::report_create(req, pool, body, redis, session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)?;
+
+    // Convert response to V2 format
+    match v2_reroute::extract_ok_json::<Report>(response).await {
+        Ok(report) => {
+            let report = LegacyReport::from(report);
+            Ok(HttpResponse::Ok().json(report))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+#[derive(Deserialize)]
+pub struct ReportsRequestOptions {
+    #[serde(default = "default_count")]
+    count: i16,
+    #[serde(default = "default_all")]
+    all: bool,
+}
+
+fn default_count() -> i16 {
+    100
+}
+fn default_all() -> bool {
+    true
+}
+
+#[get("report")]
+pub async fn reports(
+    req: HttpRequest,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    count: web::Query<ReportsRequestOptions>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let response = v3::reports::reports(
+        req,
+        pool,
+        redis,
+        web::Query(v3::reports::ReportsRequestOptions {
+            count: count.count,
+            all: count.all,
+        }),
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)?;
+
+    // Convert response to V2 format
+    match v2_reroute::extract_ok_json::<Vec<Report>>(response).await {
+        Ok(reports) => {
+            let reports: Vec<_> = reports.into_iter().map(LegacyReport::from).collect();
+            Ok(HttpResponse::Ok().json(reports))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+#[derive(Deserialize)]
+pub struct ReportIds {
+    pub ids: String,
+}
+
+#[get("reports")]
+pub async fn reports_get(
+    req: HttpRequest,
+    web::Query(ids): web::Query<ReportIds>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let response = v3::reports::reports_get(
+        req,
+        web::Query(v3::reports::ReportIds { ids: ids.ids }),
+        pool,
+        redis,
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)?;
+
+    // Convert response to V2 format
+    match v2_reroute::extract_ok_json::<Vec<Report>>(response).await {
+        Ok(report_list) => {
+            let report_list: Vec<_> = report_list.into_iter().map(LegacyReport::from).collect();
+            Ok(HttpResponse::Ok().json(report_list))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+#[get("report/{id}")]
+pub async fn report_get(
+    req: HttpRequest,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    info: web::Path<(crate::models::reports::ReportId,)>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let response = v3::reports::report_get(req, pool, redis, info, session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)?;
+
+    // Convert response to V2 format
+    match v2_reroute::extract_ok_json::<Report>(response).await {
+        Ok(report) => {
+            let report = LegacyReport::from(report);
+            Ok(HttpResponse::Ok().json(report))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+#[derive(Deserialize, Validate)]
+pub struct EditReport {
+    #[validate(length(max = 65536))]
+    pub body: Option<String>,
+    pub closed: Option<bool>,
+}
+
+#[patch("report/{id}")]
+pub async fn report_edit(
+    req: HttpRequest,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    info: web::Path<(crate::models::reports::ReportId,)>,
+    session_queue: web::Data<AuthQueue>,
+    edit_report: web::Json<EditReport>,
+) -> Result<HttpResponse, ApiError> {
+    let edit_report = edit_report.into_inner();
+    // Returns NoContent, so no need to convert
+    v3::reports::report_edit(
+        req,
+        pool,
+        redis,
+        info,
+        session_queue,
+        web::Json(v3::reports::EditReport {
+            body: edit_report.body,
+            closed: edit_report.closed,
+        }),
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)
+}
+
+#[delete("report/{id}")]
+pub async fn report_delete(
+    req: HttpRequest,
+    pool: web::Data<PgPool>,
+    info: web::Path<(crate::models::reports::ReportId,)>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // Returns NoContent, so no need to convert
+    v3::reports::report_delete(req, pool, info, redis, session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)
+}

apps/labrinth/src/routes/v2/statistics.rs

@@ -0,0 +1,39 @@
+use crate::routes::{
+    v2_reroute,
+    v3::{self, statistics::V3Stats},
+    ApiError,
+};
+use actix_web::{get, web, HttpResponse};
+use sqlx::PgPool;
+
+pub fn config(cfg: &mut web::ServiceConfig) {
+    cfg.service(get_stats);
+}
+
+#[derive(serde::Serialize)]
+pub struct V2Stats {
+    pub projects: Option<i64>,
+    pub versions: Option<i64>,
+    pub authors: Option<i64>,
+    pub files: Option<i64>,
+}
+
+#[get("statistics")]
+pub async fn get_stats(pool: web::Data<PgPool>) -> Result<HttpResponse, ApiError> {
+    let response = v3::statistics::get_stats(pool)
+        .await
+        .or_else(v2_reroute::flatten_404_error)?;
+
+    match v2_reroute::extract_ok_json::<V3Stats>(response).await {
+        Ok(stats) => {
+            let stats = V2Stats {
+                projects: stats.projects,
+                versions: stats.versions,
+                authors: stats.authors,
+                files: stats.files,
+            };
+            Ok(HttpResponse::Ok().json(stats))
+        }
+        Err(response) => Ok(response),
+    }
+}

apps/labrinth/src/routes/v2/tags.rs

@@ -0,0 +1,314 @@
+use std::collections::HashMap;
+
+use super::ApiError;
+use crate::database::models::loader_fields::LoaderFieldEnumValue;
+use crate::database::redis::RedisPool;
+use crate::models::v2::projects::LegacySideType;
+use crate::routes::v2_reroute::capitalize_first;
+use crate::routes::v3::tags::{LinkPlatformQueryData, LoaderFieldsEnumQuery};
+use crate::routes::{v2_reroute, v3};
+use actix_web::{get, web, HttpResponse};
+use chrono::{DateTime, Utc};
+use itertools::Itertools;
+use sqlx::PgPool;
+
+pub fn config(cfg: &mut web::ServiceConfig) {
+    cfg.service(
+        web::scope("tag")
+            .service(category_list)
+            .service(loader_list)
+            .service(game_version_list)
+            .service(license_list)
+            .service(license_text)
+            .service(donation_platform_list)
+            .service(report_type_list)
+            .service(project_type_list)
+            .service(side_type_list),
+    );
+}
+
+#[derive(serde::Serialize, serde::Deserialize)]
+pub struct CategoryData {
+    pub icon: String,
+    pub name: String,
+    pub project_type: String,
+    pub header: String,
+}
+
+#[get("category")]
+pub async fn category_list(
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+) -> Result<HttpResponse, ApiError> {
+    let response = v3::tags::category_list(pool, redis).await?;
+
+    // Convert to V2 format
+    match v2_reroute::extract_ok_json::<Vec<v3::tags::CategoryData>>(response).await {
+        Ok(categories) => {
+            let categories = categories
+                .into_iter()
+                .map(|c| CategoryData {
+                    icon: c.icon,
+                    name: c.name,
+                    project_type: c.project_type,
+                    header: c.header,
+                })
+                .collect::<Vec<_>>();
+            Ok(HttpResponse::Ok().json(categories))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+#[derive(serde::Serialize, serde::Deserialize)]
+pub struct LoaderData {
+    pub icon: String,
+    pub name: String,
+    pub supported_project_types: Vec<String>,
+}
+
+#[get("loader")]
+pub async fn loader_list(
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+) -> Result<HttpResponse, ApiError> {
+    let response = v3::tags::loader_list(pool, redis).await?;
+
+    // Convert to V2 format
+    match v2_reroute::extract_ok_json::<Vec<v3::tags::LoaderData>>(response).await {
+        Ok(loaders) => {
+            let loaders = loaders
+                .into_iter()
+                .filter(|l| &*l.name != "mrpack")
+                .map(|l| {
+                    let mut supported_project_types = l.supported_project_types;
+                    // Add generic 'project' type to all loaders, which is the v2 representation of
+                    // a project type before any versions are set.
+                    supported_project_types.push("project".to_string());
+
+                    if ["forge", "fabric", "quilt", "neoforge"].contains(&&*l.name) {
+                        supported_project_types.push("modpack".to_string());
+                    }
+
+                    if supported_project_types.contains(&"datapack".to_string())
+                        || supported_project_types.contains(&"plugin".to_string())
+                    {
+                        supported_project_types.push("mod".to_string());
+                    }
+
+                    LoaderData {
+                        icon: l.icon,
+                        name: l.name,
+                        supported_project_types,
+                    }
+                })
+                .collect::<Vec<_>>();
+            Ok(HttpResponse::Ok().json(loaders))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+#[derive(serde::Serialize, serde::Deserialize)]
+pub struct GameVersionQueryData {
+    pub version: String,
+    pub version_type: String,
+    pub date: DateTime<Utc>,
+    pub major: bool,
+}
+
+#[derive(serde::Deserialize)]
+pub struct GameVersionQuery {
+    #[serde(rename = "type")]
+    type_: Option<String>,
+    major: Option<bool>,
+}
+
+#[get("game_version")]
+pub async fn game_version_list(
+    pool: web::Data<PgPool>,
+    query: web::Query<GameVersionQuery>,
+    redis: web::Data<RedisPool>,
+) -> Result<HttpResponse, ApiError> {
+    let mut filters = HashMap::new();
+    if let Some(type_) = &query.type_ {
+        filters.insert("type".to_string(), serde_json::json!(type_));
+    }
+    if let Some(major) = query.major {
+        filters.insert("major".to_string(), serde_json::json!(major));
+    }
+    let response = v3::tags::loader_fields_list(
+        pool,
+        web::Query(LoaderFieldsEnumQuery {
+            loader_field: "game_versions".to_string(),
+            filters: Some(filters),
+        }),
+        redis,
+    )
+    .await?;
+
+    // Convert to V2 format
+    Ok(
+        match v2_reroute::extract_ok_json::<Vec<LoaderFieldEnumValue>>(response).await {
+            Ok(fields) => {
+                let fields = fields
+                    .into_iter()
+                    .map(|f| GameVersionQueryData {
+                        version: f.value,
+                        version_type: f
+                            .metadata
+                            .get("type")
+                            .and_then(|m| m.as_str())
+                            .unwrap_or_default()
+                            .to_string(),
+                        date: f.created,
+                        major: f
+                            .metadata
+                            .get("major")
+                            .and_then(|m| m.as_bool())
+                            .unwrap_or_default(),
+                    })
+                    .collect::<Vec<_>>();
+                HttpResponse::Ok().json(fields)
+            }
+            Err(response) => response,
+        },
+    )
+}
+
+#[derive(serde::Serialize)]
+pub struct License {
+    pub short: String,
+    pub name: String,
+}
+
+#[get("license")]
+pub async fn license_list() -> HttpResponse {
+    let response = v3::tags::license_list().await;
+
+    // Convert to V2 format
+    match v2_reroute::extract_ok_json::<Vec<v3::tags::License>>(response).await {
+        Ok(licenses) => {
+            let licenses = licenses
+                .into_iter()
+                .map(|l| License {
+                    short: l.short,
+                    name: l.name,
+                })
+                .collect::<Vec<_>>();
+            HttpResponse::Ok().json(licenses)
+        }
+        Err(response) => response,
+    }
+}
+
+#[derive(serde::Serialize)]
+pub struct LicenseText {
+    pub title: String,
+    pub body: String,
+}
+
+#[get("license/{id}")]
+pub async fn license_text(params: web::Path<(String,)>) -> Result<HttpResponse, ApiError> {
+    let license = v3::tags::license_text(params)
+        .await
+        .or_else(v2_reroute::flatten_404_error)?;
+
+    // Convert to V2 format
+    Ok(
+        match v2_reroute::extract_ok_json::<v3::tags::LicenseText>(license).await {
+            Ok(license) => HttpResponse::Ok().json(LicenseText {
+                title: license.title,
+                body: license.body,
+            }),
+            Err(response) => response,
+        },
+    )
+}
+
+#[derive(serde::Serialize, serde::Deserialize, PartialEq, Eq, Debug)]
+pub struct DonationPlatformQueryData {
+    // The difference between name and short is removed in v3.
+    // Now, the 'id' becomes the name, and the 'name' is removed (the frontend uses the id as the name)
+    // pub short: String,
+    pub short: String,
+    pub name: String,
+}
+
+#[get("donation_platform")]
+pub async fn donation_platform_list(
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+) -> Result<HttpResponse, ApiError> {
+    let response = v3::tags::link_platform_list(pool, redis).await?;
+
+    // Convert to V2 format
+    Ok(
+        match v2_reroute::extract_ok_json::<Vec<LinkPlatformQueryData>>(response).await {
+            Ok(platforms) => {
+                let platforms = platforms
+                    .into_iter()
+                    .filter_map(|p| {
+                        if p.donation {
+                            Some(DonationPlatformQueryData {
+                                // Short vs name is no longer a recognized difference in v3.
+                                // We capitalize to recreate the old behavior, with some special handling.
+                                // This may result in different behaviour for platforms added after the v3 migration.
+                                name: match p.name.as_str() {
+                                    "bmac" => "Buy Me A Coffee".to_string(),
+                                    "github" => "GitHub Sponsors".to_string(),
+                                    "ko-fi" => "Ko-fi".to_string(),
+                                    "paypal" => "PayPal".to_string(),
+                                    // Otherwise, capitalize it
+                                    _ => capitalize_first(&p.name),
+                                },
+                                short: p.name,
+                            })
+                        } else {
+                            None
+                        }
+                    })
+                    .collect::<Vec<_>>();
+                HttpResponse::Ok().json(platforms)
+            }
+            Err(response) => response,
+        },
+    )
+    .or_else(v2_reroute::flatten_404_error)
+}
+
+#[get("report_type")]
+pub async fn report_type_list(
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+) -> Result<HttpResponse, ApiError> {
+    // This returns a list of strings directly, so we don't need to convert to v2 format.
+    v3::tags::report_type_list(pool, redis)
+        .await
+        .or_else(v2_reroute::flatten_404_error)
+}
+
+#[get("project_type")]
+pub async fn project_type_list(
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+) -> Result<HttpResponse, ApiError> {
+    // This returns a list of strings directly, so we don't need to convert to v2 format.
+    v3::tags::project_type_list(pool, redis)
+        .await
+        .or_else(v2_reroute::flatten_404_error)
+}
+
+#[get("side_type")]
+pub async fn side_type_list() -> Result<HttpResponse, ApiError> {
+    // Original side types are no longer reflected in the database.
+    // Therefore, we hardcode and return all the fields that are supported by our v2 conversion logic.
+    let side_types = [
+        LegacySideType::Required,
+        LegacySideType::Optional,
+        LegacySideType::Unsupported,
+        LegacySideType::Unknown,
+    ];
+    let side_types = side_types.iter().map(|s| s.to_string()).collect_vec();
+    Ok(HttpResponse::Ok().json(side_types))
+}

apps/labrinth/src/routes/v2/teams.rs

@@ -0,0 +1,265 @@
+use crate::database::redis::RedisPool;
+use crate::models::teams::{OrganizationPermissions, ProjectPermissions, TeamId, TeamMember};
+use crate::models::users::UserId;
+use crate::models::v2::teams::LegacyTeamMember;
+use crate::queue::session::AuthQueue;
+use crate::routes::{v2_reroute, v3, ApiError};
+use actix_web::{delete, get, patch, post, web, HttpRequest, HttpResponse};
+use rust_decimal::Decimal;
+use serde::{Deserialize, Serialize};
+use sqlx::PgPool;
+
+pub fn config(cfg: &mut web::ServiceConfig) {
+    cfg.service(teams_get);
+
+    cfg.service(
+        web::scope("team")
+            .service(team_members_get)
+            .service(edit_team_member)
+            .service(transfer_ownership)
+            .service(add_team_member)
+            .service(join_team)
+            .service(remove_team_member),
+    );
+}
+
+// Returns all members of a project,
+// including the team members of the project's team, but
+// also the members of the organization's team if the project is associated with an organization
+// (Unlike team_members_get_project, which only returns the members of the project's team)
+// They can be differentiated by the "organization_permissions" field being null or not
+#[get("{id}/members")]
+pub async fn team_members_get_project(
+    req: HttpRequest,
+    info: web::Path<(String,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let response = v3::teams::team_members_get_project(req, info, pool, redis, session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)?;
+    // Convert response to V2 format
+    match v2_reroute::extract_ok_json::<Vec<TeamMember>>(response).await {
+        Ok(members) => {
+            let members = members
+                .into_iter()
+                .map(LegacyTeamMember::from)
+                .collect::<Vec<_>>();
+            Ok(HttpResponse::Ok().json(members))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+// Returns all members of a team, but not necessarily those of a project-team's organization (unlike team_members_get_project)
+#[get("{id}/members")]
+pub async fn team_members_get(
+    req: HttpRequest,
+    info: web::Path<(TeamId,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let response = v3::teams::team_members_get(req, info, pool, redis, session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)?;
+    // Convert response to V2 format
+    match v2_reroute::extract_ok_json::<Vec<TeamMember>>(response).await {
+        Ok(members) => {
+            let members = members
+                .into_iter()
+                .map(LegacyTeamMember::from)
+                .collect::<Vec<_>>();
+            Ok(HttpResponse::Ok().json(members))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct TeamIds {
+    pub ids: String,
+}
+
+#[get("teams")]
+pub async fn teams_get(
+    req: HttpRequest,
+    web::Query(ids): web::Query<TeamIds>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let response = v3::teams::teams_get(
+        req,
+        web::Query(v3::teams::TeamIds { ids: ids.ids }),
+        pool,
+        redis,
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error);
+    // Convert response to V2 format
+    match v2_reroute::extract_ok_json::<Vec<Vec<TeamMember>>>(response?).await {
+        Ok(members) => {
+            let members = members
+                .into_iter()
+                .map(|members| {
+                    members
+                        .into_iter()
+                        .map(LegacyTeamMember::from)
+                        .collect::<Vec<_>>()
+                })
+                .collect::<Vec<_>>();
+            Ok(HttpResponse::Ok().json(members))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+#[post("{id}/join")]
+pub async fn join_team(
+    req: HttpRequest,
+    info: web::Path<(TeamId,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // Returns NoContent, so we don't need to convert the response
+    v3::teams::join_team(req, info, pool, redis, session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)
+}
+
+fn default_role() -> String {
+    "Member".to_string()
+}
+
+fn default_ordering() -> i64 {
+    0
+}
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct NewTeamMember {
+    pub user_id: UserId,
+    #[serde(default = "default_role")]
+    pub role: String,
+    #[serde(default)]
+    pub permissions: ProjectPermissions,
+    #[serde(default)]
+    pub organization_permissions: Option<OrganizationPermissions>,
+    #[serde(default)]
+    #[serde(with = "rust_decimal::serde::float")]
+    pub payouts_split: Decimal,
+    #[serde(default = "default_ordering")]
+    pub ordering: i64,
+}
+
+#[post("{id}/members")]
+pub async fn add_team_member(
+    req: HttpRequest,
+    info: web::Path<(TeamId,)>,
+    pool: web::Data<PgPool>,
+    new_member: web::Json<NewTeamMember>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // Returns NoContent, so we don't need to convert the response
+    v3::teams::add_team_member(
+        req,
+        info,
+        pool,
+        web::Json(v3::teams::NewTeamMember {
+            user_id: new_member.user_id,
+            role: new_member.role.clone(),
+            permissions: new_member.permissions,
+            organization_permissions: new_member.organization_permissions,
+            payouts_split: new_member.payouts_split,
+            ordering: new_member.ordering,
+        }),
+        redis,
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)
+}
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct EditTeamMember {
+    pub permissions: Option<ProjectPermissions>,
+    pub organization_permissions: Option<OrganizationPermissions>,
+    pub role: Option<String>,
+    pub payouts_split: Option<Decimal>,
+    pub ordering: Option<i64>,
+}
+
+#[patch("{id}/members/{user_id}")]
+pub async fn edit_team_member(
+    req: HttpRequest,
+    info: web::Path<(TeamId, UserId)>,
+    pool: web::Data<PgPool>,
+    edit_member: web::Json<EditTeamMember>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // Returns NoContent, so we don't need to convert the response
+    v3::teams::edit_team_member(
+        req,
+        info,
+        pool,
+        web::Json(v3::teams::EditTeamMember {
+            permissions: edit_member.permissions,
+            organization_permissions: edit_member.organization_permissions,
+            role: edit_member.role.clone(),
+            payouts_split: edit_member.payouts_split,
+            ordering: edit_member.ordering,
+        }),
+        redis,
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)
+}
+
+#[derive(Deserialize)]
+pub struct TransferOwnership {
+    pub user_id: UserId,
+}
+
+#[patch("{id}/owner")]
+pub async fn transfer_ownership(
+    req: HttpRequest,
+    info: web::Path<(TeamId,)>,
+    pool: web::Data<PgPool>,
+    new_owner: web::Json<TransferOwnership>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // Returns NoContent, so we don't need to convert the response
+    v3::teams::transfer_ownership(
+        req,
+        info,
+        pool,
+        web::Json(v3::teams::TransferOwnership {
+            user_id: new_owner.user_id,
+        }),
+        redis,
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)
+}
+
+#[delete("{id}/members/{user_id}")]
+pub async fn remove_team_member(
+    req: HttpRequest,
+    info: web::Path<(TeamId, UserId)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // Returns NoContent, so we don't need to convert the response
+    v3::teams::remove_team_member(req, info, pool, redis, session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)
+}

apps/labrinth/src/routes/v2/threads.rs

@@ -0,0 +1,116 @@
+use std::sync::Arc;
+
+use crate::database::redis::RedisPool;
+use crate::file_hosting::FileHost;
+use crate::models::ids::ThreadMessageId;
+use crate::models::threads::{MessageBody, Thread, ThreadId};
+use crate::models::v2::threads::LegacyThread;
+use crate::queue::session::AuthQueue;
+use crate::routes::{v2_reroute, v3, ApiError};
+use actix_web::{delete, get, post, web, HttpRequest, HttpResponse};
+use serde::Deserialize;
+use sqlx::PgPool;
+
+pub fn config(cfg: &mut web::ServiceConfig) {
+    cfg.service(
+        web::scope("thread")
+            .service(thread_get)
+            .service(thread_send_message),
+    );
+    cfg.service(web::scope("message").service(message_delete));
+    cfg.service(threads_get);
+}
+
+#[get("{id}")]
+pub async fn thread_get(
+    req: HttpRequest,
+    info: web::Path<(ThreadId,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    v3::threads::thread_get(req, info, pool, redis, session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)
+}
+
+#[derive(Deserialize)]
+pub struct ThreadIds {
+    pub ids: String,
+}
+
+#[get("threads")]
+pub async fn threads_get(
+    req: HttpRequest,
+    web::Query(ids): web::Query<ThreadIds>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let response = v3::threads::threads_get(
+        req,
+        web::Query(v3::threads::ThreadIds { ids: ids.ids }),
+        pool,
+        redis,
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)?;
+
+    // Convert response to V2 format
+    match v2_reroute::extract_ok_json::<Vec<Thread>>(response).await {
+        Ok(threads) => {
+            let threads = threads
+                .into_iter()
+                .map(LegacyThread::from)
+                .collect::<Vec<_>>();
+            Ok(HttpResponse::Ok().json(threads))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+#[derive(Deserialize)]
+pub struct NewThreadMessage {
+    pub body: MessageBody,
+}
+
+#[post("{id}")]
+pub async fn thread_send_message(
+    req: HttpRequest,
+    info: web::Path<(ThreadId,)>,
+    pool: web::Data<PgPool>,
+    new_message: web::Json<NewThreadMessage>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let new_message = new_message.into_inner();
+    // Returns NoContent, so we don't need to convert the response
+    v3::threads::thread_send_message(
+        req,
+        info,
+        pool,
+        web::Json(v3::threads::NewThreadMessage {
+            body: new_message.body,
+        }),
+        redis,
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)
+}
+
+#[delete("{id}")]
+pub async fn message_delete(
+    req: HttpRequest,
+    info: web::Path<(ThreadMessageId,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+    file_host: web::Data<Arc<dyn FileHost + Send + Sync>>,
+) -> Result<HttpResponse, ApiError> {
+    // Returns NoContent, so we don't need to convert the response
+    v3::threads::message_delete(req, info, pool, redis, session_queue, file_host)
+        .await
+        .or_else(v2_reroute::flatten_404_error)
+}

apps/labrinth/src/routes/v2/users.rs

@@ -0,0 +1,269 @@
+use crate::database::redis::RedisPool;
+use crate::file_hosting::FileHost;
+use crate::models::notifications::Notification;
+use crate::models::projects::Project;
+use crate::models::users::{Badges, Role, User};
+use crate::models::v2::notifications::LegacyNotification;
+use crate::models::v2::projects::LegacyProject;
+use crate::models::v2::user::LegacyUser;
+use crate::queue::session::AuthQueue;
+use crate::routes::{v2_reroute, v3, ApiError};
+use actix_web::{delete, get, patch, web, HttpRequest, HttpResponse};
+use lazy_static::lazy_static;
+use regex::Regex;
+use serde::{Deserialize, Serialize};
+use sqlx::PgPool;
+use std::sync::Arc;
+use validator::Validate;
+
+pub fn config(cfg: &mut web::ServiceConfig) {
+    cfg.service(user_auth_get);
+    cfg.service(users_get);
+
+    cfg.service(
+        web::scope("user")
+            .service(user_get)
+            .service(projects_list)
+            .service(user_delete)
+            .service(user_edit)
+            .service(user_icon_edit)
+            .service(user_notifications)
+            .service(user_follows),
+    );
+}
+
+#[get("user")]
+pub async fn user_auth_get(
+    req: HttpRequest,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let response = v3::users::user_auth_get(req, pool, redis, session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)?;
+
+    // Convert response to V2 format
+    match v2_reroute::extract_ok_json::<User>(response).await {
+        Ok(user) => {
+            let user = LegacyUser::from(user);
+            Ok(HttpResponse::Ok().json(user))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct UserIds {
+    pub ids: String,
+}
+
+#[get("users")]
+pub async fn users_get(
+    web::Query(ids): web::Query<UserIds>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+) -> Result<HttpResponse, ApiError> {
+    let response =
+        v3::users::users_get(web::Query(v3::users::UserIds { ids: ids.ids }), pool, redis)
+            .await
+            .or_else(v2_reroute::flatten_404_error)?;
+
+    // Convert response to V2 format
+    match v2_reroute::extract_ok_json::<Vec<User>>(response).await {
+        Ok(users) => {
+            let legacy_users: Vec<LegacyUser> = users.into_iter().map(LegacyUser::from).collect();
+            Ok(HttpResponse::Ok().json(legacy_users))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+#[get("{id}")]
+pub async fn user_get(
+    info: web::Path<(String,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+) -> Result<HttpResponse, ApiError> {
+    let response = v3::users::user_get(info, pool, redis)
+        .await
+        .or_else(v2_reroute::flatten_404_error)?;
+
+    // Convert response to V2 format
+    match v2_reroute::extract_ok_json::<User>(response).await {
+        Ok(user) => {
+            let user = LegacyUser::from(user);
+            Ok(HttpResponse::Ok().json(user))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+#[get("{user_id}/projects")]
+pub async fn projects_list(
+    req: HttpRequest,
+    info: web::Path<(String,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let response = v3::users::projects_list(req, info, pool.clone(), redis.clone(), session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)?;
+
+    // Convert to V2 projects
+    match v2_reroute::extract_ok_json::<Vec<Project>>(response).await {
+        Ok(project) => {
+            let legacy_projects = LegacyProject::from_many(project, &**pool, &redis).await?;
+            Ok(HttpResponse::Ok().json(legacy_projects))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+lazy_static! {
+    static ref RE_URL_SAFE: Regex = Regex::new(r"^[a-zA-Z0-9_-]*$").unwrap();
+}
+
+#[derive(Serialize, Deserialize, Validate)]
+pub struct EditUser {
+    #[validate(length(min = 1, max = 39), regex = "RE_URL_SAFE")]
+    pub username: Option<String>,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        with = "::serde_with::rust::double_option"
+    )]
+    #[validate(length(min = 1, max = 64), regex = "RE_URL_SAFE")]
+    pub name: Option<Option<String>>,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        with = "::serde_with::rust::double_option"
+    )]
+    #[validate(length(max = 160))]
+    pub bio: Option<Option<String>>,
+    pub role: Option<Role>,
+    pub badges: Option<Badges>,
+}
+
+#[patch("{id}")]
+pub async fn user_edit(
+    req: HttpRequest,
+    info: web::Path<(String,)>,
+    new_user: web::Json<EditUser>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let new_user = new_user.into_inner();
+    // Returns NoContent, so we don't need to convert to V2
+    v3::users::user_edit(
+        req,
+        info,
+        web::Json(v3::users::EditUser {
+            username: new_user.username,
+            bio: new_user.bio,
+            role: new_user.role,
+            badges: new_user.badges,
+            venmo_handle: None,
+        }),
+        pool,
+        redis,
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Extension {
+    pub ext: String,
+}
+
+#[patch("{id}/icon")]
+#[allow(clippy::too_many_arguments)]
+pub async fn user_icon_edit(
+    web::Query(ext): web::Query<Extension>,
+    req: HttpRequest,
+    info: web::Path<(String,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    file_host: web::Data<Arc<dyn FileHost + Send + Sync>>,
+    payload: web::Payload,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // Returns NoContent, so we don't need to convert to V2
+    v3::users::user_icon_edit(
+        web::Query(v3::users::Extension { ext: ext.ext }),
+        req,
+        info,
+        pool,
+        redis,
+        file_host,
+        payload,
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)
+}
+
+#[delete("{id}")]
+pub async fn user_delete(
+    req: HttpRequest,
+    info: web::Path<(String,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // Returns NoContent, so we don't need to convert to V2
+    v3::users::user_delete(req, info, pool, redis, session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)
+}
+
+#[get("{id}/follows")]
+pub async fn user_follows(
+    req: HttpRequest,
+    info: web::Path<(String,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let response = v3::users::user_follows(req, info, pool.clone(), redis.clone(), session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)?;
+
+    // Convert to V2 projects
+    match v2_reroute::extract_ok_json::<Vec<Project>>(response).await {
+        Ok(project) => {
+            let legacy_projects = LegacyProject::from_many(project, &**pool, &redis).await?;
+            Ok(HttpResponse::Ok().json(legacy_projects))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+#[get("{id}/notifications")]
+pub async fn user_notifications(
+    req: HttpRequest,
+    info: web::Path<(String,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let response = v3::users::user_notifications(req, info, pool, redis, session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)?;
+    // Convert response to V2 format
+    match v2_reroute::extract_ok_json::<Vec<Notification>>(response).await {
+        Ok(notifications) => {
+            let legacy_notifications: Vec<LegacyNotification> = notifications
+                .into_iter()
+                .map(LegacyNotification::from)
+                .collect();
+            Ok(HttpResponse::Ok().json(legacy_notifications))
+        }
+        Err(response) => Ok(response),
+    }
+}

apps/labrinth/src/routes/v2/version_creation.rs

@@ -0,0 +1,298 @@
+use crate::database::models::loader_fields::VersionField;
+use crate::database::models::{project_item, version_item};
+use crate::database::redis::RedisPool;
+use crate::file_hosting::FileHost;
+use crate::models::ids::ImageId;
+use crate::models::projects::{
+    Dependency, FileType, Loader, ProjectId, Version, VersionId, VersionStatus, VersionType,
+};
+use crate::models::v2::projects::LegacyVersion;
+use crate::queue::moderation::AutomatedModerationQueue;
+use crate::queue::session::AuthQueue;
+use crate::routes::v3::project_creation::CreateError;
+use crate::routes::v3::version_creation;
+use crate::routes::{v2_reroute, v3};
+use actix_multipart::Multipart;
+use actix_web::http::header::ContentDisposition;
+use actix_web::web::Data;
+use actix_web::{post, web, HttpRequest, HttpResponse};
+use serde::{Deserialize, Serialize};
+use serde_json::json;
+use sqlx::postgres::PgPool;
+use std::collections::HashMap;
+use std::sync::Arc;
+use validator::Validate;
+
+pub fn default_requested_status() -> VersionStatus {
+    VersionStatus::Listed
+}
+
+#[derive(Serialize, Deserialize, Validate, Clone)]
+pub struct InitialVersionData {
+    #[serde(alias = "mod_id")]
+    pub project_id: Option<ProjectId>,
+    #[validate(length(min = 1, max = 256))]
+    pub file_parts: Vec<String>,
+    #[validate(
+        length(min = 1, max = 32),
+        regex = "crate::util::validate::RE_URL_SAFE"
+    )]
+    pub version_number: String,
+    #[validate(
+        length(min = 1, max = 64),
+        custom(function = "crate::util::validate::validate_name")
+    )]
+    #[serde(alias = "name")]
+    pub version_title: String,
+    #[validate(length(max = 65536))]
+    #[serde(alias = "changelog")]
+    pub version_body: Option<String>,
+    #[validate(
+        length(min = 0, max = 4096),
+        custom(function = "crate::util::validate::validate_deps")
+    )]
+    pub dependencies: Vec<Dependency>,
+    #[validate(length(min = 1))]
+    pub game_versions: Vec<String>,
+    #[serde(alias = "version_type")]
+    pub release_channel: VersionType,
+    #[validate(length(min = 1))]
+    pub loaders: Vec<Loader>,
+    pub featured: bool,
+    pub primary_file: Option<String>,
+    #[serde(default = "default_requested_status")]
+    pub status: VersionStatus,
+    #[serde(default = "HashMap::new")]
+    pub file_types: HashMap<String, Option<FileType>>,
+    // Associations to uploaded images in changelog
+    #[validate(length(max = 10))]
+    #[serde(default)]
+    pub uploaded_images: Vec<ImageId>,
+
+    // The ordering relative to other versions
+    pub ordering: Option<i32>,
+}
+
+#[derive(Serialize, Deserialize, Clone)]
+struct InitialFileData {
+    #[serde(default = "HashMap::new")]
+    pub file_types: HashMap<String, Option<FileType>>,
+}
+
+// under `/api/v1/version`
+#[post("version")]
+pub async fn version_create(
+    req: HttpRequest,
+    payload: Multipart,
+    client: Data<PgPool>,
+    redis: Data<RedisPool>,
+    file_host: Data<Arc<dyn FileHost + Send + Sync>>,
+    session_queue: Data<AuthQueue>,
+    moderation_queue: Data<AutomatedModerationQueue>,
+) -> Result<HttpResponse, CreateError> {
+    let payload = v2_reroute::alter_actix_multipart(
+        payload,
+        req.headers().clone(),
+        |legacy_create: InitialVersionData, content_dispositions: Vec<ContentDisposition>| {
+            let client = client.clone();
+            let redis = redis.clone();
+            async move {
+                // Convert input data to V3 format
+                let mut fields = HashMap::new();
+                fields.insert(
+                    "game_versions".to_string(),
+                    json!(legacy_create.game_versions),
+                );
+
+                // Get all possible side-types for loaders given- we will use these to check if we need to convert/apply singleplayer, etc.
+                let loaders = match v3::tags::loader_list(client.clone(), redis.clone()).await {
+                    Ok(loader_response) => {
+                        (v2_reroute::extract_ok_json::<Vec<v3::tags::LoaderData>>(loader_response)
+                            .await)
+                            .unwrap_or_default()
+                    }
+                    Err(_) => vec![],
+                };
+
+                let loader_fields_aggregate = loaders
+                    .into_iter()
+                    .filter_map(|loader| {
+                        if legacy_create.loaders.contains(&Loader(loader.name.clone())) {
+                            Some(loader.supported_fields)
+                        } else {
+                            None
+                        }
+                    })
+                    .flatten()
+                    .collect::<Vec<_>>();
+
+                // Copies side types of another version of the project.
+                // If no version exists, defaults to all false.
+                // This is inherently lossy, but not much can be done about it, as side types are no longer associated with projects,
+                // so the 'missing' ones can't be easily accessed, and versions do need to have these fields explicitly set.
+                let side_type_loader_field_names = [
+                    "singleplayer",
+                    "client_and_server",
+                    "client_only",
+                    "server_only",
+                ];
+
+                // Check if loader_fields_aggregate contains any of these side types
+                // We assume these four fields are linked together.
+                if loader_fields_aggregate
+                    .iter()
+                    .any(|f| side_type_loader_field_names.contains(&f.as_str()))
+                {
+                    // If so, we get the fields of the example version of the project, and set the side types to match.
+                    fields.extend(
+                        side_type_loader_field_names
+                            .iter()
+                            .map(|f| (f.to_string(), json!(false))),
+                    );
+                    if let Some(example_version_fields) =
+                        get_example_version_fields(legacy_create.project_id, client, &redis).await?
+                    {
+                        fields.extend(example_version_fields.into_iter().filter_map(|f| {
+                            if side_type_loader_field_names.contains(&f.field_name.as_str()) {
+                                Some((f.field_name, f.value.serialize_internal()))
+                            } else {
+                                None
+                            }
+                        }));
+                    }
+                }
+                // Handle project type via file extension prediction
+                let mut project_type = None;
+                for file_part in &legacy_create.file_parts {
+                    if let Some(ext) = file_part.split('.').last() {
+                        match ext {
+                            "mrpack" | "mrpack-primary" => {
+                                project_type = Some("modpack");
+                                break;
+                            }
+                            // No other type matters
+                            _ => {}
+                        }
+                        break;
+                    }
+                }
+
+                // Similarly, check actual content disposition for mrpacks, in case file_parts is wrong
+                for content_disposition in content_dispositions {
+                    // Uses version_create functions to get the file name and extension
+                    let (_, file_extension) = version_creation::get_name_ext(&content_disposition)?;
+                    crate::util::ext::project_file_type(file_extension)
+                        .ok_or_else(|| CreateError::InvalidFileType(file_extension.to_string()))?;
+
+                    if file_extension == "mrpack" {
+                        project_type = Some("modpack");
+                        break;
+                    }
+                }
+
+                // Modpacks now use the "mrpack" loader, and loaders are converted to loader fields.
+                // Setting of 'project_type' directly is removed, it's loader-based now.
+                if project_type == Some("modpack") {
+                    fields.insert("mrpack_loaders".to_string(), json!(legacy_create.loaders));
+                }
+
+                let loaders = if project_type == Some("modpack") {
+                    vec![Loader("mrpack".to_string())]
+                } else {
+                    legacy_create.loaders
+                };
+
+                Ok(v3::version_creation::InitialVersionData {
+                    project_id: legacy_create.project_id,
+                    file_parts: legacy_create.file_parts,
+                    version_number: legacy_create.version_number,
+                    version_title: legacy_create.version_title,
+                    version_body: legacy_create.version_body,
+                    dependencies: legacy_create.dependencies,
+                    release_channel: legacy_create.release_channel,
+                    loaders,
+                    featured: legacy_create.featured,
+                    primary_file: legacy_create.primary_file,
+                    status: legacy_create.status,
+                    file_types: legacy_create.file_types,
+                    uploaded_images: legacy_create.uploaded_images,
+                    ordering: legacy_create.ordering,
+                    fields,
+                })
+            }
+        },
+    )
+    .await?;
+
+    // Call V3 project creation
+    let response = v3::version_creation::version_create(
+        req,
+        payload,
+        client.clone(),
+        redis.clone(),
+        file_host,
+        session_queue,
+        moderation_queue,
+    )
+    .await?;
+
+    // Convert response to V2 format
+    match v2_reroute::extract_ok_json::<Version>(response).await {
+        Ok(version) => {
+            let v2_version = LegacyVersion::from(version);
+            Ok(HttpResponse::Ok().json(v2_version))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+// Gets version fields of an example version of a project, if one exists.
+async fn get_example_version_fields(
+    project_id: Option<ProjectId>,
+    pool: Data<PgPool>,
+    redis: &RedisPool,
+) -> Result<Option<Vec<VersionField>>, CreateError> {
+    let project_id = match project_id {
+        Some(project_id) => project_id,
+        None => return Ok(None),
+    };
+
+    let vid = match project_item::Project::get_id(project_id.into(), &**pool, redis)
+        .await?
+        .and_then(|p| p.versions.first().cloned())
+    {
+        Some(vid) => vid,
+        None => return Ok(None),
+    };
+
+    let example_version = match version_item::Version::get(vid, &**pool, redis).await? {
+        Some(version) => version,
+        None => return Ok(None),
+    };
+    Ok(Some(example_version.version_fields))
+}
+
+// under /api/v1/version/{version_id}
+#[post("{version_id}/file")]
+pub async fn upload_file_to_version(
+    req: HttpRequest,
+    url_data: web::Path<(VersionId,)>,
+    payload: Multipart,
+    client: Data<PgPool>,
+    redis: Data<RedisPool>,
+    file_host: Data<Arc<dyn FileHost + Send + Sync>>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, CreateError> {
+    // Returns NoContent, so no need to convert to V2
+    let response = v3::version_creation::upload_file_to_version(
+        req,
+        url_data,
+        payload,
+        client.clone(),
+        redis.clone(),
+        file_host,
+        session_queue,
+    )
+    .await?;
+    Ok(response)
+}

apps/labrinth/src/routes/v2/version_file.rs

@@ -0,0 +1,355 @@
+use super::ApiError;
+use crate::database::redis::RedisPool;
+use crate::models::projects::{Project, Version, VersionType};
+use crate::models::v2::projects::{LegacyProject, LegacyVersion};
+use crate::queue::session::AuthQueue;
+use crate::routes::v3::version_file::HashQuery;
+use crate::routes::{v2_reroute, v3};
+use actix_web::{delete, get, post, web, HttpRequest, HttpResponse};
+use serde::{Deserialize, Serialize};
+use sqlx::PgPool;
+use std::collections::HashMap;
+
+pub fn config(cfg: &mut web::ServiceConfig) {
+    cfg.service(
+        web::scope("version_file")
+            .service(delete_file)
+            .service(get_version_from_hash)
+            .service(download_version)
+            .service(get_update_from_hash)
+            .service(get_projects_from_hashes),
+    );
+
+    cfg.service(
+        web::scope("version_files")
+            .service(get_versions_from_hashes)
+            .service(update_files)
+            .service(update_individual_files),
+    );
+}
+
+// under /api/v1/version_file/{hash}
+#[get("{version_id}")]
+pub async fn get_version_from_hash(
+    req: HttpRequest,
+    info: web::Path<(String,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    hash_query: web::Query<HashQuery>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let response =
+        v3::version_file::get_version_from_hash(req, info, pool, redis, hash_query, session_queue)
+            .await
+            .or_else(v2_reroute::flatten_404_error)?;
+
+    // Convert response to V2 format
+    match v2_reroute::extract_ok_json::<Version>(response).await {
+        Ok(version) => {
+            let v2_version = LegacyVersion::from(version);
+            Ok(HttpResponse::Ok().json(v2_version))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+// under /api/v1/version_file/{hash}/download
+#[get("{version_id}/download")]
+pub async fn download_version(
+    req: HttpRequest,
+    info: web::Path<(String,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    hash_query: web::Query<HashQuery>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // Returns TemporaryRedirect, so no need to convert to V2
+    v3::version_file::download_version(req, info, pool, redis, hash_query, session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)
+}
+
+// under /api/v1/version_file/{hash}
+#[delete("{version_id}")]
+pub async fn delete_file(
+    req: HttpRequest,
+    info: web::Path<(String,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    hash_query: web::Query<HashQuery>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // Returns NoContent, so no need to convert to V2
+    v3::version_file::delete_file(req, info, pool, redis, hash_query, session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct UpdateData {
+    pub loaders: Option<Vec<String>>,
+    pub game_versions: Option<Vec<String>>,
+    pub version_types: Option<Vec<VersionType>>,
+}
+
+#[post("{version_id}/update")]
+pub async fn get_update_from_hash(
+    req: HttpRequest,
+    info: web::Path<(String,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    hash_query: web::Query<HashQuery>,
+    update_data: web::Json<UpdateData>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let update_data = update_data.into_inner();
+    let mut loader_fields = HashMap::new();
+    let mut game_versions = vec![];
+    for gv in update_data.game_versions.into_iter().flatten() {
+        game_versions.push(serde_json::json!(gv.clone()));
+    }
+    if !game_versions.is_empty() {
+        loader_fields.insert("game_versions".to_string(), game_versions);
+    }
+    let update_data = v3::version_file::UpdateData {
+        loaders: update_data.loaders.clone(),
+        version_types: update_data.version_types.clone(),
+        loader_fields: Some(loader_fields),
+    };
+
+    let response = v3::version_file::get_update_from_hash(
+        req,
+        info,
+        pool,
+        redis,
+        hash_query,
+        web::Json(update_data),
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)?;
+
+    // Convert response to V2 format
+    match v2_reroute::extract_ok_json::<Version>(response).await {
+        Ok(version) => {
+            let v2_version = LegacyVersion::from(version);
+            Ok(HttpResponse::Ok().json(v2_version))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+// Requests above with multiple versions below
+#[derive(Deserialize)]
+pub struct FileHashes {
+    pub algorithm: Option<String>,
+    pub hashes: Vec<String>,
+}
+
+// under /api/v2/version_files
+#[post("")]
+pub async fn get_versions_from_hashes(
+    req: HttpRequest,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    file_data: web::Json<FileHashes>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let file_data = file_data.into_inner();
+    let file_data = v3::version_file::FileHashes {
+        algorithm: file_data.algorithm,
+        hashes: file_data.hashes,
+    };
+    let response = v3::version_file::get_versions_from_hashes(
+        req,
+        pool,
+        redis,
+        web::Json(file_data),
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)?;
+
+    // Convert to V2
+    match v2_reroute::extract_ok_json::<HashMap<String, Version>>(response).await {
+        Ok(versions) => {
+            let v2_versions = versions
+                .into_iter()
+                .map(|(hash, version)| {
+                    let v2_version = LegacyVersion::from(version);
+                    (hash, v2_version)
+                })
+                .collect::<HashMap<_, _>>();
+            Ok(HttpResponse::Ok().json(v2_versions))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+#[post("project")]
+pub async fn get_projects_from_hashes(
+    req: HttpRequest,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    file_data: web::Json<FileHashes>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let file_data = file_data.into_inner();
+    let file_data = v3::version_file::FileHashes {
+        algorithm: file_data.algorithm,
+        hashes: file_data.hashes,
+    };
+    let response = v3::version_file::get_projects_from_hashes(
+        req,
+        pool.clone(),
+        redis.clone(),
+        web::Json(file_data),
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)?;
+
+    // Convert to V2
+    match v2_reroute::extract_ok_json::<HashMap<String, Project>>(response).await {
+        Ok(projects_hashes) => {
+            let hash_to_project_id = projects_hashes
+                .iter()
+                .map(|(hash, project)| {
+                    let project_id = project.id;
+                    (hash.clone(), project_id)
+                })
+                .collect::<HashMap<_, _>>();
+            let legacy_projects =
+                LegacyProject::from_many(projects_hashes.into_values().collect(), &**pool, &redis)
+                    .await?;
+            let legacy_projects_hashes = hash_to_project_id
+                .into_iter()
+                .filter_map(|(hash, project_id)| {
+                    let legacy_project =
+                        legacy_projects.iter().find(|x| x.id == project_id)?.clone();
+                    Some((hash, legacy_project))
+                })
+                .collect::<HashMap<_, _>>();
+
+            Ok(HttpResponse::Ok().json(legacy_projects_hashes))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+#[derive(Deserialize)]
+pub struct ManyUpdateData {
+    pub algorithm: Option<String>, // Defaults to calculation based on size of hash
+    pub hashes: Vec<String>,
+    pub loaders: Option<Vec<String>>,
+    pub game_versions: Option<Vec<String>>,
+    pub version_types: Option<Vec<VersionType>>,
+}
+
+#[post("update")]
+pub async fn update_files(
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    update_data: web::Json<ManyUpdateData>,
+) -> Result<HttpResponse, ApiError> {
+    let update_data = update_data.into_inner();
+    let update_data = v3::version_file::ManyUpdateData {
+        loaders: update_data.loaders.clone(),
+        version_types: update_data.version_types.clone(),
+        game_versions: update_data.game_versions.clone(),
+        algorithm: update_data.algorithm,
+        hashes: update_data.hashes,
+    };
+
+    let response = v3::version_file::update_files(pool, redis, web::Json(update_data))
+        .await
+        .or_else(v2_reroute::flatten_404_error)?;
+
+    // Convert response to V2 format
+    match v2_reroute::extract_ok_json::<HashMap<String, Version>>(response).await {
+        Ok(returned_versions) => {
+            let v3_versions = returned_versions
+                .into_iter()
+                .map(|(hash, version)| {
+                    let v2_version = LegacyVersion::from(version);
+                    (hash, v2_version)
+                })
+                .collect::<HashMap<_, _>>();
+            Ok(HttpResponse::Ok().json(v3_versions))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct FileUpdateData {
+    pub hash: String,
+    pub loaders: Option<Vec<String>>,
+    pub game_versions: Option<Vec<String>>,
+    pub version_types: Option<Vec<VersionType>>,
+}
+
+#[derive(Deserialize)]
+pub struct ManyFileUpdateData {
+    pub algorithm: Option<String>, // Defaults to calculation based on size of hash
+    pub hashes: Vec<FileUpdateData>,
+}
+
+#[post("update_individual")]
+pub async fn update_individual_files(
+    req: HttpRequest,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    update_data: web::Json<ManyFileUpdateData>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let update_data = update_data.into_inner();
+    let update_data = v3::version_file::ManyFileUpdateData {
+        algorithm: update_data.algorithm,
+        hashes: update_data
+            .hashes
+            .into_iter()
+            .map(|x| {
+                let mut loader_fields = HashMap::new();
+                let mut game_versions = vec![];
+                for gv in x.game_versions.into_iter().flatten() {
+                    game_versions.push(serde_json::json!(gv.clone()));
+                }
+                if !game_versions.is_empty() {
+                    loader_fields.insert("game_versions".to_string(), game_versions);
+                }
+                v3::version_file::FileUpdateData {
+                    hash: x.hash.clone(),
+                    loaders: x.loaders.clone(),
+                    loader_fields: Some(loader_fields),
+                    version_types: x.version_types,
+                }
+            })
+            .collect(),
+    };
+
+    let response = v3::version_file::update_individual_files(
+        req,
+        pool,
+        redis,
+        web::Json(update_data),
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)?;
+
+    // Convert response to V2 format
+    match v2_reroute::extract_ok_json::<HashMap<String, Version>>(response).await {
+        Ok(returned_versions) => {
+            let v3_versions = returned_versions
+                .into_iter()
+                .map(|(hash, version)| {
+                    let v2_version = LegacyVersion::from(version);
+                    (hash, v2_version)
+                })
+                .collect::<HashMap<_, _>>();
+            Ok(HttpResponse::Ok().json(v3_versions))
+        }
+        Err(response) => Ok(response),
+    }
+}

apps/labrinth/src/routes/v2/versions.rs

@@ -0,0 +1,321 @@
+use std::collections::HashMap;
+
+use super::ApiError;
+use crate::database::redis::RedisPool;
+use crate::models;
+use crate::models::ids::VersionId;
+use crate::models::projects::{Dependency, FileType, Version, VersionStatus, VersionType};
+use crate::models::v2::projects::LegacyVersion;
+use crate::queue::session::AuthQueue;
+use crate::routes::{v2_reroute, v3};
+use crate::search::SearchConfig;
+use actix_web::{delete, get, patch, web, HttpRequest, HttpResponse};
+use serde::{Deserialize, Serialize};
+use sqlx::PgPool;
+use validator::Validate;
+
+pub fn config(cfg: &mut web::ServiceConfig) {
+    cfg.service(versions_get);
+    cfg.service(super::version_creation::version_create);
+
+    cfg.service(
+        web::scope("version")
+            .service(version_get)
+            .service(version_delete)
+            .service(version_edit)
+            .service(super::version_creation::upload_file_to_version),
+    );
+}
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct VersionListFilters {
+    pub game_versions: Option<String>,
+    pub loaders: Option<String>,
+    pub featured: Option<bool>,
+    pub version_type: Option<VersionType>,
+    pub limit: Option<usize>,
+    pub offset: Option<usize>,
+}
+
+#[get("version")]
+pub async fn version_list(
+    req: HttpRequest,
+    info: web::Path<(String,)>,
+    web::Query(filters): web::Query<VersionListFilters>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let loaders = if let Some(loaders) = filters.loaders {
+        if let Ok(mut loaders) = serde_json::from_str::<Vec<String>>(&loaders) {
+            loaders.push("mrpack".to_string());
+            Some(loaders)
+        } else {
+            None
+        }
+    } else {
+        None
+    };
+
+    let loader_fields = if let Some(game_versions) = filters.game_versions {
+        // TODO: extract this logic which is similar to the other v2->v3 version_file functions
+        let mut loader_fields = HashMap::new();
+        serde_json::from_str::<Vec<String>>(&game_versions)
+            .ok()
+            .and_then(|versions| {
+                let mut game_versions: Vec<serde_json::Value> = vec![];
+                for gv in versions {
+                    game_versions.push(serde_json::json!(gv.clone()));
+                }
+                loader_fields.insert("game_versions".to_string(), game_versions);
+
+                if let Some(ref loaders) = loaders {
+                    loader_fields.insert(
+                        "loaders".to_string(),
+                        loaders
+                            .iter()
+                            .map(|x| serde_json::json!(x.clone()))
+                            .collect(),
+                    );
+                }
+
+                serde_json::to_string(&loader_fields).ok()
+            })
+    } else {
+        None
+    };
+
+    let filters = v3::versions::VersionListFilters {
+        loader_fields,
+        loaders: loaders.and_then(|x| serde_json::to_string(&x).ok()),
+        featured: filters.featured,
+        version_type: filters.version_type,
+        limit: filters.limit,
+        offset: filters.offset,
+    };
+
+    let response =
+        v3::versions::version_list(req, info, web::Query(filters), pool, redis, session_queue)
+            .await
+            .or_else(v2_reroute::flatten_404_error)?;
+
+    // Convert response to V2 format
+    match v2_reroute::extract_ok_json::<Vec<Version>>(response).await {
+        Ok(versions) => {
+            let v2_versions = versions
+                .into_iter()
+                .map(LegacyVersion::from)
+                .collect::<Vec<_>>();
+            Ok(HttpResponse::Ok().json(v2_versions))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+// Given a project ID/slug and a version slug
+#[get("version/{slug}")]
+pub async fn version_project_get(
+    req: HttpRequest,
+    info: web::Path<(String, String)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let id = info.into_inner();
+    let response = v3::versions::version_project_get_helper(req, id, pool, redis, session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)?;
+    // Convert response to V2 format
+    match v2_reroute::extract_ok_json::<Version>(response).await {
+        Ok(version) => {
+            let v2_version = LegacyVersion::from(version);
+            Ok(HttpResponse::Ok().json(v2_version))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct VersionIds {
+    pub ids: String,
+}
+
+#[get("versions")]
+pub async fn versions_get(
+    req: HttpRequest,
+    web::Query(ids): web::Query<VersionIds>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let ids = v3::versions::VersionIds { ids: ids.ids };
+    let response = v3::versions::versions_get(req, web::Query(ids), pool, redis, session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)?;
+
+    // Convert response to V2 format
+    match v2_reroute::extract_ok_json::<Vec<Version>>(response).await {
+        Ok(versions) => {
+            let v2_versions = versions
+                .into_iter()
+                .map(LegacyVersion::from)
+                .collect::<Vec<_>>();
+            Ok(HttpResponse::Ok().json(v2_versions))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+#[get("{version_id}")]
+pub async fn version_get(
+    req: HttpRequest,
+    info: web::Path<(models::ids::VersionId,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let id = info.into_inner().0;
+    let response = v3::versions::version_get_helper(req, id, pool, redis, session_queue)
+        .await
+        .or_else(v2_reroute::flatten_404_error)?;
+    // Convert response to V2 format
+    match v2_reroute::extract_ok_json::<Version>(response).await {
+        Ok(version) => {
+            let v2_version = LegacyVersion::from(version);
+            Ok(HttpResponse::Ok().json(v2_version))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
+#[derive(Serialize, Deserialize, Validate)]
+pub struct EditVersion {
+    #[validate(
+        length(min = 1, max = 64),
+        custom(function = "crate::util::validate::validate_name")
+    )]
+    pub name: Option<String>,
+    #[validate(
+        length(min = 1, max = 32),
+        regex = "crate::util::validate::RE_URL_SAFE"
+    )]
+    pub version_number: Option<String>,
+    #[validate(length(max = 65536))]
+    pub changelog: Option<String>,
+    pub version_type: Option<models::projects::VersionType>,
+    #[validate(
+        length(min = 0, max = 4096),
+        custom(function = "crate::util::validate::validate_deps")
+    )]
+    pub dependencies: Option<Vec<Dependency>>,
+    pub game_versions: Option<Vec<String>>,
+    pub loaders: Option<Vec<models::projects::Loader>>,
+    pub featured: Option<bool>,
+    pub downloads: Option<u32>,
+    pub status: Option<VersionStatus>,
+    pub file_types: Option<Vec<EditVersionFileType>>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct EditVersionFileType {
+    pub algorithm: String,
+    pub hash: String,
+    pub file_type: Option<FileType>,
+}
+
+#[patch("{id}")]
+pub async fn version_edit(
+    req: HttpRequest,
+    info: web::Path<(VersionId,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    new_version: web::Json<EditVersion>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let new_version = new_version.into_inner();
+
+    let mut fields = HashMap::new();
+    if new_version.game_versions.is_some() {
+        fields.insert(
+            "game_versions".to_string(),
+            serde_json::json!(new_version.game_versions),
+        );
+    }
+
+    // Get the older version to get info from
+    let old_version = v3::versions::version_get_helper(
+        req.clone(),
+        (*info).0,
+        pool.clone(),
+        redis.clone(),
+        session_queue.clone(),
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)?;
+    let old_version = match v2_reroute::extract_ok_json::<Version>(old_version).await {
+        Ok(version) => version,
+        Err(response) => return Ok(response),
+    };
+
+    // If this has 'mrpack_loaders' as a loader field previously, this is a modpack.
+    // Therefore, if we are modifying the 'loader' field in this case,
+    // we are actually modifying the 'mrpack_loaders' loader field
+    let mut loaders = new_version.loaders.clone();
+    if old_version.fields.contains_key("mrpack_loaders") && new_version.loaders.is_some() {
+        fields.insert(
+            "mrpack_loaders".to_string(),
+            serde_json::json!(new_version.loaders),
+        );
+        loaders = None;
+    }
+
+    let new_version = v3::versions::EditVersion {
+        name: new_version.name,
+        version_number: new_version.version_number,
+        changelog: new_version.changelog,
+        version_type: new_version.version_type,
+        dependencies: new_version.dependencies,
+        loaders,
+        featured: new_version.featured,
+        downloads: new_version.downloads,
+        status: new_version.status,
+        file_types: new_version.file_types.map(|v| {
+            v.into_iter()
+                .map(|evft| v3::versions::EditVersionFileType {
+                    algorithm: evft.algorithm,
+                    hash: evft.hash,
+                    file_type: evft.file_type,
+                })
+                .collect::<Vec<_>>()
+        }),
+        ordering: None,
+        fields,
+    };
+
+    let response = v3::versions::version_edit(
+        req,
+        info,
+        pool,
+        redis,
+        web::Json(serde_json::to_value(new_version)?),
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)?;
+    Ok(response)
+}
+
+#[delete("{version_id}")]
+pub async fn version_delete(
+    req: HttpRequest,
+    info: web::Path<(VersionId,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+    search_config: web::Data<SearchConfig>,
+) -> Result<HttpResponse, ApiError> {
+    // Returns NoContent, so we don't need to convert the response
+    v3::versions::version_delete(req, info, pool, redis, session_queue, search_config)
+        .await
+        .or_else(v2_reroute::flatten_404_error)
+}