1use crate::Client;
2use anyhow::Result;
3#[derive(Clone, Debug)]
4pub struct ProcessedMail {
5 pub client: Client,
6}
7
8impl ProcessedMail {
9 #[doc(hidden)]
10 pub fn new(client: Client) -> Self {
11 Self { client }
12 }
13
14 #[doc = "Perform a `GET` request to `/api/processed_mail/`.\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- `rule: Option<i64>`\n- `status: Option<String>`\n\n```rust,no_run\nuse futures_util::TryStreamExt;\nasync fn example_processed_mail_list_stream() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let mut processed_mail = client.processed_mail();\n let mut stream = processed_mail.list_stream(\n Some(\"some-string\".to_string()),\n Some(4 as i64),\n Some(4 as i64),\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 rule: Option<i64>,
23 status: Option<String>,
24 ) -> Result<crate::types::PaginatedProcessedMailList, crate::types::error::Error> {
25 let mut req = self.client.client.request(
26 http::Method::GET,
27 format!("{}/{}", self.client.base_url, "api/processed_mail/"),
28 );
29 req = req.header("Authorization", format!("Token {}", &self.client.token));
30 let mut query_params = vec![];
31 if let Some(p) = ordering {
32 query_params.push(("ordering", p));
33 }
34
35 if let Some(p) = page {
36 query_params.push(("page", format!("{p}")));
37 }
38
39 if let Some(p) = page_size {
40 query_params.push(("page_size", format!("{p}")));
41 }
42
43 if let Some(p) = rule {
44 query_params.push(("rule", format!("{p}")));
45 }
46
47 if let Some(p) = status {
48 query_params.push(("status", p));
49 }
50
51 req = req.query(&query_params);
52 let resp = req.send().await?;
53 let status = resp.status();
54 if status.is_success() {
55 let text = resp.text().await.unwrap_or_default();
56 serde_json::from_str(&text).map_err(|err| {
57 crate::types::error::Error::from_serde_error(
58 format_serde_error::SerdeError::new(text.to_string(), err),
59 status,
60 )
61 })
62 } else {
63 let text = resp.text().await.unwrap_or_default();
64 Err(crate::types::error::Error::Server {
65 body: text.to_string(),
66 status,
67 })
68 }
69 }
70
71 #[doc = "Perform a `GET` request to `/api/processed_mail/`.\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- `rule: Option<i64>`\n- `status: Option<String>`\n\n```rust,no_run\nuse futures_util::TryStreamExt;\nasync fn example_processed_mail_list_stream() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let mut processed_mail = client.processed_mail();\n let mut stream = processed_mail.list_stream(\n Some(\"some-string\".to_string()),\n Some(4 as i64),\n Some(4 as i64),\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```"]
72 #[tracing::instrument]
73 #[cfg(not(feature = "js"))]
74 #[allow(non_snake_case)]
75 pub fn list_stream<'a>(
76 &'a self,
77 ordering: Option<String>,
78 page_size: Option<i64>,
79 rule: Option<i64>,
80 status: Option<String>,
81 ) -> impl futures::Stream<Item = Result<crate::types::ProcessedMail, crate::types::error::Error>>
82 + Unpin
83 + '_ {
84 use crate::types::paginate::Pagination;
85 use futures::{StreamExt, TryFutureExt, TryStreamExt};
86 self.list(ordering, None, page_size, rule, status)
87 .map_ok(move |result| {
88 let items = futures::stream::iter(result.items().into_iter().map(Ok));
89 let next_pages = futures::stream::try_unfold(
90 (None, result),
91 move |(prev_page_token, new_result)| async move {
92 if new_result.has_more_pages()
93 && !new_result.items().is_empty()
94 && prev_page_token != new_result.next_page_token()
95 {
96 async {
97 let mut req = self.client.client.request(
98 http::Method::GET,
99 format!("{}/{}", self.client.base_url, "api/processed_mail/"),
100 );
101 req = req.header(
102 "Authorization",
103 format!("Token {}", &self.client.token),
104 );
105 let mut request = req.build()?;
106 request = new_result.next_page(request)?;
107 let resp = self.client.client.execute(request).await?;
108 let status = resp.status();
109 if status.is_success() {
110 let text = resp.text().await.unwrap_or_default();
111 serde_json::from_str(&text).map_err(|err| {
112 crate::types::error::Error::from_serde_error(
113 format_serde_error::SerdeError::new(
114 text.to_string(),
115 err,
116 ),
117 status,
118 )
119 })
120 } else {
121 let text = resp.text().await.unwrap_or_default();
122 Err(crate::types::error::Error::Server {
123 body: text.to_string(),
124 status,
125 })
126 }
127 }
128 .map_ok(|result: crate::types::PaginatedProcessedMailList| {
129 Some((
130 futures::stream::iter(result.items().into_iter().map(Ok)),
131 (new_result.next_page_token(), result),
132 ))
133 })
134 .await
135 } else {
136 Ok(None)
137 }
138 },
139 )
140 .try_flatten();
141 items.chain(next_pages)
142 })
143 .try_flatten_stream()
144 .boxed()
145 }
146
147 #[doc = "Perform a `GET` request to `/api/processed_mail/{id}/`.\n\n**Parameters:**\n\n- `id: i64`: A unique integer value identifying this processed mail. (required)\n\n```rust,no_run\nasync fn example_processed_mail_retrieve() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let result: paperless_api_client::types::ProcessedMail = client.processed_mail().retrieve(4 as i64).await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
148 #[tracing::instrument]
149 #[allow(non_snake_case)]
150 pub async fn retrieve<'a>(
151 &'a self,
152 id: i64,
153 ) -> Result<crate::types::ProcessedMail, crate::types::error::Error> {
154 let mut req = self.client.client.request(
155 http::Method::GET,
156 format!(
157 "{}/{}",
158 self.client.base_url,
159 "api/processed_mail/{id}/".replace("{id}", &format!("{id}"))
160 ),
161 );
162 req = req.header("Authorization", format!("Token {}", &self.client.token));
163 let resp = req.send().await?;
164 let status = resp.status();
165 if status.is_success() {
166 let text = resp.text().await.unwrap_or_default();
167 serde_json::from_str(&text).map_err(|err| {
168 crate::types::error::Error::from_serde_error(
169 format_serde_error::SerdeError::new(text.to_string(), err),
170 status,
171 )
172 })
173 } else {
174 let text = resp.text().await.unwrap_or_default();
175 Err(crate::types::error::Error::Server {
176 body: text.to_string(),
177 status,
178 })
179 }
180 }
181
182 #[doc = "Perform a `POST` request to `/api/processed_mail/bulk_delete/`.\n\n```rust,no_run\nasync fn example_processed_mail_bulk_delete_create() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let result: paperless_api_client::types::ProcessedMail = client\n .processed_mail()\n .bulk_delete_create(&paperless_api_client::types::ProcessedMailRequest {\n owner: Some(4 as i64),\n })\n .await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
183 #[tracing::instrument]
184 #[allow(non_snake_case)]
185 pub async fn bulk_delete_create<'a>(
186 &'a self,
187 body: &crate::types::ProcessedMailRequest,
188 ) -> Result<crate::types::ProcessedMail, crate::types::error::Error> {
189 let mut req = self.client.client.request(
190 http::Method::POST,
191 format!(
192 "{}/{}",
193 self.client.base_url, "api/processed_mail/bulk_delete/"
194 ),
195 );
196 req = req.header("Authorization", format!("Token {}", &self.client.token));
197 req = req.json(body);
198 let resp = req.send().await?;
199 let status = resp.status();
200 if status.is_success() {
201 let text = resp.text().await.unwrap_or_default();
202 serde_json::from_str(&text).map_err(|err| {
203 crate::types::error::Error::from_serde_error(
204 format_serde_error::SerdeError::new(text.to_string(), err),
205 status,
206 )
207 })
208 } else {
209 let text = resp.text().await.unwrap_or_default();
210 Err(crate::types::error::Error::Server {
211 body: text.to_string(),
212 status,
213 })
214 }
215 }
216}