Refactor oauth into its own module

1 files changed, 72 insertions, 130 deletions

diff --git a/app/src/lib.rs b/app/src/lib.rs
index ae80c24..8ad149f 100644
--- a/app/src/lib.rs
+++ b/app/src/lib.rs
@@ -1,17 +1,18 @@
-mod state;
-use state::AppState;
+mod oauth;
+use oauth::OAuthController;
 
 use tauri_plugin_deep_link::DeepLinkExt;
 use tauri_plugin_opener::OpenerExt;
 
-use std::collections::HashMap;
 use tauri::{Manager, State, AppHandle};
 use url::Host;
-use serde::Deserialize;
-use tokio::sync::Mutex;
-use tokio::sync::mpsc::channel;
+use uuid::Uuid;
 
-const OAUTH_CLIENT_NAME: &'static str = "foxfleet_test";
+pub const OAUTH_CLIENT_NAME: &'static str = "foxfleet_test";
+
+struct AppState {
+    oauth_controller: OAuthController
+}
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
@@ -22,7 +23,9 @@ pub fn run() {
         .plugin(tauri_plugin_deep_link::init())
         .plugin(tauri_plugin_opener::init())
         .setup(|app| {
-            app.manage(Mutex::new(state::AppState::default()));
+            app.manage(AppState {
+                oauth_controller: OAuthController::new()
+            });
 
             #[cfg(any(target_os = "linux", all(debug_assertions, windows)))]
             app.deep_link().register_all()?;
@@ -30,31 +33,37 @@ pub fn run() {
             app.deep_link().on_open_url(move |event| {
                 if let Some(oauth_callback) = event.urls().iter().find(|url| {
                     if let Some(Host::Domain(domain)) = url.host() {
-                        if domain == "oauth-response" {
-                            return true;
-                        }
+                        domain == "oauth-response"
+                    } else {
+                        false
                     }
-                    false
                 }) {
                     let mut query = oauth_callback.query_pairs();
-                    if let Some(code) = query.find(|(key, _value)| key == "code") {
-                        let app_handle = app_handle.clone();
-                        let code = code.1.to_string();
-                        tauri::async_runtime::spawn(async move {
-                            let app_state = app_handle.state::<Mutex<AppState>>();
-                            app_state.lock().await.accounts.iter_mut().for_each(|account| {
-                                // TODO: handle if there's multiple of these that match
-                                if let state::ApiCredential::Pending(sender) = &account.api_credential {
-                                    let sender = sender.clone();
-                                    let code = code.clone();
-                                    tauri::async_runtime::spawn(async move {
-                                        let _ = sender.send(state::AuthCode(code)).await;
-                                    });
-                                }
+                    let query = (
+                        query.find(|(key, _)| key == "code").map(|(_, value)| value ),
+                        query.find(|(key, _)| key == "state").map(|(_, value)| value )
+                    );
+                    let query = match query {
+                        (Some(code), Some(state)) => Some((code, state)),
+                        _ => None,
+                    };
+
+                    if let Some((auth_code, state)) = query {
+                        if let Ok(state) = Uuid::try_parse(&state) {
+                            let state = state.clone();
+                            let auth_code = auth_code.to_string().clone();
+                            let app_handle = app_handle.clone();
+                            let oauth_controller = app_handle.state::<AppState>().oauth_controller.clone();
+
+                            tauri::async_runtime::spawn(async move {
+                                oauth_controller.resolve_code(state, auth_code);
                             });
-                        });
+                        } else {
+                            println!("Invalid UUID format: {state}");
+                            return
+                        }
                     } else {
-                        println!("No code in oauth callback");
+                        println!("Missing either state or code in oauth callback");
                         return
                     }
                 }
@@ -66,118 +75,53 @@ pub fn run() {
         .expect("Error starting")
 }
 
-#[derive(Deserialize)]
-struct RegistrationResponse {
-    id: String,
-    name: String,
-    client_id: String,
-    client_secret: String,
-}
-
-#[derive(Deserialize)]
-struct TokenResponse {
-    access_token: String,
-    created_at: u32,
-    scope: String,
-    token_type: String,
-}
 
 #[tauri::command]
-async fn start_account_auth(app_handle: AppHandle, state: State<'_, Mutex<AppState>>, instance_domain: &str) -> Result<(), ()> {
-    println!("Starting account auth");
-    let registration_endpoint = format!("https://{instance_domain}/api/v1/apps");
-    let token_endpoint = format!("https://{instance_domain}/oauth/token");
-    let client = reqwest::Client::builder().user_agent("Foxfleet v0.0.1").build().expect("Could not construct client");
-    println!("Registering client");
-    let registration_response : RegistrationResponse = client.post(registration_endpoint)
-        .json(&HashMap::from([
-            ("client_name", OAUTH_CLIENT_NAME),
-            ("redirect_uris", "dev.tempest.foxfleet://oauth-response"),
-            ("scopes", "read write"),
-        ])).send().await.expect("Could not send client registration")
-        .json().await.expect("Could not parse client registration response");
-
-    // Make channel for awaiting
-    let (sender, mut receiver) = channel::<state::AuthCode>(1);
-
-    println!("Saving registration");
-    { state.lock().await.accounts.push(state::Account {
-        server_domain: instance_domain.to_string(),
-        handle_domain: None,
-        client_credential: state::ClientCredential {
-            client_name: OAUTH_CLIENT_NAME.to_string(),
-            client_id: registration_response.client_id.clone(),
-            client_secret: Some(registration_response.client_secret.clone()),
-        },
-        api_credential: state::ApiCredential::Pending(sender),
-    }) }
-
-    // Open browser to auth page
-    println!("Opening authentication page");
-    let client_id = registration_response.client_id.clone();
-    let auth_page = format!("https://{instance_domain}/oauth/authorize?client_id={client_id}&redirect_uri=dev.tempest.foxfleet://oauth-response&response_type=code&scope=read+write");
-    let opener = app_handle.opener();
-    if let Err(_) = opener.open_url(auth_page, None::<&str>) {
-        println!("Could not open authentication page");
-        return Err(())
-    }
-
-
-    // Wait for resolution of the credential
-    let auth_code = receiver.recv().await;
-
-    if auth_code.is_none() {
-        return Err(())
-    }
-
-    let auth_code = auth_code.unwrap();
-    println!("Exchanging auth code for API token");
-
-    // Get long-lived credential
-    let token_response : TokenResponse = client.post(token_endpoint)
-        .json(&HashMap::from([
-            ("redirect_uri", "dev.tempest.foxfleet://oauth-response"),
-            ("client_id", registration_response.client_id.as_str()),
-            ("client_secret", registration_response.client_secret.as_str()),
-            ("grant_type", "authorization_code"),
-            ("code", auth_code.0.as_str()),
-        ])).send().await.expect("Could not get API token")
-        .json().await.expect("Could not parse client registration response");
-
-    println!("Successfully exchanged for credential");
-
-    // Save credential
-    { state.lock().await.accounts.iter_mut().for_each(|account| {
-        if account.server_domain == instance_domain {
-            account.api_credential = state::ApiCredential::Some {
-                token: token_response.access_token.clone(),
-                refresh: None,
+async fn start_account_auth(app_handle: AppHandle, state: State<'_, AppState>, instance_domain: &str) -> Result<Vec<String>, ()> {
+    let add_result = state.oauth_controller.add_server(instance_domain).await;
+
+    let state_nonce = match add_result {
+        Ok(result) => {
+            let opener = app_handle.opener();
+            if let Err(_) = opener.open_url(result.auth_url, None::<&str>) {
+                println!("Could not open authentication page");
+                return Err(())
             }
-        }
-    }) };
 
-    println!("Saved credential");
+            result.auth_state
+        }
+        Err(err) => {
+            println!("Error adding server: {err}");
+            return Err(())
+        }
+    };
 
-    Ok(())
+    let signin_result = state.oauth_controller.finish_signin(state_nonce).await;
+    match signin_result {
+        Ok((server_domain, username)) => {
+            println!("Signed in successfully");
+            Ok(vec!(server_domain, username))
+        }
+        Err(err) => {
+            println!("Error completing signin: {err}");
+            Err(())
+        }
+    }
 }
 
 #[tauri::command]
-async fn get_self(state: State<'_, Mutex<AppState>>) -> Result<String, String> {
+async fn get_self(state: State<'_, AppState>, server_domain: String, username: String) -> Result<String, String> {
     let client = reqwest::Client::builder().user_agent("Foxfleet v0.0.1").build().expect("Could not construct client");
 
-    let accounts = { state.lock().await.accounts.clone() };
-    let account = accounts.iter().find(|account| {
-        if let state::ApiCredential::Some {token: _, refresh: _} = account.api_credential {
-            true
-        } else {
-            false
+    let api_key = state.oauth_controller.get_api_token(server_domain, username).await;
+    match api_key {
+        Err(err) => {
+            println!("Error getting API token: {err}");
+            return Err(err)
         }
-    });
-
-    if let Some(account) = account {
-        if let state::ApiCredential::Some {token, refresh: _} = &account.api_credential {
+        Ok(api_key) => {
             if let Ok(result) = client.get("https://social.tempest.dev/api/v1/accounts/verify_credentials")
-                .bearer_auth(token)
+                .bearer_auth(api_key)
                 .send().await {
                     if let Ok(result) = result.text().await {
                         return Ok(result)
@@ -189,6 +133,4 @@ async fn get_self(state: State<'_, Mutex<AppState>>) -> Result<String, String> {
                 }
         }
     }
-
-    return Err("No logged in account".to_string());
 }