main
use crate::Accounts;
use crate::errors::KenAuthError;
use crate::protos::auth::common::v1::UserPublic;
use api::users::UserDto;
use std::collections::HashMap;
pub async fn load_user_briefs(
accounts: &Accounts,
uids: &[i64],
) -> Result<HashMap<i64, UserDto>, KenAuthError> {
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>, KenAuthError> {
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?;
Ok(users.into_iter().map(|user| (user.user_id, user)).collect())
}
pub async fn get_public_user(
accounts: &Accounts,
uid: i64,
) -> Result<Option<UserPublic>, KenAuthError> {
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(error),
}
}
pub async fn find_by_email(
accounts: &Accounts,
email: &str,
) -> Result<Option<UserPublic>, KenAuthError> {
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(error),
}
}
pub async fn find_by_username(
accounts: &Accounts,
username: &str,
) -> Result<Option<UserPublic>, KenAuthError> {
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(error),
}
}