v0.3.0 (#2)

Reviewed-on: #2

src/service/core.rs

@@ -0,0 +1,177 @@
+pub struct Service {
+    pub app: crate::app::App,
+    pub token: textsender_models::token::Login,
+}
+
+impl Service {
+    pub async fn do_the_work(&mut self) {
+        println!("Do some work");
+        println!("Checking queue");
+
+        use textsender_models::message::scheduling::ScheduledMessage;
+
+        let queue = super::queue::Queue {
+            app: self.app.clone(),
+            token: self.token.clone(),
+        };
+        let queue_item: Option<ScheduledMessage> = match queue.get_queue().await {
+            Ok(item) => Some(item),
+            Err(err) => {
+                eprintln!("Error: {err:?}");
+                None
+            }
+        };
+
+        if queue_item.is_none() {
+            println!("No queue item found");
+            return;
+        }
+        let queue_item = queue_item.unwrap();
+
+        println!("Queue item Id: {:?}", queue_item.id);
+
+        if !self.is_schedulable(&queue_item) {
+            println!("Not schedulable");
+            return;
+        }
+
+        println!("Can schedule");
+
+        let events_req = super::event::Event {
+            app: self.app.clone(),
+            token: self.token.clone(),
+        };
+
+        let scheduled_message_id = queue_item.id;
+        let events = match events_req.get(&scheduled_message_id).await {
+            Ok(events) => Some(events),
+            Err(err) => {
+                eprintln!("Error: {err:?}");
+                None
+            }
+        };
+
+        let contacts = super::contact::Contact {
+            app: self.app.clone(),
+            token: self.token.clone(),
+        };
+        let messages = super::message::Message {
+            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:?}");
+            let contact = &match contacts.get(&event.contact_id).await {
+                Ok(contact) => contact,
+                Err(err) => {
+                    eprintln!("Error: {err:?}");
+                    continue;
+                }
+            }[0];
+            let message = &match messages.get(&event.message_id).await {
+                Ok(messages) => messages,
+                Err(err) => {
+                    eprintln!("Error: {err:?}");
+                    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);
+            println!("Scheduled Message Id: {:?}", scheduled_message.id);
+
+            let param = swoosh::twilio::types::Parameters {
+                schedule: true,
+                schedule_at: scheduled_message.scheduled,
+            };
+
+            let twilio_config = &self.app.twilio_config;
+            println!("Config: {twilio_config:?}");
+            println!("SM: {scheduled_message:?}");
+
+            match swoosh::twilio::api::send_message(message, contact, &param, twilio_config).await {
+                Ok(resp) => {
+                    println!("Message scheduled");
+                    // 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!("Recording MER");
+                            println!("Response: {response:?}");
+                        }
+                        Err(err) => {
+                            eprintln!("Error recording mer");
+                            eprintln!("Error: {err:?}");
+                        }
+                    }
+                }
+                Err(err) => {
+                    eprintln!("Message not sent");
+                    eprintln!("Error: {err:?}");
+                }
+            }
+        }
+
+        /*
+        todo!(
+            r#"
+        Need to finish this
+
+        [X] - This function should fetch a token, check if the token is valid, and obtain a refresh token if
+        it has expired.
+
+        Then do the real work.
+
+        1. Check the queue - Done
+        2. If there is an item, get the data - Done
+        3. Evaluate if it is schedulable - Done
+        4. Get the events and iterate each one - Done
+        5. Starting with the message - Done
+        6. Get the contact - Done
+        7. Send the message
+        8. Record the message event response - Added, not used
+        9. Add to scheduler
+            "#
+        );
+        */
+    }
+
+    fn is_schedulable(
+        &self,
+        queue_item: &textsender_models::message::scheduling::ScheduledMessage,
+    ) -> bool {
+        let now = time::OffsetDateTime::now_utc();
+
+        match queue_item.scheduled {
+            Some(date) => date > now,
+            None => false,
+        }
+    }
+}