Adds /teams route (#373)

* basic list (no grouping yet)

* now groups and checks auth, moved Team::get_many to TeamMember::get_from_team_full_many

* Ran 'cargo sqlx prepare'

* batch TeamMember::get_from_user_id

* Batches before for loop

* Ran 'cargo sqlx prepare'

Co-authored-by: Emma Cypress <emmaffle@modrinth.com>
Co-authored-by: Geometrically <18202329+Geometrically@users.noreply.github.com>

src/database/models/team_item.rs

@@ -202,6 +202,71 @@ impl TeamMember {
         Ok(team_members)
     }
 
+    pub async fn get_from_team_full_many<'a, E>(
+        team_ids: Vec<TeamId>,
+        exec: E,
+    ) -> Result<Vec<QueryTeamMember>, super::DatabaseError>
+    where
+        E: sqlx::Executor<'a, Database = sqlx::Postgres> + Copy,
+    {
+        use futures::stream::TryStreamExt;
+
+        let team_ids_parsed: Vec<i64> =
+            team_ids.into_iter().map(|x| x.0).collect();
+
+        let teams = sqlx::query!(
+            "
+            SELECT tm.id id, tm.team_id team_id, tm.role member_role, tm.permissions permissions, tm.accepted accepted,
+            u.id user_id, u.github_id github_id, u.name user_name, u.email email,
+            u.avatar_url avatar_url, u.username username, u.bio bio,
+            u.created created, u.role user_role
+            FROM team_members tm
+            INNER JOIN users u ON u.id = tm.user_id
+            WHERE tm.team_id = ANY($1)
+            ORDER BY tm.team_id
+            ",
+            &team_ids_parsed
+        )
+          .fetch_many(exec)
+          .try_filter_map(|e| async {
+              if let Some(m) = e.right() {
+                  let permissions = Permissions::from_bits(m.permissions as u64);
+                  if let Some(perms) = permissions {
+                      Ok(Some(Ok(QueryTeamMember {
+                          id: TeamMemberId(m.id),
+                          team_id: TeamId(m.team_id),
+                          role: m.member_role,
+                          permissions: perms,
+                          accepted: m.accepted,
+                          user: User {
+                              id: UserId(m.user_id),
+                              github_id: m.github_id,
+                              name: m.user_name,
+                              email: m.email,
+                              avatar_url: m.avatar_url,
+                              username: m.username,
+                              bio: m.bio,
+                              created: m.created,
+                              role: m.user_role,
+                          },
+                      })))
+                  } else {
+                      Ok(Some(Err(super::DatabaseError::Bitflag)))
+                  }
+              } else {
+                  Ok(None)
+              }
+          })
+          .try_collect::<Vec<Result<QueryTeamMember, super::DatabaseError>>>()
+          .await?;
+
+        let team_members = teams
+            .into_iter()
+            .collect::<Result<Vec<QueryTeamMember>, super::DatabaseError>>()?;
+
+        Ok(team_members)
+    }
+
     /// Lists the team members for a user.  Does not list pending requests.
     pub async fn get_from_user_public<'a, 'b, E>(
         id: UserId,
@@ -334,6 +399,59 @@ impl TeamMember {
         }
     }
 
+    /// Gets team members from user ids and team ids.  Does not return pending members.
+    pub async fn get_from_user_id_many<'a, 'b, E>(
+        team_ids: Vec<TeamId>,
+        user_id: UserId,
+        executor: E,
+    ) -> Result<Vec<Self>, super::DatabaseError>
+    where
+        E: sqlx::Executor<'a, Database = sqlx::Postgres>,
+    {
+        use futures::stream::TryStreamExt;
+
+        let team_ids_parsed: Vec<i64> =
+            team_ids.into_iter().map(|x| x.0).collect();
+
+        let team_members = sqlx::query!(
+            "
+            SELECT id, team_id, user_id, role, permissions, accepted
+            FROM team_members
+            WHERE (team_id = ANY($1) AND user_id = $2 AND accepted = TRUE)
+            ",
+            &team_ids_parsed,
+            user_id as UserId
+        )
+        .fetch_many(executor)
+        .try_filter_map(|e| async {
+            if let Some(m) = e.right() {
+                let permissions = Permissions::from_bits(m.permissions as u64);
+                if let Some(perms) = permissions {
+                    Ok(Some(Ok(TeamMember {
+                        id: TeamMemberId(m.id),
+                        team_id: TeamId(m.team_id),
+                        user_id,
+                        role: m.role,
+                        permissions: perms,
+                        accepted: m.accepted,
+                    })))
+                } else {
+                    Ok(Some(Err(super::DatabaseError::Bitflag)))
+                }
+            } else {
+                Ok(None)
+            }
+        })
+        .try_collect::<Vec<Result<TeamMember, super::DatabaseError>>>()
+        .await?;
+
+        let team_members = team_members
+            .into_iter()
+            .collect::<Result<Vec<TeamMember>, super::DatabaseError>>()?;
+
+        Ok(team_members)
+    }
+
     /// Gets a team member from a user id and team id, including pending members.
     pub async fn get_from_user_id_pending<'a, 'b, E>(
         id: TeamId,

src/routes/mod.rs

@@ -126,6 +126,8 @@ pub fn users_config(cfg: &mut web::ServiceConfig) {
 }
 
 pub fn teams_config(cfg: &mut web::ServiceConfig) {
+    cfg.service(teams::teams_get);
+
     cfg.service(
         web::scope("team")
             .service(teams::team_members_get)

src/routes/teams.rs

@@ -101,6 +101,63 @@ pub async fn team_members_get(
     Ok(HttpResponse::Ok().json(team_members))
 }
 
+#[derive(Serialize, Deserialize)]
+pub struct TeamIds {
+    pub ids: String,
+}
+
+#[get("teams")]
+pub async fn teams_get(
+    req: HttpRequest,
+    web::Query(ids): web::Query<TeamIds>,
+    pool: web::Data<PgPool>,
+) -> Result<HttpResponse, ApiError> {
+    use itertools::Itertools;
+
+    let team_ids = serde_json::from_str::<Vec<TeamId>>(&*ids.ids)?
+        .into_iter()
+        .map(|x| x.into())
+        .collect::<Vec<crate::database::models::ids::TeamId>>();
+
+    let teams_data =
+        TeamMember::get_from_team_full_many(team_ids.clone(), &**pool).await?;
+
+    let current_user = get_user_from_headers(req.headers(), &**pool).await.ok();
+    let accepted = if let Some(user) = current_user {
+        TeamMember::get_from_user_id_many(team_ids, user.id.into(), &**pool)
+            .await?
+            .into_iter()
+            .map(|m| m.team_id.0)
+            .collect()
+    } else {
+        std::collections::HashSet::new()
+    };
+
+    let teams_groups = teams_data.into_iter().group_by(|data| data.team_id.0);
+
+    let mut teams: Vec<Vec<crate::models::teams::TeamMember>> = vec![];
+
+    for (id, member_data) in &teams_groups {
+        if accepted.contains(&id) {
+            let team_members = member_data.map(|data| {
+                crate::models::teams::TeamMember::from(data, false)
+            });
+
+            teams.push(team_members.collect());
+
+            continue;
+        }
+
+        let team_members = member_data
+            .filter(|x| x.accepted)
+            .map(|data| crate::models::teams::TeamMember::from(data, true));
+
+        teams.push(team_members.collect());
+    }
+
+    Ok(HttpResponse::Ok().json(teams))
+}
+
 #[post("{id}/join")]
 pub async fn join_team(
     req: HttpRequest,