Genarrative/server-rs/crates/api-server/src/auth_public_user.rs

use axum::{
    Json,
    extract::{Extension, Path, State},
    http::StatusCode,
};
use shared_contracts::auth::PublicUserSearchResponse;

use crate::{
    api_response::json_success_body, auth_payload::map_public_user_summary_payload,
    http_error::AppError, request_context::RequestContext, state::AppState,
};

pub async fn get_public_user_by_code(
    State(state): State<AppState>,
    Extension(request_context): Extension<RequestContext>,
    Path(code): Path<String>,
) -> Result<Json<serde_json::Value>, AppError> {
    state
        .refresh_auth_store_from_spacetime()
        .await
        .map_err(|error| {
            AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR)
                .with_message(format!("刷新认证状态失败：{error}"))
        })?;
    let user = state
        .password_entry_service()
        .get_user_by_public_user_code(&code)
        .map_err(map_public_user_search_error)?
        .ok_or_else(|| {
            AppError::from_status(StatusCode::NOT_FOUND).with_message("未找到对应陶泥号用户")
        })?;

    Ok(json_success_body(
        Some(&request_context),
        PublicUserSearchResponse {
            user: map_public_user_summary_payload(user.user),
        },
    ))
}

pub async fn get_public_user_by_id(
    State(state): State<AppState>,
    Extension(request_context): Extension<RequestContext>,
    Path(user_id): Path<String>,
) -> Result<Json<serde_json::Value>, AppError> {
    let user_id = user_id.trim();
    if user_id.is_empty() {
        return Err(AppError::from_status(StatusCode::BAD_REQUEST).with_message("用户 ID 不能为空"));
    }

    state
        .refresh_auth_store_from_spacetime()
        .await
        .map_err(|error| {
            AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR)
                .with_message(format!("刷新认证状态失败：{error}"))
        })?;

    let user = state
        .auth_user_service()
        .get_user_by_id(user_id)
        .map_err(map_public_user_id_search_error)?
        .ok_or_else(|| {
            AppError::from_status(StatusCode::NOT_FOUND).with_message("未找到对应用户")
        })?;

    Ok(json_success_body(
        Some(&request_context),
        PublicUserSearchResponse {
            user: map_public_user_summary_payload(user),
        },
    ))
}

fn map_public_user_search_error(error: module_auth::PasswordEntryError) -> AppError {
    match error {
        module_auth::PasswordEntryError::InvalidPublicUserCode => {
            AppError::from_status(StatusCode::BAD_REQUEST).with_message("陶泥号格式不正确")
        }
        module_auth::PasswordEntryError::Store(_)
        | module_auth::PasswordEntryError::PasswordHash(_)
        | module_auth::PasswordEntryError::InvalidPhoneNumber
        | module_auth::PasswordEntryError::UnsupportedPhoneCountryCode
        | module_auth::PasswordEntryError::InvalidPasswordLength
        | module_auth::PasswordEntryError::InvalidDisplayName
        | module_auth::PasswordEntryError::InvalidAvatarDataUrl
        | module_auth::PasswordEntryError::EmptyProfileUpdate
        | module_auth::PasswordEntryError::InvalidCredentials
        | module_auth::PasswordEntryError::UserNotFound => {
            AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR).with_message(error.to_string())
        }
    }
}

fn map_public_user_id_search_error(error: module_auth::LogoutError) -> AppError {
    match error {
        module_auth::LogoutError::UserNotFound => {
            AppError::from_status(StatusCode::NOT_FOUND).with_message("未找到对应用户")
        }
        module_auth::LogoutError::Store(_) => {
            AppError::from_status(StatusCode::INTERNAL_SERVER_ERROR).with_message(error.to_string())
        }
    }
}