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) {
+            Ok(hash_password) => {
                 if hashing::verify_password(&usr.password, hash_password.clone()).unwrap() {
-            println!("Do work");
-        }
-
                     // Create token
                     let key = token_stuff::get_key().unwrap();
                     let token_literal = token_stuff::create_token(&key).unwrap();
 
-        let result = token_stuff::verify_token(&key, &token_literal);
+                    if token_stuff::verify_token(&key, &token_literal) {
-
-        if result {
                         (
                             StatusCode::OK,
                             Json(response::Response {
-                    message: String::from("Not implemented"),
+                                message: String::from("Successful"),
                                 data: vec![icarus_models::login_result::LoginResult {
                                     id: user.id,
                                     username: user.username,
                                     token: token_literal,
-                        token_type: String::from("JWT"),
+                                    token_type: String::from(token_stuff::TOKENTYPE),
                                     expiration: -1,
                                 }],
                             }),
                         )
                     } else {
-            (
+                        return not_found(&"Could not verify password".to_string()).await;
-                StatusCode::BAD_REQUEST,
+                    }
-                Json(response::Response {
+                } else {
-                    message: String::from("Not implemented"),
+                    return not_found(&"Error Hashing".to_string()).await;
-                    data: vec![icarus_models::login_result::LoginResult::default()],
+                }
-                }),
+            }
-            )
+            Err(err) => {
+                return not_found(&err.to_string()).await;
+            }
         }
     }
 }