From 0f9753874b680a74f8c7e6369d99f56e16985b4f Mon Sep 17 00:00:00 2001 From: phoenix Date: Mon, 22 Jun 2026 17:11:08 -0400 Subject: [PATCH] Saving changes --- src/app.rs | 1 + src/main.rs | 20 ++++- src/service.rs | 214 ++++++++++++++++++++++++++++++++++++++++++++----- 3 files changed, 213 insertions(+), 22 deletions(-) diff --git a/src/app.rs b/src/app.rs index d637aa0..72203a9 100644 --- a/src/app.rs +++ b/src/app.rs @@ -3,6 +3,7 @@ pub const SECONDS_TO_SLEEP: u64 = 5; pub const APP_NAME: &str = "catapult"; +#[derive(Clone)] pub struct App { pub api_url: String, pub auth_url: String, diff --git a/src/main.rs b/src/main.rs index 80bfe63..bda6829 100644 --- a/src/main.rs +++ b/src/main.rs @@ -14,8 +14,26 @@ async fn main() -> Result<(), Box> { } }; + let auth = catapult::service::auth::Auth { + app: app.clone() + }; + let token = match auth.get_token().await { + Ok(token) => token, + Err(err) => { + eprintln!("Error getting token"); + eprintln!("Error: {err:?}"); + std::process::exit(-1); + } + }; + + let mut svc = catapult::service::Service { + app: app.clone(), + token + }; + loop { - catapult::service::do_the_work(&app).await; + // catapult::service::do_the_work(&app).await; + svc.do_the_work().await; tokio::time::sleep(tokio::time::Duration::from_secs( catapult::app::SECONDS_TO_SLEEP, )) diff --git a/src/service.rs b/src/service.rs index 93bb630..f2bbbbc 100644 --- a/src/service.rs +++ b/src/service.rs @@ -1,22 +1,194 @@ -pub async fn do_the_work(_app: &crate::app::App) { - 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 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 { + /* + 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); + + let payload = serde_json::json!({ + "username": self.app.auth_url, + "passphrase": self.app.api_url + }); + + match client.post(api_url).json(&payload).send().await { + Ok(response) => match response.status() { + reqwest::StatusCode::OK => { + println!("Response: {response:?}"); + match response.json().await { + Ok(val) => { + Ok(val) + } + 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::() + .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 + } +} + * + */