Testing bug fixes (#788)

* fixes

* adds tests- fixes failures

* changes

* moved transaction commits/caches around

* collections nullable

* merge fixes

* sqlx prepare

* revs

* lf fixes

* made changes back

* added collections update

---------

Co-authored-by: Geometrically <18202329+Geometrically@users.noreply.github.com>

src/routes/v2/tags.rs

@@ -4,6 +4,7 @@ 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, LoaderData as LoaderDataV3, LoaderFieldsEnumQuery,
 };
@@ -172,11 +173,12 @@ pub async fn license_text(params: web::Path<(String,)>) -> Result<HttpResponse,
         .or_else(v2_reroute::flatten_404_error)
 }
 
-#[derive(serde::Serialize)]
+#[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,
 }
 
@@ -193,7 +195,26 @@ pub async fn donation_platform_list(
             Ok(platforms) => {
                 let platforms = platforms
                     .into_iter()
-                    .map(|p| DonationPlatformQueryData { name: p.name })
+                    .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)
             }

src/routes/v2/version_creation.rs

@@ -100,34 +100,66 @@ pub async fn version_create(
                     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) => match v2_reroute::extract_ok_json::<
+                        Vec<v3::tags::LoaderData>,
+                    >(loader_response)
+                    .await
+                    {
+                        Ok(loaders) => loaders,
+                        Err(_) => vec![],
+                    },
+                    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.
-                // TODO: write test for this to ensure predictible unchanging behaviour
                 // 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.
+                // 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",
                 ];
-                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
-                        }
-                    }));
-                }
 
+                // 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 {