Able to get token

src/app.rs

@@ -3,7 +3,7 @@ pub const SECONDS_TO_SLEEP: u64 = 5;
 
 pub const APP_NAME: &str = "catapult";
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct App {
     pub api_url: String,
     pub auth_url: String,
@@ -22,8 +22,8 @@ pub async fn load_app() -> Result<App, std::io::Error> {
     let service_passphrase_env = envy::environment::get_env("SERVICE_PASSPHRASE").await;
 
     let envs = vec![
-        auth_url_env,
         api_url_env,
+        auth_url_env,
         service_username_env,
         service_passphrase_env,
     ];
@@ -42,10 +42,10 @@ pub async fn load_app() -> Result<App, std::io::Error> {
     if envs_valid {
         match textsender_models::config::auxiliary::load_config().await {
             Ok(twilio_config) => Ok(App {
-                api_url: String::new(),
-                auth_url: String::new(),
-                service_username: String::new(),
-                service_passphrase: String::new(),
+                api_url: envs[0].value.clone(),
+                auth_url: envs[1].value.clone(), 
+                service_username: envs[2].value.clone(),
+                service_passphrase: envs[3].value.clone(), 
                 twilio_config: twilio_config,
             }),
             Err(err) => Err(err),

src/main.rs

@@ -14,6 +14,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         }
     };
 
+    println!("App: {app:?}");
+
     let auth = catapult::service::auth::Auth {
         app: app.clone()
     };
@@ -26,6 +28,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         }
     };
 
+    println!("Access token: {}", token.access_token);
+
     let mut svc = catapult::service::Service {
         app: app.clone(),
         token

src/service.rs

@@ -53,18 +53,53 @@ pub mod auth {
             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.auth_url,
-                "passphrase": self.app.api_url
+                "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.json().await {
+                        match response.text().await {
                             Ok(val) => {
-                                Ok(val)
+                                match serde_json::from_str::<serde_json::Value>(&val) {
+                                    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)
+                                                    // Ok(textsender_models::token::LoginResult::default())
+                                                }
+                                            }
+                                            _ => {
+                                                Err(std::io::Error::other("Error parsing response"))
+                                            }
+                                        }
+                                    }
+                                    Err(err) => {
+                                        Err(std::io::Error::other(err.to_string()))
+                                    }
+                                }
                             }
                             Err(err) => {
                                 Err(std::io::Error::other(err))