Refactoring code

src/service/auth.rs

@@ -0,0 +1,116 @@
+pub struct Auth {
+    pub app: crate::app::App,
+}
+
+impl Auth {
+    pub async fn get_token(&self) -> Result<textsender_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);
+
+        println!("Url: {api_url:?}");
+
+        let payload = serde_json::json!({
+            "username": &self.app.service_username,
+            "passphrase": &self.app.service_passphrase,
+        });
+
+        println!("Payload: {payload:?}");
+
+        match client.post(api_url).json(&payload).send().await {
+            Ok(response) => match response.status() {
+                reqwest::StatusCode::OK => {
+                    println!("Response: {response:?}");
+                    match response.text().await {
+                        Ok(val) => match parse_token_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())),
+        }
+    }
+
+    pub async fn get_refresh_token(
+        &self,
+        login_result: &textsender_models::token::Login,
+    ) -> Result<textsender_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);
+
+        println!("Url: {api_url:?}");
+
+        let payload = serde_json::json!({
+            "access_token": login_result.access_token
+        });
+
+        match client.post(api_url).json(&payload).send().await {
+            Ok(response) => match response.status() {
+                reqwest::StatusCode::OK => {
+                    println!("Response: {response:?}");
+                    match response.text().await {
+                        Ok(val) => match parse_token_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_token_response(
+    response: &str,
+) -> Result<textsender_models::token::LoginResult, std::io::Error> {
+    match serde_json::from_str::<serde_json::Value>(response) {
+        Ok(j) => {
+            println!("Good");
+            let message = &j["message"];
+            let data = &j["data"];
+
+            println!("Message: {message:?}");
+            println!("Data: {data:?}");
+            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 lr = lrs[0].clone();
+                        let ll: textsender_models::token::LoginResult =
+                            match serde_json::from_value(lr) {
+                                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())),
+    }
+}
+
+pub async fn has_token_expired(token: &textsender_models::token::LoginResult) -> bool {
+    let now = time::OffsetDateTime::now_utc();
+    let expire = match time::OffsetDateTime::from_unix_timestamp(token.expires_in) {
+        Ok(res) => res,
+        Err(err) => {
+            eprintln!("Error: {err:?}");
+            return false;
+        }
+    };
+
+    now > expire
+}

src/service/core.rs

@@ -82,8 +82,8 @@ impl Service {
         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
+        5. Starting with the message
-        6. Get the contact
+        6. Get the contact - Done
         7. Send the message
         8. Record the message event response
         9. Add to scheduler

src/service/mod.rs

@@ -1,127 +1,9 @@
+pub mod auth;
 pub mod contact;
 pub mod core;
 pub mod event;
 pub mod queue;
 
-pub mod auth {
-    pub struct Auth {
-        pub app: crate::app::App,
-    }
-
-    impl Auth {
-        pub async fn get_token(&self) -> Result<textsender_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);
-
-            println!("Url: {api_url:?}");
-
-            let payload = serde_json::json!({
-                "username": &self.app.service_username,
-                "passphrase": &self.app.service_passphrase,
-            });
-
-            println!("Payload: {payload:?}");
-
-            match client.post(api_url).json(&payload).send().await {
-                Ok(response) => match response.status() {
-                    reqwest::StatusCode::OK => {
-                        println!("Response: {response:?}");
-                        match response.text().await {
-                            Ok(val) => match parse_token_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())),
-            }
-        }
-
-        pub async fn get_refresh_token(
-            &self,
-            login_result: &textsender_models::token::Login,
-        ) -> Result<textsender_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);
-
-            println!("Url: {api_url:?}");
-
-            let payload = serde_json::json!({
-                "access_token": login_result.access_token
-            });
-
-            match client.post(api_url).json(&payload).send().await {
-                Ok(response) => match response.status() {
-                    reqwest::StatusCode::OK => {
-                        println!("Response: {response:?}");
-                        match response.text().await {
-                            Ok(val) => match parse_token_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_token_response(
-        response: &str,
-    ) -> Result<textsender_models::token::LoginResult, std::io::Error> {
-        match serde_json::from_str::<serde_json::Value>(response) {
-            Ok(j) => {
-                println!("Good");
-                let message = &j["message"];
-                let data = &j["data"];
-
-                println!("Message: {message:?}");
-                println!("Data: {data:?}");
-                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 lr = lrs[0].clone();
-                            let ll: textsender_models::token::LoginResult =
-                                match serde_json::from_value(lr) {
-                                    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())),
-        }
-    }
-
-    pub async fn has_token_expired(token: &textsender_models::token::LoginResult) -> bool {
-        let now = time::OffsetDateTime::now_utc();
-        let expire = match time::OffsetDateTime::from_unix_timestamp(token.expires_in) {
-            Ok(res) => res,
-            Err(err) => {
-                eprintln!("Error: {err:?}");
-                return false;
-            }
-        };
-
-        now > expire
-    }
-}
-
 pub fn auth_header(
     access_token: &str,
 ) -> (reqwest::header::HeaderName, reqwest::header::HeaderValue) {