src/callers/login.rs

@@ -28,6 +28,16 @@ pub mod endpoint {
     use super::request;
     use super::response;
 
+    async fn not_found(message: &String) -> (StatusCode, Json<response::Response>) {
+        (
+            StatusCode::NOT_FOUND,
+            Json(response::Response {
+                message: message.clone(),
+                data: Vec::new(),
+            }),
+        )
+    }
+
     pub async fn login(
         axum::Extension(pool): axum::Extension<sqlx::PgPool>,
         Json(payload): Json<request::Request>,
@@ -37,53 +47,56 @@ pub mod endpoint {
             password: payload.password,
             ..Default::default()
         };
-        // usr.username = payload.username;
-        // usr.password = payload.password;
 
         // Check if user exists
-        let user_exists = repo::user::exists(&pool, &usr.username).await.unwrap();
+        match repo::user::exists(&pool, &usr.username).await {
-        if !user_exists {
+            Ok(exists) => {
-            // End
+                if !exists {
-        }
+                    return not_found(&"Not Found".to_string()).await;
+                }
+            }
+            Err(err) => {
+                return not_found(&err.to_string()).await;
+            }
+        };
+
+        // End
         let user = repo::user::get(&pool, &usr.username).await.unwrap();
         let salt = repo::salt::get(&pool, &user.salt_id).await.unwrap();
-        let salt_literal = salt.salt.clone();
+        let salt_str = hashing::get_salt(&salt.salt).unwrap();
-        let salt_str = hashing::get_salt(&salt_literal).unwrap();
 
         // Check if password is correct
-        let hash_password = hashing::hash_password(&usr.password, &salt_str).unwrap();
+        match hashing::hash_password(&usr.password, &salt_str) {
-        if hashing::verify_password(&usr.password, hash_password.clone()).unwrap() {
+            Ok(hash_password) => {
-            println!("Do work");
+                if hashing::verify_password(&usr.password, hash_password.clone()).unwrap() {
-        }
+                    // Create token
+                    let key = token_stuff::get_key().unwrap();
+                    let token_literal = token_stuff::create_token(&key).unwrap();
 
-        // Create token
+                    if token_stuff::verify_token(&key, &token_literal) {
-        let key = token_stuff::get_key().unwrap();
+                        (
-        let token_literal = token_stuff::create_token(&key).unwrap();
+                            StatusCode::OK,
-
+                            Json(response::Response {
-        let result = token_stuff::verify_token(&key, &token_literal);
+                                message: String::from("Successful"),
-
+                                data: vec![icarus_models::login_result::LoginResult {
-        if result {
+                                    id: user.id,
-            (
+                                    username: user.username,
-                StatusCode::OK,
+                                    token: token_literal,
-                Json(response::Response {
+                                    token_type: String::from(token_stuff::TOKENTYPE),
-                    message: String::from("Not implemented"),
+                                    expiration: -1,
-                    data: vec![icarus_models::login_result::LoginResult {
+                                }],
-                        id: user.id,
+                            }),
-                        username: user.username,
+                        )
-                        token: token_literal,
+                    } else {
-                        token_type: String::from("JWT"),
+                        return not_found(&"Could not verify password".to_string()).await;
-                        expiration: -1,
+                    }
-                    }],
+                } else {
-                }),
+                    return not_found(&"Error Hashing".to_string()).await;
-            )
+                }
-        } else {
+            }
-            (
+            Err(err) => {
-                StatusCode::BAD_REQUEST,
+                return not_found(&err.to_string()).await;
-                Json(response::Response {
+            }
-                    message: String::from("Not implemented"),
-                    data: vec![icarus_models::login_result::LoginResult::default()],
-                }),
-            )
         }
     }
 }