feat: add new endpoint

Author: maulanasdqn

src/app/auth/auth_controller.rs

@@ -22,7 +22,7 @@ pub async fn post_login(Json(payload): Json<AuthDto>) -> impl IntoResponse {
 #[utoipa::path(
     post,
     path = "/api/auth/refresh",
-    request_body(content = String, description = "Refresh token"),
+    request_body(content = AuthRefreshDto, description = "Refresh token"),
     responses(
         (status = 200, description = "Token refreshed", body = AuthResponse),
         (status = 400, description = "Invalid refresh token", body = MessageResponse)

src/app/auth/auth_dto.rs

@@ -20,6 +20,11 @@ pub struct AuthData {
 	pub refresh_token: String,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
+pub struct AuthRefreshDto {
+	pub refresh_token: String,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
 pub struct AuthResponse {
 	pub data: AuthData,

src/app/auth/auth_service.rs

@@ -1,12 +1,17 @@
-use super::auth_dto::AuthDto;
-use axum::Json;
+use axum::{
+	http::StatusCode,
+	response::{IntoResponse, Response},
+	Json,
+};
 use serde_json::json;
 use std::env;
 use utils::{
 	format_error, format_success, jwt::decode_refresh_token,
 	jwt::encode_access_token, jwt::encode_refresh_token,
 };
 
+use super::auth_dto::AuthDto;
+
 #[derive(serde::Serialize)]
 pub struct ErrorResponse {
 	pub message: String,
@@ -18,33 +23,43 @@ pub struct LoginResponse {
 	pub refresh_token: String,
 }
 
-pub async fn login(Json(credentials): Json<AuthDto>) -> Json<serde_json::Value> {
+pub async fn login(Json(credentials): Json<AuthDto>) -> Response {
 	let email = env::var("USER_EMAIL").expect("USER_EMAIL must be set");
 	let password = env::var("USER_PASSWORD").expect("USER_PASSWORD must be set");
 
 	if credentials.email != email {
-		return Json(format_error("Email or password is incorrect"));
+		return (
+			StatusCode::UNAUTHORIZED,
+			Json(format_error("Email or password is incorrect")),
+		)
+			.into_response();
 	}
 
 	if credentials.password != password {
-		return Json(format_error("Email or password is incorrect"));
+		return (
+			StatusCode::UNAUTHORIZED,
+			Json(format_error("Email or password is incorrect")),
+		)
+			.into_response();
 	}
 
 	let access_token = encode_access_token(email.clone()).unwrap();
 	let refresh_token = encode_refresh_token(email.clone()).unwrap();
 
-	Json(format_success(
-		json!({
-			"access_token": access_token,
-			"refresh_token": refresh_token,
-		}),
-		None,
-	))
+	(
+		StatusCode::OK,
+		Json(format_success(
+			json!({
+				"access_token": access_token,
+				"refresh_token": refresh_token,
+			}),
+			None,
+		)),
+	)
+		.into_response()
 }
 
-pub async fn refresh_token(
-	Json(payload): Json<serde_json::Value>,
-) -> Json<serde_json::Value> {
+pub async fn refresh_token(Json(payload): Json<serde_json::Value>) -> Response {
 	let refresh_token = payload
 		.get("refresh_token")
 		.and_then(|token| token.as_str())
@@ -55,13 +70,21 @@ pub async fn refresh_token(
 			let access_token =
 				encode_access_token(env::var("USER_EMAIL").unwrap().to_string())
 					.unwrap();
-			Json(format_success(
-				json!({
-					"access_token": access_token
-				}),
-				None,
-			))
+			(
+				StatusCode::OK,
+				Json(format_success(
+					json!({
+						"access_token": access_token
+					}),
+					None,
+				)),
+			)
+				.into_response()
 		}
-		Err(_) => Json(format_error("Invalid or expired refresh token")),
+		Err(_) => (
+			StatusCode::UNAUTHORIZED,
+			Json(format_error("Invalid or expired refresh token")),
+		)
+			.into_response(),
 	}
 }

src/app/lib.rs

@@ -27,15 +27,21 @@ pub async fn routes() -> Router {
             auth::auth_controller::post_login,
             auth::auth_controller::post_refresh,
             reservations::reservation_controller::create,
-            reservations::reservation_controller::get_all
+            reservations::reservation_controller::get_all,
+            reservations::reservation_controller::get_by_id,
+            reservations::reservation_controller::delete,
+            reservations::reservation_controller::update
         ),
         components(
             schemas(
                 auth::auth_dto::AuthDto,
+                auth::auth_dto::AuthRefreshDto,
                 auth::auth_dto::AuthResponse,
+                auth::auth_dto::AuthData,
                 auth::auth_dto::MessageResponse,
                 reservations::reservation_dto::ReservationDto,
                 reservations::reservation_dto::ReservationListResponse,
+                reservations::reservation_dto::ReservationDetailResponse,
                 reservations::reservation_dto::TMetas
             )
         ),

src/app/reservations/mod.rs

@@ -3,13 +3,18 @@ pub mod reservation_dto;
 pub mod reservation_service;
 
 use axum::{
-	routing::{get, post},
+	routing::{delete, get, post, put},
 	Router,
 };
-use reservation_controller::{create, get_all};
+use reservation_controller::{
+	create, delete as delete_c, get_all, get_by_id, update,
+};
 
 pub fn reservation_router() -> Router {
 	Router::new()
 		.route("/", get(get_all))
+		.route("/:id", get(get_by_id))
 		.route("/create", post(create))
+		.route("/delete/:id", delete(delete_c))
+		.route("/update/:id", put(update))
 }

src/app/reservations/reservation_controller.rs

@@ -21,7 +21,23 @@ use axum::{extract::Query, response::IntoResponse, Json};
 )]
 
 pub async fn get_all(Query(params): Query<TMetas>) -> impl IntoResponse {
-	println!("Raw query params: {:?}", params);
+	fetch_reservations(params).await
+}
+
+#[utoipa::path(
+    get,
+    path = "/api/reservations/{id}",
+    security(
+        ("Bearer" = [])
+    ),
+    responses(
+        (status = 201, description = "Detail Reservation", body = ReservationDetailResponse),
+        (status = 400, description = "Invalid reservation data", body = MessageResponse)
+    ),
+    tag = "Reservations"
+)]
+
+pub async fn get_by_id(Query(params): Query<TMetas>) -> impl IntoResponse {
 	fetch_reservations(params).await
 }
 
@@ -33,7 +49,7 @@ pub async fn get_all(Query(params): Query<TMetas>) -> impl IntoResponse {
         ("Bearer" = [])
     ),
     responses(
-        (status = 201, description = "Reservation created", body = ReservationDto),
+        (status = 201, description = "Reservation created", body = MessageResponse),
         (status = 400, description = "Invalid reservation data", body = MessageResponse)
     ),
     tag = "Reservations"
@@ -42,3 +58,38 @@ pub async fn get_all(Query(params): Query<TMetas>) -> impl IntoResponse {
 pub async fn create(Json(payload): Json<ReservationDto>) -> impl IntoResponse {
 	create_reservation(Json(payload)).await
 }
+
+#[utoipa::path(
+    delete,
+    path = "/api/reservations/delete/{id}",
+    security(
+        ("Bearer" = [])
+    ),
+    responses(
+        (status = 201, description = "Reservation deleted", body = MessageResponse),
+        (status = 400, description = "Invalid reservation data", body = MessageResponse)
+    ),
+    tag = "Reservations"
+)]
+
+pub async fn delete() -> impl IntoResponse {
+	()
+}
+
+#[utoipa::path(
+    put,
+    path = "/api/reservations/update/{id}",
+    request_body = ReservationDto,
+    security(
+        ("Bearer" = [])
+    ),
+    responses(
+        (status = 201, description = "Reservation updated", body = MessageResponse),
+        (status = 400, description = "Invalid reservation data", body = MessageResponse)
+    ),
+    tag = "Reservations"
+)]
+
+pub async fn update(Json(payload): Json<ReservationDto>) -> impl IntoResponse {
+	create_reservation(Json(payload)).await
+}

src/app/reservations/reservation_dto.rs

@@ -17,6 +17,12 @@ pub struct ReservationDto {
 #[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
 pub struct ReservationListResponse {
 	pub data: Vec<ReservationDto>,
+	pub meta: Option<TMetas>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
+pub struct ReservationDetailResponse {
+	pub data: ReservationDto,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, ToSchema, IntoParams)]