From e82a62dec44d92f92ecc48ce668f6bf6336aacd5 Mon Sep 17 00:00:00 2001 From: phoenix Date: Wed, 11 Nov 2026 13:13:49 -0500 Subject: [PATCH] tsk-14: Update user profile (#15) Closes #14 Reviewed-on: http://git.kundeng.us/phoenix/soaricarus_auth/pulls/15 --- Cargo.lock | 2 +- Cargo.toml | 2 +- src/callers/login.rs | 104 ++++++++++++++++ src/callers/mod.rs | 1 + src/lib.rs | 144 ++++++++++++++++++++++ src/main.rs | 287 +++++++++++++++++++++---------------------- src/repo/mod.rs | 28 +++++ 7 files changed, 420 insertions(+), 148 deletions(-) create mode 100644 src/lib.rs diff --git a/Cargo.lock b/Cargo.lock index a9c8300..91033f1 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1526,7 +1526,7 @@ dependencies = [ [[package]] name = "soaricarus_auth" -version = "0.8.8" +version = "0.8.9" dependencies = [ "argon2", "axum", diff --git a/Cargo.toml b/Cargo.toml index d81f4de..cd1fb3e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "soaricarus_auth" -version = "0.8.8" +version = "0.8.9" edition = "2024" rust-version = "1.95" license = "MIT" diff --git a/src/callers/login.rs b/src/callers/login.rs index 348c85e..e09c29c 100644 --- a/src/callers/login.rs +++ b/src/callers/login.rs @@ -43,6 +43,23 @@ pub mod request { } } } + + pub mod update_user_profile { + use serde::{Deserialize, Serialize}; + + #[derive(Debug, Deserialize, Serialize, utoipa::ToSchema)] + pub struct UpdateUserProfileRequest { + pub user_id: uuid::Uuid, + pub firstname: String, + pub lastname: String, + } + + impl UpdateUserProfileRequest { + pub fn is_valid(&self) -> bool { + !self.user_id.is_nil() && !self.firstname.is_empty() && !self.lastname.is_empty() + } + } + } } pub mod response { @@ -89,6 +106,16 @@ pub mod response { pub data: Vec, } } + + pub mod update_user_profile { + use serde::{Deserialize, Serialize}; + + #[derive(Default, Deserialize, Serialize, utoipa::ToSchema)] + pub struct UpdateUserProfileResponse { + pub message: String, + pub data: Vec, + } + } } /// Module for login endpoints @@ -446,4 +473,81 @@ pub mod endpoint { } } } + + #[utoipa::path( + put, + path = super::super::endpoints::UPDATE_USER_PROFILE, + request_body( + content = super::request::update_user_profile::UpdateUserProfileRequest, + description = "Update user profile", + content_type = "application/json" + ), + responses( + (status = 200, description = "User profile updated successfully", body = super::response::update_user_profile::UpdateUserProfileResponse), + (status = 400, description = "Invalid", body = super::response::update_user_profile::UpdateUserProfileResponse), + (status = 500, description = "Failure", body = super::response::update_user_profile::UpdateUserProfileResponse) + ) + )] + pub async fn update_user_profile( + axum::Extension(pool): axum::Extension, + axum::Json(payload): axum::Json< + super::request::update_user_profile::UpdateUserProfileRequest, + >, + ) -> ( + axum::http::StatusCode, + axum::Json, + ) { + let mut response = + super::response::update_user_profile::UpdateUserProfileResponse::default(); + if !payload.is_valid() { + response.message = "Invalid".to_string(); + (axum::http::StatusCode::BAD_REQUEST, axum::Json(response)) + } else { + let user_id = payload.user_id; + match repo::user::get_with_id(&pool, &user_id).await { + Ok(user) => { + let firstname = payload.firstname; + let lastname = payload.lastname; + + if firstname == user.firstname && lastname == user.lastname { + (axum::http::StatusCode::NOT_MODIFIED, axum::Json(response)) + } else { + match repo::user::update_user_profile( + &pool, &user_id, &firstname, &lastname, + ) + .await + { + Ok(_) => { + let user_profile = simodels::user::UserProfile { + firstname, + lastname, + username: user.username, + email: user.email, + }; + response.message = "SUCCESSFUL".to_string(); + response.data.push(user_profile); + (axum::http::StatusCode::OK, axum::Json(response)) + } + Err(err) => { + eprintln!("Error: {err:?}"); + response.message = "ERROR - Updating user profile".to_string(); + ( + axum::http::StatusCode::INTERNAL_SERVER_ERROR, + axum::Json(response), + ) + } + } + } + } + Err(err) => { + eprintln!("Error: {err:?}"); + response.message = "ERROR".to_string(); + ( + axum::http::StatusCode::INTERNAL_SERVER_ERROR, + axum::Json(response), + ) + } + } + } + } } diff --git a/src/callers/mod.rs b/src/callers/mod.rs index 27b8657..e358339 100644 --- a/src/callers/mod.rs +++ b/src/callers/mod.rs @@ -11,4 +11,5 @@ pub mod endpoints { pub const SERVICE_LOGIN: &str = "/api/v2/service/login"; pub const REFRESH_TOKEN: &str = "/api/v2/token/refresh"; pub const GET_USER_PROFILE: &str = "/api/v2/user/profile/{id}"; + pub const UPDATE_USER_PROFILE: &str = "/api/v2/user/profile/update"; } diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..be25a0e --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,144 @@ +pub mod callers; +pub mod config; +pub mod db; +pub mod hashing; +pub mod repo; +pub mod token_stuff; + +pub mod init { + use axum::{ + Router, + routing::{get, patch, post, put}, + }; + use utoipa::OpenApi; + + use super::callers; + use callers::common as common_callers; + use callers::login as login_caller; + use callers::register as register_caller; + use login_caller::endpoint as login_endpoints; + use login_caller::response as login_responses; + use register_caller::response as register_responses; + + #[derive(utoipa::OpenApi)] + #[openapi( + paths( + common_callers::endpoint::db_ping, common_callers::endpoint::root, + register_caller::register_user, + login_endpoints::login, login_endpoints::update_password, login_endpoints::service_login, login_endpoints::refresh_token, login_endpoints::get_user_profile, + ), + components(schemas(common_callers::response::TestResult, + register_responses::Response, + login_responses::Response, login_responses::service_login::Response, login_responses::update_password::Response, login_responses::refresh_token::Response, login_responses::get_user_profile::GetUserProfileResponse)), + tags( + (name = "soaricarus Auth API", description = "Auth API for soaricarus API") + ) + )] + struct ApiDoc; + + mod cors { + pub async fn configure_cors() -> tower_http::cors::CorsLayer { + let cors = tower_http::cors::CorsLayer::new() + .allow_methods([ + axum::http::Method::GET, + axum::http::Method::PATCH, + axum::http::Method::POST, + axum::http::Method::PUT, + axum::http::Method::DELETE, + ]) + .allow_headers([ + axum::http::header::CONTENT_TYPE, + axum::http::header::AUTHORIZATION, + ]) + .allow_credentials(true) + .max_age(std::time::Duration::from_secs(3600)); + + // Dynamically set the allowed origin based on the environment + match std::env::var(sienvy::keys::APP_ENV).as_deref() { + Ok("production") => { + let allowed_origins_env = sienvy::environment::get_allowed_origins(); + match sienvy::utility::delimitize(&allowed_origins_env) { + Ok(alwd) => { + let allowed_origins: Vec = alwd + .into_iter() + .map(|s| s.parse::().unwrap()) + .collect(); + cors.allow_origin(allowed_origins) + } + Err(err) => { + eprintln!( + "Could not parse out allowed origins from env: Error: {err:?}" + ); + std::process::exit(-1); + } + } + } + _ => { + // Development (default): Allow localhost origins + cors.allow_origin(vec![ + "http://localhost:4200".parse().unwrap(), + "http://127.0.0.1:4200".parse().unwrap(), + ]) + } + } + } + } + + pub async fn routes() -> Router { + // build our application with a route + Router::new() + .route( + callers::endpoints::DBTEST, + get(callers::common::endpoint::db_ping), + ) + .route( + callers::endpoints::ROOT, + get(callers::common::endpoint::root), + ) + .route( + callers::endpoints::REGISTER, + post(callers::register::register_user), + ) + .route( + callers::endpoints::LOGIN, + post(callers::login::endpoint::login), + ) + .route( + callers::endpoints::UPDATE_PASSWORD, + patch(callers::login::endpoint::update_password), + ) + .route( + callers::endpoints::SERVICE_LOGIN, + post(callers::login::endpoint::service_login), + ) + .route( + callers::endpoints::REFRESH_TOKEN, + post(callers::login::endpoint::refresh_token), + ) + .route( + callers::endpoints::GET_USER_PROFILE, + get(callers::login::endpoint::get_user_profile), + ) + .route( + callers::endpoints::UPDATE_USER_PROFILE, + put(callers::login::endpoint::update_user_profile), + ) + .layer(cors::configure_cors().await) + } + + pub async fn app() -> Router { + let pool = super::db::init::create_pool() + .await + .expect("Failed to create pool"); + + super::db::init::migrations(&pool).await; + + routes() + .await + .merge( + utoipa_swagger_ui::SwaggerUi::new("/swagger-ui") + .url("/api-docs/openapi.json", ApiDoc::openapi()), + ) + .layer(axum::Extension(pool)) + } +} diff --git a/src/main.rs b/src/main.rs index 1ca3276..80e069d 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,9 +1,4 @@ -pub mod callers; -pub mod config; -pub mod db; -pub mod hashing; -pub mod repo; -pub mod token_stuff; +use soaricarus_auth::{config, init}; #[tokio::main] async fn main() { @@ -18,143 +13,11 @@ async fn main() { axum::serve(listener, app).await.unwrap(); } -mod init { - use axum::{ - Router, - routing::{get, patch, post}, - }; - use utoipa::OpenApi; - - use super::callers; - use callers::common as common_callers; - use callers::login as login_caller; - use callers::register as register_caller; - use login_caller::endpoint as login_endpoints; - use login_caller::response as login_responses; - use register_caller::response as register_responses; - - #[derive(utoipa::OpenApi)] - #[openapi( - paths( - common_callers::endpoint::db_ping, common_callers::endpoint::root, - register_caller::register_user, - login_endpoints::login, login_endpoints::update_password, login_endpoints::service_login, login_endpoints::refresh_token, login_endpoints::get_user_profile, - ), - components(schemas(common_callers::response::TestResult, - register_responses::Response, - login_responses::Response, login_responses::service_login::Response, login_responses::update_password::Response, login_responses::refresh_token::Response, login_responses::get_user_profile::GetUserProfileResponse)), - tags( - (name = "soaricarus Auth API", description = "Auth API for soaricarus API") - ) - )] - struct ApiDoc; - - mod cors { - pub async fn configure_cors() -> tower_http::cors::CorsLayer { - let cors = tower_http::cors::CorsLayer::new() - .allow_methods([ - axum::http::Method::GET, - axum::http::Method::PATCH, - axum::http::Method::POST, - axum::http::Method::PUT, - axum::http::Method::DELETE, - ]) - .allow_headers([ - axum::http::header::CONTENT_TYPE, - axum::http::header::AUTHORIZATION, - ]) - .allow_credentials(true) - .max_age(std::time::Duration::from_secs(3600)); - - // Dynamically set the allowed origin based on the environment - match std::env::var(sienvy::keys::APP_ENV).as_deref() { - Ok("production") => { - let allowed_origins_env = sienvy::environment::get_allowed_origins(); - match sienvy::utility::delimitize(&allowed_origins_env) { - Ok(alwd) => { - let allowed_origins: Vec = alwd - .into_iter() - .map(|s| s.parse::().unwrap()) - .collect(); - cors.allow_origin(allowed_origins) - } - Err(err) => { - eprintln!( - "Could not parse out allowed origins from env: Error: {err:?}" - ); - std::process::exit(-1); - } - } - } - _ => { - // Development (default): Allow localhost origins - cors.allow_origin(vec![ - "http://localhost:4200".parse().unwrap(), - "http://127.0.0.1:4200".parse().unwrap(), - ]) - } - } - } - } - - pub async fn routes() -> Router { - // build our application with a route - Router::new() - .route( - callers::endpoints::DBTEST, - get(callers::common::endpoint::db_ping), - ) - .route( - callers::endpoints::ROOT, - get(callers::common::endpoint::root), - ) - .route( - callers::endpoints::REGISTER, - post(callers::register::register_user), - ) - .route( - callers::endpoints::LOGIN, - post(callers::login::endpoint::login), - ) - .route( - callers::endpoints::UPDATE_PASSWORD, - patch(callers::login::endpoint::update_password), - ) - .route( - callers::endpoints::SERVICE_LOGIN, - post(callers::login::endpoint::service_login), - ) - .route( - callers::endpoints::REFRESH_TOKEN, - post(callers::login::endpoint::refresh_token), - ) - .route( - callers::endpoints::GET_USER_PROFILE, - get(callers::login::endpoint::get_user_profile), - ) - .layer(cors::configure_cors().await) - } - - pub async fn app() -> Router { - let pool = super::db::init::create_pool() - .await - .expect("Failed to create pool"); - - super::db::init::migrations(&pool).await; - - routes() - .await - .merge( - utoipa_swagger_ui::SwaggerUi::new("/swagger-ui") - .url("/api-docs/openapi.json", ApiDoc::openapi()), - ) - .layer(axum::Extension(pool)) - } -} - #[cfg(test)] mod tests { use super::*; + use soaricarus_auth; + use soaricarus_auth::{callers, db}; use axum::{ body::Body, @@ -265,6 +128,9 @@ mod tests { pub mod test_data { use serde_json::json; + pub const UPDATED_FIRSTNAME: &str = "Bolt"; + pub const UPDATED_LASTNAME: &str = "Thunder"; + pub fn get_updated_password(user_id: &uuid::Uuid) -> serde_json::Value { json!({ "username": "somethingsss", @@ -274,9 +140,22 @@ mod tests { "confirmed_password": "SpeakWithUrChest22!" }) } + + pub fn update_user_profile( + user_id: &uuid::Uuid, + firstname: &str, + lastname: &str, + ) -> serde_json::Value { + json!({ + "firstname": firstname, + "lastname": lastname, + "user_id": user_id + }) + } } pub mod requests { + use soaricarus_auth::callers; use tower::ServiceExt; // for `call`, `oneshot`, and `ready` pub async fn register( @@ -286,7 +165,7 @@ mod tests { let payload = super::get_test_register_payload(&usr); let req = axum::http::Request::builder() .method(axum::http::Method::POST) - .uri(crate::callers::endpoints::REGISTER) + .uri(callers::endpoints::REGISTER) .header(axum::http::header::CONTENT_TYPE, "application/json") .body(axum::body::Body::from(payload.to_string())) .unwrap(); @@ -301,7 +180,7 @@ mod tests { let payload = super::get_test_login_payload(&usr); let req = axum::http::Request::builder() .method(axum::http::Method::POST) - .uri(crate::callers::endpoints::LOGIN) + .uri(callers::endpoints::LOGIN) .header(axum::http::header::CONTENT_TYPE, "application/json") .body(axum::body::Body::from(payload.to_string())) .unwrap(); @@ -316,7 +195,7 @@ mod tests { let payload = super::test_data::get_updated_password(user_id); let req = axum::http::Request::builder() .method(axum::http::Method::PATCH) - .uri(crate::callers::endpoints::UPDATE_PASSWORD) + .uri(callers::endpoints::UPDATE_PASSWORD) .header(axum::http::header::CONTENT_TYPE, "application/json") .body(axum::body::Body::from(payload.to_string())) .unwrap(); @@ -328,7 +207,7 @@ mod tests { app: &axum::Router, user_id: &uuid::Uuid, ) -> Result { - let raw_uri = String::from(crate::callers::endpoints::GET_USER_PROFILE); + let raw_uri = String::from(callers::endpoints::GET_USER_PROFILE); let end_index = raw_uri.len() - 4; let uri = format!("{}{user_id}", (&raw_uri[..end_index]).to_string()); @@ -340,6 +219,28 @@ mod tests { .unwrap(); app.clone().oneshot(req).await } + + pub async fn update_user_profile( + app: &axum::Router, + user_id: &uuid::Uuid, + firstname: &str, + lastname: &str, + ) -> Result { + let payload = super::test_data::update_user_profile(user_id, firstname, lastname); + let req = axum::http::Request::builder() + .method(axum::http::Method::PUT) + .uri(callers::endpoints::UPDATE_USER_PROFILE) + .header(axum::http::header::CONTENT_TYPE, "application/json") + .body(axum::body::Body::from(payload.to_string())) + .unwrap(); + + app.clone().oneshot(req).await + } + } + + pub mod responses { + pub use soaricarus_auth::callers::login::response as login_responses; + pub use soaricarus_auth::callers::register::response as register_responses; } #[tokio::test] @@ -575,7 +476,7 @@ mod tests { let id = uuid::Uuid::parse_str("22f9c775-cce9-457a-a147-9dafbb801f61").unwrap(); let key = sienvy::environment::get_secret_key().value; - match token_stuff::create_service_token(&key, &id) { + match soaricarus_auth::token_stuff::create_service_token(&key, &id) { Ok((token, _expire)) => { let payload = serde_json::json!({ "access_token": token @@ -771,7 +672,8 @@ mod tests { let body = axum::body::to_bytes(resp.into_body(), usize::MAX) .await .unwrap(); - let parsed_body: callers::login::response::get_user_profile::GetUserProfileResponse = + + let parsed_body: responses::login_responses::get_user_profile::GetUserProfileResponse = serde_json::from_slice(&body).unwrap(); let user_profile = &parsed_body.data[0]; assert!( @@ -791,4 +693,97 @@ mod tests { let _ = db_mgr::drop_database(&tm_pool, &db_name).await; } + + #[tokio::test] + async fn test_update_user_profile() { + let tm_pool = db_mgr::get_pool().await.unwrap(); + + let db_name = db_mgr::generate_db_name().await; + + match db_mgr::create_database(&tm_pool, &db_name).await { + Ok(_) => { + println!("Success"); + } + Err(e) => { + assert!(false, "Error: {:?}", e.to_string()); + } + } + + let pool = db_mgr::connect_to_db(&db_name).await.unwrap(); + + db::init::migrations(&pool).await; + + let app = init::routes().await.layer(axum::Extension(pool)); + + let usr = get_test_register_request(); + + let response = requests::register(&app, &usr).await; + + match response { + Ok(resp) => { + assert_eq!( + resp.status(), + StatusCode::CREATED, + "Message: {:?} {:?}", + resp, + usr.username + ); + let body = axum::body::to_bytes(resp.into_body(), usize::MAX) + .await + .unwrap(); + let parsed_body: responses::register_responses::Response = + serde_json::from_slice(&body).unwrap(); + let returned_usr = &parsed_body.data[0]; + + let user_id = returned_usr.id; + assert_eq!(false, user_id.is_nil(), "Id is not populated"); + + assert_eq!( + usr.username, returned_usr.username, + "Usernames do not match" + ); + assert!(returned_usr.date_created.is_some(), "Date Created is empty"); + + let updated_firstname = test_data::UPDATED_FIRSTNAME; + let updated_lastname = test_data::UPDATED_LASTNAME; + + match requests::update_user_profile( + &app, + &user_id, + &updated_firstname, + &updated_lastname, + ) + .await + { + Ok(resp) => { + assert_eq!(StatusCode::OK, resp.status(), "Status is not right"); + let body = axum::body::to_bytes(resp.into_body(), usize::MAX) + .await + .unwrap(); + + let parsed_body: responses::login_responses::update_user_profile::UpdateUserProfileResponse = + serde_json::from_slice(&body).unwrap(); + let user_profile = &parsed_body.data[0]; + + assert_eq!( + updated_firstname, user_profile.firstname, + "Firstname has not been updated" + ); + assert_eq!( + updated_lastname, user_profile.lastname, + "Lastname has not been updated" + ); + } + Err(err) => { + assert!(false, "Error: {:?}", err.to_string()); + } + } + } + Err(err) => { + assert!(false, "Error: {:?}", err.to_string()); + } + }; + + let _ = db_mgr::drop_database(&tm_pool, &db_name).await; + } } diff --git a/src/repo/mod.rs b/src/repo/mod.rs index 4200934..384b9d6 100644 --- a/src/repo/mod.rs +++ b/src/repo/mod.rs @@ -132,6 +132,34 @@ pub mod user { } } + pub async fn update_user_profile( + pool: &sqlx::PgPool, + id: &uuid::Uuid, + firstname: &str, + lastname: &str, + ) -> Result { + match sqlx::query( + r#" + UPDATE "user" SET firstname = $1, lastname = $2 WHERE id = $3 + "#, + ) + .bind(firstname) + .bind(lastname) + .bind(id) + .execute(pool) + .await + { + Ok(r) => { + if r.rows_affected() > 0 { + Ok(true) + } else { + Ok(false) + } + } + Err(err) => Err(err), + } + } + pub async fn update_last_login( pool: &sqlx::PgPool, user: &simodels::user::User,