Get scheduled message event (#18)

Reviewed-on: phoenix/textsender_api#18

src/caller/message/scheduling.rs

@@ -36,6 +36,12 @@ pub mod request {
                 || !self.scheduled_message_id.is_nil()
         }
     }
+
+    #[derive(Debug, Default, serde::Deserialize, serde::Serialize, utoipa::ToSchema)]
+    pub struct GetScheduledMessageEventParams {
+        pub id: Option<uuid::Uuid>,
+        pub scheduled_message_id: Option<uuid::Uuid>,
+    }
 }
 
 pub mod response {
@@ -59,6 +65,8 @@ pub mod response {
         pub message: String,
         pub data: Vec<textsender_models::message::scheduling::ScheduledMessageEvent>,
     }
+
+    pub use CreateScheduleMessageEventResponse as GetScheduledMessageEventResponse;
 }
 
 pub mod endpoint {
@@ -278,4 +286,73 @@ pub mod endpoint {
             (axum::http::StatusCode::BAD_REQUEST, axum::Json(response))
         }
     }
+
+    /// Endpoint to get Scheduled Message Event
+    #[utoipa::path(
+        get,
+        path = crate::caller::endpoints::GET_SCHEDULED_MESSAGE_EVENT,
+        params(
+            ("id" = uuid::Uuid, Path, description = "Id of Scheduled Message Event"),
+            ("scheduled_message_id" = uuid::Uuid, Path, description = "Scheduled Message Id associated with the Scheduled Message Event")
+            ),
+        responses(
+            (status = 200, description = "Scheduled Message Event found", body = super::response::GetScheduledMessageEventResponse),
+            (status = 400, description = "Invalid request", body = super::response::GetScheduledMessageEventResponse),
+            (status = 500, description = "Error getting Scheduled Message Event", body = super::response::GetScheduledMessageEventResponse)
+        )
+    )]
+    pub async fn get_scheduled_message_events(
+        axum::Extension(pool): axum::Extension<sqlx::PgPool>,
+        axum::extract::Query(params): axum::extract::Query<
+            super::request::GetScheduledMessageEventParams,
+        >,
+    ) -> (
+        axum::http::StatusCode,
+        axum::Json<super::response::GetScheduledMessageEventResponse>,
+    ) {
+        let mut response = super::response::GetScheduledMessageEventResponse::default();
+
+        let scheduled_message_events = match params.id {
+            Some(id) => match scheduling_repo::sched_msg_event::get(&pool, &id).await {
+                Ok(scheduled_message) => {
+                    vec![scheduled_message]
+                }
+                Err(err) => {
+                    eprintln!("Error: {err:?}");
+                    return (
+                        axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+                        axum::Json(response),
+                    );
+                }
+            },
+            None => match params.scheduled_message_id {
+                Some(scheduled_message_id) => {
+                    match scheduling_repo::sched_msg_event::get_with_scheduled_message_id(
+                        &pool,
+                        &scheduled_message_id,
+                    )
+                    .await
+                    {
+                        Ok(scheduled_messages) => scheduled_messages,
+                        Err(err) => {
+                            eprintln!("Error: {err:?}");
+                            return (
+                                axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+                                axum::Json(response),
+                            );
+                        }
+                    }
+                }
+                None => {
+                    response.message = String::from("Invalid parameter");
+                    return (axum::http::StatusCode::BAD_REQUEST, axum::Json(response));
+                }
+            },
+        };
+
+        response.data = scheduled_message_events;
+        response.message = String::from(super::super::super::response::SUCCESSFUL);
+
+        (axum::http::StatusCode::OK, axum::Json(response))
+    }
 }

src/caller/mod.rs

@@ -20,6 +20,8 @@ pub mod endpoints {
     pub const GET_SCHEDULE_MESSAGE: &str = "/api/v1/schedule/message";
     /// Constant for creating Scheduled Message Event endpoint
     pub const CREATE_SCHEDULED_MESSAGE_EVENT: &str = "/api/v1/schedule/message/event";
+    /// Constant for getting Scheduled Message Event endpoint
+    pub const GET_SCHEDULED_MESSAGE_EVENT: &str = "/api/v1/schedule/message/event";
 }
 
 pub mod response {

src/config/mod.rs

@@ -142,6 +142,12 @@ pub mod init {
                     axum::middleware::from_fn(crate::auth::auth::<axum::body::Body>),
                 ),
             )
+            .route(
+                crate::caller::endpoints::GET_SCHEDULED_MESSAGE_EVENT,
+                get(scheduling_endpoints::get_scheduled_message_events).route_layer(
+                    axum::middleware::from_fn(crate::auth::auth::<axum::body::Body>),
+                ),
+            )
             .layer(cors::configure_cors().await)
     }
 

tests/test.rs

@@ -408,6 +408,25 @@ mod request {
                     Err(err) => Err(err),
                 }
             }
+
+            pub async fn get_scheduled_message_events(
+                app: &axum::Router,
+                scheduled_message_id: &uuid::Uuid,
+            ) -> Result<axum::response::Response, axum::http::Error> {
+                let uri = format!(
+                    "{}?scheduled_message_id={}",
+                    textsender_api::caller::endpoints::GET_SCHEDULED_MESSAGE_EVENT,
+                    scheduled_message_id
+                );
+
+                match super::super::run_post(None, &uri, axum::http::Method::GET, false).await {
+                    Ok(req) => match app.clone().oneshot(req).await {
+                        Ok(response) => Ok(response),
+                        Err(err) => Err(axum::http::Error::from(err)),
+                    },
+                    Err(err) => Err(err),
+                }
+            }
         }
     }
 
@@ -793,3 +812,93 @@ async fn test_create_scheduled_message_event() {
 
     let _ = db_mgr::drop_database(&tm_pool, &db_name).await;
 }
+
+#[tokio::test]
+async fn test_get_scheduled_message_event() {
+    let (tm_pool, db_name, pool) = db_mgr::get_database_ready().await;
+    let app = init::app(pool).await;
+
+    let mut contact_id: uuid::Uuid = uuid::Uuid::nil();
+    let mut message_id: uuid::Uuid = uuid::Uuid::nil();
+    let mut scheduled_message_id: uuid::Uuid = uuid::Uuid::nil();
+
+    match request::create_contact(&app).await {
+        Ok(response) => {
+            let resp = util::get_resp_data::<
+                textsender_api::caller::contact::response::AddContactResponse,
+            >(response)
+            .await;
+            assert_eq!(false, resp.data.is_empty(), "Should not be empty");
+            contact_id = resp.data[0].id.unwrap();
+        }
+        Err(err) => {
+            assert!(false, "Error: {:?}", err);
+        }
+    };
+
+    match request::message::create_message(&app).await {
+        Ok(response) => {
+            let resp = util::get_resp_data::<
+                textsender_api::caller::message::response::AddMessageResponse,
+            >(response)
+            .await;
+            assert_eq!(false, resp.data.is_empty(), "Should not be empty");
+            let message = &resp.data[0];
+            message_id = message.id.unwrap();
+        }
+        Err(err) => {
+            assert!(false, "Error: {:?}", err);
+        }
+    };
+
+    match request::message::scheduling::create_scheduled_message(&app).await {
+        Ok(response) => {
+            let resp = util::get_resp_data::<
+                textsender_api::caller::message::scheduling::response::ScheduleMessageResponse,
+            >(response)
+            .await;
+            assert_eq!(false, resp.data.is_empty(), "Should not be empty");
+            scheduled_message_id = resp.data[0].id;
+        }
+        Err(err) => {
+            assert!(false, "Error: {err:?}");
+        }
+    }
+
+    match request::message::scheduling::create_scheduled_message_event(
+        &app,
+        &contact_id,
+        &message_id,
+        &scheduled_message_id,
+    )
+    .await
+    {
+        Ok(response) => {
+            let resp = util::get_resp_data::<
+                textsender_api::caller::message::scheduling::response::CreateScheduleMessageEventResponse,
+            >(response)
+            .await;
+            assert_eq!(false, resp.data.is_empty(), "Should not be empty");
+        }
+        Err(err) => {
+            assert!(false, "Error: {err:?}");
+        }
+    }
+
+    match request::message::scheduling::get_scheduled_message_events(&app, &scheduled_message_id)
+        .await
+    {
+        Ok(response) => {
+            let resp = util::get_resp_data::<
+                textsender_api::caller::message::scheduling::response::GetScheduledMessageEventResponse,
+            >(response)
+            .await;
+            assert_eq!(false, resp.data.is_empty(), "Should not be empty");
+        }
+        Err(err) => {
+            assert!(false, "Error: {err:?}");
+        }
+    }
+
+    let _ = db_mgr::drop_database(&tm_pool, &db_name).await;
+}