1use crate::Client;
2use anyhow::Result;
3#[derive(Clone, Debug)]
4pub struct Tasks {
5 pub client: Client,
6}
7
8impl Tasks {
9 #[doc(hidden)]
10 pub fn new(client: Client) -> Self {
11 Self { client }
12 }
13
14 #[doc = "Perform a `GET` request to `/api/tasks/`.\n\n**Parameters:**\n\n- `acknowledged: Option<bool>`: Acknowledged\n- `ordering: Option<String>`: Which field to use when ordering the results.\n- `status: Option<crate::types::Status>`: Current state of the task being run\n\n* `FAILURE` - FAILURE\n* `PENDING` - PENDING\n* `RECEIVED` - RECEIVED\n* `RETRY` - RETRY\n* `REVOKED` - REVOKED\n* `STARTED` - STARTED\n* `SUCCESS` - SUCCESS\n- `task_id: Option<String>`: Filter tasks by Celery UUID\n- `task_name: Option<crate::types::ListTaskName>`: Name of the task that was run\n\n* `consume_file` - Consume File\n* `train_classifier` - Train Classifier\n* `check_sanity` - Check Sanity\n* `index_optimize` - Index Optimize\n- `type_: Option<crate::types::Type>`: The type of task that was run\n\n* `auto_task` - Auto Task\n* `scheduled_task` - Scheduled Task\n* `manual_task` - Manual Task\n\n```rust,no_run\nasync fn example_tasks_list() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let result: Vec<paperless_api_client::types::TasksView> = client\n .tasks()\n .list(\n Some(true),\n Some(\"some-string\".to_string()),\n Some(paperless_api_client::types::Status::Revoked),\n Some(\"some-string\".to_string()),\n Some(paperless_api_client::types::OptionListTaskName::IndexOptimize),\n Some(paperless_api_client::types::Type::ManualTask),\n )\n .await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
15 #[tracing::instrument]
16 #[allow(non_snake_case)]
17 pub async fn list<'a>(
18 &'a self,
19 acknowledged: Option<bool>,
20 ordering: Option<String>,
21 status: Option<crate::types::Status>,
22 task_id: Option<String>,
23 task_name: Option<crate::types::ListTaskName>,
24 type_: Option<crate::types::Type>,
25 ) -> Result<Vec<crate::types::TasksView>, crate::types::error::Error> {
26 let mut req = self.client.client.request(
27 http::Method::GET,
28 format!("{}/{}", self.client.base_url, "api/tasks/"),
29 );
30 req = req.header("Authorization", format!("Token {}", &self.client.token));
31 let mut query_params = vec![];
32 if let Some(p) = acknowledged {
33 query_params.push(("acknowledged", format!("{p}")));
34 }
35
36 if let Some(p) = ordering {
37 query_params.push(("ordering", p));
38 }
39
40 if let Some(p) = status {
41 query_params.push(("status", format!("{p}")));
42 }
43
44 if let Some(p) = task_id {
45 query_params.push(("task_id", p));
46 }
47
48 if let Some(p) = task_name {
49 query_params.push(("task_name", format!("{p}")));
50 }
51
52 if let Some(p) = type_ {
53 query_params.push(("type", format!("{p}")));
54 }
55
56 req = req.query(&query_params);
57 let resp = req.send().await?;
58 let status = resp.status();
59 if status.is_success() {
60 let text = resp.text().await.unwrap_or_default();
61 serde_json::from_str(&text).map_err(|err| {
62 crate::types::error::Error::from_serde_error(
63 format_serde_error::SerdeError::new(text.to_string(), err),
64 status,
65 )
66 })
67 } else {
68 let text = resp.text().await.unwrap_or_default();
69 Err(crate::types::error::Error::Server {
70 body: text.to_string(),
71 status,
72 })
73 }
74 }
75
76 #[doc = "Perform a `GET` request to `/api/tasks/{id}/`.\n\n**Parameters:**\n\n- `id: i64`: A unique integer value identifying this paperless task. (required)\n- `task_id: Option<String>`: Filter tasks by Celery UUID\n\n```rust,no_run\nasync fn example_tasks_retrieve() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let result: paperless_api_client::types::TasksView = client\n .tasks()\n .retrieve(4 as i64, Some(\"some-string\".to_string()))\n .await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
77 #[tracing::instrument]
78 #[allow(non_snake_case)]
79 pub async fn retrieve<'a>(
80 &'a self,
81 id: i64,
82 task_id: Option<String>,
83 ) -> Result<crate::types::TasksView, crate::types::error::Error> {
84 let mut req = self.client.client.request(
85 http::Method::GET,
86 format!(
87 "{}/{}",
88 self.client.base_url,
89 "api/tasks/{id}/".replace("{id}", &format!("{id}"))
90 ),
91 );
92 req = req.header("Authorization", format!("Token {}", &self.client.token));
93 let mut query_params = vec![];
94 if let Some(p) = task_id {
95 query_params.push(("task_id", p));
96 }
97
98 req = req.query(&query_params);
99 let resp = req.send().await?;
100 let status = resp.status();
101 if status.is_success() {
102 let text = resp.text().await.unwrap_or_default();
103 serde_json::from_str(&text).map_err(|err| {
104 crate::types::error::Error::from_serde_error(
105 format_serde_error::SerdeError::new(text.to_string(), err),
106 status,
107 )
108 })
109 } else {
110 let text = resp.text().await.unwrap_or_default();
111 Err(crate::types::error::Error::Server {
112 body: text.to_string(),
113 status,
114 })
115 }
116 }
117
118 #[doc = "Perform a `POST` request to `/api/tasks/acknowledge/`.\n\nAcknowledge a list of tasks\n\n**Parameters:**\n\n- `task_id: Option<String>`: Filter tasks by Celery UUID\n\n```rust,no_run\nasync fn example_tasks_acknowledge() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let result: paperless_api_client::types::AcknowledgeTasks = client\n .tasks()\n .acknowledge(\n Some(\"some-string\".to_string()),\n &paperless_api_client::types::AcknowledgeTasksRequestBody {\n tasks: vec![4 as i64],\n },\n )\n .await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
119 #[tracing::instrument]
120 #[allow(non_snake_case)]
121 pub async fn acknowledge<'a>(
122 &'a self,
123 task_id: Option<String>,
124 body: &crate::types::AcknowledgeTasksRequestBody,
125 ) -> Result<crate::types::AcknowledgeTasks, crate::types::error::Error> {
126 let mut req = self.client.client.request(
127 http::Method::POST,
128 format!("{}/{}", self.client.base_url, "api/tasks/acknowledge/"),
129 );
130 req = req.header("Authorization", format!("Token {}", &self.client.token));
131 let mut query_params = vec![];
132 if let Some(p) = task_id {
133 query_params.push(("task_id", p));
134 }
135
136 req = req.query(&query_params);
137 req = req.json(body);
138 let resp = req.send().await?;
139 let status = resp.status();
140 if status.is_success() {
141 let text = resp.text().await.unwrap_or_default();
142 serde_json::from_str(&text).map_err(|err| {
143 crate::types::error::Error::from_serde_error(
144 format_serde_error::SerdeError::new(text.to_string(), err),
145 status,
146 )
147 })
148 } else {
149 let text = resp.text().await.unwrap_or_default();
150 Err(crate::types::error::Error::Server {
151 body: text.to_string(),
152 status,
153 })
154 }
155 }
156
157 #[doc = "Perform a `POST` request to `/api/tasks/run/`.\n\n**Parameters:**\n\n- `task_id: Option<String>`: Filter tasks by Celery UUID\n\n```rust,no_run\nasync fn example_tasks_run_create() -> anyhow::Result<()> {\n let client = paperless_api_client::Client::new_from_env();\n let result: paperless_api_client::types::TasksView = client\n .tasks()\n .run_create(\n Some(\"some-string\".to_string()),\n &paperless_api_client::types::TasksViewRequest {\n task_id: \"some-string\".to_string(),\n task_name: Some(paperless_api_client::types::TaskName::CheckSanity),\n task_file_name: Some(\"some-string\".to_string()),\n date_created: Some(chrono::Utc::now()),\n date_done: Some(chrono::Utc::now()),\n type_: Some(paperless_api_client::types::TasksViewTypeEnum::ScheduledTask),\n status: Some(paperless_api_client::types::StatusEnum::Revoked),\n result: Some(\"some-string\".to_string()),\n acknowledged: Some(true),\n owner: Some(4 as i64),\n },\n )\n .await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
158 #[tracing::instrument]
159 #[allow(non_snake_case)]
160 pub async fn run_create<'a>(
161 &'a self,
162 task_id: Option<String>,
163 body: &crate::types::TasksViewRequest,
164 ) -> Result<crate::types::TasksView, crate::types::error::Error> {
165 let mut req = self.client.client.request(
166 http::Method::POST,
167 format!("{}/{}", self.client.base_url, "api/tasks/run/"),
168 );
169 req = req.header("Authorization", format!("Token {}", &self.client.token));
170 let mut query_params = vec![];
171 if let Some(p) = task_id {
172 query_params.push(("task_id", p));
173 }
174
175 req = req.query(&query_params);
176 req = req.json(body);
177 let resp = req.send().await?;
178 let status = resp.status();
179 if status.is_success() {
180 let text = resp.text().await.unwrap_or_default();
181 serde_json::from_str(&text).map_err(|err| {
182 crate::types::error::Error::from_serde_error(
183 format_serde_error::SerdeError::new(text.to_string(), err),
184 status,
185 )
186 })
187 } else {
188 let text = resp.text().await.unwrap_or_default();
189 Err(crate::types::error::Error::Server {
190 body: text.to_string(),
191 status,
192 })
193 }
194 }
195}