Dependency name change (#33)

Reviewed-on: #33

src/auth/mod.rs

@@ -36,11 +36,11 @@ pub async fn auth<B>(
         (StatusCode::UNAUTHORIZED, Json(json_error))
     })?;
 
-    let secret_key = textsender_models::envy::environment::get_secret_main_key().value;
+    let secret_key = schedtxt_models::envy::environment::get_secret_main_key().value;
 
     let mut validation = Validation::new(jsonwebtoken::Algorithm::HS256);
-    validation.set_audience(&["textsender"]); // Must match exactly what's in the token
-    let _claims = decode::<textsender_models::token::Claims>(
+    validation.set_audience(&["schedtxt"]); // Must match exactly what's in the token
+    let _claims = decode::<schedtxt_models::token::Claims>(
         &token,
         &DecodingKey::from_secret(secret_key.as_ref()),
         &validation,

src/caller/contact.rs

@@ -49,7 +49,7 @@ pub mod response {
     #[derive(Debug, Default, Deserialize, Serialize, ToSchema)]
     pub struct AddContactResponse {
         pub message: String,
-        pub data: Vec<textsender_models::contact::Contact>,
+        pub data: Vec<schedtxt_models::contact::Contact>,
     }
 
     pub use AddContactResponse as GetContactResponse;
@@ -69,19 +69,9 @@ pub mod response {
         pub new_lastname: Option<String>,
         pub new_nickname: Option<String>,
     }
-
-    /*
-    #[derive(Debug, Default, Deserialize, Serialize, ToSchema)]
-    pub struct GetContactResponse {
-        pub message: String,
-        pub data: Vec<textsender_models::contact::Contact>,
-    }
-    */
 }
 
 pub mod endpoint {
-    // use axum::{Json, response::IntoResponse};
-
     use crate::repo::contact as contact_repo;
 
     /// Endpoint to create Contact
@@ -126,7 +116,7 @@ pub mod endpoint {
                         sqlx::Error::RowNotFound => {
                             println!("Good to create");
                             // Put code here
-                            let mut contact = textsender_models::contact::Contact {
+                            let mut contact = schedtxt_models::contact::Contact {
                                 firstname: payload.firstname,
                                 lastname: payload.lastname,
                                 phone_number: payload.phone_number,

src/caller/instant.rs

@@ -23,7 +23,7 @@ pub mod response {
     #[derive(Debug, Default, Deserialize, Serialize, ToSchema)]
     pub struct InstantMessageResponse {
         pub message: String,
-        pub data: Vec<textsender_models::message::event::MessageEventResponse>,
+        pub data: Vec<schedtxt_models::message::event::MessageEventResponse>,
     }
 }
 
@@ -57,7 +57,7 @@ pub mod endpoint {
         let mut response = super::response::InstantMessageResponse::default();
 
         if payload.is_valid() {
-            let mut contacts: Vec<textsender_models::contact::Contact> = Vec::new();
+            let mut contacts: Vec<schedtxt_models::contact::Contact> = Vec::new();
 
             for contact_id in &payload.contact_ids {
                 match contact_repo::get(&pool, contact_id).await {
@@ -81,7 +81,7 @@ pub mod endpoint {
                 match message_repo::get(&pool, &payload.message_id).await {
                     Ok(message) => {
                         println!("Valid message");
-                        let t_config = match textsender_models::config::auxiliary::load_config() {
+                        let t_config = match schedtxt_models::config::auxiliary::load_config() {
                             Ok(config) => config,
                             Err(err) => {
                                 eprintln!("Error: {err:?}");
@@ -93,7 +93,7 @@ pub mod endpoint {
                             }
                         };
                         let mut results: Vec<
-                            textsender_models::message::event::MessageEventResponse,
+                            schedtxt_models::message::event::MessageEventResponse,
                         > = Vec::new();
                         let pp = swoosh::twilio::types::Parameters {
                             schedule: false,
@@ -114,11 +114,11 @@ pub mod endpoint {
                             match sendmsg.send_message(&pp).await {
                                 Ok(result) => {
                                     let val = swoosh::twilio::api::response_to_json(result).await;
-                                    let mer = textsender_models::message::event::MessageEventResponse {
+                                    let mer = schedtxt_models::message::event::MessageEventResponse {
                                         user_id: payload.user_id,
                                         // TODO: Make this more accurate
                                         sent: Some(time::OffsetDateTime::now_utc()),
-                                        status: String::from(textsender_models::message::event::MESSAGE_EVENT_RESPONSE_STATUS_INSTANT),
+                                        status: String::from(schedtxt_models::message::event::MESSAGE_EVENT_RESPONSE_STATUS_INSTANT),
                                         contact_id: contact.id.unwrap(),
                                         message_id: message.id.unwrap(),
                                         response: val,

src/caller/message/event.rs

@@ -40,7 +40,7 @@ pub mod response {
     #[derive(Debug, Default, Deserialize, Serialize, ToSchema)]
     pub struct RecordMessageEventResponse {
         pub message: String,
-        pub data: Vec<textsender_models::message::event::MessageEventResponse>,
+        pub data: Vec<schedtxt_models::message::event::MessageEventResponse>,
     }
 
     pub use RecordMessageEventResponse as GetMERResponse;
@@ -74,7 +74,7 @@ pub mod endpoint {
         let mut response = super::response::RecordMessageEventResponse::default();
 
         if payload.is_valid() {
-            let mut mer = textsender_models::message::event::MessageEventResponse {
+            let mut mer = schedtxt_models::message::event::MessageEventResponse {
                 scheduled_message_event_id: Some(payload.scheduled_message_event_id),
                 user_id: payload.user_id,
                 sent: payload.sent,

src/caller/message/mod.rs

@@ -31,7 +31,7 @@ pub mod response {
     #[derive(Debug, Default, Deserialize, Serialize, ToSchema)]
     pub struct AddMessageResponse {
         pub message: String,
-        pub data: Vec<textsender_models::message::Message>,
+        pub data: Vec<schedtxt_models::message::Message>,
     }
 
     pub use AddMessageResponse as GetMessageResponse;
@@ -65,7 +65,7 @@ pub mod endpoint {
         let mut response = super::response::AddMessageResponse::default();
 
         if payload.is_valid() {
-            let mut msg = textsender_models::message::Message {
+            let mut msg = schedtxt_models::message::Message {
                 content: payload.content,
                 user_id: Some(payload.user_id),
                 ..Default::default()

src/caller/message/scheduling.rs

@@ -52,10 +52,10 @@ pub mod request {
     impl UpdateScheduledMessageStatusRequest {
         pub fn is_valid(&self) -> bool {
             if !self.status.is_empty() || !self.scheduled_message_id.is_nil() {
-                self.status == textsender_models::message::scheduling::PENDING
-                    || self.status == textsender_models::message::scheduling::READY
-                    || self.status == textsender_models::message::scheduling::PROCESSING
-                    || self.status == textsender_models::message::scheduling::DONE
+                self.status == schedtxt_models::message::scheduling::PENDING
+                    || self.status == schedtxt_models::message::scheduling::READY
+                    || self.status == schedtxt_models::message::scheduling::PROCESSING
+                    || self.status == schedtxt_models::message::scheduling::DONE
             } else {
                 false
             }
@@ -70,19 +70,19 @@ pub mod response {
     #[derive(Debug, Default, Deserialize, Serialize, ToSchema)]
     pub struct ScheduleMessageResponse {
         pub message: String,
-        pub data: Vec<textsender_models::message::scheduling::ScheduledMessage>,
+        pub data: Vec<schedtxt_models::message::scheduling::ScheduledMessage>,
     }
 
     #[derive(Debug, Default, Deserialize, Serialize, ToSchema)]
     pub struct GetScheduledMessageResponse {
         pub message: String,
-        pub data: Vec<textsender_models::message::scheduling::ScheduledMessage>,
+        pub data: Vec<schedtxt_models::message::scheduling::ScheduledMessage>,
     }
 
     #[derive(Debug, Default, Deserialize, Serialize, ToSchema)]
     pub struct CreateScheduleMessageEventResponse {
         pub message: String,
-        pub data: Vec<textsender_models::message::scheduling::ScheduledMessageEvent>,
+        pub data: Vec<schedtxt_models::message::scheduling::ScheduledMessageEvent>,
     }
 
     pub use CreateScheduleMessageEventResponse as GetScheduledMessageEventResponse;
@@ -133,13 +133,13 @@ pub mod endpoint {
         let mut response = super::response::ScheduleMessageResponse::default();
 
         if payload.is_valid() {
-            if payload.status != textsender_models::message::scheduling::PENDING {
+            if payload.status != schedtxt_models::message::scheduling::PENDING {
                 response.message = String::from("scheduled message must be pending");
                 (axum::http::StatusCode::BAD_REQUEST, axum::Json(response))
             } else {
                 if can_schedule(&payload.scheduled) {
                     let mut scheduled_message =
-                        textsender_models::message::scheduling::ScheduledMessage {
+                        schedtxt_models::message::scheduling::ScheduledMessage {
                             scheduled: payload.scheduled,
                             status: payload.status,
                             ..Default::default()
@@ -402,7 +402,7 @@ pub mod endpoint {
                 }
             }
 
-            let mut scme = textsender_models::message::scheduling::ScheduledMessageEvent {
+            let mut scme = schedtxt_models::message::scheduling::ScheduledMessageEvent {
                 contact_id: payload.contact_id,
                 message_id: payload.message_id,
                 scheduled_message_id: payload.scheduled_message_id,

src/config/mod.rs

@@ -46,12 +46,12 @@ pub mod init {
                 .max_age(std::time::Duration::from_secs(3600)); // Cache the preflight response for 1 hour:cite[2]
 
             // Dynamically set the allowed origin based on the environment
-            match std::env::var(textsender_models::envy::keys::APP_ENV).as_deref() {
+            match std::env::var(schedtxt_models::envy::keys::APP_ENV).as_deref() {
                 Ok("production") => {
                     // In production, allow only your specific, trusted origins
                     let allowed_origins_env =
-                        textsender_models::envy::environment::get_allowed_origins();
-                    match textsender_models::envy::utility::delimitize(&allowed_origins_env) {
+                        schedtxt_models::envy::environment::get_allowed_origins();
+                    match schedtxt_models::envy::utility::delimitize(&allowed_origins_env) {
                         Ok(alwd) => {
                             let allowed_origins: Vec<axum::http::HeaderValue> = alwd
                                 .into_iter()
@@ -93,7 +93,7 @@ pub mod init {
             event_responses::RecordMessageEventResponse
             )),
     tags(
-        (name = "textsender API", description = "Web API to manage texting")
+        (name = "schedtxt API", description = "Web API to manage texting")
     )
     )]
     struct ApiDoc;

src/db/mod.rs

@@ -5,7 +5,7 @@ pub mod connection_settings {
 }
 
 pub async fn create_pool() -> Result<sqlx::PgPool, sqlx::Error> {
-    let database_url = textsender_models::envy::environment::get_db_url().value;
+    let database_url = schedtxt_models::envy::environment::get_db_url().value;
     println!("Database url: {database_url}");
 
     PgPoolOptions::new()

src/main.rs

@@ -3,10 +3,10 @@ async fn main() {
     // initialize tracing
     tracing_subscriber::fmt::init();
 
-    match tokio::net::TcpListener::bind(textsender_api::config::host::get_full()).await {
+    match tokio::net::TcpListener::bind(schedtxt_api::config::host::get_full()).await {
         Ok(listener) => {
             // build our application with routes
-            let app = textsender_api::config::init::app().await;
+            let app = schedtxt_api::config::init::app().await;
             axum::serve(listener, app).await.unwrap();
         }
         Err(err) => {

src/repo/contact.rs

@@ -2,7 +2,7 @@ use sqlx::Row;
 
 pub async fn insert(
     pool: &sqlx::PgPool,
-    contact: &textsender_models::contact::Contact,
+    contact: &schedtxt_models::contact::Contact,
 ) -> Result<uuid::Uuid, sqlx::Error> {
     match sqlx::query(
         r#"
@@ -29,7 +29,7 @@ pub async fn insert(
 pub async fn get(
     pool: &sqlx::PgPool,
     id: &uuid::Uuid,
-) -> Result<textsender_models::contact::Contact, sqlx::Error> {
+) -> Result<schedtxt_models::contact::Contact, sqlx::Error> {
     match sqlx::query(
         r#"
         SELECT id, firstname, lastname, nickname, phone_number, user_id FROM "contacts"
@@ -46,7 +46,7 @@ pub async fn get(
 
             let phone_number: String = row.try_get("phone_number")?;
             let user_id: uuid::Uuid = row.try_get("user_id")?;
-            Ok(textsender_models::contact::Contact {
+            Ok(schedtxt_models::contact::Contact {
                 id: Some(id),
                 firstname: match row.try_get("firstname") {
                     Ok(val) => val,
@@ -81,7 +81,7 @@ pub async fn get_with_user_id_and_phone(
     pool: &sqlx::PgPool,
     user_id: &uuid::Uuid,
     phone_number: &str,
-) -> Result<textsender_models::contact::Contact, sqlx::Error> {
+) -> Result<schedtxt_models::contact::Contact, sqlx::Error> {
     match sqlx::query(
         r#"
         SELECT id, firstname, lastname, nickname, phone_number, user_id FROM "contacts"
@@ -103,7 +103,7 @@ pub async fn get_with_user_id_and_phone(
             let phone_number: String = row.try_get("phone_number")?;
             let user_id: uuid::Uuid = row.try_get("user_id")?;
             println!("Found");
-            Ok(textsender_models::contact::Contact {
+            Ok(schedtxt_models::contact::Contact {
                 id: Some(id),
                 firstname: Some(firstname),
                 lastname: Some(lastname),
@@ -122,7 +122,7 @@ pub async fn get_with_user_id_and_phone(
 pub async fn get_with_user_id(
     pool: &sqlx::PgPool,
     user_id: &uuid::Uuid,
-) -> Result<Vec<textsender_models::contact::Contact>, sqlx::Error> {
+) -> Result<Vec<schedtxt_models::contact::Contact>, sqlx::Error> {
     match sqlx::query(
         r#"
         SELECT id, firstname, lastname, nickname, phone_number, user_id FROM "contacts"
@@ -135,13 +135,13 @@ pub async fn get_with_user_id(
     .await
     {
         Ok(rows) => {
-            let mut contacts: Vec<textsender_models::contact::Contact> = Vec::new();
+            let mut contacts: Vec<schedtxt_models::contact::Contact> = Vec::new();
             for row in rows {
                 let id: uuid::Uuid = row.try_get("id")?;
 
                 let phone_number: String = row.try_get("phone_number")?;
                 let user_id: uuid::Uuid = row.try_get("user_id")?;
-                let contact = textsender_models::contact::Contact {
+                let contact = schedtxt_models::contact::Contact {
                     id: Some(id),
                     firstname: match row.try_get("firstname") {
                         Ok(val) => val,

src/repo/message/event.rs

@@ -2,7 +2,7 @@ use sqlx::Row;
 
 pub async fn insert(
     pool: &sqlx::PgPool,
-    event: &textsender_models::message::event::MessageEventResponse,
+    event: &schedtxt_models::message::event::MessageEventResponse,
 ) -> Result<uuid::Uuid, sqlx::Error> {
     match sqlx::query(
         r#"
@@ -31,7 +31,7 @@ pub async fn insert(
 pub async fn get(
     pool: &sqlx::PgPool,
     id: &uuid::Uuid,
-) -> Result<textsender_models::message::event::MessageEventResponse, sqlx::Error> {
+) -> Result<schedtxt_models::message::event::MessageEventResponse, sqlx::Error> {
     match sqlx::query(
         r#"
         SELECT id, scheduled_message_event_id, response, user_id, sent, contact_id, message_id, status FROM "message_event_responses"
@@ -54,7 +54,7 @@ pub async fn get(
 pub async fn get_with_user_id(
     pool: &sqlx::PgPool,
     user_id: &uuid::Uuid,
-) -> Result<Vec<textsender_models::message::event::MessageEventResponse>, sqlx::Error> {
+) -> Result<Vec<schedtxt_models::message::event::MessageEventResponse>, sqlx::Error> {
     match sqlx::query(
         r#"
         SELECT id, scheduled_message_event_id, response, user_id, sent, contact_id, message_id, status FROM "message_event_responses"
@@ -67,7 +67,7 @@ pub async fn get_with_user_id(
     .await
     {
         Ok(rows) => {
-            let mut events: Vec<textsender_models::message::event::MessageEventResponse> =
+            let mut events: Vec<schedtxt_models::message::event::MessageEventResponse> =
                 Vec::new();
             for row in rows {
                 match parse_row(&row).await {
@@ -88,7 +88,7 @@ pub async fn get_with_user_id(
 
 async fn parse_row(
     row: &sqlx::postgres::PgRow,
-) -> Result<textsender_models::message::event::MessageEventResponse, sqlx::Error> {
+) -> Result<schedtxt_models::message::event::MessageEventResponse, sqlx::Error> {
     println!("Parsing MER");
     let id: uuid::Uuid = row.try_get("id")?;
     let response: serde_json::Value = row.try_get("response")?;
@@ -101,7 +101,7 @@ async fn parse_row(
         .unwrap_or_default();
     let user_id: uuid::Uuid = row.try_get("user_id")?;
 
-    Ok(textsender_models::message::event::MessageEventResponse {
+    Ok(schedtxt_models::message::event::MessageEventResponse {
         id,
         response,
         contact_id,

src/repo/message/mod.rs

@@ -5,7 +5,7 @@ use sqlx::Row;
 
 pub async fn insert(
     pool: &sqlx::PgPool,
-    message: &textsender_models::message::Message,
+    message: &schedtxt_models::message::Message,
     user_id: &uuid::Uuid,
 ) -> Result<uuid::Uuid, sqlx::Error> {
     match sqlx::query(
@@ -30,7 +30,7 @@ pub async fn insert(
 pub async fn get(
     pool: &sqlx::PgPool,
     id: &uuid::Uuid,
-) -> Result<textsender_models::message::Message, sqlx::Error> {
+) -> Result<schedtxt_models::message::Message, sqlx::Error> {
     match sqlx::query(
         r#"
         SELECT id, content, user_id FROM "messages"
@@ -47,7 +47,7 @@ pub async fn get(
 
             let content: String = row.try_get("content")?;
             let user_id: uuid::Uuid = row.try_get("user_id")?;
-            Ok(textsender_models::message::Message {
+            Ok(schedtxt_models::message::Message {
                 id: Some(id),
                 content,
                 user_id: Some(user_id),
@@ -60,7 +60,7 @@ pub async fn get(
 pub async fn get_with_user_id(
     pool: &sqlx::PgPool,
     user_id: &uuid::Uuid,
-) -> Result<Vec<textsender_models::message::Message>, sqlx::Error> {
+) -> Result<Vec<schedtxt_models::message::Message>, sqlx::Error> {
     match sqlx::query(
         r#"
         SELECT id, content, user_id FROM "messages"
@@ -73,13 +73,13 @@ pub async fn get_with_user_id(
     .await
     {
         Ok(rows) => {
-            let mut messages: Vec<textsender_models::message::Message> = Vec::new();
+            let mut messages: Vec<schedtxt_models::message::Message> = Vec::new();
             for row in rows {
                 let id: uuid::Uuid = row.try_get("id")?;
                 let content: String = row.try_get("content")?;
                 let user_id: uuid::Uuid = row.try_get("user_id")?;
 
-                let message = textsender_models::message::Message {
+                let message = schedtxt_models::message::Message {
                     id: Some(id),
                     content,
                     user_id: Some(user_id),

src/repo/message/scheduling.rs

@@ -2,7 +2,7 @@ use sqlx::Row;
 
 pub async fn insert(
     pool: &sqlx::PgPool,
-    scheduled_message: &textsender_models::message::scheduling::ScheduledMessage,
+    scheduled_message: &schedtxt_models::message::scheduling::ScheduledMessage,
     user_id: &uuid::Uuid,
 ) -> Result<(uuid::Uuid, time::OffsetDateTime), sqlx::Error> {
     match sqlx::query(
@@ -29,7 +29,7 @@ pub async fn insert(
 pub async fn get(
     pool: &sqlx::PgPool,
     id: &uuid::Uuid,
-) -> Result<textsender_models::message::scheduling::ScheduledMessage, sqlx::Error> {
+) -> Result<schedtxt_models::message::scheduling::ScheduledMessage, sqlx::Error> {
     match sqlx::query(
         r#"
         SELECT id, scheduled, created, status, user_id FROM "scheduled_messages"
@@ -52,7 +52,7 @@ pub async fn get(
 pub async fn get_with_user_id(
     pool: &sqlx::PgPool,
     user_id: &uuid::Uuid,
-) -> Result<Vec<textsender_models::message::scheduling::ScheduledMessage>, sqlx::Error> {
+) -> Result<Vec<schedtxt_models::message::scheduling::ScheduledMessage>, sqlx::Error> {
     match sqlx::query(
         r#"
         SELECT id, scheduled, created, status, user_id FROM "scheduled_messages"
@@ -65,7 +65,7 @@ pub async fn get_with_user_id(
     .await
     {
         Ok(rows) => {
-            let mut messages: Vec<textsender_models::message::scheduling::ScheduledMessage> =
+            let mut messages: Vec<schedtxt_models::message::scheduling::ScheduledMessage> =
                 Vec::new();
             for row in rows {
                 match parse_row(&row).await {
@@ -86,7 +86,7 @@ pub async fn get_with_user_id(
 
 pub async fn fetch(
     pool: &sqlx::PgPool,
-) -> Result<textsender_models::message::scheduling::ScheduledMessage, sqlx::Error> {
+) -> Result<schedtxt_models::message::scheduling::ScheduledMessage, sqlx::Error> {
     match sqlx::query(
         r#"
         UPDATE "scheduled_messages"
@@ -101,8 +101,8 @@ pub async fn fetch(
 		RETURNING id, scheduled, created, status, user_id
         "#,
     )
-    .bind(textsender_models::message::scheduling::PROCESSING)
-    .bind(textsender_models::message::scheduling::READY)
+    .bind(schedtxt_models::message::scheduling::PROCESSING)
+    .bind(schedtxt_models::message::scheduling::READY)
     .fetch_one(pool)
     .await
     {
@@ -136,14 +136,14 @@ pub async fn update_status(
 
 async fn parse_row(
     row: &sqlx::postgres::PgRow,
-) -> Result<textsender_models::message::scheduling::ScheduledMessage, sqlx::Error> {
+) -> Result<schedtxt_models::message::scheduling::ScheduledMessage, sqlx::Error> {
     let id: uuid::Uuid = row.try_get("id")?;
     let scheduled: time::OffsetDateTime = row.try_get("scheduled")?;
     let status: String = row.try_get("status")?;
     let created: time::OffsetDateTime = row.try_get("created")?;
     let user_id: uuid::Uuid = row.try_get("user_id")?;
 
-    Ok(textsender_models::message::scheduling::ScheduledMessage {
+    Ok(schedtxt_models::message::scheduling::ScheduledMessage {
         id,
         scheduled: Some(scheduled),
         created: Some(created),
@@ -157,7 +157,7 @@ pub mod sched_msg_event {
 
     pub async fn insert(
         pool: &sqlx::PgPool,
-        scheduled_message_event: &textsender_models::message::scheduling::ScheduledMessageEvent,
+        scheduled_message_event: &schedtxt_models::message::scheduling::ScheduledMessageEvent,
     ) -> Result<(uuid::Uuid, time::OffsetDateTime), sqlx::Error> {
         match sqlx::query(
             r#"
@@ -183,7 +183,7 @@ pub mod sched_msg_event {
     pub async fn get(
         pool: &sqlx::PgPool,
         id: &uuid::Uuid,
-    ) -> Result<textsender_models::message::scheduling::ScheduledMessageEvent, sqlx::Error> {
+    ) -> Result<schedtxt_models::message::scheduling::ScheduledMessageEvent, sqlx::Error> {
         match sqlx::query(
             r#"
             SELECT id, contact_id, message_id, scheduled_message_id, created FROM "scheduled_message_events"
@@ -206,8 +206,7 @@ pub mod sched_msg_event {
     pub async fn get_with_scheduled_message_id(
         pool: &sqlx::PgPool,
         scheduled_message_id: &uuid::Uuid,
-    ) -> Result<Vec<textsender_models::message::scheduling::ScheduledMessageEvent>, sqlx::Error>
-    {
+    ) -> Result<Vec<schedtxt_models::message::scheduling::ScheduledMessageEvent>, sqlx::Error> {
         match sqlx::query(
             r#"
             SELECT id, contact_id, message_id, scheduled_message_id, created FROM "scheduled_message_events"
@@ -220,7 +219,7 @@ pub mod sched_msg_event {
         .await
         {
             Ok(rows) => {
-                let mut scheduled_message_events: Vec<textsender_models::message::scheduling::ScheduledMessageEvent> =
+                let mut scheduled_message_events: Vec<schedtxt_models::message::scheduling::ScheduledMessageEvent> =
                     Vec::new();
                 for row in rows {
                     match parse_row(&row).await {
@@ -241,7 +240,7 @@ pub mod sched_msg_event {
 
     pub async fn delete(
         pool: &sqlx::PgPool,
-        scheduled_message_event: &textsender_models::message::scheduling::ScheduledMessageEvent,
+        scheduled_message_event: &schedtxt_models::message::scheduling::ScheduledMessageEvent,
     ) -> Result<(), sqlx::Error> {
         match sqlx::query(
             r#"
@@ -260,7 +259,7 @@ pub mod sched_msg_event {
 
     async fn parse_row(
         row: &sqlx::postgres::PgRow,
-    ) -> Result<textsender_models::message::scheduling::ScheduledMessageEvent, sqlx::Error> {
+    ) -> Result<schedtxt_models::message::scheduling::ScheduledMessageEvent, sqlx::Error> {
         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")?;
@@ -268,7 +267,7 @@ pub mod sched_msg_event {
         let created: time::OffsetDateTime = row.try_get("created")?;
 
         Ok(
-            textsender_models::message::scheduling::ScheduledMessageEvent {
+            schedtxt_models::message::scheduling::ScheduledMessageEvent {
                 id,
                 contact_id,
                 message_id,