search curators

openapi.yml

@@ -758,6 +758,13 @@ paths:
           schema:
             $ref: "#/components/schemas/TrustType"
           example: Ndaed
+        - in: query
+          name: c
+          description: search for potential curators (requires g to be set)
+          required: false
+          schema:
+            type: string
+          example: true
       responses:
         "200":
           description: the top matches of users

src/api/error.rs

@@ -25,6 +25,8 @@ pub enum ApiError {
     ScopeError(TrustError),
     #[fail(display = "Groups scope Error: {}", _0)]
     GroupsScopeError(GroupsTrustError),
+    #[fail(display = "Invalid query parameters.")]
+    InvalidQuery,
 }
 
 fn to_json_error(e: &impl Display) -> Value {

src/api/users.rs

@@ -16,6 +16,8 @@ struct SearchUsersQuery {
     q: String,
     t: Option<TrustType>,
     g: Option<String>,
+    #[serde(default)]
+    c: bool,
 }
 
 #[guard(Ndaed)]
@@ -24,13 +26,18 @@ async fn search_users(
     scope_and_user: ScopeAndUser,
     query: web::Query<SearchUsersQuery>,
 ) -> impl Responder {
-    match operations::users::search_users(
-        &pool,
-        scope_and_user,
-        query.g.clone(),
-        query.t.clone(),
-        &query.q,
-    ) {
+    let query = query.into_inner();
+    let users = if query.c {
+        match query.g {
+            Some(group_name) => {
+                operations::users::search_admins(&pool, scope_and_user, group_name, &query.q)
+            }
+            _ => return Err(ApiError::InvalidQuery),
+        }
+    } else {
+        operations::users::search_users(&pool, scope_and_user, query.g, query.t, &query.q)
+    };
+    match users {
         Ok(users) => Ok(HttpResponse::Ok().json(users)),
         Err(e) => Err(ApiError::GenericBadRequest(e)),
     }

src/db/internal/user.rs

@@ -1,5 +1,6 @@
 use crate::db::internal;
 use crate::db::schema;
+use crate::db::types::RoleType;
 use crate::db::types::TrustType;
 use crate::db::users::UserProfile;
 use crate::db::users::*;
@@ -165,6 +166,7 @@ pub fn update_user_cache(connection: &PgConnection, profile: &Profile) -> Result
         .execute(connection)?;
     Ok(())
 }
+
 macro_rules! scoped_search_users_for_group {
     ($g:ident, $t:ident, $typ:ident, $q:ident, $trust:ident, $limit:ident, $connection:ident) => {{
         use schema::$t as u;
@@ -200,6 +202,51 @@ macro_rules! scoped_search_users_for_group {
     }};
 }
 
+/*
+                .inner_join(schema::roles::table)
+                .on(schema::roles::role_id.eq(schema::memberships::role_id))
+                .filter(schema::memberships::group_id.eq($g))
+                .filter(schema::roles::typ.ne(RoleType::Member))
+                .select(schema::memberships::all_columns))
+*/
+macro_rules! scoped_search_curators_for_group {
+    ($g:ident, $t:ident, $typ:ident, $q:ident, $trust:ident, $limit:ident, $connection:ident) => {{
+        use schema::$t as u;
+        u::table
+            .filter(
+                u::first_name
+                    .concat(" ")
+                    .concat(u::last_name)
+                    .ilike($q)
+                    .or(u::first_name.ilike($q))
+                    .or(u::last_name.ilike($q))
+                    .or(u::username.ilike($q))
+                    .or(u::email.ilike($q)),
+            )
+            .filter(u::trust.ge($trust))
+            .left_outer_join(
+                schema::memberships::table.on(schema::memberships::user_uuid
+                    .eq(u::user_uuid)
+                    .and(schema::memberships::group_id.eq($g))),
+            )
+            .left_outer_join(
+                schema::roles::table.on(schema::roles::role_id.eq(schema::memberships::role_id)),
+            )
+            .filter(
+                schema::memberships::group_id
+                    .is_null()
+                    .or(schema::memberships::group_id
+                        .ne($g)
+                        .or(schema::roles::typ.eq(RoleType::Member))),
+            )
+            .select(u::all_columns)
+            .limit($limit)
+            .get_results::<$typ>($connection)
+            .map(|users| users.into_iter().map(|u| u.into()).collect())
+            .map_err(Into::into)
+    }};
+}
+
 macro_rules! scoped_search_users {
     ($t:ident, $typ:ident, $q:ident, $trust:ident, $limit:ident, $connection:ident) => {{
         use schema::$t as u;
@@ -222,6 +269,64 @@ macro_rules! scoped_search_users {
     }};
 }
 
+pub fn search_curators_for_group(
+    connection: &PgConnection,
+    group_name: &str,
+    scope: TrustType,
+    q: &str,
+    limit: i64,
+) -> Result<Vec<DisplayUser>, Error> {
+    let q: &str = &format!("{}%", q);
+    let group_id = internal::group::get_group(connection, group_name)?.id;
+    let trust = TrustType::Ndaed;
+    match scope {
+        TrustType::Staff => scoped_search_curators_for_group!(
+            group_id,
+            users_staff,
+            UsersStaff,
+            q,
+            trust,
+            limit,
+            connection
+        ),
+        TrustType::Ndaed => scoped_search_curators_for_group!(
+            group_id,
+            users_ndaed,
+            UsersNdaed,
+            q,
+            trust,
+            limit,
+            connection
+        ),
+        TrustType::Vouched => scoped_search_curators_for_group!(
+            group_id,
+            users_vouched,
+            UsersVouched,
+            q,
+            trust,
+            limit,
+            connection
+        ),
+        TrustType::Authenticated => scoped_search_curators_for_group!(
+            group_id,
+            users_authenticated,
+            UsersAuthenticated,
+            q,
+            trust,
+            limit,
+            connection
+        ),
+        TrustType::Public => scoped_search_curators_for_group!(
+            group_id,
+            users_public,
+            UsersPublic,
+            q,
+            trust,
+            limit,
+            connection
+        ),
+    }
+}
 pub fn search_users_for_group(
     connection: &PgConnection,
     group_name: &str,

src/db/operations/users.rs

@@ -66,6 +66,30 @@ pub fn search_users(
     }
 }
 
+pub fn search_admins(
+    pool: &Pool,
+    scope_and_user: ScopeAndUser,
+    group_name: String,
+    q: &str,
+) -> Result<Vec<DisplayUser>, Error> {
+    let connection = pool.get()?;
+    let host = internal::user::user_by_id(&connection, &scope_and_user.user_id)?;
+    SEARCH_USERS.run(&RuleContext::minimal(
+        pool,
+        &scope_and_user,
+        &group_name,
+        &host.user_uuid,
+    ))?;
+
+    internal::user::search_curators_for_group(
+        &connection,
+        &group_name,
+        scope_and_user.scope.into(),
+        q,
+        5,
+    )
+}
+
 pub fn delete_user(pool: &Pool, user: &User) -> Result<(), Error> {
     let connection = pool.get()?;
     internal::user::delete_user(&connection, user)