1use reqwest;
13
14use crate::apis::ResponseContent;
15use super::{Error, configuration};
16
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum BlockNewDomainError {
22 Status400(crate::models::ErrorModel),
23 UnknownValue(serde_json::Value),
24}
25
26#[derive(Debug, Clone, Serialize, Deserialize)]
28#[serde(untagged)]
29pub enum CreateSmtpTemplateError {
30 Status400(crate::models::ErrorModel),
31 UnknownValue(serde_json::Value),
32}
33
34#[derive(Debug, Clone, Serialize, Deserialize)]
36#[serde(untagged)]
37pub enum DeleteBlockedDomainError {
38 Status404(),
39 Status400(crate::models::ErrorModel),
40 UnknownValue(serde_json::Value),
41}
42
43#[derive(Debug, Clone, Serialize, Deserialize)]
45#[serde(untagged)]
46pub enum DeleteHardbouncesError {
47 Status400(crate::models::ErrorModel),
48 UnknownValue(serde_json::Value),
49}
50
51#[derive(Debug, Clone, Serialize, Deserialize)]
53#[serde(untagged)]
54pub enum DeleteSmtpTemplateError {
55 Status404(crate::models::ErrorModel),
56 Status400(crate::models::ErrorModel),
57 UnknownValue(serde_json::Value),
58}
59
60#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum GetAggregatedSmtpReportError {
64 Status400(crate::models::ErrorModel),
65 UnknownValue(serde_json::Value),
66}
67
68#[derive(Debug, Clone, Serialize, Deserialize)]
70#[serde(untagged)]
71pub enum GetBlockedDomainsError {
72 UnknownValue(serde_json::Value),
73}
74
75#[derive(Debug, Clone, Serialize, Deserialize)]
77#[serde(untagged)]
78pub enum GetEmailEventReportError {
79 Status400(crate::models::ErrorModel),
80 UnknownValue(serde_json::Value),
81}
82
83#[derive(Debug, Clone, Serialize, Deserialize)]
85#[serde(untagged)]
86pub enum GetSmtpReportError {
87 Status400(crate::models::ErrorModel),
88 UnknownValue(serde_json::Value),
89}
90
91#[derive(Debug, Clone, Serialize, Deserialize)]
93#[serde(untagged)]
94pub enum GetSmtpTemplateError {
95 Status404(crate::models::ErrorModel),
96 Status400(crate::models::ErrorModel),
97 UnknownValue(serde_json::Value),
98}
99
100#[derive(Debug, Clone, Serialize, Deserialize)]
102#[serde(untagged)]
103pub enum GetSmtpTemplatesError {
104 Status400(crate::models::ErrorModel),
105 UnknownValue(serde_json::Value),
106}
107
108#[derive(Debug, Clone, Serialize, Deserialize)]
110#[serde(untagged)]
111pub enum GetTransacBlockedContactsError {
112 Status400(crate::models::ErrorModel),
113 UnknownValue(serde_json::Value),
114}
115
116#[derive(Debug, Clone, Serialize, Deserialize)]
118#[serde(untagged)]
119pub enum GetTransacEmailContentError {
120 UnknownValue(serde_json::Value),
121}
122
123#[derive(Debug, Clone, Serialize, Deserialize)]
125#[serde(untagged)]
126pub enum GetTransacEmailsListError {
127 Status400(crate::models::ErrorModel),
128 UnknownValue(serde_json::Value),
129}
130
131#[derive(Debug, Clone, Serialize, Deserialize)]
133#[serde(untagged)]
134pub enum SendTemplateError {
135 Status400(crate::models::PostSendFailed),
136 Status404(crate::models::ErrorModel),
137 UnknownValue(serde_json::Value),
138}
139
140#[derive(Debug, Clone, Serialize, Deserialize)]
142#[serde(untagged)]
143pub enum SendTestTemplateError {
144 Status400(crate::models::PostSendFailed),
145 Status404(crate::models::ErrorModel),
146 UnknownValue(serde_json::Value),
147}
148
149#[derive(Debug, Clone, Serialize, Deserialize)]
151#[serde(untagged)]
152pub enum SendTransacEmailError {
153 Status400(crate::models::ErrorModel),
154 UnknownValue(serde_json::Value),
155}
156
157#[derive(Debug, Clone, Serialize, Deserialize)]
159#[serde(untagged)]
160pub enum SmtpBlockedContactsEmailDeleteError {
161 Status400(crate::models::ErrorModel),
162 Status404(crate::models::ErrorModel),
163 UnknownValue(serde_json::Value),
164}
165
166#[derive(Debug, Clone, Serialize, Deserialize)]
168#[serde(untagged)]
169pub enum SmtpLogMessageIdDeleteError {
170 Status404(crate::models::ErrorModel),
171 Status400(crate::models::ErrorModel),
172 UnknownValue(serde_json::Value),
173}
174
175#[derive(Debug, Clone, Serialize, Deserialize)]
177#[serde(untagged)]
178pub enum UpdateSmtpTemplateError {
179 Status400(crate::models::ErrorModel),
180 Status404(crate::models::ErrorModel),
181 UnknownValue(serde_json::Value),
182}
183
184
185pub async fn block_new_domain(configuration: &configuration::Configuration, block_domain: crate::models::BlockDomain) -> Result<(), Error<BlockNewDomainError>> {
187 let local_var_configuration = configuration;
188
189 let local_var_client = &local_var_configuration.client;
190
191 let local_var_uri_str = format!("{}/smtp/blockedDomains", local_var_configuration.base_path);
192 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
193
194 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
195 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
196 }
197 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
198 let local_var_key = local_var_apikey.key.clone();
199 let local_var_value = match local_var_apikey.prefix {
200 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
201 None => local_var_key,
202 };
203 local_var_req_builder = local_var_req_builder.header("api-key", local_var_value);
204 };
205 local_var_req_builder = local_var_req_builder.json(&block_domain);
206
207 let local_var_req = local_var_req_builder.build()?;
208 let local_var_resp = local_var_client.execute(local_var_req).await?;
209
210 let local_var_status = local_var_resp.status();
211 let local_var_content = local_var_resp.text().await?;
212
213 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
214 Ok(())
215 } else {
216 let local_var_entity: Option<BlockNewDomainError> = serde_json::from_str(&local_var_content).ok();
217 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
218 Err(Error::ResponseError(local_var_error))
219 }
220}
221
222pub async fn create_smtp_template(configuration: &configuration::Configuration, smtp_template: crate::models::CreateSmtpTemplate) -> Result<crate::models::CreateModel, Error<CreateSmtpTemplateError>> {
223 let local_var_configuration = configuration;
224
225 let local_var_client = &local_var_configuration.client;
226
227 let local_var_uri_str = format!("{}/smtp/templates", local_var_configuration.base_path);
228 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
229
230 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
231 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
232 }
233 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
234 let local_var_key = local_var_apikey.key.clone();
235 let local_var_value = match local_var_apikey.prefix {
236 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
237 None => local_var_key,
238 };
239 local_var_req_builder = local_var_req_builder.header("api-key", local_var_value);
240 };
241 local_var_req_builder = local_var_req_builder.json(&smtp_template);
242
243 let local_var_req = local_var_req_builder.build()?;
244 let local_var_resp = local_var_client.execute(local_var_req).await?;
245
246 let local_var_status = local_var_resp.status();
247 let local_var_content = local_var_resp.text().await?;
248
249 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
250 serde_json::from_str(&local_var_content).map_err(Error::from)
251 } else {
252 let local_var_entity: Option<CreateSmtpTemplateError> = serde_json::from_str(&local_var_content).ok();
253 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
254 Err(Error::ResponseError(local_var_error))
255 }
256}
257
258pub async fn delete_blocked_domain(configuration: &configuration::Configuration, domain: &str) -> Result<(), Error<DeleteBlockedDomainError>> {
260 let local_var_configuration = configuration;
261
262 let local_var_client = &local_var_configuration.client;
263
264 let local_var_uri_str = format!("{}/smtp/blockedDomains/{domain}", local_var_configuration.base_path, domain=crate::apis::urlencode(domain));
265 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
266
267 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
268 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
269 }
270 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
271 let local_var_key = local_var_apikey.key.clone();
272 let local_var_value = match local_var_apikey.prefix {
273 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
274 None => local_var_key,
275 };
276 local_var_req_builder = local_var_req_builder.header("api-key", local_var_value);
277 };
278
279 let local_var_req = local_var_req_builder.build()?;
280 let local_var_resp = local_var_client.execute(local_var_req).await?;
281
282 let local_var_status = local_var_resp.status();
283 let local_var_content = local_var_resp.text().await?;
284
285 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
286 Ok(())
287 } else {
288 let local_var_entity: Option<DeleteBlockedDomainError> = serde_json::from_str(&local_var_content).ok();
289 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
290 Err(Error::ResponseError(local_var_error))
291 }
292}
293
294pub async fn delete_hardbounces(configuration: &configuration::Configuration, delete_hardbounces: Option<crate::models::DeleteHardbounces>) -> Result<(), Error<DeleteHardbouncesError>> {
296 let local_var_configuration = configuration;
297
298 let local_var_client = &local_var_configuration.client;
299
300 let local_var_uri_str = format!("{}/smtp/deleteHardbounces", local_var_configuration.base_path);
301 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
302
303 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
304 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
305 }
306 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
307 let local_var_key = local_var_apikey.key.clone();
308 let local_var_value = match local_var_apikey.prefix {
309 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
310 None => local_var_key,
311 };
312 local_var_req_builder = local_var_req_builder.header("api-key", local_var_value);
313 };
314 local_var_req_builder = local_var_req_builder.json(&delete_hardbounces);
315
316 let local_var_req = local_var_req_builder.build()?;
317 let local_var_resp = local_var_client.execute(local_var_req).await?;
318
319 let local_var_status = local_var_resp.status();
320 let local_var_content = local_var_resp.text().await?;
321
322 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
323 Ok(())
324 } else {
325 let local_var_entity: Option<DeleteHardbouncesError> = serde_json::from_str(&local_var_content).ok();
326 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
327 Err(Error::ResponseError(local_var_error))
328 }
329}
330
331pub async fn delete_smtp_template(configuration: &configuration::Configuration, template_id: i64) -> Result<(), Error<DeleteSmtpTemplateError>> {
332 let local_var_configuration = configuration;
333
334 let local_var_client = &local_var_configuration.client;
335
336 let local_var_uri_str = format!("{}/smtp/templates/{templateId}", local_var_configuration.base_path, templateId=template_id);
337 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
338
339 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
340 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
341 }
342 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
343 let local_var_key = local_var_apikey.key.clone();
344 let local_var_value = match local_var_apikey.prefix {
345 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
346 None => local_var_key,
347 };
348 local_var_req_builder = local_var_req_builder.header("api-key", local_var_value);
349 };
350
351 let local_var_req = local_var_req_builder.build()?;
352 let local_var_resp = local_var_client.execute(local_var_req).await?;
353
354 let local_var_status = local_var_resp.status();
355 let local_var_content = local_var_resp.text().await?;
356
357 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
358 Ok(())
359 } else {
360 let local_var_entity: Option<DeleteSmtpTemplateError> = serde_json::from_str(&local_var_content).ok();
361 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
362 Err(Error::ResponseError(local_var_error))
363 }
364}
365
366pub async fn get_aggregated_smtp_report(configuration: &configuration::Configuration, start_date: Option<&str>, end_date: Option<&str>, days: Option<i32>, tag: Option<&str>) -> Result<crate::models::GetAggregatedReport, Error<GetAggregatedSmtpReportError>> {
367 let local_var_configuration = configuration;
368
369 let local_var_client = &local_var_configuration.client;
370
371 let local_var_uri_str = format!("{}/smtp/statistics/aggregatedReport", local_var_configuration.base_path);
372 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
373
374 if let Some(ref local_var_str) = start_date {
375 local_var_req_builder = local_var_req_builder.query(&[("startDate", &local_var_str.to_string())]);
376 }
377 if let Some(ref local_var_str) = end_date {
378 local_var_req_builder = local_var_req_builder.query(&[("endDate", &local_var_str.to_string())]);
379 }
380 if let Some(ref local_var_str) = days {
381 local_var_req_builder = local_var_req_builder.query(&[("days", &local_var_str.to_string())]);
382 }
383 if let Some(ref local_var_str) = tag {
384 local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
385 }
386 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
387 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
388 }
389 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
390 let local_var_key = local_var_apikey.key.clone();
391 let local_var_value = match local_var_apikey.prefix {
392 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
393 None => local_var_key,
394 };
395 local_var_req_builder = local_var_req_builder.header("api-key", local_var_value);
396 };
397
398 let local_var_req = local_var_req_builder.build()?;
399 let local_var_resp = local_var_client.execute(local_var_req).await?;
400
401 let local_var_status = local_var_resp.status();
402 let local_var_content = local_var_resp.text().await?;
403
404 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
405 serde_json::from_str(&local_var_content).map_err(Error::from)
406 } else {
407 let local_var_entity: Option<GetAggregatedSmtpReportError> = serde_json::from_str(&local_var_content).ok();
408 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
409 Err(Error::ResponseError(local_var_error))
410 }
411}
412
413pub async fn get_blocked_domains(configuration: &configuration::Configuration, ) -> Result<crate::models::GetBlockedDomains, Error<GetBlockedDomainsError>> {
415 let local_var_configuration = configuration;
416
417 let local_var_client = &local_var_configuration.client;
418
419 let local_var_uri_str = format!("{}/smtp/blockedDomains", local_var_configuration.base_path);
420 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
421
422 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
423 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
424 }
425 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
426 let local_var_key = local_var_apikey.key.clone();
427 let local_var_value = match local_var_apikey.prefix {
428 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
429 None => local_var_key,
430 };
431 local_var_req_builder = local_var_req_builder.header("api-key", local_var_value);
432 };
433
434 let local_var_req = local_var_req_builder.build()?;
435 let local_var_resp = local_var_client.execute(local_var_req).await?;
436
437 let local_var_status = local_var_resp.status();
438 let local_var_content = local_var_resp.text().await?;
439
440 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
441 serde_json::from_str(&local_var_content).map_err(Error::from)
442 } else {
443 let local_var_entity: Option<GetBlockedDomainsError> = serde_json::from_str(&local_var_content).ok();
444 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
445 Err(Error::ResponseError(local_var_error))
446 }
447}
448
449pub async fn get_email_event_report(configuration: &configuration::Configuration, limit: Option<i64>, offset: Option<i64>, start_date: Option<&str>, end_date: Option<&str>, days: Option<i32>, email: Option<&str>, event: Option<&str>, tags: Option<&str>, message_id: Option<&str>, template_id: Option<i64>) -> Result<crate::models::GetEmailEventReport, Error<GetEmailEventReportError>> {
450 let local_var_configuration = configuration;
451
452 let local_var_client = &local_var_configuration.client;
453
454 let local_var_uri_str = format!("{}/smtp/statistics/events", local_var_configuration.base_path);
455 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
456
457 if let Some(ref local_var_str) = limit {
458 local_var_req_builder = local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
459 }
460 if let Some(ref local_var_str) = offset {
461 local_var_req_builder = local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
462 }
463 if let Some(ref local_var_str) = start_date {
464 local_var_req_builder = local_var_req_builder.query(&[("startDate", &local_var_str.to_string())]);
465 }
466 if let Some(ref local_var_str) = end_date {
467 local_var_req_builder = local_var_req_builder.query(&[("endDate", &local_var_str.to_string())]);
468 }
469 if let Some(ref local_var_str) = days {
470 local_var_req_builder = local_var_req_builder.query(&[("days", &local_var_str.to_string())]);
471 }
472 if let Some(ref local_var_str) = email {
473 local_var_req_builder = local_var_req_builder.query(&[("email", &local_var_str.to_string())]);
474 }
475 if let Some(ref local_var_str) = event {
476 local_var_req_builder = local_var_req_builder.query(&[("event", &local_var_str.to_string())]);
477 }
478 if let Some(ref local_var_str) = tags {
479 local_var_req_builder = local_var_req_builder.query(&[("tags", &local_var_str.to_string())]);
480 }
481 if let Some(ref local_var_str) = message_id {
482 local_var_req_builder = local_var_req_builder.query(&[("messageId", &local_var_str.to_string())]);
483 }
484 if let Some(ref local_var_str) = template_id {
485 local_var_req_builder = local_var_req_builder.query(&[("templateId", &local_var_str.to_string())]);
486 }
487 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
488 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
489 }
490 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
491 let local_var_key = local_var_apikey.key.clone();
492 let local_var_value = match local_var_apikey.prefix {
493 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
494 None => local_var_key,
495 };
496 local_var_req_builder = local_var_req_builder.header("api-key", local_var_value);
497 };
498
499 let local_var_req = local_var_req_builder.build()?;
500 let local_var_resp = local_var_client.execute(local_var_req).await?;
501
502 let local_var_status = local_var_resp.status();
503 let local_var_content = local_var_resp.text().await?;
504
505 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
506 serde_json::from_str(&local_var_content).map_err(Error::from)
507 } else {
508 let local_var_entity: Option<GetEmailEventReportError> = serde_json::from_str(&local_var_content).ok();
509 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
510 Err(Error::ResponseError(local_var_error))
511 }
512}
513
514pub async fn get_smtp_report(configuration: &configuration::Configuration, limit: Option<i64>, offset: Option<i64>, start_date: Option<&str>, end_date: Option<&str>, days: Option<i32>, tag: Option<&str>) -> Result<crate::models::GetReports, Error<GetSmtpReportError>> {
515 let local_var_configuration = configuration;
516
517 let local_var_client = &local_var_configuration.client;
518
519 let local_var_uri_str = format!("{}/smtp/statistics/reports", local_var_configuration.base_path);
520 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
521
522 if let Some(ref local_var_str) = limit {
523 local_var_req_builder = local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
524 }
525 if let Some(ref local_var_str) = offset {
526 local_var_req_builder = local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
527 }
528 if let Some(ref local_var_str) = start_date {
529 local_var_req_builder = local_var_req_builder.query(&[("startDate", &local_var_str.to_string())]);
530 }
531 if let Some(ref local_var_str) = end_date {
532 local_var_req_builder = local_var_req_builder.query(&[("endDate", &local_var_str.to_string())]);
533 }
534 if let Some(ref local_var_str) = days {
535 local_var_req_builder = local_var_req_builder.query(&[("days", &local_var_str.to_string())]);
536 }
537 if let Some(ref local_var_str) = tag {
538 local_var_req_builder = local_var_req_builder.query(&[("tag", &local_var_str.to_string())]);
539 }
540 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
541 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
542 }
543 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
544 let local_var_key = local_var_apikey.key.clone();
545 let local_var_value = match local_var_apikey.prefix {
546 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
547 None => local_var_key,
548 };
549 local_var_req_builder = local_var_req_builder.header("api-key", local_var_value);
550 };
551
552 let local_var_req = local_var_req_builder.build()?;
553 let local_var_resp = local_var_client.execute(local_var_req).await?;
554
555 let local_var_status = local_var_resp.status();
556 let local_var_content = local_var_resp.text().await?;
557
558 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
559 serde_json::from_str(&local_var_content).map_err(Error::from)
560 } else {
561 let local_var_entity: Option<GetSmtpReportError> = serde_json::from_str(&local_var_content).ok();
562 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
563 Err(Error::ResponseError(local_var_error))
564 }
565}
566
567pub async fn get_smtp_template(configuration: &configuration::Configuration, template_id: i64) -> Result<crate::models::GetSmtpTemplateOverview, Error<GetSmtpTemplateError>> {
568 let local_var_configuration = configuration;
569
570 let local_var_client = &local_var_configuration.client;
571
572 let local_var_uri_str = format!("{}/smtp/templates/{templateId}", local_var_configuration.base_path, templateId=template_id);
573 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
574
575 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
576 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
577 }
578 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
579 let local_var_key = local_var_apikey.key.clone();
580 let local_var_value = match local_var_apikey.prefix {
581 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
582 None => local_var_key,
583 };
584 local_var_req_builder = local_var_req_builder.header("api-key", local_var_value);
585 };
586
587 let local_var_req = local_var_req_builder.build()?;
588 let local_var_resp = local_var_client.execute(local_var_req).await?;
589
590 let local_var_status = local_var_resp.status();
591 let local_var_content = local_var_resp.text().await?;
592
593 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
594 serde_json::from_str(&local_var_content).map_err(Error::from)
595 } else {
596 let local_var_entity: Option<GetSmtpTemplateError> = serde_json::from_str(&local_var_content).ok();
597 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
598 Err(Error::ResponseError(local_var_error))
599 }
600}
601
602pub async fn get_smtp_templates(configuration: &configuration::Configuration, template_status: Option<bool>, limit: Option<i64>, offset: Option<i64>) -> Result<crate::models::GetSmtpTemplates, Error<GetSmtpTemplatesError>> {
603 let local_var_configuration = configuration;
604
605 let local_var_client = &local_var_configuration.client;
606
607 let local_var_uri_str = format!("{}/smtp/templates", local_var_configuration.base_path);
608 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
609
610 if let Some(ref local_var_str) = template_status {
611 local_var_req_builder = local_var_req_builder.query(&[("templateStatus", &local_var_str.to_string())]);
612 }
613 if let Some(ref local_var_str) = limit {
614 local_var_req_builder = local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
615 }
616 if let Some(ref local_var_str) = offset {
617 local_var_req_builder = local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
618 }
619 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
620 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
621 }
622 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
623 let local_var_key = local_var_apikey.key.clone();
624 let local_var_value = match local_var_apikey.prefix {
625 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
626 None => local_var_key,
627 };
628 local_var_req_builder = local_var_req_builder.header("api-key", local_var_value);
629 };
630
631 let local_var_req = local_var_req_builder.build()?;
632 let local_var_resp = local_var_client.execute(local_var_req).await?;
633
634 let local_var_status = local_var_resp.status();
635 let local_var_content = local_var_resp.text().await?;
636
637 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
638 serde_json::from_str(&local_var_content).map_err(Error::from)
639 } else {
640 let local_var_entity: Option<GetSmtpTemplatesError> = serde_json::from_str(&local_var_content).ok();
641 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
642 Err(Error::ResponseError(local_var_error))
643 }
644}
645
646pub async fn get_transac_blocked_contacts(configuration: &configuration::Configuration, start_date: Option<&str>, end_date: Option<&str>, limit: Option<i64>, offset: Option<i64>, senders: Option<Vec<String>>) -> Result<crate::models::GetTransacBlockedContacts, Error<GetTransacBlockedContactsError>> {
647 let local_var_configuration = configuration;
648
649 let local_var_client = &local_var_configuration.client;
650
651 let local_var_uri_str = format!("{}/smtp/blockedContacts", local_var_configuration.base_path);
652 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
653
654 if let Some(ref local_var_str) = start_date {
655 local_var_req_builder = local_var_req_builder.query(&[("startDate", &local_var_str.to_string())]);
656 }
657 if let Some(ref local_var_str) = end_date {
658 local_var_req_builder = local_var_req_builder.query(&[("endDate", &local_var_str.to_string())]);
659 }
660 if let Some(ref local_var_str) = limit {
661 local_var_req_builder = local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
662 }
663 if let Some(ref local_var_str) = offset {
664 local_var_req_builder = local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
665 }
666 if let Some(ref local_var_str) = senders {
667 local_var_req_builder = match "csv" {
668 "multi" => local_var_req_builder.query(&local_var_str.into_iter().map(|p| ("senders".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
669 _ => local_var_req_builder.query(&[("senders", &local_var_str.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
670 };
671 }
672 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
673 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
674 }
675 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
676 let local_var_key = local_var_apikey.key.clone();
677 let local_var_value = match local_var_apikey.prefix {
678 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
679 None => local_var_key,
680 };
681 local_var_req_builder = local_var_req_builder.header("api-key", local_var_value);
682 };
683
684 let local_var_req = local_var_req_builder.build()?;
685 let local_var_resp = local_var_client.execute(local_var_req).await?;
686
687 let local_var_status = local_var_resp.status();
688 let local_var_content = local_var_resp.text().await?;
689
690 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
691 serde_json::from_str(&local_var_content).map_err(Error::from)
692 } else {
693 let local_var_entity: Option<GetTransacBlockedContactsError> = serde_json::from_str(&local_var_content).ok();
694 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
695 Err(Error::ResponseError(local_var_error))
696 }
697}
698
699pub async fn get_transac_email_content(configuration: &configuration::Configuration, uuid: &str) -> Result<crate::models::GetTransacEmailContent, Error<GetTransacEmailContentError>> {
700 let local_var_configuration = configuration;
701
702 let local_var_client = &local_var_configuration.client;
703
704 let local_var_uri_str = format!("{}/smtp/emails/{uuid}", local_var_configuration.base_path, uuid=crate::apis::urlencode(uuid));
705 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
706
707 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
708 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
709 }
710 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
711 let local_var_key = local_var_apikey.key.clone();
712 let local_var_value = match local_var_apikey.prefix {
713 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
714 None => local_var_key,
715 };
716 local_var_req_builder = local_var_req_builder.header("api-key", local_var_value);
717 };
718
719 let local_var_req = local_var_req_builder.build()?;
720 let local_var_resp = local_var_client.execute(local_var_req).await?;
721
722 let local_var_status = local_var_resp.status();
723 let local_var_content = local_var_resp.text().await?;
724
725 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
726 serde_json::from_str(&local_var_content).map_err(Error::from)
727 } else {
728 let local_var_entity: Option<GetTransacEmailContentError> = serde_json::from_str(&local_var_content).ok();
729 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
730 Err(Error::ResponseError(local_var_error))
731 }
732}
733
734pub async fn get_transac_emails_list(configuration: &configuration::Configuration, email: Option<&str>, template_id: Option<i64>, message_id: Option<&str>, start_date: Option<String>, end_date: Option<String>) -> Result<crate::models::GetTransacEmailsList, Error<GetTransacEmailsListError>> {
736 let local_var_configuration = configuration;
737
738 let local_var_client = &local_var_configuration.client;
739
740 let local_var_uri_str = format!("{}/smtp/emails", local_var_configuration.base_path);
741 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
742
743 if let Some(ref local_var_str) = email {
744 local_var_req_builder = local_var_req_builder.query(&[("email", &local_var_str.to_string())]);
745 }
746 if let Some(ref local_var_str) = template_id {
747 local_var_req_builder = local_var_req_builder.query(&[("templateId", &local_var_str.to_string())]);
748 }
749 if let Some(ref local_var_str) = message_id {
750 local_var_req_builder = local_var_req_builder.query(&[("messageId", &local_var_str.to_string())]);
751 }
752 if let Some(ref local_var_str) = start_date {
753 local_var_req_builder = local_var_req_builder.query(&[("startDate", &local_var_str.to_string())]);
754 }
755 if let Some(ref local_var_str) = end_date {
756 local_var_req_builder = local_var_req_builder.query(&[("endDate", &local_var_str.to_string())]);
757 }
758 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
759 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
760 }
761 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
762 let local_var_key = local_var_apikey.key.clone();
763 let local_var_value = match local_var_apikey.prefix {
764 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
765 None => local_var_key,
766 };
767 local_var_req_builder = local_var_req_builder.header("api-key", local_var_value);
768 };
769
770 let local_var_req = local_var_req_builder.build()?;
771 let local_var_resp = local_var_client.execute(local_var_req).await?;
772
773 let local_var_status = local_var_resp.status();
774 let local_var_content = local_var_resp.text().await?;
775
776 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
777 serde_json::from_str(&local_var_content).map_err(Error::from)
778 } else {
779 let local_var_entity: Option<GetTransacEmailsListError> = serde_json::from_str(&local_var_content).ok();
780 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
781 Err(Error::ResponseError(local_var_error))
782 }
783}
784
785pub async fn send_template(configuration: &configuration::Configuration, template_id: i64, send_email: crate::models::SendEmail) -> Result<crate::models::SendTemplateEmail, Error<SendTemplateError>> {
787 let local_var_configuration = configuration;
788
789 let local_var_client = &local_var_configuration.client;
790
791 let local_var_uri_str = format!("{}/smtp/templates/{templateId}/send", local_var_configuration.base_path, templateId=template_id);
792 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
793
794 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
795 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
796 }
797 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
798 let local_var_key = local_var_apikey.key.clone();
799 let local_var_value = match local_var_apikey.prefix {
800 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
801 None => local_var_key,
802 };
803 local_var_req_builder = local_var_req_builder.header("api-key", local_var_value);
804 };
805 local_var_req_builder = local_var_req_builder.json(&send_email);
806
807 let local_var_req = local_var_req_builder.build()?;
808 let local_var_resp = local_var_client.execute(local_var_req).await?;
809
810 let local_var_status = local_var_resp.status();
811 let local_var_content = local_var_resp.text().await?;
812
813 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
814 serde_json::from_str(&local_var_content).map_err(Error::from)
815 } else {
816 let local_var_entity: Option<SendTemplateError> = serde_json::from_str(&local_var_content).ok();
817 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
818 Err(Error::ResponseError(local_var_error))
819 }
820}
821
822pub async fn send_test_template(configuration: &configuration::Configuration, template_id: i64, send_test_email: crate::models::SendTestEmail) -> Result<(), Error<SendTestTemplateError>> {
823 let local_var_configuration = configuration;
824
825 let local_var_client = &local_var_configuration.client;
826
827 let local_var_uri_str = format!("{}/smtp/templates/{templateId}/sendTest", local_var_configuration.base_path, templateId=template_id);
828 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
829
830 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
831 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
832 }
833 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
834 let local_var_key = local_var_apikey.key.clone();
835 let local_var_value = match local_var_apikey.prefix {
836 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
837 None => local_var_key,
838 };
839 local_var_req_builder = local_var_req_builder.header("api-key", local_var_value);
840 };
841 local_var_req_builder = local_var_req_builder.json(&send_test_email);
842
843 let local_var_req = local_var_req_builder.build()?;
844 let local_var_resp = local_var_client.execute(local_var_req).await?;
845
846 let local_var_status = local_var_resp.status();
847 let local_var_content = local_var_resp.text().await?;
848
849 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
850 Ok(())
851 } else {
852 let local_var_entity: Option<SendTestTemplateError> = serde_json::from_str(&local_var_content).ok();
853 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
854 Err(Error::ResponseError(local_var_error))
855 }
856}
857
858pub async fn send_transac_email(configuration: &configuration::Configuration, send_smtp_email: crate::models::SendSmtpEmail) -> Result<crate::models::CreateSmtpEmail, Error<SendTransacEmailError>> {
859 let local_var_configuration = configuration;
860
861 let local_var_client = &local_var_configuration.client;
862
863 let local_var_uri_str = format!("{}/smtp/email", local_var_configuration.base_path);
864 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
865
866 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
867 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
868 }
869 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
870 let local_var_key = local_var_apikey.key.clone();
871 let local_var_value = match local_var_apikey.prefix {
872 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
873 None => local_var_key,
874 };
875 local_var_req_builder = local_var_req_builder.header("api-key", local_var_value);
876 };
877 local_var_req_builder = local_var_req_builder.json(&send_smtp_email);
878
879 let local_var_req = local_var_req_builder.build()?;
880 let local_var_resp = local_var_client.execute(local_var_req).await?;
881
882 let local_var_status = local_var_resp.status();
883 let local_var_content = local_var_resp.text().await?;
884
885 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
886 serde_json::from_str(&local_var_content).map_err(Error::from)
887 } else {
888 let local_var_entity: Option<SendTransacEmailError> = serde_json::from_str(&local_var_content).ok();
889 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
890 Err(Error::ResponseError(local_var_error))
891 }
892}
893
894pub async fn smtp_blocked_contacts_email_delete(configuration: &configuration::Configuration, email: &str) -> Result<(), Error<SmtpBlockedContactsEmailDeleteError>> {
895 let local_var_configuration = configuration;
896
897 let local_var_client = &local_var_configuration.client;
898
899 let local_var_uri_str = format!("{}/smtp/blockedContacts/{email}", local_var_configuration.base_path, email=crate::apis::urlencode(email));
900 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
901
902 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
903 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
904 }
905 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
906 let local_var_key = local_var_apikey.key.clone();
907 let local_var_value = match local_var_apikey.prefix {
908 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
909 None => local_var_key,
910 };
911 local_var_req_builder = local_var_req_builder.header("api-key", local_var_value);
912 };
913
914 let local_var_req = local_var_req_builder.build()?;
915 let local_var_resp = local_var_client.execute(local_var_req).await?;
916
917 let local_var_status = local_var_resp.status();
918 let local_var_content = local_var_resp.text().await?;
919
920 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
921 Ok(())
922 } else {
923 let local_var_entity: Option<SmtpBlockedContactsEmailDeleteError> = serde_json::from_str(&local_var_content).ok();
924 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
925 Err(Error::ResponseError(local_var_error))
926 }
927}
928
929pub async fn smtp_log_message_id_delete(configuration: &configuration::Configuration, message_id: &str) -> Result<(), Error<SmtpLogMessageIdDeleteError>> {
930 let local_var_configuration = configuration;
931
932 let local_var_client = &local_var_configuration.client;
933
934 let local_var_uri_str = format!("{}/smtp/log/{messageId}", local_var_configuration.base_path, messageId=crate::apis::urlencode(message_id));
935 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
936
937 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
938 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
939 }
940 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
941 let local_var_key = local_var_apikey.key.clone();
942 let local_var_value = match local_var_apikey.prefix {
943 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
944 None => local_var_key,
945 };
946 local_var_req_builder = local_var_req_builder.header("api-key", local_var_value);
947 };
948
949 let local_var_req = local_var_req_builder.build()?;
950 let local_var_resp = local_var_client.execute(local_var_req).await?;
951
952 let local_var_status = local_var_resp.status();
953 let local_var_content = local_var_resp.text().await?;
954
955 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
956 Ok(())
957 } else {
958 let local_var_entity: Option<SmtpLogMessageIdDeleteError> = serde_json::from_str(&local_var_content).ok();
959 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
960 Err(Error::ResponseError(local_var_error))
961 }
962}
963
964pub async fn update_smtp_template(configuration: &configuration::Configuration, template_id: i64, smtp_template: crate::models::UpdateSmtpTemplate) -> Result<(), Error<UpdateSmtpTemplateError>> {
965 let local_var_configuration = configuration;
966
967 let local_var_client = &local_var_configuration.client;
968
969 let local_var_uri_str = format!("{}/smtp/templates/{templateId}", local_var_configuration.base_path, templateId=template_id);
970 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
971
972 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
973 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
974 }
975 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
976 let local_var_key = local_var_apikey.key.clone();
977 let local_var_value = match local_var_apikey.prefix {
978 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
979 None => local_var_key,
980 };
981 local_var_req_builder = local_var_req_builder.header("api-key", local_var_value);
982 };
983 local_var_req_builder = local_var_req_builder.json(&smtp_template);
984
985 let local_var_req = local_var_req_builder.build()?;
986 let local_var_resp = local_var_client.execute(local_var_req).await?;
987
988 let local_var_status = local_var_resp.status();
989 let local_var_content = local_var_resp.text().await?;
990
991 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
992 Ok(())
993 } else {
994 let local_var_entity: Option<UpdateSmtpTemplateError> = serde_json::from_str(&local_var_content).ok();
995 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
996 Err(Error::ResponseError(local_var_error))
997 }
998}
999