move login modal to separate module

1 files changed, 147 insertions, 0 deletions

diff --git a/src/login_modal.rs b/src/login_modal.rs
new file mode 100644
index 0000000..f4e556e
--- /dev/null
+++ b/src/login_modal.rs
@@ -0,0 +1,147 @@
+use iced::{
+    futures::StreamExt,
+    widget::{button, checkbox, column, container, text, text_input},
+    Element, Task,
+};
+use jid::JID;
+use luz::{
+    presence::{Offline, Presence},
+    LuzHandle,
+};
+use tokio_stream::wrappers::ReceiverStream;
+use tracing::info;
+
+use crate::Client;
+
+#[derive(Default)]
+pub struct LoginModal {
+    jid: String,
+    password: String,
+    remember_me: bool,
+    error: Option<Error>,
+}
+
+#[derive(Debug, Clone)]
+pub enum Message {
+    JID(String),
+    Password(String),
+    RememberMe,
+    Submit,
+    Error(Error),
+}
+
+#[derive(Debug, Clone)]
+pub enum Error {
+    InvalidJID(String),
+    DatabaseConnection,
+}
+
+pub enum Action {
+    None,
+    ClientCreated(Task<crate::Message>),
+}
+
+impl LoginModal {
+    pub fn update(&mut self, message: Message) -> Action {
+        match message {
+            Message::JID(j) => {
+                self.jid = j;
+                Action::None
+            }
+            Message::Password(p) => {
+                self.password = p;
+                Action::None
+            }
+            Message::RememberMe => {
+                self.remember_me = !self.remember_me;
+                Action::None
+            }
+            Message::Submit => {
+                info!("submitting login");
+                let jid_str = self.jid.clone();
+                let password = self.password.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 stream = ReceiverStream::new(receiver);
+                                        let stream =
+                                            stream.map(|message| crate::Message::Luz(message));
+                                        vec![
+                                            Task::done(crate::Message::ClientCreated(Client {
+                                                client: luz_handle,
+                                                jid: j,
+                                                connection_status: Presence::Offline(
+                                                    Offline::default(),
+                                                ),
+                                            })),
+                                            Task::stream(stream),
+                                        ]
+                                    }
+                                    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)),
+                )
+            }
+            Message::Error(error) => {
+                self.error = Some(error);
+                Action::None
+            }
+        }
+    }
+
+    pub fn view(&self) -> Element<Message> {
+        container(
+            column![
+                text("Log In").size(24),
+                column![
+                    column![
+                        text("JID").size(12),
+                        text_input("berry@macaw.chat", &self.jid)
+                            .on_input(|j| Message::JID(j))
+                            .on_submit(Message::Submit)
+                            .padding(5),
+                    ]
+                    .spacing(5),
+                    column![
+                        text("Password").size(12),
+                        text_input("", &self.password)
+                            .on_input(|p| Message::Password(p))
+                            .on_submit(Message::Submit)
+                            .secure(true)
+                            .padding(5),
+                    ]
+                    .spacing(5),
+                    checkbox("remember me", self.remember_me).on_toggle(|_| Message::RememberMe),
+                    button(text("Submit")).on_press(Message::Submit),
+                ]
+                .spacing(10)
+            ]
+            .spacing(20),
+        )
+        .width(300)
+        .padding(10)
+        .style(container::rounded_box)
+        .into()
+    }
+}