move views around

gamercade_app/src/app.rs

@@ -1,106 +1,18 @@
-use eframe::egui::{self, TextEdit, Ui};
+use eframe::egui::{self};
 
-use crate::auth::AuthClient;
+use crate::{auth::AuthClient, view::ActiveView};
 
 #[derive(Default)]
 pub struct App {
     auth_client: AuthClient,
 
-    username: String,
-    password: String,
-    email: String,
-
     active_view: ActiveView,
 }
 
-#[derive(Default)]
-enum ActiveView {
-    #[default]
-    Login,
-    SignUp,
-    Browsing,
-}
-
 impl eframe::App for App {
     fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
         egui::CentralPanel::default().show(ctx, |ui| {
-            match self.active_view {
-                ActiveView::Login => self.draw_login(ui),
-                ActiveView::SignUp => self.draw_sign_up(ui),
-                ActiveView::Browsing => self.draw_browsing(ui),
-            };
-        });
-    }
-}
-
-impl App {
-    fn draw_login(&mut self, ui: &mut Ui) {
-        ui.horizontal(|ui| {
-            ui.label("Username: ");
-            ui.text_edit_singleline(&mut self.username);
-        });
-
-        ui.horizontal(|ui| {
-            ui.label("Password: ");
-            let pw_entry = TextEdit::singleline(&mut self.password).password(true);
-            ui.add(pw_entry);
-        });
-
-        if ui.button("Sign Up").clicked() {
-            self.active_view = ActiveView::SignUp;
-        }
-
-        if ui.button("Login").clicked() {
-            self.auth_client.try_login(&self.username, &self.password);
-            //TODO: Lock entries while waiting
-            //TODO: Show an animation thing
-            self.clear_text();
-        }
-
-        if ui.button("Login as Guest").clicked() {
-            println!("TODO: Login as guest!")
-        }
-    }
-
-    fn draw_sign_up(&mut self, ui: &mut Ui) {
-        ui.horizontal(|ui| {
-            ui.label("Username: ");
-            ui.text_edit_singleline(&mut self.username);
-        });
-
-        ui.horizontal(|ui| {
-            ui.label("Email Address: ");
-            let email = TextEdit::singleline(&mut self.email);
-            ui.add(email);
-        });
-
-        ui.horizontal(|ui| {
-            ui.label("Password: ");
-            let pw_entry = TextEdit::singleline(&mut self.password).password(true);
-            ui.add(pw_entry);
+            self.active_view.draw(ui, &mut self.auth_client);
         });
-
-        if ui.button("Register").clicked() {
-            self.auth_client
-                .try_register(&self.username, &self.email, &self.password);
-            // TODO: Lock the entries while waiting...
-            // TODO: Show an animation thing...
-            self.clear_text();
-        }
-
-        if ui.button("Cancel").clicked() {
-            self.clear_text();
-            self.active_view = ActiveView::Login;
-        }
-    }
-
-    fn draw_browsing(&mut self, ui: &mut Ui) {
-        ui.label("Browsing");
-    }
-
-    fn clear_text(&mut self) {
-        self.username.clear();
-        self.email.clear();
-        self.password.clear();
     }
 }

gamercade_app/src/auth/auth_client.rs

@@ -1,19 +1,19 @@
 use std::sync::Arc;
 
-use gamercade_interface::auth::{
-    auth_service_client::AuthServiceClient, login_request::Provider, LoginRequest,
-    RefreshTokenRequest, SignUpRequest,
-};
-use tokio::{
-    select,
-    sync::{
-        mpsc::{channel, Receiver, Sender},
-        RwLock,
+use gamercade_interface::{
+    auth::{
+        auth_service_client::AuthServiceClient, login_request::Provider, LoginRequest,
+        SignUpRequest,
     },
+    Session,
+};
+use tokio::sync::{
+    mpsc::{channel, Receiver, Sender},
+    RwLock,
 };
 use tonic::transport::Channel;
 
-use crate::{auth::auth_state::AuthToken, ips::AUTH_IP};
+use crate::ips::AUTH_IP;
 
 use super::auth_state::AuthState;
 
@@ -25,7 +25,6 @@ pub struct AuthClient {
 pub enum AuthClientRequest {
     Login(LoginRequest),
     SignUp(SignUpRequest),
-    RefreshToken(RefreshTokenRequest),
 }
 
 impl Default for AuthClient {
@@ -87,21 +86,18 @@ impl AuthTask {
         }
     }
 
-    async fn run(mut self) -> ! {
+    async fn run(mut self) {
         let mut client = AuthServiceClient::connect(AUTH_IP).await.unwrap();
 
-        loop {
-            select! {
-                // Handle Requests
-                Some(request) = self.main_thread_receiver.recv() => {
-                    match request {
-                        AuthClientRequest::Login(login) => self.handle_login(&mut client, login).await,
-                        AuthClientRequest::SignUp(signup) => self.handle_sign_up(&mut client, signup).await,
-                        AuthClientRequest::RefreshToken(refresh) => self.handle_refresh(&mut client, refresh).await,
-                    }
-                }
+        // Handle Requests
+        while let Some(request) = self.main_thread_receiver.recv().await {
+            match request {
+                AuthClientRequest::Login(login) => self.handle_login(&mut client, login).await,
+                AuthClientRequest::SignUp(signup) => self.handle_sign_up(&mut client, signup).await,
             }
         }
+
+        println!("auth_client died.");
     }
 
     async fn handle_login(
@@ -113,14 +109,16 @@ impl AuthTask {
         match client.login(request).await {
             Ok(response) => {
                 let response = response.into_inner();
-                let mut write = self.auth_state.write().await;
-                *write = AuthState::TokensHeld(AuthToken {
-                    access_token: response.access_token,
-                    refresh_token: response.refresh_token,
-                    expires_at: response.expires_at,
-                });
-                // TODO: Update the login page / move to browsing
-                println!("Logged in successfully: {:?}", write);
+
+                if let Ok(session) = Session::try_from(response.session.as_slice()) {
+                    let mut write = self.auth_state.write().await;
+                    *write = AuthState::SessionHeld(session);
+                    println!("Logged in successfully: {:?}", write);
+                    // TODO: Update the login page / move to browsing
+                } else {
+                    println!("Error parsing session from server")
+                    // TODO: Handle this
+                }
             }
             Err(e) => {
                 println!("{e}");
@@ -145,12 +143,4 @@ impl AuthTask {
             }
         }
     }
-
-    async fn handle_refresh(
-        &mut self,
-        _client: &mut AuthServiceClient<Channel>,
-        _request: RefreshTokenRequest,
-    ) {
-        todo!()
-    }
 }

gamercade_app/src/auth/auth_state.rs

@@ -1,16 +1,11 @@
+use gamercade_interface::Session;
+
 #[derive(Default, Debug)]
 pub enum AuthState {
     // Default State
     #[default]
     Unauthorized,
 
-    // Holding Tokens
-    TokensHeld(AuthToken),
-}
-
-#[derive(Debug)]
-pub struct AuthToken {
-    pub access_token: String,
-    pub refresh_token: String,
-    pub expires_at: u64,
+    // Holding Session
+    SessionHeld(Session),
 }

gamercade_app/src/main.rs

@@ -3,6 +3,7 @@ use eframe::egui;
 mod app;
 mod auth;
 mod ips;
+mod view;
 
 #[tokio::main]
 async fn main() -> Result<(), eframe::Error> {

gamercade_app/src/view/browsing.rs

@@ -0,0 +1,14 @@
+use eframe::egui::Ui;
+
+use super::ActiveView;
+
+#[derive(Default)]
+pub struct BrowsingView {}
+
+impl BrowsingView {
+    pub fn draw(&mut self, ui: &mut Ui) -> Option<ActiveView> {
+        ui.label("Browsing");
+
+        None
+    }
+}

gamercade_app/src/view/login.rs

@@ -0,0 +1,55 @@
+use eframe::egui::{TextEdit, Ui};
+
+use crate::auth::AuthClient;
+
+use super::ActiveView;
+
+#[derive(Default)]
+pub struct LoginView {
+    provider: String,
+    provider_kind: Provider,
+    password: String,
+}
+
+#[derive(Default)]
+enum Provider {
+    #[default]
+    Username,
+    Email,
+}
+
+impl LoginView {
+    pub fn draw(&mut self, ui: &mut Ui, auth_client: &AuthClient) -> Option<ActiveView> {
+        ui.horizontal(|ui| {
+            let text = match self.provider_kind {
+                Provider::Username => "Username: ",
+                Provider::Email => "Email: ",
+            };
+            ui.label(text);
+            ui.text_edit_singleline(&mut self.provider);
+        });
+
+        ui.horizontal(|ui| {
+            ui.label("Password: ");
+            let pw_entry = TextEdit::singleline(&mut self.password).password(true);
+            ui.add(pw_entry);
+        });
+
+        if ui.button("Sign Up").clicked() {
+            return Some(ActiveView::sign_up());
+        }
+
+        if ui.button("Login").clicked() {
+            // TODO: Support email login too
+            auth_client.try_login(&self.provider, &self.password);
+            //TODO: Lock entries while waiting
+            //TODO: Show an animation thing
+        }
+
+        if ui.button("Login as Guest").clicked() {
+            println!("TODO: Login as guest!")
+        }
+
+        None
+    }
+}

gamercade_app/src/view/mod.rs

@@ -0,0 +1,45 @@
+use eframe::egui::Ui;
+
+use crate::auth::AuthClient;
+
+use self::{browsing::BrowsingView, login::LoginView, sign_up::SignUpView};
+
+mod browsing;
+mod login;
+mod sign_up;
+
+pub enum ActiveView {
+    Login(LoginView),
+    SignUp(SignUpView),
+    Browsing(BrowsingView),
+}
+
+impl Default for ActiveView {
+    fn default() -> Self {
+        Self::login()
+    }
+}
+
+impl ActiveView {
+    fn login() -> Self {
+        Self::Login(LoginView::default())
+    }
+
+    fn sign_up() -> Self {
+        Self::SignUp(SignUpView::default())
+    }
+
+    fn browsing() -> Self {
+        Self::Browsing(BrowsingView::default())
+    }
+
+    pub fn draw(&mut self, ui: &mut Ui, auth_client: &mut AuthClient) {
+        if let Some(next) = match self {
+            ActiveView::Login(view) => view.draw(ui, auth_client),
+            ActiveView::SignUp(view) => view.draw(ui, auth_client),
+            ActiveView::Browsing(view) => view.draw(ui),
+        } {
+            *self = next;
+        }
+    }
+}