feat: store user data in correct dir, or according to config

1 files changed, 4 insertions, 82 deletions

diff --git a/src/login_modal.rs b/src/login_modal.rs
index 02d878e..5a63158 100644
--- a/src/login_modal.rs
+++ b/src/login_modal.rs
@@ -34,16 +34,16 @@ pub enum Message {
 
 #[derive(Debug, Clone)]
 pub enum Error {
-    InvalidJID(String),
-    DatabaseConnection,
+    InvalidJID,
 }
 
 pub enum Action {
     None,
     ClientCreated(Task<crate::Message>),
+    CreateClient(String, String, bool),
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Clone)]
 pub struct Creds {
     pub jid: String,
     pub password: String,
@@ -69,85 +69,7 @@ impl LoginModal {
                 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();
-                        match jid {
-                            Ok(j) => {
-                                let result =
-                                    LuzHandle::new(j.clone(), password.to_string(), "macaw.db")
-                                        .await;
-                                match result {
-                                    Ok((luz_handle, receiver)) => {
-                                        let mut tasks = Vec::new();
-                                        tasks.push(Task::done(crate::Message::ClientCreated(
-                                            Client {
-                                                client: luz_handle,
-                                                jid: j,
-                                                connection_status: Presence::Offline(
-                                                    Offline::default(),
-                                                ),
-                                            },
-                                        )));
-                                        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)");
-                                        return vec![Task::done(crate::Message::LoginModal(
-                                            Message::Error(Error::DatabaseConnection),
-                                        ))];
-                                    }
-                                }
-                            }
-                            Err(_) => {
-                                tracing::error!("parsing jid");
-                                return vec![Task::done(crate::Message::LoginModal(
-                                    Message::Error(Error::InvalidJID(jid_str.to_string())),
-                                ))];
-                            }
-                        }
-                    })
-                    .then(|tasks| Task::batch(tasks)),
-                )
+                Action::CreateClient(jid_str, password, remember_me)
             }
             Message::Error(error) => {
                 self.error = Some(error);