Updating name references for library

Cargo.lock

@@ -2230,6 +2230,22 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "schedtxt_models"
+version = "0.5.3"
+source = "git+ssh://git@git.kundeng.us/phoenix/schedtxt_models.git?tag=v0.5.3#597af4e84c082bb437cc94817bb19592614681a5"
+dependencies = [
+ "const_format",
+ "dotenvy",
+ "josekit",
+ "serde",
+ "serde_json",
+ "sqlx",
+ "time",
+ "utoipa",
+ "uuid",
+]
+
 [[package]]
 name = "scopeguard"
 version = "1.2.0"
@@ -2781,11 +2797,11 @@ dependencies = [
  "axum-extra",
  "josekit",
  "jsonwebtoken",
+ "schedtxt_models",
  "serde",
  "serde_json",
  "sqlx",
  "swoosh",
- "textsender_models",
  "time",
  "tokio",
  "tower",

Cargo.toml

@@ -18,7 +18,7 @@ time = { version = "0.3.53", features = ["formatting", "macros", "parsing", "ser
 jsonwebtoken = { version = "10.4.0", features = ["rust_crypto"] }
 utoipa = { version = "5.5.0", features = ["axum_extras"] }
 utoipa-swagger-ui = { version = "9.0.2", features = ["axum"] }
-textsender_models = { git = "ssh://git@git.kundeng.us/phoenix/textsender_models.git", tag = "v0.5.2" }
+schedtxt_models = { git = "ssh://git@git.kundeng.us/phoenix/schedtxt_models.git", tag = "v0.5.3" }
 swoosh = { git = "ssh://git@git.kundeng.us/phoenix/swoosh.git", tag = "v0.5.3" }
 
 [dev-dependencies]

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>(
+    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 == schedtxt_models::message::scheduling::PENDING
-                    || self.status == textsender_models::message::scheduling::READY
+                    || self.status == schedtxt_models::message::scheduling::READY
-                    || self.status == textsender_models::message::scheduling::PROCESSING
+                    || self.status == schedtxt_models::message::scheduling::PROCESSING
-                    || self.status == textsender_models::message::scheduling::DONE
+                    || 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();
+                        schedtxt_models::envy::environment::get_allowed_origins();
-                    match textsender_models::envy::utility::delimitize(&allowed_origins_env) {
+                    match schedtxt_models::envy::utility::delimitize(&allowed_origins_env) {
                         Ok(alwd) => {
                             let allowed_origins: Vec<axum::http::HeaderValue> = alwd
                                 .into_iter()

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/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(schedtxt_models::message::scheduling::PROCESSING)
-    .bind(textsender_models::message::scheduling::READY)
+    .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,

tests/test.rs

@@ -6,7 +6,7 @@ mod db_mgr {
     pub const LIMIT: usize = 6;
 
     pub async fn get_pool() -> Result<sqlx::PgPool, sqlx::Error> {
-        let tm_db_url = textsender_models::envy::environment::get_db_url().value;
+        let tm_db_url = schedtxt_models::envy::environment::get_db_url().value;
         let tm_options = sqlx::postgres::PgConnectOptions::from_str(&tm_db_url).unwrap();
         sqlx::PgPool::connect_with(tm_options).await
     }
@@ -18,7 +18,7 @@ mod db_mgr {
     }
 
     pub async fn connect_to_db(db_name: &str) -> Result<sqlx::PgPool, sqlx::Error> {
-        let db_url = textsender_models::envy::environment::get_db_url().value;
+        let db_url = schedtxt_models::envy::environment::get_db_url().value;
         let options = sqlx::postgres::PgConnectOptions::from_str(&db_url)?.database(db_name);
         sqlx::PgPool::connect_with(options).await
     }
@@ -77,7 +77,7 @@ mod db_mgr {
     }
 
     pub async fn get_database_name() -> Result<String, Box<dyn std::error::Error>> {
-        let database_url = textsender_models::envy::environment::get_db_url().value;
+        let database_url = schedtxt_models::envy::environment::get_db_url().value;
         let parsed_url = url::Url::parse(&database_url)?;
 
         if parsed_url.scheme() == "postgres" || parsed_url.scheme() == "postgresql" {
@@ -185,17 +185,17 @@ pub fn test_mer_response() -> serde_json::Value {
 }
 
 pub async fn test_token() -> Result<String, josekit::JoseError> {
-    let key: String = textsender_models::envy::environment::get_secret_main_key().value;
+    let key: String = schedtxt_models::envy::environment::get_secret_main_key().value;
     let (message, issuer, audience) = token_fields();
 
-    let token_resource = textsender_models::token::TokenResource {
+    let token_resource = schedtxt_models::token::TokenResource {
         message: message,
         issuer: issuer,
         audiences: vec![audience],
         user_id: TEST_USER_ID,
     };
 
-    match textsender_models::token::create_token(&key, token_resource, time::Duration::hours(1)) {
+    match schedtxt_models::token::create_token(&key, token_resource, time::Duration::hours(1)) {
         Ok(access_token) => Ok(access_token.access_token),
         Err(err) => Err(err),
     }
@@ -372,7 +372,7 @@ mod request {
                     "response": super::super::super::test_mer_response(),
                     "user_id": user_id,
                     "sent": sent,
-                    "status": textsender_models::message::event::MESSAGE_EVENT_RESPONSE_STATUS_SCHEDULED,
+                    "status": schedtxt_models::message::event::MESSAGE_EVENT_RESPONSE_STATUS_SCHEDULED,
                     "contact_id": contact_id,
                     "message_id": message_id
                 });
@@ -430,7 +430,7 @@ mod request {
 
                 let payload = serde_json::json!({
                     "scheduled": scheduled,
-                    "status": textsender_models::message::scheduling::PENDING,
+                    "status": schedtxt_models::message::scheduling::PENDING,
                     "user_id": super::super::super::TEST_USER_ID,
                 });
 
@@ -683,7 +683,7 @@ async fn test_update_contact_names() {
     let (tm_pool, db_name, pool) = db_mgr::get_database_ready().await;
     let app = init::app(pool).await;
 
-    let mut opt_contact: Option<textsender_models::contact::Contact> = None;
+    let mut opt_contact: Option<schedtxt_models::contact::Contact> = None;
 
     // Send request
     match request::create_contact(&app).await {
@@ -786,7 +786,7 @@ async fn test_create_message() {
 async fn test_get_message() {
     let (tm_pool, db_name, pool) = db_mgr::get_database_ready().await;
     let app = init::app(pool).await;
-    let mut message_result: Option<textsender_models::message::Message> = None;
+    let mut message_result: Option<schedtxt_models::message::Message> = None;
 
     // Send request
     match request::message::create_message(&app).await {
@@ -1239,7 +1239,7 @@ async fn test_update_scheduled_message_status() {
     match request::message::scheduling::update_scheduled_message_status(
         &app,
         &scheduled_message_id,
-        textsender_models::message::scheduling::READY,
+        schedtxt_models::message::scheduling::READY,
     )
     .await
     {
@@ -1333,7 +1333,7 @@ async fn test_fetch_scheduled_message() {
     match request::message::scheduling::update_scheduled_message_status(
         &app,
         &scheduled_message_id,
-        textsender_models::message::scheduling::READY,
+        schedtxt_models::message::scheduling::READY,
     )
     .await
     {
@@ -1443,7 +1443,7 @@ async fn test_record_message_event_response() {
     match request::message::scheduling::update_scheduled_message_status(
         &app,
         &scheduled_message_id,
-        textsender_models::message::scheduling::READY,
+        schedtxt_models::message::scheduling::READY,
     )
     .await
     {
@@ -1580,7 +1580,7 @@ async fn test_get_message_event_response() {
     match request::message::scheduling::update_scheduled_message_status(
         &app,
         &scheduled_message_id,
-        textsender_models::message::scheduling::READY,
+        schedtxt_models::message::scheduling::READY,
     )
     .await
     {