cargo fmt
catapult PR / Rustfmt (pull_request) Successful in 49s
catapult PR / Check (pull_request) Successful in 1m32s
catapult PR / Clippy (pull_request) Failing after 2m18s

This commit is contained in:
2026-06-22 17:43:55 -04:00
parent aaa20c8752
commit dd9d452576
3 changed files with 117 additions and 124 deletions
+2 -4
View File
@@ -16,9 +16,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
println!("App: {app:?}"); 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 { let token = match auth.get_token().await {
Ok(token) => token, Ok(token) => token,
Err(err) => { Err(err) => {
@@ -32,7 +30,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut svc = catapult::service::Service { let mut svc = catapult::service::Service {
app: app.clone(), app: app.clone(),
token token,
}; };
loop { loop {
+113 -118
View File
@@ -1,6 +1,6 @@
pub struct Service { pub struct Service {
pub app: crate::app::App, pub app: crate::app::App,
pub token: textsender_models::token::Login pub token: textsender_models::token::Login,
} }
impl Service { impl Service {
@@ -30,7 +30,7 @@ impl Service {
pub mod auth { pub mod auth {
pub struct Auth { pub struct Auth {
pub app: crate::app::App pub app: crate::app::App,
} }
/* /*
@@ -63,167 +63,162 @@ pub mod auth {
println!("Payload: {payload:?}"); println!("Payload: {payload:?}");
match client.post(api_url).json(&payload).send().await { 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) => { Err(err) => {
return Err(std::io::Error::other(err.to_string())); 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 { 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) { 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 { type refreshTokenRequest struct {
AccessToken string `json:"access_token"` AccessToken string `json:"access_token"`
} }
func (a *Auth) GetRefreshToken(tok *token.Login) (*token.Login, error) { 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 { 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
} }
} }
* *
*/ */