BREAKING CHANGES updating gRPC based on the enum now

client/src/functions/modes/edit/form_e.rs

@@ -4,6 +4,8 @@ use crate::services::grpc_client::GrpcClient;
 use crate::state::canvas_state::CanvasState;
 use crate::state::pages::form::FormState;
 use crate::tui::functions::common::form::{revert, save};
+use crate::tui::functions::common::form::SaveOutcome;
+use crate::modes::handlers::event::EventOutcome;
 use crossterm::event::{KeyCode, KeyEvent};
 use std::any::Any;
 
@@ -11,48 +13,61 @@ pub async fn execute_common_action<S: CanvasState + Any>(
     action: &str,
     state: &mut S,
     grpc_client: &mut GrpcClient,
-    is_saved: &mut bool,
     current_position: &mut u64,
     total_count: u64,
-) -> Result<String, Box<dyn std::error::Error>> {
+) -> Result<EventOutcome, Box<dyn std::error::Error>> {
     match action {
         "save" | "revert" => {
             if !state.has_unsaved_changes() {
-                return Ok("No changes to save or revert.".to_string());
+                return Ok(EventOutcome::Ok("No changes to save or revert.".to_string()));
             }
             if let Some(form_state) =
                 (state as &mut dyn Any).downcast_mut::<FormState>()
             {
                 match action {
                     "save" => {
-                        save(
+                        let save_result = save(
                             form_state,
                             grpc_client,
-                            is_saved,
                             current_position,
                             total_count,
-                        )
-                        .await
+                        ).await;
+                        
+                        match save_result {
+                            Ok(save_outcome) => {
+                                let message = match save_outcome {
+                                    SaveOutcome::NoChange => "No changes to save.".to_string(),
+                                    SaveOutcome::UpdatedExisting => "Entry updated.".to_string(),
+                                    SaveOutcome::CreatedNew(_) => "New entry created.".to_string(),
+                                };
+                                Ok(EventOutcome::DataSaved(save_outcome, message))
+                            }
+                            Err(e) => Err(e),
+                        }
                     }
                     "revert" => {
-                        revert(
+                        let revert_result = revert(
                             form_state,
                             grpc_client,
                             current_position,
                             total_count,
-                        )
-                        .await
+                        ).await;
+                        
+                        match revert_result {
+                            Ok(message) => Ok(EventOutcome::Ok(message)),
+                            Err(e) => Err(e),
+                        }
                     }
                     _ => unreachable!(),
                 }
             } else {
-                Ok(format!(
+                Ok(EventOutcome::Ok(format!(
                     "Action '{}' not implemented for this state type.",
                     action
-                ))
+                )))
             }
         }
-        _ => Ok(format!("Common action '{}' not handled here.", action)),
+        _ => Ok(EventOutcome::Ok(format!("Common action '{}' not handled here.", action))),
     }
 }
 
@@ -61,10 +76,10 @@ pub async fn execute_edit_action<S: CanvasState>(
     key: KeyEvent,
     state: &mut S,
     ideal_cursor_column: &mut usize,
-    _grpc_client: &mut GrpcClient,
-    _is_saved: &mut bool,
-    _current_position: &mut u64,
-    _total_count: u64,
+    grpc_client: &mut GrpcClient,
+    is_saved: &mut bool,
+    current_position: &mut u64,
+    total_count: u64,
 ) -> Result<String, Box<dyn std::error::Error>> {
     match action {
         "insert_char" => {