catapult/src/service/core.rs

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);

            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!(
            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,
        }
    }
}