You've already forked AstralRinth
forked from didirus/AstralRinth
824 lines
27 KiB
Rust
824 lines
27 KiB
Rust
use crate::database::models;
|
|
use crate::database::models::notification_item::NotificationBuilder;
|
|
use crate::database::models::version_item::{
|
|
DependencyBuilder, VersionBuilder, VersionFileBuilder,
|
|
};
|
|
use crate::file_hosting::FileHost;
|
|
use crate::models::pack::PackFileHash;
|
|
use crate::models::projects::{
|
|
Dependency, DependencyType, GameVersion, Loader, ProjectId, Version,
|
|
VersionFile, VersionId, VersionType,
|
|
};
|
|
use crate::models::teams::Permissions;
|
|
use crate::routes::project_creation::{CreateError, UploadedFile};
|
|
use crate::util::auth::get_user_from_headers;
|
|
use crate::util::routes::read_from_field;
|
|
use crate::util::validate::validation_errors_to_string;
|
|
use crate::validate::{validate_file, ValidationResult};
|
|
use actix_multipart::{Field, Multipart};
|
|
use actix_web::web::Data;
|
|
use actix_web::{post, HttpRequest, HttpResponse};
|
|
use chrono::Utc;
|
|
use futures::stream::StreamExt;
|
|
use serde::{Deserialize, Serialize};
|
|
use sqlx::postgres::PgPool;
|
|
use validator::Validate;
|
|
|
|
#[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 = 64),
|
|
regex = "crate::util::validate::RE_URL_SAFE"
|
|
)]
|
|
pub version_number: String,
|
|
#[validate(length(min = 1, max = 256))]
|
|
#[serde(alias = "name")]
|
|
pub version_title: String,
|
|
#[validate(length(max = 65536))]
|
|
#[serde(alias = "changelog")]
|
|
pub version_body: Option<String>,
|
|
#[validate(
|
|
length(min = 0, max = 256),
|
|
custom(function = "crate::util::validate::validate_deps")
|
|
)]
|
|
pub dependencies: Vec<Dependency>,
|
|
#[validate(length(min = 1))]
|
|
pub game_versions: Vec<GameVersion>,
|
|
#[serde(alias = "version_type")]
|
|
pub release_channel: VersionType,
|
|
#[validate(length(min = 1))]
|
|
pub loaders: Vec<Loader>,
|
|
pub featured: bool,
|
|
pub primary_file: Option<String>,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Clone)]
|
|
struct InitialFileData {
|
|
// TODO: hashes?
|
|
}
|
|
|
|
// under `/api/v1/version`
|
|
#[post("version")]
|
|
pub async fn version_create(
|
|
req: HttpRequest,
|
|
payload: Multipart,
|
|
client: Data<PgPool>,
|
|
file_host: Data<std::sync::Arc<dyn FileHost + Send + Sync>>,
|
|
) -> Result<HttpResponse, CreateError> {
|
|
let mut transaction = client.begin().await?;
|
|
let mut uploaded_files = Vec::new();
|
|
|
|
let result = version_create_inner(
|
|
req,
|
|
payload,
|
|
&mut transaction,
|
|
&***file_host,
|
|
&mut uploaded_files,
|
|
)
|
|
.await;
|
|
|
|
if result.is_err() {
|
|
let undo_result = super::project_creation::undo_uploads(
|
|
&***file_host,
|
|
&uploaded_files,
|
|
)
|
|
.await;
|
|
let rollback_result = transaction.rollback().await;
|
|
|
|
if let Err(e) = undo_result {
|
|
return Err(e);
|
|
}
|
|
if let Err(e) = rollback_result {
|
|
return Err(e.into());
|
|
}
|
|
} else {
|
|
transaction.commit().await?;
|
|
}
|
|
|
|
result
|
|
}
|
|
|
|
async fn version_create_inner(
|
|
req: HttpRequest,
|
|
mut payload: Multipart,
|
|
transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
|
|
file_host: &dyn FileHost,
|
|
uploaded_files: &mut Vec<UploadedFile>,
|
|
) -> Result<HttpResponse, CreateError> {
|
|
let cdn_url = dotenv::var("CDN_URL")?;
|
|
|
|
let mut initial_version_data = None;
|
|
let mut version_builder = None;
|
|
|
|
let all_game_versions =
|
|
models::categories::GameVersion::list(&mut *transaction).await?;
|
|
let all_loaders =
|
|
models::categories::Loader::list(&mut *transaction).await?;
|
|
|
|
let user = get_user_from_headers(req.headers(), &mut *transaction).await?;
|
|
|
|
while let Some(item) = payload.next().await {
|
|
let mut field: Field = item.map_err(CreateError::MultipartError)?;
|
|
let content_disposition = field.content_disposition().clone();
|
|
let name = content_disposition.get_name().ok_or_else(|| {
|
|
CreateError::MissingValueError("Missing content name".to_string())
|
|
})?;
|
|
|
|
if name == "data" {
|
|
let mut data = Vec::new();
|
|
while let Some(chunk) = field.next().await {
|
|
data.extend_from_slice(
|
|
&chunk.map_err(CreateError::MultipartError)?,
|
|
);
|
|
}
|
|
|
|
let version_create_data: InitialVersionData =
|
|
serde_json::from_slice(&data)?;
|
|
initial_version_data = Some(version_create_data);
|
|
let version_create_data = initial_version_data.as_ref().unwrap();
|
|
if version_create_data.project_id.is_none() {
|
|
return Err(CreateError::MissingValueError(
|
|
"Missing project id".to_string(),
|
|
));
|
|
}
|
|
|
|
version_create_data.validate().map_err(|err| {
|
|
CreateError::ValidationError(validation_errors_to_string(
|
|
err, None,
|
|
))
|
|
})?;
|
|
|
|
let project_id: models::ProjectId =
|
|
version_create_data.project_id.unwrap().into();
|
|
|
|
// Ensure that the project this version is being added to exists
|
|
let results = sqlx::query!(
|
|
"SELECT EXISTS(SELECT 1 FROM mods WHERE id=$1)",
|
|
project_id as models::ProjectId
|
|
)
|
|
.fetch_one(&mut *transaction)
|
|
.await?;
|
|
|
|
if !results.exists.unwrap_or(false) {
|
|
return Err(CreateError::InvalidInput(
|
|
"An invalid project id was supplied".to_string(),
|
|
));
|
|
}
|
|
|
|
// Check that the user creating this version is a team member
|
|
// of the project the version is being added to.
|
|
let team_member = models::TeamMember::get_from_user_id_project(
|
|
project_id,
|
|
user.id.into(),
|
|
&mut *transaction,
|
|
)
|
|
.await?
|
|
.ok_or_else(|| {
|
|
CreateError::CustomAuthenticationError(
|
|
"You don't have permission to upload this version!"
|
|
.to_string(),
|
|
)
|
|
})?;
|
|
|
|
if !team_member
|
|
.permissions
|
|
.contains(Permissions::UPLOAD_VERSION)
|
|
{
|
|
return Err(CreateError::CustomAuthenticationError(
|
|
"You don't have permission to upload this version!"
|
|
.to_string(),
|
|
));
|
|
}
|
|
|
|
let version_id: VersionId =
|
|
models::generate_version_id(transaction).await?.into();
|
|
|
|
let project_type = sqlx::query!(
|
|
"
|
|
SELECT name FROM project_types pt
|
|
INNER JOIN mods ON mods.project_type = pt.id
|
|
WHERE mods.id = $1
|
|
",
|
|
project_id as models::ProjectId,
|
|
)
|
|
.fetch_one(&mut *transaction)
|
|
.await?
|
|
.name;
|
|
|
|
let game_versions = version_create_data
|
|
.game_versions
|
|
.iter()
|
|
.map(|x| {
|
|
all_game_versions
|
|
.iter()
|
|
.find(|y| y.version == x.0)
|
|
.ok_or_else(|| {
|
|
CreateError::InvalidGameVersion(x.0.clone())
|
|
})
|
|
.map(|y| y.id)
|
|
})
|
|
.collect::<Result<Vec<models::GameVersionId>, CreateError>>()?;
|
|
|
|
let loaders = version_create_data
|
|
.loaders
|
|
.iter()
|
|
.map(|x| {
|
|
all_loaders
|
|
.iter()
|
|
.find(|y| {
|
|
y.loader == x.0
|
|
&& y.supported_project_types
|
|
.contains(&project_type)
|
|
})
|
|
.ok_or_else(|| CreateError::InvalidLoader(x.0.clone()))
|
|
.map(|y| y.id)
|
|
})
|
|
.collect::<Result<Vec<models::LoaderId>, CreateError>>()?;
|
|
|
|
let dependencies = version_create_data
|
|
.dependencies
|
|
.iter()
|
|
.map(|d| models::version_item::DependencyBuilder {
|
|
version_id: d.version_id.map(|x| x.into()),
|
|
project_id: d.project_id.map(|x| x.into()),
|
|
dependency_type: d.dependency_type.to_string(),
|
|
file_name: None,
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
version_builder = Some(VersionBuilder {
|
|
version_id: version_id.into(),
|
|
project_id,
|
|
author_id: user.id.into(),
|
|
name: version_create_data.version_title.clone(),
|
|
version_number: version_create_data.version_number.clone(),
|
|
changelog: version_create_data
|
|
.version_body
|
|
.clone()
|
|
.unwrap_or_else(|| "".to_string()),
|
|
files: Vec::new(),
|
|
dependencies,
|
|
game_versions,
|
|
loaders,
|
|
version_type: version_create_data.release_channel.to_string(),
|
|
featured: version_create_data.featured,
|
|
});
|
|
|
|
continue;
|
|
}
|
|
|
|
let version = version_builder.as_mut().ok_or_else(|| {
|
|
CreateError::InvalidInput(String::from(
|
|
"`data` field must come before file fields",
|
|
))
|
|
})?;
|
|
|
|
let project_type = sqlx::query!(
|
|
"
|
|
SELECT name FROM project_types pt
|
|
INNER JOIN mods ON mods.project_type = pt.id
|
|
WHERE mods.id = $1
|
|
",
|
|
version.project_id as models::ProjectId,
|
|
)
|
|
.fetch_one(&mut *transaction)
|
|
.await?
|
|
.name;
|
|
|
|
let version_data = initial_version_data.clone().ok_or_else(|| {
|
|
CreateError::InvalidInput("`data` field is required".to_string())
|
|
})?;
|
|
|
|
upload_file(
|
|
&mut field,
|
|
file_host,
|
|
uploaded_files,
|
|
&mut version.files,
|
|
&mut version.dependencies,
|
|
&cdn_url,
|
|
&content_disposition,
|
|
version.project_id.into(),
|
|
&version.version_number,
|
|
&*project_type,
|
|
version_data.loaders,
|
|
version_data.game_versions,
|
|
all_game_versions.clone(),
|
|
version_data.primary_file.is_some(),
|
|
version_data.primary_file.as_deref() == Some(name),
|
|
transaction,
|
|
)
|
|
.await?;
|
|
}
|
|
|
|
let version_data = initial_version_data.ok_or_else(|| {
|
|
CreateError::InvalidInput("`data` field is required".to_string())
|
|
})?;
|
|
let builder = version_builder.ok_or_else(|| {
|
|
CreateError::InvalidInput("`data` field is required".to_string())
|
|
})?;
|
|
|
|
if builder.files.is_empty() {
|
|
return Err(CreateError::InvalidInput(
|
|
"Versions must have at least one file uploaded to them".to_string(),
|
|
));
|
|
}
|
|
|
|
let result = sqlx::query!(
|
|
"
|
|
SELECT m.title title, pt.name project_type
|
|
FROM mods m
|
|
INNER JOIN project_types pt ON pt.id = m.project_type
|
|
WHERE m.id = $1
|
|
",
|
|
builder.project_id as crate::database::models::ids::ProjectId
|
|
)
|
|
.fetch_one(&mut *transaction)
|
|
.await?;
|
|
|
|
use futures::stream::TryStreamExt;
|
|
|
|
let users = sqlx::query!(
|
|
"
|
|
SELECT follower_id FROM mod_follows
|
|
WHERE mod_id = $1
|
|
",
|
|
builder.project_id as crate::database::models::ids::ProjectId
|
|
)
|
|
.fetch_many(&mut *transaction)
|
|
.try_filter_map(|e| async {
|
|
Ok(e.right().map(|m| models::ids::UserId(m.follower_id)))
|
|
})
|
|
.try_collect::<Vec<models::ids::UserId>>()
|
|
.await?;
|
|
|
|
let project_id: ProjectId = builder.project_id.into();
|
|
let version_id: VersionId = builder.version_id.into();
|
|
|
|
NotificationBuilder {
|
|
notification_type: Some("project_update".to_string()),
|
|
title: format!("**{}** has been updated!", result.title),
|
|
text: format!(
|
|
"The project, {}, has released a new version: {}",
|
|
result.title,
|
|
version_data.version_number.clone()
|
|
),
|
|
link: format!(
|
|
"/{}/{}/version/{}",
|
|
result.project_type, project_id, version_id
|
|
),
|
|
actions: vec![],
|
|
}
|
|
.insert_many(users, &mut *transaction)
|
|
.await?;
|
|
|
|
let response = Version {
|
|
id: builder.version_id.into(),
|
|
project_id: builder.project_id.into(),
|
|
author_id: user.id,
|
|
featured: builder.featured,
|
|
name: builder.name.clone(),
|
|
version_number: builder.version_number.clone(),
|
|
changelog: builder.changelog.clone(),
|
|
changelog_url: None,
|
|
date_published: Utc::now(),
|
|
downloads: 0,
|
|
version_type: version_data.release_channel,
|
|
files: builder
|
|
.files
|
|
.iter()
|
|
.map(|file| VersionFile {
|
|
hashes: file
|
|
.hashes
|
|
.iter()
|
|
.map(|hash| {
|
|
(
|
|
hash.algorithm.clone(),
|
|
// This is a hack since the hashes are currently stored as ASCII
|
|
// in the database, but represented here as a Vec<u8>. At some
|
|
// point we need to change the hash to be the real bytes in the
|
|
// database and add more processing here.
|
|
String::from_utf8(hash.hash.clone()).unwrap(),
|
|
)
|
|
})
|
|
.collect(),
|
|
url: file.url.clone(),
|
|
filename: file.filename.clone(),
|
|
primary: file.primary,
|
|
size: file.size,
|
|
})
|
|
.collect::<Vec<_>>(),
|
|
dependencies: version_data.dependencies,
|
|
game_versions: version_data.game_versions,
|
|
loaders: version_data.loaders,
|
|
};
|
|
|
|
builder.insert(transaction).await?;
|
|
|
|
Ok(HttpResponse::Ok().json(response))
|
|
}
|
|
|
|
// TODO: file deletion, listing, etc
|
|
|
|
// under /api/v1/version/{version_id}
|
|
#[post("{version_id}/file")]
|
|
pub async fn upload_file_to_version(
|
|
req: HttpRequest,
|
|
url_data: actix_web::web::Path<(VersionId,)>,
|
|
payload: Multipart,
|
|
client: Data<PgPool>,
|
|
file_host: Data<std::sync::Arc<dyn FileHost + Send + Sync>>,
|
|
) -> Result<HttpResponse, CreateError> {
|
|
let mut transaction = client.begin().await?;
|
|
let mut uploaded_files = Vec::new();
|
|
|
|
let version_id = models::VersionId::from(url_data.into_inner().0);
|
|
|
|
let result = upload_file_to_version_inner(
|
|
req,
|
|
payload,
|
|
client,
|
|
&mut transaction,
|
|
&***file_host,
|
|
&mut uploaded_files,
|
|
version_id,
|
|
)
|
|
.await;
|
|
|
|
if result.is_err() {
|
|
let undo_result = super::project_creation::undo_uploads(
|
|
&***file_host,
|
|
&uploaded_files,
|
|
)
|
|
.await;
|
|
let rollback_result = transaction.rollback().await;
|
|
|
|
if let Err(e) = undo_result {
|
|
return Err(e);
|
|
}
|
|
if let Err(e) = rollback_result {
|
|
return Err(e.into());
|
|
}
|
|
} else {
|
|
transaction.commit().await?;
|
|
}
|
|
|
|
result
|
|
}
|
|
|
|
async fn upload_file_to_version_inner(
|
|
req: HttpRequest,
|
|
mut payload: Multipart,
|
|
client: Data<PgPool>,
|
|
transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
|
|
file_host: &dyn FileHost,
|
|
uploaded_files: &mut Vec<UploadedFile>,
|
|
version_id: models::VersionId,
|
|
) -> Result<HttpResponse, CreateError> {
|
|
let cdn_url = dotenv::var("CDN_URL")?;
|
|
|
|
let mut initial_file_data: Option<InitialFileData> = None;
|
|
let mut file_builders: Vec<VersionFileBuilder> = Vec::new();
|
|
|
|
let user = get_user_from_headers(req.headers(), &mut *transaction).await?;
|
|
|
|
let result = models::Version::get_full(version_id, &**client).await?;
|
|
|
|
let version = match result {
|
|
Some(v) => v,
|
|
None => {
|
|
return Err(CreateError::InvalidInput(
|
|
"An invalid version id was supplied".to_string(),
|
|
));
|
|
}
|
|
};
|
|
|
|
let team_member = models::TeamMember::get_from_user_id_version(
|
|
version_id,
|
|
user.id.into(),
|
|
&mut *transaction,
|
|
)
|
|
.await?
|
|
.ok_or_else(|| {
|
|
CreateError::CustomAuthenticationError(
|
|
"You don't have permission to upload files to this version!"
|
|
.to_string(),
|
|
)
|
|
})?;
|
|
|
|
if !team_member
|
|
.permissions
|
|
.contains(Permissions::UPLOAD_VERSION)
|
|
{
|
|
return Err(CreateError::CustomAuthenticationError(
|
|
"You don't have permission to upload files to this version!"
|
|
.to_string(),
|
|
));
|
|
}
|
|
|
|
let project_id = ProjectId(version.project_id.0 as u64);
|
|
let version_number = version.version_number;
|
|
|
|
let project_type = sqlx::query!(
|
|
"
|
|
SELECT name FROM project_types pt
|
|
INNER JOIN mods ON mods.project_type = pt.id
|
|
WHERE mods.id = $1
|
|
",
|
|
version.project_id as models::ProjectId,
|
|
)
|
|
.fetch_one(&mut *transaction)
|
|
.await?
|
|
.name;
|
|
|
|
let all_game_versions =
|
|
models::categories::GameVersion::list(&mut *transaction).await?;
|
|
|
|
while let Some(item) = payload.next().await {
|
|
let mut field: Field = item.map_err(CreateError::MultipartError)?;
|
|
let content_disposition = field.content_disposition().clone();
|
|
let name = content_disposition.get_name().ok_or_else(|| {
|
|
CreateError::MissingValueError("Missing content name".to_string())
|
|
})?;
|
|
|
|
if name == "data" {
|
|
let mut data = Vec::new();
|
|
while let Some(chunk) = field.next().await {
|
|
data.extend_from_slice(
|
|
&chunk.map_err(CreateError::MultipartError)?,
|
|
);
|
|
}
|
|
let file_data: InitialFileData = serde_json::from_slice(&data)?;
|
|
// TODO: currently no data here, but still required
|
|
|
|
initial_file_data = Some(file_data);
|
|
continue;
|
|
}
|
|
|
|
let _file_data = initial_file_data.as_ref().ok_or_else(|| {
|
|
CreateError::InvalidInput(String::from(
|
|
"`data` field must come before file fields",
|
|
))
|
|
})?;
|
|
|
|
let mut dependencies = version
|
|
.dependencies
|
|
.iter()
|
|
.map(|x| models::version_item::DependencyBuilder {
|
|
project_id: x.project_id,
|
|
version_id: x.version_id,
|
|
file_name: None,
|
|
dependency_type: x.dependency_type.clone(),
|
|
})
|
|
.collect();
|
|
|
|
upload_file(
|
|
&mut field,
|
|
file_host,
|
|
uploaded_files,
|
|
&mut file_builders,
|
|
&mut dependencies,
|
|
&cdn_url,
|
|
&content_disposition,
|
|
project_id,
|
|
&version_number,
|
|
&*project_type,
|
|
version.loaders.clone().into_iter().map(Loader).collect(),
|
|
version
|
|
.game_versions
|
|
.clone()
|
|
.into_iter()
|
|
.map(GameVersion)
|
|
.collect(),
|
|
all_game_versions.clone(),
|
|
true,
|
|
false,
|
|
transaction,
|
|
)
|
|
.await?;
|
|
}
|
|
|
|
if file_builders.is_empty() {
|
|
return Err(CreateError::InvalidInput(
|
|
"At least one file must be specified".to_string(),
|
|
));
|
|
} else {
|
|
for file_builder in file_builders {
|
|
file_builder.insert(version_id, &mut *transaction).await?;
|
|
}
|
|
}
|
|
|
|
Ok(HttpResponse::NoContent().body(""))
|
|
}
|
|
|
|
// This function is used for adding a file to a version, uploading the initial
|
|
// files for a version, and for uploading the initial version files for a project
|
|
#[allow(clippy::too_many_arguments)]
|
|
pub async fn upload_file(
|
|
field: &mut Field,
|
|
file_host: &dyn FileHost,
|
|
uploaded_files: &mut Vec<UploadedFile>,
|
|
version_files: &mut Vec<VersionFileBuilder>,
|
|
dependencies: &mut Vec<DependencyBuilder>,
|
|
cdn_url: &str,
|
|
content_disposition: &actix_web::http::header::ContentDisposition,
|
|
project_id: ProjectId,
|
|
version_number: &str,
|
|
project_type: &str,
|
|
loaders: Vec<Loader>,
|
|
game_versions: Vec<GameVersion>,
|
|
all_game_versions: Vec<models::categories::GameVersion>,
|
|
ignore_primary: bool,
|
|
force_primary: bool,
|
|
transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
|
|
) -> Result<(), CreateError> {
|
|
let (file_name, file_extension) = get_name_ext(content_disposition)?;
|
|
|
|
let content_type = crate::util::ext::project_file_type(file_extension)
|
|
.ok_or_else(|| {
|
|
CreateError::InvalidFileType(file_extension.to_string())
|
|
})?;
|
|
|
|
let data = read_from_field(
|
|
field, 500 * (1 << 20),
|
|
"Project file exceeds the maximum of 500MiB. Contact a moderator or admin to request permission to upload larger files."
|
|
).await?;
|
|
|
|
let hash = sha1::Sha1::from(&data).hexdigest();
|
|
let exists = sqlx::query!(
|
|
"
|
|
SELECT EXISTS(SELECT 1 FROM hashes h
|
|
WHERE h.algorithm = $2 AND h.hash = $1)
|
|
",
|
|
hash.as_bytes(),
|
|
"sha1"
|
|
)
|
|
.fetch_one(&mut *transaction)
|
|
.await?
|
|
.exists
|
|
.unwrap_or(false);
|
|
|
|
if exists {
|
|
return Err(CreateError::InvalidInput(
|
|
"Duplicate files are not allowed to be uploaded to Modrinth!"
|
|
.to_string(),
|
|
));
|
|
}
|
|
|
|
let validation_result = validate_file(
|
|
data.clone().into(),
|
|
file_extension.to_string(),
|
|
project_type.to_string(),
|
|
loaders,
|
|
game_versions,
|
|
all_game_versions,
|
|
)
|
|
.await?;
|
|
|
|
if let ValidationResult::PassWithPackDataAndFiles {
|
|
ref format,
|
|
ref files,
|
|
} = validation_result
|
|
{
|
|
if dependencies.is_empty() {
|
|
let hashes: Vec<Vec<u8>> = format
|
|
.files
|
|
.iter()
|
|
.filter_map(|x| x.hashes.get(&PackFileHash::Sha1))
|
|
.map(|x| x.as_bytes().to_vec())
|
|
.collect();
|
|
|
|
let res = sqlx::query!(
|
|
"
|
|
SELECT v.id version_id, v.mod_id project_id, h.hash hash FROM hashes h
|
|
INNER JOIN files f on h.file_id = f.id
|
|
INNER JOIN versions v on f.version_id = v.id
|
|
WHERE h.algorithm = 'sha1' AND h.hash = ANY($1)
|
|
",
|
|
&*hashes
|
|
)
|
|
.fetch_all(&mut *transaction).await?;
|
|
|
|
for file in &format.files {
|
|
if let Some(dep) = res.iter().find(|x| {
|
|
Some(&*x.hash)
|
|
== file
|
|
.hashes
|
|
.get(&PackFileHash::Sha1)
|
|
.map(|x| x.as_bytes())
|
|
}) {
|
|
dependencies.push(DependencyBuilder {
|
|
project_id: Some(models::ProjectId(dep.project_id)),
|
|
version_id: Some(models::VersionId(dep.version_id)),
|
|
file_name: None,
|
|
dependency_type: DependencyType::Embedded.to_string(),
|
|
});
|
|
} else if let Some(first_download) = file.downloads.first() {
|
|
dependencies.push(DependencyBuilder {
|
|
project_id: None,
|
|
version_id: None,
|
|
file_name: Some(
|
|
first_download
|
|
.rsplit('/')
|
|
.next()
|
|
.unwrap_or(first_download)
|
|
.to_string(),
|
|
),
|
|
dependency_type: DependencyType::Embedded.to_string(),
|
|
});
|
|
}
|
|
}
|
|
|
|
for file in files {
|
|
if !file.is_empty() {
|
|
dependencies.push(DependencyBuilder {
|
|
project_id: None,
|
|
version_id: None,
|
|
file_name: Some(file.to_string()),
|
|
dependency_type: DependencyType::Embedded.to_string(),
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
let file_path_encode = format!(
|
|
"data/{}/versions/{}/{}",
|
|
project_id,
|
|
version_number,
|
|
urlencoding::encode(file_name)
|
|
);
|
|
let file_path = format!(
|
|
"data/{}/versions/{}/{}",
|
|
project_id, version_number, &file_name
|
|
);
|
|
|
|
let upload_data = file_host
|
|
.upload_file(content_type, &file_path, data.freeze())
|
|
.await?;
|
|
|
|
uploaded_files.push(UploadedFile {
|
|
file_id: upload_data.file_id,
|
|
file_name: file_path,
|
|
});
|
|
|
|
let sha1_bytes = upload_data.content_sha1.into_bytes();
|
|
let sha512_bytes = upload_data.content_sha512.into_bytes();
|
|
|
|
if version_files.iter().any(|x| {
|
|
x.hashes
|
|
.iter()
|
|
.any(|y| y.hash == sha1_bytes || y.hash == sha512_bytes)
|
|
}) {
|
|
return Err(CreateError::InvalidInput(
|
|
"Duplicate files are not allowed to be uploaded to Modrinth!"
|
|
.to_string(),
|
|
));
|
|
}
|
|
|
|
version_files.push(models::version_item::VersionFileBuilder {
|
|
filename: file_name.to_string(),
|
|
url: format!("{}/{}", cdn_url, file_path_encode),
|
|
hashes: vec![
|
|
models::version_item::HashBuilder {
|
|
algorithm: "sha1".to_string(),
|
|
// This is an invalid cast - the database expects the hash's
|
|
// bytes, but this is the string version.
|
|
hash: sha1_bytes,
|
|
},
|
|
models::version_item::HashBuilder {
|
|
algorithm: "sha512".to_string(),
|
|
// This is an invalid cast - the database expects the hash's
|
|
// bytes, but this is the string version.
|
|
hash: sha512_bytes,
|
|
},
|
|
],
|
|
primary: (validation_result.is_passed()
|
|
&& version_files.iter().all(|x| !x.primary)
|
|
&& !ignore_primary)
|
|
|| force_primary,
|
|
size: upload_data.content_length,
|
|
});
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn get_name_ext(
|
|
content_disposition: &actix_web::http::header::ContentDisposition,
|
|
) -> Result<(&str, &str), CreateError> {
|
|
let file_name = content_disposition.get_filename().ok_or_else(|| {
|
|
CreateError::MissingValueError("Missing content file name".to_string())
|
|
})?;
|
|
let file_extension = if let Some(last_period) = file_name.rfind('.') {
|
|
file_name.get((last_period + 1)..).unwrap_or("")
|
|
} else {
|
|
return Err(CreateError::MissingValueError(
|
|
"Missing content file extension".to_string(),
|
|
));
|
|
};
|
|
Ok((file_name, file_extension))
|
|
}
|