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

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

* Run prepare

src/routes/v1/mod.rs

@@ -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)

src/routes/v1/tags.rs

@@ -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))
+    }
+}

src/routes/v1/teams.rs

@@ -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))
+}

src/routes/v1/users.rs

@@ -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(""))
+    }
+}