twilio_rust_openapi/apis/
api20100401_application_api.rs1use reqwest;
13use serde::{Deserialize, Serialize};
14use crate::{apis::ResponseContent, models};
15use super::{Error, configuration};
16
17#[derive(Clone, Debug)]
19pub struct CreateApplicationParams {
20 pub account_sid: String,
22 pub api_version: Option<String>,
24 pub voice_url: Option<String>,
26 pub voice_method: Option<String>,
28 pub voice_fallback_url: Option<String>,
30 pub voice_fallback_method: Option<String>,
32 pub status_callback: Option<String>,
34 pub status_callback_method: Option<String>,
36 pub voice_caller_id_lookup: Option<bool>,
38 pub sms_url: Option<String>,
40 pub sms_method: Option<String>,
42 pub sms_fallback_url: Option<String>,
44 pub sms_fallback_method: Option<String>,
46 pub sms_status_callback: Option<String>,
48 pub message_status_callback: Option<String>,
50 pub friendly_name: Option<String>,
52 pub public_application_connect_enabled: Option<bool>
54}
55
56#[derive(Clone, Debug)]
58pub struct DeleteApplicationParams {
59 pub account_sid: String,
61 pub sid: String
63}
64
65#[derive(Clone, Debug)]
67pub struct FetchApplicationParams {
68 pub account_sid: String,
70 pub sid: String
72}
73
74#[derive(Clone, Debug)]
76pub struct ListApplicationParams {
77 pub account_sid: String,
79 pub friendly_name: Option<String>,
81 pub page_size: Option<i32>,
83 pub page: Option<i32>,
85 pub page_token: Option<String>
87}
88
89#[derive(Clone, Debug)]
91pub struct UpdateApplicationParams {
92 pub account_sid: String,
94 pub sid: String,
96 pub friendly_name: Option<String>,
98 pub api_version: Option<String>,
100 pub voice_url: Option<String>,
102 pub voice_method: Option<String>,
104 pub voice_fallback_url: Option<String>,
106 pub voice_fallback_method: Option<String>,
108 pub status_callback: Option<String>,
110 pub status_callback_method: Option<String>,
112 pub voice_caller_id_lookup: Option<bool>,
114 pub sms_url: Option<String>,
116 pub sms_method: Option<String>,
118 pub sms_fallback_url: Option<String>,
120 pub sms_fallback_method: Option<String>,
122 pub sms_status_callback: Option<String>,
124 pub message_status_callback: Option<String>,
126 pub public_application_connect_enabled: Option<bool>
128}
129
130
131#[derive(Debug, Clone, Serialize, Deserialize)]
133#[serde(untagged)]
134pub enum CreateApplicationError {
135 UnknownValue(serde_json::Value),
136}
137
138#[derive(Debug, Clone, Serialize, Deserialize)]
140#[serde(untagged)]
141pub enum DeleteApplicationError {
142 UnknownValue(serde_json::Value),
143}
144
145#[derive(Debug, Clone, Serialize, Deserialize)]
147#[serde(untagged)]
148pub enum FetchApplicationError {
149 UnknownValue(serde_json::Value),
150}
151
152#[derive(Debug, Clone, Serialize, Deserialize)]
154#[serde(untagged)]
155pub enum ListApplicationError {
156 UnknownValue(serde_json::Value),
157}
158
159#[derive(Debug, Clone, Serialize, Deserialize)]
161#[serde(untagged)]
162pub enum UpdateApplicationError {
163 UnknownValue(serde_json::Value),
164}
165
166
167pub async fn create_application(configuration: &configuration::Configuration, params: CreateApplicationParams) -> Result<models::ApiPeriodV2010PeriodAccountPeriodApplication, Error<CreateApplicationError>> {
169 let local_var_configuration = configuration;
170
171 let account_sid = params.account_sid;
173 let api_version = params.api_version;
174 let voice_url = params.voice_url;
175 let voice_method = params.voice_method;
176 let voice_fallback_url = params.voice_fallback_url;
177 let voice_fallback_method = params.voice_fallback_method;
178 let status_callback = params.status_callback;
179 let status_callback_method = params.status_callback_method;
180 let voice_caller_id_lookup = params.voice_caller_id_lookup;
181 let sms_url = params.sms_url;
182 let sms_method = params.sms_method;
183 let sms_fallback_url = params.sms_fallback_url;
184 let sms_fallback_method = params.sms_fallback_method;
185 let sms_status_callback = params.sms_status_callback;
186 let message_status_callback = params.message_status_callback;
187 let friendly_name = params.friendly_name;
188 let public_application_connect_enabled = params.public_application_connect_enabled;
189
190
191 let local_var_client = &local_var_configuration.client;
192
193 let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Applications.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
194 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
195
196 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
197 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
198 }
199 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
200 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
201 };
202 let mut local_var_form_params = std::collections::HashMap::new();
203 if let Some(local_var_param_value) = api_version {
204 local_var_form_params.insert("ApiVersion", local_var_param_value.to_string());
205 }
206 if let Some(local_var_param_value) = voice_url {
207 local_var_form_params.insert("VoiceUrl", local_var_param_value.to_string());
208 }
209 if let Some(local_var_param_value) = voice_method {
210 local_var_form_params.insert("VoiceMethod", local_var_param_value.to_string());
211 }
212 if let Some(local_var_param_value) = voice_fallback_url {
213 local_var_form_params.insert("VoiceFallbackUrl", local_var_param_value.to_string());
214 }
215 if let Some(local_var_param_value) = voice_fallback_method {
216 local_var_form_params.insert("VoiceFallbackMethod", local_var_param_value.to_string());
217 }
218 if let Some(local_var_param_value) = status_callback {
219 local_var_form_params.insert("StatusCallback", local_var_param_value.to_string());
220 }
221 if let Some(local_var_param_value) = status_callback_method {
222 local_var_form_params.insert("StatusCallbackMethod", local_var_param_value.to_string());
223 }
224 if let Some(local_var_param_value) = voice_caller_id_lookup {
225 local_var_form_params.insert("VoiceCallerIdLookup", local_var_param_value.to_string());
226 }
227 if let Some(local_var_param_value) = sms_url {
228 local_var_form_params.insert("SmsUrl", local_var_param_value.to_string());
229 }
230 if let Some(local_var_param_value) = sms_method {
231 local_var_form_params.insert("SmsMethod", local_var_param_value.to_string());
232 }
233 if let Some(local_var_param_value) = sms_fallback_url {
234 local_var_form_params.insert("SmsFallbackUrl", local_var_param_value.to_string());
235 }
236 if let Some(local_var_param_value) = sms_fallback_method {
237 local_var_form_params.insert("SmsFallbackMethod", local_var_param_value.to_string());
238 }
239 if let Some(local_var_param_value) = sms_status_callback {
240 local_var_form_params.insert("SmsStatusCallback", local_var_param_value.to_string());
241 }
242 if let Some(local_var_param_value) = message_status_callback {
243 local_var_form_params.insert("MessageStatusCallback", local_var_param_value.to_string());
244 }
245 if let Some(local_var_param_value) = friendly_name {
246 local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
247 }
248 if let Some(local_var_param_value) = public_application_connect_enabled {
249 local_var_form_params.insert("PublicApplicationConnectEnabled", local_var_param_value.to_string());
250 }
251 local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
252
253 let local_var_req = local_var_req_builder.build()?;
254 let local_var_resp = local_var_client.execute(local_var_req).await?;
255
256 let local_var_status = local_var_resp.status();
257 let local_var_content = local_var_resp.text().await?;
258
259 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
260 serde_json::from_str(&local_var_content).map_err(Error::from)
261 } else {
262 let local_var_entity: Option<CreateApplicationError> = serde_json::from_str(&local_var_content).ok();
263 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
264 Err(Error::ResponseError(local_var_error))
265 }
266}
267
268pub async fn delete_application(configuration: &configuration::Configuration, params: DeleteApplicationParams) -> Result<(), Error<DeleteApplicationError>> {
270 let local_var_configuration = configuration;
271
272 let account_sid = params.account_sid;
274 let sid = params.sid;
275
276
277 let local_var_client = &local_var_configuration.client;
278
279 let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Applications/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
280 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
281
282 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
283 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
284 }
285 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
286 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
287 };
288
289 let local_var_req = local_var_req_builder.build()?;
290 let local_var_resp = local_var_client.execute(local_var_req).await?;
291
292 let local_var_status = local_var_resp.status();
293 let local_var_content = local_var_resp.text().await?;
294
295 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
296 Ok(())
297 } else {
298 let local_var_entity: Option<DeleteApplicationError> = serde_json::from_str(&local_var_content).ok();
299 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
300 Err(Error::ResponseError(local_var_error))
301 }
302}
303
304pub async fn fetch_application(configuration: &configuration::Configuration, params: FetchApplicationParams) -> Result<models::ApiPeriodV2010PeriodAccountPeriodApplication, Error<FetchApplicationError>> {
306 let local_var_configuration = configuration;
307
308 let account_sid = params.account_sid;
310 let sid = params.sid;
311
312
313 let local_var_client = &local_var_configuration.client;
314
315 let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Applications/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
316 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
317
318 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
319 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
320 }
321 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
322 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
323 };
324
325 let local_var_req = local_var_req_builder.build()?;
326 let local_var_resp = local_var_client.execute(local_var_req).await?;
327
328 let local_var_status = local_var_resp.status();
329 let local_var_content = local_var_resp.text().await?;
330
331 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
332 serde_json::from_str(&local_var_content).map_err(Error::from)
333 } else {
334 let local_var_entity: Option<FetchApplicationError> = serde_json::from_str(&local_var_content).ok();
335 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
336 Err(Error::ResponseError(local_var_error))
337 }
338}
339
340pub async fn list_application(configuration: &configuration::Configuration, params: ListApplicationParams) -> Result<models::ListApplicationResponse, Error<ListApplicationError>> {
342 let local_var_configuration = configuration;
343
344 let account_sid = params.account_sid;
346 let friendly_name = params.friendly_name;
347 let page_size = params.page_size;
348 let page = params.page;
349 let page_token = params.page_token;
350
351
352 let local_var_client = &local_var_configuration.client;
353
354 let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Applications.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
355 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
356
357 if let Some(ref local_var_str) = friendly_name {
358 local_var_req_builder = local_var_req_builder.query(&[("FriendlyName", &local_var_str.to_string())]);
359 }
360 if let Some(ref local_var_str) = page_size {
361 local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
362 }
363 if let Some(ref local_var_str) = page {
364 local_var_req_builder = local_var_req_builder.query(&[("Page", &local_var_str.to_string())]);
365 }
366 if let Some(ref local_var_str) = page_token {
367 local_var_req_builder = local_var_req_builder.query(&[("PageToken", &local_var_str.to_string())]);
368 }
369 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
370 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
371 }
372 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
373 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
374 };
375
376 let local_var_req = local_var_req_builder.build()?;
377 let local_var_resp = local_var_client.execute(local_var_req).await?;
378
379 let local_var_status = local_var_resp.status();
380 let local_var_content = local_var_resp.text().await?;
381
382 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
383 serde_json::from_str(&local_var_content).map_err(Error::from)
384 } else {
385 let local_var_entity: Option<ListApplicationError> = serde_json::from_str(&local_var_content).ok();
386 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
387 Err(Error::ResponseError(local_var_error))
388 }
389}
390
391pub async fn update_application(configuration: &configuration::Configuration, params: UpdateApplicationParams) -> Result<models::ApiPeriodV2010PeriodAccountPeriodApplication, Error<UpdateApplicationError>> {
393 let local_var_configuration = configuration;
394
395 let account_sid = params.account_sid;
397 let sid = params.sid;
398 let friendly_name = params.friendly_name;
399 let api_version = params.api_version;
400 let voice_url = params.voice_url;
401 let voice_method = params.voice_method;
402 let voice_fallback_url = params.voice_fallback_url;
403 let voice_fallback_method = params.voice_fallback_method;
404 let status_callback = params.status_callback;
405 let status_callback_method = params.status_callback_method;
406 let voice_caller_id_lookup = params.voice_caller_id_lookup;
407 let sms_url = params.sms_url;
408 let sms_method = params.sms_method;
409 let sms_fallback_url = params.sms_fallback_url;
410 let sms_fallback_method = params.sms_fallback_method;
411 let sms_status_callback = params.sms_status_callback;
412 let message_status_callback = params.message_status_callback;
413 let public_application_connect_enabled = params.public_application_connect_enabled;
414
415
416 let local_var_client = &local_var_configuration.client;
417
418 let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Applications/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
419 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
420
421 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
422 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
423 }
424 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
425 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
426 };
427 let mut local_var_form_params = std::collections::HashMap::new();
428 if let Some(local_var_param_value) = friendly_name {
429 local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
430 }
431 if let Some(local_var_param_value) = api_version {
432 local_var_form_params.insert("ApiVersion", local_var_param_value.to_string());
433 }
434 if let Some(local_var_param_value) = voice_url {
435 local_var_form_params.insert("VoiceUrl", local_var_param_value.to_string());
436 }
437 if let Some(local_var_param_value) = voice_method {
438 local_var_form_params.insert("VoiceMethod", local_var_param_value.to_string());
439 }
440 if let Some(local_var_param_value) = voice_fallback_url {
441 local_var_form_params.insert("VoiceFallbackUrl", local_var_param_value.to_string());
442 }
443 if let Some(local_var_param_value) = voice_fallback_method {
444 local_var_form_params.insert("VoiceFallbackMethod", local_var_param_value.to_string());
445 }
446 if let Some(local_var_param_value) = status_callback {
447 local_var_form_params.insert("StatusCallback", local_var_param_value.to_string());
448 }
449 if let Some(local_var_param_value) = status_callback_method {
450 local_var_form_params.insert("StatusCallbackMethod", local_var_param_value.to_string());
451 }
452 if let Some(local_var_param_value) = voice_caller_id_lookup {
453 local_var_form_params.insert("VoiceCallerIdLookup", local_var_param_value.to_string());
454 }
455 if let Some(local_var_param_value) = sms_url {
456 local_var_form_params.insert("SmsUrl", local_var_param_value.to_string());
457 }
458 if let Some(local_var_param_value) = sms_method {
459 local_var_form_params.insert("SmsMethod", local_var_param_value.to_string());
460 }
461 if let Some(local_var_param_value) = sms_fallback_url {
462 local_var_form_params.insert("SmsFallbackUrl", local_var_param_value.to_string());
463 }
464 if let Some(local_var_param_value) = sms_fallback_method {
465 local_var_form_params.insert("SmsFallbackMethod", local_var_param_value.to_string());
466 }
467 if let Some(local_var_param_value) = sms_status_callback {
468 local_var_form_params.insert("SmsStatusCallback", local_var_param_value.to_string());
469 }
470 if let Some(local_var_param_value) = message_status_callback {
471 local_var_form_params.insert("MessageStatusCallback", local_var_param_value.to_string());
472 }
473 if let Some(local_var_param_value) = public_application_connect_enabled {
474 local_var_form_params.insert("PublicApplicationConnectEnabled", local_var_param_value.to_string());
475 }
476 local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
477
478 let local_var_req = local_var_req_builder.build()?;
479 let local_var_resp = local_var_client.execute(local_var_req).await?;
480
481 let local_var_status = local_var_resp.status();
482 let local_var_content = local_var_resp.text().await?;
483
484 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
485 serde_json::from_str(&local_var_content).map_err(Error::from)
486 } else {
487 let local_var_entity: Option<UpdateApplicationError> = serde_json::from_str(&local_var_content).ok();
488 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
489 Err(Error::ResponseError(local_var_error))
490 }
491}
492