forked from didirus/AstralRinth
c37bf75853
* Implement replied/unreplied filter for tech review * project status filter * wip: issue type filter * correct filter field * wip: break up tech review query * Improve tech review query * Get tech review working more properly * Add get single project reports endpoint
294 lines
12 KiB
Rust
294 lines
12 KiB
Rust
use crate::database::models::DelphiReportIssueDetailsId;
|
|
use crate::file_hosting::FileHostingError;
|
|
use crate::routes::analytics::{page_view_ingest, playtime_ingest};
|
|
use crate::util::cors::default_cors;
|
|
use crate::util::env::parse_strings_from_var;
|
|
use actix_cors::Cors;
|
|
use actix_files::Files;
|
|
use actix_web::http::StatusCode;
|
|
use actix_web::{HttpResponse, web};
|
|
use futures::FutureExt;
|
|
use serde_json::json;
|
|
|
|
pub mod internal;
|
|
pub mod v2;
|
|
pub mod v3;
|
|
|
|
#[cfg(target_os = "linux")]
|
|
pub mod debug;
|
|
|
|
pub mod v2_reroute;
|
|
|
|
mod analytics;
|
|
mod index;
|
|
mod maven;
|
|
mod not_found;
|
|
mod updates;
|
|
|
|
pub use self::not_found::not_found;
|
|
|
|
pub fn root_config(cfg: &mut web::ServiceConfig) {
|
|
cfg.service(
|
|
web::scope("maven")
|
|
.wrap(default_cors())
|
|
.configure(maven::config),
|
|
);
|
|
cfg.service(
|
|
web::scope("updates")
|
|
.wrap(default_cors())
|
|
.configure(updates::config),
|
|
);
|
|
cfg.service(
|
|
web::scope("analytics")
|
|
.wrap(
|
|
Cors::default()
|
|
.allowed_origin_fn(|origin, _req_head| {
|
|
let allowed_origins =
|
|
parse_strings_from_var("ANALYTICS_ALLOWED_ORIGINS")
|
|
.unwrap_or_default();
|
|
|
|
allowed_origins.contains(&"*".to_string())
|
|
|| allowed_origins.contains(
|
|
&origin
|
|
.to_str()
|
|
.unwrap_or_default()
|
|
.to_string(),
|
|
)
|
|
})
|
|
.allowed_methods(vec!["GET", "POST"])
|
|
.allowed_headers(vec![
|
|
actix_web::http::header::AUTHORIZATION,
|
|
actix_web::http::header::ACCEPT,
|
|
actix_web::http::header::CONTENT_TYPE,
|
|
])
|
|
.max_age(3600),
|
|
)
|
|
.service(page_view_ingest)
|
|
.service(playtime_ingest),
|
|
);
|
|
cfg.service(
|
|
web::scope("api/v1")
|
|
.wrap(default_cors())
|
|
.wrap_fn(|req, _srv| {
|
|
async {
|
|
Ok(req.into_response(
|
|
HttpResponse::Gone()
|
|
.content_type("application/json")
|
|
.body(r#"{"error":"api_deprecated","description":"You are using an application that uses an outdated version of Modrinth's API. Please either update it or switch to another application. For developers: https://docs.modrinth.com/api/#versioning"}"#)
|
|
))
|
|
}.boxed_local()
|
|
})
|
|
);
|
|
cfg.service(
|
|
web::scope("")
|
|
.wrap(default_cors())
|
|
.service(index::index_get)
|
|
.service(Files::new("/", "assets/")),
|
|
);
|
|
}
|
|
|
|
/// Error when calling an HTTP endpoint.
|
|
#[derive(thiserror::Error, Debug)]
|
|
pub enum ApiError {
|
|
/// Error occurred on the server side, which the caller has no fault in.
|
|
#[error(transparent)]
|
|
Internal(eyre::Report),
|
|
/// Caller made an invalid or malformed request.
|
|
#[error(transparent)]
|
|
Request(eyre::Report),
|
|
/// Caller attempted a request which they are not allowed to make.
|
|
#[error(transparent)]
|
|
Auth(eyre::Report),
|
|
#[error("Invalid input: {0}")]
|
|
InvalidInput(String),
|
|
#[error("Environment error")]
|
|
Env(#[from] dotenvy::Error),
|
|
#[error("Error while uploading file: {0}")]
|
|
FileHosting(#[from] FileHostingError),
|
|
#[error("Database error: {0}")]
|
|
Database(#[from] crate::database::models::DatabaseError),
|
|
#[error("SQLx database error: {0}")]
|
|
SqlxDatabase(#[from] sqlx::Error),
|
|
#[error("Redis database error: {0}")]
|
|
RedisDatabase(#[from] redis::RedisError),
|
|
#[error("Clickhouse error: {0}")]
|
|
Clickhouse(#[from] clickhouse::error::Error),
|
|
#[error("XML error: {0}")]
|
|
Xml(String),
|
|
#[error("Deserialization error: {0}")]
|
|
Json(#[from] serde_json::Error),
|
|
#[error("Authentication error: {0}")]
|
|
Authentication(#[from] crate::auth::AuthenticationError),
|
|
#[error("Authentication error: {0}")]
|
|
CustomAuthentication(String),
|
|
#[error("Error while validating input: {0}")]
|
|
Validation(String),
|
|
#[error("Search error: {0}")]
|
|
Search(#[from] meilisearch_sdk::errors::Error),
|
|
#[error("Indexing error: {0}")]
|
|
Indexing(#[from] crate::search::indexing::IndexingError),
|
|
#[error("Payments error: {0}")]
|
|
Payments(String),
|
|
#[error("Discord error: {0}")]
|
|
Discord(String),
|
|
#[error("Slack webhook error: {0}")]
|
|
Slack(String),
|
|
#[error("Captcha error. Try resubmitting the form.")]
|
|
Turnstile,
|
|
#[error("Error while decoding Base62: {0}")]
|
|
Decoding(#[from] ariadne::ids::DecodingError),
|
|
#[error("Image parsing error: {0}")]
|
|
ImageParse(#[from] image::ImageError),
|
|
#[error("Password hashing error: {0}")]
|
|
PasswordHashing(#[from] argon2::password_hash::Error),
|
|
#[error("{0}")]
|
|
Mail(#[from] crate::queue::email::MailError),
|
|
#[error("Error while rerouting request: {0:?}")]
|
|
Reroute(#[from] reqwest::Error),
|
|
#[error("Unable to read zip archive: {0}")]
|
|
Zip(#[from] zip::result::ZipError),
|
|
#[error("IO Error: {0}")]
|
|
Io(#[from] std::io::Error),
|
|
#[error("Resource not found")]
|
|
NotFound,
|
|
#[error("Conflict: {0}")]
|
|
Conflict(String),
|
|
#[error("External tax compliance API error")]
|
|
TaxComplianceApi,
|
|
#[error(transparent)]
|
|
TaxProcessor(#[from] crate::util::anrok::AnrokError),
|
|
#[error(
|
|
"You are being rate-limited. Please wait {0} milliseconds. 0/{1} remaining."
|
|
)]
|
|
RateLimitError(u128, u32),
|
|
#[error("Error while interacting with payment processor: {0}")]
|
|
Stripe(#[from] stripe::StripeError),
|
|
#[error("Error while interacting with Delphi: {0:?}")]
|
|
Delphi(eyre::Error),
|
|
#[error(transparent)]
|
|
Mural(#[from] Box<muralpay::ApiError>),
|
|
#[error("report still has {} issue details with no verdict", details.len())]
|
|
TechReviewDetailsWithNoVerdict {
|
|
details: Vec<DelphiReportIssueDetailsId>,
|
|
},
|
|
}
|
|
|
|
impl ApiError {
|
|
pub fn delphi(err: impl Into<eyre::Error>) -> Self {
|
|
Self::Delphi(err.into())
|
|
}
|
|
|
|
pub fn as_api_error<'a>(&self) -> crate::models::error::ApiError<'a> {
|
|
crate::models::error::ApiError {
|
|
error: match self {
|
|
Self::Internal(..) => "internal_error",
|
|
Self::Request(..) => "request_error",
|
|
Self::Auth(..) => "auth_error",
|
|
Self::Env(..) => "environment_error",
|
|
Self::Database(..) => "database_error",
|
|
Self::SqlxDatabase(..) => "database_error",
|
|
Self::RedisDatabase(..) => "database_error",
|
|
Self::Authentication(..) => "unauthorized",
|
|
Self::CustomAuthentication(..) => "unauthorized",
|
|
Self::Xml(..) => "xml_error",
|
|
Self::Json(..) => "json_error",
|
|
Self::Search(..) => "search_error",
|
|
Self::Indexing(..) => "indexing_error",
|
|
Self::FileHosting(..) => "file_hosting_error",
|
|
Self::InvalidInput(..) => "invalid_input",
|
|
Self::Validation(..) => "invalid_input",
|
|
Self::Payments(..) => "payments_error",
|
|
Self::Discord(..) => "discord_error",
|
|
Self::Turnstile => "turnstile_error",
|
|
Self::Decoding(..) => "decoding_error",
|
|
Self::ImageParse(..) => "invalid_image",
|
|
Self::PasswordHashing(..) => "password_hashing_error",
|
|
Self::Mail(..) => "mail_error",
|
|
Self::Clickhouse(..) => "clickhouse_error",
|
|
Self::Reroute(..) => "reroute_error",
|
|
Self::NotFound => "not_found",
|
|
Self::Conflict(..) => "conflict",
|
|
Self::TaxComplianceApi => "tax_compliance_api_error",
|
|
Self::Zip(..) => "zip_error",
|
|
Self::Io(..) => "io_error",
|
|
Self::RateLimitError(..) => "ratelimit_error",
|
|
Self::Stripe(..) => "stripe_error",
|
|
Self::TaxProcessor(..) => "tax_processor_error",
|
|
Self::Slack(..) => "slack_error",
|
|
Self::Delphi(..) => "delphi_error",
|
|
Self::Mural(..) => "mural_error",
|
|
Self::TechReviewDetailsWithNoVerdict { .. } => {
|
|
"tech_review_issues_with_no_verdict"
|
|
}
|
|
},
|
|
description: match self {
|
|
Self::Internal(e) => format!("{e:#?}"),
|
|
Self::Request(e) => format!("{e:#?}"),
|
|
Self::Auth(e) => format!("{e:#?}"),
|
|
_ => self.to_string(),
|
|
},
|
|
details: match self {
|
|
Self::Mural(err) => serde_json::to_value(err.clone()).ok(),
|
|
Self::TechReviewDetailsWithNoVerdict { details } => {
|
|
let details = serde_json::to_value(details)
|
|
.expect("details should never fail to serialize");
|
|
Some(json!({
|
|
"issue_details": details
|
|
}))
|
|
}
|
|
_ => None,
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
impl actix_web::ResponseError for ApiError {
|
|
fn status_code(&self) -> StatusCode {
|
|
match self {
|
|
Self::Internal(..) => StatusCode::INTERNAL_SERVER_ERROR,
|
|
Self::Request(..) => StatusCode::BAD_REQUEST,
|
|
Self::Auth(..) => StatusCode::UNAUTHORIZED,
|
|
Self::InvalidInput(..) => StatusCode::BAD_REQUEST,
|
|
Self::Env(..) => StatusCode::INTERNAL_SERVER_ERROR,
|
|
Self::Database(..) => StatusCode::INTERNAL_SERVER_ERROR,
|
|
Self::SqlxDatabase(..) => StatusCode::INTERNAL_SERVER_ERROR,
|
|
Self::RedisDatabase(..) => StatusCode::INTERNAL_SERVER_ERROR,
|
|
Self::Clickhouse(..) => StatusCode::INTERNAL_SERVER_ERROR,
|
|
Self::Authentication(..) => StatusCode::UNAUTHORIZED,
|
|
Self::CustomAuthentication(..) => StatusCode::UNAUTHORIZED,
|
|
Self::Xml(..) => StatusCode::INTERNAL_SERVER_ERROR,
|
|
Self::Json(..) => StatusCode::BAD_REQUEST,
|
|
Self::Search(..) => StatusCode::INTERNAL_SERVER_ERROR,
|
|
Self::Indexing(..) => StatusCode::INTERNAL_SERVER_ERROR,
|
|
Self::FileHosting(..) => StatusCode::INTERNAL_SERVER_ERROR,
|
|
Self::Validation(..) => StatusCode::BAD_REQUEST,
|
|
Self::Payments(..) => StatusCode::FAILED_DEPENDENCY,
|
|
Self::Discord(..) => StatusCode::FAILED_DEPENDENCY,
|
|
Self::Turnstile => StatusCode::BAD_REQUEST,
|
|
Self::Decoding(..) => StatusCode::BAD_REQUEST,
|
|
Self::ImageParse(..) => StatusCode::BAD_REQUEST,
|
|
Self::PasswordHashing(..) => StatusCode::INTERNAL_SERVER_ERROR,
|
|
Self::Mail(..) => StatusCode::INTERNAL_SERVER_ERROR,
|
|
Self::Reroute(..) => StatusCode::INTERNAL_SERVER_ERROR,
|
|
Self::NotFound => StatusCode::NOT_FOUND,
|
|
Self::Conflict(..) => StatusCode::CONFLICT,
|
|
Self::TaxComplianceApi => StatusCode::INTERNAL_SERVER_ERROR,
|
|
Self::Zip(..) => StatusCode::BAD_REQUEST,
|
|
Self::Io(..) => StatusCode::BAD_REQUEST,
|
|
Self::RateLimitError(..) => StatusCode::TOO_MANY_REQUESTS,
|
|
Self::Stripe(..) => StatusCode::FAILED_DEPENDENCY,
|
|
Self::TaxProcessor(..) => StatusCode::INTERNAL_SERVER_ERROR,
|
|
Self::Slack(..) => StatusCode::INTERNAL_SERVER_ERROR,
|
|
Self::Delphi(..) => StatusCode::INTERNAL_SERVER_ERROR,
|
|
Self::Mural(..) => StatusCode::BAD_REQUEST,
|
|
Self::TechReviewDetailsWithNoVerdict { .. } => {
|
|
StatusCode::BAD_REQUEST
|
|
}
|
|
}
|
|
}
|
|
|
|
fn error_response(&self) -> HttpResponse {
|
|
HttpResponse::build(self.status_code()).json(self.as_api_error())
|
|
}
|
|
}
|