printnanny_api_client/apis/
crash_reports_api.rs1use reqwest;
13
14use bytes::Bytes;
15use crate::apis::ResponseContent;
16use super::{Error, configuration};
17
18
19#[derive(Debug, Clone, Serialize, Deserialize)]
21#[serde(untagged)]
22pub enum CrashReportsCreateError {
23 Status409(crate::models::ErrorDetail),
24 Status400(crate::models::ErrorDetail),
25 Status401(crate::models::ErrorDetail),
26 Status403(crate::models::ErrorDetail),
27 Status500(crate::models::ErrorDetail),
28 UnknownValue(serde_json::Value),
29}
30
31#[derive(Debug, Clone, Serialize, Deserialize)]
33#[serde(untagged)]
34pub enum CrashReportsListError {
35 Status400(crate::models::ErrorDetail),
36 Status401(crate::models::ErrorDetail),
37 Status403(crate::models::ErrorDetail),
38 Status500(crate::models::ErrorDetail),
39 UnknownValue(serde_json::Value),
40}
41
42#[derive(Debug, Clone, Serialize, Deserialize)]
44#[serde(untagged)]
45pub enum CrashReportsPartialUpdateError {
46 Status409(crate::models::ErrorDetail),
47 Status400(crate::models::ErrorDetail),
48 Status401(crate::models::ErrorDetail),
49 Status403(crate::models::ErrorDetail),
50 Status500(crate::models::ErrorDetail),
51 UnknownValue(serde_json::Value),
52}
53
54#[derive(Debug, Clone, Serialize, Deserialize)]
56#[serde(untagged)]
57pub enum CrashReportsRetrieveError {
58 UnknownValue(serde_json::Value),
59}
60
61#[derive(Debug, Clone, Serialize, Deserialize)]
63#[serde(untagged)]
64pub enum CrashReportsUpdateError {
65 Status409(crate::models::ErrorDetail),
66 Status400(crate::models::ErrorDetail),
67 Status401(crate::models::ErrorDetail),
68 Status403(crate::models::ErrorDetail),
69 Status500(crate::models::ErrorDetail),
70 UnknownValue(serde_json::Value),
71}
72
73
74pub async fn crash_reports_create(configuration: &configuration::Configuration, description: Option<&str>, email: Option<&str>, os_version: Option<&str>, os_logs: Option<std::path::PathBuf>, browser_version: Option<&str>, browser_logs: Option<std::path::PathBuf>, serial: Option<&str>, posthog_session: Option<&str>, status: Option<crate::models::CrashReportStatusEnum>, support_comment: Option<&str>, pi: Option<i32>) -> Result<crate::models::CrashReport, Error<CrashReportsCreateError>> {
75 let local_var_configuration = configuration;
76
77 let local_var_client = &local_var_configuration.client;
78
79 let local_var_uri_str = format!("{}/api/crash-reports/", local_var_configuration.base_path);
80 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
81
82 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
83 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
84 }
85 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
86 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
87 };
88 let mut local_var_form = reqwest::multipart::Form::new();
89 if let Some(local_var_param_value) = description {
90 local_var_form = local_var_form.text("description", local_var_param_value.to_string());
91 }
92 if let Some(local_var_param_value) = email {
93 local_var_form = local_var_form.text("email", local_var_param_value.to_string());
94 }
95 if let Some(local_var_param_value) = os_version {
96 local_var_form = local_var_form.text("os_version", local_var_param_value.to_string());
97 }
98 if let Some(local_var_param_value) = os_logs {
99 let kind = infer::get_from_path(&local_var_param_value)?.map(|v| v.mime_type().to_string()).unwrap_or_else(|| "application/octet-stream".to_string());
100 let filebytes = tokio::fs::read(&local_var_param_value).await?;
101 let file_part = reqwest::multipart::Part::bytes(filebytes)
102 .file_name(local_var_param_value.display().to_string())
103 .mime_str(&kind)?;
104 local_var_form = local_var_form.part("os_logs", file_part);
105 }
106 if let Some(local_var_param_value) = browser_version {
107 local_var_form = local_var_form.text("browser_version", local_var_param_value.to_string());
108 }
109 if let Some(local_var_param_value) = browser_logs {
110 let kind = infer::get_from_path(&local_var_param_value)?.map(|v| v.mime_type().to_string()).unwrap_or_else(|| "application/octet-stream".to_string());
111 let filebytes = tokio::fs::read(&local_var_param_value).await?;
112 let file_part = reqwest::multipart::Part::bytes(filebytes)
113 .file_name(local_var_param_value.display().to_string())
114 .mime_str(&kind)?;
115 local_var_form = local_var_form.part("browser_logs", file_part);
116 }
117 if let Some(local_var_param_value) = serial {
118 local_var_form = local_var_form.text("serial", local_var_param_value.to_string());
119 }
120 if let Some(local_var_param_value) = posthog_session {
121 local_var_form = local_var_form.text("posthog_session", local_var_param_value.to_string());
122 }
123 if let Some(local_var_param_value) = status {
124 local_var_form = local_var_form.text("status", local_var_param_value.to_string());
125 }
126 if let Some(local_var_param_value) = support_comment {
127 local_var_form = local_var_form.text("support_comment", local_var_param_value.to_string());
128 }
129 if let Some(local_var_param_value) = pi {
130 local_var_form = local_var_form.text("pi", local_var_param_value.to_string());
131 }
132 local_var_req_builder = local_var_req_builder.multipart(local_var_form);
133
134 let local_var_req = local_var_req_builder.build()?;
135 let local_var_resp = local_var_client.execute(local_var_req).await?;
136
137 let local_var_status = local_var_resp.status();
138 let local_var_content = local_var_resp.text().await?;
139
140 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
141 serde_json::from_str(&local_var_content).map_err(Error::from)
142 } else {
143 let local_var_entity: Option<CrashReportsCreateError> = serde_json::from_str(&local_var_content).ok();
144 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
145 Err(Error::ResponseError(local_var_error))
146 }
147}
148
149pub async fn crash_reports_list(configuration: &configuration::Configuration, page: Option<i32>) -> Result<crate::models::PaginatedCrashReportList, Error<CrashReportsListError>> {
150 let local_var_configuration = configuration;
151
152 let local_var_client = &local_var_configuration.client;
153
154 let local_var_uri_str = format!("{}/api/crash-reports/", local_var_configuration.base_path);
155 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
156
157 if let Some(ref local_var_str) = page {
158 local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
159 }
160 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
161 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
162 }
163 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
164 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
165 };
166
167 let local_var_req = local_var_req_builder.build()?;
168 let local_var_resp = local_var_client.execute(local_var_req).await?;
169
170 let local_var_status = local_var_resp.status();
171 let local_var_content = local_var_resp.text().await?;
172
173 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
174 serde_json::from_str(&local_var_content).map_err(Error::from)
175 } else {
176 let local_var_entity: Option<CrashReportsListError> = serde_json::from_str(&local_var_content).ok();
177 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
178 Err(Error::ResponseError(local_var_error))
179 }
180}
181
182pub async fn crash_reports_partial_update(configuration: &configuration::Configuration, id: &str, description: Option<&str>, email: Option<&str>, os_version: Option<&str>, os_logs: Option<std::path::PathBuf>, browser_version: Option<&str>, browser_logs: Option<std::path::PathBuf>, serial: Option<&str>, posthog_session: Option<&str>, status: Option<crate::models::CrashReportStatusEnum>, support_comment: Option<&str>, pi: Option<i32>) -> Result<crate::models::CrashReport, Error<CrashReportsPartialUpdateError>> {
183 let local_var_configuration = configuration;
184
185 let local_var_client = &local_var_configuration.client;
186
187 let local_var_uri_str = format!("{}/api/crash-reports/{id}/", local_var_configuration.base_path, id=crate::apis::urlencode(id));
188 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
189
190 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
191 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
192 }
193 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
194 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
195 };
196 let mut local_var_form = reqwest::multipart::Form::new();
197 if let Some(local_var_param_value) = description {
198 local_var_form = local_var_form.text("description", local_var_param_value.to_string());
199 }
200 if let Some(local_var_param_value) = email {
201 local_var_form = local_var_form.text("email", local_var_param_value.to_string());
202 }
203 if let Some(local_var_param_value) = os_version {
204 local_var_form = local_var_form.text("os_version", local_var_param_value.to_string());
205 }
206 if let Some(local_var_param_value) = os_logs {
207 let kind = infer::get_from_path(&local_var_param_value)?.map(|v| v.mime_type().to_string()).unwrap_or_else(|| "application/octet-stream".to_string());
208 let filebytes = tokio::fs::read(&local_var_param_value).await?;
209 let file_part = reqwest::multipart::Part::bytes(filebytes)
210 .file_name(local_var_param_value.display().to_string())
211 .mime_str(&kind)?;
212 local_var_form = local_var_form.part("os_logs", file_part);
213 }
214 if let Some(local_var_param_value) = browser_version {
215 local_var_form = local_var_form.text("browser_version", local_var_param_value.to_string());
216 }
217 if let Some(local_var_param_value) = browser_logs {
218 let kind = infer::get_from_path(&local_var_param_value)?.map(|v| v.mime_type().to_string()).unwrap_or_else(|| "application/octet-stream".to_string());
219 let filebytes = tokio::fs::read(&local_var_param_value).await?;
220 let file_part = reqwest::multipart::Part::bytes(filebytes)
221 .file_name(local_var_param_value.display().to_string())
222 .mime_str(&kind)?;
223 local_var_form = local_var_form.part("browser_logs", file_part);
224 }
225 if let Some(local_var_param_value) = serial {
226 local_var_form = local_var_form.text("serial", local_var_param_value.to_string());
227 }
228 if let Some(local_var_param_value) = posthog_session {
229 local_var_form = local_var_form.text("posthog_session", local_var_param_value.to_string());
230 }
231 if let Some(local_var_param_value) = status {
232 local_var_form = local_var_form.text("status", local_var_param_value.to_string());
233 }
234 if let Some(local_var_param_value) = support_comment {
235 local_var_form = local_var_form.text("support_comment", local_var_param_value.to_string());
236 }
237 if let Some(local_var_param_value) = pi {
238 local_var_form = local_var_form.text("pi", local_var_param_value.to_string());
239 }
240 local_var_req_builder = local_var_req_builder.multipart(local_var_form);
241
242 let local_var_req = local_var_req_builder.build()?;
243 let local_var_resp = local_var_client.execute(local_var_req).await?;
244
245 let local_var_status = local_var_resp.status();
246 let local_var_content = local_var_resp.text().await?;
247
248 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
249 serde_json::from_str(&local_var_content).map_err(Error::from)
250 } else {
251 let local_var_entity: Option<CrashReportsPartialUpdateError> = serde_json::from_str(&local_var_content).ok();
252 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
253 Err(Error::ResponseError(local_var_error))
254 }
255}
256
257pub async fn crash_reports_retrieve(configuration: &configuration::Configuration, id: &str) -> Result<crate::models::CrashReport, Error<CrashReportsRetrieveError>> {
258 let local_var_configuration = configuration;
259
260 let local_var_client = &local_var_configuration.client;
261
262 let local_var_uri_str = format!("{}/api/crash-reports/{id}/", local_var_configuration.base_path, id=crate::apis::urlencode(id));
263 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
264
265 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
266 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
267 }
268 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
269 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
270 };
271
272 let local_var_req = local_var_req_builder.build()?;
273 let local_var_resp = local_var_client.execute(local_var_req).await?;
274
275 let local_var_status = local_var_resp.status();
276 let local_var_content = local_var_resp.text().await?;
277
278 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
279 serde_json::from_str(&local_var_content).map_err(Error::from)
280 } else {
281 let local_var_entity: Option<CrashReportsRetrieveError> = serde_json::from_str(&local_var_content).ok();
282 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
283 Err(Error::ResponseError(local_var_error))
284 }
285}
286
287pub async fn crash_reports_update(configuration: &configuration::Configuration, id: &str, description: Option<&str>, email: Option<&str>, os_version: Option<&str>, os_logs: Option<std::path::PathBuf>, browser_version: Option<&str>, browser_logs: Option<std::path::PathBuf>, serial: Option<&str>, posthog_session: Option<&str>, status: Option<crate::models::CrashReportStatusEnum>, support_comment: Option<&str>, pi: Option<i32>) -> Result<crate::models::CrashReport, Error<CrashReportsUpdateError>> {
288 let local_var_configuration = configuration;
289
290 let local_var_client = &local_var_configuration.client;
291
292 let local_var_uri_str = format!("{}/api/crash-reports/{id}/", local_var_configuration.base_path, id=crate::apis::urlencode(id));
293 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
294
295 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
296 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
297 }
298 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
299 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
300 };
301 let mut local_var_form = reqwest::multipart::Form::new();
302 if let Some(local_var_param_value) = description {
303 local_var_form = local_var_form.text("description", local_var_param_value.to_string());
304 }
305 if let Some(local_var_param_value) = email {
306 local_var_form = local_var_form.text("email", local_var_param_value.to_string());
307 }
308 if let Some(local_var_param_value) = os_version {
309 local_var_form = local_var_form.text("os_version", local_var_param_value.to_string());
310 }
311 if let Some(local_var_param_value) = os_logs {
312 let kind = infer::get_from_path(&local_var_param_value)?.map(|v| v.mime_type().to_string()).unwrap_or_else(|| "application/octet-stream".to_string());
313 let filebytes = tokio::fs::read(&local_var_param_value).await?;
314 let file_part = reqwest::multipart::Part::bytes(filebytes)
315 .file_name(local_var_param_value.display().to_string())
316 .mime_str(&kind)?;
317 local_var_form = local_var_form.part("os_logs", file_part);
318 }
319 if let Some(local_var_param_value) = browser_version {
320 local_var_form = local_var_form.text("browser_version", local_var_param_value.to_string());
321 }
322 if let Some(local_var_param_value) = browser_logs {
323 let kind = infer::get_from_path(&local_var_param_value)?.map(|v| v.mime_type().to_string()).unwrap_or_else(|| "application/octet-stream".to_string());
324 let filebytes = tokio::fs::read(&local_var_param_value).await?;
325 let file_part = reqwest::multipart::Part::bytes(filebytes)
326 .file_name(local_var_param_value.display().to_string())
327 .mime_str(&kind)?;
328 local_var_form = local_var_form.part("browser_logs", file_part);
329 }
330 if let Some(local_var_param_value) = serial {
331 local_var_form = local_var_form.text("serial", local_var_param_value.to_string());
332 }
333 if let Some(local_var_param_value) = posthog_session {
334 local_var_form = local_var_form.text("posthog_session", local_var_param_value.to_string());
335 }
336 if let Some(local_var_param_value) = status {
337 local_var_form = local_var_form.text("status", local_var_param_value.to_string());
338 }
339 if let Some(local_var_param_value) = support_comment {
340 local_var_form = local_var_form.text("support_comment", local_var_param_value.to_string());
341 }
342 if let Some(local_var_param_value) = pi {
343 local_var_form = local_var_form.text("pi", local_var_param_value.to_string());
344 }
345 local_var_req_builder = local_var_req_builder.multipart(local_var_form);
346
347 let local_var_req = local_var_req_builder.build()?;
348 let local_var_resp = local_var_client.execute(local_var_req).await?;
349
350 let local_var_status = local_var_resp.status();
351 let local_var_content = local_var_resp.text().await?;
352
353 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
354 serde_json::from_str(&local_var_content).map_err(Error::from)
355 } else {
356 let local_var_entity: Option<CrashReportsUpdateError> = serde_json::from_str(&local_var_content).ok();
357 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
358 Err(Error::ResponseError(local_var_error))
359 }
360}
361