twilio_rust_openapi/apis/
api20100401_message_api.rs1use reqwest;
13use serde::{Deserialize, Serialize};
14use crate::{apis::ResponseContent, models};
15use super::{Error, configuration};
16
17#[derive(Clone, Debug)]
19pub struct CreateMessageParams {
20 pub account_sid: String,
22 pub to: String,
24 pub status_callback: Option<String>,
26 pub application_sid: Option<String>,
28 pub max_price: Option<f64>,
30 pub provide_feedback: Option<bool>,
32 pub attempt: Option<i32>,
34 pub validity_period: Option<i32>,
36 pub force_delivery: Option<bool>,
38 pub content_retention: Option<String>,
39 pub address_retention: Option<String>,
40 pub smart_encoded: Option<bool>,
42 pub persistent_action: Option<Vec<String>>,
44 pub shorten_urls: Option<bool>,
46 pub schedule_type: Option<String>,
47 pub send_at: Option<String>,
49 pub send_as_mms: Option<bool>,
51 pub content_variables: Option<String>,
53 pub risk_check: Option<String>,
54 pub from: Option<String>,
56 pub messaging_service_sid: Option<String>,
58 pub body: Option<String>,
60 pub media_url: Option<Vec<String>>,
62 pub content_sid: Option<String>
64}
65
66#[derive(Clone, Debug)]
68pub struct DeleteMessageParams {
69 pub account_sid: String,
71 pub sid: String
73}
74
75#[derive(Clone, Debug)]
77pub struct FetchMessageParams {
78 pub account_sid: String,
80 pub sid: String
82}
83
84#[derive(Clone, Debug)]
86pub struct ListMessageParams {
87 pub account_sid: String,
89 pub to: Option<String>,
91 pub from: Option<String>,
93 pub date_sent: Option<String>,
95 pub date_sent_less_than: Option<String>,
97 pub date_sent_greater_than: Option<String>,
99 pub page_size: Option<i32>,
101 pub page: Option<i32>,
103 pub page_token: Option<String>
105}
106
107#[derive(Clone, Debug)]
109pub struct UpdateMessageParams {
110 pub account_sid: String,
112 pub sid: String,
114 pub body: Option<String>,
116 pub status: Option<String>
117}
118
119
120#[derive(Debug, Clone, Serialize, Deserialize)]
122#[serde(untagged)]
123pub enum CreateMessageError {
124 UnknownValue(serde_json::Value),
125}
126
127#[derive(Debug, Clone, Serialize, Deserialize)]
129#[serde(untagged)]
130pub enum DeleteMessageError {
131 UnknownValue(serde_json::Value),
132}
133
134#[derive(Debug, Clone, Serialize, Deserialize)]
136#[serde(untagged)]
137pub enum FetchMessageError {
138 UnknownValue(serde_json::Value),
139}
140
141#[derive(Debug, Clone, Serialize, Deserialize)]
143#[serde(untagged)]
144pub enum ListMessageError {
145 UnknownValue(serde_json::Value),
146}
147
148#[derive(Debug, Clone, Serialize, Deserialize)]
150#[serde(untagged)]
151pub enum UpdateMessageError {
152 UnknownValue(serde_json::Value),
153}
154
155
156pub async fn create_message(configuration: &configuration::Configuration, params: CreateMessageParams) -> Result<models::ApiPeriodV2010PeriodAccountPeriodMessage, Error<CreateMessageError>> {
158 let local_var_configuration = configuration;
159
160 let account_sid = params.account_sid;
162 let to = params.to;
163 let status_callback = params.status_callback;
164 let application_sid = params.application_sid;
165 let max_price = params.max_price;
166 let provide_feedback = params.provide_feedback;
167 let attempt = params.attempt;
168 let validity_period = params.validity_period;
169 let force_delivery = params.force_delivery;
170 let content_retention = params.content_retention;
171 let address_retention = params.address_retention;
172 let smart_encoded = params.smart_encoded;
173 let persistent_action = params.persistent_action;
174 let shorten_urls = params.shorten_urls;
175 let schedule_type = params.schedule_type;
176 let send_at = params.send_at;
177 let send_as_mms = params.send_as_mms;
178 let content_variables = params.content_variables;
179 let risk_check = params.risk_check;
180 let from = params.from;
181 let messaging_service_sid = params.messaging_service_sid;
182 let body = params.body;
183 let media_url = params.media_url;
184 let content_sid = params.content_sid;
185
186
187 let local_var_client = &local_var_configuration.client;
188
189 let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Messages.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
190 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
191
192 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
193 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
194 }
195 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
196 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
197 };
198 let mut local_var_form_params = std::collections::HashMap::new();
199 local_var_form_params.insert("To", to.to_string());
200 if let Some(local_var_param_value) = status_callback {
201 local_var_form_params.insert("StatusCallback", local_var_param_value.to_string());
202 }
203 if let Some(local_var_param_value) = application_sid {
204 local_var_form_params.insert("ApplicationSid", local_var_param_value.to_string());
205 }
206 if let Some(local_var_param_value) = max_price {
207 local_var_form_params.insert("MaxPrice", local_var_param_value.to_string());
208 }
209 if let Some(local_var_param_value) = provide_feedback {
210 local_var_form_params.insert("ProvideFeedback", local_var_param_value.to_string());
211 }
212 if let Some(local_var_param_value) = attempt {
213 local_var_form_params.insert("Attempt", local_var_param_value.to_string());
214 }
215 if let Some(local_var_param_value) = validity_period {
216 local_var_form_params.insert("ValidityPeriod", local_var_param_value.to_string());
217 }
218 if let Some(local_var_param_value) = force_delivery {
219 local_var_form_params.insert("ForceDelivery", local_var_param_value.to_string());
220 }
221 if let Some(local_var_param_value) = content_retention {
222 local_var_form_params.insert("ContentRetention", local_var_param_value.to_string());
223 }
224 if let Some(local_var_param_value) = address_retention {
225 local_var_form_params.insert("AddressRetention", local_var_param_value.to_string());
226 }
227 if let Some(local_var_param_value) = smart_encoded {
228 local_var_form_params.insert("SmartEncoded", local_var_param_value.to_string());
229 }
230 if let Some(local_var_param_value) = persistent_action {
231 local_var_form_params.insert("PersistentAction", local_var_param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string());
232 }
233 if let Some(local_var_param_value) = shorten_urls {
234 local_var_form_params.insert("ShortenUrls", local_var_param_value.to_string());
235 }
236 if let Some(local_var_param_value) = schedule_type {
237 local_var_form_params.insert("ScheduleType", local_var_param_value.to_string());
238 }
239 if let Some(local_var_param_value) = send_at {
240 local_var_form_params.insert("SendAt", local_var_param_value.to_string());
241 }
242 if let Some(local_var_param_value) = send_as_mms {
243 local_var_form_params.insert("SendAsMms", local_var_param_value.to_string());
244 }
245 if let Some(local_var_param_value) = content_variables {
246 local_var_form_params.insert("ContentVariables", local_var_param_value.to_string());
247 }
248 if let Some(local_var_param_value) = risk_check {
249 local_var_form_params.insert("RiskCheck", local_var_param_value.to_string());
250 }
251 if let Some(local_var_param_value) = from {
252 local_var_form_params.insert("From", local_var_param_value.to_string());
253 }
254 if let Some(local_var_param_value) = messaging_service_sid {
255 local_var_form_params.insert("MessagingServiceSid", local_var_param_value.to_string());
256 }
257 if let Some(local_var_param_value) = body {
258 local_var_form_params.insert("Body", local_var_param_value.to_string());
259 }
260 if let Some(local_var_param_value) = media_url {
261 local_var_form_params.insert("MediaUrl", local_var_param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string());
262 }
263 if let Some(local_var_param_value) = content_sid {
264 local_var_form_params.insert("ContentSid", local_var_param_value.to_string());
265 }
266 local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
267
268 let local_var_req = local_var_req_builder.build()?;
269 let local_var_resp = local_var_client.execute(local_var_req).await?;
270
271 let local_var_status = local_var_resp.status();
272 let local_var_content = local_var_resp.text().await?;
273
274 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
275 serde_json::from_str(&local_var_content).map_err(Error::from)
276 } else {
277 let local_var_entity: Option<CreateMessageError> = serde_json::from_str(&local_var_content).ok();
278 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
279 Err(Error::ResponseError(local_var_error))
280 }
281}
282
283pub async fn delete_message(configuration: &configuration::Configuration, params: DeleteMessageParams) -> Result<(), Error<DeleteMessageError>> {
285 let local_var_configuration = configuration;
286
287 let account_sid = params.account_sid;
289 let sid = params.sid;
290
291
292 let local_var_client = &local_var_configuration.client;
293
294 let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Messages/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
295 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
296
297 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
298 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
299 }
300 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
301 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
302 };
303
304 let local_var_req = local_var_req_builder.build()?;
305 let local_var_resp = local_var_client.execute(local_var_req).await?;
306
307 let local_var_status = local_var_resp.status();
308 let local_var_content = local_var_resp.text().await?;
309
310 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
311 Ok(())
312 } else {
313 let local_var_entity: Option<DeleteMessageError> = serde_json::from_str(&local_var_content).ok();
314 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
315 Err(Error::ResponseError(local_var_error))
316 }
317}
318
319pub async fn fetch_message(configuration: &configuration::Configuration, params: FetchMessageParams) -> Result<models::ApiPeriodV2010PeriodAccountPeriodMessage, Error<FetchMessageError>> {
321 let local_var_configuration = configuration;
322
323 let account_sid = params.account_sid;
325 let sid = params.sid;
326
327
328 let local_var_client = &local_var_configuration.client;
329
330 let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Messages/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
331 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
332
333 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
334 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
335 }
336 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
337 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
338 };
339
340 let local_var_req = local_var_req_builder.build()?;
341 let local_var_resp = local_var_client.execute(local_var_req).await?;
342
343 let local_var_status = local_var_resp.status();
344 let local_var_content = local_var_resp.text().await?;
345
346 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
347 serde_json::from_str(&local_var_content).map_err(Error::from)
348 } else {
349 let local_var_entity: Option<FetchMessageError> = serde_json::from_str(&local_var_content).ok();
350 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
351 Err(Error::ResponseError(local_var_error))
352 }
353}
354
355pub async fn list_message(configuration: &configuration::Configuration, params: ListMessageParams) -> Result<models::ListMessageResponse, Error<ListMessageError>> {
357 let local_var_configuration = configuration;
358
359 let account_sid = params.account_sid;
361 let to = params.to;
362 let from = params.from;
363 let date_sent = params.date_sent;
364 let date_sent_less_than = params.date_sent_less_than;
365 let date_sent_greater_than = params.date_sent_greater_than;
366 let page_size = params.page_size;
367 let page = params.page;
368 let page_token = params.page_token;
369
370
371 let local_var_client = &local_var_configuration.client;
372
373 let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Messages.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
374 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
375
376 if let Some(ref local_var_str) = to {
377 local_var_req_builder = local_var_req_builder.query(&[("To", &local_var_str.to_string())]);
378 }
379 if let Some(ref local_var_str) = from {
380 local_var_req_builder = local_var_req_builder.query(&[("From", &local_var_str.to_string())]);
381 }
382 if let Some(ref local_var_str) = date_sent {
383 local_var_req_builder = local_var_req_builder.query(&[("DateSent", &local_var_str.to_string())]);
384 }
385 if let Some(ref local_var_str) = date_sent_less_than {
386 local_var_req_builder = local_var_req_builder.query(&[("DateSent<", &local_var_str.to_string())]);
387 }
388 if let Some(ref local_var_str) = date_sent_greater_than {
389 local_var_req_builder = local_var_req_builder.query(&[("DateSent>", &local_var_str.to_string())]);
390 }
391 if let Some(ref local_var_str) = page_size {
392 local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
393 }
394 if let Some(ref local_var_str) = page {
395 local_var_req_builder = local_var_req_builder.query(&[("Page", &local_var_str.to_string())]);
396 }
397 if let Some(ref local_var_str) = page_token {
398 local_var_req_builder = local_var_req_builder.query(&[("PageToken", &local_var_str.to_string())]);
399 }
400 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
401 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
402 }
403 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
404 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
405 };
406
407 let local_var_req = local_var_req_builder.build()?;
408 let local_var_resp = local_var_client.execute(local_var_req).await?;
409
410 let local_var_status = local_var_resp.status();
411 let local_var_content = local_var_resp.text().await?;
412
413 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
414 serde_json::from_str(&local_var_content).map_err(Error::from)
415 } else {
416 let local_var_entity: Option<ListMessageError> = serde_json::from_str(&local_var_content).ok();
417 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
418 Err(Error::ResponseError(local_var_error))
419 }
420}
421
422pub async fn update_message(configuration: &configuration::Configuration, params: UpdateMessageParams) -> Result<models::ApiPeriodV2010PeriodAccountPeriodMessage, Error<UpdateMessageError>> {
424 let local_var_configuration = configuration;
425
426 let account_sid = params.account_sid;
428 let sid = params.sid;
429 let body = params.body;
430 let status = params.status;
431
432
433 let local_var_client = &local_var_configuration.client;
434
435 let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Messages/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
436 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
437
438 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
439 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
440 }
441 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
442 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
443 };
444 let mut local_var_form_params = std::collections::HashMap::new();
445 if let Some(local_var_param_value) = body {
446 local_var_form_params.insert("Body", local_var_param_value.to_string());
447 }
448 if let Some(local_var_param_value) = status {
449 local_var_form_params.insert("Status", local_var_param_value.to_string());
450 }
451 local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
452
453 let local_var_req = local_var_req_builder.build()?;
454 let local_var_resp = local_var_client.execute(local_var_req).await?;
455
456 let local_var_status = local_var_resp.status();
457 let local_var_content = local_var_resp.text().await?;
458
459 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
460 serde_json::from_str(&local_var_content).map_err(Error::from)
461 } else {
462 let local_var_entity: Option<UpdateMessageError> = serde_json::from_str(&local_var_content).ok();
463 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
464 Err(Error::ResponseError(local_var_error))
465 }
466}
467