Start database configuration

Cargo.lock

@@ -886,6 +886,7 @@ checksum = "1aab8fc367588b89dcee83ab0fd66b72b50b72fa1904d7095045ace2b0c81c35"
 name = "jean-marie"
 version = "0.1.0"
 dependencies = [
+ "anyhow",
  "askama",
  "async-session",
  "axum",

Cargo.toml

@@ -21,3 +21,4 @@ headers = "0.3"
 http = "0.2"
 tower-http = { version = "0.3.4", features = ["full"] }
 sqlx = { version = "0.6.2", features = ["runtime-tokio-rustls", "postgres", "macros", "migrate", "chrono", "json"]}
+anyhow = "1.0"

src/db.rs

@@ -0,0 +1,18 @@
+use sqlx::{PgPool};
+use anyhow::*;
+use sqlx::postgres::PgPoolOptions;
+ 
+#[derive(Clone)]
+pub struct DBApplication {
+    pool: PgPool
+}
+ 
+impl DBApplication {
+    pub async fn new(config: String) -> Result<DBApplication> {
+        let pool = PgPoolOptions::new()
+            .max_connections(5)
+            .connect(&config)
+            .await?;
+        Ok(DBApplication { pool })
+    }
+}

src/discord_oauth.rs

@@ -1,31 +1,15 @@
 use async_session::{MemoryStore, Session, SessionStore as _};
 use axum::{
-    async_trait,
+    extract::{Extension, Query},
-    extract::{
+    http::{header::HeaderMap, header::SET_COOKIE},
-        rejection::TypedHeaderRejectionReason, Extension, FromRequest, Query, RequestParts,
+    response::{IntoResponse, Redirect},
-        TypedHeader,
-    },
-    headers::Cookie,
-    http::{
-        self,
-        header::SET_COOKIE,
-        header::{HeaderMap, HeaderValue},
-        StatusCode
-    },
-    response::{Html, IntoResponse, Redirect, Response},
-    routing::{get, get_service},
-    Router, body::{BoxBody, boxed},
 };
-use http::{header};
 use oauth2::{
     basic::BasicClient, reqwest::async_http_client, AuthUrl, AuthorizationCode, ClientId,
-    PkceCodeChallenge, RedirectUrl, Scope, TokenUrl,
+    ClientSecret, CsrfToken, PkceCodeChallenge, RedirectUrl, Scope, TokenResponse, TokenUrl,
-    ClientSecret, TokenResponse, CsrfToken,
 };
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
-use std::{env, net::SocketAddr, collections::HashMap};
+use std::{collections::HashMap, env};
-use tower_http::services::ServeDir;
-use uuid::Uuid;
 
 use crate::User;
 use crate::COOKIE_NAME;
@@ -51,62 +35,63 @@ pub async fn discord_auth() -> impl IntoResponse {
 pub async fn discord_authorized(
     Query(query): Query<AuthRequest>,
     Extension(store): Extension<MemoryStore>,
-    Extension(oauth_clients): Extension<HashMap::<&str, BasicClient>>,
+    Extension(oauth_clients): Extension<HashMap<&str, BasicClient>>,
 ) -> impl IntoResponse {
     // Check for Discord client
     if oauth_clients.contains_key("Discord") {
-    // Get Discord client
+        // Get Discord client
-    let discord_oauth_client = oauth_clients.get(&"Discord").unwrap();
+        let discord_oauth_client = oauth_clients.get(&"Discord").unwrap();
 
-    // Get an auth token
+        // Get an auth token
-    let token = discord_oauth_client
+        let token = discord_oauth_client
-        .exchange_code(AuthorizationCode::new(query.code.clone()))
+            .exchange_code(AuthorizationCode::new(query.code.clone()))
-        .request_async(async_http_client)
+            .request_async(async_http_client)
-        .await
+            .await
-        .unwrap();
+            .unwrap();
 
-    // Fetch user data from discord
+        // Fetch user data from discord
-    let client = reqwest::Client::new();
+        let client = reqwest::Client::new();
-    let user_data: User = client
+        let user_data: User = client
-        // https://discord.com/developers/docs/resources/user#get-current-user
+            // https://discord.com/developers/docs/resources/user#get-current-user
-        .get("https://discordapp.com/api/users/@me")
+            .get("https://discordapp.com/api/users/@me")
-        .bearer_auth(token.access_token().secret())
+            .bearer_auth(token.access_token().secret())
-        .send()
+            .send()
-        .await
+            .await
-        .unwrap()
+            .unwrap()
-        .json::<User>()
+            .json::<User>()
-        .await
+            .await
-        .unwrap();
+            .unwrap();
 
-    // Create a new session filled with user data
+        // Create a new session filled with user data
-    let mut session = Session::new();
+        let mut session = Session::new();
-    session.insert("user", &user_data).unwrap();
+        session.insert("user", &user_data).unwrap();
 
-    // Store session and get corresponding cookie
+        // Store session and get corresponding cookie
-    let cookie = store.store_session(session).await.unwrap().unwrap();
+        let cookie = store.store_session(session).await.unwrap().unwrap();
 
-    // Build the cookie
+        // Build the cookie
-    let cookie = format!("{}={}; SameSite=Lax; Path=/", COOKIE_NAME, cookie);
+        let cookie = format!("{}={}; SameSite=Lax; Path=/", COOKIE_NAME, cookie);
 
-    // Set cookie
+        // Set cookie
-    let mut headers = HeaderMap::new();
+        let mut headers = HeaderMap::new();
-    headers.insert(SET_COOKIE, cookie.parse().unwrap());
+        headers.insert(SET_COOKIE, cookie.parse().unwrap());
 
-    (headers, Redirect::to(&"/dashboard"))
+        (headers, Redirect::to(&"/dashboard"))
     } else {
         let headers = HeaderMap::new();
-        
+
         (headers, Redirect::to(&"/"))
     }
 }
 
 pub fn discord_oauth_client() -> BasicClient {
     let redirect_url = env::var("REDIRECT_URL")
-        //.unwrap_or_else(|_| "http://localhost:40192/auth/discord".to_string());
+        .unwrap_or_else(|_| "http://localhost:40192/auth/discord".to_string());
-        .unwrap_or_else(|_| "https://www.jean-marie.ca/auth/discord".to_string());
+    // .unwrap_or_else(|_| "https://www.jean-marie.ca/auth/discord".to_string());
 
     let discord_client_id = env::var("DISCORD_CLIENT_ID").expect("Missing DISCORD_CLIENT_ID!");
-    let discord_client_secret = env::var("DISCORD_CLIENT_SECRET").expect("Missing DISCORD_CLIENT_SECRET!");
+    let discord_client_secret =
+        env::var("DISCORD_CLIENT_SECRET").expect("Missing DISCORD_CLIENT_SECRET!");
     let discord_auth_url = env::var("DISCORD_AUTH_URL").unwrap_or_else(|_| {
         "https://discord.com/api/oauth2/authorize?response_type=code".to_string()
     });

src/facebook_oauth.rs

@@ -1,34 +1,23 @@
-use async_session::{MemoryStore, Session, SessionStore as _};
+use async_session::{MemoryStore};
 use axum::{
-    async_trait,
     extract::{
-        rejection::TypedHeaderRejectionReason, Extension, FromRequest, Query, RequestParts,
+        Extension, Query
-        TypedHeader,
     },
-    headers::Cookie,
     http::{
-        self,
+        header::{HeaderMap}
-        header::SET_COOKIE,
-        header::{HeaderMap, HeaderValue},
-        StatusCode
     },
-    response::{Html, IntoResponse, Redirect, Response},
+    response::{IntoResponse, Redirect},
-    routing::{get, get_service},
-    Router, body::{BoxBody, boxed},
 };
-use http::{header};
 use oauth2::{
     basic::BasicClient, reqwest::async_http_client, AuthUrl, AuthorizationCode, ClientId,
     PkceCodeChallenge, RedirectUrl, Scope, TokenUrl,
     ClientSecret, TokenResponse, CsrfToken,
 };
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize};
-use std::{env, net::SocketAddr, collections::HashMap};
+use std::{env, collections::HashMap};
-use tower_http::services::ServeDir;
-use uuid::Uuid;
 
 use crate::User;
-use crate::COOKIE_NAME;
+// use crate::COOKIE_NAME;
 
 #[derive(Debug, Deserialize)]
 #[allow(dead_code)]
@@ -91,11 +80,14 @@ pub async fn facebook_authorized(
     
         // Fetch user data from facebook
         let client = reqwest::Client::new();
-        let user_data: = client
+        let user_data: User = client
             .get("https://graph.facebook.com/v15.0/dialog/oauth")
             .bearer_auth(token.access_token().secret())
             .send()
             .await
+            .unwrap()
+            .json::<User>()
+            .await
             .unwrap();
     
     //     // Create a new session filled with user data

src/google_oauth.rs

@@ -1,24 +1,17 @@
 use async_session::{MemoryStore, Session, SessionStore as _};
 use axum::{
-    extract::{
+    extract::{Extension, Query},
-        Extension, Query, 
+    http::header::{HeaderMap, SET_COOKIE},
-    },
-    http::{
-        self,
-        header::{SET_COOKIE, HeaderMap}
-    },
     response::{IntoResponse, Redirect},
 };
-use http::{header};
 use oauth2::{
     basic::BasicClient, reqwest::async_http_client, AuthUrl, AuthorizationCode, ClientId,
-    PkceCodeChallenge, RedirectUrl, Scope, TokenUrl,
+    ClientSecret, CsrfToken, PkceCodeChallenge, RedirectUrl, Scope, TokenUrl,
-    ClientSecret, TokenResponse, CsrfToken,
 };
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
-use std::{env, net::SocketAddr, collections::HashMap};
+use std::{collections::HashMap, env};
 
-use crate::User;
+// use crate::User;
 use crate::COOKIE_NAME;
 
 #[derive(Debug, Deserialize)]
@@ -47,74 +40,52 @@ pub async fn google_auth() -> impl IntoResponse {
     Redirect::to(&auth_url.to_string())
 }
 
-pub fn google_oauth_client() -> BasicClient {
-    let redirect_url = env::var("REDIRECT_URL")
-        //.unwrap_or_else(|_| "http://localhost:40192/auth/callback".to_string());
-        .unwrap_or_else(|_| "https://www.jean-marie.ca/auth/google".to_string());
-
-    let google_client_id = env::var("GOOGLE_CLIENT_ID").expect("Missing GOOGLE_CLIENT_ID!");
-    let google_client_secret = env::var("GOOGLE_CLIENT_SECRET").expect("Missing GOOGLE_CLIENT_SECRET!");
-    let google_auth_url = env::var("GOOGLE_AUTH_URL").unwrap_or_else(|_| {
-        "https://accounts.google.com/o/oauth2/v2/auth".to_string()
-    });
-    let google_token_url = env::var("GOOGLE_TOKEN_URL")
-        .unwrap_or_else(|_| "https://www.googleapis.com/oauth2/v3/token".to_string());
-
-    BasicClient::new(
-        ClientId::new(google_client_id),
-        Some(ClientSecret::new(google_client_secret)),
-        AuthUrl::new(google_auth_url).unwrap(),
-        Some(TokenUrl::new(google_token_url).unwrap()),
-    )
-    .set_redirect_uri(RedirectUrl::new(redirect_url).unwrap())
-}
-
 pub async fn google_authorized(
     Query(query): Query<AuthRequest>,
     Extension(store): Extension<MemoryStore>,
-    Extension(oauth_clients): Extension<HashMap::<&str, BasicClient>>,
+    Extension(oauth_clients): Extension<HashMap<&str, BasicClient>>,
 ) -> impl IntoResponse {
     // Check for Google client
     if oauth_clients.contains_key("Google") {
         // Get Google client
-        let oauth_client = oauth_clients.get(&"Google").unwrap();
+        let google_oauth_client = oauth_clients.get(&"Google").unwrap();
-/*
-    // Get an auth token
-    let token = google_oauth_client
-        .exchange_code(AuthorizationCode::new(query.code.clone()))
-        .request_async(async_http_client)
-        .await
-        .unwrap();
 
-    // Fetch user data from google
+        // Get an auth token
-    let client = reqwest::Client::new();
+        let token = google_oauth_client
-    let user_data: User = client
+            .exchange_code(AuthorizationCode::new(query.code.clone()))
-        // https://discord.com/developers/docs/resources/user#get-current-user
+            .request_async(async_http_client)
-        .get("https://discordapp.com/api/users/@me")
+            .await
-        .bearer_auth(token.access_token().secret())
+            .unwrap();
-        .send()
+        /*
-        .await
+            // Fetch user data from google
-        .unwrap()
+            let client = reqwest::Client::new();
-        .json::<User>()
+            let user_data: User = client
-        .await
+                // https://discord.com/developers/docs/resources/user#get-current-user
-        .unwrap();
+                .get("https://discordapp.com/api/users/@me")
-*/
+                .bearer_auth(token.access_token().secret())
+                .send()
+                .await
+                .unwrap()
+                .json::<User>()
+                .await
+                .unwrap();
+        */
 
-    // Create a new session filled with user data
+        // Create a new session filled with user data
-    let session = Session::new();
+        let session = Session::new();
-    //session.insert("user", &user_data).unwrap();
+        //session.insert("user", &user_data).unwrap();
 
-    // Store session and get corresponding cookie
+        // Store session and get corresponding cookie
-    let cookie = store.store_session(session).await.unwrap().unwrap();
+        let cookie = store.store_session(session).await.unwrap().unwrap();
 
-    // Build the cookie
+        // Build the cookie
-    let cookie = format!("{}={}; SameSite=Lax; Path=/", COOKIE_NAME, cookie);
+        let cookie = format!("{}={}; SameSite=Lax; Path=/", COOKIE_NAME, cookie);
 
-    // Set cookie
+        // Set cookie
-    let mut headers = HeaderMap::new();
+        let mut headers = HeaderMap::new();
-    headers.insert(SET_COOKIE, cookie.parse().unwrap());
+        headers.insert(SET_COOKIE, cookie.parse().unwrap());
 
-    //(headers, Redirect::to("/dashboard".parse().unwrap()))
+        //(headers, Redirect::to("/dashboard".parse().unwrap()))
     }
 
     let mut page = String::new();
@@ -127,3 +98,25 @@ pub async fn google_authorized(
 
     page
 }
+
+pub fn google_oauth_client() -> BasicClient {
+    let redirect_url = env::var("REDIRECT_URL")
+        .unwrap_or_else(|_| "http://localhost:40192/auth/google".to_string());
+        // .unwrap_or_else(|_| "https://www.jean-marie.ca/auth/google".to_string());
+
+    let google_client_id = env::var("GOOGLE_CLIENT_ID").expect("Missing GOOGLE_CLIENT_ID!");
+    let google_client_secret =
+        env::var("GOOGLE_CLIENT_SECRET").expect("Missing GOOGLE_CLIENT_SECRET!");
+    let google_auth_url = env::var("GOOGLE_AUTH_URL")
+        .unwrap_or_else(|_| "https://accounts.google.com/o/oauth2/v2/auth".to_string());
+    let google_token_url = env::var("GOOGLE_TOKEN_URL")
+        .unwrap_or_else(|_| "https://www.googleapis.com/oauth2/v3/token".to_string());
+
+    BasicClient::new(
+        ClientId::new(google_client_id),
+        Some(ClientSecret::new(google_client_secret)),
+        AuthUrl::new(google_auth_url).unwrap(),
+        Some(TokenUrl::new(google_token_url).unwrap()),
+    )
+    .set_redirect_uri(RedirectUrl::new(redirect_url).unwrap())
+}

src/main.rs

@@ -25,6 +25,14 @@ use std::{net::SocketAddr, collections::HashMap};
 use tower_http::services::ServeDir;
 use uuid::Uuid;
 
+use sqlx::{PgPool};
+use anyhow::*;
+use sqlx::postgres::PgPoolOptions;
+
+mod db;
+
+use db::*;
+
 mod google_oauth;
 mod facebook_oauth;
 mod discord_oauth;
@@ -73,6 +81,11 @@ async fn main() {
     // initialize tracing
     tracing_subscriber::fmt::init();
 
+    // Initialize database
+    let db = DBApplication::new("postgres://postgres:postgres@localhost/sqlx-demo".into()).await?;
+    println!("Connection acquired!");
+
+
     // `MemoryStore` just used as an example. Don't use this in production.
     let store = MemoryStore::new();
 

src/oauth.rs

@@ -0,0 +1,5 @@
+pub struct OauthSession {
+    client: BasicClient,
+    pkce_code_verifier: PkceCodeVerifier,
+    csrf_state: CsrfToken
+}