src/service/core.rs

@@ -59,6 +59,15 @@ impl Service {
             app: self.app.clone(),
             token: self.token.clone(),
         };
+        let sch_msg = super::scheduler::ScheduledMessage {
+            app: self.app.clone(),
+            token: self.token.clone()
+        };
+        let mer_req = super::mer::MessageEventResponse {
+            app: self.app.clone(),
+            token: self.token.clone()
+        };
+
         let events = events.unwrap_or_default();
         for event in events {
             println!("Event: {event:?}");
@@ -76,9 +85,52 @@ impl Service {
                     continue;
                 }
             }[0];
+            let scheduled_message = match sch_msg.get(&event.scheduled_message_id).await {
+                Ok(sch_msg_here) => sch_msg_here,
+                Err(err) => {
+                    eprintln!("Error: {err:?}");
+                    continue;
+                }
+            };
 
             println!("Contact Id: {:?}", contact.id);
             println!("Message Id: {:?}", message.id);
+
+            let param = swoosh::twilio::types::Parameters {
+                schedule: true,
+                schedule_at: scheduled_message.scheduled
+            };
+
+            let twilio_config = &self.app.twilio_config;
+
+
+            match swoosh::twilio::api::send_message(&message, contact, &param, twilio_config).await {
+                Ok(resp) => {
+                    // MER response
+                    let result = swoosh::twilio::api::response_to_json(resp).await;
+                    let mer = textsender_models::message::event::MessageEventResponse {
+                        contact_id: contact.id.unwrap(),
+                        scheduled_message_event_id: Some(event.id),
+                        response: result,
+                        message_id: message.id.unwrap(),
+                        sent: scheduled_message.scheduled,
+                        user_id: scheduled_message.user_id,
+                        ..Default::default()
+                    };
+
+                    match mer_req.record_message_event_response(&mer).await {
+                        Ok(response) => {
+                            println!("Response: {response:?}");
+                        }
+                        Err(err) => {
+                            eprintln!("Error: {err:?}");
+                        }
+                    }
+                }
+                Err(err) => {
+                    eprintln!("Error: {err:?}");
+                }
+            }
         }
 
         todo!(

src/service/mer.rs

@@ -1,5 +1,6 @@
 pub struct MessageEventResponse {
     pub app: crate::app::App,
+    pub token: textsender_models::token::LoginResult,
 }
 
 impl MessageEventResponse {
@@ -33,7 +34,9 @@ impl MessageEventResponse {
 
         println!("Payload: {payload:?}");
 
-        match client.post(api_url).json(&payload).send().await {
+        let (key, header) = super::auth_header(&self.token.access_token);
+
+        match client.post(api_url).json(&payload).header(key, header).send().await {
             Ok(response) => match response.status() {
                 reqwest::StatusCode::CREATED | reqwest::StatusCode::OK => {
                     println!("Response: {response:?}");

src/service/mod.rs

@@ -5,6 +5,7 @@ pub mod event;
 pub mod mer;
 pub mod message;
 pub mod queue;
+pub mod scheduler;
 
 pub fn auth_header(
     access_token: &str,

src/service/scheduler.rs

@@ -0,0 +1,59 @@
+pub struct ScheduledMessage {
+    pub app: crate::app::App,
+    pub token: textsender_models::token::LoginResult,
+}
+
+impl ScheduledMessage {
+    pub async fn get(
+        &self,
+        scheduled_message_id: &uuid::Uuid,
+    ) -> Result<textsender_models::message::scheduling::ScheduledMessage, std::io::Error> {
+        let client = reqwest::Client::new();
+        let endpoint = format!("api/v1/scheduled/message?id={scheduled_message_id}");
+        let api_url = format!("{}/{endpoint}", self.app.api_url);
+
+        println!("Url: {api_url:?}");
+
+        let (key, header) = super::auth_header(&self.token.access_token);
+
+        match client.get(api_url).header(key, header).send().await {
+            Ok(response) => match response.status() {
+                reqwest::StatusCode::OK => match response.text().await {
+                    Ok(val) => match parse_response(&val).await {
+                        Ok(login_result) => Ok(login_result),
+                        Err(err) => Err(err),
+                    },
+                    Err(err) => Err(std::io::Error::other(err)),
+                },
+                _ => Err(std::io::Error::other("Error getting token")),
+            },
+            Err(err) => Err(std::io::Error::other(err.to_string())),
+        }
+    }
+}
+
+async fn parse_response(
+    response: &str,
+) -> Result<textsender_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 =
+                            match serde_json::from_value(lrs[0].clone()) {
+                                Ok(lr) => lr,
+                                Err(err) => {
+                                    return Err(std::io::Error::other(err.to_string()));
+                                }
+                        };
+
+                    Ok(ll)
+                }
+            }
+            _ => Err(std::io::Error::other("Error parsing response")),
+        },
+        Err(err) => Err(std::io::Error::other(err.to_string())),
+    }
+}