Notifications

src/system/config_client.rs

@@ -27,7 +27,7 @@
  */
 // Locals
 use crate::config::{
-    params::UserConfig,
+    params::{UserConfig, DEFAULT_NOTIFICATION_TRANSFER_THRESHOLD},
     serialization::{deserialize, serialize, SerializerError, SerializerErrorKind},
 };
 use crate::filetransfer::FileTransferProtocol;
@@ -254,6 +254,37 @@ impl ConfigClient {
         };
     }
 
+    /// ### get_notifications
+    ///
+    /// Get value of `notifications`
+    pub fn get_notifications(&self) -> bool {
+        self.config.user_interface.notifications.unwrap_or(true)
+    }
+
+    /// ### set_notifications
+    ///
+    /// Set new value for `notifications`
+    pub fn set_notifications(&mut self, value: bool) {
+        self.config.user_interface.notifications = Some(value);
+    }
+
+    /// ### get_notification_threshold
+    ///
+    /// Get value of `notification_threshold`
+    pub fn get_notification_threshold(&self) -> u64 {
+        self.config
+            .user_interface
+            .notification_threshold
+            .unwrap_or(DEFAULT_NOTIFICATION_TRANSFER_THRESHOLD)
+    }
+
+    /// ### set_notification_threshold
+    ///
+    /// Set new value for `notification_threshold`
+    pub fn set_notification_threshold(&mut self, value: u64) {
+        self.config.user_interface.notification_threshold = Some(value);
+    }
+
     // SSH Keys
 
     /// ### save_ssh_key
@@ -657,6 +688,37 @@ mod tests {
         assert_eq!(client.get_remote_file_fmt(), None);
     }
 
+    #[test]
+    fn test_system_config_notifications() {
+        let tmp_dir: TempDir = TempDir::new().ok().unwrap();
+        let (cfg_path, key_path): (PathBuf, PathBuf) = get_paths(tmp_dir.path());
+        let mut client: ConfigClient = ConfigClient::new(cfg_path.as_path(), key_path.as_path())
+            .ok()
+            .unwrap();
+        assert_eq!(client.get_notifications(), true); // Null ?
+        client.set_notifications(true);
+        assert_eq!(client.get_notifications(), true);
+        client.set_notifications(false);
+        assert_eq!(client.get_notifications(), false);
+    }
+
+    #[test]
+    fn test_system_config_remote_notification_threshold() {
+        let tmp_dir: TempDir = TempDir::new().ok().unwrap();
+        let (cfg_path, key_path): (PathBuf, PathBuf) = get_paths(tmp_dir.path());
+        let mut client: ConfigClient = ConfigClient::new(cfg_path.as_path(), key_path.as_path())
+            .ok()
+            .unwrap();
+        assert_eq!(
+            client.get_notification_threshold(),
+            DEFAULT_NOTIFICATION_TRANSFER_THRESHOLD
+        ); // Null ?
+        client.set_notification_threshold(1024);
+        assert_eq!(client.get_notification_threshold(), 1024);
+        client.set_notification_threshold(64);
+        assert_eq!(client.get_notification_threshold(), 64);
+    }
+
     #[test]
     fn test_system_config_ssh_keys() {
         let tmp_dir: TempDir = TempDir::new().ok().unwrap();

src/system/mod.rs

@@ -32,5 +32,6 @@ pub mod config_client;
 pub mod environment;
 pub(self) mod keys;
 pub mod logging;
+pub mod notifications;
 pub mod sshkey_storage;
 pub mod theme_provider;

src/system/notifications.rs

@@ -0,0 +1,82 @@
+//! # Notifications
+//!
+//! This module exposes the function to send notifications to the guest OS
+
+#[cfg(all(unix, not(target_os = "macos")))]
+use notify_rust::Hint;
+use notify_rust::{Notification as OsNotification, Timeout};
+
+/// ## Notification
+///
+/// A notification helper which provides all the functions to send the available notifications for termscp
+pub struct Notification;
+
+impl Notification {
+    /// ### transfer_completed
+    ///
+    /// Notify a transfer has been completed with success
+    pub fn transfer_completed<S: AsRef<str>>(body: S) {
+        Self::notify(
+            "Transfer completed ✅",
+            body.as_ref(),
+            Some("transfer.complete"),
+        );
+    }
+
+    /// ### transfer_error
+    ///
+    /// Notify a transfer has failed
+    pub fn transfer_error<S: AsRef<str>>(body: S) {
+        Self::notify("Transfer failed ❌", body.as_ref(), Some("transfer.error"));
+    }
+
+    /// ### update_available
+    ///
+    /// Notify a new version of termscp is available for download
+    pub fn update_available<S: AsRef<str>>(version: S) {
+        Self::notify(
+            "New version available ⬇️",
+            format!("termscp {} is now available for download", version.as_ref()).as_str(),
+            None,
+        );
+    }
+
+    /// ### update_installed
+    ///
+    /// Notify the update has been correctly installed
+    pub fn update_installed<S: AsRef<str>>(version: S) {
+        Self::notify(
+        "Update installed 🎉",
+            format!("termscp {} has been installed! Restart termscp to enjoy the latest version of termscp 🙂", version.as_ref()).as_str(),
+        None,
+        );
+    }
+
+    /// ### update_failed
+    ///
+    /// Notify the update installation has failed
+    pub fn update_failed<S: AsRef<str>>(err: S) {
+        Self::notify("Update installation failed ❌", err.as_ref(), None);
+    }
+
+    /// ### notify
+    ///
+    /// Notify guest OS with provided Summary, body and optional category
+    /// e.g. Category is supported on FreeBSD/Linux only
+    #[allow(unused_variables)]
+    fn notify(summary: &str, body: &str, category: Option<&str>) {
+        let mut notification = OsNotification::new();
+        // Set common params
+        notification
+            .appname(env!("CARGO_PKG_NAME"))
+            .summary(summary)
+            .body(body)
+            .timeout(Timeout::Milliseconds(10000));
+        // Set category if any
+        #[cfg(all(unix, not(target_os = "macos")))]
+        if let Some(category) = category {
+            notification.hint(Hint::Category(category.to_string()));
+        }
+        let _ = notification.show();
+    }
+}