1use crate::Client;
2use anyhow::Result;
3#[derive(Clone, Debug)]
4pub struct ShareLinks {
5 pub client: Client,
6}
7
8impl ShareLinks {
9 #[doc(hidden)]
10 pub fn new(client: Client) -> Self {
11 Self { client }
12 }
13
14 #[doc = "Perform a `GET` request to `/api/share_links/`.\n\n**Parameters:**\n\n- `created_date_gt: Option<chrono::NaiveDate>`\n- `created_date_gte: Option<chrono::NaiveDate>`\n- `created_date_lt: Option<chrono::NaiveDate>`\n- `created_date_lte: Option<chrono::NaiveDate>`\n- `created_day: Option<f64>`\n- `created_gt: Option<chrono::DateTime<chrono::Utc>>`\n- `created_gte: Option<chrono::DateTime<chrono::Utc>>`\n- `created_lt: Option<chrono::DateTime<chrono::Utc>>`\n- `created_lte: Option<chrono::DateTime<chrono::Utc>>`\n- `created_month: Option<f64>`\n- `created_year: Option<f64>`\n- `expiration_date_gt: Option<chrono::NaiveDate>`\n- `expiration_date_gte: Option<chrono::NaiveDate>`\n- `expiration_date_lt: Option<chrono::NaiveDate>`\n- `expiration_date_lte: Option<chrono::NaiveDate>`\n- `expiration_day: Option<f64>`\n- `expiration_gt: Option<chrono::DateTime<chrono::Utc>>`\n- `expiration_gte: Option<chrono::DateTime<chrono::Utc>>`\n- `expiration_lt: Option<chrono::DateTime<chrono::Utc>>`\n- `expiration_lte: Option<chrono::DateTime<chrono::Utc>>`\n- `expiration_month: Option<f64>`\n- `expiration_year: Option<f64>`\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_share_links_list_stream() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let mut share_links = client.share_links();\n let mut stream = share_links.list_stream(\n Some(chrono::Utc::now().date_naive()),\n Some(chrono::Utc::now().date_naive()),\n Some(chrono::Utc::now().date_naive()),\n Some(chrono::Utc::now().date_naive()),\n Some(3.14 as f64),\n Some(chrono::Utc::now()),\n Some(chrono::Utc::now()),\n Some(chrono::Utc::now()),\n Some(chrono::Utc::now()),\n Some(3.14 as f64),\n Some(3.14 as f64),\n Some(chrono::Utc::now().date_naive()),\n Some(chrono::Utc::now().date_naive()),\n Some(chrono::Utc::now().date_naive()),\n Some(chrono::Utc::now().date_naive()),\n Some(3.14 as f64),\n Some(chrono::Utc::now()),\n Some(chrono::Utc::now()),\n Some(chrono::Utc::now()),\n Some(chrono::Utc::now()),\n Some(3.14 as f64),\n Some(3.14 as f64),\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 created_date_gt: Option<chrono::NaiveDate>,
20 created_date_gte: Option<chrono::NaiveDate>,
21 created_date_lt: Option<chrono::NaiveDate>,
22 created_date_lte: Option<chrono::NaiveDate>,
23 created_day: Option<f64>,
24 created_gt: Option<chrono::DateTime<chrono::Utc>>,
25 created_gte: Option<chrono::DateTime<chrono::Utc>>,
26 created_lt: Option<chrono::DateTime<chrono::Utc>>,
27 created_lte: Option<chrono::DateTime<chrono::Utc>>,
28 created_month: Option<f64>,
29 created_year: Option<f64>,
30 expiration_date_gt: Option<chrono::NaiveDate>,
31 expiration_date_gte: Option<chrono::NaiveDate>,
32 expiration_date_lt: Option<chrono::NaiveDate>,
33 expiration_date_lte: Option<chrono::NaiveDate>,
34 expiration_day: Option<f64>,
35 expiration_gt: Option<chrono::DateTime<chrono::Utc>>,
36 expiration_gte: Option<chrono::DateTime<chrono::Utc>>,
37 expiration_lt: Option<chrono::DateTime<chrono::Utc>>,
38 expiration_lte: Option<chrono::DateTime<chrono::Utc>>,
39 expiration_month: Option<f64>,
40 expiration_year: Option<f64>,
41 ordering: Option<String>,
42 page: Option<i64>,
43 page_size: Option<i64>,
44 ) -> Result<crate::types::PaginatedShareLinkList, crate::types::error::Error> {
45 let mut req = self.client.client.request(
46 http::Method::GET,
47 format!("{}/{}", self.client.base_url, "api/share_links/"),
48 );
49 req = req.header("Authorization", format!("Token {}", &self.client.token));
50 let mut query_params = vec![];
51 if let Some(p) = created_date_gt {
52 query_params.push(("created__date__gt", format!("{p}")));
53 }
54
55 if let Some(p) = created_date_gte {
56 query_params.push(("created__date__gte", format!("{p}")));
57 }
58
59 if let Some(p) = created_date_lt {
60 query_params.push(("created__date__lt", format!("{p}")));
61 }
62
63 if let Some(p) = created_date_lte {
64 query_params.push(("created__date__lte", format!("{p}")));
65 }
66
67 if let Some(p) = created_day {
68 query_params.push(("created__day", format!("{p}")));
69 }
70
71 if let Some(p) = created_gt {
72 query_params.push(("created__gt", format!("{p}")));
73 }
74
75 if let Some(p) = created_gte {
76 query_params.push(("created__gte", format!("{p}")));
77 }
78
79 if let Some(p) = created_lt {
80 query_params.push(("created__lt", format!("{p}")));
81 }
82
83 if let Some(p) = created_lte {
84 query_params.push(("created__lte", format!("{p}")));
85 }
86
87 if let Some(p) = created_month {
88 query_params.push(("created__month", format!("{p}")));
89 }
90
91 if let Some(p) = created_year {
92 query_params.push(("created__year", format!("{p}")));
93 }
94
95 if let Some(p) = expiration_date_gt {
96 query_params.push(("expiration__date__gt", format!("{p}")));
97 }
98
99 if let Some(p) = expiration_date_gte {
100 query_params.push(("expiration__date__gte", format!("{p}")));
101 }
102
103 if let Some(p) = expiration_date_lt {
104 query_params.push(("expiration__date__lt", format!("{p}")));
105 }
106
107 if let Some(p) = expiration_date_lte {
108 query_params.push(("expiration__date__lte", format!("{p}")));
109 }
110
111 if let Some(p) = expiration_day {
112 query_params.push(("expiration__day", format!("{p}")));
113 }
114
115 if let Some(p) = expiration_gt {
116 query_params.push(("expiration__gt", format!("{p}")));
117 }
118
119 if let Some(p) = expiration_gte {
120 query_params.push(("expiration__gte", format!("{p}")));
121 }
122
123 if let Some(p) = expiration_lt {
124 query_params.push(("expiration__lt", format!("{p}")));
125 }
126
127 if let Some(p) = expiration_lte {
128 query_params.push(("expiration__lte", format!("{p}")));
129 }
130
131 if let Some(p) = expiration_month {
132 query_params.push(("expiration__month", format!("{p}")));
133 }
134
135 if let Some(p) = expiration_year {
136 query_params.push(("expiration__year", format!("{p}")));
137 }
138
139 if let Some(p) = ordering {
140 query_params.push(("ordering", p));
141 }
142
143 if let Some(p) = page {
144 query_params.push(("page", format!("{p}")));
145 }
146
147 if let Some(p) = page_size {
148 query_params.push(("page_size", format!("{p}")));
149 }
150
151 req = req.query(&query_params);
152 let resp = req.send().await?;
153 let status = resp.status();
154 if status.is_success() {
155 let text = resp.text().await.unwrap_or_default();
156 serde_json::from_str(&text).map_err(|err| {
157 crate::types::error::Error::from_serde_error(
158 format_serde_error::SerdeError::new(text.to_string(), err),
159 status,
160 )
161 })
162 } else {
163 let text = resp.text().await.unwrap_or_default();
164 Err(crate::types::error::Error::Server {
165 body: text.to_string(),
166 status,
167 })
168 }
169 }
170
171 #[doc = "Perform a `GET` request to `/api/share_links/`.\n\n**Parameters:**\n\n- `created_date_gt: Option<chrono::NaiveDate>`\n- `created_date_gte: Option<chrono::NaiveDate>`\n- `created_date_lt: Option<chrono::NaiveDate>`\n- `created_date_lte: Option<chrono::NaiveDate>`\n- `created_day: Option<f64>`\n- `created_gt: Option<chrono::DateTime<chrono::Utc>>`\n- `created_gte: Option<chrono::DateTime<chrono::Utc>>`\n- `created_lt: Option<chrono::DateTime<chrono::Utc>>`\n- `created_lte: Option<chrono::DateTime<chrono::Utc>>`\n- `created_month: Option<f64>`\n- `created_year: Option<f64>`\n- `expiration_date_gt: Option<chrono::NaiveDate>`\n- `expiration_date_gte: Option<chrono::NaiveDate>`\n- `expiration_date_lt: Option<chrono::NaiveDate>`\n- `expiration_date_lte: Option<chrono::NaiveDate>`\n- `expiration_day: Option<f64>`\n- `expiration_gt: Option<chrono::DateTime<chrono::Utc>>`\n- `expiration_gte: Option<chrono::DateTime<chrono::Utc>>`\n- `expiration_lt: Option<chrono::DateTime<chrono::Utc>>`\n- `expiration_lte: Option<chrono::DateTime<chrono::Utc>>`\n- `expiration_month: Option<f64>`\n- `expiration_year: Option<f64>`\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_share_links_list_stream() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let mut share_links = client.share_links();\n let mut stream = share_links.list_stream(\n Some(chrono::Utc::now().date_naive()),\n Some(chrono::Utc::now().date_naive()),\n Some(chrono::Utc::now().date_naive()),\n Some(chrono::Utc::now().date_naive()),\n Some(3.14 as f64),\n Some(chrono::Utc::now()),\n Some(chrono::Utc::now()),\n Some(chrono::Utc::now()),\n Some(chrono::Utc::now()),\n Some(3.14 as f64),\n Some(3.14 as f64),\n Some(chrono::Utc::now().date_naive()),\n Some(chrono::Utc::now().date_naive()),\n Some(chrono::Utc::now().date_naive()),\n Some(chrono::Utc::now().date_naive()),\n Some(3.14 as f64),\n Some(chrono::Utc::now()),\n Some(chrono::Utc::now()),\n Some(chrono::Utc::now()),\n Some(chrono::Utc::now()),\n Some(3.14 as f64),\n Some(3.14 as f64),\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```"]
172 #[tracing::instrument]
173 #[cfg(not(feature = "js"))]
174 #[allow(non_snake_case)]
175 pub fn list_stream<'a>(
176 &'a self,
177 created__date__gt: Option<chrono::NaiveDate>,
178 created__date__gte: Option<chrono::NaiveDate>,
179 created__date__lt: Option<chrono::NaiveDate>,
180 created__date__lte: Option<chrono::NaiveDate>,
181 created__day: Option<f64>,
182 created__gt: Option<chrono::DateTime<chrono::Utc>>,
183 created__gte: Option<chrono::DateTime<chrono::Utc>>,
184 created__lt: Option<chrono::DateTime<chrono::Utc>>,
185 created__lte: Option<chrono::DateTime<chrono::Utc>>,
186 created__month: Option<f64>,
187 created__year: Option<f64>,
188 expiration__date__gt: Option<chrono::NaiveDate>,
189 expiration__date__gte: Option<chrono::NaiveDate>,
190 expiration__date__lt: Option<chrono::NaiveDate>,
191 expiration__date__lte: Option<chrono::NaiveDate>,
192 expiration__day: Option<f64>,
193 expiration__gt: Option<chrono::DateTime<chrono::Utc>>,
194 expiration__gte: Option<chrono::DateTime<chrono::Utc>>,
195 expiration__lt: Option<chrono::DateTime<chrono::Utc>>,
196 expiration__lte: Option<chrono::DateTime<chrono::Utc>>,
197 expiration__month: Option<f64>,
198 expiration__year: Option<f64>,
199 ordering: Option<String>,
200 page_size: Option<i64>,
201 ) -> impl futures::Stream<Item = Result<crate::types::ShareLink, crate::types::error::Error>>
202 + Unpin
203 + '_ {
204 use crate::types::paginate::Pagination;
205 use futures::{StreamExt, TryFutureExt, TryStreamExt};
206 self.list(
207 created__date__gt,
208 created__date__gte,
209 created__date__lt,
210 created__date__lte,
211 created__day,
212 created__gt,
213 created__gte,
214 created__lt,
215 created__lte,
216 created__month,
217 created__year,
218 expiration__date__gt,
219 expiration__date__gte,
220 expiration__date__lt,
221 expiration__date__lte,
222 expiration__day,
223 expiration__gt,
224 expiration__gte,
225 expiration__lt,
226 expiration__lte,
227 expiration__month,
228 expiration__year,
229 ordering,
230 None,
231 page_size,
232 )
233 .map_ok(move |result| {
234 let items = futures::stream::iter(result.items().into_iter().map(Ok));
235 let next_pages = futures::stream::try_unfold(
236 (None, result),
237 move |(prev_page_token, new_result)| async move {
238 if new_result.has_more_pages()
239 && !new_result.items().is_empty()
240 && prev_page_token != new_result.next_page_token()
241 {
242 async {
243 let mut req = self.client.client.request(
244 http::Method::GET,
245 format!("{}/{}", self.client.base_url, "api/share_links/"),
246 );
247 req = req
248 .header("Authorization", format!("Token {}", &self.client.token));
249 let mut request = req.build()?;
250 request = new_result.next_page(request)?;
251 let resp = self.client.client.execute(request).await?;
252 let status = resp.status();
253 if status.is_success() {
254 let text = resp.text().await.unwrap_or_default();
255 serde_json::from_str(&text).map_err(|err| {
256 crate::types::error::Error::from_serde_error(
257 format_serde_error::SerdeError::new(text.to_string(), err),
258 status,
259 )
260 })
261 } else {
262 let text = resp.text().await.unwrap_or_default();
263 Err(crate::types::error::Error::Server {
264 body: text.to_string(),
265 status,
266 })
267 }
268 }
269 .map_ok(|result: crate::types::PaginatedShareLinkList| {
270 Some((
271 futures::stream::iter(result.items().into_iter().map(Ok)),
272 (new_result.next_page_token(), result),
273 ))
274 })
275 .await
276 } else {
277 Ok(None)
278 }
279 },
280 )
281 .try_flatten();
282 items.chain(next_pages)
283 })
284 .try_flatten_stream()
285 .boxed()
286 }
287
288 #[doc = "Perform a `POST` request to `/api/share_links/`.\n\n```rust,no_run\nasync fn example_share_links_create() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let result: paperless_api_client::types::ShareLink = client\n .share_links()\n .create(&paperless_api_client::types::ShareLinkRequest {\n expiration: Some(chrono::Utc::now()),\n document: Some(4 as i64),\n file_version: Some(paperless_api_client::types::FileVersionEnum::Original),\n })\n .await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
289 #[tracing::instrument]
290 #[allow(non_snake_case)]
291 pub async fn create<'a>(
292 &'a self,
293 body: &crate::types::ShareLinkRequest,
294 ) -> Result<crate::types::ShareLink, crate::types::error::Error> {
295 let mut req = self.client.client.request(
296 http::Method::POST,
297 format!("{}/{}", self.client.base_url, "api/share_links/"),
298 );
299 req = req.header("Authorization", format!("Token {}", &self.client.token));
300 req = req.json(body);
301 let resp = req.send().await?;
302 let status = resp.status();
303 if status.is_success() {
304 let text = resp.text().await.unwrap_or_default();
305 serde_json::from_str(&text).map_err(|err| {
306 crate::types::error::Error::from_serde_error(
307 format_serde_error::SerdeError::new(text.to_string(), err),
308 status,
309 )
310 })
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 `GET` request to `/api/share_links/{id}/`.\n\n**Parameters:**\n\n- `id: i64`: A unique integer value identifying this share link. (required)\n\n```rust,no_run\nasync fn example_share_links_retrieve() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let result: paperless_api_client::types::ShareLink = client.share_links().retrieve(4 as i64).await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
321 #[tracing::instrument]
322 #[allow(non_snake_case)]
323 pub async fn retrieve<'a>(
324 &'a self,
325 id: i64,
326 ) -> Result<crate::types::ShareLink, crate::types::error::Error> {
327 let mut req = self.client.client.request(
328 http::Method::GET,
329 format!(
330 "{}/{}",
331 self.client.base_url,
332 "api/share_links/{id}/".replace("{id}", &format!("{id}"))
333 ),
334 );
335 req = req.header("Authorization", format!("Token {}", &self.client.token));
336 let resp = req.send().await?;
337 let status = resp.status();
338 if status.is_success() {
339 let text = resp.text().await.unwrap_or_default();
340 serde_json::from_str(&text).map_err(|err| {
341 crate::types::error::Error::from_serde_error(
342 format_serde_error::SerdeError::new(text.to_string(), err),
343 status,
344 )
345 })
346 } else {
347 let text = resp.text().await.unwrap_or_default();
348 Err(crate::types::error::Error::Server {
349 body: text.to_string(),
350 status,
351 })
352 }
353 }
354
355 #[doc = "Perform a `PUT` request to `/api/share_links/{id}/`.\n\n**Parameters:**\n\n- `id: i64`: A unique integer value identifying this share link. (required)\n\n```rust,no_run\nasync fn example_share_links_update() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let result: paperless_api_client::types::ShareLink = client\n .share_links()\n .update(\n 4 as i64,\n &paperless_api_client::types::ShareLinkRequest {\n expiration: Some(chrono::Utc::now()),\n document: Some(4 as i64),\n file_version: Some(paperless_api_client::types::FileVersionEnum::Original),\n },\n )\n .await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
356 #[tracing::instrument]
357 #[allow(non_snake_case)]
358 pub async fn update<'a>(
359 &'a self,
360 id: i64,
361 body: &crate::types::ShareLinkRequest,
362 ) -> Result<crate::types::ShareLink, crate::types::error::Error> {
363 let mut req = self.client.client.request(
364 http::Method::PUT,
365 format!(
366 "{}/{}",
367 self.client.base_url,
368 "api/share_links/{id}/".replace("{id}", &format!("{id}"))
369 ),
370 );
371 req = req.header("Authorization", format!("Token {}", &self.client.token));
372 req = req.json(body);
373 let resp = req.send().await?;
374 let status = resp.status();
375 if status.is_success() {
376 let text = resp.text().await.unwrap_or_default();
377 serde_json::from_str(&text).map_err(|err| {
378 crate::types::error::Error::from_serde_error(
379 format_serde_error::SerdeError::new(text.to_string(), err),
380 status,
381 )
382 })
383 } else {
384 let text = resp.text().await.unwrap_or_default();
385 Err(crate::types::error::Error::Server {
386 body: text.to_string(),
387 status,
388 })
389 }
390 }
391
392 #[doc = "Perform a `DELETE` request to `/api/share_links/{id}/`.\n\n**Parameters:**\n\n- `id: i64`: A unique integer value identifying this share link. (required)\n\n```rust,no_run\nasync fn example_share_links_destroy() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n client.share_links().destroy(4 as i64).await?;\n Ok(())\n}\n```"]
393 #[tracing::instrument]
394 #[allow(non_snake_case)]
395 pub async fn destroy<'a>(&'a self, id: i64) -> Result<(), crate::types::error::Error> {
396 let mut req = self.client.client.request(
397 http::Method::DELETE,
398 format!(
399 "{}/{}",
400 self.client.base_url,
401 "api/share_links/{id}/".replace("{id}", &format!("{id}"))
402 ),
403 );
404 req = req.header("Authorization", format!("Token {}", &self.client.token));
405 let resp = req.send().await?;
406 let status = resp.status();
407 if status.is_success() {
408 Ok(())
409 } else {
410 let text = resp.text().await.unwrap_or_default();
411 Err(crate::types::error::Error::Server {
412 body: text.to_string(),
413 status,
414 })
415 }
416 }
417
418 #[doc = "Perform a `PATCH` request to `/api/share_links/{id}/`.\n\n**Parameters:**\n\n- `id: i64`: A unique integer value identifying this share link. (required)\n\n```rust,no_run\nasync fn example_share_links_partial_update() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let result: paperless_api_client::types::ShareLink = client\n .share_links()\n .partial_update(\n 4 as i64,\n &paperless_api_client::types::PatchedShareLinkRequest {\n expiration: Some(chrono::Utc::now()),\n document: Some(4 as i64),\n file_version: Some(paperless_api_client::types::FileVersionEnum::Original),\n },\n )\n .await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
419 #[tracing::instrument]
420 #[allow(non_snake_case)]
421 pub async fn partial_update<'a>(
422 &'a self,
423 id: i64,
424 body: &crate::types::PatchedShareLinkRequest,
425 ) -> Result<crate::types::ShareLink, crate::types::error::Error> {
426 let mut req = self.client.client.request(
427 http::Method::PATCH,
428 format!(
429 "{}/{}",
430 self.client.base_url,
431 "api/share_links/{id}/".replace("{id}", &format!("{id}"))
432 ),
433 );
434 req = req.header("Authorization", format!("Token {}", &self.client.token));
435 req = req.json(body);
436 let resp = req.send().await?;
437 let status = resp.status();
438 if status.is_success() {
439 let text = resp.text().await.unwrap_or_default();
440 serde_json::from_str(&text).map_err(|err| {
441 crate::types::error::Error::from_serde_error(
442 format_serde_error::SerdeError::new(text.to_string(), err),
443 status,
444 )
445 })
446 } else {
447 let text = resp.text().await.unwrap_or_default();
448 Err(crate::types::error::Error::Server {
449 body: text.to_string(),
450 status,
451 })
452 }
453 }
454}