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