use std::collections::{HashMap, HashSet}; use axum::{extract::State, http::StatusCode}; use serde::Deserialize; use sqlx::PgPool; use uuid::Uuid; use super::{ dtos::account_member::{AccountMemberRequest, AccountMemberResponse}, extractors::{Auth, Json, Path, Query}, }; use crate::{domain, error::AppError, repository}; pub fn create_router() -> axum::Router { axum::Router::new() .route("/", axum::routing::get(list_account_members)) .route( "/{member_id}", axum::routing::get(get_account_member) .put(upsert_account_member) .delete(delete_account_member), ) } #[derive(Debug, Deserialize)] pub struct QueryParams { pub limit: Option, pub offset: Option, } #[axum::debug_handler] #[tracing::instrument(skip(pool))] async fn list_account_members( Auth(auth): Auth, Path(account_id): Path, Query(query): Query, State(pool): State, ) -> Result>, AppError> { let user_id = auth.user_id(); repository::accounts::get_by_id(&pool, user_id, account_id) .await? .map(|_| ()) .ok_or(AppError::NotFound)?; let query = repository::account_members::Query { limit: Some(query.limit.unwrap_or(20)), offset: query.offset, }; let members = repository::account_members::list(&pool, user_id, account_id, query).await?; let users = get_users_for_account_members(&pool, &members).await?; let responses = members .into_iter() .map(|member| create_response(member, &users)) .collect::, _>>()?; Ok(Json(responses)) } #[axum::debug_handler] #[tracing::instrument(skip(pool))] async fn get_account_member( Auth(auth): Auth, Path((account_id, member_id)): Path<(Uuid, Uuid)>, State(pool): State, ) -> Result, AppError> { let user_id = auth.user_id(); let member = repository::account_members::get_by_id(&pool, user_id, account_id, member_id) .await? .ok_or(AppError::NotFound)?; let users = repository::users::get_by_id(&pool, member.user_id) .await? .map(|user| HashMap::from([(user.id, user)])) .ok_or(AppError::RaceCondition)?; // User should exist! Ok(Json(create_response(member, &users)?)) } #[axum::debug_handler] #[tracing::instrument(skip(pool, member))] async fn upsert_account_member( Auth(auth): Auth, Path((account_id, member_id)): Path<(Uuid, Uuid)>, State(pool): State, Json(member): Json, ) -> Result<(StatusCode, Json), AppError> { let user_id = auth.user_id(); let member = member.into_domain(member_id, account_id)?; let user = repository::users::get_by_id(&pool, member.user_id) .await? .ok_or(AppError::UserNotFound)?; let upserted = repository::account_members::upsert(&pool, user_id, member) .await? .ok_or(AppError::NotFound)?; let status = if upserted.previous.is_some() { StatusCode::OK } else { StatusCode::CREATED }; Ok(( status, Json(create_response( upserted.current, &HashMap::from([(user.id, user)]), )?), )) } #[axum::debug_handler] #[tracing::instrument(skip(pool))] async fn delete_account_member( Auth(auth): Auth, Path((account_id, member_id)): Path<(Uuid, Uuid)>, State(pool): State, ) -> Result { let user_id = auth.user_id(); repository::account_members::delete_by_id(&pool, user_id, account_id, member_id) .await? .ok_or(AppError::NotFound)?; Ok(StatusCode::NO_CONTENT) } async fn get_users_for_account_members<'e, E>( executor: E, account_members: &[domain::AccountMember], ) -> Result, AppError> where E: sqlx::Executor<'e, Database = sqlx::Postgres>, { let user_ids = account_members .iter() .map(|account_member| account_member.user_id) .collect::>() .into_iter() .collect::>(); Ok(repository::users::get_by_ids(executor, &user_ids).await?) } fn create_response( account_member: domain::AccountMember, users: &HashMap, ) -> Result { let user = users .get(&account_member.user_id) .cloned() .ok_or(AppError::Unknown)?; Ok(AccountMemberResponse::new(account_member, user)) }