chore: save workspace member info to disk (#5536)

* chore: save workspace member info to disk

* chore: fix clippy

frontend/rust-lib/flowy-user/Cargo.toml

@@ -9,7 +9,7 @@ edition = "2018"
 flowy-derive.workspace = true
 flowy-sqlite = { workspace = true }
 flowy-encrypt = { workspace = true }
-flowy-error = { workspace = true, features = ["impl_from_dispatch_error", "impl_from_sqlite", "impl_from_collab_folder", "impl_from_collab_persistence"] }
+flowy-error = { workspace = true, features = ["impl_from_dispatch_error", "impl_from_sqlite", "impl_from_collab_folder", "impl_from_collab_persistence", "impl_from_collab_document"] }
 flowy-folder-pub = { workspace = true }
 lib-infra = { workspace = true }
 flowy-notification = { workspace = true }
@@ -39,7 +39,6 @@ parking_lot.workspace = true
 strum = "0.25"
 strum_macros = "0.25.2"
 tokio = { workspace = true, features = ["rt"] }
-validator = "0.16.0"
 unicode-segmentation = "1.10"
 fancy-regex = "0.11.0"
 uuid.workspace = true
@@ -47,6 +46,7 @@ chrono = { workspace = true, default-features = false, features = ["clock"] }
 base64 = "^0.21"
 tokio-stream = "0.1.14"
 semver = "1.0.22"
+validator = { workspace = true, features = ["derive"] }
 
 [dev-dependencies]
 nanoid = "0.4.0"

frontend/rust-lib/flowy-user/src/services/sqlite_sql/member_sql.rs

@@ -0,0 +1,52 @@
+use diesel::{insert_into, RunQueryDsl};
+use flowy_error::FlowyResult;
+
+use flowy_sqlite::schema::workspace_members_table;
+
+use flowy_sqlite::schema::workspace_members_table::dsl;
+use flowy_sqlite::{query_dsl::*, DBConnection, ExpressionMethods};
+
+#[derive(Queryable, Insertable, AsChangeset, Debug)]
+#[diesel(table_name = workspace_members_table)]
+#[diesel(primary_key(email, workspace_id))]
+pub struct WorkspaceMemberTable {
+  pub email: String,
+  pub role: i32,
+  pub name: String,
+  pub avatar_url: Option<String>,
+  pub uid: i64,
+  pub workspace_id: String,
+  pub updated_at: chrono::NaiveDateTime,
+}
+
+pub fn upsert_workspace_member<T: Into<WorkspaceMemberTable>>(
+  mut conn: DBConnection,
+  member: T,
+) -> FlowyResult<()> {
+  let member = member.into();
+
+  insert_into(workspace_members_table::table)
+    .values(&member)
+    .on_conflict((
+      workspace_members_table::email,
+      workspace_members_table::workspace_id,
+    ))
+    .do_update()
+    .set(&member)
+    .execute(&mut conn)?;
+
+  Ok(())
+}
+
+pub fn select_workspace_member(
+  mut conn: DBConnection,
+  workspace_id: &str,
+  uid: i64,
+) -> FlowyResult<WorkspaceMemberTable> {
+  let member = dsl::workspace_members_table
+    .filter(workspace_members_table::workspace_id.eq(workspace_id))
+    .filter(workspace_members_table::uid.eq(uid))
+    .first::<WorkspaceMemberTable>(&mut conn)?;
+
+  Ok(member)
+}

frontend/rust-lib/flowy-user/src/services/sqlite_sql/mod.rs

@@ -1,2 +1,3 @@
+pub(crate) mod member_sql;
 pub(crate) mod user_sql;
 pub(crate) mod workspace_sql;

frontend/rust-lib/flowy-user/src/user_manager/manager_user_workspace.rs

@@ -1,9 +1,10 @@
+use chrono::{Duration, NaiveDateTime, Utc};
 use std::convert::TryFrom;
 use std::sync::Arc;
 
 use collab_entity::{CollabObject, CollabType};
 use collab_integrate::CollabKVDB;
-use tracing::{error, info, instrument, warn};
+use tracing::{error, info, instrument, trace, warn};
 
 use flowy_error::{ErrorCode, FlowyError, FlowyResult};
 use flowy_folder_pub::entities::{AppFlowyData, ImportData};
@@ -23,6 +24,9 @@ use crate::notification::{send_notification, UserNotification};
 use crate::services::data_import::{
   generate_import_data, upload_collab_objects_data, ImportedFolder, ImportedSource,
 };
+use crate::services::sqlite_sql::member_sql::{
+  select_workspace_member, upsert_workspace_member, WorkspaceMemberTable,
+};
 use crate::services::sqlite_sql::workspace_sql::{
   get_all_user_workspace_op, get_user_workspace_op, insert_new_workspaces_op, UserWorkspaceTable,
 };
@@ -483,11 +487,54 @@ impl UserManager {
   #[instrument(level = "debug", skip(self), err)]
   pub async fn get_workspace_member_info(&self, uid: i64) -> FlowyResult<WorkspaceMember> {
     let workspace_id = self.get_session()?.user_workspace.id.clone();
+    let db = self.authenticate_user.get_sqlite_connection(uid)?;
+    // Can opt in using memory cache
+    if let Ok(member_record) = select_workspace_member(db, &workspace_id, uid) {
+      if is_older_than_n_minutes(member_record.updated_at, 10) {
+        self
+          .get_workspace_member_info_from_remote(&workspace_id, uid)
+          .await?;
+      }
+
+      return Ok(WorkspaceMember {
+        email: member_record.email,
+        role: member_record.role.into(),
+        name: member_record.name,
+        avatar_url: member_record.avatar_url,
+      });
+    }
+
+    let member = self
+      .get_workspace_member_info_from_remote(&workspace_id, uid)
+      .await?;
+
+    Ok(member)
+  }
+
+  async fn get_workspace_member_info_from_remote(
+    &self,
+    workspace_id: &str,
+    uid: i64,
+  ) -> FlowyResult<WorkspaceMember> {
+    trace!("get workspace member info from remote: {}", workspace_id);
     let member = self
       .cloud_services
       .get_user_service()?
       .get_workspace_member_info(&workspace_id, uid)
       .await?;
+
+    let record = WorkspaceMemberTable {
+      email: member.email.clone(),
+      role: member.role.clone().into(),
+      name: member.name.clone(),
+      avatar_url: member.avatar_url.clone(),
+      uid,
+      workspace_id: workspace_id.to_string(),
+      updated_at: Utc::now().naive_utc(),
+    };
+
+    let db = self.authenticate_user.get_sqlite_connection(uid)?;
+    upsert_workspace_member(db, record)?;
     Ok(member)
   }
 }
@@ -599,3 +646,11 @@ pub fn delete_user_workspaces(mut conn: DBConnection, workspace_id: &str) -> Flo
   }
   Ok(())
 }
+
+fn is_older_than_n_minutes(updated_at: NaiveDateTime, minutes: i64) -> bool {
+  let current_time: NaiveDateTime = Utc::now().naive_utc();
+  match current_time.checked_sub_signed(Duration::minutes(minutes)) {
+    Some(five_minutes_ago) => updated_at < five_minutes_ago,
+    None => false,
+  }
+}