feat: add members count

admin_frontend/src/ext/api.rs

@@ -1,58 +1,120 @@
 use database_entity::dto::AFWorkspace;
 
-use super::entities::{JsonResponse, UserUsageLimit};
+use super::entities::{JsonResponse, UserUsageLimit, WorkspaceMember, WorkspaceUsage};
 
-pub async fn get_user_workspace_count(
+pub async fn get_user_workspace_count(auth_header: &str, appflowy_cloud_base_url: &str) -> u32 {
-  auth_header: &str,
+  let workspaces = get_user_workspaces(auth_header, appflowy_cloud_base_url).await;
-  appflowy_cloud_base_url: &str,
+  workspaces.len() as u32
-) -> Result<u32, reqwest::Error> {
+}
+
+async fn get_user_workspaces(auth_header: &str, appflowy_cloud_base_url: &str) -> Vec<AFWorkspace> {
   let http_client = reqwest::Client::new();
-  let resp = http_client
+  let resp = match http_client
     .get(format!("{}/api/workspace", appflowy_cloud_base_url))
     .header("Authorization", format!("Bearer {}", auth_header))
     .send()
-    .await?;
+    .await
+  {
+    Ok(resp) => resp,
+    Err(err) => {
+      tracing::error!("Error getting user workspaces: {:?}", err);
+      return vec![];
+    },
+  };
 
-  let res = resp.json::<JsonResponse<Vec<AFWorkspace>>>().await?;
+  let res = match resp.json::<JsonResponse<Vec<AFWorkspace>>>().await {
-  Ok(res.data.len() as u32)
+    Ok(res) => res,
+    Err(err) => {
+      tracing::error!("Error parsing user workspaces: {:?}", err);
+      return vec![];
+    },
+  };
+
+  res.data
 }
 
 pub async fn get_user_workspace_limit(
   auth_header: &str,
   appflowy_cloud_base_url: &str,
-) -> Result<u32, reqwest::Error> {
+) -> Option<i64> {
   let http_client = reqwest::Client::new();
-  let resp = http_client
+  let resp = match http_client
     .get(format!("{}/api/user/limit", appflowy_cloud_base_url))
     .header("Authorization", format!("Bearer {}", auth_header))
     .send()
-    .await?;
+    .await
+  {
+    Ok(resp) => resp,
+    Err(err) => {
+      tracing::warn!("unable to get user workspace limit: {:?}", err);
+      return None;
+    },
+  };
 
-  let res = resp.json::<JsonResponse<UserUsageLimit>>().await?;
+  let res = match resp.json::<JsonResponse<UserUsageLimit>>().await {
-  let b = res.data;
+    Ok(res) => res,
-  let c = b.workspace_count.unwrap_or({
+    Err(err) => {
-    tracing::warn!("workspace_count is None, returning 0");
+      tracing::error!("Error parsing user workspace limit: {:?}", err);
-    0
+      return None;
-  });
+    },
-  Ok(c as u32)
+  };
+  Some(res.data.workspace_count)
 }
 
-pub async fn get_workspace_limit(
+pub async fn get_user_workspace_usages(
   auth_header: &str,
   appflowy_cloud_base_url: &str,
-) -> Result<u32, reqwest::Error> {
+  appflowy_cloud_gateway_base_url: &str,
+) -> Vec<WorkspaceUsage> {
+  let user_workspaces = get_user_workspaces(auth_header, appflowy_cloud_base_url).await;
+
+  let mut workspace_usages: Vec<WorkspaceUsage> = Vec::with_capacity(user_workspaces.len());
+  for user_workspace in user_workspaces {
+    let workspace_id = user_workspace.workspace_id.to_string();
+    let members =
+      get_user_workspace_members(&workspace_id, auth_header, appflowy_cloud_gateway_base_url).await;
+
+    workspace_usages.push(WorkspaceUsage {
+      name: user_workspace.workspace_name,
+      member_count: members.len(),
+      member_limit: 98798,                                  // todo
+      total_doc_size: human_bytes::human_bytes(987654),     // todo
+      total_blob_size: human_bytes::human_bytes(9876543),   // todo
+      total_blob_limit: human_bytes::human_bytes(98765432), // todo
+    });
+  }
+
+  workspace_usages
+}
+
+async fn get_user_workspace_members(
+  workspace_id: &str,
+  auth_header: &str,
+  appflowy_cloud_base_url: &str,
+) -> Vec<WorkspaceMember> {
   let http_client = reqwest::Client::new();
-  let resp = http_client
+  let resp = match http_client
-    .get(format!("{}/api/user/limit", appflowy_cloud_base_url))
+    .get(format!(
+      "{}/api/workspace/{}/member",
+      appflowy_cloud_base_url, workspace_id
+    ))
     .header("Authorization", format!("Bearer {}", auth_header))
     .send()
-    .await?;
+    .await
+  {
+    Ok(resp) => resp,
+    Err(err) => {
+      tracing::error!("Error getting user workspace members: {:?}", err);
+      return vec![];
+    },
+  };
 
-  let res = resp.json::<JsonResponse<UserUsageLimit>>().await?;
+  let res = match resp.json::<JsonResponse<Vec<WorkspaceMember>>>().await {
-  let b = res.data;
+    Ok(res) => res,
-  let c = b.workspace_count.unwrap_or({
+    Err(err) => {
-    tracing::warn!("workspace_count is None, returning 0");
+      tracing::error!("Error parsing user workspace limit: {:?}", err);
-    0
+      return vec![];
-  });
+    },
-  Ok(c as u32)
+  };
+  res.data
 }

admin_frontend/src/ext/entities.rs

@@ -8,15 +8,22 @@ pub struct JsonResponse<T> {
 
 #[derive(Deserialize)]
 pub struct UserUsageLimit {
-  pub workspace_count: Option<i64>,
+  pub workspace_count: i64,
 }
 
 #[derive(Serialize)]
 pub struct WorkspaceUsage {
   pub name: String,
-  pub member_count: i64,
+  pub member_count: usize,
   pub member_limit: i64,
   pub total_doc_size: String,
   pub total_blob_size: String,
   pub total_blob_limit: String,
 }
+
+#[derive(Deserialize)]
+pub struct WorkspaceMember {
+  pub name: String,
+  pub email: String,
+  pub role: String,
+}

admin_frontend/src/templates.rs

@@ -7,7 +7,7 @@ use crate::ext::entities::WorkspaceUsage;
 #[template(path = "components/user_usage.html")]
 pub struct UserUsage {
   pub workspace_count: u32,
-  pub workspace_limit: u32,
+  pub workspace_limit: String,
 }
 
 // ./../templates/components/workspace_usage.html

admin_frontend/src/web_app.rs

@@ -1,5 +1,7 @@
 use crate::error::WebAppError;
-use crate::ext::api::{get_user_workspace_count, get_user_workspace_limit};
+use crate::ext::api::{
+  get_user_workspace_count, get_user_workspace_limit, get_user_workspace_usages,
+};
 use crate::ext::entities::WorkspaceUsage;
 use crate::session::UserSession;
 use askama::Template;
@@ -100,22 +102,15 @@ pub async fn user_usage_handler(
   session: UserSession,
 ) -> Result<Html<String>, WebAppError> {
   let workspace_count =
-    get_user_workspace_count(&session.token.access_token, &state.appflowy_cloud_url)
+    get_user_workspace_count(&session.token.access_token, &state.appflowy_cloud_url).await;
-      .await
-      .unwrap_or_else(|err| {
-        tracing::error!("Error getting user workspace count: {:?}", err);
-        0
-      });
 
   let workspace_limit = get_user_workspace_limit(
     &session.token.access_token,
     &state.appflowy_cloud_gateway_url,
   )
   .await
-  .unwrap_or_else(|err| {
+  .map(|limit| limit.to_string())
-    tracing::error!("Error getting user workspace limit: {:?}", err);
+  .unwrap_or("".to_owned());
-    0
-  });
 
   render_template(templates::UserUsage {
     workspace_count,
@@ -127,25 +122,12 @@ pub async fn workspace_usage_handler(
   State(app_state): State<AppState>,
   session: UserSession,
 ) -> Result<Html<String>, WebAppError> {
-  let workspace_usages = vec![
+  let workspace_usages = get_user_workspace_usages(
-    WorkspaceUsage {
+    &session.token.access_token,
-      name: "test".to_owned(),
+    &app_state.appflowy_cloud_url,
-      member_count: 6,
+    &app_state.appflowy_cloud_gateway_url,
-      member_limit: 7,
+  )
-      total_doc_size: human_bytes(987654),
+  .await;
-      total_blob_size: human_bytes(9876543),
-      total_blob_limit: human_bytes(98765432),
-    },
-    WorkspaceUsage {
-      name: "test".to_owned(),
-      member_count: 6,
-      member_limit: 7,
-      total_doc_size: human_bytes(987654),
-      total_blob_size: human_bytes(9876543),
-      total_blob_limit: human_bytes(98765432),
-    },
-  ];
-
   render_template(templates::WorkspaceUsageList { workspace_usages })
 }