implement credential saving with cross-platform keyring

1 files changed, 54 insertions, 8 deletions

diff --git a/src/login_modal.rs b/src/login_modal.rs
index f4e556e..02d878e 100644
--- a/src/login_modal.rs
+++ b/src/login_modal.rs
@@ -4,10 +4,12 @@ use iced::{
     Element, Task,
 };
 use jid::JID;
+use keyring::Entry;
 use luz::{
     presence::{Offline, Presence},
     LuzHandle,
 };
+use serde::{Deserialize, Serialize};
 use tokio_stream::wrappers::ReceiverStream;
 use tracing::info;
 
@@ -41,6 +43,12 @@ pub enum Action {
     ClientCreated(Task<crate::Message>),
 }
 
+#[derive(Serialize, Deserialize)]
+pub struct Creds {
+    pub jid: String,
+    pub password: String,
+}
+
 impl LoginModal {
     pub fn update(&mut self, message: Message) -> Action {
         match message {
@@ -60,6 +68,7 @@ impl LoginModal {
                 info!("submitting login");
                 let jid_str = self.jid.clone();
                 let password = self.password.clone();
+                let remember_me = self.remember_me.clone();
                 Action::ClientCreated(
                     Task::future(async move {
                         let jid: Result<JID, _> = jid_str.parse();
@@ -70,19 +79,56 @@ impl LoginModal {
                                         .await;
                                 match result {
                                     Ok((luz_handle, receiver)) => {
-                                        let stream = ReceiverStream::new(receiver);
-                                        let stream =
-                                            stream.map(|message| crate::Message::Luz(message));
-                                        vec![
-                                            Task::done(crate::Message::ClientCreated(Client {
+                                        let mut tasks = Vec::new();
+                                        tasks.push(Task::done(crate::Message::ClientCreated(
+                                            Client {
                                                 client: luz_handle,
                                                 jid: j,
                                                 connection_status: Presence::Offline(
                                                     Offline::default(),
                                                 ),
-                                            })),
-                                            Task::stream(stream),
-                                        ]
+                                            },
+                                        )));
+                                        let stream = ReceiverStream::new(receiver);
+                                        let stream =
+                                            stream.map(|message| crate::Message::Luz(message));
+                                        tasks.push(Task::stream(stream));
+
+                                        if remember_me {
+                                            let entry = Entry::new("macaw", "macaw");
+                                            match entry {
+                                                Ok(e) => {
+                                                    let creds = Creds {
+                                                        jid: jid_str,
+                                                        password,
+                                                    };
+                                                    let creds = toml::to_string(&creds);
+                                                    match creds {
+                                                        Ok(c) => {
+                                                            let result = e.set_password(&c);
+                                                            if let Err(e) = result {
+                                                                tasks.push(Task::done(crate::Message::Error(
+                                                                    crate::Error::CredentialsSave(e.into()),
+                                                                )));
+                                                            }
+                                                        }
+                                                        Err(e) => tasks.push(Task::done(
+                                                            crate::Message::Error(
+                                                                crate::Error::CredentialsSave(
+                                                                    e.into(),
+                                                                ),
+                                                            ),
+                                                        )),
+                                                    }
+                                                }
+                                                Err(e) => {
+                                                    tasks.push(Task::done(crate::Message::Error(
+                                                        crate::Error::CredentialsSave(e.into()),
+                                                    )))
+                                                }
+                                            }
+                                        }
+                                        tasks
                                     }
                                     Err(_e) => {
                                         tracing::error!("error (database probably)");