From b5bb605361b5be600f42ed6afcafa62c1ffe56f1 Mon Sep 17 00:00:00 2001 From: phoenix Date: Wed, 24 Jun 2026 14:50:15 -0400 Subject: [PATCH] Get token (#8) Reviewed-on: http://git.kundeng.us/phoenix/catapult/pulls/8 --- Cargo.lock | 1 + Cargo.toml | 1 + src/app.rs | 11 ++-- src/main.rs | 37 +++++++++++++- src/service.rs | 22 -------- src/service/core.rs | 29 +++++++++++ src/service/mod.rs | 120 ++++++++++++++++++++++++++++++++++++++++++++ 7 files changed, 193 insertions(+), 28 deletions(-) delete mode 100644 src/service.rs create mode 100644 src/service/core.rs create mode 100644 src/service/mod.rs diff --git a/Cargo.lock b/Cargo.lock index 1964bbc..e1898ac 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -136,6 +136,7 @@ dependencies = [ "serde_json", "swoosh", "textsender_models", + "time", "tokio", ] diff --git a/Cargo.toml b/Cargo.toml index 64eae2d..75f702b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,6 +10,7 @@ futures = { version = "0.3.32" } reqwest = { version = "0.13.4", features = ["json", "stream", "multipart"] } serde = { version = "1.0.228", features = ["derive"] } serde_json = { version = "1.0.150" } +time = { version = "0.3.49", features = ["formatting", "macros", "parsing", "serde"] } textsender_models = { git = "ssh://git@git.kundeng.us/phoenix/textsender_models.git", tag = "v0.4.3-29-720f3d8f75-111" } swoosh = { git = "ssh://git@git.kundeng.us/phoenix/swoosh.git", tag = "v0.4.1-10-6bdec12084-871" } diff --git a/src/app.rs b/src/app.rs index d637aa0..310eab0 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, Debug)] pub struct App { pub api_url: String, pub auth_url: String, @@ -21,8 +22,8 @@ pub async fn load_app() -> Result { 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, ]; @@ -41,10 +42,10 @@ pub async fn load_app() -> Result { 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), diff --git a/src/main.rs b/src/main.rs index 80bfe63..a1a87c3 100644 --- a/src/main.rs +++ b/src/main.rs @@ -14,8 +14,43 @@ async fn main() -> Result<(), Box> { } }; + println!("App: {app:?}"); + + 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); + } + }; + + println!("Access token: {}", token.access_token); + + let mut svc = catapult::service::core::Service { + app: app.clone(), + token: token, + }; + loop { - catapult::service::do_the_work(&app).await; + // TODO: Need to update textsender_models. The token module needs updating. + // The LoginResult needs expires_in populated + if catapult::service::auth::has_token_expired(&svc.token).await { + match auth.get_refresh_token(&svc.token).await { + Ok(refresh) => { + println!("Refresh token: {refresh:?}"); + svc.token = refresh; + } + Err(err) => { + eprintln!("Error: {err:?}"); + std::process::exit(-1); + } + } + } + + 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 deleted file mode 100644 index 93bb630..0000000 --- a/src/service.rs +++ /dev/null @@ -1,22 +0,0 @@ -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 - "# - ); -} diff --git a/src/service/core.rs b/src/service/core.rs new file mode 100644 index 0000000..839e38f --- /dev/null +++ b/src/service/core.rs @@ -0,0 +1,29 @@ +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 + "# + ); + } +} diff --git a/src/service/mod.rs b/src/service/mod.rs new file mode 100644 index 0000000..d3bd740 --- /dev/null +++ b/src/service/mod.rs @@ -0,0 +1,120 @@ +pub mod core; + +pub mod auth { + pub struct Auth { + pub app: crate::app::App, + } + + impl Auth { + pub async fn get_token(&self) -> Result { + 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 { + 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: &String, + ) -> Result { + match serde_json::from_str::(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 + } +}