26af08e
use crate::Accounts;
use crate::protos::auth::common::v1::UserPublic;
use export::ExportError;
use export::users::UserDto;
use std::collections::HashMap;
pub async fn load_user_briefs(
accounts: &Accounts,
uids: &[i64],
) -> Result<HashMap<i64, UserDto>, ExportError> {
let users = load_public_users(accounts, uids).await?;
Ok(users
.into_iter()
.map(|(uid, public)| (uid, UserDto::from_public(&public)))
.collect())
}
/// Bulk identity lookup. KenApi keeps no local copy of usernames, display
/// names or avatars: every caller goes through KenOAuth.
pub async fn load_public_users(
accounts: &Accounts,
uids: &[i64],
) -> Result<HashMap<i64, UserPublic>, ExportError> {
if uids.is_empty() {
return Ok(HashMap::new());
}
let mut ids: Vec<i64> = uids.to_vec();
ids.sort_unstable();
ids.dedup();
let client = accounts;
let users = client
.batch_get_user_public(ids)
.await
.map_err(|error| ExportError::Connection(error.to_string()))?;
Ok(users.into_iter().map(|user| (user.user_id, user)).collect())
}
pub async fn get_public_user(
accounts: &Accounts,
uid: i64,
) -> Result<Option<UserPublic>, ExportError> {
let client = accounts;
match client.get_user_public(uid).await {
Ok(user) => Ok(Some(user)),
Err(crate::errors::KenAuthError::NotFound) => Ok(None),
Err(error) => Err(ExportError::Connection(error.to_string())),
}
}
pub async fn find_by_email(
accounts: &Accounts,
email: &str,
) -> Result<Option<UserPublic>, ExportError> {
let client = accounts;
match client
.get_user_public_by_ref(proto::auth::common::v1::user_ref::Key::Email(
email.to_string(),
))
.await
{
Ok(user) => Ok(Some(user)),
Err(crate::errors::KenAuthError::NotFound) => Ok(None),
Err(error) => Err(ExportError::Connection(error.to_string())),
}
}
pub async fn find_by_username(
accounts: &Accounts,
username: &str,
) -> Result<Option<UserPublic>, ExportError> {
let client = accounts;
match client
.get_user_public_by_ref(proto::auth::common::v1::user_ref::Key::Username(
username.to_string(),
))
.await
{
Ok(user) => Ok(Some(user)),
Err(crate::errors::KenAuthError::NotFound) => Ok(None),
Err(error) => Err(ExportError::Connection(error.to_string())),
}
}