Add 'core/' from commit 'b0dfc4146ca0da535a87f8509aec68817fb2ab14'

git-subtree-dir: core
git-subtree-mainline: a07f3dcd23
git-subtree-split: b0dfc4146c

core/kpcli/src/daemon/dbus.rs

@@ -0,0 +1,212 @@
+//! Linux-only D-Bus implementation of the `DaemonInterface`.
+#![cfg(target_os = "linux")]
+
+use super::{ConfigCommands, DaemonInterface};
+use crate::printers::{ConversationPrinter, MessagePrinter};
+use anyhow::Result;
+use async_trait::async_trait;
+use dbus::blocking::{Connection, Proxy};
+use prettytable::table;
+
+const DBUS_NAME: &str = "net.buzzert.kordophonecd";
+const DBUS_PATH: &str = "/net/buzzert/kordophonecd/daemon";
+
+#[allow(unused)]
+mod dbus_interface {
+    #![allow(unused)]
+    include!(concat!(env!("OUT_DIR"), "/kordophone-client.rs"));
+}
+
+use dbus_interface::NetBuzzertKordophoneRepository as KordophoneRepository;
+use dbus_interface::NetBuzzertKordophoneSettings as KordophoneSettings;
+
+pub struct DBusDaemonInterface {
+    conn: Connection,
+}
+
+impl DBusDaemonInterface {
+    pub fn new() -> Result<Self> {
+        Ok(Self {
+            conn: Connection::new_session()?,
+        })
+    }
+
+    fn proxy(&self) -> Proxy<&Connection> {
+        self.conn
+            .with_proxy(DBUS_NAME, DBUS_PATH, std::time::Duration::from_millis(5000))
+    }
+
+    async fn print_settings(&mut self) -> Result<()> {
+        let server_url = KordophoneSettings::server_url(&self.proxy()).unwrap_or_default();
+        let username = KordophoneSettings::username(&self.proxy()).unwrap_or_default();
+
+        let table = table!([
+            b->"Server URL", &server_url
+        ], [
+            b->"Username", &username
+        ]);
+        table.printstd();
+        Ok(())
+    }
+
+    async fn set_server_url(&mut self, url: String) -> Result<()> {
+        KordophoneSettings::set_server_url(&self.proxy(), url)
+            .map_err(|e| anyhow::anyhow!("Failed to set server URL: {}", e))
+    }
+
+    async fn set_username(&mut self, username: String) -> Result<()> {
+        KordophoneSettings::set_username(&self.proxy(), username)
+            .map_err(|e| anyhow::anyhow!("Failed to set username: {}", e))
+    }
+}
+
+#[async_trait]
+impl DaemonInterface for DBusDaemonInterface {
+    async fn print_version(&mut self) -> Result<()> {
+        let version = KordophoneRepository::get_version(&self.proxy())?;
+        println!("Server version: {}", version);
+        Ok(())
+    }
+
+    async fn print_conversations(&mut self) -> Result<()> {
+        let conversations = KordophoneRepository::get_conversations(&self.proxy(), 100, 0)?;
+        println!("Number of conversations: {}", conversations.len());
+        for conversation in conversations {
+            println!("{}", ConversationPrinter::new(&conversation.into()));
+        }
+        Ok(())
+    }
+
+    async fn sync_conversations(&mut self, conversation_id: Option<String>) -> Result<()> {
+        if let Some(conversation_id) = conversation_id {
+            KordophoneRepository::sync_conversation(&self.proxy(), &conversation_id)
+                .map_err(|e| anyhow::anyhow!("Failed to sync conversation: {}", e))
+        } else {
+            KordophoneRepository::sync_all_conversations(&self.proxy())
+                .map_err(|e| anyhow::anyhow!("Failed to sync conversations: {}", e))
+        }
+    }
+
+    async fn sync_conversations_list(&mut self) -> Result<()> {
+        KordophoneRepository::sync_conversation_list(&self.proxy())
+            .map_err(|e| anyhow::anyhow!("Failed to sync conversations: {}", e))
+    }
+
+    async fn print_messages(
+        &mut self,
+        conversation_id: String,
+        last_message_id: Option<String>,
+    ) -> Result<()> {
+        let messages = KordophoneRepository::get_messages(
+            &self.proxy(),
+            &conversation_id,
+            &last_message_id.unwrap_or_default(),
+        )?;
+        println!("Number of messages: {}", messages.len());
+        for message in messages {
+            println!("{}", MessagePrinter::new(&message.into()));
+        }
+        Ok(())
+    }
+
+    async fn enqueue_outgoing_message(
+        &mut self,
+        conversation_id: String,
+        text: String,
+    ) -> Result<()> {
+        let attachment_guids: Vec<&str> = vec![];
+        let outgoing_message_id = KordophoneRepository::send_message(
+            &self.proxy(),
+            &conversation_id,
+            &text,
+            attachment_guids,
+        )?;
+        println!("Outgoing message ID: {}", outgoing_message_id);
+        Ok(())
+    }
+
+    async fn wait_for_signals(&mut self) -> Result<()> {
+        use dbus::Message;
+        mod dbus_signals {
+            pub use super::dbus_interface::NetBuzzertKordophoneRepositoryConversationsUpdated as ConversationsUpdated;
+        }
+
+        let _id = self.proxy().match_signal(
+            |_: dbus_signals::ConversationsUpdated, _: &Connection, _: &Message| {
+                println!("Signal: Conversations updated");
+                true
+            },
+        );
+
+        println!("Waiting for signals...");
+        loop {
+            self.conn.process(std::time::Duration::from_millis(1000))?;
+        }
+    }
+
+    async fn config(&mut self, cmd: ConfigCommands) -> Result<()> {
+        match cmd {
+            ConfigCommands::Print => self.print_settings().await,
+            ConfigCommands::SetServerUrl { url } => self.set_server_url(url).await,
+            ConfigCommands::SetUsername { username } => self.set_username(username).await,
+        }
+    }
+
+    async fn delete_all_conversations(&mut self) -> Result<()> {
+        KordophoneRepository::delete_all_conversations(&self.proxy())
+            .map_err(|e| anyhow::anyhow!("Failed to delete all conversations: {}", e))
+    }
+
+    async fn download_attachment(&mut self, attachment_id: String) -> Result<()> {
+        // Trigger download.
+        KordophoneRepository::download_attachment(&self.proxy(), &attachment_id, false)?;
+
+        // Get attachment info.
+        let attachment_info =
+            KordophoneRepository::get_attachment_info(&self.proxy(), &attachment_id)?;
+        let (path, _preview_path, downloaded, _preview_downloaded) = attachment_info;
+
+        if downloaded {
+            println!("Attachment already downloaded: {}", path);
+            return Ok(());
+        }
+
+        println!("Downloading attachment: {}", attachment_id);
+
+        // Attach to the signal that the attachment has been downloaded.
+        let download_path = path.clone();
+        let _id = self.proxy().match_signal(
+            move |_: dbus_interface::NetBuzzertKordophoneRepositoryAttachmentDownloadCompleted,
+                  _: &Connection,
+                  _: &dbus::message::Message| {
+                println!("Signal: Attachment downloaded: {}", download_path);
+                std::process::exit(0);
+            },
+        );
+
+        let _id = self.proxy().match_signal(
+            |h: dbus_interface::NetBuzzertKordophoneRepositoryAttachmentDownloadFailed,
+             _: &Connection,
+             _: &dbus::message::Message| {
+                println!("Signal: Attachment download failed: {}", h.attachment_id);
+                std::process::exit(1);
+            },
+        );
+
+        // Wait for the signal.
+        loop {
+            self.conn.process(std::time::Duration::from_millis(1000))?;
+        }
+    }
+
+    async fn upload_attachment(&mut self, path: String) -> Result<()> {
+        let upload_guid = KordophoneRepository::upload_attachment(&self.proxy(), &path)?;
+        println!("Upload GUID: {}", upload_guid);
+        Ok(())
+    }
+
+    async fn mark_conversation_as_read(&mut self, conversation_id: String) -> Result<()> {
+        KordophoneRepository::mark_conversation_as_read(&self.proxy(), &conversation_id)
+            .map_err(|e| anyhow::anyhow!("Failed to mark conversation as read: {}", e))
+    }
+}