Updating name references

Cargo.lock

@@ -135,9 +135,9 @@ name = "catapult"
 version = "0.3.4"
 dependencies = [
  "reqwest",
+ "schedtxt_models",
  "serde_json",
  "swoosh",
- "textsender_models",
  "time",
  "tokio",
  "uuid",
@@ -1643,6 +1643,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"

Cargo.toml

@@ -10,7 +10,7 @@ reqwest = { version = "0.13.4", features = ["json", "stream", "multipart"] }
 serde_json = { version = "1.0.150" }
 time = { version = "0.3.53", features = ["formatting", "macros", "parsing", "serde"] }
 uuid = { version = "1.23.5", features = ["v4", "serde"] }
-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/app.rs

@@ -9,11 +9,11 @@ pub struct App {
     pub auth_url: String,
     pub service_username: String,
     pub service_passphrase: String,
-    pub twilio_config: textsender_models::config::auxiliary::TwilioConfig,
+    pub twilio_config: schedtxt_models::config::auxiliary::TwilioConfig,
 }
 
 pub fn load_app() -> Result<App, std::io::Error> {
-    use textsender_models::envy;
+    use schedtxt_models::envy;
     let auth_url_env = envy::environment::get_env("AUTH_URL");
     let api_url_env = envy::environment::get_env("API_URL");
     let service_username_env = envy::environment::get_env("SERVICE_USERNAME");
@@ -41,7 +41,7 @@ pub fn load_app() -> Result<App, std::io::Error> {
         let api_url: String = api_url_env.value;
         let service_username: String = service_username_env.value;
         let service_passphrase: String = service_passphrase_env.value;
-        match textsender_models::config::auxiliary::load_config() {
+        match schedtxt_models::config::auxiliary::load_config() {
             Ok(twilio_config) => Ok(App {
                 api_url,
                 auth_url,

src/service/auth.rs

@@ -3,7 +3,7 @@ pub struct Auth {
 }
 
 impl Auth {
-    pub async fn get_token(&self) -> Result<textsender_models::token::Login, std::io::Error> {
+    pub async fn get_token(&self) -> Result<schedtxt_models::token::Login, std::io::Error> {
         let client = reqwest::Client::new();
         let endpoint = String::from("api/v1/service/login");
         let api_url = format!("{}/{endpoint}", self.app.auth_url);
@@ -37,8 +37,8 @@ impl Auth {
 
     pub async fn get_refresh_token(
         &self,
-        login_result: &textsender_models::token::Login,
+        login_result: &schedtxt_models::token::Login,
-    ) -> Result<textsender_models::token::Login, std::io::Error> {
+    ) -> Result<schedtxt_models::token::Login, std::io::Error> {
         let client = reqwest::Client::new();
         let endpoint = String::from("api/v1/token/refresh");
         let api_url = format!("{}/{endpoint}", self.app.auth_url);
@@ -70,7 +70,7 @@ impl Auth {
 
 async fn parse_token_response(
     response: &str,
-) -> Result<textsender_models::token::LoginResult, std::io::Error> {
+) -> Result<schedtxt_models::token::LoginResult, std::io::Error> {
     match serde_json::from_str::<serde_json::Value>(response) {
         Ok(j) => {
             println!("Good");
@@ -85,7 +85,7 @@ async fn parse_token_response(
                         Err(std::io::Error::other("Error response is empty"))
                     } else {
                         let lr = lrs[0].clone();
-                        let ll: textsender_models::token::LoginResult =
+                        let ll: schedtxt_models::token::LoginResult =
                             match serde_json::from_value(lr) {
                                 Ok(lr) => lr,
                                 Err(err) => {
@@ -102,7 +102,7 @@ async fn parse_token_response(
     }
 }
 
-pub async fn has_token_expired(token: &textsender_models::token::LoginResult) -> bool {
+pub async fn has_token_expired(token: &schedtxt_models::token::LoginResult) -> bool {
     let now = time::OffsetDateTime::now_utc();
     let expire = match time::OffsetDateTime::from_unix_timestamp(token.expires_in) {
         Ok(res) => res,

src/service/contact.rs

@@ -1,13 +1,13 @@
 pub struct Contact {
     pub app: std::sync::Arc<crate::app::App>,
-    pub token: std::sync::Arc<textsender_models::token::LoginResult>,
+    pub token: std::sync::Arc<schedtxt_models::token::LoginResult>,
 }
 
 impl Contact {
     pub async fn get(
         &self,
         contact_id: &uuid::Uuid,
-    ) -> Result<Vec<textsender_models::contact::Contact>, std::io::Error> {
+    ) -> Result<Vec<schedtxt_models::contact::Contact>, std::io::Error> {
         let client = reqwest::Client::new();
         let endpoint = format!("api/v1/contact?id={contact_id}");
         let api_url = format!("{}/{endpoint}", self.app.api_url);
@@ -34,17 +34,17 @@ impl Contact {
 
 async fn parse_response(
     response: &str,
-) -> Result<Vec<textsender_models::contact::Contact>, std::io::Error> {
+) -> Result<Vec<schedtxt_models::contact::Contact>, std::io::Error> {
     match serde_json::from_str::<serde_json::Value>(response) {
         Ok(j) => match j.get("data") {
             Some(serde_json::Value::Array(lrs)) => {
                 if lrs.is_empty() {
                     Err(std::io::Error::other("Error response is empty"))
                 } else {
-                    let mut events: Vec<textsender_models::contact::Contact> = Vec::new();
+                    let mut events: Vec<schedtxt_models::contact::Contact> = Vec::new();
 
                     for event in lrs.iter() {
-                        let ll: textsender_models::contact::Contact =
+                        let ll: schedtxt_models::contact::Contact =
                             match serde_json::from_value(event.clone()) {
                                 Ok(lr) => lr,
                                 Err(err) => {

src/service/core.rs

@@ -1,13 +1,13 @@
 pub struct Service {
     pub app: std::sync::Arc<crate::app::App>,
-    pub token: std::sync::Arc<textsender_models::token::Login>,
+    pub token: std::sync::Arc<schedtxt_models::token::Login>,
 }
 
 impl Service {
     pub async fn do_the_work(&mut self) {
         println!("Checking queue");
 
-        use textsender_models::message::scheduling::ScheduledMessage;
+        use schedtxt_models::message::scheduling::ScheduledMessage;
 
         let queue = super::queue::Queue {
             app: std::sync::Arc::clone(&self.app),
@@ -120,7 +120,7 @@ impl Service {
                     println!("Message scheduled");
                     // MER response
                     let result = swoosh::twilio::api::response_to_json(resp).await;
-                    let mer = textsender_models::message::event::MessageEventResponse {
+                    let mer = schedtxt_models::message::event::MessageEventResponse {
                         contact_id: contact.id.unwrap(),
                         scheduled_message_event_id: Some(event.id),
                         response: result,
@@ -151,7 +151,7 @@ impl Service {
 
     fn is_schedulable(
         &self,
-        queue_item: &textsender_models::message::scheduling::ScheduledMessage,
+        queue_item: &schedtxt_models::message::scheduling::ScheduledMessage,
     ) -> bool {
         match queue_item.scheduled {
             Some(date) => date > time::OffsetDateTime::now_utc(),

src/service/event.rs

@@ -1,13 +1,13 @@
 pub struct Event {
     pub app: std::sync::Arc<crate::app::App>,
-    pub token: std::sync::Arc<textsender_models::token::LoginResult>,
+    pub token: std::sync::Arc<schedtxt_models::token::LoginResult>,
 }
 
 impl Event {
     pub async fn get(
         &self,
         scheduled_message_id: &uuid::Uuid,
-    ) -> Result<Vec<textsender_models::message::scheduling::ScheduledMessageEvent>, std::io::Error>
+    ) -> Result<Vec<schedtxt_models::message::scheduling::ScheduledMessageEvent>, std::io::Error>
     {
         let client = reqwest::Client::new();
         let endpoint =
@@ -38,7 +38,7 @@ impl Event {
 
 async fn parse_response(
     response: &str,
-) -> Result<Vec<textsender_models::message::scheduling::ScheduledMessageEvent>, std::io::Error> {
+) -> Result<Vec<schedtxt_models::message::scheduling::ScheduledMessageEvent>, std::io::Error> {
     match serde_json::from_str::<serde_json::Value>(response) {
         Ok(j) => match j.get("data") {
             Some(serde_json::Value::Array(lrs)) => {
@@ -46,11 +46,11 @@ async fn parse_response(
                     Err(std::io::Error::other("Error response is empty"))
                 } else {
                     let mut events: Vec<
-                        textsender_models::message::scheduling::ScheduledMessageEvent,
+                        schedtxt_models::message::scheduling::ScheduledMessageEvent,
                     > = Vec::new();
 
                     for event in lrs.iter() {
-                        let ll: textsender_models::message::scheduling::ScheduledMessageEvent =
+                        let ll: schedtxt_models::message::scheduling::ScheduledMessageEvent =
                             match serde_json::from_value(event.clone()) {
                                 Ok(lr) => lr,
                                 Err(err) => {

src/service/mer.rs

@@ -1,13 +1,13 @@
 pub struct MessageEventResponse {
     pub app: std::sync::Arc<crate::app::App>,
-    pub token: std::sync::Arc<textsender_models::token::LoginResult>,
+    pub token: std::sync::Arc<schedtxt_models::token::LoginResult>,
 }
 
 impl MessageEventResponse {
     pub async fn record_message_event_response(
         &self,
-        mer: &textsender_models::message::event::MessageEventResponse,
+        mer: &schedtxt_models::message::event::MessageEventResponse,
-    ) -> Result<textsender_models::message::event::MessageEventResponse, std::io::Error> {
+    ) -> Result<schedtxt_models::message::event::MessageEventResponse, std::io::Error> {
         let client = reqwest::Client::new();
         let endpoint = String::from("api/v1/schedule/message/event/response/record");
         let api_url = format!("{}/{endpoint}", self.app.api_url);
@@ -27,7 +27,7 @@ impl MessageEventResponse {
             "response": mer.response,
             "user_id": mer.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": mer.contact_id,
             "message_id": mer.message_id
         });
@@ -79,7 +79,7 @@ impl MessageEventResponse {
 
 async fn parse_response(
     response: &str,
-) -> Result<textsender_models::message::event::MessageEventResponse, std::io::Error> {
+) -> Result<schedtxt_models::message::event::MessageEventResponse, std::io::Error> {
     match serde_json::from_str::<serde_json::Value>(response) {
         Ok(j) => {
             println!("Good");
@@ -94,7 +94,7 @@ async fn parse_response(
                         Err(std::io::Error::other("Error response is empty"))
                     } else {
                         let lr = lrs[0].clone();
-                        let ll: textsender_models::message::event::MessageEventResponse =
+                        let ll: schedtxt_models::message::event::MessageEventResponse =
                             match serde_json::from_value(lr) {
                                 Ok(lr) => lr,
                                 Err(err) => {

src/service/message.rs

@@ -1,13 +1,13 @@
 pub struct Message {
     pub app: std::sync::Arc<crate::app::App>,
-    pub token: std::sync::Arc<textsender_models::token::LoginResult>,
+    pub token: std::sync::Arc<schedtxt_models::token::LoginResult>,
 }
 
 impl Message {
     pub async fn get(
         &self,
         message_id: &uuid::Uuid,
-    ) -> Result<Vec<textsender_models::message::Message>, std::io::Error> {
+    ) -> Result<Vec<schedtxt_models::message::Message>, std::io::Error> {
         let client = reqwest::Client::new();
         let endpoint = format!("api/v1/message?id={message_id}");
         let api_url = format!("{}/{endpoint}", self.app.api_url);
@@ -34,17 +34,17 @@ impl Message {
 
 async fn parse_response(
     response: &str,
-) -> Result<Vec<textsender_models::message::Message>, std::io::Error> {
+) -> Result<Vec<schedtxt_models::message::Message>, std::io::Error> {
     match serde_json::from_str::<serde_json::Value>(response) {
         Ok(j) => match j.get("data") {
             Some(serde_json::Value::Array(lrs)) => {
                 if lrs.is_empty() {
                     Err(std::io::Error::other("Error response is empty"))
                 } else {
-                    let mut events: Vec<textsender_models::message::Message> = Vec::new();
+                    let mut events: Vec<schedtxt_models::message::Message> = Vec::new();
 
                     for event in lrs.iter() {
-                        let ll: textsender_models::message::Message =
+                        let ll: schedtxt_models::message::Message =
                             match serde_json::from_value(event.clone()) {
                                 Ok(lr) => lr,
                                 Err(err) => {

src/service/queue.rs

@@ -1,12 +1,12 @@
 pub struct Queue {
     pub app: std::sync::Arc<crate::app::App>,
-    pub token: std::sync::Arc<textsender_models::token::LoginResult>,
+    pub token: std::sync::Arc<schedtxt_models::token::LoginResult>,
 }
 
 impl Queue {
     pub async fn get_queue(
         &self,
-    ) -> Result<textsender_models::message::scheduling::ScheduledMessage, std::io::Error> {
+    ) -> Result<schedtxt_models::message::scheduling::ScheduledMessage, std::io::Error> {
         let client = reqwest::Client::new();
         let endpoint = String::from("api/v1/schedule/message/fetch");
         let api_url = format!("{}/{endpoint}", self.app.api_url);
@@ -36,7 +36,7 @@ impl Queue {
 
 async fn parse_queue_response(
     response: &str,
-) -> Result<textsender_models::message::scheduling::ScheduledMessage, std::io::Error> {
+) -> Result<schedtxt_models::message::scheduling::ScheduledMessage, std::io::Error> {
     match serde_json::from_str::<serde_json::Value>(response) {
         Ok(j) => {
             let message = &j["message"];
@@ -50,7 +50,7 @@ async fn parse_queue_response(
                         Err(std::io::Error::other("Error response is empty"))
                     } else {
                         let lr = lrs[0].clone();
-                        let ll: textsender_models::message::scheduling::ScheduledMessage =
+                        let ll: schedtxt_models::message::scheduling::ScheduledMessage =
                             match serde_json::from_value(lr) {
                                 Ok(lr) => lr,
                                 Err(err) => {

src/service/scheduler.rs

@@ -1,13 +1,13 @@
 pub struct ScheduledMessage {
     pub app: std::sync::Arc<crate::app::App>,
-    pub token: std::sync::Arc<textsender_models::token::LoginResult>,
+    pub token: std::sync::Arc<schedtxt_models::token::LoginResult>,
 }
 
 impl ScheduledMessage {
     pub async fn get(
         &self,
         scheduled_message_id: &uuid::Uuid,
-    ) -> Result<textsender_models::message::scheduling::ScheduledMessage, std::io::Error> {
+    ) -> Result<schedtxt_models::message::scheduling::ScheduledMessage, std::io::Error> {
         let client = reqwest::Client::new();
         let endpoint = format!("api/v1/schedule/message?id={scheduled_message_id}");
         let api_url = format!("{}/{endpoint}", self.app.api_url);
@@ -34,14 +34,14 @@ impl ScheduledMessage {
 
 async fn parse_response(
     response: &str,
-) -> Result<textsender_models::message::scheduling::ScheduledMessage, std::io::Error> {
+) -> Result<schedtxt_models::message::scheduling::ScheduledMessage, std::io::Error> {
     match serde_json::from_str::<serde_json::Value>(response) {
         Ok(j) => match j.get("data") {
             Some(serde_json::Value::Array(lrs)) => {
                 if lrs.is_empty() {
                     Err(std::io::Error::other("Error response is empty"))
                 } else {
-                    let ll: textsender_models::message::scheduling::ScheduledMessage =
+                    let ll: schedtxt_models::message::scheduling::ScheduledMessage =
                         match serde_json::from_value(lrs[0].clone()) {
                             Ok(lr) => lr,
                             Err(err) => {