1use crate::Client;
2use anyhow::Result;
3#[derive(Clone, Debug)]
4pub struct StoragePaths {
5 pub client: Client,
6}
7
8impl StoragePaths {
9 #[doc(hidden)]
10 pub fn new(client: Client) -> Self {
11 Self { client }
12 }
13
14 #[doc = "Perform a `GET` request to `/api/storage_paths/`.\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- `path_icontains: Option<String>`\n- `path_iendswith: Option<String>`\n- `path_iexact: Option<String>`\n- `path_istartswith: Option<String>`\n\n```rust,no_run\nuse futures_util::TryStreamExt;\nasync fn example_storage_paths_list_stream() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let mut storage_paths = client.storage_paths();\n let mut stream = storage_paths.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 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 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 path_icontains: Option<String>,
30 path_iendswith: Option<String>,
31 path_iexact: Option<String>,
32 path_istartswith: Option<String>,
33 ) -> Result<crate::types::PaginatedStoragePathList, crate::types::error::Error> {
34 let mut req = self.client.client.request(
35 http::Method::GET,
36 format!("{}/{}", self.client.base_url, "api/storage_paths/"),
37 );
38 req = req.header("Authorization", format!("Token {}", &self.client.token));
39 let mut query_params = vec![];
40 if let Some(p) = full_perms {
41 query_params.push(("full_perms", format!("{p}")));
42 }
43
44 if let Some(p) = id {
45 query_params.push(("id", format!("{p}")));
46 }
47
48 if let Some(p) = id_in {
49 query_params.push(("id__in", itertools::join(p, ",")));
50 }
51
52 if let Some(p) = name_icontains {
53 query_params.push(("name__icontains", p));
54 }
55
56 if let Some(p) = name_iendswith {
57 query_params.push(("name__iendswith", p));
58 }
59
60 if let Some(p) = name_iexact {
61 query_params.push(("name__iexact", p));
62 }
63
64 if let Some(p) = name_istartswith {
65 query_params.push(("name__istartswith", p));
66 }
67
68 if let Some(p) = ordering {
69 query_params.push(("ordering", p));
70 }
71
72 if let Some(p) = page {
73 query_params.push(("page", format!("{p}")));
74 }
75
76 if let Some(p) = page_size {
77 query_params.push(("page_size", format!("{p}")));
78 }
79
80 if let Some(p) = path_icontains {
81 query_params.push(("path__icontains", p));
82 }
83
84 if let Some(p) = path_iendswith {
85 query_params.push(("path__iendswith", p));
86 }
87
88 if let Some(p) = path_iexact {
89 query_params.push(("path__iexact", p));
90 }
91
92 if let Some(p) = path_istartswith {
93 query_params.push(("path__istartswith", p));
94 }
95
96 req = req.query(&query_params);
97 let resp = req.send().await?;
98 let status = resp.status();
99 if status.is_success() {
100 let text = resp.text().await.unwrap_or_default();
101 serde_json::from_str(&text).map_err(|err| {
102 crate::types::error::Error::from_serde_error(
103 format_serde_error::SerdeError::new(text.to_string(), err),
104 status,
105 )
106 })
107 } else {
108 let text = resp.text().await.unwrap_or_default();
109 Err(crate::types::error::Error::Server {
110 body: text.to_string(),
111 status,
112 })
113 }
114 }
115
116 #[doc = "Perform a `GET` request to `/api/storage_paths/`.\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- `path_icontains: Option<String>`\n- `path_iendswith: Option<String>`\n- `path_iexact: Option<String>`\n- `path_istartswith: Option<String>`\n\n```rust,no_run\nuse futures_util::TryStreamExt;\nasync fn example_storage_paths_list_stream() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let mut storage_paths = client.storage_paths();\n let mut stream = storage_paths.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 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```"]
117 #[tracing::instrument]
118 #[cfg(not(feature = "js"))]
119 #[allow(non_snake_case)]
120 pub fn list_stream<'a>(
121 &'a self,
122 full_perms: Option<bool>,
123 id: Option<i64>,
124 id__in: Option<Vec<i64>>,
125 name__icontains: Option<String>,
126 name__iendswith: Option<String>,
127 name__iexact: Option<String>,
128 name__istartswith: Option<String>,
129 ordering: Option<String>,
130 page_size: Option<i64>,
131 path__icontains: Option<String>,
132 path__iendswith: Option<String>,
133 path__iexact: Option<String>,
134 path__istartswith: Option<String>,
135 ) -> impl futures::Stream<Item = Result<crate::types::StoragePath, crate::types::error::Error>>
136 + Unpin
137 + '_ {
138 use crate::types::paginate::Pagination;
139 use futures::{StreamExt, TryFutureExt, TryStreamExt};
140 self.list(
141 full_perms,
142 id,
143 id__in,
144 name__icontains,
145 name__iendswith,
146 name__iexact,
147 name__istartswith,
148 ordering,
149 None,
150 page_size,
151 path__icontains,
152 path__iendswith,
153 path__iexact,
154 path__istartswith,
155 )
156 .map_ok(move |result| {
157 let items = futures::stream::iter(result.items().into_iter().map(Ok));
158 let next_pages = futures::stream::try_unfold(
159 (None, result),
160 move |(prev_page_token, new_result)| async move {
161 if new_result.has_more_pages()
162 && !new_result.items().is_empty()
163 && prev_page_token != new_result.next_page_token()
164 {
165 async {
166 let mut req = self.client.client.request(
167 http::Method::GET,
168 format!("{}/{}", self.client.base_url, "api/storage_paths/"),
169 );
170 req = req
171 .header("Authorization", format!("Token {}", &self.client.token));
172 let mut request = req.build()?;
173 request = new_result.next_page(request)?;
174 let resp = self.client.client.execute(request).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 .map_ok(|result: crate::types::PaginatedStoragePathList| {
193 Some((
194 futures::stream::iter(result.items().into_iter().map(Ok)),
195 (new_result.next_page_token(), result),
196 ))
197 })
198 .await
199 } else {
200 Ok(None)
201 }
202 },
203 )
204 .try_flatten();
205 items.chain(next_pages)
206 })
207 .try_flatten_stream()
208 .boxed()
209 }
210
211 #[doc = "Perform a `POST` request to `/api/storage_paths/`.\n\n```rust,no_run\nasync fn example_storage_paths_create() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let result: paperless_api_client::types::StoragePath = client\n .storage_paths()\n .create(&paperless_api_client::types::StoragePathRequest {\n name: \"some-string\".to_string(),\n path: \"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```"]
212 #[tracing::instrument]
213 #[allow(non_snake_case)]
214 pub async fn create<'a>(
215 &'a self,
216 body: &crate::types::StoragePathRequest,
217 ) -> Result<crate::types::StoragePath, crate::types::error::Error> {
218 let mut req = self.client.client.request(
219 http::Method::POST,
220 format!("{}/{}", self.client.base_url, "api/storage_paths/"),
221 );
222 req = req.header("Authorization", format!("Token {}", &self.client.token));
223 req = req.json(body);
224 let resp = req.send().await?;
225 let status = resp.status();
226 if status.is_success() {
227 let text = resp.text().await.unwrap_or_default();
228 serde_json::from_str(&text).map_err(|err| {
229 crate::types::error::Error::from_serde_error(
230 format_serde_error::SerdeError::new(text.to_string(), err),
231 status,
232 )
233 })
234 } else {
235 let text = resp.text().await.unwrap_or_default();
236 Err(crate::types::error::Error::Server {
237 body: text.to_string(),
238 status,
239 })
240 }
241 }
242
243 #[doc = "Perform a `GET` request to `/api/storage_paths/{id}/`.\n\n**Parameters:**\n\n- `full_perms: Option<bool>`\n- `id: i64`: A unique integer value identifying this storage path. (required)\n\n```rust,no_run\nasync fn example_storage_paths_retrieve() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let result: paperless_api_client::types::StoragePath = client\n .storage_paths()\n .retrieve(Some(true), 4 as i64)\n .await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
244 #[tracing::instrument]
245 #[allow(non_snake_case)]
246 pub async fn retrieve<'a>(
247 &'a self,
248 full_perms: Option<bool>,
249 id: i64,
250 ) -> Result<crate::types::StoragePath, crate::types::error::Error> {
251 let mut req = self.client.client.request(
252 http::Method::GET,
253 format!(
254 "{}/{}",
255 self.client.base_url,
256 "api/storage_paths/{id}/".replace("{id}", &format!("{id}"))
257 ),
258 );
259 req = req.header("Authorization", format!("Token {}", &self.client.token));
260 let mut query_params = vec![];
261 if let Some(p) = full_perms {
262 query_params.push(("full_perms", format!("{p}")));
263 }
264
265 req = req.query(&query_params);
266 let resp = req.send().await?;
267 let status = resp.status();
268 if status.is_success() {
269 let text = resp.text().await.unwrap_or_default();
270 serde_json::from_str(&text).map_err(|err| {
271 crate::types::error::Error::from_serde_error(
272 format_serde_error::SerdeError::new(text.to_string(), err),
273 status,
274 )
275 })
276 } else {
277 let text = resp.text().await.unwrap_or_default();
278 Err(crate::types::error::Error::Server {
279 body: text.to_string(),
280 status,
281 })
282 }
283 }
284
285 #[doc = "Perform a `PUT` request to `/api/storage_paths/{id}/`.\n\n**Parameters:**\n\n- `id: i64`: A unique integer value identifying this storage path. (required)\n\n```rust,no_run\nasync fn example_storage_paths_update() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let result: paperless_api_client::types::StoragePath = client\n .storage_paths()\n .update(\n 4 as i64,\n &paperless_api_client::types::StoragePathRequest {\n name: \"some-string\".to_string(),\n path: \"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```"]
286 #[tracing::instrument]
287 #[allow(non_snake_case)]
288 pub async fn update<'a>(
289 &'a self,
290 id: i64,
291 body: &crate::types::StoragePathRequest,
292 ) -> Result<crate::types::StoragePath, crate::types::error::Error> {
293 let mut req = self.client.client.request(
294 http::Method::PUT,
295 format!(
296 "{}/{}",
297 self.client.base_url,
298 "api/storage_paths/{id}/".replace("{id}", &format!("{id}"))
299 ),
300 );
301 req = req.header("Authorization", format!("Token {}", &self.client.token));
302 req = req.json(body);
303 let resp = req.send().await?;
304 let status = resp.status();
305 if status.is_success() {
306 let text = resp.text().await.unwrap_or_default();
307 serde_json::from_str(&text).map_err(|err| {
308 crate::types::error::Error::from_serde_error(
309 format_serde_error::SerdeError::new(text.to_string(), err),
310 status,
311 )
312 })
313 } else {
314 let text = resp.text().await.unwrap_or_default();
315 Err(crate::types::error::Error::Server {
316 body: text.to_string(),
317 status,
318 })
319 }
320 }
321
322 #[doc = "Perform a `DELETE` request to `/api/storage_paths/{id}/`.\n\nWhen a storage path is deleted, see if documents\nusing it require a rename/move\n\n**Parameters:**\n\n- `id: i64`: A unique integer value identifying this storage path. (required)\n\n```rust,no_run\nasync fn example_storage_paths_destroy() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n client.storage_paths().destroy(4 as i64).await?;\n Ok(())\n}\n```"]
323 #[tracing::instrument]
324 #[allow(non_snake_case)]
325 pub async fn destroy<'a>(&'a self, id: i64) -> Result<(), crate::types::error::Error> {
326 let mut req = self.client.client.request(
327 http::Method::DELETE,
328 format!(
329 "{}/{}",
330 self.client.base_url,
331 "api/storage_paths/{id}/".replace("{id}", &format!("{id}"))
332 ),
333 );
334 req = req.header("Authorization", format!("Token {}", &self.client.token));
335 let resp = req.send().await?;
336 let status = resp.status();
337 if status.is_success() {
338 Ok(())
339 } else {
340 let text = resp.text().await.unwrap_or_default();
341 Err(crate::types::error::Error::Server {
342 body: text.to_string(),
343 status,
344 })
345 }
346 }
347
348 #[doc = "Perform a `PATCH` request to `/api/storage_paths/{id}/`.\n\n**Parameters:**\n\n- `id: i64`: A unique integer value identifying this storage path. (required)\n\n```rust,no_run\nasync fn example_storage_paths_partial_update() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let result: paperless_api_client::types::StoragePath = client\n .storage_paths()\n .partial_update(\n 4 as i64,\n &paperless_api_client::types::PatchedStoragePathRequest {\n name: Some(\"some-string\".to_string()),\n path: 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```"]
349 #[tracing::instrument]
350 #[allow(non_snake_case)]
351 pub async fn partial_update<'a>(
352 &'a self,
353 id: i64,
354 body: &crate::types::PatchedStoragePathRequest,
355 ) -> Result<crate::types::StoragePath, crate::types::error::Error> {
356 let mut req = self.client.client.request(
357 http::Method::PATCH,
358 format!(
359 "{}/{}",
360 self.client.base_url,
361 "api/storage_paths/{id}/".replace("{id}", &format!("{id}"))
362 ),
363 );
364 req = req.header("Authorization", format!("Token {}", &self.client.token));
365 req = req.json(body);
366 let resp = req.send().await?;
367 let status = resp.status();
368 if status.is_success() {
369 let text = resp.text().await.unwrap_or_default();
370 serde_json::from_str(&text).map_err(|err| {
371 crate::types::error::Error::from_serde_error(
372 format_serde_error::SerdeError::new(text.to_string(), err),
373 status,
374 )
375 })
376 } else {
377 let text = resp.text().await.unwrap_or_default();
378 Err(crate::types::error::Error::Server {
379 body: text.to_string(),
380 status,
381 })
382 }
383 }
384
385 #[doc = "Perform a `POST` request to `/api/storage_paths/test/`.\n\nTest storage path against a document\n\n```rust,no_run\nasync fn example_storage_paths_test_create() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let result: paperless_api_client::types::StoragePath = client\n .storage_paths()\n .test_create(&paperless_api_client::types::StoragePathRequest {\n name: \"some-string\".to_string(),\n path: \"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```"]
386 #[tracing::instrument]
387 #[allow(non_snake_case)]
388 pub async fn test_create<'a>(
389 &'a self,
390 body: &crate::types::StoragePathRequest,
391 ) -> Result<crate::types::StoragePath, crate::types::error::Error> {
392 let mut req = self.client.client.request(
393 http::Method::POST,
394 format!("{}/{}", self.client.base_url, "api/storage_paths/test/"),
395 );
396 req = req.header("Authorization", format!("Token {}", &self.client.token));
397 req = req.json(body);
398 let resp = req.send().await?;
399 let status = resp.status();
400 if status.is_success() {
401 let text = resp.text().await.unwrap_or_default();
402 serde_json::from_str(&text).map_err(|err| {
403 crate::types::error::Error::from_serde_error(
404 format_serde_error::SerdeError::new(text.to_string(), err),
405 status,
406 )
407 })
408 } else {
409 let text = resp.text().await.unwrap_or_default();
410 Err(crate::types::error::Error::Server {
411 body: text.to_string(),
412 status,
413 })
414 }
415 }
416}