add member status to details endpoint

openapi.yml

@@ -1241,6 +1241,9 @@ components:
         curator:
           type: boolean
           example: true
+        member:
+          type: boolean
+          example: true
         group:
           $ref: "#/components/schemas/GroupWithTerms"
         member_count:

src/api/groups.rs

@@ -16,6 +16,7 @@ use actix_web::HttpResponse;
 use actix_web::Responder;
 use cis_client::CisClient;
 use dino_park_gate::scope::ScopeAndUser;
+use dino_park_trust::GroupsTrust;
 use log::info;
 use serde::Deserialize;
 use std::sync::Arc;
@@ -101,7 +102,10 @@ async fn group_details(
     scope_and_user: ScopeAndUser,
 ) -> Result<HttpResponse, ApiError> {
     let host = operations::users::user_by_id(&pool, &scope_and_user.user_id)?;
-    let curator = operations::admins::is_admin(&pool, &scope_and_user, &group_name, &host);
+    let role = operations::members::role_for_current(&pool, &scope_and_user, &group_name)?;
+    let curator = role.as_ref().map(|r| r.is_curator()).unwrap_or_default()
+        || scope_and_user.groups_scope == GroupsTrust::Admin;
+    let is_member = role.is_some();
     let member_count = match operations::members::member_count(&pool, &group_name) {
         Ok(member_count) => member_count,
         Err(e) => return Err(ApiError::GenericBadRequest(e)),
@@ -128,6 +132,7 @@ async fn group_details(
     };
     let result = DisplayGroupDetails {
         curator,
+        member: is_member,
         group: GroupInfo {
             name: group.group.name,
             description: group.group.description,

src/api/models.rs

@@ -40,6 +40,7 @@ pub struct GroupInfo {
 #[derive(Serialize)]
 pub struct DisplayGroupDetails {
     pub curator: bool,
+    pub member: bool,
     pub group: GroupInfo,
     pub member_count: i64,
     pub invitation_count: Option<i64>,

src/db/internal/member.rs

@@ -206,14 +206,15 @@ pub fn role_for(
     connection: &PgConnection,
     user_uuid: &Uuid,
     group_name: &str,
-) -> Result<Role, Error> {
+) -> Result<Option<Role>, Error> {
     schema::memberships::table
         .filter(schema::memberships::user_uuid.eq(user_uuid))
         .inner_join(schema::groups::table)
         .filter(schema::groups::name.eq(group_name))
         .inner_join(schema::roles::table)
-        .get_result::<(Membership, Group, Role)>(connection)
-        .map(|(_, _, r)| r)
+        .select(schema::roles::all_columns)
+        .get_result::<Role>(connection)
+        .optional()
         .map_err(Into::into)
 }
 

src/db/operations/admins.rs

@@ -33,17 +33,6 @@ pub async fn add_admin(
     add_group_to_profile(cis_client, group_name_f, profile).await
 }
 
-pub fn is_admin(pool: &Pool, scope_and_user: &ScopeAndUser, group_name: &str, host: &User) -> bool {
-    HOST_IS_GROUP_ADMIN
-        .run(&RuleContext::minimal(
-            pool,
-            scope_and_user,
-            &group_name,
-            &host.user_uuid,
-        ))
-        .is_ok()
-}
-
 pub fn demote(
     pool: &Pool,
     scope_and_user: &ScopeAndUser,

src/db/operations/members.rs

@@ -249,3 +249,14 @@ pub fn renew(
     let connection = pool.get()?;
     internal::member::renew(&host.user_uuid, &connection, group_name, user, expiration)
 }
+
+pub fn role_for_current(
+    pool: &Pool,
+    scope_and_user: &ScopeAndUser,
+    group_name: &str,
+) -> Result<Option<RoleType>, Error> {
+    let connection = pool.get()?;
+    let user = internal::user::user_by_id(&connection, &scope_and_user.user_id)?;
+    internal::member::role_for(&connection, &user.user_uuid, group_name)
+        .map(|role| role.map(|role| role.typ))
+}

src/db/types.rs

@@ -97,6 +97,15 @@ pub enum RoleType {
     Member,
 }
 
+impl RoleType {
+    pub fn is_curator(&self) -> bool {
+        match *self {
+            Self::Admin | Self::Curator => true,
+            Self::Member => false,
+        }
+    }
+}
+
 #[derive(DbEnum, Debug, Deserialize, PartialEq, Serialize)]
 #[DieselType = "Group_type"]
 pub enum GroupType {

src/rules/functions.rs

@@ -33,7 +33,7 @@ pub fn rule_is_creator(ctx: &RuleContext) -> Result<(), RuleError> {
 pub fn rule_host_can_invite(ctx: &RuleContext) -> Result<(), RuleError> {
     let connection = ctx.pool.get().map_err(|_| RuleError::PoolError)?;
     match internal::member::role_for(&connection, ctx.host_uuid, ctx.group) {
-        Ok(role)
+        Ok(Some(role))
             if role.typ == RoleType::Admin
                 || role.permissions.contains(&PermissionType::InviteMember) =>
         {
@@ -48,7 +48,7 @@ pub fn rule_host_can_invite(ctx: &RuleContext) -> Result<(), RuleError> {
 pub fn rule_host_can_remove(ctx: &RuleContext) -> Result<(), RuleError> {
     let connection = ctx.pool.get().map_err(|_| RuleError::PoolError)?;
     match internal::member::role_for(&connection, ctx.host_uuid, ctx.group) {
-        Ok(role)
+        Ok(Some(role))
             if role.typ == RoleType::Admin
                 || role.permissions.contains(&PermissionType::RemoveMember) =>
         {
@@ -115,7 +115,7 @@ pub fn current_user_can_join(ctx: &RuleContext) -> Result<(), RuleError> {
 pub fn rule_host_is_curator(ctx: &RuleContext) -> Result<(), RuleError> {
     let connection = ctx.pool.get().map_err(|_| RuleError::PoolError)?;
     match internal::member::role_for(&connection, ctx.host_uuid, ctx.group) {
-        Ok(role) if role.typ == RoleType::Admin || role.typ == RoleType::Curator => Ok(()),
+        Ok(Some(role)) if role.typ == RoleType::Admin || role.typ == RoleType::Curator => Ok(()),
         _ => Err(RuleError::NotACurator),
     }
 }
@@ -124,7 +124,7 @@ pub fn rule_host_is_curator(ctx: &RuleContext) -> Result<(), RuleError> {
 pub fn rule_host_is_group_admin(ctx: &RuleContext) -> Result<(), RuleError> {
     let connection = ctx.pool.get().map_err(|_| RuleError::PoolError)?;
     match internal::member::role_for(&connection, ctx.host_uuid, ctx.group) {
-        Ok(role) if role.typ == RoleType::Admin => Ok(()),
+        Ok(Some(role)) if role.typ == RoleType::Admin => Ok(()),
         _ => Err(RuleError::NotAnAdmin),
     }
 }
@@ -134,7 +134,7 @@ pub fn rule_user_has_member_role(ctx: &RuleContext) -> Result<(), RuleError> {
     let member_uuid = ctx.member_uuid.ok_or(RuleError::InvalidRuleContext)?;
     let connection = ctx.pool.get().map_err(|_| RuleError::PoolError)?;
     match internal::member::role_for(&connection, member_uuid, ctx.group) {
-        Ok(role) if role.typ == RoleType::Member => Ok(()),
+        Ok(Some(role)) if role.typ == RoleType::Member => Ok(()),
         _ => Err(RuleError::NotAnAdmin),
     }
 }
@@ -144,7 +144,7 @@ pub fn rule_user_has_member_role(ctx: &RuleContext) -> Result<(), RuleError> {
 pub fn rule_host_can_edit_terms(ctx: &RuleContext) -> Result<(), RuleError> {
     let connection = ctx.pool.get().map_err(|_| RuleError::PoolError)?;
     match internal::member::role_for(&connection, ctx.host_uuid, ctx.group) {
-        Ok(role)
+        Ok(Some(role))
             if role.typ == RoleType::Admin
                 || role.permissions.contains(&PermissionType::EditTerms) =>
         {