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

Improve peformance of search indexing, v2 fixes + new routes (#205)

Browse Source 
* Refactor search to not spam the database with queries, new utility routes for V2

* Run prepare
This commit is contained in:
Geometrically
2021-06-02 18:33:11 -07:00
committed by GitHub
parent 16db28060c
commit 157962e42a
18 changed files with 833 additions and 763 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/routes/mod.rs
View File

@@ -54,6 +54,7 @@ pub fn projects_config(cfg: &mut web::ServiceConfig) {
.service(projects::project_icon_edit)
.service(projects::project_follow)
.service(projects::project_unfollow)
.service(teams::team_members_get_project)
.service(web::scope("{project_id}").service(versions::version_list)),
);
}

9
src/routes/tags.rs
View File

@@ -41,7 +41,7 @@ pub struct CategoryData {
// searching category list
#[get("category")]
pub async fn category_list(pool: web::Data<PgPool>) -> Result<HttpResponse, ApiError> {
let results = Category::list(&**pool)
let mut results = Category::list(&**pool)
.await?
.into_iter()
.map(|x| CategoryData {
@@ -51,6 +51,8 @@ pub async fn category_list(pool: web::Data<PgPool>) -> Result<HttpResponse, ApiE
})
.collect::<Vec<_>>();
results.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
Ok(HttpResponse::Ok().json(results))
}
@@ -115,7 +117,7 @@ pub struct LoaderData {
#[get("loader")]
pub async fn loader_list(pool: web::Data<PgPool>) -> Result<HttpResponse, ApiError> {
let results = Loader::list(&**pool)
let mut results = Loader::list(&**pool)
.await?
.into_iter()
.map(|x| LoaderData {
@@ -124,6 +126,9 @@ pub async fn loader_list(pool: web::Data<PgPool>) -> Result<HttpResponse, ApiErr
supported_project_types: x.supported_project_types,
})
.collect::<Vec<_>>();
results.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
Ok(HttpResponse::Ok().json(results))
}

89
src/routes/teams.rs
View File

@@ -1,5 +1,6 @@
use crate::auth::get_user_from_headers;
use crate::database::models::notification_item::{NotificationActionBuilder, NotificationBuilder};
use crate::database::models::team_item::QueryTeamMember;
use crate::database::models::TeamMember;
use crate::models::ids::ProjectId;
use crate::models::teams::{Permissions, TeamId};
@@ -9,6 +10,66 @@ use actix_web::{delete, get, patch, post, web, HttpRequest, HttpResponse};
use serde::{Deserialize, Serialize};
use sqlx::PgPool;
#[get("{id}/members")]
pub async fn team_members_get_project(
req: HttpRequest,
info: web::Path<(String,)>,
pool: web::Data<PgPool>,
) -> Result<HttpResponse, ApiError> {
let string = info.into_inner().0;
let project_data =
crate::database::models::Project::get_from_slug_or_project_id(string, &**pool).await?;
if let Some(project) = project_data {
let members_data = TeamMember::get_from_team_full(project.team_id, &**pool).await?;
let current_user = get_user_from_headers(req.headers(), &**pool).await.ok();
if let Some(user) = current_user {
let team_member =
TeamMember::get_from_user_id(project.team_id, user.id.into(), &**pool)
.await
.map_err(ApiError::DatabaseError)?;
if team_member.is_some() {
let team_members: Vec<crate::models::teams::TeamMember> = members_data
.into_iter()
.map(|data| convert_team_member(data, false))
.collect();
return Ok(HttpResponse::Ok().json(team_members));
}
}
let team_members: Vec<crate::models::teams::TeamMember> = members_data
.into_iter()
.filter(|x| x.accepted)
.map(|data| convert_team_member(data, true))
.collect();
Ok(HttpResponse::Ok().json(team_members))
} else {
Ok(HttpResponse::NotFound().body(""))
}
}
pub fn convert_team_member(
data: QueryTeamMember,
override_permissions: bool,
) -> crate::models::teams::TeamMember {
crate::models::teams::TeamMember {
team_id: data.team_id.into(),
user: super::users::convert_user(data.user),
role: data.role,
permissions: if override_permissions {
None
} else {
Some(data.permissions)
},
accepted: data.accepted,
}
}
#[get("{id}/members")]
pub async fn team_members_get(
req: HttpRequest,
@@ -16,7 +77,7 @@ pub async fn team_members_get(
pool: web::Data<PgPool>,
) -> Result<HttpResponse, ApiError> {
let id = info.into_inner().0;
let members_data = TeamMember::get_from_team(id.into(), &**pool).await?;
let members_data = TeamMember::get_from_team_full(id.into(), &**pool).await?;
let current_user = get_user_from_headers(req.headers(), &**pool).await.ok();
@@ -28,32 +89,18 @@ pub async fn team_members_get(
if team_member.is_some() {
let team_members: Vec<crate::models::teams::TeamMember> = members_data
.into_iter()
.map(|data| crate::models::teams::TeamMember {
team_id: id,
user_id: data.user_id.into(),
role: data.role,
permissions: Some(data.permissions),
accepted: data.accepted,
})
.map(|data| convert_team_member(data, false))
.collect();
return Ok(HttpResponse::Ok().json(team_members));
}
}
let mut team_members: Vec<crate::models::teams::TeamMember> = Vec::new();
for team_member in members_data {
if team_member.accepted {
team_members.push(crate::models::teams::TeamMember {
team_id: id,
user_id: team_member.user_id.into(),
role: team_member.role,
permissions: None,
accepted: team_member.accepted,
})
}
}
let team_members: Vec<crate::models::teams::TeamMember> = members_data
.into_iter()
.filter(|x| x.accepted)
.map(|data| convert_team_member(data, true))
.collect();
Ok(HttpResponse::Ok().json(team_members))
}

27
src/routes/users.rs
View File

@@ -1,9 +1,8 @@
use crate::auth::get_user_from_headers;
use crate::database::models::User;
use crate::file_hosting::FileHost;
use crate::models::ids::ProjectId;
use crate::models::notifications::Notification;
use crate::models::projects::ProjectStatus;
use crate::models::projects::{Project, ProjectStatus};
use crate::models::users::{Role, UserId};
use crate::routes::notifications::convert_notification;
use crate::routes::ApiError;
@@ -75,7 +74,7 @@ pub async fn user_get(
}
}
fn convert_user(data: crate::database::models::user_item::User) -> crate::models::users::User {
pub fn convert_user(data: crate::database::models::user_item::User) -> crate::models::users::User {
crate::models::users::User {
id: data.id.into(),
github_id: data.github_id.map(|i| i as u64),
@@ -114,10 +113,11 @@ pub async fn projects_list(
User::get_projects(id, ProjectStatus::Approved.as_str(), &**pool).await?
};
let response = project_data
let response = crate::database::Project::get_many_full(project_data, &**pool)
.await?
.into_iter()
.map(|v| v.into())
.collect::<Vec<crate::models::ids::ProjectId>>();
.map(super::projects::convert_project)
.collect::<Vec<Project>>();
Ok(HttpResponse::Ok().json(response))
} else {
@@ -433,7 +433,7 @@ pub async fn user_follows(
use futures::TryStreamExt;
let projects: Vec<ProjectId> = sqlx::query!(
let project_ids = sqlx::query!(
"
SELECT mf.mod_id FROM mod_follows mf
WHERE mf.follower_id = $1
@@ -441,10 +441,19 @@ pub async fn user_follows(
id as crate::database::models::ids::UserId,
)
.fetch_many(&**pool)
.try_filter_map(|e| async { Ok(e.right().map(|m| ProjectId(m.mod_id as u64))) })
.try_collect::<Vec<ProjectId>>()
.try_filter_map(|e| async {
Ok(e.right()
.map(|m| crate::database::models::ProjectId(m.mod_id)))
})
.try_collect::<Vec<crate::database::models::ProjectId>>()
.await?;
let projects = crate::database::Project::get_many_full(project_ids, &**pool)
.await?
.into_iter()
.map(super::projects::convert_project)
.collect::<Vec<Project>>();
Ok(HttpResponse::Ok().json(projects))
} else {
Ok(HttpResponse::NotFound().body(""))

7
src/routes/v1/mod.rs
View File

@@ -4,6 +4,7 @@ mod moderation;
mod mods;
mod reports;
mod tags;
mod teams;
mod users;
mod versions;
@@ -31,7 +32,7 @@ pub fn tags_config(cfg: &mut web::ServiceConfig) {
.service(tags::loader_list)
.service(tags::loader_create)
.service(super::tags::loader_delete)
.service(super::tags::game_version_list)
.service(tags::game_version_list)
.service(super::tags::game_version_create)
.service(super::tags::game_version_delete)
.service(super::tags::license_create)
@@ -93,14 +94,14 @@ pub fn users_config(cfg: &mut web::ServiceConfig) {
.service(super::users::user_edit)
.service(super::users::user_icon_edit)
.service(super::users::user_notifications)
.service(super::users::user_follows),
.service(users::user_follows),
);
}
pub fn teams_config(cfg: &mut web::ServiceConfig) {
cfg.service(
web::scope("team")
.service(super::teams::team_members_get)
.service(teams::team_members_get)
.service(super::teams::edit_team_member)
.service(super::teams::add_team_member)
.service(super::teams::join_team)

31
src/routes/v1/tags.rs
View File

@@ -1,5 +1,5 @@
use crate::auth::check_is_admin_from_headers;
use crate::database::models::categories::{Category, Loader, ProjectType};
use crate::database::models::categories::{Category, GameVersion, Loader, ProjectType};
use crate::routes::ApiError;
use actix_web::{get, put, web};
use actix_web::{HttpRequest, HttpResponse};
@@ -79,3 +79,32 @@ pub async fn loader_create(
Ok(HttpResponse::NoContent().body(""))
}
#[derive(serde::Deserialize)]
pub struct GameVersionQueryData {
#[serde(rename = "type")]
type_: Option<String>,
major: Option<bool>,
}
#[get("game_version")]
pub async fn game_version_list(
pool: web::Data<PgPool>,
query: web::Query<GameVersionQueryData>,
) -> Result<HttpResponse, ApiError> {
if query.type_.is_some() || query.major.is_some() {
let results = GameVersion::list_filter(query.type_.as_deref(), query.major, &**pool)
.await?
.into_iter()
.map(|x| x.version)
.collect::<Vec<String>>();
Ok(HttpResponse::Ok().json(results))
} else {
let results = GameVersion::list(&**pool)
.await?
.into_iter()
.map(|x| x.version)
.collect::<Vec<String>>();
Ok(HttpResponse::Ok().json(results))
}
}

76
src/routes/v1/teams.rs Normal file
View File

@@ -0,0 +1,76 @@
use crate::auth::get_user_from_headers;
use crate::models::teams::{Permissions, TeamId};
use crate::models::users::UserId;
use crate::routes::ApiError;
use actix_web::{get, web, HttpRequest, HttpResponse};
use serde::{Deserialize, Serialize};
use sqlx::PgPool;
/// A member of a team
#[derive(Serialize, Deserialize, Clone)]
pub struct TeamMember {
/// The ID of the team this team member is a member of
pub team_id: TeamId,
/// The ID of the user associated with the member
pub user_id: UserId,
/// The role of the user in the team
pub role: String,
/// A bitset containing the user's permissions in this team
pub permissions: Option<Permissions>,
/// Whether the user has joined the team or is just invited to it
pub accepted: bool,
}
#[get("{id}/members")]
pub async fn team_members_get(
req: HttpRequest,
info: web::Path<(TeamId,)>,
pool: web::Data<PgPool>,
) -> Result<HttpResponse, ApiError> {
let id = info.into_inner().0;
let members_data =
crate::database::models::TeamMember::get_from_team(id.into(), &**pool).await?;
let current_user = get_user_from_headers(req.headers(), &**pool).await.ok();
if let Some(user) = current_user {
let team_member = crate::database::models::TeamMember::get_from_user_id(
id.into(),
user.id.into(),
&**pool,
)
.await
.map_err(ApiError::DatabaseError)?;
if team_member.is_some() {
let team_members: Vec<TeamMember> = members_data
.into_iter()
.map(|data| TeamMember {
team_id: id,
user_id: data.user_id.into(),
role: data.role,
permissions: Some(data.permissions),
accepted: data.accepted,
})
.collect();
return Ok(HttpResponse::Ok().json(team_members));
}
}
let mut team_members: Vec<TeamMember> = Vec::new();
for team_member in members_data {
if team_member.accepted {
team_members.push(TeamMember {
team_id: id,
user_id: team_member.user_id.into(),
role: team_member.role,
permissions: None,
accepted: team_member.accepted,
})
}
}
Ok(HttpResponse::Ok().json(team_members))
}

40
src/routes/v1/users.rs
View File

@@ -1,7 +1,7 @@
use crate::auth::get_user_from_headers;
use crate::database::models::User;
use crate::models::ids::UserId;
use crate::models::projects::ProjectStatus;
use crate::models::projects::{ProjectId, ProjectStatus};
use crate::routes::ApiError;
use actix_web::web;
use actix_web::{get, HttpRequest, HttpResponse};
@@ -42,3 +42,41 @@ pub async fn mods_list(
Ok(HttpResponse::NotFound().body(""))
}
}
#[get("{id}/follows")]
pub async fn user_follows(
req: HttpRequest,
info: web::Path<(String,)>,
pool: web::Data<PgPool>,
) -> Result<HttpResponse, ApiError> {
let user = get_user_from_headers(req.headers(), &**pool).await?;
let id_option =
crate::database::models::User::get_id_from_username_or_id(info.into_inner().0, &**pool)
.await?;
if let Some(id) = id_option {
if !user.role.is_mod() && user.id != id.into() {
return Err(ApiError::CustomAuthenticationError(
"You do not have permission to see the projects this user follows!".to_string(),
));
}
use futures::TryStreamExt;
let projects: Vec<ProjectId> = sqlx::query!(
"
SELECT mf.mod_id FROM mod_follows mf
WHERE mf.follower_id = $1
",
id as crate::database::models::ids::UserId,
)
.fetch_many(&**pool)
.try_filter_map(|e| async { Ok(e.right().map(|m| ProjectId(m.mod_id as u64))) })
.try_collect::<Vec<ProjectId>>()
.await?;
Ok(HttpResponse::Ok().json(projects))
} else {
Ok(HttpResponse::NotFound().body(""))
}
}