Add support for logging in to an account

src/api/auth.rs

@@ -1,10 +1,10 @@
-use lemmy_api_common::{person::{LoginResponse, Login}, sensitive::Sensitive};
+use lemmy_api_common::{person::Login, sensitive::Sensitive};
 
-pub fn login(username_or_email: String, password: String) -> std::result::Result<LoginResponse, reqwest::Error> {
+pub fn login(username_or_email: String, password: String) -> std::result::Result<lemmy_api_common::person::LoginResponse, reqwest::Error> {
     let params = Login {
         username_or_email: Sensitive::new(username_or_email),
         password: Sensitive::new(password)
     };
 
-    super::get("/user/login", &params)
+    super::post("/user/login", &params)
 }

src/api/mod.rs

@@ -38,3 +38,15 @@ where
         .send()?
         .json()
 }
+
+fn post<T, Params>(path: &str, params: &Params) -> Result<T, reqwest::Error>
+where
+    T: DeserializeOwned,
+    Params: Serialize + std::fmt::Debug,
+{
+    CLIENT
+        .post(&get_url(path))
+        .json(&params)
+        .send()?
+        .json()
+}

src/main.rs

@@ -19,11 +19,15 @@ enum AppState {
     Communities,
     Community,
     Person,
-    Post
+    Post,
+    Login,
+    Message
 }
 
 struct App {
     state: AppState,
+    message: Option<String>,
+    latest_action: Option<AppMsg>,
     posts: FactoryVecDeque<PostRow>,
     communities: FactoryVecDeque<CommunityRow>,
     profile_page: Controller<ProfilePage>,
@@ -31,13 +35,18 @@ struct App {
     post_page: Controller<PostPage>
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum AppMsg {
     ChooseInstance,
+    ShowLogin,
+    Login(String, String),
+    Logout,
+    Retry,
+    ShowMessage(String),
     DoneChoosingInstance(String),
     StartFetchPosts,
-    DoneFetchPosts(Result<Vec<PostView>, reqwest::Error>),
+    DoneFetchPosts(Vec<PostView>),
-    DoneFetchCommunities(Result<Vec<CommunityView>, reqwest::Error>),
+    DoneFetchCommunities(Vec<CommunityView>),
     ViewCommunities(Option<String>),
     OpenCommunity(String),
     DoneFetchCommunity(GetCommunityResponse),
@@ -75,7 +84,6 @@ impl SimpleComponent for App {
                 },
             },
 
-            #[name(stack)]
             match model.state {
                 AppState::Posts => gtk::ScrolledWindow {
                     set_vexpand: true,
@@ -118,12 +126,54 @@ impl SimpleComponent for App {
                     gtk::Button {
                         set_label: "Done",
                         connect_clicked[sender, instance_url] => move |_| {
-                            let text = instance_url.buffer().text().as_str().to_string();
+                            let text = instance_url.text().as_str().to_string();
-                            instance_url.buffer().set_text("");
+                            instance_url.set_text("");
                             sender.input(AppMsg::DoneChoosingInstance(text));
                         },
                     }
                 },
+                AppState::Login => gtk::Box {
+                    set_hexpand: true,
+                    set_orientation: gtk::Orientation::Vertical,
+                    set_spacing: 12,
+                    set_margin_all: 20,
+                    set_valign: gtk::Align::Center,
+                    set_hexpand: true,
+
+                    gtk::Label {
+                        set_text: "Login",
+                        add_css_class: "font-bold",
+                    },
+                    #[name(username)]
+                    gtk::Entry {
+                        set_placeholder_text: Some("Username or E-Mail"),
+                    },
+                    #[name(password)]
+                    gtk::PasswordEntry {
+                        set_placeholder_text: Some("Password"),
+                        set_show_peek_icon: true,
+                    },
+                    gtk::Box {
+                        set_orientation: gtk::Orientation::Horizontal,
+                        set_halign: gtk::Align::End,
+
+                        gtk::Button {
+                            set_label: "Cancel",
+                            connect_clicked => AppMsg::StartFetchPosts,
+                            set_margin_end: 10,
+                        },
+                        gtk::Button {
+                            set_label: "Login",
+                            connect_clicked[sender, username, password] => move |_| {
+                                let username_text = username.text().as_str().to_string();
+                                username.set_text("");
+                                let password_text = password.text().as_str().to_string();
+                                password.set_text("");
+                                sender.input(AppMsg::Login(username_text, password_text));
+                            },
+                        },
+                    }
+                },
                 AppState::Communities => gtk::Box {
                     gtk::ScrolledWindow {
                         set_vexpand: true,
@@ -145,7 +195,7 @@ impl SimpleComponent for App {
                                 gtk::Button {
                                     set_label: "Search",
                                     connect_clicked[sender, community_search_query] => move |_| {
-                                        let text = community_search_query.buffer().text().as_str().to_string();
+                                        let text = community_search_query.text().as_str().to_string();
                                         sender.input(AppMsg::ViewCommunities(Some(text)));
                                     },
                                 }
@@ -177,13 +227,30 @@ impl SimpleComponent for App {
                         post_page -> gtk::ScrolledWindow {}
                     }
                 }
+                AppState::Message => {
+                    gtk::Box {
+                        set_orientation: gtk::Orientation::Vertical,
+                        set_margin_all: 40,
+
+                        gtk::Label {
+                            #[watch]
+                            set_text: &model.message.clone().unwrap_or("".to_string()),
+                        },
+                        gtk::Button {
+                            set_label: "Go Home",
+                            connect_clicked => AppMsg::Retry,
+                        }
+                    }
+                }
             }
         }
     }
 
     menu! {
         menu_model: {
-            "Choose Instance" => ChangeInstanceAction
+            "Choose Instance" => ChangeInstanceAction,
+            "Login" => LoginAction,
+            "Logout" => LogoutAction
         }
     }
 
@@ -203,7 +270,7 @@ impl SimpleComponent for App {
         let community_page = CommunityPage::builder().launch(default_community()).forward(sender.input_sender(), |msg| msg);
         let post_page = PostPage::builder().launch(default_post()).forward(sender.input_sender(), |msg| msg);
         
-        let model = App { state, posts, communities, profile_page, community_page, post_page };
+        let model = App { state, posts, communities, profile_page, community_page, post_page, message: None, latest_action: None };
 
         // fetch posts if that's the initial page
         if !instance_url.is_empty() { sender.input(AppMsg::StartFetchPosts) };
@@ -217,13 +284,23 @@ impl SimpleComponent for App {
         
         let widgets = view_output!();
 
-        // create the menu and its actions
+        // create the header bar menu and its actions
+        let instance_sender = sender.clone();
         let instance_action: RelmAction<ChangeInstanceAction> = RelmAction::new_stateless(move |_| {
+            instance_sender.input(AppMsg::ChooseInstance);
+        });
+        let login_sender = sender.clone();
+        let login_action: RelmAction<LoginAction> = RelmAction::new_stateless(move |_| {
+            login_sender.input(AppMsg::ShowLogin);
+        });
+        let logout_action: RelmAction<LogoutAction> = RelmAction::new_stateless(move |_| {
             sender.input(AppMsg::ChooseInstance);
         });
 
         let mut group = RelmActionGroup::<WindowActionGroup>::new();
         group.add_action(instance_action);
+        group.add_action(login_action);
+        group.add_action(logout_action);
         group.register_for_widget(&widgets.main_window);
 
         ComponentParts { model, widgets }
@@ -244,43 +321,46 @@ impl SimpleComponent for App {
             }
             AppMsg::StartFetchPosts => {
                 std::thread::spawn(move || {
-                    let posts = api::posts::list_posts(1, None);
+                    let message = match api::posts::list_posts(1, None) {
-                    sender.input(AppMsg::DoneFetchPosts(posts));
+                        Ok(posts) => AppMsg::DoneFetchPosts(posts),
+                        Err(err) => AppMsg::ShowMessage(err.to_string())
+                    };
+                    sender.input(message);
                 });
             }
             AppMsg::DoneFetchPosts(posts) => {
                 self.state = AppState::Posts;
-                if let Ok(posts) = posts {
                 self.posts.guard().clear();
                 for post in posts {
                     self.posts.guard().push_back(post);
                 }
             }
-            }
             AppMsg::ViewCommunities(query) => {
                 self.state = AppState::Communities;
                 if (query.is_none() || query.clone().unwrap().trim().is_empty()) && !self.communities.is_empty() { return; }
                 std::thread::spawn(move || {
-                    let communities = api::communities::fetch_communities(1, query);
+                    let message = match api::communities::fetch_communities(1, query) {
-                    sender.input(AppMsg::DoneFetchCommunities(communities));
+                        Ok(communities) => AppMsg::DoneFetchCommunities(communities),
+                        Err(err) => AppMsg::ShowMessage(err.to_string())
+                    };
+                    sender.input(message);
                 });
             }
             AppMsg::DoneFetchCommunities(communities) => {
                 self.state = AppState::Communities;
-                if let Ok(communities) = communities {
                 self.communities.guard().clear();
                 for community in communities {
                     self.communities.guard().push_back(community);
                 }
             }
-            }
             AppMsg::OpenPerson(person_name) => {
                 self.state = AppState::Loading;
                 std::thread::spawn(move || {
-                    let person = api::user::get_user(person_name, 1);
+                    let message = match api::user::get_user(person_name, 1) {
-                    if let Ok(person) = person {
+                        Ok(person) => AppMsg::DoneFetchPerson(person),
-                        sender.input(AppMsg::DoneFetchPerson(person));
+                        Err(err) => AppMsg::ShowMessage(err.to_string())
-                    }
+                    };
+                    sender.input(message);
                 });
             }
             AppMsg::DoneFetchPerson(person) => {
@@ -290,10 +370,11 @@ impl SimpleComponent for App {
             AppMsg::OpenCommunity(community_name) => {
                 self.state = AppState::Loading;
                 std::thread::spawn(move || {
-                    let community = api::community::get_community(community_name);
+                    let message = match api::community::get_community(community_name) {
-                    if let Ok(community) = community {
+                        Ok(community) => AppMsg::DoneFetchCommunity(community),
-                        sender.input(AppMsg::DoneFetchCommunity(community));
+                        Err(err) => AppMsg::ShowMessage(err.to_string())
-                    }
+                    };
+                    sender.input(message);
                 });
             }
             AppMsg::DoneFetchCommunity(community) => {
@@ -303,22 +384,55 @@ impl SimpleComponent for App {
             AppMsg::OpenPost(post_id) => {
                 self.state = AppState::Loading;
                 std::thread::spawn(move || {
-                    let post = api::post::get_post(post_id);
+                    let message = match api::post::get_post(post_id) {
-                    if let Ok(post) = post {
+                        Ok(post) => AppMsg::DoneFetchPost(post),
-                        sender.input(AppMsg::DoneFetchPost(post));
+                        Err(err) => AppMsg::ShowMessage(err.to_string())
-                    }
+                    };
+                    sender.input(message);
                 });
             }
             AppMsg::DoneFetchPost(post) => {
                 self.post_page.sender().emit(post_page::PostInput::UpdatePost(post));
                 self.state = AppState::Post;
             }
+            AppMsg::ShowLogin => {
+                self.state = AppState::Login;
+            }
+            AppMsg::Login(username, password) => {
+                self.state = AppState::Loading;
+                std::thread::spawn(move || {
+                    let message = match api::auth::login(username, password) {
+                        Ok(login) => {
+                            if let Some(token) = login.jwt {
+                                util::set_auth_token(Some(token));
+                                AppMsg::StartFetchPosts
+                            } else {
+                                AppMsg::ShowMessage("Wrong credentials!".to_string())
+                            }
+                        }
+                        Err(err) => AppMsg::ShowMessage(err.to_string())
+                    };
+                    sender.input(message);
+                });
+            }
+            AppMsg::Logout => {
+                util::set_auth_token(None);
+            }
+            AppMsg::ShowMessage(message) => {
+                self.message = Some(message);
+                self.state = AppState::Message;
+            }
+            AppMsg::Retry => {
+                sender.input(self.latest_action.clone().unwrap_or(AppMsg::StartFetchPosts));
+            }
         }
     }
 }
 
 relm4::new_action_group!(WindowActionGroup, "win");
 relm4::new_stateless_action!(ChangeInstanceAction, WindowActionGroup, "instance");
+relm4::new_stateless_action!(LoginAction, WindowActionGroup, "login");
+relm4::new_stateless_action!(LogoutAction, WindowActionGroup, "logout");
 
 fn main() {
     let app = RelmApp::new(APP_ID);

src/settings.rs

@@ -1,11 +1,13 @@
 use std::{fs::File, path::PathBuf};
 use crate::gtk::glib;
+use lemmy_api_common::sensitive::Sensitive;
 use serde::{Deserialize, Serialize};
 use crate::APP_ID;
 
 #[derive(Deserialize, Serialize, Default)]
 pub struct Preferences {
     pub instance_url: String,
+    pub jwt: Option<Sensitive<String>>
 }
 
 pub fn data_path() -> PathBuf {

src/util.rs

@@ -1,6 +1,8 @@
-use lemmy_api_common::lemmy_db_schema::newtypes::DbUrl;
+use lemmy_api_common::{lemmy_db_schema::newtypes::DbUrl, sensitive::Sensitive};
 use relm4_components::web_image::WebImageMsg;
 
+use crate::settings;
+
 pub fn get_web_image_msg(url: Option<DbUrl>) -> WebImageMsg  {
     return if let Some(url) = url {
         WebImageMsg::LoadImage(url.to_string())
@@ -16,3 +18,13 @@ pub fn get_web_image_url(url: Option<DbUrl>) -> String {
 pub fn markdown_to_pango_markup(text: String) -> String {
     return html2pango::markup_html(&markdown::to_html(&text)).unwrap_or(text)
 }
+
+pub fn set_auth_token(token: Option<Sensitive<String>>) {
+    let mut settings = settings::get_prefs();
+    settings.jwt = token.clone();
+    settings::save_prefs(&settings);
+}
+
+pub fn get_auth_token() -> Option<Sensitive<String>> {
+    settings::get_prefs().jwt
+}