diff --git a/src/caller/message/scheduling.rs b/src/caller/message/scheduling.rs index 5604f67..5f3c3b5 100644 --- a/src/caller/message/scheduling.rs +++ b/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, + pub scheduled_message_id: Option, + } } pub mod response { @@ -59,6 +65,8 @@ pub mod response { pub message: String, pub data: Vec, } + + 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, + axum::extract::Query(params): axum::extract::Query< + super::request::GetScheduledMessageEventParams, + >, + ) -> ( + axum::http::StatusCode, + axum::Json, + ) { + 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)) + } } diff --git a/src/caller/mod.rs b/src/caller/mod.rs index 5d68d7f..a65b069 100644 --- a/src/caller/mod.rs +++ b/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 { diff --git a/src/config/mod.rs b/src/config/mod.rs index 6cb9a0d..bbf64e4 100644 --- a/src/config/mod.rs +++ b/src/config/mod.rs @@ -142,6 +142,12 @@ pub mod init { axum::middleware::from_fn(crate::auth::auth::), ), ) + .route( + crate::caller::endpoints::GET_SCHEDULED_MESSAGE_EVENT, + get(scheduling_endpoints::get_scheduled_message_events).route_layer( + axum::middleware::from_fn(crate::auth::auth::), + ), + ) .layer(cors::configure_cors().await) } diff --git a/tests/test.rs b/tests/test.rs index 6d2b843..54cc70a 100644 --- a/tests/test.rs +++ b/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 { + 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; +}