tomasalias/AstralRinth
1
0
Fork 0
forked from didirus/AstralRinth
Code Pull Requests Activity

Fix clippy errors + lint, use turbo CI

Browse Source
This commit is contained in:
Jai A
2024-10-18 16:07:35 -07:00
parent 663ab83b08
commit 8dd955563e
186 changed files with 10615 additions and 6433 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
apps/labrinth/src/routes/v2/moderation.rs
View File

@@ -43,7 +43,8 @@ pub async fn get_projects(
// 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?;
let legacy_projects =
LegacyProject::from_many(project, &**pool, &redis).await?;
Ok(HttpResponse::Ok().json(legacy_projects))
}
Err(response) => Ok(response),

24
apps/labrinth/src/routes/v2/notifications.rs
View File

@@ -65,9 +65,15 @@ pub async fn notification_get(
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)?;
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);
@@ -100,9 +106,15 @@ pub async fn notification_delete(
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)
v3::notifications::notification_delete(
req,
info,
pool,
redis,
session_queue,
)
.await
.or_else(v2_reroute::flatten_404_error)
}
#[patch("notifications")]

24
apps/labrinth/src/routes/v2/project_creation.rs
View File

@@ -4,7 +4,9 @@ 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::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};
@@ -158,13 +160,22 @@ pub async fn project_create(
.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));
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));
fields.insert(
"mrpack_loaders".to_string(),
json!(v.loaders),
);
}
let loaders = if project_type == "modpack" {
@@ -248,7 +259,10 @@ pub async fn project_create(
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?,
Some(vid) => {
version_item::Version::get((*vid).into(), &**client, &redis)
.await?
}
None => None,
};
let project = LegacyProject::from(project, version_item);

126
apps/labrinth/src/routes/v2/projects.rs
View File

@@ -5,7 +5,9 @@ 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::projects::{
DonationLink, LegacyProject, LegacySideType, LegacyVersion,
};
use crate::models::v2::search::LegacySearchResults;
use crate::queue::moderation::AutomatedModerationQueue;
use crate::queue::session::AuthQueue;
@@ -71,7 +73,9 @@ pub async fn project_search(
facet
.into_iter()
.map(|facet| {
if let Some((key, operator, val)) = parse_facet(&facet) {
if let Some((key, operator, val)) =
parse_facet(&facet)
{
format!(
"{}{}{}",
match key.as_str() {
@@ -155,15 +159,19 @@ pub async fn random_projects_get(
) -> 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)?;
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?;
let legacy_projects =
LegacyProject::from_many(project, &**pool, &redis).await?;
Ok(HttpResponse::Ok().json(legacy_projects))
}
Err(response) => Ok(response),
@@ -193,7 +201,8 @@ pub async fn projects_get(
// 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?;
let legacy_projects =
LegacyProject::from_many(project, &**pool, &redis).await?;
Ok(HttpResponse::Ok().json(legacy_projects))
}
Err(response) => Ok(response),
@@ -210,15 +219,24 @@ pub async fn project_get(
) -> 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)?;
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?,
Some(vid) => {
version_item::Version::get((*vid).into(), &**pool, &redis)
.await?
}
None => None,
};
let project = LegacyProject::from(project, version_item);
@@ -256,16 +274,28 @@ pub async fn dependency_list(
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)?;
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
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_projects = LegacyProject::from_many(
dependency_info.projects,
&**pool,
&redis,
)
.await?;
let converted_versions = dependency_info
.versions
.into_iter()
@@ -443,7 +473,8 @@ pub async fn project_edit(
// (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 fetched_example_project =
project_item::Project::get(&info.0, &**pool, &redis).await?;
let donation_links = fetched_example_project
.map(|x| {
x.urls
@@ -504,11 +535,19 @@ pub async fn project_edit(
// 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?;
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?;
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;
@@ -516,7 +555,10 @@ pub async fn project_edit(
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));
fields.extend(v2_reroute::convert_side_types_v3(
client_side,
server_side,
));
response = v3::versions::version_edit_helper(
req.clone(),
@@ -682,8 +724,10 @@ pub async fn projects_edit(
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,
add_additional_categories: bulk_edit_project
.add_additional_categories,
remove_additional_categories: bulk_edit_project
.remove_additional_categories,
link_urls: Some(link_urls),
}),
redis,
@@ -735,9 +779,16 @@ pub async fn delete_project_icon(
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)
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)]
@@ -873,9 +924,16 @@ pub async fn project_delete(
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)
v3::projects::project_delete(
req,
info,
pool,
redis,
search_config,
session_queue,
)
.await
.or_else(v2_reroute::flatten_404_error)
}
#[post("{id}/follow")]

20
apps/labrinth/src/routes/v2/reports.rs
View File

@@ -25,9 +25,10 @@ pub async fn report_create(
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)?;
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 {
@@ -78,7 +79,8 @@ pub async fn reports(
// 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();
let reports: Vec<_> =
reports.into_iter().map(LegacyReport::from).collect();
Ok(HttpResponse::Ok().json(reports))
}
Err(response) => Ok(response),
@@ -111,7 +113,8 @@ pub async fn reports_get(
// 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();
let report_list: Vec<_> =
report_list.into_iter().map(LegacyReport::from).collect();
Ok(HttpResponse::Ok().json(report_list))
}
Err(response) => Ok(response),
@@ -126,9 +129,10 @@ pub async fn report_get(
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)?;
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 {

4
apps/labrinth/src/routes/v2/statistics.rs
View File

@@ -19,7 +19,9 @@ pub struct V2Stats {
}
#[get("statistics")]
pub async fn get_stats(pool: web::Data<PgPool>) -> Result<HttpResponse, ApiError> {
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)?;

36
apps/labrinth/src/routes/v2/tags.rs
View File

@@ -43,7 +43,9 @@ pub async fn category_list(
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 {
match v2_reroute::extract_ok_json::<Vec<v3::tags::CategoryData>>(response)
.await
{
Ok(categories) => {
let categories = categories
.into_iter()
@@ -75,7 +77,9 @@ pub async fn loader_list(
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 {
match v2_reroute::extract_ok_json::<Vec<v3::tags::LoaderData>>(response)
.await
{
Ok(loaders) => {
let loaders = loaders
.into_iter()
@@ -86,12 +90,15 @@ pub async fn loader_list(
// a project type before any versions are set.
supported_project_types.push("project".to_string());
if ["forge", "fabric", "quilt", "neoforge"].contains(&&*l.name) {
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
.contains(&"plugin".to_string())
{
supported_project_types.push("mod".to_string());
}
@@ -149,7 +156,9 @@ pub async fn game_version_list(
// Convert to V2 format
Ok(
match v2_reroute::extract_ok_json::<Vec<LoaderFieldEnumValue>>(response).await {
match v2_reroute::extract_ok_json::<Vec<LoaderFieldEnumValue>>(response)
.await
{
Ok(fields) => {
let fields = fields
.into_iter()
@@ -187,7 +196,8 @@ 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 {
match v2_reroute::extract_ok_json::<Vec<v3::tags::License>>(response).await
{
Ok(licenses) => {
let licenses = licenses
.into_iter()
@@ -209,14 +219,18 @@ pub struct LicenseText {
}
#[get("license/{id}")]
pub async fn license_text(params: web::Path<(String,)>) -> Result<HttpResponse, ApiError> {
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 {
match v2_reroute::extract_ok_json::<v3::tags::LicenseText>(license)
.await
{
Ok(license) => HttpResponse::Ok().json(LicenseText {
title: license.title,
body: license.body,
@@ -244,7 +258,11 @@ pub async fn donation_platform_list(
// Convert to V2 format
Ok(
match v2_reroute::extract_ok_json::<Vec<LinkPlatformQueryData>>(response).await {
match v2_reroute::extract_ok_json::<Vec<LinkPlatformQueryData>>(
response,
)
.await
{
Ok(platforms) => {
let platforms = platforms
.into_iter()

23
apps/labrinth/src/routes/v2/teams.rs
View File

@@ -1,5 +1,7 @@
use crate::database::redis::RedisPool;
use crate::models::teams::{OrganizationPermissions, ProjectPermissions, TeamId, TeamMember};
use crate::models::teams::{
OrganizationPermissions, ProjectPermissions, TeamId, TeamMember,
};
use crate::models::users::UserId;
use crate::models::v2::teams::LegacyTeamMember;
use crate::queue::session::AuthQueue;
@@ -36,9 +38,15 @@ pub async fn team_members_get_project(
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)?;
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) => {
@@ -61,9 +69,10 @@ pub async fn team_members_get(
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)?;
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) => {

13
apps/labrinth/src/routes/v2/threads.rs
View File

@@ -110,7 +110,14 @@ pub async fn message_delete(
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)
v3::threads::message_delete(
req,
info,
pool,
redis,
session_queue,
file_host,
)
.await
.or_else(v2_reroute::flatten_404_error)
}

51
apps/labrinth/src/routes/v2/users.rs
View File

@@ -64,15 +64,19 @@ pub async fn users_get(
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)?;
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();
let legacy_users: Vec<LegacyUser> =
users.into_iter().map(LegacyUser::from).collect();
Ok(HttpResponse::Ok().json(legacy_users))
}
Err(response) => Ok(response),
@@ -107,14 +111,21 @@ pub async fn projects_list(
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)?;
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?;
let legacy_projects =
LegacyProject::from_many(project, &**pool, &redis).await?;
Ok(HttpResponse::Ok().json(legacy_projects))
}
Err(response) => Ok(response),
@@ -230,14 +241,21 @@ pub async fn user_follows(
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)?;
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?;
let legacy_projects =
LegacyProject::from_many(project, &**pool, &redis).await?;
Ok(HttpResponse::Ok().json(legacy_projects))
}
Err(response) => Ok(response),
@@ -252,9 +270,10 @@ pub async fn user_notifications(
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)?;
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) => {

98
apps/labrinth/src/routes/v2/version_creation.rs
View File

@@ -4,7 +4,8 @@ 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,
Dependency, FileType, Loader, ProjectId, Version, VersionId, VersionStatus,
VersionType,
};
use crate::models::v2::projects::LegacyVersion;
use crate::queue::moderation::AutomatedModerationQueue;
@@ -93,7 +94,8 @@ pub async fn version_create(
let payload = v2_reroute::alter_actix_multipart(
payload,
req.headers().clone(),
|legacy_create: InitialVersionData, content_dispositions: Vec<ContentDisposition>| {
|legacy_create: InitialVersionData,
content_dispositions: Vec<ContentDisposition>| {
let client = client.clone();
let redis = redis.clone();
async move {
@@ -105,19 +107,27 @@ pub async fn version_create(
);
// 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)
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![],
};
.unwrap_or_default()
}
Err(_) => vec![],
};
let loader_fields_aggregate = loaders
.into_iter()
.filter_map(|loader| {
if legacy_create.loaders.contains(&Loader(loader.name.clone())) {
if legacy_create
.loaders
.contains(&Loader(loader.name.clone()))
{
Some(loader.supported_fields)
} else {
None
@@ -150,15 +160,29 @@ pub async fn version_create(
.map(|f| (f.to_string(), json!(false))),
);
if let Some(example_version_fields) =
get_example_version_fields(legacy_create.project_id, client, &redis).await?
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
}
}));
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
@@ -180,9 +204,14 @@ pub async fn version_create(
// 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)?;
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()))?;
.ok_or_else(|| {
CreateError::InvalidFileType(
file_extension.to_string(),
)
})?;
if file_extension == "mrpack" {
project_type = Some("modpack");
@@ -193,7 +222,10 @@ pub async fn version_create(
// 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));
fields.insert(
"mrpack_loaders".to_string(),
json!(legacy_create.loaders),
);
}
let loaders = if project_type == Some("modpack") {
@@ -257,18 +289,20 @@ async fn get_example_version_fields(
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 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),
};
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))
}

81
apps/labrinth/src/routes/v2/version_file.rs
View File

@@ -38,10 +38,16 @@ pub async fn get_version_from_hash(
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)?;
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 {
@@ -64,9 +70,16 @@ pub async fn download_version(
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)
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}
@@ -80,9 +93,16 @@ pub async fn delete_file(
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)
v3::version_file::delete_file(
req,
info,
pool,
redis,
hash_query,
session_queue,
)
.await
.or_else(v2_reroute::flatten_404_error)
}
#[derive(Serialize, Deserialize)]
@@ -171,7 +191,9 @@ pub async fn get_versions_from_hashes(
.or_else(v2_reroute::flatten_404_error)?;
// Convert to V2
match v2_reroute::extract_ok_json::<HashMap<String, Version>>(response).await {
match v2_reroute::extract_ok_json::<HashMap<String, Version>>(response)
.await
{
Ok(versions) => {
let v2_versions = versions
.into_iter()
@@ -210,7 +232,9 @@ pub async fn get_projects_from_hashes(
.or_else(v2_reroute::flatten_404_error)?;
// Convert to V2
match v2_reroute::extract_ok_json::<HashMap<String, Project>>(response).await {
match v2_reroute::extract_ok_json::<HashMap<String, Project>>(response)
.await
{
Ok(projects_hashes) => {
let hash_to_project_id = projects_hashes
.iter()
@@ -219,14 +243,19 @@ pub async fn get_projects_from_hashes(
(hash.clone(), project_id)
})
.collect::<HashMap<_, _>>();
let legacy_projects =
LegacyProject::from_many(projects_hashes.into_values().collect(), &**pool, &redis)
.await?;
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();
let legacy_project = legacy_projects
.iter()
.find(|x| x.id == project_id)?
.clone();
Some((hash, legacy_project))
})
.collect::<HashMap<_, _>>();
@@ -261,12 +290,15 @@ pub async fn update_files(
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)?;
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 {
match v2_reroute::extract_ok_json::<HashMap<String, Version>>(response)
.await
{
Ok(returned_versions) => {
let v3_versions = returned_versions
.into_iter()
@@ -316,7 +348,8 @@ pub async fn update_individual_files(
game_versions.push(serde_json::json!(gv.clone()));
}
if !game_versions.is_empty() {
loader_fields.insert("game_versions".to_string(), game_versions);
loader_fields
.insert("game_versions".to_string(), game_versions);
}
v3::version_file::FileUpdateData {
hash: x.hash.clone(),
@@ -339,7 +372,9 @@ pub async fn update_individual_files(
.or_else(v2_reroute::flatten_404_error)?;
// Convert response to V2 format
match v2_reroute::extract_ok_json::<HashMap<String, Version>>(response).await {
match v2_reroute::extract_ok_json::<HashMap<String, Version>>(response)
.await
{
Ok(returned_versions) => {
let v3_versions = returned_versions
.into_iter()

78
apps/labrinth/src/routes/v2/versions.rs
View File

@@ -4,7 +4,9 @@ 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::projects::{
Dependency, FileType, Version, VersionStatus, VersionType,
};
use crate::models::v2::projects::LegacyVersion;
use crate::queue::session::AuthQueue;
use crate::routes::{v2_reroute, v3};
@@ -67,7 +69,8 @@ pub async fn version_list(
for gv in versions {
game_versions.push(serde_json::json!(gv.clone()));
}
loader_fields.insert("game_versions".to_string(), game_versions);
loader_fields
.insert("game_versions".to_string(), game_versions);
if let Some(ref loaders) = loaders {
loader_fields.insert(
@@ -94,10 +97,16 @@ pub async fn version_list(
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)?;
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 {
@@ -122,9 +131,15 @@ pub async fn version_project_get(
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)?;
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) => {
@@ -149,9 +164,15 @@ pub async fn versions_get(
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)?;
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 {
@@ -175,9 +196,10 @@ pub async fn version_get(
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)?;
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) => {
@@ -252,16 +274,19 @@ pub async fn version_edit(
)
.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),
};
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() {
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),
@@ -315,7 +340,14 @@ pub async fn version_delete(
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)
v3::versions::version_delete(
req,
info,
pool,
redis,
session_queue,
search_config,
)
.await
.or_else(v2_reroute::flatten_404_error)
}