diff --git a/src/caller/message/scheduling.rs b/src/caller/message/scheduling.rs index 089f1a9..94f0c7f 100644 --- a/src/caller/message/scheduling.rs +++ b/src/caller/message/scheduling.rs @@ -21,6 +21,19 @@ pub mod request { pub id: Option, pub user_id: Option, } + + #[derive(Debug, Default, serde::Deserialize, serde::Serialize, utoipa::ToSchema)] + pub struct CreateScheduleMessageEventRequest { + pub contact_id: uuid::Uuid, + pub message_id: uuid::Uuid, + pub scheduled_message_id: uuid::Uuid, + } + + impl CreateScheduleMessageEventRequest { + pub fn is_valid(&self) -> bool { + !self.contact_id.is_nil() || !self.message_id.is_nil() || !self.scheduled_message_id.is_nil() + } + } } pub mod response { @@ -38,10 +51,18 @@ pub mod response { pub message: String, pub data: Vec, } + + #[derive(Debug, Default, Deserialize, Serialize, ToSchema)] + pub struct CreateScheduleMessageEventResponse { + pub message: String, + pub data: Vec, + } } pub mod endpoint { - use crate::repo::message::scheduling as scheduling_repo; + use crate::repo::message as message_repo; + use message_repo::scheduling as scheduling_repo; + use crate::repo::contact as contact_repo; /// Endpoint to create a Scheudled Message #[utoipa::path( @@ -174,4 +195,95 @@ pub mod endpoint { scheduled_time .is_some_and(|t| t - time::OffsetDateTime::now_utc() >= time::Duration::minutes(10)) } + + + /// Endpoint to create a Scheudled Message Event + #[utoipa::path( + post, + path = crate::caller::endpoints::CREATE_SCHEDULED_MESSAGE_EVENT, + request_body( + content = super::request::CreateScheduleMessageEventRequest, + description = "Data needed to create a Scheduled Message Event", + content_type = "application/json" + ), + responses( + (status = 201, description = "Scheduled Message Event created", body = super::response::CreateScheduleMessageEventResponse), + (status = 400, description = "Error", body = super::response::CreateScheduleMessageEventResponse), + (status = 500, description = "Error creating Scheduled Message Event", body = super::response::CreateScheduleMessageEventResponse) + ) +)] + pub async fn create_scheduled_message_event( + axum::Extension(pool): axum::Extension, + axum::Json(payload): axum::Json, + ) -> ( + axum::http::StatusCode, + axum::Json, + ) { + let mut response = super::response::CreateScheduleMessageEventResponse::default(); + + if payload.is_valid() { + match scheduling_repo::get(&pool, &payload.scheduled_message_id).await { + Ok(_) => { } + Err(err) => { + eprintln!("Error: {err:?}"); + response.message = String::from("Scheduled Message does not exist"); + return ( + axum::http::StatusCode::BAD_REQUEST, + axum::Json(response), + ); + } + } + + match contact_repo::get(&pool, &payload.contact_id).await { + Ok(_) => { } + Err(err) => { + eprintln!("Error: {err:?}"); + response.message = String::from("Contact does not exist"); + return ( + axum::http::StatusCode::BAD_REQUEST, + axum::Json(response), + ); + } + } + + match message_repo::get(&pool, &payload.message_id).await { + Ok(_) => { } + Err(err) => { + eprintln!("Error: {err:?}"); + response.message = String::from("Contact does not exist"); + return ( + axum::http::StatusCode::BAD_REQUEST, + axum::Json(response), + ); + } + } + + let mut scme = textsender_models::message::scheduling::ScheduledMessageEvent { + contact_id: payload.contact_id, + message_id: payload.message_id, + scheduled_message_id: payload.scheduled_message_id, + ..Default::default() + }; + match scheduling_repo::sched_msg_event::insert(&pool, &scme).await { + Ok((id, created)) => { + scme.id = id; + scme.created = Some(created); + response.message = String::from(super::super::super::response::SUCCESSFUL); + response.data.push(scme); + (axum::http::StatusCode::CREATED, axum::Json(response)) + } + Err(err) => { + eprintln!("Error: {err:?}"); + response.message = String::from("Error inserting"); + ( + axum::http::StatusCode::INTERNAL_SERVER_ERROR, + axum::Json(response), + ) + } + } + } else { + response.message = String::from("Request body is not valid"); + (axum::http::StatusCode::BAD_REQUEST, axum::Json(response)) + } + } } diff --git a/src/repo/message/scheduling.rs b/src/repo/message/scheduling.rs index 97af52c..674d065 100644 --- a/src/repo/message/scheduling.rs +++ b/src/repo/message/scheduling.rs @@ -101,3 +101,108 @@ async fn parse_row( user_id, }) } + +pub mod sched_msg_event { + use sqlx::Row; + + pub async fn insert( + pool: &sqlx::PgPool, + scheduled_message_event: &textsender_models::message::scheduling::ScheduledMessageEvent, + ) -> Result<(uuid::Uuid, time::OffsetDateTime), sqlx::Error> { + match sqlx::query( + r#" + INSERT INTO "scheduled_message_events" (contact_id, message_id, scheduled_message_id) + VALUES($1, $2, $3) RETURNING id, created; + "#, + ) + .bind(&scheduled_message_event.contact_id) + .bind(&scheduled_message_event.message_id) + .bind(&scheduled_message_event.scheduled_message_id) + .fetch_one(pool) + .await + { + Ok(row) => { + let id: uuid::Uuid = row.try_get("id")?; + let created: time::OffsetDateTime = row.try_get("created")?; + Ok((id, created)) + } + Err(_) => Err(sqlx::Error::RowNotFound), + } + } + + pub async fn get( + pool: &sqlx::PgPool, + id: &uuid::Uuid, + ) -> Result { + match sqlx::query( + r#" + SELECT id, contact_id, message_id, scheduled_message_id, created FROM "scheduled_message_events" + WHERE + id = $1; + "#, + ) + .bind(id) + .fetch_one(pool) + .await + { + Ok(row) => match parse_row(&row).await { + Ok(scheduled_message_event) => Ok(scheduled_message_event), + Err(err) => Err(err), + }, + Err(_) => Err(sqlx::Error::RowNotFound), + } + } + + pub async fn get_with_scheduled_message_id( + pool: &sqlx::PgPool, + scheduled_message_id: &uuid::Uuid, + ) -> Result, sqlx::Error> { + match sqlx::query( + r#" + SELECT id, contact_id, message_id, scheduled_message_id, created FROM "scheduled_message_events" + WHERE + scheduled_message_id = $1; + "#, + ) + .bind(&scheduled_message_id) + .fetch_all(pool) + .await + { + Ok(rows) => { + let mut scheduled_message_events: Vec = + Vec::new(); + for row in rows { + match parse_row(&row).await { + Ok(scheduled_message_event) => { + scheduled_message_events.push(scheduled_message_event); + } + Err(err) => { + return Err(err); + } + } + } + + Ok(scheduled_message_events) + } + Err(_) => Err(sqlx::Error::RowNotFound), + } + } + + async fn parse_row( + row: &sqlx::postgres::PgRow, + ) -> Result { + let id: uuid::Uuid = row.try_get("id")?; + let contact_id: uuid::Uuid = row.try_get("contact_id")?; + let message_id: uuid::Uuid = row.try_get("message_id")?; + let scheduled_message_id: uuid::Uuid = row.try_get("scheduled_message_id")?; + let created: time::OffsetDateTime = row.try_get("created")?; + + Ok(textsender_models::message::scheduling::ScheduledMessageEvent { + id, + contact_id, + message_id, + scheduled_message_id, + created: Some(created), + }) + } +}