feat: complete auth system

2025-03-23 01:19:17 +07:00
parent 1e6957720e
commit 093e290221
12 changed files with 186 additions and 101 deletions
@@ -1,14 +1,14 @@
 use super::{
 	AuthLoginRequestDto, AuthLoginResponsetDto, AuthNewPasswordRequestDto,
-	AuthRegisterRequestDto, AuthRepository, AuthResendOtpRequestDto,
-	AuthVerifyEmailRequestDto, TokenDto,
+	AuthRefreshTokenRequestDto, AuthRegisterRequestDto, AuthRepository,
+	AuthResendOtpRequestDto, AuthVerifyEmailRequestDto, TokenDto,
 };
 use crate::{
-	common_response, encode_access_token, encode_refresh_token, extract_email_token,
-	generate_otp, get_iso_date, hash_password, send_email, success_response,
-	validate_request, verify_password, AppState, Env, ResourceEnum,
-	ResponseSuccessDto, UsersActiveInactiveSchema, UsersItemDto, UsersRepository,
-	UsersSchema,
+	common_response, decode_refresh_token, encode_access_token, encode_refresh_token,
+	encode_reset_password_token, extract_email_token, generate_otp, get_iso_date,
+	hash_password, send_email, success_response, validate_request, verify_password,
+	AppState, Env, ResourceEnum, ResponseSuccessDto, UsersActiveInactiveSchema,
+	UsersItemDto, UsersRepository, UsersSchema, UsersSetNewPasswordSchema,
 };
 use axum::{http::StatusCode, response::Response};
 use surrealdb::{
@@ -83,8 +83,8 @@ impl AuthService {
 					},
 				};

-				if let Err(_) = auth_repo.query_store_user(user).await {
-					return common_response(StatusCode::BAD_REQUEST, "Failed to store data");
+				if let Err(err) = auth_repo.query_store_user(user).await {
+					return common_response(StatusCode::BAD_REQUEST, &err.to_string());
 				}

 				success_response(response)
@@ -200,6 +200,46 @@ impl AuthService {
 		}
 	}

+	pub async fn mutation_refresh_token(
+		payload: AuthRefreshTokenRequestDto,
+	) -> Response {
+		let email = match decode_refresh_token(&payload.refresh_token) {
+			Ok(token) => token.claims.sub,
+			Err(_) => {
+				return common_response(StatusCode::UNAUTHORIZED, "Invalid refresh token");
+			}
+		};
+
+		let access_token = match encode_access_token(email.clone()) {
+			Ok(token) => token,
+			Err(_) => {
+				return common_response(
+					StatusCode::INTERNAL_SERVER_ERROR,
+					"Failed to generate access token",
+				);
+			}
+		};
+
+		let refresh_token = match encode_refresh_token(email.clone()) {
+			Ok(token) => token,
+			Err(_) => {
+				return common_response(
+					StatusCode::INTERNAL_SERVER_ERROR,
+					"Failed to generate refresh token",
+				);
+			}
+		};
+
+		let response = ResponseSuccessDto {
+			data: TokenDto {
+				access_token,
+				refresh_token,
+			},
+		};
+
+		success_response(response)
+	}
+
 	pub async fn mutation_forgot_password(
 		payload: AuthResendOtpRequestDto,
 		state: &AppState,
@@ -212,7 +252,7 @@ impl AuthService {
 		{
 			return common_response(StatusCode::BAD_REQUEST, "User not found");
 		}
-		let token = match encode_access_token(payload.email.clone()) {
+		let token = match encode_reset_password_token(payload.email.clone()) {
 			Ok(token) => token,
 			Err(_) => {
 				return common_response(
@@ -240,46 +280,32 @@ impl AuthService {
 	) -> Response {
 		let user_repo = UsersRepository::new(state);
 		let auth_repo = AuthRepository::new(state);
-
-		match auth_repo.query_get_stored_otp(payload.email.clone()).await {
-			Ok(stored_otp) => {
-				let user_otp = payload.otp;
-				let is_otp_valid = stored_otp == user_otp;
-				if is_otp_valid {
-					match user_repo
-						.query_active_inactive_user(
-							payload.email.clone(),
-							UsersActiveInactiveSchema { is_active: true },
-						)
-						.await
-					{
-						Ok(_) => {
-							if let Err(e) = auth_repo
-								.query_delete_stored_otp(payload.email.clone())
-								.await
-							{
-								return common_response(
-									StatusCode::INTERNAL_SERVER_ERROR,
-									&e.to_string(),
-								);
-							}
-							common_response(StatusCode::OK, "Email verified successfully")
+		let email = payload.email.clone();
+		match auth_repo.query_get_stored_otp(email.clone()).await {
+			Ok(stored_otp) => match stored_otp == payload.otp {
+				true => match user_repo
+					.query_active_inactive_user(
+						email.clone(),
+						UsersActiveInactiveSchema { is_active: true },
+					)
+					.await
+				{
+					Ok(_) => match auth_repo.query_delete_stored_otp(email).await {
+						Ok(_) => common_response(StatusCode::OK, "Email verified successfully"),
+						Err(e) => {
+							common_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string())
 						}
-						Err(err) => common_response(StatusCode::BAD_REQUEST, &err.to_string()),
-					}
-				} else {
-					if let Err(e) = auth_repo
-						.query_delete_stored_otp(payload.email.clone())
-						.await
-					{
-						return common_response(
-							StatusCode::INTERNAL_SERVER_ERROR,
-							&format!("Failed to delete OTP: {}", e),
-						);
-					}
-					common_response(StatusCode::BAD_REQUEST, "Failed to verify OTP")
-				}
-			}
+					},
+					Err(err) => common_response(StatusCode::BAD_REQUEST, &err.to_string()),
+				},
+				false => match auth_repo.query_delete_stored_otp(email).await {
+					Ok(_) => common_response(StatusCode::BAD_REQUEST, "Failed to verify OTP"),
+					Err(e) => common_response(
+						StatusCode::INTERNAL_SERVER_ERROR,
+						&format!("Failed to delete OTP: {}", e),
+					),
+				},
+			},
 			Err(err) => common_response(StatusCode::BAD_REQUEST, &err.to_string()),
 		}
 	}
@@ -290,12 +316,9 @@ impl AuthService {
 	) -> Response {
 		let user_repo = UsersRepository::new(state);
 		let email = extract_email_token(payload.token).unwrap();
-
+		let password = hash_password(&payload.password).unwrap();
 		match user_repo
-			.query_update_password_user(crate::UsersSetNewPasswordSchema {
-				email: email.clone(),
-				password: payload.password.clone(),
-			})
+			.query_update_password_user(email, UsersSetNewPasswordSchema { password })
 			.await
 		{
 			Ok(msg) => common_response(StatusCode::OK, &msg),