mattermost_client/openapi/apis/
status_api.rs1use reqwest;
12
13use super::{configuration, Error};
14use super::ResponseContent;
15
16#[derive(Clone, Debug, Default)]
18pub struct GetUserStatusParams {
19 pub user_id: String,
21}
22
23#[derive(Clone, Debug, Default)]
25pub struct GetUsersStatusesByIdsParams {
26 pub request_body: Vec<String>,
28}
29
30#[derive(Clone, Debug, Default)]
32pub struct PostUserRecentCustomStatusDeleteParams {
33 pub user_id: String,
35 pub remove_recent_custom_status_request: crate::openapi::models::RemoveRecentCustomStatusRequest,
37}
38
39#[derive(Clone, Debug, Default)]
41pub struct RemoveRecentCustomStatusParams {
42 pub user_id: String,
44 pub remove_recent_custom_status_request: crate::openapi::models::RemoveRecentCustomStatusRequest,
46}
47
48#[derive(Clone, Debug, Default)]
50pub struct UnsetUserCustomStatusParams {
51 pub user_id: String,
53}
54
55#[derive(Clone, Debug, Default)]
57pub struct UpdateUserCustomStatusParams {
58 pub user_id: String,
60 pub update_user_custom_status_request: crate::openapi::models::UpdateUserCustomStatusRequest,
62}
63
64#[derive(Clone, Debug, Default)]
66pub struct UpdateUserStatusParams {
67 pub user_id: String,
69 pub update_user_status_request: crate::openapi::models::UpdateUserStatusRequest,
71}
72
73#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
75#[serde(untagged)]
76pub enum GetUserStatusError {
77 Status400(crate::openapi::models::AppError),
78 Status401(crate::openapi::models::AppError),
79 UnknownValue(serde_json::Value),
80}
81
82#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
84#[serde(untagged)]
85pub enum GetUsersStatusesByIdsError {
86 Status400(crate::openapi::models::AppError),
87 Status401(crate::openapi::models::AppError),
88 UnknownValue(serde_json::Value),
89}
90
91#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
93#[serde(untagged)]
94pub enum PostUserRecentCustomStatusDeleteError {
95 Status400(crate::openapi::models::AppError),
96 Status401(crate::openapi::models::AppError),
97 UnknownValue(serde_json::Value),
98}
99
100#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
102#[serde(untagged)]
103pub enum RemoveRecentCustomStatusError {
104 Status400(crate::openapi::models::AppError),
105 Status401(crate::openapi::models::AppError),
106 UnknownValue(serde_json::Value),
107}
108
109#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
111#[serde(untagged)]
112pub enum UnsetUserCustomStatusError {
113 Status400(crate::openapi::models::AppError),
114 Status401(crate::openapi::models::AppError),
115 UnknownValue(serde_json::Value),
116}
117
118#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
120#[serde(untagged)]
121pub enum UpdateUserCustomStatusError {
122 Status400(crate::openapi::models::AppError),
123 Status401(crate::openapi::models::AppError),
124 UnknownValue(serde_json::Value),
125}
126
127#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
129#[serde(untagged)]
130pub enum UpdateUserStatusError {
131 Status400(crate::openapi::models::AppError),
132 Status401(crate::openapi::models::AppError),
133 UnknownValue(serde_json::Value),
134}
135
136pub async fn get_user_status(
138 configuration: &configuration::Configuration,
139 params: GetUserStatusParams,
140) -> Result<crate::openapi::models::Status, Error<GetUserStatusError>> {
141 let local_var_configuration = configuration;
142
143 let user_id = params.user_id;
145
146 let local_var_client = &local_var_configuration.client;
147
148 let local_var_uri_str = format!(
149 "{}/api/v4/users/{user_id}/status",
150 local_var_configuration.base_path,
151 user_id = super::urlencode(user_id)
152 );
153 let mut local_var_req_builder =
154 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
155
156 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
157 local_var_req_builder =
158 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
159 }
160 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
161 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
162 };
163
164 let local_var_req = local_var_req_builder.build()?;
165 let local_var_resp = local_var_client.execute(local_var_req).await?;
166
167 let local_var_status = local_var_resp.status();
168 let local_var_content = local_var_resp.text().await?;
169
170 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
171 serde_json::from_str(&local_var_content).map_err(Error::from)
172 } else {
173 let local_var_entity: Option<GetUserStatusError> =
174 serde_json::from_str(&local_var_content).ok();
175 let local_var_error = ResponseContent {
176 status: local_var_status,
177 content: local_var_content,
178 entity: local_var_entity,
179 };
180 Err(Error::ResponseError(local_var_error))
181 }
182}
183
184pub async fn get_users_statuses_by_ids(
186 configuration: &configuration::Configuration,
187 params: GetUsersStatusesByIdsParams,
188) -> Result<Vec<crate::openapi::models::Status>, Error<GetUsersStatusesByIdsError>> {
189 let local_var_configuration = configuration;
190
191 let request_body = params.request_body;
193
194 let local_var_client = &local_var_configuration.client;
195
196 let local_var_uri_str = format!(
197 "{}/api/v4/users/status/ids",
198 local_var_configuration.base_path
199 );
200 let mut local_var_req_builder =
201 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
202
203 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
204 local_var_req_builder =
205 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
206 }
207 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
208 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
209 };
210 local_var_req_builder = local_var_req_builder.json(&request_body);
211
212 let local_var_req = local_var_req_builder.build()?;
213 let local_var_resp = local_var_client.execute(local_var_req).await?;
214
215 let local_var_status = local_var_resp.status();
216 let local_var_content = local_var_resp.text().await?;
217
218 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
219 serde_json::from_str(&local_var_content).map_err(Error::from)
220 } else {
221 let local_var_entity: Option<GetUsersStatusesByIdsError> =
222 serde_json::from_str(&local_var_content).ok();
223 let local_var_error = ResponseContent {
224 status: local_var_status,
225 content: local_var_content,
226 entity: local_var_entity,
227 };
228 Err(Error::ResponseError(local_var_error))
229 }
230}
231
232pub async fn post_user_recent_custom_status_delete(
234 configuration: &configuration::Configuration,
235 params: PostUserRecentCustomStatusDeleteParams,
236) -> Result<(), Error<PostUserRecentCustomStatusDeleteError>> {
237 let local_var_configuration = configuration;
238
239 let user_id = params.user_id;
241 let remove_recent_custom_status_request = params.remove_recent_custom_status_request;
242
243 let local_var_client = &local_var_configuration.client;
244
245 let local_var_uri_str = format!(
246 "{}/api/v4/users/{user_id}/status/custom/recent/delete",
247 local_var_configuration.base_path,
248 user_id = super::urlencode(user_id)
249 );
250 let mut local_var_req_builder =
251 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
252
253 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
254 local_var_req_builder =
255 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
256 }
257 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
258 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
259 };
260 local_var_req_builder = local_var_req_builder.json(&remove_recent_custom_status_request);
261
262 let local_var_req = local_var_req_builder.build()?;
263 let local_var_resp = local_var_client.execute(local_var_req).await?;
264
265 let local_var_status = local_var_resp.status();
266 let local_var_content = local_var_resp.text().await?;
267
268 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
269 Ok(())
270 } else {
271 let local_var_entity: Option<PostUserRecentCustomStatusDeleteError> =
272 serde_json::from_str(&local_var_content).ok();
273 let local_var_error = ResponseContent {
274 status: local_var_status,
275 content: local_var_content,
276 entity: local_var_entity,
277 };
278 Err(Error::ResponseError(local_var_error))
279 }
280}
281
282pub async fn remove_recent_custom_status(
284 configuration: &configuration::Configuration,
285 params: RemoveRecentCustomStatusParams,
286) -> Result<(), Error<RemoveRecentCustomStatusError>> {
287 let local_var_configuration = configuration;
288
289 let user_id = params.user_id;
291 let remove_recent_custom_status_request = params.remove_recent_custom_status_request;
292
293 let local_var_client = &local_var_configuration.client;
294
295 let local_var_uri_str = format!(
296 "{}/api/v4/users/{user_id}/status/custom/recent",
297 local_var_configuration.base_path,
298 user_id = super::urlencode(user_id)
299 );
300 let mut local_var_req_builder =
301 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
302
303 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
304 local_var_req_builder =
305 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
306 }
307 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
308 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
309 };
310 local_var_req_builder = local_var_req_builder.json(&remove_recent_custom_status_request);
311
312 let local_var_req = local_var_req_builder.build()?;
313 let local_var_resp = local_var_client.execute(local_var_req).await?;
314
315 let local_var_status = local_var_resp.status();
316 let local_var_content = local_var_resp.text().await?;
317
318 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
319 Ok(())
320 } else {
321 let local_var_entity: Option<RemoveRecentCustomStatusError> =
322 serde_json::from_str(&local_var_content).ok();
323 let local_var_error = ResponseContent {
324 status: local_var_status,
325 content: local_var_content,
326 entity: local_var_entity,
327 };
328 Err(Error::ResponseError(local_var_error))
329 }
330}
331
332pub async fn unset_user_custom_status(
334 configuration: &configuration::Configuration,
335 params: UnsetUserCustomStatusParams,
336) -> Result<(), Error<UnsetUserCustomStatusError>> {
337 let local_var_configuration = configuration;
338
339 let user_id = params.user_id;
341
342 let local_var_client = &local_var_configuration.client;
343
344 let local_var_uri_str = format!(
345 "{}/api/v4/users/{user_id}/status/custom",
346 local_var_configuration.base_path,
347 user_id = super::urlencode(user_id)
348 );
349 let mut local_var_req_builder =
350 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
351
352 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
353 local_var_req_builder =
354 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
355 }
356 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
357 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
358 };
359
360 let local_var_req = local_var_req_builder.build()?;
361 let local_var_resp = local_var_client.execute(local_var_req).await?;
362
363 let local_var_status = local_var_resp.status();
364 let local_var_content = local_var_resp.text().await?;
365
366 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
367 Ok(())
368 } else {
369 let local_var_entity: Option<UnsetUserCustomStatusError> =
370 serde_json::from_str(&local_var_content).ok();
371 let local_var_error = ResponseContent {
372 status: local_var_status,
373 content: local_var_content,
374 entity: local_var_entity,
375 };
376 Err(Error::ResponseError(local_var_error))
377 }
378}
379
380pub async fn update_user_custom_status(
382 configuration: &configuration::Configuration,
383 params: UpdateUserCustomStatusParams,
384) -> Result<(), Error<UpdateUserCustomStatusError>> {
385 let local_var_configuration = configuration;
386
387 let user_id = params.user_id;
389 let update_user_custom_status_request = params.update_user_custom_status_request;
390
391 let local_var_client = &local_var_configuration.client;
392
393 let local_var_uri_str = format!(
394 "{}/api/v4/users/{user_id}/status/custom",
395 local_var_configuration.base_path,
396 user_id = super::urlencode(user_id)
397 );
398 let mut local_var_req_builder =
399 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
400
401 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
402 local_var_req_builder =
403 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
404 }
405 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
406 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
407 };
408 local_var_req_builder = local_var_req_builder.json(&update_user_custom_status_request);
409
410 let local_var_req = local_var_req_builder.build()?;
411 let local_var_resp = local_var_client.execute(local_var_req).await?;
412
413 let local_var_status = local_var_resp.status();
414 let local_var_content = local_var_resp.text().await?;
415
416 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
417 Ok(())
418 } else {
419 let local_var_entity: Option<UpdateUserCustomStatusError> =
420 serde_json::from_str(&local_var_content).ok();
421 let local_var_error = ResponseContent {
422 status: local_var_status,
423 content: local_var_content,
424 entity: local_var_entity,
425 };
426 Err(Error::ResponseError(local_var_error))
427 }
428}
429
430pub async fn update_user_status(
432 configuration: &configuration::Configuration,
433 params: UpdateUserStatusParams,
434) -> Result<crate::openapi::models::Status, Error<UpdateUserStatusError>> {
435 let local_var_configuration = configuration;
436
437 let user_id = params.user_id;
439 let update_user_status_request = params.update_user_status_request;
440
441 let local_var_client = &local_var_configuration.client;
442
443 let local_var_uri_str = format!(
444 "{}/api/v4/users/{user_id}/status",
445 local_var_configuration.base_path,
446 user_id = super::urlencode(user_id)
447 );
448 let mut local_var_req_builder =
449 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
450
451 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
452 local_var_req_builder =
453 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
454 }
455 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
456 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
457 };
458 local_var_req_builder = local_var_req_builder.json(&update_user_status_request);
459
460 let local_var_req = local_var_req_builder.build()?;
461 let local_var_resp = local_var_client.execute(local_var_req).await?;
462
463 let local_var_status = local_var_resp.status();
464 let local_var_content = local_var_resp.text().await?;
465
466 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
467 serde_json::from_str(&local_var_content).map_err(Error::from)
468 } else {
469 let local_var_entity: Option<UpdateUserStatusError> =
470 serde_json::from_str(&local_var_content).ok();
471 let local_var_error = ResponseContent {
472 status: local_var_status,
473 content: local_var_content,
474 entity: local_var_entity,
475 };
476 Err(Error::ResponseError(local_var_error))
477 }
478}