sender/src/messaging/mod.rs

use textsender_models::config::auxiliary::TwilioConfig;
use textsender_models::contact::Contact;
use textsender_models::message::Message;

pub async fn send_messages(
    config: &TwilioConfig,
    contacts: &[Contact],
    message: &Message,
    second_interval: u64,
) {
    let long_sleep_limit: i64 = 5;

    for (text_count, contact) in (0_i64..).zip(contacts.iter()) {
        println!("Sending to: {:?}", contact.phone_number);
        let param = swoosh::twilio::types::Parameters {
            schedule: false,
            schedule_at: None,
        };
        let mut sendmsg = swoosh::SendMsg::default();
        sendmsg.load_config(
            &config.auth_token,
            &config.phone_number,
            &config.service_sid,
            &config.account_sid,
        );
        sendmsg.load_recipient(&contact.phone_number);
        sendmsg.load_message(&message.content);
        match sendmsg.send_message(&param).await {
            Ok(response) => {
                println!("Raw response: {response:?}");
                let val = swoosh::twilio::api::response_to_json(response).await;
                println!("Response: {val:?}");
            }
            Err(err) => {
                eprintln!("Error: {err:?}");
            }
        }

        if text_count % long_sleep_limit == 0 {
            // Sleep for X seconds
            let wait_time = second_interval;
            std::thread::sleep(std::time::Duration::from_secs(wait_time));
        } else {
            // Sleep for a second
            std::thread::sleep(std::time::Duration::from_secs(1));
        }
    }
}

pub fn parse_numbers(filepath: &str) -> Result<Vec<Contact>, std::io::Error> {
    match std::fs::File::open(filepath) {
        Ok(file) => {
            let reader = std::io::BufReader::new(file);
            let contacts: Vec<Contact> = match serde_json::from_reader(reader) {
                Ok(va) => va,
                Err(err) => {
                    return Err(std::io::Error::other(err.to_string()));
                }
            };

            Ok(contacts)
        }
        Err(err) => Err(err),
    }
}

pub fn parse_message(filepath: &str) -> Result<Message, std::io::Error> {
    match std::fs::File::open(filepath) {
        Ok(file) => {
            let reader = std::io::BufReader::new(file);
            let message: Message = serde_json::from_reader(reader)?;
            Ok(message)
        }
        Err(err) => Err(err),
    }
}

#[cfg(test)]
mod tests {
    #[test]
    fn test_parse_message() {
        let message_path = String::from("tests/message-0.json");
        match super::parse_message(&message_path) {
            Ok(message) => {
                assert_eq!(false, message.content.is_empty(), "Content is empty");
            }
            Err(err) => {
                assert!(false, "Error: {err:?}");
            }
        };
    }

    #[test]
    fn test_parse_numbers() {
        let numbers_path = String::from("tests/numbers-0.json");
        match super::parse_numbers(&numbers_path) {
            Ok(contacts) => {
                assert_eq!(false, contacts.is_empty(), "Should not be empty");
            }
            Err(err) => {
                assert!(false, "Error: {err:?}");
            }
        };
    }
}