b7cd2b1
use crate::auth::AuthSvc;
use crate::auth::grpc::context::RequestMeta;
use tonic::{Request, Response, Status};
use uuid::Uuid;
use crate::auth::grpc::identity::IdentityApi;
use crate::protos::auth::v1::identity_service_server::IdentityService;
pub struct IdentityClient {
api: IdentityApi,
}
impl IdentityClient {
pub fn new(service: AuthSvc) -> Self {
Self {
api: IdentityApi::new(service),
}
}
pub async fn authenticate(
&mut self,
mut request: Request<crate::protos::auth::v1::AuthenticateRequest>,
) -> Result<Response<crate::protos::auth::v1::AuthenticateResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.authenticate(request).await
}
pub async fn verify_credential(
&mut self,
mut request: Request<crate::protos::auth::v1::VerifyCredentialRequest>,
) -> Result<Response<crate::protos::auth::v1::VerifyCredentialResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.verify_credential(request).await
}
pub async fn get_user_public(
&mut self,
mut request: Request<crate::protos::auth::v1::GetUserPublicRequest>,
) -> Result<Response<crate::protos::auth::v1::GetUserPublicResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.get_user_public(request).await
}
pub async fn batch_get_user_public(
&mut self,
mut request: Request<crate::protos::auth::v1::BatchGetUserPublicRequest>,
) -> Result<Response<crate::protos::auth::v1::BatchGetUserPublicResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.batch_get_user_public(request).await
}
pub async fn get_user_status(
&mut self,
mut request: Request<crate::protos::auth::v1::GetUserStatusRequest>,
) -> Result<Response<crate::protos::auth::v1::GetUserStatusResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.get_user_status(request).await
}
pub async fn ensure_bot_user(
&mut self,
mut request: Request<crate::protos::auth::v1::EnsureBotUserRequest>,
) -> Result<Response<crate::protos::auth::v1::EnsureBotUserResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.ensure_bot_user(request).await
}
pub async fn change_password(
&mut self,
mut request: Request<crate::protos::auth::v1::ChangePasswordRequest>,
) -> Result<Response<crate::protos::auth::v1::ChangePasswordResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.change_password(request).await
}
}
use crate::auth::grpc::authority::AuthorityApi;
use crate::protos::auth::internal::v1::authority_service_server::AuthorityService;
pub struct AuthorityClient {
api: AuthorityApi,
}
impl AuthorityClient {
pub fn new(service: AuthSvc) -> Self {
Self {
api: AuthorityApi::new(service),
}
}
pub async fn redeem_socket_ticket(
&mut self,
mut request: Request<crate::protos::auth::internal::v1::RedeemSocketTicketRequest>,
) -> Result<Response<crate::protos::auth::internal::v1::RedeemSocketTicketResponse>, Status>
{
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.redeem_socket_ticket(request).await
}
pub async fn validate(
&mut self,
mut request: Request<crate::protos::auth::internal::v1::ValidateRequest>,
) -> Result<Response<crate::protos::auth::internal::v1::ValidateResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.validate(request).await
}
pub async fn get_user(
&mut self,
mut request: Request<crate::protos::auth::internal::v1::GetUserRequest>,
) -> Result<Response<crate::protos::auth::internal::v1::GetUserResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.get_user(request).await
}
pub async fn batch_get_user(
&mut self,
mut request: Request<crate::protos::auth::internal::v1::BatchGetUserRequest>,
) -> Result<Response<crate::protos::auth::internal::v1::BatchGetUserResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.batch_get_user(request).await
}
pub async fn get_session(
&mut self,
mut request: Request<crate::protos::auth::internal::v1::GetSessionRequest>,
) -> Result<Response<crate::protos::auth::internal::v1::GetSessionResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.get_session(request).await
}
pub async fn update_user(
&mut self,
mut request: Request<crate::protos::auth::internal::v1::UpdateUserRequest>,
) -> Result<Response<crate::protos::auth::internal::v1::UpdateUserResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.update_user(request).await
}
pub async fn delete_account(
&mut self,
mut request: Request<crate::protos::auth::internal::v1::DeleteAccountRequest>,
) -> Result<Response<crate::protos::auth::internal::v1::DeleteAccountResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.delete_account(request).await
}
pub async fn cancel_account_deletion(
&mut self,
mut request: Request<crate::protos::auth::internal::v1::CancelAccountDeletionRequest>,
) -> Result<Response<crate::protos::auth::internal::v1::CancelAccountDeletionResponse>, Status>
{
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.cancel_account_deletion(request).await
}
pub async fn purge_account(
&mut self,
mut request: Request<crate::protos::auth::internal::v1::PurgeAccountRequest>,
) -> Result<Response<crate::protos::auth::internal::v1::PurgeAccountResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.purge_account(request).await
}
pub async fn list_users(
&mut self,
mut request: Request<crate::protos::auth::internal::v1::ListUsersRequest>,
) -> Result<Response<crate::protos::auth::internal::v1::ListUsersResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.list_users(request).await
}
}
use crate::auth::grpc::email::EmailApi;
use crate::protos::auth::internal::v1::email_service_server::EmailService;
pub struct EmailClient {
api: EmailApi,
}
impl EmailClient {
pub fn new(service: AuthSvc) -> Self {
Self {
api: EmailApi::new(service),
}
}
pub async fn send_email(
&mut self,
mut request: Request<crate::protos::auth::internal::v1::SendEmailRequest>,
) -> Result<Response<crate::protos::auth::internal::v1::SendEmailResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.send_email(request).await
}
pub async fn send_batch_email(
&mut self,
mut request: Request<crate::protos::auth::internal::v1::SendBatchEmailRequest>,
) -> Result<Response<crate::protos::auth::internal::v1::SendBatchEmailResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.send_batch_email(request).await
}
pub async fn render_and_send_email(
&mut self,
mut request: Request<crate::protos::auth::internal::v1::RenderAndSendEmailRequest>,
) -> Result<Response<crate::protos::auth::internal::v1::SendEmailResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.render_and_send_email(request).await
}
pub async fn get_queue_status(
&mut self,
mut request: Request<crate::protos::auth::internal::v1::EmailQueueStatusRequest>,
) -> Result<Response<crate::protos::auth::internal::v1::EmailQueueStatus>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.get_queue_status(request).await
}
}
use crate::auth::grpc::session::SessionApi;
use crate::protos::auth::v1::session_service_server::SessionService;
pub struct SessionClient {
api: SessionApi,
}
impl SessionClient {
pub fn new(service: AuthSvc) -> Self {
Self {
api: SessionApi::new(service),
}
}
pub async fn list_user_sessions(
&mut self,
mut request: Request<crate::protos::auth::v1::ListUserSessionsRequest>,
) -> Result<Response<crate::protos::auth::v1::ListUserSessionsResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.list_user_sessions(request).await
}
pub async fn revoke_session(
&mut self,
mut request: Request<crate::protos::auth::v1::RevokeSessionRequest>,
) -> Result<Response<crate::protos::auth::v1::RevokeSessionResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.revoke_session(request).await
}
pub async fn revoke_user_sessions(
&mut self,
mut request: Request<crate::protos::auth::v1::RevokeUserSessionsRequest>,
) -> Result<Response<crate::protos::auth::v1::RevokeUserSessionsResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.revoke_user_sessions(request).await
}
pub async fn bump_security_version(
&mut self,
mut request: Request<crate::protos::auth::v1::BumpSecurityVersionRequest>,
) -> Result<Response<crate::protos::auth::v1::BumpSecurityVersionResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.bump_security_version(request).await
}
}
use crate::auth::grpc::organization::OrganizationApi;
use crate::protos::auth::v1::organization_service_server::OrganizationService;
pub struct OrganizationClient {
api: OrganizationApi,
}
impl OrganizationClient {
pub fn new(service: AuthSvc) -> Self {
Self {
api: OrganizationApi::new(service),
}
}
pub async fn create_organization(
&mut self,
mut request: Request<crate::protos::auth::v1::CreateOrganizationRequest>,
) -> Result<Response<crate::protos::auth::v1::CreateOrganizationResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.create_organization(request).await
}
pub async fn get_organization(
&mut self,
mut request: Request<crate::protos::auth::v1::GetOrganizationRequest>,
) -> Result<Response<crate::protos::auth::v1::GetOrganizationResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.get_organization(request).await
}
pub async fn list_organizations(
&mut self,
mut request: Request<crate::protos::auth::v1::ListOrganizationsRequest>,
) -> Result<Response<crate::protos::auth::v1::ListOrganizationsResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.list_organizations(request).await
}
pub async fn list_public_organizations(
&mut self,
mut request: Request<crate::protos::auth::v1::ListPublicOrganizationsRequest>,
) -> Result<Response<crate::protos::auth::v1::ListPublicOrganizationsResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.list_public_organizations(request).await
}
pub async fn update_organization(
&mut self,
mut request: Request<crate::protos::auth::v1::UpdateOrganizationRequest>,
) -> Result<Response<crate::protos::auth::v1::UpdateOrganizationResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.update_organization(request).await
}
pub async fn archive_organization(
&mut self,
mut request: Request<crate::protos::auth::v1::ArchiveOrganizationRequest>,
) -> Result<Response<crate::protos::auth::v1::ArchiveOrganizationResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.archive_organization(request).await
}
pub async fn restore_organization(
&mut self,
mut request: Request<crate::protos::auth::v1::RestoreOrganizationRequest>,
) -> Result<Response<crate::protos::auth::v1::RestoreOrganizationResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.restore_organization(request).await
}
pub async fn delete_organization(
&mut self,
mut request: Request<crate::protos::auth::v1::DeleteOrganizationRequest>,
) -> Result<Response<crate::protos::auth::v1::DeleteOrganizationResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.delete_organization(request).await
}
pub async fn transfer_ownership(
&mut self,
mut request: Request<crate::protos::auth::v1::TransferOwnershipRequest>,
) -> Result<Response<crate::protos::auth::v1::TransferOwnershipResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.transfer_ownership(request).await
}
pub async fn add_member(
&mut self,
mut request: Request<crate::protos::auth::v1::AddMemberRequest>,
) -> Result<Response<crate::protos::auth::v1::AddMemberResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.add_member(request).await
}
pub async fn remove_member(
&mut self,
mut request: Request<crate::protos::auth::v1::RemoveMemberRequest>,
) -> Result<Response<crate::protos::auth::v1::RemoveMemberResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.remove_member(request).await
}
pub async fn leave_organization(
&mut self,
mut request: Request<crate::protos::auth::v1::LeaveOrganizationRequest>,
) -> Result<Response<crate::protos::auth::v1::LeaveOrganizationResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.leave_organization(request).await
}
pub async fn list_members(
&mut self,
mut request: Request<crate::protos::auth::v1::ListMembersRequest>,
) -> Result<Response<crate::protos::auth::v1::ListMembersResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.list_members(request).await
}
pub async fn set_member_role(
&mut self,
mut request: Request<crate::protos::auth::v1::SetMemberRoleRequest>,
) -> Result<Response<crate::protos::auth::v1::SetMemberRoleResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.set_member_role(request).await
}
pub async fn ban_member(
&mut self,
mut request: Request<crate::protos::auth::v1::BanMemberRequest>,
) -> Result<Response<crate::protos::auth::v1::BanMemberResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.ban_member(request).await
}
pub async fn unban_member(
&mut self,
mut request: Request<crate::protos::auth::v1::UnbanMemberRequest>,
) -> Result<Response<crate::protos::auth::v1::UnbanMemberResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.unban_member(request).await
}
pub async fn get_member(
&mut self,
mut request: Request<crate::protos::auth::v1::GetMemberRequest>,
) -> Result<Response<crate::protos::auth::v1::GetMemberResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.get_member(request).await
}
pub async fn update_member(
&mut self,
mut request: Request<crate::protos::auth::v1::UpdateMemberRequest>,
) -> Result<Response<crate::protos::auth::v1::UpdateMemberResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.update_member(request).await
}
pub async fn update_self_member(
&mut self,
mut request: Request<crate::protos::auth::v1::UpdateMemberRequest>,
) -> Result<Response<crate::protos::auth::v1::UpdateMemberResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.update_self_member(request).await
}
pub async fn list_bans(
&mut self,
mut request: Request<crate::protos::auth::v1::ListBansRequest>,
) -> Result<Response<crate::protos::auth::v1::ListBansResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.list_bans(request).await
}
pub async fn get_ban(
&mut self,
mut request: Request<crate::protos::auth::v1::GetBanRequest>,
) -> Result<Response<crate::protos::auth::v1::GetBanResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.get_ban(request).await
}
pub async fn update_ban(
&mut self,
mut request: Request<crate::protos::auth::v1::UpdateBanRequest>,
) -> Result<Response<crate::protos::auth::v1::UpdateBanResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.update_ban(request).await
}
pub async fn get_role(
&mut self,
mut request: Request<crate::protos::auth::v1::GetRoleRequest>,
) -> Result<Response<crate::protos::auth::v1::GetRoleResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.get_role(request).await
}
pub async fn join_role(
&mut self,
mut request: Request<crate::protos::auth::v1::JoinRoleRequest>,
) -> Result<Response<crate::protos::auth::v1::JoinRoleResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.join_role(request).await
}
pub async fn leave_role(
&mut self,
mut request: Request<crate::protos::auth::v1::LeaveRoleRequest>,
) -> Result<Response<crate::protos::auth::v1::LeaveRoleResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.leave_role(request).await
}
pub async fn create_role(
&mut self,
mut request: Request<crate::protos::auth::v1::CreateRoleRequest>,
) -> Result<Response<crate::protos::auth::v1::CreateRoleResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.create_role(request).await
}
pub async fn update_role(
&mut self,
mut request: Request<crate::protos::auth::v1::UpdateRoleRequest>,
) -> Result<Response<crate::protos::auth::v1::UpdateRoleResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.update_role(request).await
}
pub async fn delete_role(
&mut self,
mut request: Request<crate::protos::auth::v1::DeleteRoleRequest>,
) -> Result<Response<crate::protos::auth::v1::DeleteRoleResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.delete_role(request).await
}
pub async fn list_roles(
&mut self,
mut request: Request<crate::protos::auth::v1::ListRolesRequest>,
) -> Result<Response<crate::protos::auth::v1::ListRolesResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.list_roles(request).await
}
pub async fn set_role_permissions(
&mut self,
mut request: Request<crate::protos::auth::v1::SetRolePermissionsRequest>,
) -> Result<Response<crate::protos::auth::v1::SetRolePermissionsResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.set_role_permissions(request).await
}
pub async fn assign_role(
&mut self,
mut request: Request<crate::protos::auth::v1::AssignRoleRequest>,
) -> Result<Response<crate::protos::auth::v1::AssignRoleResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.assign_role(request).await
}
pub async fn unassign_role(
&mut self,
mut request: Request<crate::protos::auth::v1::UnassignRoleRequest>,
) -> Result<Response<crate::protos::auth::v1::UnassignRoleResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.unassign_role(request).await
}
pub async fn set_member_permissions(
&mut self,
mut request: Request<crate::protos::auth::v1::SetMemberPermissionsRequest>,
) -> Result<Response<crate::protos::auth::v1::SetMemberPermissionsResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.set_member_permissions(request).await
}
pub async fn check_permission(
&mut self,
mut request: Request<crate::protos::auth::v1::CheckPermissionRequest>,
) -> Result<Response<crate::protos::auth::v1::CheckPermissionResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.check_permission(request).await
}
pub async fn check_permissions(
&mut self,
mut request: Request<crate::protos::auth::v1::CheckPermissionsRequest>,
) -> Result<Response<crate::protos::auth::v1::CheckPermissionsResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.check_permissions(request).await
}
pub async fn create_invite(
&mut self,
mut request: Request<crate::protos::auth::v1::CreateInviteRequest>,
) -> Result<Response<crate::protos::auth::v1::CreateInviteResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.create_invite(request).await
}
pub async fn revoke_invite(
&mut self,
mut request: Request<crate::protos::auth::v1::RevokeInviteRequest>,
) -> Result<Response<crate::protos::auth::v1::RevokeInviteResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.revoke_invite(request).await
}
pub async fn list_invites(
&mut self,
mut request: Request<crate::protos::auth::v1::ListInvitesRequest>,
) -> Result<Response<crate::protos::auth::v1::ListInvitesResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.list_invites(request).await
}
pub async fn redeem_invite(
&mut self,
mut request: Request<crate::protos::auth::v1::RedeemInviteRequest>,
) -> Result<Response<crate::protos::auth::v1::RedeemInviteResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.redeem_invite(request).await
}
pub async fn create_join_rule(
&mut self,
mut request: Request<crate::protos::auth::v1::CreateJoinRuleRequest>,
) -> Result<Response<crate::protos::auth::v1::CreateJoinRuleResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.create_join_rule(request).await
}
pub async fn update_join_rule(
&mut self,
mut request: Request<crate::protos::auth::v1::UpdateJoinRuleRequest>,
) -> Result<Response<crate::protos::auth::v1::UpdateJoinRuleResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.update_join_rule(request).await
}
pub async fn delete_join_rule(
&mut self,
mut request: Request<crate::protos::auth::v1::DeleteJoinRuleRequest>,
) -> Result<Response<crate::protos::auth::v1::DeleteJoinRuleResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.delete_join_rule(request).await
}
pub async fn list_join_rules(
&mut self,
mut request: Request<crate::protos::auth::v1::ListJoinRulesRequest>,
) -> Result<Response<crate::protos::auth::v1::ListJoinRulesResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.list_join_rules(request).await
}
pub async fn create_join_request(
&mut self,
mut request: Request<crate::protos::auth::v1::CreateJoinRequestRequest>,
) -> Result<Response<crate::protos::auth::v1::CreateJoinRequestResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.create_join_request(request).await
}
pub async fn list_join_requests(
&mut self,
mut request: Request<crate::protos::auth::v1::ListJoinRequestsRequest>,
) -> Result<Response<crate::protos::auth::v1::ListJoinRequestsResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.list_join_requests(request).await
}
pub async fn withdraw_join_request(
&mut self,
mut request: Request<crate::protos::auth::v1::WithdrawJoinRequestRequest>,
) -> Result<Response<crate::protos::auth::v1::WithdrawJoinRequestResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.withdraw_join_request(request).await
}
pub async fn approve_join_request(
&mut self,
mut request: Request<crate::protos::auth::v1::ApproveJoinRequestRequest>,
) -> Result<Response<crate::protos::auth::v1::ApproveJoinRequestResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.approve_join_request(request).await
}
pub async fn reject_join_request(
&mut self,
mut request: Request<crate::protos::auth::v1::RejectJoinRequestRequest>,
) -> Result<Response<crate::protos::auth::v1::RejectJoinRequestResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.reject_join_request(request).await
}
pub async fn ensure_bot_member(
&mut self,
mut request: Request<crate::protos::auth::v1::EnsureBotMemberRequest>,
) -> Result<Response<crate::protos::auth::v1::EnsureBotMemberResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.ensure_bot_member(request).await
}
}
use crate::auth::grpc::token::TokenApi;
use crate::protos::auth::v1::token_service_server::TokenService;
pub struct TokenClient {
api: TokenApi,
}
impl TokenClient {
pub fn new(service: AuthSvc) -> Self {
Self {
api: TokenApi::new(service),
}
}
pub async fn introspect_token(
&mut self,
mut request: Request<crate::protos::auth::v1::IntrospectTokenRequest>,
) -> Result<Response<crate::protos::auth::v1::IntrospectTokenResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.introspect_token(request).await
}
pub async fn issue_service_token(
&mut self,
mut request: Request<crate::protos::auth::v1::IssueServiceTokenRequest>,
) -> Result<Response<crate::protos::auth::v1::IssueServiceTokenResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.issue_service_token(request).await
}
pub async fn revoke_service_token(
&mut self,
mut request: Request<crate::protos::auth::v1::RevokeServiceTokenRequest>,
) -> Result<Response<crate::protos::auth::v1::RevokeServiceTokenResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.revoke_service_token(request).await
}
}
use crate::auth::grpc::authorization::AuthorizationApi;
use crate::protos::auth::v1::authorization_service_server::AuthorizationService;
pub struct AuthorizationClient {
api: AuthorizationApi,
}
impl AuthorizationClient {
pub fn new(service: AuthSvc) -> Self {
Self {
api: AuthorizationApi::new(service),
}
}
pub async fn authorize(
&mut self,
mut request: Request<crate::protos::auth::v1::AuthorizeRequest>,
) -> Result<Response<crate::protos::auth::v1::AuthorizeResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.authorize(request).await
}
pub async fn batch_authorize(
&mut self,
mut request: Request<crate::protos::auth::v1::BatchAuthorizeRequest>,
) -> Result<Response<crate::protos::auth::v1::BatchAuthorizeResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.batch_authorize(request).await
}
pub async fn is_platform_admin(
&mut self,
mut request: Request<crate::protos::auth::v1::IsPlatformAdminRequest>,
) -> Result<Response<crate::protos::auth::v1::IsPlatformAdminResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.is_platform_admin(request).await
}
pub async fn get_capabilities(
&mut self,
mut request: Request<crate::protos::auth::v1::GetCapabilitiesRequest>,
) -> Result<Response<crate::protos::auth::v1::GetCapabilitiesResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.get_capabilities(request).await
}
}
use crate::auth::grpc::access_key::AccessKeyApi;
use crate::protos::auth::v1::access_key_service_server::AccessKeyService;
pub struct AccessKeyClient {
api: AccessKeyApi,
}
impl AccessKeyClient {
pub fn new(service: AuthSvc) -> Self {
Self {
api: AccessKeyApi::new(service),
}
}
pub async fn verify_access_key(
&mut self,
mut request: Request<crate::protos::auth::v1::VerifyAccessKeyRequest>,
) -> Result<Response<crate::protos::auth::v1::VerifyAccessKeyResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.verify_access_key(request).await
}
pub async fn create_access_key(
&mut self,
mut request: Request<crate::protos::auth::v1::CreateAccessKeyRequest>,
) -> Result<Response<crate::protos::auth::v1::CreateAccessKeyResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.create_access_key(request).await
}
pub async fn rotate_access_key(
&mut self,
mut request: Request<crate::protos::auth::v1::RotateAccessKeyRequest>,
) -> Result<Response<crate::protos::auth::v1::RotateAccessKeyResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.rotate_access_key(request).await
}
pub async fn list_access_keys(
&mut self,
mut request: Request<crate::protos::auth::v1::ListAccessKeysRequest>,
) -> Result<Response<crate::protos::auth::v1::ListAccessKeysResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.list_access_keys(request).await
}
pub async fn revoke_access_key(
&mut self,
mut request: Request<crate::protos::auth::v1::RevokeAccessKeyRequest>,
) -> Result<Response<crate::protos::auth::v1::RevokeAccessKeyResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.revoke_access_key(request).await
}
}
use crate::auth::grpc::ssh_key::SshKeyApi;
use crate::protos::auth::v1::ssh_key_service_server::SshKeyService;
pub struct SshKeyClient {
api: SshKeyApi,
}
impl SshKeyClient {
pub fn new(service: AuthSvc) -> Self {
Self {
api: SshKeyApi::new(service),
}
}
pub async fn lookup_ssh_key(
&mut self,
mut request: Request<crate::protos::auth::v1::LookupSshKeyRequest>,
) -> Result<Response<crate::protos::auth::v1::LookupSshKeyResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.lookup_ssh_key(request).await
}
pub async fn add_ssh_key(
&mut self,
mut request: Request<crate::protos::auth::v1::AddSshKeyRequest>,
) -> Result<Response<crate::protos::auth::v1::AddSshKeyResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.add_ssh_key(request).await
}
pub async fn list_user_ssh_keys(
&mut self,
mut request: Request<crate::protos::auth::v1::ListUserSshKeysRequest>,
) -> Result<Response<crate::protos::auth::v1::ListUserSshKeysResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.list_user_ssh_keys(request).await
}
pub async fn revoke_ssh_key(
&mut self,
mut request: Request<crate::protos::auth::v1::RevokeSshKeyRequest>,
) -> Result<Response<crate::protos::auth::v1::RevokeSshKeyResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.revoke_ssh_key(request).await
}
}
use crate::auth::grpc::mfa::MfaApi;
use crate::protos::auth::v1::mfa_service_server::MfaService;
pub struct MfaClient {
api: MfaApi,
}
impl MfaClient {
pub fn new(service: AuthSvc) -> Self {
Self {
api: MfaApi::new(service),
}
}
pub async fn get_mfa_status(
&mut self,
mut request: Request<crate::protos::auth::v1::GetMfaStatusRequest>,
) -> Result<Response<crate::protos::auth::v1::GetMfaStatusResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.get_mfa_status(request).await
}
pub async fn verify_totp(
&mut self,
mut request: Request<crate::protos::auth::v1::VerifyTotpRequest>,
) -> Result<Response<crate::protos::auth::v1::VerifyTotpResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.verify_totp(request).await
}
pub async fn redeem_recovery_code(
&mut self,
mut request: Request<crate::protos::auth::v1::RedeemRecoveryCodeRequest>,
) -> Result<Response<crate::protos::auth::v1::RedeemRecoveryCodeResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.redeem_recovery_code(request).await
}
pub async fn configure_totp(
&mut self,
mut request: Request<crate::protos::auth::v1::ConfigureTotpRequest>,
) -> Result<Response<crate::protos::auth::v1::ConfigureTotpResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.configure_totp(request).await
}
pub async fn enable_totp(
&mut self,
mut request: Request<crate::protos::auth::v1::EnableTotpRequest>,
) -> Result<Response<crate::protos::auth::v1::EnableTotpResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.enable_totp(request).await
}
pub async fn disable_totp(
&mut self,
mut request: Request<crate::protos::auth::v1::DisableTotpRequest>,
) -> Result<Response<crate::protos::auth::v1::DisableTotpResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.disable_totp(request).await
}
pub async fn regenerate_recovery_codes(
&mut self,
mut request: Request<crate::protos::auth::v1::RegenerateRecoveryCodesRequest>,
) -> Result<Response<crate::protos::auth::v1::RegenerateRecoveryCodesResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.regenerate_recovery_codes(request).await
}
}
use crate::auth::grpc::agreement::AgreementApi;
use crate::protos::auth::v1::agreement_service_server::AgreementService;
pub struct AgreementClient {
api: AgreementApi,
}
impl AgreementClient {
pub fn new(service: AuthSvc) -> Self {
Self {
api: AgreementApi::new(service),
}
}
pub async fn list_agreements(
&mut self,
mut request: Request<crate::protos::auth::v1::ListAgreementsRequest>,
) -> Result<Response<crate::protos::auth::v1::ListAgreementsResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.list_agreements(request).await
}
pub async fn check_agreements_accepted(
&mut self,
mut request: Request<crate::protos::auth::v1::CheckAgreementsAcceptedRequest>,
) -> Result<Response<crate::protos::auth::v1::CheckAgreementsAcceptedResponse>, Status> {
request.extensions_mut().insert(RequestMeta {
request_id: Uuid::now_v7().to_string(),
caller_service: "kenapi".to_owned(),
});
self.api.check_agreements_accepted(request).await
}
}