main
use crate::protos::auth as proto;
use crate::{Accounts, KenAuthError};
impl Accounts {
pub async fn check_health(&self) -> Result<(), KenAuthError> {
self.cache()
.ping()
.await
.map_err(|error| KenAuthError::Unavailable(error.to_string()))
}
#[allow(clippy::too_many_arguments)]
pub async fn list_user_sessions(
&self,
user_id: i64,
include_revoked: bool,
include_expired: bool,
page: proto::common::v1::PageRequest,
) -> Result<proto::v1::ListUserSessionsResponse, KenAuthError> {
let request_id = crate::share::audit::current_request_id();
self.list_user_sessions_inner(
Some(request_id.as_str()),
proto::v1::ListUserSessionsRequest {
user_id,
include_revoked,
include_expired,
page: Some(page),
},
)
.await
}
pub async fn revoke_user_sessions(
&self,
user_id: i64,
except_session_id: &str,
reason: &str,
bump_security_version: bool,
) -> Result<proto::v1::RevokeUserSessionsResponse, KenAuthError> {
let request_id = crate::share::audit::current_request_id();
self.revoke_user_sessions_inner(
Some(request_id.as_str()),
proto::v1::RevokeUserSessionsRequest {
user_id,
except_session_id: except_session_id.to_string(),
reason: reason.to_string(),
bump_security_version,
},
)
.await
}
pub async fn get_session(
&self,
user_id: i64,
version: i32,
session_id: &str,
) -> Result<proto::internal::v1::AuthorityAccess, KenAuthError> {
let request_id = crate::share::audit::current_request_id();
self.get_session_inner(
Some(request_id.as_str()),
proto::internal::v1::GetSessionRequest {
user_id,
version,
session_id: session_id.to_string(),
},
)
.await
.map(|response| response.access.unwrap_or_default())
}
pub async fn delete_account(&self, user_id: i64, reason: &str) -> Result<(), KenAuthError> {
let request_id = crate::share::audit::current_request_id();
self.delete_account_inner(
Some(request_id.as_str()),
proto::internal::v1::DeleteAccountRequest {
user_id,
reason: reason.to_string(),
},
)
.await?;
Ok(())
}
pub async fn cancel_account_deletion(&self, user_id: i64) -> Result<(), KenAuthError> {
let request_id = crate::share::audit::current_request_id();
self.cancel_account_deletion_inner(
Some(request_id.as_str()),
proto::internal::v1::CancelAccountDeletionRequest { user_id },
)
.await?;
Ok(())
}
pub async fn purge_account(&self, user_id: i64) -> Result<(), KenAuthError> {
let request_id = crate::share::audit::current_request_id();
self.purge_account_inner(
Some(request_id.as_str()),
proto::internal::v1::PurgeAccountRequest { user_id },
)
.await?;
Ok(())
}
pub async fn batch_get_authority_users(
&self,
user_ids: Vec<i64>,
) -> Result<Vec<proto::internal::v1::AuthorityUser>, KenAuthError> {
let request_id = crate::share::audit::current_request_id();
self.batch_get_user_inner(
Some(request_id.as_str()),
proto::internal::v1::BatchGetUserRequest { user_ids },
)
.await
.map(|response| response.users)
}
pub async fn get_user_status(
&self,
user_id: i64,
) -> Result<proto::common::v1::UserStatus, KenAuthError> {
let request_id = crate::share::audit::current_request_id();
let user = Some(proto::common::v1::UserRef {
key: Some(proto::common::v1::user_ref::Key::UserId(user_id)),
});
self.get_user_status_inner(
Some(request_id.as_str()),
proto::v1::GetUserStatusRequest { user },
)
.await
.map(|response| response.status.unwrap_or_default())
}
pub async fn get_user_public_by_ref(
&self,
key: proto::common::v1::user_ref::Key,
) -> Result<proto::common::v1::UserPublic, KenAuthError> {
let request_id = crate::share::audit::current_request_id();
let user = Some(proto::common::v1::UserRef { key: Some(key) });
self.get_user_public_inner(
Some(request_id.as_str()),
proto::v1::GetUserPublicRequest { user },
)
.await?
.user
.ok_or(KenAuthError::NotFound)
}
pub async fn get_authority_user(
&self,
user_id: i64,
) -> Result<proto::internal::v1::AuthorityUser, KenAuthError> {
let request_id = crate::share::audit::current_request_id();
self.get_user_inner(
Some(request_id.as_str()),
proto::internal::v1::GetUserRequest { user_id },
)
.await?
.user
.ok_or(KenAuthError::NotFound)
}
#[allow(clippy::too_many_arguments)]
pub async fn update_authority_user(
&self,
user_id: i64,
username: Option<String>,
displayname: Option<String>,
clear_displayname: bool,
public_show_email: Option<bool>,
version: i32,
) -> Result<proto::internal::v1::AuthorityUser, KenAuthError> {
let request_id = crate::share::audit::current_request_id();
self.update_user_inner(
Some(request_id.as_str()),
proto::internal::v1::UpdateUserRequest {
user_id,
patch: Some(proto::internal::v1::AuthorityUserPatch {
version,
username,
displayname,
clear_displayname,
public_show_email,
}),
},
)
.await?
.user
.ok_or(KenAuthError::NotFound)
}
pub async fn batch_get_user_public(
&self,
user_ids: Vec<i64>,
) -> Result<Vec<proto::common::v1::UserPublic>, KenAuthError> {
let request_id = crate::share::audit::current_request_id();
self.batch_get_user_public_inner(
Some(request_id.as_str()),
proto::v1::BatchGetUserPublicRequest { user_ids },
)
.await
.map(|response| response.users)
}
pub async fn get_user_public(
&self,
user_id: i64,
) -> Result<proto::common::v1::UserPublic, KenAuthError> {
let request_id = crate::share::audit::current_request_id();
let user = Some(proto::common::v1::UserRef {
key: Some(proto::common::v1::user_ref::Key::UserId(user_id)),
});
self.get_user_public_inner(
Some(request_id.as_str()),
proto::v1::GetUserPublicRequest { user },
)
.await?
.user
.ok_or(KenAuthError::NotFound)
}
pub async fn revoke_session(
&self,
user_id: i64,
session_id: &str,
reason: &str,
) -> Result<(), KenAuthError> {
let request_id = crate::share::audit::current_request_id();
self.revoke_session_inner(
Some(request_id.as_str()),
proto::v1::RevokeSessionRequest {
user_id,
session_id: session_id.to_string(),
reason: reason.to_string(),
},
)
.await?;
Ok(())
}
pub async fn ensure_bot_user(
&self,
username: &str,
displayname: &str,
system: bool,
) -> Result<proto::common::v1::UserPublic, KenAuthError> {
let request_id = crate::share::audit::current_request_id();
self.ensure_bot_user_inner(
Some(request_id.as_str()),
proto::v1::EnsureBotUserRequest {
username: username.to_string(),
displayname: displayname.to_string(),
system,
},
)
.await?
.user
.ok_or(KenAuthError::NotFound)
}
}