1d5be35
use async_trait::async_trait;
use crate::protos::auth as proto;
use crate::service::AuthService;
use export::{AuthApi, KenAuthError};
#[async_trait]
impl AuthApi for AuthService {
async fn check_health(&self) -> Result<(), KenAuthError> {
self.check_health().await
}
async fn change_password(
&self,
user_id: i64,
old_password_hash: &str,
new_password_hash: &str,
keep_session_id: &str,
client_ip: &str,
) -> Result<proto::v1::ChangePasswordResponse, KenAuthError> {
self.change_password(
user_id,
old_password_hash,
new_password_hash,
keep_session_id,
client_ip,
)
.await
}
async fn get_mfa_status(
&self,
user_id: i64,
) -> Result<proto::v1::GetMfaStatusResponse, KenAuthError> {
self.get_mfa_status(user_id).await
}
async fn configure_totp(
&self,
user_id: i64,
name: &str,
client_ip: &str,
) -> Result<proto::v1::ConfigureTotpResponse, KenAuthError> {
self.configure_totp(user_id, name, client_ip).await
}
async fn enable_totp(
&self,
user_id: i64,
code: &str,
password_hash: &str,
client_ip: &str,
) -> Result<proto::v1::EnableTotpResponse, KenAuthError> {
self.enable_totp(user_id, code, password_hash, client_ip)
.await
}
async fn disable_totp(
&self,
user_id: i64,
code: &str,
client_ip: &str,
) -> Result<proto::v1::DisableTotpResponse, KenAuthError> {
self.disable_totp(user_id, code, client_ip).await
}
async fn regenerate_recovery_codes(
&self,
user_id: i64,
password_hash: &str,
client_ip: &str,
) -> Result<proto::v1::RegenerateRecoveryCodesResponse, KenAuthError> {
self.regenerate_recovery_codes(user_id, password_hash, client_ip)
.await
}
async fn list_user_ssh_keys(
&self,
user_id: i64,
include_revoked: bool,
page: proto::common::v1::PageRequest,
) -> Result<proto::v1::ListUserSshKeysResponse, KenAuthError> {
self.list_user_ssh_keys(user_id, include_revoked, page)
.await
}
async fn add_ssh_key(
&self,
user_id: i64,
name: &str,
public_key: &str,
description: &str,
client_ip: &str,
) -> Result<proto::v1::AddSshKeyResponse, KenAuthError> {
self.add_ssh_key(user_id, name, public_key, description, client_ip)
.await
}
async fn revoke_ssh_key(
&self,
user_id: i64,
key_id: &str,
reason: &str,
bump_security_version: bool,
) -> Result<proto::v1::RevokeSshKeyResponse, KenAuthError> {
self.revoke_ssh_key(user_id, key_id, reason, bump_security_version)
.await
}
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> {
self.list_user_sessions(user_id, include_revoked, include_expired, page)
.await
}
async fn revoke_user_sessions(
&self,
user_id: i64,
except_session_id: &str,
reason: &str,
bump_security_version: bool,
) -> Result<proto::v1::RevokeUserSessionsResponse, KenAuthError> {
self.revoke_user_sessions(user_id, except_session_id, reason, bump_security_version)
.await
}
async fn get_session(
&self,
user_id: i64,
version: i32,
session_id: &str,
) -> Result<proto::internal::v1::AuthorityAccess, KenAuthError> {
self.get_session(user_id, version, session_id).await
}
async fn delete_account(&self, user_id: i64, reason: &str) -> Result<(), KenAuthError> {
self.delete_account(user_id, reason).await
}
async fn cancel_account_deletion(&self, user_id: i64) -> Result<(), KenAuthError> {
self.cancel_account_deletion(user_id).await
}
async fn purge_account(&self, user_id: i64) -> Result<(), KenAuthError> {
self.purge_account(user_id).await
}
async fn batch_get_authority_users(
&self,
user_ids: Vec<i64>,
) -> Result<Vec<proto::internal::v1::AuthorityUser>, KenAuthError> {
self.batch_get_authority_users(user_ids).await
}
async fn get_user_status(
&self,
user_id: i64,
) -> Result<proto::common::v1::UserStatus, KenAuthError> {
self.get_user_status(user_id).await
}
async fn get_user_public_by_ref(
&self,
key: proto::common::v1::user_ref::Key,
) -> Result<proto::common::v1::UserPublic, KenAuthError> {
self.get_user_public_by_ref(key).await
}
async fn get_authority_user(
&self,
user_id: i64,
) -> Result<proto::internal::v1::AuthorityUser, KenAuthError> {
self.get_authority_user(user_id).await
}
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> {
self.update_authority_user(
user_id,
username,
displayname,
clear_displayname,
public_show_email,
version,
)
.await
}
async fn batch_get_user_public(
&self,
user_ids: Vec<i64>,
) -> Result<Vec<proto::common::v1::UserPublic>, KenAuthError> {
self.batch_get_user_public(user_ids).await
}
async fn get_user_public(
&self,
user_id: i64,
) -> Result<proto::common::v1::UserPublic, KenAuthError> {
self.get_user_public(user_id).await
}
async fn revoke_session(
&self,
user_id: i64,
session_id: &str,
reason: &str,
) -> Result<(), KenAuthError> {
self.revoke_session(user_id, session_id, reason).await
}
async fn lookup_ssh_key(
&self,
public_key: &str,
) -> Result<Option<proto::common::v1::Principal>, KenAuthError> {
self.lookup_ssh_key(public_key).await
}
async fn ensure_bot_user(
&self,
username: &str,
displayname: &str,
system: bool,
) -> Result<proto::common::v1::UserPublic, KenAuthError> {
self.ensure_bot_user(username, displayname, system).await
}
async fn ensure_bot_member(
&self,
organization_id: &str,
user_id: i64,
role_keys: Vec<String>,
role_ids: Vec<String>,
) -> Result<proto::v1::OrganizationMemberInfo, KenAuthError> {
self.ensure_bot_member(organization_id, user_id, role_keys, role_ids)
.await
}
async fn get_organization(
&self,
actor_user_id: i64,
organization_id: &str,
slug: &str,
) -> Result<proto::v1::GetOrganizationResponse, KenAuthError> {
self.get_organization(actor_user_id, organization_id, slug)
.await
}
async fn get_member(
&self,
actor_user_id: i64,
organization_id: &str,
user_id: i64,
) -> Result<Option<proto::v1::OrganizationMemberInfo>, KenAuthError> {
self.get_member(actor_user_id, organization_id, user_id)
.await
}
async fn list_members(
&self,
actor_user_id: i64,
organization_id: &str,
include_inactive: bool,
include_banned: bool,
page: proto::common::v1::PageRequest,
) -> Result<proto::v1::ListMembersResponse, KenAuthError> {
self.list_members(
actor_user_id,
organization_id,
include_inactive,
include_banned,
page,
)
.await
}
async fn list_organizations(
&self,
actor_user_id: i64,
user_id: i64,
include_archived: bool,
page: proto::common::v1::PageRequest,
) -> Result<proto::v1::ListOrganizationsResponse, KenAuthError> {
self.list_organizations(actor_user_id, user_id, include_archived, page)
.await
}
async fn list_public_organizations(
&self,
query: &str,
page: proto::common::v1::PageRequest,
) -> Result<proto::v1::ListPublicOrganizationsResponse, KenAuthError> {
self.list_public_organizations(query, page).await
}
async fn check_permissions(
&self,
actor_user_id: i64,
organization_id: &str,
user_id: i64,
permissions: Vec<String>,
) -> Result<proto::v1::CheckPermissionsResponse, KenAuthError> {
self.check_permissions(actor_user_id, organization_id, user_id, permissions)
.await
}
async fn create_organization(
&self,
actor_user_id: i64,
slug: &str,
name: &str,
description: &str,
avatar_url: &str,
join_policy: Option<i32>,
allow_join: Option<bool>,
require_email_verified: Option<bool>,
require_mfa: Option<bool>,
welcome_message: Option<String>,
member_must_enable_2fa: Option<bool>,
allow_invite: Option<bool>,
allow_join_level: Option<i32>,
) -> Result<proto::v1::CreateOrganizationResponse, KenAuthError> {
self.create_organization(
actor_user_id,
slug,
name,
description,
avatar_url,
join_policy,
allow_join,
require_email_verified,
require_mfa,
welcome_message,
member_must_enable_2fa,
allow_invite,
allow_join_level,
)
.await
}
async fn update_organization(
&self,
actor_user_id: i64,
organization_id: &str,
name: Option<String>,
description: Option<String>,
avatar_url: Option<String>,
expected_version: i32,
join_policy: Option<i32>,
allow_join: Option<bool>,
require_email_verified: Option<bool>,
require_mfa: Option<bool>,
welcome_message: Option<String>,
member_must_enable_2fa: Option<bool>,
allow_invite: Option<bool>,
allow_join_level: Option<i32>,
) -> Result<proto::v1::OrganizationInfo, KenAuthError> {
self.update_organization(
actor_user_id,
organization_id,
name,
description,
avatar_url,
expected_version,
join_policy,
allow_join,
require_email_verified,
require_mfa,
welcome_message,
member_must_enable_2fa,
allow_invite,
allow_join_level,
)
.await
}
async fn archive_organization(
&self,
actor_user_id: i64,
organization_id: &str,
reason: &str,
) -> Result<(), KenAuthError> {
self.archive_organization(actor_user_id, organization_id, reason)
.await
}
async fn restore_organization(
&self,
actor_user_id: i64,
organization_id: &str,
) -> Result<(), KenAuthError> {
self.restore_organization(actor_user_id, organization_id)
.await
}
async fn delete_organization(
&self,
actor_user_id: i64,
organization_id: &str,
force: bool,
reason: &str,
) -> Result<(), KenAuthError> {
self.delete_organization(actor_user_id, organization_id, force, reason)
.await
}
async fn add_member(
&self,
actor_user_id: i64,
organization_id: &str,
user_id: i64,
role: i32,
role_keys: Vec<String>,
) -> Result<(proto::v1::OrganizationMemberInfo, bool), KenAuthError> {
self.add_member(actor_user_id, organization_id, user_id, role, role_keys)
.await
}
async fn remove_member(
&self,
actor_user_id: i64,
organization_id: &str,
user_id: i64,
reason: &str,
) -> Result<bool, KenAuthError> {
self.remove_member(actor_user_id, organization_id, user_id, reason)
.await
}
async fn leave_organization(
&self,
actor_user_id: i64,
organization_id: &str,
) -> Result<bool, KenAuthError> {
self.leave_organization(actor_user_id, organization_id)
.await
}
async fn update_member(
&self,
actor_user_id: i64,
organization_id: &str,
user_id: i64,
alias_name: Option<Option<String>>,
alias_avatar_url: Option<Option<String>>,
message_notifications: Option<String>,
muted: Option<bool>,
mute_until: Option<Option<prost_types::Timestamp>>,
mobile_push: Option<bool>,
suppress_everyone: Option<bool>,
suppress_roles: Option<bool>,
hide_muted_channels: Option<bool>,
) -> Result<proto::v1::OrganizationMemberInfo, KenAuthError> {
self.update_member(
actor_user_id,
organization_id,
user_id,
alias_name,
alias_avatar_url,
message_notifications,
muted,
mute_until,
mobile_push,
suppress_everyone,
suppress_roles,
hide_muted_channels,
)
.await
}
async fn ban_member(
&self,
actor_user_id: i64,
organization_id: &str,
user_id: i64,
reason: &str,
) -> Result<proto::v1::OrganizationMemberInfo, KenAuthError> {
self.ban_member(actor_user_id, organization_id, user_id, reason)
.await
}
async fn unban_member(
&self,
actor_user_id: i64,
organization_id: &str,
user_id: i64,
) -> Result<proto::v1::OrganizationMemberInfo, KenAuthError> {
self.unban_member(actor_user_id, organization_id, user_id)
.await
}
async fn update_ban(
&self,
actor_user_id: i64,
organization_id: &str,
user_id: i64,
reason: Option<Option<String>>,
expires_at: Option<Option<prost_types::Timestamp>>,
allow_speak: Option<bool>,
allow_push_repo: Option<bool>,
allow_comment_any: Option<bool>,
) -> Result<proto::v1::OrganizationMemberInfo, KenAuthError> {
self.update_ban(
actor_user_id,
organization_id,
user_id,
reason,
expires_at,
allow_speak,
allow_push_repo,
allow_comment_any,
)
.await
}
async fn create_role(
&self,
actor_user_id: i64,
organization_id: &str,
key: &str,
name: &str,
description: &str,
rank: i32,
self_assignable: bool,
permissions: Vec<String>,
) -> Result<proto::v1::OrganizationRoleInfo, KenAuthError> {
self.create_role(
actor_user_id,
organization_id,
key,
name,
description,
rank,
self_assignable,
permissions,
)
.await
}
async fn update_role(
&self,
actor_user_id: i64,
organization_id: &str,
role_id: &str,
name: Option<String>,
description: Option<String>,
rank: Option<i32>,
self_assignable: Option<bool>,
expected_version: i32,
) -> Result<proto::v1::OrganizationRoleInfo, KenAuthError> {
self.update_role(
actor_user_id,
organization_id,
role_id,
name,
description,
rank,
self_assignable,
expected_version,
)
.await
}
async fn set_role_permissions(
&self,
actor_user_id: i64,
organization_id: &str,
role_id: &str,
permissions: Vec<String>,
) -> Result<proto::v1::OrganizationRoleInfo, KenAuthError> {
self.set_role_permissions(actor_user_id, organization_id, role_id, permissions)
.await
}
async fn delete_role(
&self,
actor_user_id: i64,
organization_id: &str,
role_id: &str,
) -> Result<bool, KenAuthError> {
self.delete_role(actor_user_id, organization_id, role_id)
.await
}
async fn assign_role(
&self,
actor_user_id: i64,
organization_id: &str,
user_id: i64,
role_id: &str,
) -> Result<proto::v1::OrganizationMemberInfo, KenAuthError> {
self.assign_role(actor_user_id, organization_id, user_id, role_id)
.await
}
async fn unassign_role(
&self,
actor_user_id: i64,
organization_id: &str,
user_id: i64,
role_id: &str,
) -> Result<proto::v1::OrganizationMemberInfo, KenAuthError> {
self.unassign_role(actor_user_id, organization_id, user_id, role_id)
.await
}
async fn create_invite(
&self,
actor_user_id: i64,
organization_id: &str,
method: i32,
max_uses: i32,
expires_at: Option<prost_types::Timestamp>,
role_ids: Vec<String>,
target_user_id: i64,
email: &str,
) -> Result<(proto::v1::OrganizationInviteInfo, String), KenAuthError> {
self.create_invite(
actor_user_id,
organization_id,
method,
max_uses,
expires_at,
role_ids,
target_user_id,
email,
)
.await
}
async fn revoke_invite(
&self,
actor_user_id: i64,
organization_id: &str,
invite_id: &str,
) -> Result<bool, KenAuthError> {
self.revoke_invite(actor_user_id, organization_id, invite_id)
.await
}
async fn redeem_invite(
&self,
actor_user_id: i64,
token: &str,
) -> Result<proto::v1::RedeemInviteResponse, KenAuthError> {
self.redeem_invite(actor_user_id, token).await
}
async fn create_join_rule(
&self,
actor_user_id: i64,
organization_id: &str,
role_id: &str,
trigger: &str,
matcher: &str,
enabled: bool,
) -> Result<proto::v1::JoinRuleInfo, KenAuthError> {
self.create_join_rule(
actor_user_id,
organization_id,
role_id,
trigger,
matcher,
enabled,
)
.await
}
async fn update_join_rule(
&self,
actor_user_id: i64,
organization_id: &str,
rule_id: &str,
role_id: Option<String>,
trigger: Option<String>,
matcher: Option<String>,
enabled: Option<bool>,
) -> Result<proto::v1::JoinRuleInfo, KenAuthError> {
self.update_join_rule(
actor_user_id,
organization_id,
rule_id,
role_id,
trigger,
matcher,
enabled,
)
.await
}
async fn delete_join_rule(
&self,
actor_user_id: i64,
organization_id: &str,
rule_id: &str,
) -> Result<bool, KenAuthError> {
self.delete_join_rule(actor_user_id, organization_id, rule_id)
.await
}
async fn create_join_request(
&self,
actor_user_id: i64,
organization_id: &str,
note: &str,
) -> Result<proto::v1::JoinRequestInfo, KenAuthError> {
self.create_join_request(actor_user_id, organization_id, note)
.await
}
async fn withdraw_join_request(
&self,
actor_user_id: i64,
organization_id: &str,
request_id: &str,
) -> Result<proto::v1::JoinRequestInfo, KenAuthError> {
self.withdraw_join_request(actor_user_id, organization_id, request_id)
.await
}
async fn approve_join_request(
&self,
actor_user_id: i64,
organization_id: &str,
request_id: &str,
) -> Result<
(
proto::v1::JoinRequestInfo,
Option<proto::v1::OrganizationMemberInfo>,
),
KenAuthError,
> {
self.approve_join_request(actor_user_id, organization_id, request_id)
.await
}
async fn reject_join_request(
&self,
actor_user_id: i64,
organization_id: &str,
request_id: &str,
note: &str,
) -> Result<proto::v1::JoinRequestInfo, KenAuthError> {
self.reject_join_request(actor_user_id, organization_id, request_id, note)
.await
}
}