1use reqwest;
10
11use crate::apis::ResponseContent;
12use super::{Error, configuration};
13
14#[derive(Clone, Debug, Default)]
16pub struct CreateHeaderObjectParams {
17 pub service_id: String,
19 pub version_id: i32,
21 pub action: Option<String>,
23 pub cache_condition: Option<String>,
25 pub dst: Option<String>,
27 pub name: Option<String>,
29 pub regex: Option<String>,
31 pub request_condition: Option<String>,
33 pub response_condition: Option<String>,
35 pub src: Option<String>,
37 pub substitution: Option<String>,
39 pub _type: Option<String>,
41 pub ignore_if_set: Option<String>,
43 pub priority: Option<String>
45}
46
47#[derive(Clone, Debug, Default)]
49pub struct DeleteHeaderObjectParams {
50 pub service_id: String,
52 pub version_id: i32,
54 pub header_name: String
56}
57
58#[derive(Clone, Debug, Default)]
60pub struct GetHeaderObjectParams {
61 pub service_id: String,
63 pub version_id: i32,
65 pub header_name: String
67}
68
69#[derive(Clone, Debug, Default)]
71pub struct ListHeaderObjectsParams {
72 pub service_id: String,
74 pub version_id: i32
76}
77
78#[derive(Clone, Debug, Default)]
80pub struct UpdateHeaderObjectParams {
81 pub service_id: String,
83 pub version_id: i32,
85 pub header_name: String,
87 pub action: Option<String>,
89 pub cache_condition: Option<String>,
91 pub dst: Option<String>,
93 pub name: Option<String>,
95 pub regex: Option<String>,
97 pub request_condition: Option<String>,
99 pub response_condition: Option<String>,
101 pub src: Option<String>,
103 pub substitution: Option<String>,
105 pub _type: Option<String>,
107 pub ignore_if_set: Option<String>,
109 pub priority: Option<String>
111}
112
113
114#[derive(Debug, Clone, Serialize, Deserialize)]
116#[serde(untagged)]
117pub enum CreateHeaderObjectError {
118 UnknownValue(serde_json::Value),
119}
120
121#[derive(Debug, Clone, Serialize, Deserialize)]
123#[serde(untagged)]
124pub enum DeleteHeaderObjectError {
125 UnknownValue(serde_json::Value),
126}
127
128#[derive(Debug, Clone, Serialize, Deserialize)]
130#[serde(untagged)]
131pub enum GetHeaderObjectError {
132 UnknownValue(serde_json::Value),
133}
134
135#[derive(Debug, Clone, Serialize, Deserialize)]
137#[serde(untagged)]
138pub enum ListHeaderObjectsError {
139 UnknownValue(serde_json::Value),
140}
141
142#[derive(Debug, Clone, Serialize, Deserialize)]
144#[serde(untagged)]
145pub enum UpdateHeaderObjectError {
146 UnknownValue(serde_json::Value),
147}
148
149
150pub async fn create_header_object(configuration: &mut configuration::Configuration, params: CreateHeaderObjectParams) -> Result<crate::models::HeaderResponse, Error<CreateHeaderObjectError>> {
152 let local_var_configuration = configuration;
153
154 let service_id = params.service_id;
156 let version_id = params.version_id;
157 let action = params.action;
158 let cache_condition = params.cache_condition;
159 let dst = params.dst;
160 let name = params.name;
161 let regex = params.regex;
162 let request_condition = params.request_condition;
163 let response_condition = params.response_condition;
164 let src = params.src;
165 let substitution = params.substitution;
166 let _type = params._type;
167 let ignore_if_set = params.ignore_if_set;
168 let priority = params.priority;
169
170
171 let local_var_client = &local_var_configuration.client;
172
173 let local_var_uri_str = format!("{}/service/{service_id}/version/{version_id}/header", local_var_configuration.base_path, service_id=crate::apis::urlencode(service_id), version_id=version_id);
174 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
175
176 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
177 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
178 }
179 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
180 let local_var_key = local_var_apikey.key.clone();
181 let local_var_value = match local_var_apikey.prefix {
182 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
183 None => local_var_key,
184 };
185 local_var_req_builder = local_var_req_builder.header("Fastly-Key", local_var_value);
186 };
187 let mut local_var_form_params = std::collections::HashMap::new();
188 if let Some(local_var_param_value) = action {
189 local_var_form_params.insert("action", local_var_param_value.to_string());
190 }
191 if let Some(local_var_param_value) = cache_condition {
192 local_var_form_params.insert("cache_condition", local_var_param_value.to_string());
193 }
194 if let Some(local_var_param_value) = dst {
195 local_var_form_params.insert("dst", local_var_param_value.to_string());
196 }
197 if let Some(local_var_param_value) = name {
198 local_var_form_params.insert("name", local_var_param_value.to_string());
199 }
200 if let Some(local_var_param_value) = regex {
201 local_var_form_params.insert("regex", local_var_param_value.to_string());
202 }
203 if let Some(local_var_param_value) = request_condition {
204 local_var_form_params.insert("request_condition", local_var_param_value.to_string());
205 }
206 if let Some(local_var_param_value) = response_condition {
207 local_var_form_params.insert("response_condition", local_var_param_value.to_string());
208 }
209 if let Some(local_var_param_value) = src {
210 local_var_form_params.insert("src", local_var_param_value.to_string());
211 }
212 if let Some(local_var_param_value) = substitution {
213 local_var_form_params.insert("substitution", local_var_param_value.to_string());
214 }
215 if let Some(local_var_param_value) = _type {
216 local_var_form_params.insert("type", local_var_param_value.to_string());
217 }
218 if let Some(local_var_param_value) = ignore_if_set {
219 local_var_form_params.insert("ignore_if_set", local_var_param_value.to_string());
220 }
221 if let Some(local_var_param_value) = priority {
222 local_var_form_params.insert("priority", local_var_param_value.to_string());
223 }
224 local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
225
226 let local_var_req = local_var_req_builder.build()?;
227 let local_var_resp = local_var_client.execute(local_var_req).await?;
228
229 if "POST" != "GET" && "POST" != "HEAD" {
230 let headers = local_var_resp.headers();
231 local_var_configuration.rate_limit_remaining = match headers.get("Fastly-RateLimit-Remaining") {
232 Some(v) => v.to_str().unwrap().parse().unwrap(),
233 None => configuration::DEFAULT_RATELIMIT,
234 };
235 local_var_configuration.rate_limit_reset = match headers.get("Fastly-RateLimit-Reset") {
236 Some(v) => v.to_str().unwrap().parse().unwrap(),
237 None => 0,
238 };
239 }
240
241 let local_var_status = local_var_resp.status();
242 let local_var_content = local_var_resp.text().await?;
243
244 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
245 serde_json::from_str(&local_var_content).map_err(Error::from)
246 } else {
247 let local_var_entity: Option<CreateHeaderObjectError> = serde_json::from_str(&local_var_content).ok();
248 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
249 Err(Error::ResponseError(local_var_error))
250 }
251}
252
253pub async fn delete_header_object(configuration: &mut configuration::Configuration, params: DeleteHeaderObjectParams) -> Result<crate::models::InlineResponse200, Error<DeleteHeaderObjectError>> {
255 let local_var_configuration = configuration;
256
257 let service_id = params.service_id;
259 let version_id = params.version_id;
260 let header_name = params.header_name;
261
262
263 let local_var_client = &local_var_configuration.client;
264
265 let local_var_uri_str = format!("{}/service/{service_id}/version/{version_id}/header/{header_name}", local_var_configuration.base_path, service_id=crate::apis::urlencode(service_id), version_id=version_id, header_name=crate::apis::urlencode(header_name));
266 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
267
268 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
269 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
270 }
271 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
272 let local_var_key = local_var_apikey.key.clone();
273 let local_var_value = match local_var_apikey.prefix {
274 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
275 None => local_var_key,
276 };
277 local_var_req_builder = local_var_req_builder.header("Fastly-Key", local_var_value);
278 };
279
280 let local_var_req = local_var_req_builder.build()?;
281 let local_var_resp = local_var_client.execute(local_var_req).await?;
282
283 if "DELETE" != "GET" && "DELETE" != "HEAD" {
284 let headers = local_var_resp.headers();
285 local_var_configuration.rate_limit_remaining = match headers.get("Fastly-RateLimit-Remaining") {
286 Some(v) => v.to_str().unwrap().parse().unwrap(),
287 None => configuration::DEFAULT_RATELIMIT,
288 };
289 local_var_configuration.rate_limit_reset = match headers.get("Fastly-RateLimit-Reset") {
290 Some(v) => v.to_str().unwrap().parse().unwrap(),
291 None => 0,
292 };
293 }
294
295 let local_var_status = local_var_resp.status();
296 let local_var_content = local_var_resp.text().await?;
297
298 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
299 serde_json::from_str(&local_var_content).map_err(Error::from)
300 } else {
301 let local_var_entity: Option<DeleteHeaderObjectError> = serde_json::from_str(&local_var_content).ok();
302 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
303 Err(Error::ResponseError(local_var_error))
304 }
305}
306
307pub async fn get_header_object(configuration: &mut configuration::Configuration, params: GetHeaderObjectParams) -> Result<crate::models::HeaderResponse, Error<GetHeaderObjectError>> {
309 let local_var_configuration = configuration;
310
311 let service_id = params.service_id;
313 let version_id = params.version_id;
314 let header_name = params.header_name;
315
316
317 let local_var_client = &local_var_configuration.client;
318
319 let local_var_uri_str = format!("{}/service/{service_id}/version/{version_id}/header/{header_name}", local_var_configuration.base_path, service_id=crate::apis::urlencode(service_id), version_id=version_id, header_name=crate::apis::urlencode(header_name));
320 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
321
322 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
323 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
324 }
325 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
326 let local_var_key = local_var_apikey.key.clone();
327 let local_var_value = match local_var_apikey.prefix {
328 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
329 None => local_var_key,
330 };
331 local_var_req_builder = local_var_req_builder.header("Fastly-Key", local_var_value);
332 };
333
334 let local_var_req = local_var_req_builder.build()?;
335 let local_var_resp = local_var_client.execute(local_var_req).await?;
336
337 if "GET" != "GET" && "GET" != "HEAD" {
338 let headers = local_var_resp.headers();
339 local_var_configuration.rate_limit_remaining = match headers.get("Fastly-RateLimit-Remaining") {
340 Some(v) => v.to_str().unwrap().parse().unwrap(),
341 None => configuration::DEFAULT_RATELIMIT,
342 };
343 local_var_configuration.rate_limit_reset = match headers.get("Fastly-RateLimit-Reset") {
344 Some(v) => v.to_str().unwrap().parse().unwrap(),
345 None => 0,
346 };
347 }
348
349 let local_var_status = local_var_resp.status();
350 let local_var_content = local_var_resp.text().await?;
351
352 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
353 serde_json::from_str(&local_var_content).map_err(Error::from)
354 } else {
355 let local_var_entity: Option<GetHeaderObjectError> = serde_json::from_str(&local_var_content).ok();
356 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
357 Err(Error::ResponseError(local_var_error))
358 }
359}
360
361pub async fn list_header_objects(configuration: &mut configuration::Configuration, params: ListHeaderObjectsParams) -> Result<Vec<crate::models::HeaderResponse>, Error<ListHeaderObjectsError>> {
363 let local_var_configuration = configuration;
364
365 let service_id = params.service_id;
367 let version_id = params.version_id;
368
369
370 let local_var_client = &local_var_configuration.client;
371
372 let local_var_uri_str = format!("{}/service/{service_id}/version/{version_id}/header", local_var_configuration.base_path, service_id=crate::apis::urlencode(service_id), version_id=version_id);
373 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
374
375 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
376 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
377 }
378 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
379 let local_var_key = local_var_apikey.key.clone();
380 let local_var_value = match local_var_apikey.prefix {
381 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
382 None => local_var_key,
383 };
384 local_var_req_builder = local_var_req_builder.header("Fastly-Key", local_var_value);
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 if "GET" != "GET" && "GET" != "HEAD" {
391 let headers = local_var_resp.headers();
392 local_var_configuration.rate_limit_remaining = match headers.get("Fastly-RateLimit-Remaining") {
393 Some(v) => v.to_str().unwrap().parse().unwrap(),
394 None => configuration::DEFAULT_RATELIMIT,
395 };
396 local_var_configuration.rate_limit_reset = match headers.get("Fastly-RateLimit-Reset") {
397 Some(v) => v.to_str().unwrap().parse().unwrap(),
398 None => 0,
399 };
400 }
401
402 let local_var_status = local_var_resp.status();
403 let local_var_content = local_var_resp.text().await?;
404
405 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
406 serde_json::from_str(&local_var_content).map_err(Error::from)
407 } else {
408 let local_var_entity: Option<ListHeaderObjectsError> = serde_json::from_str(&local_var_content).ok();
409 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
410 Err(Error::ResponseError(local_var_error))
411 }
412}
413
414pub async fn update_header_object(configuration: &mut configuration::Configuration, params: UpdateHeaderObjectParams) -> Result<crate::models::HeaderResponse, Error<UpdateHeaderObjectError>> {
416 let local_var_configuration = configuration;
417
418 let service_id = params.service_id;
420 let version_id = params.version_id;
421 let header_name = params.header_name;
422 let action = params.action;
423 let cache_condition = params.cache_condition;
424 let dst = params.dst;
425 let name = params.name;
426 let regex = params.regex;
427 let request_condition = params.request_condition;
428 let response_condition = params.response_condition;
429 let src = params.src;
430 let substitution = params.substitution;
431 let _type = params._type;
432 let ignore_if_set = params.ignore_if_set;
433 let priority = params.priority;
434
435
436 let local_var_client = &local_var_configuration.client;
437
438 let local_var_uri_str = format!("{}/service/{service_id}/version/{version_id}/header/{header_name}", local_var_configuration.base_path, service_id=crate::apis::urlencode(service_id), version_id=version_id, header_name=crate::apis::urlencode(header_name));
439 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
440
441 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
442 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
443 }
444 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
445 let local_var_key = local_var_apikey.key.clone();
446 let local_var_value = match local_var_apikey.prefix {
447 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
448 None => local_var_key,
449 };
450 local_var_req_builder = local_var_req_builder.header("Fastly-Key", local_var_value);
451 };
452 let mut local_var_form_params = std::collections::HashMap::new();
453 if let Some(local_var_param_value) = action {
454 local_var_form_params.insert("action", local_var_param_value.to_string());
455 }
456 if let Some(local_var_param_value) = cache_condition {
457 local_var_form_params.insert("cache_condition", local_var_param_value.to_string());
458 }
459 if let Some(local_var_param_value) = dst {
460 local_var_form_params.insert("dst", local_var_param_value.to_string());
461 }
462 if let Some(local_var_param_value) = name {
463 local_var_form_params.insert("name", local_var_param_value.to_string());
464 }
465 if let Some(local_var_param_value) = regex {
466 local_var_form_params.insert("regex", local_var_param_value.to_string());
467 }
468 if let Some(local_var_param_value) = request_condition {
469 local_var_form_params.insert("request_condition", local_var_param_value.to_string());
470 }
471 if let Some(local_var_param_value) = response_condition {
472 local_var_form_params.insert("response_condition", local_var_param_value.to_string());
473 }
474 if let Some(local_var_param_value) = src {
475 local_var_form_params.insert("src", local_var_param_value.to_string());
476 }
477 if let Some(local_var_param_value) = substitution {
478 local_var_form_params.insert("substitution", local_var_param_value.to_string());
479 }
480 if let Some(local_var_param_value) = _type {
481 local_var_form_params.insert("type", local_var_param_value.to_string());
482 }
483 if let Some(local_var_param_value) = ignore_if_set {
484 local_var_form_params.insert("ignore_if_set", local_var_param_value.to_string());
485 }
486 if let Some(local_var_param_value) = priority {
487 local_var_form_params.insert("priority", local_var_param_value.to_string());
488 }
489 local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
490
491 let local_var_req = local_var_req_builder.build()?;
492 let local_var_resp = local_var_client.execute(local_var_req).await?;
493
494 if "PUT" != "GET" && "PUT" != "HEAD" {
495 let headers = local_var_resp.headers();
496 local_var_configuration.rate_limit_remaining = match headers.get("Fastly-RateLimit-Remaining") {
497 Some(v) => v.to_str().unwrap().parse().unwrap(),
498 None => configuration::DEFAULT_RATELIMIT,
499 };
500 local_var_configuration.rate_limit_reset = match headers.get("Fastly-RateLimit-Reset") {
501 Some(v) => v.to_str().unwrap().parse().unwrap(),
502 None => 0,
503 };
504 }
505
506 let local_var_status = local_var_resp.status();
507 let local_var_content = local_var_resp.text().await?;
508
509 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
510 serde_json::from_str(&local_var_content).map_err(Error::from)
511 } else {
512 let local_var_entity: Option<UpdateHeaderObjectError> = serde_json::from_str(&local_var_content).ok();
513 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
514 Err(Error::ResponseError(local_var_error))
515 }
516}
517