900 lines
32 KiB
Rust
900 lines
32 KiB
Rust
use super::ids::*;
|
|
use crate::models::projects::ProjectStatus;
|
|
use chrono::{DateTime, Utc};
|
|
use serde::Deserialize;
|
|
|
|
#[derive(Clone, Debug, Deserialize)]
|
|
pub struct DonationUrl {
|
|
pub platform_id: DonationPlatformId,
|
|
pub platform_short: String,
|
|
pub platform_name: String,
|
|
pub url: String,
|
|
}
|
|
|
|
impl DonationUrl {
|
|
pub async fn insert(
|
|
&self,
|
|
project_id: ProjectId,
|
|
transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
|
|
) -> Result<(), sqlx::error::Error> {
|
|
sqlx::query!(
|
|
"
|
|
INSERT INTO mods_donations (
|
|
joining_mod_id, joining_platform_id, url
|
|
)
|
|
VALUES (
|
|
$1, $2, $3
|
|
)
|
|
",
|
|
project_id as ProjectId,
|
|
self.platform_id as DonationPlatformId,
|
|
self.url,
|
|
)
|
|
.execute(&mut *transaction)
|
|
.await?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, Deserialize)]
|
|
pub struct GalleryItem {
|
|
pub image_url: String,
|
|
pub featured: bool,
|
|
pub title: Option<String>,
|
|
pub description: Option<String>,
|
|
pub created: DateTime<Utc>,
|
|
}
|
|
|
|
impl GalleryItem {
|
|
pub async fn insert(
|
|
&self,
|
|
project_id: ProjectId,
|
|
transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
|
|
) -> Result<(), sqlx::error::Error> {
|
|
sqlx::query!(
|
|
"
|
|
INSERT INTO mods_gallery (
|
|
mod_id, image_url, featured, title, description
|
|
)
|
|
VALUES (
|
|
$1, $2, $3, $4, $5
|
|
)
|
|
",
|
|
project_id as ProjectId,
|
|
self.image_url,
|
|
self.featured,
|
|
self.title,
|
|
self.description
|
|
)
|
|
.execute(&mut *transaction)
|
|
.await?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
pub struct ProjectBuilder {
|
|
pub project_id: ProjectId,
|
|
pub project_type_id: ProjectTypeId,
|
|
pub team_id: TeamId,
|
|
pub title: String,
|
|
pub description: String,
|
|
pub body: String,
|
|
pub icon_url: Option<String>,
|
|
pub issues_url: Option<String>,
|
|
pub source_url: Option<String>,
|
|
pub wiki_url: Option<String>,
|
|
pub license_url: Option<String>,
|
|
pub discord_url: Option<String>,
|
|
pub categories: Vec<CategoryId>,
|
|
pub additional_categories: Vec<CategoryId>,
|
|
pub initial_versions: Vec<super::version_item::VersionBuilder>,
|
|
pub status: ProjectStatus,
|
|
pub requested_status: Option<ProjectStatus>,
|
|
pub client_side: SideTypeId,
|
|
pub server_side: SideTypeId,
|
|
pub license: String,
|
|
pub slug: Option<String>,
|
|
pub donation_urls: Vec<DonationUrl>,
|
|
pub gallery_items: Vec<GalleryItem>,
|
|
}
|
|
|
|
impl ProjectBuilder {
|
|
pub async fn insert(
|
|
self,
|
|
transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
|
|
) -> Result<ProjectId, super::DatabaseError> {
|
|
let project_struct = Project {
|
|
id: self.project_id,
|
|
project_type: self.project_type_id,
|
|
team_id: self.team_id,
|
|
title: self.title,
|
|
description: self.description,
|
|
body: self.body,
|
|
body_url: None,
|
|
published: Utc::now(),
|
|
updated: Utc::now(),
|
|
approved: None,
|
|
status: self.status,
|
|
requested_status: self.requested_status,
|
|
downloads: 0,
|
|
follows: 0,
|
|
icon_url: self.icon_url,
|
|
issues_url: self.issues_url,
|
|
source_url: self.source_url,
|
|
wiki_url: self.wiki_url,
|
|
license_url: self.license_url,
|
|
discord_url: self.discord_url,
|
|
client_side: self.client_side,
|
|
server_side: self.server_side,
|
|
license: self.license,
|
|
slug: self.slug,
|
|
moderation_message: None,
|
|
moderation_message_body: None,
|
|
flame_anvil_project: None,
|
|
flame_anvil_user: None,
|
|
webhook_sent: false,
|
|
};
|
|
project_struct.insert(&mut *transaction).await?;
|
|
|
|
for mut version in self.initial_versions {
|
|
version.project_id = self.project_id;
|
|
version.insert(&mut *transaction).await?;
|
|
}
|
|
|
|
for donation in self.donation_urls {
|
|
donation.insert(self.project_id, &mut *transaction).await?;
|
|
}
|
|
|
|
for gallery in self.gallery_items {
|
|
gallery.insert(self.project_id, &mut *transaction).await?;
|
|
}
|
|
|
|
for category in self.categories {
|
|
sqlx::query!(
|
|
"
|
|
INSERT INTO mods_categories (joining_mod_id, joining_category_id, is_additional)
|
|
VALUES ($1, $2, FALSE)
|
|
",
|
|
self.project_id as ProjectId,
|
|
category as CategoryId,
|
|
)
|
|
.execute(&mut *transaction)
|
|
.await?;
|
|
}
|
|
|
|
for category in self.additional_categories {
|
|
sqlx::query!(
|
|
"
|
|
INSERT INTO mods_categories (joining_mod_id, joining_category_id, is_additional)
|
|
VALUES ($1, $2, TRUE)
|
|
",
|
|
self.project_id as ProjectId,
|
|
category as CategoryId,
|
|
)
|
|
.execute(&mut *transaction)
|
|
.await?;
|
|
}
|
|
|
|
Ok(self.project_id)
|
|
}
|
|
}
|
|
#[derive(Clone, Debug)]
|
|
pub struct Project {
|
|
pub id: ProjectId,
|
|
pub project_type: ProjectTypeId,
|
|
pub team_id: TeamId,
|
|
pub title: String,
|
|
pub description: String,
|
|
pub body: String,
|
|
pub body_url: Option<String>,
|
|
pub published: DateTime<Utc>,
|
|
pub updated: DateTime<Utc>,
|
|
pub approved: Option<DateTime<Utc>>,
|
|
pub status: ProjectStatus,
|
|
pub requested_status: Option<ProjectStatus>,
|
|
pub downloads: i32,
|
|
pub follows: i32,
|
|
pub icon_url: Option<String>,
|
|
pub issues_url: Option<String>,
|
|
pub source_url: Option<String>,
|
|
pub wiki_url: Option<String>,
|
|
pub license_url: Option<String>,
|
|
pub discord_url: Option<String>,
|
|
pub client_side: SideTypeId,
|
|
pub server_side: SideTypeId,
|
|
pub license: String,
|
|
pub slug: Option<String>,
|
|
pub moderation_message: Option<String>,
|
|
pub moderation_message_body: Option<String>,
|
|
pub flame_anvil_project: Option<i32>,
|
|
pub flame_anvil_user: Option<UserId>,
|
|
pub webhook_sent: bool,
|
|
}
|
|
|
|
impl Project {
|
|
pub async fn insert(
|
|
&self,
|
|
transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
|
|
) -> Result<(), sqlx::error::Error> {
|
|
sqlx::query!(
|
|
"
|
|
INSERT INTO mods (
|
|
id, team_id, title, description, body,
|
|
published, downloads, icon_url, issues_url,
|
|
source_url, wiki_url, status, requested_status, discord_url,
|
|
client_side, server_side, license_url, license,
|
|
slug, project_type
|
|
)
|
|
VALUES (
|
|
$1, $2, $3, $4, $5,
|
|
$6, $7, $8, $9,
|
|
$10, $11, $12, $13, $14,
|
|
$15, $16, $17, $18,
|
|
LOWER($19), $20
|
|
)
|
|
",
|
|
self.id as ProjectId,
|
|
self.team_id as TeamId,
|
|
&self.title,
|
|
&self.description,
|
|
&self.body,
|
|
self.published,
|
|
self.downloads,
|
|
self.icon_url.as_ref(),
|
|
self.issues_url.as_ref(),
|
|
self.source_url.as_ref(),
|
|
self.wiki_url.as_ref(),
|
|
self.status.as_str(),
|
|
self.requested_status.map(|x| x.as_str()),
|
|
self.discord_url.as_ref(),
|
|
self.client_side as SideTypeId,
|
|
self.server_side as SideTypeId,
|
|
self.license_url.as_ref(),
|
|
&self.license,
|
|
self.slug.as_ref(),
|
|
self.project_type as ProjectTypeId
|
|
)
|
|
.execute(&mut *transaction)
|
|
.await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub async fn get<'a, 'b, E>(
|
|
id: ProjectId,
|
|
executor: E,
|
|
) -> Result<Option<Self>, sqlx::error::Error>
|
|
where
|
|
E: sqlx::Executor<'a, Database = sqlx::Postgres>,
|
|
{
|
|
let result = sqlx::query!(
|
|
"
|
|
SELECT project_type, title, description, downloads, follows,
|
|
icon_url, body, body_url, published,
|
|
updated, approved, status, requested_status,
|
|
issues_url, source_url, wiki_url, discord_url, license_url,
|
|
team_id, client_side, server_side, license, slug,
|
|
moderation_message, moderation_message_body, flame_anvil_project,
|
|
flame_anvil_user, webhook_sent
|
|
FROM mods
|
|
WHERE id = $1
|
|
",
|
|
id as ProjectId,
|
|
)
|
|
.fetch_optional(executor)
|
|
.await?;
|
|
|
|
if let Some(row) = result {
|
|
Ok(Some(Project {
|
|
id,
|
|
project_type: ProjectTypeId(row.project_type),
|
|
team_id: TeamId(row.team_id),
|
|
title: row.title,
|
|
description: row.description,
|
|
downloads: row.downloads,
|
|
body_url: row.body_url,
|
|
icon_url: row.icon_url,
|
|
published: row.published,
|
|
updated: row.updated,
|
|
issues_url: row.issues_url,
|
|
source_url: row.source_url,
|
|
wiki_url: row.wiki_url,
|
|
license_url: row.license_url,
|
|
discord_url: row.discord_url,
|
|
client_side: SideTypeId(row.client_side),
|
|
status: ProjectStatus::from_str(&row.status),
|
|
requested_status: row
|
|
.requested_status
|
|
.map(|x| ProjectStatus::from_str(&x)),
|
|
server_side: SideTypeId(row.server_side),
|
|
license: row.license,
|
|
slug: row.slug,
|
|
body: row.body,
|
|
follows: row.follows,
|
|
moderation_message: row.moderation_message,
|
|
moderation_message_body: row.moderation_message_body,
|
|
approved: row.approved,
|
|
flame_anvil_project: row.flame_anvil_project,
|
|
flame_anvil_user: row.flame_anvil_user.map(UserId),
|
|
webhook_sent: row.webhook_sent,
|
|
}))
|
|
} else {
|
|
Ok(None)
|
|
}
|
|
}
|
|
|
|
pub async fn get_many<'a, E>(
|
|
project_ids: Vec<ProjectId>,
|
|
exec: E,
|
|
) -> Result<Vec<Project>, sqlx::Error>
|
|
where
|
|
E: sqlx::Executor<'a, Database = sqlx::Postgres> + Copy,
|
|
{
|
|
use futures::stream::TryStreamExt;
|
|
|
|
let project_ids_parsed: Vec<i64> =
|
|
project_ids.into_iter().map(|x| x.0).collect();
|
|
let projects = sqlx::query!(
|
|
"
|
|
SELECT id, project_type, title, description, downloads, follows,
|
|
icon_url, body, body_url, published,
|
|
updated, approved, status, requested_status,
|
|
issues_url, source_url, wiki_url, discord_url, license_url,
|
|
team_id, client_side, server_side, license, slug,
|
|
moderation_message, moderation_message_body, flame_anvil_project,
|
|
flame_anvil_user, webhook_sent
|
|
FROM mods
|
|
WHERE id = ANY($1)
|
|
",
|
|
&project_ids_parsed
|
|
)
|
|
.fetch_many(exec)
|
|
.try_filter_map(|e| async {
|
|
Ok(e.right().map(|m| Project {
|
|
id: ProjectId(m.id),
|
|
project_type: ProjectTypeId(m.project_type),
|
|
team_id: TeamId(m.team_id),
|
|
title: m.title,
|
|
description: m.description,
|
|
downloads: m.downloads,
|
|
body_url: m.body_url,
|
|
icon_url: m.icon_url,
|
|
published: m.published,
|
|
updated: m.updated,
|
|
issues_url: m.issues_url,
|
|
source_url: m.source_url,
|
|
wiki_url: m.wiki_url,
|
|
license_url: m.license_url,
|
|
discord_url: m.discord_url,
|
|
client_side: SideTypeId(m.client_side),
|
|
status: ProjectStatus::from_str(
|
|
&m.status,
|
|
),
|
|
requested_status: m.requested_status.map(|x| ProjectStatus::from_str(
|
|
&x,
|
|
)),
|
|
server_side: SideTypeId(m.server_side),
|
|
license: m.license,
|
|
slug: m.slug,
|
|
body: m.body,
|
|
follows: m.follows,
|
|
moderation_message: m.moderation_message,
|
|
moderation_message_body: m.moderation_message_body,
|
|
approved: m.approved,
|
|
flame_anvil_project: m.flame_anvil_project,
|
|
flame_anvil_user: m.flame_anvil_user.map(UserId),
|
|
webhook_sent: m.webhook_sent,
|
|
}))
|
|
})
|
|
.try_collect::<Vec<Project>>()
|
|
.await?;
|
|
|
|
Ok(projects)
|
|
}
|
|
|
|
pub async fn remove_full(
|
|
id: ProjectId,
|
|
transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
|
|
) -> Result<Option<()>, sqlx::error::Error> {
|
|
let result = sqlx::query!(
|
|
"
|
|
SELECT team_id FROM mods WHERE id = $1
|
|
",
|
|
id as ProjectId,
|
|
)
|
|
.fetch_optional(&mut *transaction)
|
|
.await?;
|
|
|
|
let team_id: TeamId = if let Some(id) = result {
|
|
TeamId(id.team_id)
|
|
} else {
|
|
return Ok(None);
|
|
};
|
|
|
|
sqlx::query!(
|
|
"
|
|
DELETE FROM mod_follows
|
|
WHERE mod_id = $1
|
|
",
|
|
id as ProjectId
|
|
)
|
|
.execute(&mut *transaction)
|
|
.await?;
|
|
|
|
sqlx::query!(
|
|
"
|
|
DELETE FROM mods_gallery
|
|
WHERE mod_id = $1
|
|
",
|
|
id as ProjectId
|
|
)
|
|
.execute(&mut *transaction)
|
|
.await?;
|
|
|
|
sqlx::query!(
|
|
"
|
|
DELETE FROM mod_follows
|
|
WHERE mod_id = $1
|
|
",
|
|
id as ProjectId,
|
|
)
|
|
.execute(&mut *transaction)
|
|
.await?;
|
|
|
|
sqlx::query!(
|
|
"
|
|
DELETE FROM reports
|
|
WHERE mod_id = $1
|
|
",
|
|
id as ProjectId,
|
|
)
|
|
.execute(&mut *transaction)
|
|
.await?;
|
|
|
|
sqlx::query!(
|
|
"
|
|
DELETE FROM mods_categories
|
|
WHERE joining_mod_id = $1
|
|
",
|
|
id as ProjectId,
|
|
)
|
|
.execute(&mut *transaction)
|
|
.await?;
|
|
|
|
sqlx::query!(
|
|
"
|
|
DELETE FROM mods_donations
|
|
WHERE joining_mod_id = $1
|
|
",
|
|
id as ProjectId,
|
|
)
|
|
.execute(&mut *transaction)
|
|
.await?;
|
|
|
|
use futures::TryStreamExt;
|
|
let versions: Vec<VersionId> = sqlx::query!(
|
|
"
|
|
SELECT id FROM versions
|
|
WHERE mod_id = $1
|
|
",
|
|
id as ProjectId,
|
|
)
|
|
.fetch_many(&mut *transaction)
|
|
.try_filter_map(|e| async { Ok(e.right().map(|c| VersionId(c.id))) })
|
|
.try_collect::<Vec<VersionId>>()
|
|
.await?;
|
|
|
|
for version in versions {
|
|
super::Version::remove_full(version, transaction).await?;
|
|
}
|
|
|
|
sqlx::query!(
|
|
"
|
|
DELETE FROM dependencies WHERE mod_dependency_id = $1
|
|
",
|
|
id as ProjectId,
|
|
)
|
|
.execute(&mut *transaction)
|
|
.await?;
|
|
|
|
sqlx::query!(
|
|
"
|
|
UPDATE payouts_values
|
|
SET mod_id = NULL
|
|
WHERE (mod_id = $1)
|
|
",
|
|
id as ProjectId,
|
|
)
|
|
.execute(&mut *transaction)
|
|
.await?;
|
|
|
|
sqlx::query!(
|
|
"
|
|
DELETE FROM mods
|
|
WHERE id = $1
|
|
",
|
|
id as ProjectId,
|
|
)
|
|
.execute(&mut *transaction)
|
|
.await?;
|
|
|
|
sqlx::query!(
|
|
"
|
|
DELETE FROM team_members
|
|
WHERE team_id = $1
|
|
",
|
|
team_id as TeamId,
|
|
)
|
|
.execute(&mut *transaction)
|
|
.await?;
|
|
|
|
sqlx::query!(
|
|
"
|
|
DELETE FROM teams
|
|
WHERE id = $1
|
|
",
|
|
team_id as TeamId,
|
|
)
|
|
.execute(&mut *transaction)
|
|
.await?;
|
|
|
|
Ok(Some(()))
|
|
}
|
|
|
|
pub async fn get_full_from_slug<'a, 'b, E>(
|
|
slug: &str,
|
|
executor: E,
|
|
) -> Result<Option<QueryProject>, sqlx::error::Error>
|
|
where
|
|
E: sqlx::Executor<'a, Database = sqlx::Postgres> + Copy,
|
|
{
|
|
let id = sqlx::query!(
|
|
"
|
|
SELECT id FROM mods
|
|
WHERE slug = LOWER($1)
|
|
",
|
|
slug
|
|
)
|
|
.fetch_optional(executor)
|
|
.await?;
|
|
|
|
if let Some(project_id) = id {
|
|
Project::get_full(ProjectId(project_id.id), executor).await
|
|
} else {
|
|
Ok(None)
|
|
}
|
|
}
|
|
|
|
pub async fn get_from_slug<'a, 'b, E>(
|
|
slug: &str,
|
|
executor: E,
|
|
) -> Result<Option<Project>, sqlx::error::Error>
|
|
where
|
|
E: sqlx::Executor<'a, Database = sqlx::Postgres> + Copy,
|
|
{
|
|
let id = sqlx::query!(
|
|
"
|
|
SELECT id FROM mods
|
|
WHERE slug = LOWER($1)
|
|
",
|
|
slug
|
|
)
|
|
.fetch_optional(executor)
|
|
.await?;
|
|
|
|
if let Some(project_id) = id {
|
|
Project::get(ProjectId(project_id.id), executor).await
|
|
} else {
|
|
Ok(None)
|
|
}
|
|
}
|
|
|
|
pub async fn get_from_slug_or_project_id<'a, 'b, E>(
|
|
slug_or_project_id: &str,
|
|
executor: E,
|
|
) -> Result<Option<Project>, sqlx::error::Error>
|
|
where
|
|
E: sqlx::Executor<'a, Database = sqlx::Postgres> + Copy,
|
|
{
|
|
let id_option =
|
|
crate::models::ids::base62_impl::parse_base62(slug_or_project_id)
|
|
.ok();
|
|
|
|
if let Some(id) = id_option {
|
|
let mut project =
|
|
Project::get(ProjectId(id as i64), executor).await?;
|
|
|
|
if project.is_none() {
|
|
project = Project::get_from_slug(slug_or_project_id, executor)
|
|
.await?;
|
|
}
|
|
|
|
Ok(project)
|
|
} else {
|
|
let project =
|
|
Project::get_from_slug(slug_or_project_id, executor).await?;
|
|
|
|
Ok(project)
|
|
}
|
|
}
|
|
|
|
pub async fn get_full_from_slug_or_project_id<'a, 'b, E>(
|
|
slug_or_project_id: &str,
|
|
executor: E,
|
|
) -> Result<Option<QueryProject>, sqlx::error::Error>
|
|
where
|
|
E: sqlx::Executor<'a, Database = sqlx::Postgres> + Copy,
|
|
{
|
|
let id_option =
|
|
crate::models::ids::base62_impl::parse_base62(slug_or_project_id)
|
|
.ok();
|
|
|
|
if let Some(id) = id_option {
|
|
let mut project =
|
|
Project::get_full(ProjectId(id as i64), executor).await?;
|
|
|
|
if project.is_none() {
|
|
project =
|
|
Project::get_full_from_slug(slug_or_project_id, executor)
|
|
.await?;
|
|
}
|
|
|
|
Ok(project)
|
|
} else {
|
|
let project =
|
|
Project::get_full_from_slug(slug_or_project_id, executor)
|
|
.await?;
|
|
Ok(project)
|
|
}
|
|
}
|
|
|
|
pub async fn get_full<'a, 'b, E>(
|
|
id: ProjectId,
|
|
executor: E,
|
|
) -> Result<Option<QueryProject>, sqlx::error::Error>
|
|
where
|
|
E: sqlx::Executor<'a, Database = sqlx::Postgres>,
|
|
{
|
|
let result = sqlx::query!(
|
|
"
|
|
SELECT m.id id, m.project_type project_type, m.title title, m.description description, m.downloads downloads, m.follows follows,
|
|
m.icon_url icon_url, m.body body, m.body_url body_url, m.published published,
|
|
m.updated updated, m.approved approved, m.status status, m.requested_status requested_status,
|
|
m.issues_url issues_url, m.source_url source_url, m.wiki_url wiki_url, m.discord_url discord_url, m.license_url license_url,
|
|
m.team_id team_id, m.client_side client_side, m.server_side server_side, m.license license, m.slug slug, m.moderation_message moderation_message, m.moderation_message_body moderation_message_body,
|
|
cs.name client_side_type, ss.name server_side_type, pt.name project_type_name, m.flame_anvil_project flame_anvil_project, m.flame_anvil_user flame_anvil_user, m.webhook_sent webhook_sent,
|
|
ARRAY_AGG(DISTINCT c.category) filter (where c.category is not null and mc.is_additional is false) categories,
|
|
ARRAY_AGG(DISTINCT c.category) filter (where c.category is not null and mc.is_additional is true) additional_categories,
|
|
JSONB_AGG(DISTINCT jsonb_build_object('id', v.id, 'date_published', v.date_published)) filter (where v.id is not null) versions,
|
|
JSONB_AGG(DISTINCT jsonb_build_object('image_url', mg.image_url, 'featured', mg.featured, 'title', mg.title, 'description', mg.description, 'created', mg.created)) filter (where mg.image_url is not null) gallery,
|
|
JSONB_AGG(DISTINCT jsonb_build_object('platform_id', md.joining_platform_id, 'platform_short', dp.short, 'platform_name', dp.name,'url', md.url)) filter (where md.joining_platform_id is not null) donations
|
|
FROM mods m
|
|
INNER JOIN project_types pt ON pt.id = m.project_type
|
|
INNER JOIN side_types cs ON m.client_side = cs.id
|
|
INNER JOIN side_types ss ON m.server_side = ss.id
|
|
LEFT JOIN mods_donations md ON md.joining_mod_id = m.id
|
|
LEFT JOIN donation_platforms dp ON md.joining_platform_id = dp.id
|
|
LEFT JOIN mods_categories mc ON mc.joining_mod_id = m.id
|
|
LEFT JOIN categories c ON mc.joining_category_id = c.id
|
|
LEFT JOIN versions v ON v.mod_id = m.id AND v.status = ANY($2)
|
|
LEFT JOIN mods_gallery mg ON mg.mod_id = m.id
|
|
WHERE m.id = $1
|
|
GROUP BY pt.id, cs.id, ss.id, m.id;
|
|
",
|
|
id as ProjectId,
|
|
&*crate::models::projects::VersionStatus::iterator().filter(|x| x.is_listed()).map(|x| x.to_string()).collect::<Vec<String>>()
|
|
)
|
|
.fetch_optional(executor)
|
|
.await?;
|
|
|
|
if let Some(m) = result {
|
|
Ok(Some(QueryProject {
|
|
inner: Project {
|
|
id: ProjectId(m.id),
|
|
project_type: ProjectTypeId(m.project_type),
|
|
team_id: TeamId(m.team_id),
|
|
title: m.title.clone(),
|
|
description: m.description.clone(),
|
|
downloads: m.downloads,
|
|
body_url: m.body_url.clone(),
|
|
icon_url: m.icon_url.clone(),
|
|
published: m.published,
|
|
updated: m.updated,
|
|
issues_url: m.issues_url.clone(),
|
|
source_url: m.source_url.clone(),
|
|
wiki_url: m.wiki_url.clone(),
|
|
license_url: m.license_url.clone(),
|
|
discord_url: m.discord_url.clone(),
|
|
client_side: SideTypeId(m.client_side),
|
|
status: ProjectStatus::from_str(&m.status),
|
|
requested_status: m
|
|
.requested_status
|
|
.map(|x| ProjectStatus::from_str(&x)),
|
|
server_side: SideTypeId(m.server_side),
|
|
license: m.license.clone(),
|
|
slug: m.slug.clone(),
|
|
body: m.body.clone(),
|
|
follows: m.follows,
|
|
moderation_message: m.moderation_message,
|
|
moderation_message_body: m.moderation_message_body,
|
|
approved: m.approved,
|
|
flame_anvil_project: m.flame_anvil_project,
|
|
flame_anvil_user: m.flame_anvil_user.map(UserId),
|
|
webhook_sent: m.webhook_sent,
|
|
},
|
|
project_type: m.project_type_name,
|
|
categories: m.categories.unwrap_or_default(),
|
|
additional_categories: m
|
|
.additional_categories
|
|
.unwrap_or_default(),
|
|
versions: {
|
|
#[derive(Deserialize)]
|
|
struct Version {
|
|
pub id: VersionId,
|
|
pub date_published: DateTime<Utc>,
|
|
}
|
|
|
|
let mut versions: Vec<Version> =
|
|
serde_json::from_value(m.versions.unwrap_or_default())
|
|
.ok()
|
|
.unwrap_or_default();
|
|
|
|
versions.sort_by(|a, b| {
|
|
a.date_published.cmp(&b.date_published)
|
|
});
|
|
|
|
versions.into_iter().map(|x| x.id).collect()
|
|
},
|
|
gallery_items: serde_json::from_value(
|
|
m.gallery.unwrap_or_default(),
|
|
)
|
|
.ok()
|
|
.unwrap_or_default(),
|
|
donation_urls: serde_json::from_value(
|
|
m.donations.unwrap_or_default(),
|
|
)
|
|
.ok()
|
|
.unwrap_or_default(),
|
|
client_side: crate::models::projects::SideType::from_str(
|
|
&m.client_side_type,
|
|
),
|
|
server_side: crate::models::projects::SideType::from_str(
|
|
&m.server_side_type,
|
|
),
|
|
}))
|
|
} else {
|
|
Ok(None)
|
|
}
|
|
}
|
|
|
|
pub async fn get_many_full<'a, E>(
|
|
project_ids: Vec<ProjectId>,
|
|
exec: E,
|
|
) -> Result<Vec<QueryProject>, sqlx::Error>
|
|
where
|
|
E: sqlx::Executor<'a, Database = sqlx::Postgres>,
|
|
{
|
|
use futures::TryStreamExt;
|
|
|
|
let project_ids_parsed: Vec<i64> =
|
|
project_ids.into_iter().map(|x| x.0).collect();
|
|
sqlx::query!(
|
|
"
|
|
SELECT m.id id, m.project_type project_type, m.title title, m.description description, m.downloads downloads, m.follows follows,
|
|
m.icon_url icon_url, m.body body, m.body_url body_url, m.published published,
|
|
m.updated updated, m.approved approved, m.status status, m.requested_status requested_status,
|
|
m.issues_url issues_url, m.source_url source_url, m.wiki_url wiki_url, m.discord_url discord_url, m.license_url license_url,
|
|
m.team_id team_id, m.client_side client_side, m.server_side server_side, m.license license, m.slug slug, m.moderation_message moderation_message, m.moderation_message_body moderation_message_body,
|
|
cs.name client_side_type, ss.name server_side_type, pt.name project_type_name, m.flame_anvil_project flame_anvil_project, m.flame_anvil_user flame_anvil_user, m.webhook_sent,
|
|
ARRAY_AGG(DISTINCT c.category) filter (where c.category is not null and mc.is_additional is false) categories,
|
|
ARRAY_AGG(DISTINCT c.category) filter (where c.category is not null and mc.is_additional is true) additional_categories,
|
|
JSONB_AGG(DISTINCT jsonb_build_object('id', v.id, 'date_published', v.date_published)) filter (where v.id is not null) versions,
|
|
JSONB_AGG(DISTINCT jsonb_build_object('image_url', mg.image_url, 'featured', mg.featured, 'title', mg.title, 'description', mg.description, 'created', mg.created)) filter (where mg.image_url is not null) gallery,
|
|
JSONB_AGG(DISTINCT jsonb_build_object('platform_id', md.joining_platform_id, 'platform_short', dp.short, 'platform_name', dp.name,'url', md.url)) filter (where md.joining_platform_id is not null) donations
|
|
FROM mods m
|
|
INNER JOIN project_types pt ON pt.id = m.project_type
|
|
INNER JOIN side_types cs ON m.client_side = cs.id
|
|
INNER JOIN side_types ss ON m.server_side = ss.id
|
|
LEFT JOIN mods_donations md ON md.joining_mod_id = m.id
|
|
LEFT JOIN donation_platforms dp ON md.joining_platform_id = dp.id
|
|
LEFT JOIN mods_categories mc ON mc.joining_mod_id = m.id
|
|
LEFT JOIN categories c ON mc.joining_category_id = c.id
|
|
LEFT JOIN versions v ON v.mod_id = m.id AND v.status = ANY($2)
|
|
LEFT JOIN mods_gallery mg ON mg.mod_id = m.id
|
|
WHERE m.id = ANY($1)
|
|
GROUP BY pt.id, cs.id, ss.id, m.id;
|
|
",
|
|
&project_ids_parsed,
|
|
&*crate::models::projects::VersionStatus::iterator().filter(|x| x.is_listed()).map(|x| x.to_string()).collect::<Vec<String>>()
|
|
)
|
|
.fetch_many(exec)
|
|
.try_filter_map(|e| async {
|
|
Ok(e.right().map(|m| {
|
|
let id = m.id;
|
|
|
|
QueryProject {
|
|
inner: Project {
|
|
id: ProjectId(id),
|
|
project_type: ProjectTypeId(m.project_type),
|
|
team_id: TeamId(m.team_id),
|
|
title: m.title.clone(),
|
|
description: m.description.clone(),
|
|
downloads: m.downloads,
|
|
body_url: m.body_url.clone(),
|
|
icon_url: m.icon_url.clone(),
|
|
published: m.published,
|
|
updated: m.updated,
|
|
issues_url: m.issues_url.clone(),
|
|
source_url: m.source_url.clone(),
|
|
wiki_url: m.wiki_url.clone(),
|
|
license_url: m.license_url.clone(),
|
|
discord_url: m.discord_url.clone(),
|
|
client_side: SideTypeId(m.client_side),
|
|
status: ProjectStatus::from_str(
|
|
&m.status,
|
|
),
|
|
requested_status: m.requested_status.map(|x| ProjectStatus::from_str(
|
|
&x,
|
|
)),
|
|
server_side: SideTypeId(m.server_side),
|
|
license: m.license.clone(),
|
|
slug: m.slug.clone(),
|
|
body: m.body.clone(),
|
|
follows: m.follows,
|
|
moderation_message: m.moderation_message,
|
|
moderation_message_body: m.moderation_message_body,
|
|
approved: m.approved,
|
|
flame_anvil_project: m.flame_anvil_project,
|
|
flame_anvil_user: m.flame_anvil_user.map(UserId),
|
|
webhook_sent: m.webhook_sent,
|
|
},
|
|
project_type: m.project_type_name,
|
|
categories: m.categories.unwrap_or_default(),
|
|
additional_categories: m.additional_categories.unwrap_or_default(),
|
|
versions: {
|
|
#[derive(Deserialize)]
|
|
struct Version {
|
|
pub id: VersionId,
|
|
pub date_published: DateTime<Utc>,
|
|
}
|
|
|
|
let mut versions: Vec<Version> = serde_json::from_value(
|
|
m.versions.unwrap_or_default(),
|
|
)
|
|
.ok()
|
|
.unwrap_or_default();
|
|
|
|
versions.sort_by(|a, b| a.date_published.cmp(&b.date_published));
|
|
|
|
versions.into_iter().map(|x| x.id).collect()
|
|
},
|
|
gallery_items: serde_json::from_value(
|
|
m.gallery.unwrap_or_default(),
|
|
).ok().unwrap_or_default(),
|
|
donation_urls: serde_json::from_value(
|
|
m.donations.unwrap_or_default(),
|
|
).ok().unwrap_or_default(),
|
|
client_side: crate::models::projects::SideType::from_str(&m.client_side_type),
|
|
server_side: crate::models::projects::SideType::from_str(&m.server_side_type),
|
|
}}))
|
|
})
|
|
.try_collect::<Vec<QueryProject>>()
|
|
.await
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct QueryProject {
|
|
pub inner: Project,
|
|
pub project_type: String,
|
|
pub categories: Vec<String>,
|
|
pub additional_categories: Vec<String>,
|
|
pub versions: Vec<VersionId>,
|
|
pub donation_urls: Vec<DonationUrl>,
|
|
pub gallery_items: Vec<GalleryItem>,
|
|
pub client_side: crate::models::projects::SideType,
|
|
pub server_side: crate::models::projects::SideType,
|
|
}
|