cargo fmt

src/app.rs

@@ -43,9 +43,9 @@ pub async fn load_app() -> Result<App, std::io::Error> {
         match textsender_models::config::auxiliary::load_config().await {
             Ok(twilio_config) => Ok(App {
                 api_url: envs[0].value.clone(),
-                auth_url: envs[1].value.clone(), 
+                auth_url: envs[1].value.clone(),
                 service_username: envs[2].value.clone(),
-                service_passphrase: envs[3].value.clone(), 
+                service_passphrase: envs[3].value.clone(),
                 twilio_config: twilio_config,
             }),
             Err(err) => Err(err),

src/main.rs

@@ -16,9 +16,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     println!("App: {app:?}");
 
-    let auth = catapult::service::auth::Auth {
+    let auth = catapult::service::auth::Auth { app: app.clone() };
-        app: app.clone()
-    };
     let token = match auth.get_token().await {
         Ok(token) => token,
         Err(err) => {
@@ -32,7 +30,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let mut svc = catapult::service::Service {
         app: app.clone(),
-        token
+        token,
     };
 
     loop {

src/service.rs

@@ -1,6 +1,6 @@
 pub struct Service {
     pub app: crate::app::App,
-    pub token: textsender_models::token::Login
+    pub token: textsender_models::token::Login,
 }
 
 impl Service {
@@ -30,7 +30,7 @@ impl Service {
 
 pub mod auth {
     pub struct Auth {
-        pub app: crate::app::App
+        pub app: crate::app::App,
     }
 
     /*
@@ -63,167 +63,162 @@ pub mod auth {
             println!("Payload: {payload:?}");
 
             match client.post(api_url).json(&payload).send().await {
-                Ok(response) => match response.status() {
+                Ok(response) => {
-                    reqwest::StatusCode::OK => {
+                    match response.status() {
-                        println!("Response: {response:?}");
+                        reqwest::StatusCode::OK => {
-                        match response.text().await {
+                            println!("Response: {response:?}");
-                            Ok(val) => {
+                            match response.text().await {
-                                match serde_json::from_str::<serde_json::Value>(&val) {
+                                Ok(val) => {
-                                    Ok(j) => {
+                                    match serde_json::from_str::<serde_json::Value>(&val) {
-                                        println!("Good");
+                                        Ok(j) => {
-                                        let message = &j["message"];
+                                            println!("Good");
-                                        let data = &j["data"];
+                                            let message = &j["message"];
+                                            let data = &j["data"];
 
-                                        println!("Message: {message:?}");
+                                            println!("Message: {message:?}");
-                                        println!("Data: {data:?}");
+                                            println!("Data: {data:?}");
-                                        match j.get("data") {
+                                            match j.get("data") {
-                                            Some(serde_json::Value::Array(lrs)) => {
+                                                Some(serde_json::Value::Array(lrs)) => {
-                                                if lrs.is_empty() {
+                                                    if lrs.is_empty() {
-                                                    Err(std::io::Error::other("Error response is empty"))
+                                                        Err(std::io::Error::other(
-                                                } else {
+                                                            "Error response is empty",
-                                                    let lr = lrs[0].clone();
+                                                        ))
-                                                    let ll: textsender_models::token::LoginResult = match serde_json::from_value(lr) {                                                        Ok(lr) => lr,
+                                                    } 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(ll)
-                                                    // Ok(textsender_models::token::LoginResult::default())
+                                                        // Ok(textsender_models::token::LoginResult::default())
+                                                    }
                                                 }
-                                            }
+                                                _ => Err(std::io::Error::other(
-                                            _ => {
+                                                    "Error parsing response",
-                                                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.to_string()))
                                     }
                                 }
-                            }
+                                Err(err) => Err(std::io::Error::other(err)),
-                            Err(err) => {
-                                Err(std::io::Error::other(err))
                             }
                         }
-                    }
+                        _ => Err(std::io::Error::other("Error getting token")),
-                    _ => {
-                        Err(std::io::Error::other("Error getting token"))
                     }
                 }
-                Err(err) => {
+                Err(err) => Err(std::io::Error::other(err.to_string())),
-                    Err(std::io::Error::other(err.to_string()))
-                }
             }
         }
     }
 }
 
-
 /*
- *
+*
-    let client = reqwest::Client::new();
+   let client = reqwest::Client::new();
-    let endpoint = String::from("api/v2/service/login");
+   let endpoint = String::from("api/v2/service/login");
-    let api_url = format!("{}/{endpoint}", app.auth_uri);
+   let api_url = format!("{}/{endpoint}", app.auth_uri);
 
-    let payload = serde_json::json!({
+   let payload = serde_json::json!({
-        "passphrase": icarus_envy::environment::get_service_passphrase().await.value,
+       "passphrase": icarus_envy::environment::get_service_passphrase().await.value,
-    });
+   });
 
-    match client.post(api_url).json(&payload).send().await {
+   match client.post(api_url).json(&payload).send().await {
-        Ok(response) => match response
+       Ok(response) => match response
-            .json::<crate::api::service_token::response::Response>()
+           .json::<crate::api::service_token::response::Response>()
-            .await
+           .await
-        {
+       {
-            Ok(resp) => {
+           Ok(resp) => {
-                if resp.data.is_empty() {
+               if resp.data.is_empty() {
-                    Err(std::io::Error::other(String::from("No token returned")))
+                   Err(std::io::Error::other(String::from("No token returned")))
-                } else {
+               } else {
-                    Ok(resp.data[0].clone())
+                   Ok(resp.data[0].clone())
-                }
+               }
-            }
+           }
-            Err(err) => Err(std::io::Error::other(err.to_string())),
+           Err(err) => Err(std::io::Error::other(err.to_string())),
-        },
+       },
-        Err(err) => Err(std::io::Error::other(err.to_string())),
+       Err(err) => Err(std::io::Error::other(err.to_string())),
-    }
+   }
- *
+*
- */
+*/
 
 /*
  *
 type tokenResponse struct {
-	Message string         `json:"message"`
+    Message string         `json:"message"`
-	Data    []*token.Login `json:"data"`
+    Data    []*token.Login `json:"data"`
 }
 
 func (a *Auth) GetToken() (*token.Login, error) {
-	serv := service{
+    serv := service{
-		Username:   a.Application.ServiceUsername,
+        Username:   a.Application.ServiceUsername,
-		Passphrase: a.Application.ServicePassphrase,
+        Passphrase: a.Application.ServicePassphrase,
-	}
+    }
 
-	jsonData, err := json.Marshal(serv)
+    jsonData, err := json.Marshal(serv)
-	if err != nil {
+    if err != nil {
-		return nil, err
+        return nil, err
-	}
+    }
-	resp, err := http.Post(
+    resp, err := http.Post(
-		fmt.Sprintf("%s/api/v1/service/login", a.Application.AuthUrl),
+        fmt.Sprintf("%s/api/v1/service/login", a.Application.AuthUrl),
-		"application/json",
+        "application/json",
-		bytes.NewBuffer(jsonData),
+        bytes.NewBuffer(jsonData),
-	)
+    )
-	if err != nil {
+    if err != nil {
-		return nil, err
+        return nil, err
-	}
+    }
-	defer resp.Body.Close()
+    defer resp.Body.Close()
 
-	var r tokenResponse
+    var r tokenResponse
-	err = json.NewDecoder(resp.Body).Decode(&r)
+    err = json.NewDecoder(resp.Body).Decode(&r)
-	if err != nil {
+    if err != nil {
-		return nil, err
+        return nil, err
-	}
+    }
 
-	return r.Data[0], nil
+    return r.Data[0], nil
 }
 
 type refreshTokenRequest struct {
-	AccessToken string `json:"access_token"`
+    AccessToken string `json:"access_token"`
 }
 
 func (a *Auth) GetRefreshToken(tok *token.Login) (*token.Login, error) {
-	req := refreshTokenRequest{AccessToken: tok.AccessToken}
+    req := refreshTokenRequest{AccessToken: tok.AccessToken}
 
-	jsonData, err := json.Marshal(req)
+    jsonData, err := json.Marshal(req)
-	if err != nil {
+    if err != nil {
-		return nil, err
+        return nil, err
-	}
+    }
 
-	resp, err := http.Post(fmt.Sprintf("%s/api/v1/token/refresh", a.Application.AuthUrl), "application/json", bytes.NewBuffer(jsonData))
+    resp, err := http.Post(fmt.Sprintf("%s/api/v1/token/refresh", a.Application.AuthUrl), "application/json", bytes.NewBuffer(jsonData))
-	if err != nil {
+    if err != nil {
-		return nil, err
+        return nil, err
-	}
+    }
-	defer resp.Body.Close()
+    defer resp.Body.Close()
 
-	var r tokenResponse
+    var r tokenResponse
-	err = json.NewDecoder(resp.Body).Decode(&r)
+    err = json.NewDecoder(resp.Body).Decode(&r)
-	if err != nil {
+    if err != nil {
-		return nil, err
+        return nil, err
-	} else {
+    } else {
-		if len(r.Data) == 0 {
+        if len(r.Data) == 0 {
-			return nil, nil
+            return nil, nil
-		} else {
+        } else {
-			return r.Data[0], nil
+            return r.Data[0], nil
-		}
+        }
-	}
+    }
 }
 
 func (s *Auth) TokenExpired(tok *token.Login) bool {
-	now := time.Now()
+    now := time.Now()
-	expiredTime := time.Unix(tok.ExpiresIn, 0)
+    expiredTime := time.Unix(tok.ExpiresIn, 0)
 
-	if now.After(expiredTime) {
+    if now.After(expiredTime) {
-		return true
+        return true
-	} else {
+    } else {
-		return false
+        return false
-	}
+    }
 }
  *
  */