1use reqwest;
13
14use crate::apis::ResponseContent;
15use super::{Error, configuration};
16
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum ConfigureDnsForSiteError {
22 DefaultResponse(crate::models::Error),
23 UnknownValue(serde_json::Value),
24}
25
26#[derive(Debug, Clone, Serialize, Deserialize)]
28#[serde(untagged)]
29pub enum CreateDnsRecordError {
30 DefaultResponse(crate::models::Error),
31 UnknownValue(serde_json::Value),
32}
33
34#[derive(Debug, Clone, Serialize, Deserialize)]
36#[serde(untagged)]
37pub enum CreateDnsZoneError {
38 DefaultResponse(crate::models::Error),
39 UnknownValue(serde_json::Value),
40}
41
42#[derive(Debug, Clone, Serialize, Deserialize)]
44#[serde(untagged)]
45pub enum DeleteDnsRecordError {
46 DefaultResponse(crate::models::Error),
47 UnknownValue(serde_json::Value),
48}
49
50#[derive(Debug, Clone, Serialize, Deserialize)]
52#[serde(untagged)]
53pub enum DeleteDnsZoneError {
54 DefaultResponse(crate::models::Error),
55 UnknownValue(serde_json::Value),
56}
57
58#[derive(Debug, Clone, Serialize, Deserialize)]
60#[serde(untagged)]
61pub enum GetDnsForSiteError {
62 DefaultResponse(crate::models::Error),
63 UnknownValue(serde_json::Value),
64}
65
66#[derive(Debug, Clone, Serialize, Deserialize)]
68#[serde(untagged)]
69pub enum GetDnsRecordsError {
70 DefaultResponse(crate::models::Error),
71 UnknownValue(serde_json::Value),
72}
73
74#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum GetDnsZoneError {
78 DefaultResponse(crate::models::Error),
79 UnknownValue(serde_json::Value),
80}
81
82#[derive(Debug, Clone, Serialize, Deserialize)]
84#[serde(untagged)]
85pub enum GetDnsZonesError {
86 DefaultResponse(crate::models::Error),
87 UnknownValue(serde_json::Value),
88}
89
90#[derive(Debug, Clone, Serialize, Deserialize)]
92#[serde(untagged)]
93pub enum GetIndividualDnsRecordError {
94 DefaultResponse(crate::models::Error),
95 UnknownValue(serde_json::Value),
96}
97
98#[derive(Debug, Clone, Serialize, Deserialize)]
100#[serde(untagged)]
101pub enum TransferDnsZoneError {
102 DefaultResponse(crate::models::Error),
103 UnknownValue(serde_json::Value),
104}
105
106
107pub async fn configure_dns_for_site(configuration: &configuration::Configuration, site_id: &str) -> Result<Vec<crate::models::DnsZone>, Error<ConfigureDnsForSiteError>> {
108
109 let local_var_client = &configuration.client;
110
111 let local_var_uri_str = format!("{}/sites/{site_id}/dns", configuration.base_path, site_id=crate::apis::urlencode(site_id));
112 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
113
114 if let Some(ref local_var_user_agent) = configuration.user_agent {
115 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
116 }
117 if let Some(ref local_var_token) = configuration.oauth_access_token {
118 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
119 };
120
121 let local_var_req = local_var_req_builder.build()?;
122 let local_var_resp = local_var_client.execute(local_var_req).await?;
123
124 let local_var_status = local_var_resp.status();
125 let local_var_content = local_var_resp.text().await?;
126
127 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
128 serde_json::from_str(&local_var_content).map_err(Error::from)
129 } else {
130 let local_var_entity: Option<ConfigureDnsForSiteError> = serde_json::from_str(&local_var_content).ok();
131 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
132 Err(Error::ResponseError(local_var_error))
133 }
134}
135
136pub async fn create_dns_record(configuration: &configuration::Configuration, zone_id: &str, dns_record: crate::models::DnsRecordCreate) -> Result<crate::models::DnsRecord, Error<CreateDnsRecordError>> {
137
138 let local_var_client = &configuration.client;
139
140 let local_var_uri_str = format!("{}/dns_zones/{zone_id}/dns_records", configuration.base_path, zone_id=crate::apis::urlencode(zone_id));
141 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
142
143 if let Some(ref local_var_user_agent) = configuration.user_agent {
144 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
145 }
146 if let Some(ref local_var_token) = configuration.oauth_access_token {
147 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
148 };
149 local_var_req_builder = local_var_req_builder.json(&dns_record);
150
151 let local_var_req = local_var_req_builder.build()?;
152 let local_var_resp = local_var_client.execute(local_var_req).await?;
153
154 let local_var_status = local_var_resp.status();
155 let local_var_content = local_var_resp.text().await?;
156
157 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
158 serde_json::from_str(&local_var_content).map_err(Error::from)
159 } else {
160 let local_var_entity: Option<CreateDnsRecordError> = serde_json::from_str(&local_var_content).ok();
161 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
162 Err(Error::ResponseError(local_var_error))
163 }
164}
165
166pub async fn create_dns_zone(configuration: &configuration::Configuration, dns_zone_params: crate::models::DnsZoneSetup) -> Result<crate::models::DnsZone, Error<CreateDnsZoneError>> {
167
168 let local_var_client = &configuration.client;
169
170 let local_var_uri_str = format!("{}/dns_zones", configuration.base_path);
171 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
172
173 if let Some(ref local_var_user_agent) = configuration.user_agent {
174 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
175 }
176 if let Some(ref local_var_token) = configuration.oauth_access_token {
177 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
178 };
179 local_var_req_builder = local_var_req_builder.json(&dns_zone_params);
180
181 let local_var_req = local_var_req_builder.build()?;
182 let local_var_resp = local_var_client.execute(local_var_req).await?;
183
184 let local_var_status = local_var_resp.status();
185 let local_var_content = local_var_resp.text().await?;
186
187 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
188 serde_json::from_str(&local_var_content).map_err(Error::from)
189 } else {
190 let local_var_entity: Option<CreateDnsZoneError> = serde_json::from_str(&local_var_content).ok();
191 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
192 Err(Error::ResponseError(local_var_error))
193 }
194}
195
196pub async fn delete_dns_record(configuration: &configuration::Configuration, zone_id: &str, dns_record_id: &str) -> Result<(), Error<DeleteDnsRecordError>> {
197
198 let local_var_client = &configuration.client;
199
200 let local_var_uri_str = format!("{}/dns_zones/{zone_id}/dns_records/{dns_record_id}", configuration.base_path, zone_id=crate::apis::urlencode(zone_id), dns_record_id=crate::apis::urlencode(dns_record_id));
201 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
202
203 if let Some(ref local_var_user_agent) = configuration.user_agent {
204 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
205 }
206 if let Some(ref local_var_token) = configuration.oauth_access_token {
207 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
208 };
209
210 let local_var_req = local_var_req_builder.build()?;
211 let local_var_resp = local_var_client.execute(local_var_req).await?;
212
213 let local_var_status = local_var_resp.status();
214 let local_var_content = local_var_resp.text().await?;
215
216 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
217 Ok(())
218 } else {
219 let local_var_entity: Option<DeleteDnsRecordError> = serde_json::from_str(&local_var_content).ok();
220 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
221 Err(Error::ResponseError(local_var_error))
222 }
223}
224
225pub async fn delete_dns_zone(configuration: &configuration::Configuration, zone_id: &str) -> Result<(), Error<DeleteDnsZoneError>> {
226
227 let local_var_client = &configuration.client;
228
229 let local_var_uri_str = format!("{}/dns_zones/{zone_id}", configuration.base_path, zone_id=crate::apis::urlencode(zone_id));
230 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
231
232 if let Some(ref local_var_user_agent) = configuration.user_agent {
233 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
234 }
235 if let Some(ref local_var_token) = configuration.oauth_access_token {
236 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
237 };
238
239 let local_var_req = local_var_req_builder.build()?;
240 let local_var_resp = local_var_client.execute(local_var_req).await?;
241
242 let local_var_status = local_var_resp.status();
243 let local_var_content = local_var_resp.text().await?;
244
245 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
246 Ok(())
247 } else {
248 let local_var_entity: Option<DeleteDnsZoneError> = serde_json::from_str(&local_var_content).ok();
249 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
250 Err(Error::ResponseError(local_var_error))
251 }
252}
253
254pub async fn get_dns_for_site(configuration: &configuration::Configuration, site_id: &str) -> Result<Vec<crate::models::DnsZone>, Error<GetDnsForSiteError>> {
255
256 let local_var_client = &configuration.client;
257
258 let local_var_uri_str = format!("{}/sites/{site_id}/dns", configuration.base_path, site_id=crate::apis::urlencode(site_id));
259 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
260
261 if let Some(ref local_var_user_agent) = configuration.user_agent {
262 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
263 }
264 if let Some(ref local_var_token) = configuration.oauth_access_token {
265 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
266 };
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<GetDnsForSiteError> = 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 get_dns_records(configuration: &configuration::Configuration, zone_id: &str) -> Result<Vec<crate::models::DnsRecord>, Error<GetDnsRecordsError>> {
284
285 let local_var_client = &configuration.client;
286
287 let local_var_uri_str = format!("{}/dns_zones/{zone_id}/dns_records", configuration.base_path, zone_id=crate::apis::urlencode(zone_id));
288 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
289
290 if let Some(ref local_var_user_agent) = configuration.user_agent {
291 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
292 }
293 if let Some(ref local_var_token) = configuration.oauth_access_token {
294 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
295 };
296
297 let local_var_req = local_var_req_builder.build()?;
298 let local_var_resp = local_var_client.execute(local_var_req).await?;
299
300 let local_var_status = local_var_resp.status();
301 let local_var_content = local_var_resp.text().await?;
302
303 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
304 serde_json::from_str(&local_var_content).map_err(Error::from)
305 } else {
306 let local_var_entity: Option<GetDnsRecordsError> = serde_json::from_str(&local_var_content).ok();
307 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
308 Err(Error::ResponseError(local_var_error))
309 }
310}
311
312pub async fn get_dns_zone(configuration: &configuration::Configuration, zone_id: &str) -> Result<crate::models::DnsZone, Error<GetDnsZoneError>> {
313
314 let local_var_client = &configuration.client;
315
316 let local_var_uri_str = format!("{}/dns_zones/{zone_id}", configuration.base_path, zone_id=crate::apis::urlencode(zone_id));
317 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
318
319 if let Some(ref local_var_user_agent) = configuration.user_agent {
320 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
321 }
322 if let Some(ref local_var_token) = configuration.oauth_access_token {
323 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
324 };
325
326 let local_var_req = local_var_req_builder.build()?;
327 let local_var_resp = local_var_client.execute(local_var_req).await?;
328
329 let local_var_status = local_var_resp.status();
330 let local_var_content = local_var_resp.text().await?;
331
332 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
333 serde_json::from_str(&local_var_content).map_err(Error::from)
334 } else {
335 let local_var_entity: Option<GetDnsZoneError> = serde_json::from_str(&local_var_content).ok();
336 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
337 Err(Error::ResponseError(local_var_error))
338 }
339}
340
341pub async fn get_dns_zones(configuration: &configuration::Configuration, account_slug: Option<&str>) -> Result<Vec<crate::models::DnsZone>, Error<GetDnsZonesError>> {
342
343 let local_var_client = &configuration.client;
344
345 let local_var_uri_str = format!("{}/dns_zones", configuration.base_path);
346 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
347
348 if let Some(ref local_var_str) = account_slug {
349 local_var_req_builder = local_var_req_builder.query(&[("account_slug", &local_var_str.to_string())]);
350 }
351 if let Some(ref local_var_user_agent) = configuration.user_agent {
352 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
353 }
354 if let Some(ref local_var_token) = configuration.oauth_access_token {
355 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
356 };
357
358 let local_var_req = local_var_req_builder.build()?;
359 let local_var_resp = local_var_client.execute(local_var_req).await?;
360
361 let local_var_status = local_var_resp.status();
362 let local_var_content = local_var_resp.text().await?;
363
364 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
365 serde_json::from_str(&local_var_content).map_err(Error::from)
366 } else {
367 let local_var_entity: Option<GetDnsZonesError> = serde_json::from_str(&local_var_content).ok();
368 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
369 Err(Error::ResponseError(local_var_error))
370 }
371}
372
373pub async fn get_individual_dns_record(configuration: &configuration::Configuration, zone_id: &str, dns_record_id: &str) -> Result<crate::models::DnsRecord, Error<GetIndividualDnsRecordError>> {
374
375 let local_var_client = &configuration.client;
376
377 let local_var_uri_str = format!("{}/dns_zones/{zone_id}/dns_records/{dns_record_id}", configuration.base_path, zone_id=crate::apis::urlencode(zone_id), dns_record_id=crate::apis::urlencode(dns_record_id));
378 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
379
380 if let Some(ref local_var_user_agent) = configuration.user_agent {
381 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
382 }
383 if let Some(ref local_var_token) = configuration.oauth_access_token {
384 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
385 };
386
387 let local_var_req = local_var_req_builder.build()?;
388 let local_var_resp = local_var_client.execute(local_var_req).await?;
389
390 let local_var_status = local_var_resp.status();
391 let local_var_content = local_var_resp.text().await?;
392
393 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
394 serde_json::from_str(&local_var_content).map_err(Error::from)
395 } else {
396 let local_var_entity: Option<GetIndividualDnsRecordError> = serde_json::from_str(&local_var_content).ok();
397 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
398 Err(Error::ResponseError(local_var_error))
399 }
400}
401
402pub async fn transfer_dns_zone(configuration: &configuration::Configuration, zone_id: &str, account_id: &str, transfer_account_id: &str, transfer_user_id: &str) -> Result<crate::models::DnsZone, Error<TransferDnsZoneError>> {
403
404 let local_var_client = &configuration.client;
405
406 let local_var_uri_str = format!("{}/dns_zones/{zone_id}/transfer", configuration.base_path, zone_id=crate::apis::urlencode(zone_id));
407 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
408
409 local_var_req_builder = local_var_req_builder.query(&[("account_id", &account_id.to_string())]);
410 local_var_req_builder = local_var_req_builder.query(&[("transfer_account_id", &transfer_account_id.to_string())]);
411 local_var_req_builder = local_var_req_builder.query(&[("transfer_user_id", &transfer_user_id.to_string())]);
412 if let Some(ref local_var_user_agent) = configuration.user_agent {
413 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
414 }
415 if let Some(ref local_var_token) = configuration.oauth_access_token {
416 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
417 };
418
419 let local_var_req = local_var_req_builder.build()?;
420 let local_var_resp = local_var_client.execute(local_var_req).await?;
421
422 let local_var_status = local_var_resp.status();
423 let local_var_content = local_var_resp.text().await?;
424
425 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
426 serde_json::from_str(&local_var_content).map_err(Error::from)
427 } else {
428 let local_var_entity: Option<TransferDnsZoneError> = serde_json::from_str(&local_var_content).ok();
429 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
430 Err(Error::ResponseError(local_var_error))
431 }
432}
433