Renaming file

src/service/mod.rs

@@ -0,0 +1,224 @@
+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");
+        todo!(
+            r#"
+        Need to finish this
+
+        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
+        2. If there is an item, get the data, 
+        3. Evaluate if it is schedulable
+        4. Get the events and iterate each one
+        5. starting with the message
+        6. Get the contact
+        7. Send the message
+        8. Record the message event response
+            "#
+        );
+    }
+}
+
+pub mod auth {
+    pub struct Auth {
+        pub app: crate::app::App,
+    }
+
+    /*
+    #[derive(serde::Deserialize, serde::Serialize)]
+    struct ServiceRequest {
+        pub username: String,
+        pub passphrase: String
+    }
+    */
+
+    impl Auth {
+        pub async fn get_token(&self) -> Result<textsender_models::token::Login, std::io::Error> {
+            /*
+            let svcRequest = ServiceRequest {
+                username: self.app.service_username,
+                passphrase: self.app.service_passphrase,
+            };
+            */
+            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 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)),
+                            }
+                        }
+                        _ => Err(std::io::Error::other("Error getting token")),
+                    }
+                }
+                Err(err) => Err(std::io::Error::other(err.to_string())),
+            }
+        }
+    }
+}
+
+/*
+*
+   let client = reqwest::Client::new();
+   let endpoint = String::from("api/v2/service/login");
+   let api_url = format!("{}/{endpoint}", app.auth_uri);
+
+   let payload = serde_json::json!({
+       "passphrase": icarus_envy::environment::get_service_passphrase().await.value,
+   });
+
+   match client.post(api_url).json(&payload).send().await {
+       Ok(response) => match response
+           .json::<crate::api::service_token::response::Response>()
+           .await
+       {
+           Ok(resp) => {
+               if resp.data.is_empty() {
+                   Err(std::io::Error::other(String::from("No token returned")))
+               } else {
+                   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())),
+   }
+*
+*/
+
+/*
+ *
+type tokenResponse struct {
+    Message string         `json:"message"`
+    Data    []*token.Login `json:"data"`
+}
+
+func (a *Auth) GetToken() (*token.Login, error) {
+    serv := service{
+        Username:   a.Application.ServiceUsername,
+        Passphrase: a.Application.ServicePassphrase,
+    }
+
+    jsonData, err := json.Marshal(serv)
+    if err != nil {
+        return nil, err
+    }
+    resp, err := http.Post(
+        fmt.Sprintf("%s/api/v1/service/login", a.Application.AuthUrl),
+        "application/json",
+        bytes.NewBuffer(jsonData),
+    )
+    if err != nil {
+        return nil, err
+    }
+    defer resp.Body.Close()
+
+    var r tokenResponse
+    err = json.NewDecoder(resp.Body).Decode(&r)
+    if err != nil {
+        return nil, err
+    }
+
+    return r.Data[0], nil
+}
+
+type refreshTokenRequest struct {
+    AccessToken string `json:"access_token"`
+}
+
+func (a *Auth) GetRefreshToken(tok *token.Login) (*token.Login, error) {
+    req := refreshTokenRequest{AccessToken: tok.AccessToken}
+
+    jsonData, err := json.Marshal(req)
+    if err != nil {
+        return nil, err
+    }
+
+    resp, err := http.Post(fmt.Sprintf("%s/api/v1/token/refresh", a.Application.AuthUrl), "application/json", bytes.NewBuffer(jsonData))
+    if err != nil {
+        return nil, err
+    }
+    defer resp.Body.Close()
+
+    var r tokenResponse
+    err = json.NewDecoder(resp.Body).Decode(&r)
+    if err != nil {
+        return nil, err
+    } else {
+        if len(r.Data) == 0 {
+            return nil, nil
+        } else {
+            return r.Data[0], nil
+        }
+    }
+}
+
+func (s *Auth) TokenExpired(tok *token.Login) bool {
+    now := time.Now()
+    expiredTime := time.Unix(tok.ExpiresIn, 0)
+
+    if now.After(expiredTime) {
+        return true
+    } else {
+        return false
+    }
+}
+ *
+ */