1use crate::Lb;
2use crate::io::network::ApiError;
3use crate::model::account::Username;
4use crate::model::api::*;
5use crate::model::errors::{LbErrKind, LbResult, core_err_unexpected};
6use uuid::Uuid;
7
8impl Lb {
9 #[instrument(level = "debug", skip(self), err(Debug))]
10 pub async fn disappear_account(&self, username: &str) -> LbResult<()> {
11 let account = self.get_account()?;
12
13 self.client
14 .request(account, AdminDisappearAccountRequest { username: username.to_string() })
15 .await
16 .map_err(|err| {
17 match err {
18 ApiError::Endpoint(AdminDisappearAccountError::UserNotFound) => {
19 LbErrKind::UsernameNotFound
20 }
21 ApiError::Endpoint(AdminDisappearAccountError::NotPermissioned) => {
22 LbErrKind::InsufficientPermission
23 }
24 ApiError::SendFailed(_) => LbErrKind::ServerUnreachable,
25 ApiError::ClientUpdateRequired => LbErrKind::ClientUpdateRequired,
26 _ => core_err_unexpected(err),
27 }
28 .into()
29 })
30 }
31
32 #[instrument(level = "debug", skip(self), err(Debug))]
33 pub async fn disappear_file(&self, id: Uuid) -> LbResult<()> {
34 let account = self.get_account()?;
35 self.client
36 .request(account, AdminDisappearFileRequest { id })
37 .await
38 .map_err(|err| {
39 match err {
40 ApiError::Endpoint(AdminDisappearFileError::FileNonexistent) => {
41 LbErrKind::FileNonexistent
42 }
43 ApiError::Endpoint(AdminDisappearFileError::NotPermissioned) => {
44 LbErrKind::InsufficientPermission
45 }
46 ApiError::SendFailed(_) => LbErrKind::ServerUnreachable,
47 ApiError::ClientUpdateRequired => LbErrKind::ClientUpdateRequired,
48 _ => core_err_unexpected(err),
49 }
50 .into()
51 })
52 }
53
54 #[instrument(level = "debug", skip(self), err(Debug))]
55 pub async fn list_users(&self, filter: Option<AccountFilter>) -> LbResult<Vec<Username>> {
56 let account = self.get_account()?;
57
58 Ok(self
59 .client
60 .request(account, AdminListUsersRequest { filter })
61 .await
62 .map_err(|err| match err {
63 ApiError::Endpoint(AdminListUsersError::NotPermissioned) => {
64 LbErrKind::InsufficientPermission
65 }
66 ApiError::SendFailed(_) => LbErrKind::ServerUnreachable,
67 ApiError::ClientUpdateRequired => LbErrKind::ClientUpdateRequired,
68 _ => core_err_unexpected(err),
69 })?
70 .users)
71 }
72
73 #[instrument(level = "debug", skip(self), err(Debug))]
74 pub async fn get_account_info(&self, identifier: AccountIdentifier) -> LbResult<AccountInfo> {
75 let account = self.get_account()?;
76
77 Ok(self
78 .client
79 .request(account, AdminGetAccountInfoRequest { identifier })
80 .await
81 .map_err(|err| match err {
82 ApiError::Endpoint(AdminGetAccountInfoError::NotPermissioned) => {
83 LbErrKind::InsufficientPermission
84 }
85 ApiError::Endpoint(AdminGetAccountInfoError::UserNotFound) => {
86 LbErrKind::UsernameNotFound
87 }
88 ApiError::SendFailed(_) => LbErrKind::ServerUnreachable,
89 ApiError::ClientUpdateRequired => LbErrKind::ClientUpdateRequired,
90 _ => core_err_unexpected(err),
91 })?
92 .account)
93 }
94
95 #[instrument(level = "debug", skip(self), err(Debug))]
96 pub async fn validate_account(&self, username: &str) -> LbResult<AdminValidateAccount> {
97 let account = self.get_account()?;
98 self.client
99 .request(account, AdminValidateAccountRequest { username: username.to_string() })
100 .await
101 .map_err(|err| {
102 match err {
103 ApiError::Endpoint(AdminValidateAccountError::NotPermissioned) => {
104 LbErrKind::InsufficientPermission
105 }
106 ApiError::Endpoint(AdminValidateAccountError::UserNotFound) => {
107 LbErrKind::UsernameNotFound
108 }
109 ApiError::SendFailed(_) => LbErrKind::ServerUnreachable,
110 ApiError::ClientUpdateRequired => LbErrKind::ClientUpdateRequired,
111 _ => core_err_unexpected(err),
112 }
113 .into()
114 })
115 }
116
117 #[instrument(level = "debug", skip(self), err(Debug))]
118 pub async fn validate_server(&self) -> LbResult<AdminValidateServer> {
119 let account = self.get_account()?;
120 self.client
121 .request(account, AdminValidateServerRequest {})
122 .await
123 .map_err(|err| {
124 match err {
125 ApiError::Endpoint(AdminValidateServerError::NotPermissioned) => {
126 LbErrKind::InsufficientPermission
127 }
128 ApiError::SendFailed(_) => LbErrKind::ServerUnreachable,
129 ApiError::ClientUpdateRequired => LbErrKind::ClientUpdateRequired,
130 _ => core_err_unexpected(err),
131 }
132 .into()
133 })
134 }
135
136 #[instrument(level = "debug", skip(self), err(Debug))]
137 pub async fn file_info(&self, id: Uuid) -> LbResult<AdminFileInfoResponse> {
138 let account = self.get_account()?;
139 self.client
140 .request(account, AdminFileInfoRequest { id })
141 .await
142 .map_err(|err| {
143 match err {
144 ApiError::Endpoint(AdminFileInfoError::FileNonexistent) => {
145 LbErrKind::FileNonexistent
146 }
147 ApiError::Endpoint(AdminFileInfoError::NotPermissioned) => {
148 LbErrKind::InsufficientPermission
149 }
150 ApiError::SendFailed(_) => LbErrKind::ServerUnreachable,
151 ApiError::ClientUpdateRequired => LbErrKind::ClientUpdateRequired,
152 _ => core_err_unexpected(err),
153 }
154 .into()
155 })
156 }
157
158 #[instrument(level = "debug", skip(self), err(Debug))]
159 pub async fn rebuild_index(&self, index: ServerIndex) -> LbResult<()> {
160 let account = self.get_account()?;
161 self.client
162 .request(account, AdminRebuildIndexRequest { index })
163 .await
164 .map_err(|err| {
165 match err {
166 ApiError::Endpoint(AdminRebuildIndexError::NotPermissioned) => {
167 LbErrKind::InsufficientPermission
168 }
169 ApiError::SendFailed(_) => LbErrKind::ServerUnreachable,
170 ApiError::ClientUpdateRequired => LbErrKind::ClientUpdateRequired,
171 _ => core_err_unexpected(err),
172 }
173 .into()
174 })
175 }
176
177 #[instrument(level = "debug", skip(self), err(Debug))]
178 pub async fn set_user_tier(&self, username: &str, info: AdminSetUserTierInfo) -> LbResult<()> {
179 let account = self.get_account()?;
180 self.client
181 .request(account, AdminSetUserTierRequest { username: username.to_string(), info })
182 .await
183 .map_err(|err| match err {
184 ApiError::Endpoint(AdminSetUserTierError::NotPermissioned) => {
185 LbErrKind::InsufficientPermission
186 }
187 ApiError::Endpoint(AdminSetUserTierError::UserNotFound) => {
188 LbErrKind::UsernameNotFound
189 }
190 ApiError::Endpoint(AdminSetUserTierError::ExistingRequestPending) => {
191 LbErrKind::ExistingRequestPending
192 }
193 ApiError::SendFailed(_) => LbErrKind::ServerUnreachable,
194 ApiError::ClientUpdateRequired => LbErrKind::ClientUpdateRequired,
195 _ => core_err_unexpected(err),
196 })?;
197
198 Ok(())
199 }
200}