Oh wow I removed all of the unwraps

docker-compose.yml

@@ -0,0 +1,20 @@
+version: '3.8'
+
+services:
+  postgres:
+    image: postgres:latest
+    container_name: db
+    environment:
+      POSTGRES_USER: rideboard
+      POSTGRES_PASSWORD: supersecurepassword
+      POSTGRES_DB: rideboard
+    volumes:
+      - ./src/migrations:/docker-entrypoint-initdb.d
+    ports:
+      - "5432:5432"
+
+  redis:
+    image: redis:latest
+    container_name: redis
+    ports:
+      - "6379:6379"

src/api/mod.rs

@@ -2,13 +2,16 @@ use actix_web::{body::BoxBody, web, HttpResponse, Scope};
 use utoipa::OpenApi;
 use utoipa_swagger_ui::SwaggerUi;
 
+use crate::app::ApiError;
+
 mod v1;
 
 #[derive(OpenApi)]
 #[openapi(
     nest(
         (path = "/api/v1", api = v1::ApiDoc)
     ),
+    components(schemas(ApiError))
 )]
 pub(super) struct ApiDoc;
 

src/api/v1/auth/common.rs

@@ -1,7 +1,11 @@
+use actix_session::Session;
 use actix_web::{HttpResponse, Responder};
+use anyhow::Result;
 use oauth2::basic::BasicClient;
 use oauth2::{CsrfToken, Scope as OAuthScope};
 
+use super::models::UserInfo;
+
 pub async fn login(client: &BasicClient, scopes: Vec<String>) -> impl Responder {
     //let (pkce_code_challenge, _pkce_code_verifier) = PkceCodeChallenge::new_random_sha256();
 
@@ -18,3 +22,9 @@ pub async fn login(client: &BasicClient, scopes: Vec<String>) -> impl Responder
 
     HttpResponse::Ok().body(authorize_url.to_string())
 }
+
+pub fn login_session(session: &Session, user_info: UserInfo) -> Result<()> {
+    session.insert("login", true)?;
+    session.insert("userinfo", user_info)?;
+    Ok(())
+}

src/api/v1/auth/csh.rs

@@ -1,5 +1,5 @@
 use crate::api::v1::auth::models::{CSHUserInfo, UserInfo};
-use crate::app::AppState;
+use crate::app::{ApiError, AppState};
 use crate::db::user::{UserData, UserRealm};
 use actix_session::Session;
 use actix_web::http::header;
@@ -10,18 +10,17 @@ use oauth2::reqwest::async_http_client;
 use oauth2::{AuthorizationCode, TokenResponse};
 use reqwest::Client;
 use serde::Deserialize;
-use serde_json::json;
 use utoipa::{OpenApi, ToSchema};
 
-use crate::api::v1::auth::common;
+use crate::api::v1::auth::common::{self, login_session};
 
 #[derive(OpenApi)]
 #[openapi(paths(login, auth,), components(schemas(AuthRequest)))]
 pub(super) struct ApiDoc;
 
 #[utoipa::path(
     responses(
-        (status = 200, description = "Redirect to OAuth2 Link to Log In")
+        (status = 200, description = "OAuth2 Link to Log In")
     )
 )]
 #[get("/")]
@@ -42,7 +41,8 @@ pub struct AuthRequest {
 
 #[utoipa::path(
     responses(
-        (status = 200, description = "Redirect to OAuth2 to verify code and update user info.")
+        (status = 302, description = "Successful login, Redirect to home page."),
+        (status = 500, body = ApiError)
     )
 )]
 #[get("/redirect")]
@@ -53,24 +53,43 @@ async fn auth(
 ) -> impl Responder {
     let code = AuthorizationCode::new(params.code.clone());
 
-    let token = &data
+    let token = match &data
         .csh_oauth
         .exchange_code(code)
         .request_async(async_http_client)
         .await
-        .unwrap();
+    {
+        Ok(token) => token.access_token().secret().clone(),
+        Err(err) => {
+            error!("{}", err);
+            return HttpResponse::InternalServerError()
+                .json(ApiError::from("Failed to get OAuth Token".to_string()));
+        }
+    };
 
     let client = Client::new();
 
-    let user_info: CSHUserInfo = client
+    let user_info: CSHUserInfo = match client
         .get(&data.csh_userinfo_url)
-        .bearer_auth(token.access_token().secret())
+        .bearer_auth(token)
         .send()
         .await
-        .unwrap()
-        .json()
-        .await
-        .unwrap();
+    {
+        Ok(res) => match res.json().await {
+            Ok(out) => out,
+            Err(err) => {
+                error!("{}", err);
+                return HttpResponse::InternalServerError().json(ApiError::from(
+                    "Failed to deserialize UserInfo token".to_string(),
+                ));
+            }
+        },
+        Err(err) => {
+            error!("{}", err);
+            return HttpResponse::InternalServerError()
+                .json(ApiError::from("Failed to get UserInfo Token".to_string()));
+        }
+    };
 
     if let Err(err) = UserData::insert_new(
         user_info.ldap_id.clone(),
@@ -82,15 +101,15 @@ async fn auth(
     .await
     {
         error!("{}", err);
-        return HttpResponse::InternalServerError().json(json!({
-            "error": "Failed to add user to database"
-        }));
+        return HttpResponse::InternalServerError()
+            .json(ApiError::from("Failed to add user to database".to_string()));
     }
 
-    session.insert("login", true).unwrap();
-    session
-        .insert("userinfo", UserInfo::from(user_info))
-        .unwrap();
+    if let Err(err) = login_session(&session, UserInfo::from(user_info)) {
+        error!("{}", err);
+        return HttpResponse::InternalServerError()
+            .json(ApiError::from("Failed to Authorize Session".to_string()));
+    }
 
     HttpResponse::Found()
         .append_header((header::LOCATION, "/"))

src/api/v1/auth/google.rs

@@ -1,6 +1,6 @@
 use crate::api::v1::auth::common;
 use crate::api::v1::auth::models::{GoogleUserInfo, UserInfo};
-use crate::app::AppState;
+use crate::app::{ApiError, AppState};
 use crate::db::user::{UserData, UserRealm};
 use actix_session::Session;
 use actix_web::http::header;
@@ -11,9 +11,10 @@ use oauth2::reqwest::async_http_client;
 use oauth2::{AuthorizationCode, TokenResponse};
 use reqwest::Client;
 use serde::Deserialize;
-use serde_json::json;
 use utoipa::{OpenApi, ToSchema};
 
+use super::common::login_session;
+
 #[derive(OpenApi)]
 #[openapi(paths(login, auth,), components(schemas(AuthRequest)))]
 pub(super) struct ApiDoc;
@@ -45,7 +46,8 @@ pub struct AuthRequest {
 
 #[utoipa::path(
     responses(
-        (status = 200, description = "Redirect to OAuth2 to verify code and update user info.")
+        (status = 302, description = "Successful login, Redirect to home page."),
+        (status = 500, body = ApiError)
     )
 )]
 #[get("/redirect")]
@@ -58,24 +60,43 @@ async fn auth(
     //let _scope = params.scope.clone();
 
     // Exchange the code with a token.
-    let token = &data
+    let token = match &data
         .google_oauth
         .exchange_code(code)
         .request_async(async_http_client)
         .await
-        .unwrap();
+    {
+        Ok(token) => token.access_token().secret().clone(),
+        Err(err) => {
+            error!("{}", err);
+            return HttpResponse::InternalServerError()
+                .json(ApiError::from("Failed to get OAuth Token".to_string()));
+        }
+    };
 
     let client = Client::new();
 
-    let user_info: GoogleUserInfo = client
+    let user_info: GoogleUserInfo = match client
         .get(&data.google_userinfo_url)
-        .bearer_auth(token.access_token().secret())
+        .bearer_auth(token)
         .send()
         .await
-        .unwrap()
-        .json()
-        .await
-        .unwrap();
+    {
+        Ok(res) => match res.json().await {
+            Ok(out) => out,
+            Err(err) => {
+                error!("{}", err);
+                return HttpResponse::InternalServerError().json(ApiError::from(
+                    "Failed to deserialize UserInfo token".to_string(),
+                ));
+            }
+        },
+        Err(err) => {
+            error!("{}", err);
+            return HttpResponse::InternalServerError()
+                .json(ApiError::from("Failed to get UserInfo Token".to_string()));
+        }
+    };
 
     if let Err(err) = UserData::insert_new(
         user_info.sub.clone(),
@@ -87,15 +108,15 @@ async fn auth(
     .await
     {
         error!("{}", err);
-        return HttpResponse::InternalServerError().json(json!({
-            "error": "Failed to add user to database"
-        }));
+        return HttpResponse::InternalServerError()
+            .json(ApiError::from("Failed to add user to database".to_string()));
     }
 
-    session.insert("login", true).unwrap();
-    session
-        .insert("userinfo", UserInfo::from(user_info))
-        .unwrap();
+    if let Err(err) = login_session(&session, UserInfo::from(user_info)) {
+        error!("{}", err);
+        return HttpResponse::InternalServerError()
+            .json(ApiError::from("Failed to Authorize Session".to_string()));
+    }
 
     HttpResponse::Found()
         .append_header((header::LOCATION, "/"))

src/api/v1/auth/mod.rs

@@ -1,7 +1,8 @@
-use crate::api::v1::auth::models::UserInfo;
 use crate::auth::SessionAuth;
+use crate::{api::v1::auth::models::UserInfo, app::ApiError};
 use actix_session::Session;
 use actix_web::{get, http::header, post, web, HttpResponse, Responder, Scope};
+use log::error;
 use utoipa::OpenApi;
 
 mod common;
@@ -11,7 +12,7 @@ pub mod models;
 
 #[utoipa::path(
     responses(
-        (status = 200, description = "List current todo items")
+        (status = 302, description = "Logged out")
     )
 )]
 #[post("/logout")]
@@ -25,13 +26,20 @@ async fn logout(session: Session) -> impl Responder {
 
 #[utoipa::path(
     responses(
-        (status = 200, description = "List current todo items")
+        (status = 200, description = "Get current user information"),
+        (status = 500, body = ApiError)
     )
 )]
 #[get("/", wrap = "SessionAuth")]
 async fn get_user_data(session: Session) -> impl Responder {
-    let out: Option<UserInfo> = session.get("userinfo").unwrap();
-    HttpResponse::Ok().json(out)
+    match session.get::<UserInfo>("userinfo") {
+        Ok(data) => HttpResponse::Ok().json(data),
+        Err(err) => {
+            error!("{}", err);
+            HttpResponse::InternalServerError()
+                .json(ApiError::from("Failed to get Session Data".to_string()))
+        }
+    }
 }
 
 #[derive(OpenApi)]