twilio_rust_openapi/apis/
api20100401_ip_address_api.rs1use reqwest;
13use serde::{Deserialize, Serialize};
14use crate::{apis::ResponseContent, models};
15use super::{Error, configuration};
16
17#[derive(Clone, Debug)]
19pub struct CreateSipIpAddressParams {
20 pub account_sid: String,
22 pub ip_access_control_list_sid: String,
24 pub friendly_name: String,
26 pub ip_address: String,
28 pub cidr_prefix_length: Option<i32>
30}
31
32#[derive(Clone, Debug)]
34pub struct DeleteSipIpAddressParams {
35 pub account_sid: String,
37 pub ip_access_control_list_sid: String,
39 pub sid: String
41}
42
43#[derive(Clone, Debug)]
45pub struct FetchSipIpAddressParams {
46 pub account_sid: String,
48 pub ip_access_control_list_sid: String,
50 pub sid: String
52}
53
54#[derive(Clone, Debug)]
56pub struct ListSipIpAddressParams {
57 pub account_sid: String,
59 pub ip_access_control_list_sid: String,
61 pub page_size: Option<i32>,
63 pub page: Option<i32>,
65 pub page_token: Option<String>
67}
68
69#[derive(Clone, Debug)]
71pub struct UpdateSipIpAddressParams {
72 pub account_sid: String,
74 pub ip_access_control_list_sid: String,
76 pub sid: String,
78 pub ip_address: Option<String>,
80 pub friendly_name: Option<String>,
82 pub cidr_prefix_length: Option<i32>
84}
85
86
87#[derive(Debug, Clone, Serialize, Deserialize)]
89#[serde(untagged)]
90pub enum CreateSipIpAddressError {
91 UnknownValue(serde_json::Value),
92}
93
94#[derive(Debug, Clone, Serialize, Deserialize)]
96#[serde(untagged)]
97pub enum DeleteSipIpAddressError {
98 UnknownValue(serde_json::Value),
99}
100
101#[derive(Debug, Clone, Serialize, Deserialize)]
103#[serde(untagged)]
104pub enum FetchSipIpAddressError {
105 UnknownValue(serde_json::Value),
106}
107
108#[derive(Debug, Clone, Serialize, Deserialize)]
110#[serde(untagged)]
111pub enum ListSipIpAddressError {
112 UnknownValue(serde_json::Value),
113}
114
115#[derive(Debug, Clone, Serialize, Deserialize)]
117#[serde(untagged)]
118pub enum UpdateSipIpAddressError {
119 UnknownValue(serde_json::Value),
120}
121
122
123pub async fn create_sip_ip_address(configuration: &configuration::Configuration, params: CreateSipIpAddressParams) -> Result<models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipIpAccessControlListPeriodSipIpAddress, Error<CreateSipIpAddressError>> {
125 let local_var_configuration = configuration;
126
127 let account_sid = params.account_sid;
129 let ip_access_control_list_sid = params.ip_access_control_list_sid;
130 let friendly_name = params.friendly_name;
131 let ip_address = params.ip_address;
132 let cidr_prefix_length = params.cidr_prefix_length;
133
134
135 let local_var_client = &local_var_configuration.client;
136
137 let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/IpAccessControlLists/{IpAccessControlListSid}/IpAddresses.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), IpAccessControlListSid=crate::apis::urlencode(ip_access_control_list_sid));
138 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
139
140 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
141 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
142 }
143 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
144 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
145 };
146 let mut local_var_form_params = std::collections::HashMap::new();
147 local_var_form_params.insert("FriendlyName", friendly_name.to_string());
148 local_var_form_params.insert("IpAddress", ip_address.to_string());
149 if let Some(local_var_param_value) = cidr_prefix_length {
150 local_var_form_params.insert("CidrPrefixLength", local_var_param_value.to_string());
151 }
152 local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
153
154 let local_var_req = local_var_req_builder.build()?;
155 let local_var_resp = local_var_client.execute(local_var_req).await?;
156
157 let local_var_status = local_var_resp.status();
158 let local_var_content = local_var_resp.text().await?;
159
160 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
161 serde_json::from_str(&local_var_content).map_err(Error::from)
162 } else {
163 let local_var_entity: Option<CreateSipIpAddressError> = serde_json::from_str(&local_var_content).ok();
164 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
165 Err(Error::ResponseError(local_var_error))
166 }
167}
168
169pub async fn delete_sip_ip_address(configuration: &configuration::Configuration, params: DeleteSipIpAddressParams) -> Result<(), Error<DeleteSipIpAddressError>> {
171 let local_var_configuration = configuration;
172
173 let account_sid = params.account_sid;
175 let ip_access_control_list_sid = params.ip_access_control_list_sid;
176 let sid = params.sid;
177
178
179 let local_var_client = &local_var_configuration.client;
180
181 let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/IpAccessControlLists/{IpAccessControlListSid}/IpAddresses/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), IpAccessControlListSid=crate::apis::urlencode(ip_access_control_list_sid), Sid=crate::apis::urlencode(sid));
182 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
183
184 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
185 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
186 }
187 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
188 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
189 };
190
191 let local_var_req = local_var_req_builder.build()?;
192 let local_var_resp = local_var_client.execute(local_var_req).await?;
193
194 let local_var_status = local_var_resp.status();
195 let local_var_content = local_var_resp.text().await?;
196
197 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
198 Ok(())
199 } else {
200 let local_var_entity: Option<DeleteSipIpAddressError> = serde_json::from_str(&local_var_content).ok();
201 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
202 Err(Error::ResponseError(local_var_error))
203 }
204}
205
206pub async fn fetch_sip_ip_address(configuration: &configuration::Configuration, params: FetchSipIpAddressParams) -> Result<models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipIpAccessControlListPeriodSipIpAddress, Error<FetchSipIpAddressError>> {
208 let local_var_configuration = configuration;
209
210 let account_sid = params.account_sid;
212 let ip_access_control_list_sid = params.ip_access_control_list_sid;
213 let sid = params.sid;
214
215
216 let local_var_client = &local_var_configuration.client;
217
218 let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/IpAccessControlLists/{IpAccessControlListSid}/IpAddresses/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), IpAccessControlListSid=crate::apis::urlencode(ip_access_control_list_sid), Sid=crate::apis::urlencode(sid));
219 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
220
221 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
222 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
223 }
224 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
225 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
226 };
227
228 let local_var_req = local_var_req_builder.build()?;
229 let local_var_resp = local_var_client.execute(local_var_req).await?;
230
231 let local_var_status = local_var_resp.status();
232 let local_var_content = local_var_resp.text().await?;
233
234 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
235 serde_json::from_str(&local_var_content).map_err(Error::from)
236 } else {
237 let local_var_entity: Option<FetchSipIpAddressError> = serde_json::from_str(&local_var_content).ok();
238 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
239 Err(Error::ResponseError(local_var_error))
240 }
241}
242
243pub async fn list_sip_ip_address(configuration: &configuration::Configuration, params: ListSipIpAddressParams) -> Result<models::ListSipIpAddressResponse, Error<ListSipIpAddressError>> {
245 let local_var_configuration = configuration;
246
247 let account_sid = params.account_sid;
249 let ip_access_control_list_sid = params.ip_access_control_list_sid;
250 let page_size = params.page_size;
251 let page = params.page;
252 let page_token = params.page_token;
253
254
255 let local_var_client = &local_var_configuration.client;
256
257 let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/IpAccessControlLists/{IpAccessControlListSid}/IpAddresses.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), IpAccessControlListSid=crate::apis::urlencode(ip_access_control_list_sid));
258 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
259
260 if let Some(ref local_var_str) = page_size {
261 local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
262 }
263 if let Some(ref local_var_str) = page {
264 local_var_req_builder = local_var_req_builder.query(&[("Page", &local_var_str.to_string())]);
265 }
266 if let Some(ref local_var_str) = page_token {
267 local_var_req_builder = local_var_req_builder.query(&[("PageToken", &local_var_str.to_string())]);
268 }
269 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
270 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
271 }
272 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
273 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
274 };
275
276 let local_var_req = local_var_req_builder.build()?;
277 let local_var_resp = local_var_client.execute(local_var_req).await?;
278
279 let local_var_status = local_var_resp.status();
280 let local_var_content = local_var_resp.text().await?;
281
282 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
283 serde_json::from_str(&local_var_content).map_err(Error::from)
284 } else {
285 let local_var_entity: Option<ListSipIpAddressError> = serde_json::from_str(&local_var_content).ok();
286 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
287 Err(Error::ResponseError(local_var_error))
288 }
289}
290
291pub async fn update_sip_ip_address(configuration: &configuration::Configuration, params: UpdateSipIpAddressParams) -> Result<models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipIpAccessControlListPeriodSipIpAddress, Error<UpdateSipIpAddressError>> {
293 let local_var_configuration = configuration;
294
295 let account_sid = params.account_sid;
297 let ip_access_control_list_sid = params.ip_access_control_list_sid;
298 let sid = params.sid;
299 let ip_address = params.ip_address;
300 let friendly_name = params.friendly_name;
301 let cidr_prefix_length = params.cidr_prefix_length;
302
303
304 let local_var_client = &local_var_configuration.client;
305
306 let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/IpAccessControlLists/{IpAccessControlListSid}/IpAddresses/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), IpAccessControlListSid=crate::apis::urlencode(ip_access_control_list_sid), Sid=crate::apis::urlencode(sid));
307 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
308
309 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
310 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
311 }
312 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
313 local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
314 };
315 let mut local_var_form_params = std::collections::HashMap::new();
316 if let Some(local_var_param_value) = ip_address {
317 local_var_form_params.insert("IpAddress", local_var_param_value.to_string());
318 }
319 if let Some(local_var_param_value) = friendly_name {
320 local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
321 }
322 if let Some(local_var_param_value) = cidr_prefix_length {
323 local_var_form_params.insert("CidrPrefixLength", local_var_param_value.to_string());
324 }
325 local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
326
327 let local_var_req = local_var_req_builder.build()?;
328 let local_var_resp = local_var_client.execute(local_var_req).await?;
329
330 let local_var_status = local_var_resp.status();
331 let local_var_content = local_var_resp.text().await?;
332
333 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
334 serde_json::from_str(&local_var_content).map_err(Error::from)
335 } else {
336 let local_var_entity: Option<UpdateSipIpAddressError> = serde_json::from_str(&local_var_content).ok();
337 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
338 Err(Error::ResponseError(local_var_error))
339 }
340}
341