Merge pull request #31 from JustEnoughVCS/jvcs_dev_actions

Jvcs dev actions

4 files changed, 96 insertions, 13 deletions

diff --git a/crates/vcs_actions/src/actions.rs b/crates/vcs_actions/src/actions.rs
index 858695a..795d2b0 100644
--- a/crates/vcs_actions/src/actions.rs
+++ b/crates/vcs_actions/src/actions.rs
@@ -5,7 +5,7 @@ use tcp_connection::{error::TcpTargetError, instance::ConnectionInstance};
 use tokio::sync::Mutex;
 use vcs_data::{
     constants::SERVER_PATH_MEMBER_PUB,
-    data::{local::LocalWorkspace, user::UserDirectory, vault::Vault},
+    data::{local::LocalWorkspace, member::MemberId, user::UserDirectory, vault::Vault},
 };
 
 pub mod local_actions;
@@ -57,11 +57,11 @@ pub fn try_get_user_directory(ctx: &ActionContext) -> Result<Arc<UserDirectory>,
     Ok(user_directory)
 }
 
-/// Authenticate member based on whether the process is running locally or remotely
+/// Authenticate member based on context and return MemberId
 pub async fn auth_member(
     ctx: &ActionContext,
     instance: &Arc<Mutex<ConnectionInstance>>,
-) -> Result<(), TcpTargetError> {
+) -> Result<MemberId, TcpTargetError> {
     // Start Challenge (Remote)
     if ctx.is_proc_on_remote() {
         let vault = try_get_vault(ctx)?;
@@ -72,7 +72,7 @@ pub async fn auth_member(
             .await;
 
         return match result {
-            Ok(pass) => {
+            Ok((pass, member_id)) => {
                 if !pass {
                     // Send false to inform the client that authentication failed
                     instance.lock().await.write(false).await?;
@@ -82,7 +82,7 @@ pub async fn auth_member(
                 } else {
                     // Send true to inform the client that authentication was successful
                     instance.lock().await.write(true).await?;
-                    Ok(())
+                    Ok(member_id)
                 }
             }
             Err(e) => Err(e),
@@ -106,7 +106,7 @@ pub async fn auth_member(
         // Read result
         let challenge_result = instance.lock().await.read::<bool>().await?;
         if challenge_result {
-            return Ok(());
+            return Ok(member_name.clone());
         } else {
             return Err(TcpTargetError::Authentication(
                 "Authenticate failed.".to_string(),
diff --git a/crates/vcs_actions/src/actions/local_actions.rs b/crates/vcs_actions/src/actions/local_actions.rs
index 3027218..87eafb8 100644
--- a/crates/vcs_actions/src/actions/local_actions.rs
+++ b/crates/vcs_actions/src/actions/local_actions.rs
@@ -5,7 +5,10 @@ use cfg_file::config::ConfigFile;
 use log::{info, warn};
 use serde::{Deserialize, Serialize};
 use tcp_connection::error::TcpTargetError;
-use vcs_data::data::{local::config::LocalConfig, vault::config::VaultUuid};
+use vcs_data::data::{
+    local::{config::LocalConfig, latest_info::LatestInfo},
+    vault::config::VaultUuid,
+};
 
 use crate::actions::{
     auth_member, check_connection_instance, try_get_local_workspace, try_get_vault,
@@ -26,15 +29,14 @@ pub async fn set_upstream_vault_action(
     ctx: ActionContext,
     upstream: SocketAddr,
 ) -> Result<SetUpstreamVaultActionResult, TcpTargetError> {
-    // Ensure the instance is available
     let instance = check_connection_instance(&ctx)?;
 
-    // Step1: Auth Member
+    // Auth Member
     if let Err(e) = auth_member(&ctx, instance).await {
         return Ok(SetUpstreamVaultActionResult::AuthorizeFailed(e.to_string()));
     }
 
-    // Step2: Direct
+    // Direct
     if ctx.is_proc_on_remote() {
         let vault = try_get_vault(&ctx)?;
         instance
@@ -74,3 +76,76 @@ pub async fn set_upstream_vault_action(
 
     Err(TcpTargetError::NoResult("No result.".to_string()))
 }
+
+#[derive(Serialize, Deserialize)]
+pub enum UpdateToLatestInfoResult {
+    Success,
+
+    // Fail
+    AuthorizeFailed(String),
+}
+
+#[action_gen]
+pub async fn update_to_latest_info_action(
+    ctx: ActionContext,
+    _unused: (),
+) -> Result<UpdateToLatestInfoResult, TcpTargetError> {
+    let instance = check_connection_instance(&ctx)?;
+
+    let member_id = match auth_member(&ctx, instance).await {
+        Ok(id) => id,
+        Err(e) => return Ok(UpdateToLatestInfoResult::AuthorizeFailed(e.to_string())),
+    };
+
+    if ctx.is_proc_on_remote() {
+        let vault = try_get_vault(&ctx)?;
+
+        // Build latest info
+        let mut latest_info = LatestInfo::default();
+
+        // Sheet
+        let mut member_owned = Vec::new();
+        let mut member_visible = Vec::new();
+
+        for sheet in vault.sheets().await? {
+            if sheet.holder() == &member_id {
+                member_owned.push(sheet.name().clone());
+            } else {
+                member_visible.push(sheet.name().clone());
+            }
+        }
+
+        latest_info.my_sheets = member_owned;
+        latest_info.other_sheets = member_visible;
+
+        // RefSheet
+        let ref_sheet_data = vault.sheet(&"ref".to_string()).await?.to_data();
+        latest_info.ref_sheet_content = ref_sheet_data;
+
+        // Members
+        let members = vault.members().await?;
+        latest_info.vault_members = members;
+
+        // Send
+        instance
+            .lock()
+            .await
+            .write_large_msgpack(latest_info, 512 as u16)
+            .await?;
+
+        return Ok(UpdateToLatestInfoResult::Success);
+    }
+
+    if ctx.is_proc_on_local() {
+        let latest_info = instance
+            .lock()
+            .await
+            .read_large_msgpack::<LatestInfo>(512 as u16)
+            .await?;
+        LatestInfo::write(&latest_info).await?;
+
+        return Ok(UpdateToLatestInfoResult::Success);
+    }
+
+    Err(TcpTargetError::NoResult("No result.".to_string()))
+}
diff --git a/crates/vcs_actions/src/registry/client_registry.rs b/crates/vcs_actions/src/registry/client_registry.rs
index 6f820e6..c7d6eb9 100644
--- a/crates/vcs_actions/src/registry/client_registry.rs
+++ b/crates/vcs_actions/src/registry/client_registry.rs
@@ -9,13 +9,16 @@ use vcs_data::data::{
 };
 
 use crate::{
-    actions::local_actions::register_set_upstream_vault_action,
+    actions::local_actions::{
+        register_set_upstream_vault_action, register_update_to_latest_info_action,
+    },
     connection::protocol::RemoteActionInvoke,
 };
 
 fn register_actions(pool: &mut ActionPool) {
     // Pool register here
     register_set_upstream_vault_action(pool);
+    register_update_to_latest_info_action(pool);
 }
 
 pub fn client_action_pool() -> ActionPool {
@@ -52,7 +55,9 @@ async fn on_proc_begin(
     let local_workspace = match LocalWorkspace::init_current_dir(local_config) {
         Some(workspace) => workspace,
         None => {
-            return Err(TcpTargetError::NotFound("Failed to initialize local workspace.".to_string()));
+            return Err(TcpTargetError::NotFound(
+                "Failed to initialize local workspace.".to_string(),
+            ));
         }
     };
     let local_workspace_arc = Arc::new(local_workspace);
diff --git a/crates/vcs_actions/src/registry/server_registry.rs b/crates/vcs_actions/src/registry/server_registry.rs
index 3ecc103..3b6ab17 100644
--- a/crates/vcs_actions/src/registry/server_registry.rs
+++ b/crates/vcs_actions/src/registry/server_registry.rs
@@ -1,9 +1,12 @@
 use action_system::action_pool::ActionPool;
 
-use crate::actions::local_actions::register_set_upstream_vault_action;
+use crate::actions::local_actions::{
+    register_set_upstream_vault_action, register_update_to_latest_info_action,
+};
 
 pub fn server_action_pool() -> ActionPool {
     let mut pool = ActionPool::new();
     register_set_upstream_vault_action(&mut pool);
+    register_update_to_latest_info_action(&mut pool);
     pool
 }