1use crate::Client;
2use anyhow::Result;
3#[derive(Clone, Debug)]
4pub struct Users {
5 pub client: Client,
6}
7
8impl Users {
9 #[doc(hidden)]
10 pub fn new(client: Client) -> Self {
11 Self { client }
12 }
13
14 #[doc = "Perform a `GET` request to `/api/users/`.\n\n**Parameters:**\n\n- `ordering: Option<String>`: Which field to use when ordering the results.\n- `page: Option<i64>`: A page number within the paginated result set.\n- `page_size: Option<i64>`: Number of results to return per page.\n- `username_icontains: Option<String>`\n- `username_iendswith: Option<String>`\n- `username_iexact: Option<String>`\n- `username_istartswith: Option<String>`\n\n```rust,no_run\nuse futures_util::TryStreamExt;\nasync fn example_users_list_stream() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let mut users = client.users();\n let mut stream = users.list_stream(\n Some(\"some-string\".to_string()),\n Some(4 as i64),\n Some(\"some-string\".to_string()),\n Some(\"some-string\".to_string()),\n Some(\"some-string\".to_string()),\n Some(\"some-string\".to_string()),\n );\n loop {\n match stream.try_next().await {\n Ok(Some(item)) => {\n println!(\"{:?}\", item);\n }\n Ok(None) => {\n break;\n }\n Err(err) => {\n return Err(err.into());\n }\n }\n }\n\n Ok(())\n}\n```"]
15 #[tracing::instrument]
16 #[allow(non_snake_case)]
17 pub async fn list<'a>(
18 &'a self,
19 ordering: Option<String>,
20 page: Option<i64>,
21 page_size: Option<i64>,
22 username_icontains: Option<String>,
23 username_iendswith: Option<String>,
24 username_iexact: Option<String>,
25 username_istartswith: Option<String>,
26 ) -> Result<crate::types::PaginatedUserList, crate::types::error::Error> {
27 let mut req = self.client.client.request(
28 http::Method::GET,
29 format!("{}/{}", self.client.base_url, "api/users/"),
30 );
31 req = req.header("Authorization", format!("Token {}", &self.client.token));
32 let mut query_params = vec![];
33 if let Some(p) = ordering {
34 query_params.push(("ordering", p));
35 }
36
37 if let Some(p) = page {
38 query_params.push(("page", format!("{p}")));
39 }
40
41 if let Some(p) = page_size {
42 query_params.push(("page_size", format!("{p}")));
43 }
44
45 if let Some(p) = username_icontains {
46 query_params.push(("username__icontains", p));
47 }
48
49 if let Some(p) = username_iendswith {
50 query_params.push(("username__iendswith", p));
51 }
52
53 if let Some(p) = username_iexact {
54 query_params.push(("username__iexact", p));
55 }
56
57 if let Some(p) = username_istartswith {
58 query_params.push(("username__istartswith", p));
59 }
60
61 req = req.query(&query_params);
62 let resp = req.send().await?;
63 let status = resp.status();
64 if status.is_success() {
65 let text = resp.text().await.unwrap_or_default();
66 serde_json::from_str(&text).map_err(|err| {
67 crate::types::error::Error::from_serde_error(
68 format_serde_error::SerdeError::new(text.to_string(), err),
69 status,
70 )
71 })
72 } else {
73 let text = resp.text().await.unwrap_or_default();
74 Err(crate::types::error::Error::Server {
75 body: text.to_string(),
76 status,
77 })
78 }
79 }
80
81 #[doc = "Perform a `GET` request to `/api/users/`.\n\n**Parameters:**\n\n- `ordering: Option<String>`: Which field to use when ordering the results.\n- `page: Option<i64>`: A page number within the paginated result set.\n- `page_size: Option<i64>`: Number of results to return per page.\n- `username_icontains: Option<String>`\n- `username_iendswith: Option<String>`\n- `username_iexact: Option<String>`\n- `username_istartswith: Option<String>`\n\n```rust,no_run\nuse futures_util::TryStreamExt;\nasync fn example_users_list_stream() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let mut users = client.users();\n let mut stream = users.list_stream(\n Some(\"some-string\".to_string()),\n Some(4 as i64),\n Some(\"some-string\".to_string()),\n Some(\"some-string\".to_string()),\n Some(\"some-string\".to_string()),\n Some(\"some-string\".to_string()),\n );\n loop {\n match stream.try_next().await {\n Ok(Some(item)) => {\n println!(\"{:?}\", item);\n }\n Ok(None) => {\n break;\n }\n Err(err) => {\n return Err(err.into());\n }\n }\n }\n\n Ok(())\n}\n```"]
82 #[tracing::instrument]
83 #[cfg(not(feature = "js"))]
84 #[allow(non_snake_case)]
85 pub fn list_stream<'a>(
86 &'a self,
87 ordering: Option<String>,
88 page_size: Option<i64>,
89 username__icontains: Option<String>,
90 username__iendswith: Option<String>,
91 username__iexact: Option<String>,
92 username__istartswith: Option<String>,
93 ) -> impl futures::Stream<Item = Result<crate::types::User, crate::types::error::Error>> + Unpin + '_
94 {
95 use crate::types::paginate::Pagination;
96 use futures::{StreamExt, TryFutureExt, TryStreamExt};
97 self.list(
98 ordering,
99 None,
100 page_size,
101 username__icontains,
102 username__iendswith,
103 username__iexact,
104 username__istartswith,
105 )
106 .map_ok(move |result| {
107 let items = futures::stream::iter(result.items().into_iter().map(Ok));
108 let next_pages = futures::stream::try_unfold(
109 (None, result),
110 move |(prev_page_token, new_result)| async move {
111 if new_result.has_more_pages()
112 && !new_result.items().is_empty()
113 && prev_page_token != new_result.next_page_token()
114 {
115 async {
116 let mut req = self.client.client.request(
117 http::Method::GET,
118 format!("{}/{}", self.client.base_url, "api/users/"),
119 );
120 req = req
121 .header("Authorization", format!("Token {}", &self.client.token));
122 let mut request = req.build()?;
123 request = new_result.next_page(request)?;
124 let resp = self.client.client.execute(request).await?;
125 let status = resp.status();
126 if status.is_success() {
127 let text = resp.text().await.unwrap_or_default();
128 serde_json::from_str(&text).map_err(|err| {
129 crate::types::error::Error::from_serde_error(
130 format_serde_error::SerdeError::new(text.to_string(), err),
131 status,
132 )
133 })
134 } else {
135 let text = resp.text().await.unwrap_or_default();
136 Err(crate::types::error::Error::Server {
137 body: text.to_string(),
138 status,
139 })
140 }
141 }
142 .map_ok(|result: crate::types::PaginatedUserList| {
143 Some((
144 futures::stream::iter(result.items().into_iter().map(Ok)),
145 (new_result.next_page_token(), result),
146 ))
147 })
148 .await
149 } else {
150 Ok(None)
151 }
152 },
153 )
154 .try_flatten();
155 items.chain(next_pages)
156 })
157 .try_flatten_stream()
158 .boxed()
159 }
160
161 #[doc = "Perform a `POST` request to `/api/users/`.\n\n```rust,no_run\nasync fn example_users_create() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let result: paperless_api_client::types::User = client\n .users()\n .create(&paperless_api_client::types::UserRequest {\n username: \"some-string\".to_string(),\n email: Some(\"email@example.com\".to_string()),\n password: Some(\"some-string\".to_string()),\n first_name: Some(\"some-string\".to_string()),\n last_name: Some(\"some-string\".to_string()),\n date_joined: Some(chrono::Utc::now()),\n is_staff: Some(true),\n is_active: Some(true),\n is_superuser: Some(true),\n groups: Some(vec![4 as i64]),\n user_permissions: Some(vec![\"some-string\".to_string()]),\n })\n .await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
162 #[tracing::instrument]
163 #[allow(non_snake_case)]
164 pub async fn create<'a>(
165 &'a self,
166 body: &crate::types::UserRequest,
167 ) -> Result<crate::types::User, crate::types::error::Error> {
168 let mut req = self.client.client.request(
169 http::Method::POST,
170 format!("{}/{}", self.client.base_url, "api/users/"),
171 );
172 req = req.header("Authorization", format!("Token {}", &self.client.token));
173 req = req.json(body);
174 let resp = req.send().await?;
175 let status = resp.status();
176 if status.is_success() {
177 let text = resp.text().await.unwrap_or_default();
178 serde_json::from_str(&text).map_err(|err| {
179 crate::types::error::Error::from_serde_error(
180 format_serde_error::SerdeError::new(text.to_string(), err),
181 status,
182 )
183 })
184 } else {
185 let text = resp.text().await.unwrap_or_default();
186 Err(crate::types::error::Error::Server {
187 body: text.to_string(),
188 status,
189 })
190 }
191 }
192
193 #[doc = "Perform a `GET` request to `/api/users/{id}/`.\n\n**Parameters:**\n\n- `id: i64`: A unique integer value identifying this user. (required)\n\n```rust,no_run\nasync fn example_users_retrieve() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let result: paperless_api_client::types::User = client.users().retrieve(4 as i64).await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
194 #[tracing::instrument]
195 #[allow(non_snake_case)]
196 pub async fn retrieve<'a>(
197 &'a self,
198 id: i64,
199 ) -> Result<crate::types::User, crate::types::error::Error> {
200 let mut req = self.client.client.request(
201 http::Method::GET,
202 format!(
203 "{}/{}",
204 self.client.base_url,
205 "api/users/{id}/".replace("{id}", &format!("{id}"))
206 ),
207 );
208 req = req.header("Authorization", format!("Token {}", &self.client.token));
209 let resp = req.send().await?;
210 let status = resp.status();
211 if status.is_success() {
212 let text = resp.text().await.unwrap_or_default();
213 serde_json::from_str(&text).map_err(|err| {
214 crate::types::error::Error::from_serde_error(
215 format_serde_error::SerdeError::new(text.to_string(), err),
216 status,
217 )
218 })
219 } else {
220 let text = resp.text().await.unwrap_or_default();
221 Err(crate::types::error::Error::Server {
222 body: text.to_string(),
223 status,
224 })
225 }
226 }
227
228 #[doc = "Perform a `PUT` request to `/api/users/{id}/`.\n\n**Parameters:**\n\n- `id: i64`: A unique integer value identifying this user. (required)\n\n```rust,no_run\nasync fn example_users_update() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let result: paperless_api_client::types::User = client\n .users()\n .update(\n 4 as i64,\n &paperless_api_client::types::UserRequest {\n username: \"some-string\".to_string(),\n email: Some(\"email@example.com\".to_string()),\n password: Some(\"some-string\".to_string()),\n first_name: Some(\"some-string\".to_string()),\n last_name: Some(\"some-string\".to_string()),\n date_joined: Some(chrono::Utc::now()),\n is_staff: Some(true),\n is_active: Some(true),\n is_superuser: Some(true),\n groups: Some(vec![4 as i64]),\n user_permissions: Some(vec![\"some-string\".to_string()]),\n },\n )\n .await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
229 #[tracing::instrument]
230 #[allow(non_snake_case)]
231 pub async fn update<'a>(
232 &'a self,
233 id: i64,
234 body: &crate::types::UserRequest,
235 ) -> Result<crate::types::User, crate::types::error::Error> {
236 let mut req = self.client.client.request(
237 http::Method::PUT,
238 format!(
239 "{}/{}",
240 self.client.base_url,
241 "api/users/{id}/".replace("{id}", &format!("{id}"))
242 ),
243 );
244 req = req.header("Authorization", format!("Token {}", &self.client.token));
245 req = req.json(body);
246 let resp = req.send().await?;
247 let status = resp.status();
248 if status.is_success() {
249 let text = resp.text().await.unwrap_or_default();
250 serde_json::from_str(&text).map_err(|err| {
251 crate::types::error::Error::from_serde_error(
252 format_serde_error::SerdeError::new(text.to_string(), err),
253 status,
254 )
255 })
256 } else {
257 let text = resp.text().await.unwrap_or_default();
258 Err(crate::types::error::Error::Server {
259 body: text.to_string(),
260 status,
261 })
262 }
263 }
264
265 #[doc = "Perform a `DELETE` request to `/api/users/{id}/`.\n\n**Parameters:**\n\n- `id: i64`: A unique integer value identifying this user. (required)\n\n```rust,no_run\nasync fn example_users_destroy() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n client.users().destroy(4 as i64).await?;\n Ok(())\n}\n```"]
266 #[tracing::instrument]
267 #[allow(non_snake_case)]
268 pub async fn destroy<'a>(&'a self, id: i64) -> Result<(), crate::types::error::Error> {
269 let mut req = self.client.client.request(
270 http::Method::DELETE,
271 format!(
272 "{}/{}",
273 self.client.base_url,
274 "api/users/{id}/".replace("{id}", &format!("{id}"))
275 ),
276 );
277 req = req.header("Authorization", format!("Token {}", &self.client.token));
278 let resp = req.send().await?;
279 let status = resp.status();
280 if status.is_success() {
281 Ok(())
282 } else {
283 let text = resp.text().await.unwrap_or_default();
284 Err(crate::types::error::Error::Server {
285 body: text.to_string(),
286 status,
287 })
288 }
289 }
290
291 #[doc = "Perform a `PATCH` request to `/api/users/{id}/`.\n\n**Parameters:**\n\n- `id: i64`: A unique integer value identifying this user. (required)\n\n```rust,no_run\nasync fn example_users_partial_update() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let result: paperless_api_client::types::User = client\n .users()\n .partial_update(\n 4 as i64,\n &paperless_api_client::types::PatchedUserRequest {\n username: Some(\"some-string\".to_string()),\n email: Some(\"email@example.com\".to_string()),\n password: Some(\"some-string\".to_string()),\n first_name: Some(\"some-string\".to_string()),\n last_name: Some(\"some-string\".to_string()),\n date_joined: Some(chrono::Utc::now()),\n is_staff: Some(true),\n is_active: Some(true),\n is_superuser: Some(true),\n groups: Some(vec![4 as i64]),\n user_permissions: Some(vec![\"some-string\".to_string()]),\n },\n )\n .await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
292 #[tracing::instrument]
293 #[allow(non_snake_case)]
294 pub async fn partial_update<'a>(
295 &'a self,
296 id: i64,
297 body: &crate::types::PatchedUserRequest,
298 ) -> Result<crate::types::User, crate::types::error::Error> {
299 let mut req = self.client.client.request(
300 http::Method::PATCH,
301 format!(
302 "{}/{}",
303 self.client.base_url,
304 "api/users/{id}/".replace("{id}", &format!("{id}"))
305 ),
306 );
307 req = req.header("Authorization", format!("Token {}", &self.client.token));
308 req = req.json(body);
309 let resp = req.send().await?;
310 let status = resp.status();
311 if status.is_success() {
312 let text = resp.text().await.unwrap_or_default();
313 serde_json::from_str(&text).map_err(|err| {
314 crate::types::error::Error::from_serde_error(
315 format_serde_error::SerdeError::new(text.to_string(), err),
316 status,
317 )
318 })
319 } else {
320 let text = resp.text().await.unwrap_or_default();
321 Err(crate::types::error::Error::Server {
322 body: text.to_string(),
323 status,
324 })
325 }
326 }
327
328 #[doc = "Perform a `POST` request to `/api/users/{id}/deactivate_totp/`.\n\n**Parameters:**\n\n- `id: i64`: A unique integer value identifying this user. (required)\n\n```rust,no_run\nasync fn example_users_deactivate_totp_create() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let result: bool = client.users().deactivate_totp_create(4 as i64).await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
329 #[tracing::instrument]
330 #[allow(non_snake_case)]
331 pub async fn deactivate_totp_create<'a>(
332 &'a self,
333 id: i64,
334 ) -> Result<bool, crate::types::error::Error> {
335 let mut req = self.client.client.request(
336 http::Method::POST,
337 format!(
338 "{}/{}",
339 self.client.base_url,
340 "api/users/{id}/deactivate_totp/".replace("{id}", &format!("{id}"))
341 ),
342 );
343 req = req.header("Authorization", format!("Token {}", &self.client.token));
344 let resp = req.send().await?;
345 let status = resp.status();
346 if status.is_success() {
347 let text = resp.text().await.unwrap_or_default();
348 serde_json::from_str(&text).map_err(|err| {
349 crate::types::error::Error::from_serde_error(
350 format_serde_error::SerdeError::new(text.to_string(), err),
351 status,
352 )
353 })
354 } else {
355 let text = resp.text().await.unwrap_or_default();
356 Err(crate::types::error::Error::Server {
357 body: text.to_string(),
358 status,
359 })
360 }
361 }
362}