1use super::{configuration, Error};
12use crate::{apis::ResponseContent, models::ObjectField};
13use headless_common::{models::Page, reqwest};
14
15#[derive(Debug, Clone, Serialize, Deserialize)]
17#[serde(untagged)]
18pub enum DeleteObjectFieldError {
19 DefaultResponse(),
20 UnknownValue(serde_json::Value),
21}
22
23#[derive(Debug, Clone, Serialize, Deserialize)]
25#[serde(untagged)]
26pub enum DeleteObjectFieldBatchError {
27 DefaultResponse(),
28 UnknownValue(serde_json::Value),
29}
30
31#[derive(Debug, Clone, Serialize, Deserialize)]
33#[serde(untagged)]
34pub enum GetObjectDefinitionByExternalReferenceCodeObjectFieldsPageError {
35 DefaultResponse(Page<ObjectField>),
36 UnknownValue(serde_json::Value),
37}
38
39#[derive(Debug, Clone, Serialize, Deserialize)]
41#[serde(untagged)]
42pub enum GetObjectDefinitionObjectFieldsPageError {
43 DefaultResponse(Page<ObjectField>),
44 UnknownValue(serde_json::Value),
45}
46
47#[derive(Debug, Clone, Serialize, Deserialize)]
49#[serde(untagged)]
50pub enum GetObjectFieldError {
51 DefaultResponse(crate::models::ObjectField),
52 UnknownValue(serde_json::Value),
53}
54
55#[derive(Debug, Clone, Serialize, Deserialize)]
57#[serde(untagged)]
58pub enum PatchObjectFieldError {
59 DefaultResponse(crate::models::ObjectField),
60 UnknownValue(serde_json::Value),
61}
62
63#[derive(Debug, Clone, Serialize, Deserialize)]
65#[serde(untagged)]
66pub enum PostObjectDefinitionByExternalReferenceCodeObjectFieldError {
67 DefaultResponse(crate::models::ObjectField),
68 UnknownValue(serde_json::Value),
69}
70
71#[derive(Debug, Clone, Serialize, Deserialize)]
73#[serde(untagged)]
74pub enum PostObjectDefinitionObjectFieldError {
75 DefaultResponse(crate::models::ObjectField),
76 UnknownValue(serde_json::Value),
77}
78
79#[derive(Debug, Clone, Serialize, Deserialize)]
81#[serde(untagged)]
82pub enum PostObjectDefinitionObjectFieldBatchError {
83 DefaultResponse(),
84 UnknownValue(serde_json::Value),
85}
86
87#[derive(Debug, Clone, Serialize, Deserialize)]
89#[serde(untagged)]
90pub enum PutObjectFieldError {
91 DefaultResponse(crate::models::ObjectField),
92 UnknownValue(serde_json::Value),
93}
94
95#[derive(Debug, Clone, Serialize, Deserialize)]
97#[serde(untagged)]
98pub enum PutObjectFieldBatchError {
99 DefaultResponse(),
100 UnknownValue(serde_json::Value),
101}
102
103pub fn delete_object_field(
104 configuration: &configuration::Configuration,
105 object_field_id: &str,
106) -> Result<(), Error<DeleteObjectFieldError>> {
107 let local_var_configuration = configuration;
108
109 let local_var_client = &local_var_configuration.client;
110
111 let local_var_uri_str = format!(
112 "{}/v1.0/object-fields/{objectFieldId}",
113 local_var_configuration.base_path,
114 objectFieldId = crate::apis::urlencode(object_field_id)
115 );
116 let mut local_var_req_builder =
117 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
118
119 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
120 local_var_req_builder =
121 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
122 }
123 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
124 local_var_req_builder = local_var_req_builder.basic_auth(
125 local_var_auth_conf.0.to_owned(),
126 local_var_auth_conf.1.to_owned(),
127 );
128 };
129 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
130 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
131 };
132
133 let local_var_req = local_var_req_builder.build()?;
134 let local_var_resp = local_var_client.execute(local_var_req)?;
135
136 let local_var_status = local_var_resp.status();
137 let local_var_content = local_var_resp.text()?;
138
139 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
140 Ok(())
141 } else {
142 let local_var_entity: Option<DeleteObjectFieldError> =
143 serde_json::from_str(&local_var_content).ok();
144 let local_var_error = ResponseContent {
145 status: local_var_status,
146 content: local_var_content,
147 entity: local_var_entity,
148 };
149 Err(Error::ResponseError(local_var_error))
150 }
151}
152
153pub fn delete_object_field_batch(
154 configuration: &configuration::Configuration,
155 callback_url: Option<&str>,
156 body: Option<serde_json::Value>,
157) -> Result<(), Error<DeleteObjectFieldBatchError>> {
158 let local_var_configuration = configuration;
159
160 let local_var_client = &local_var_configuration.client;
161
162 let local_var_uri_str = format!(
163 "{}/v1.0/object-fields/batch",
164 local_var_configuration.base_path
165 );
166 let mut local_var_req_builder =
167 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
168
169 if let Some(ref local_var_str) = callback_url {
170 local_var_req_builder =
171 local_var_req_builder.query(&[("callbackURL", &local_var_str.to_string())]);
172 }
173 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
174 local_var_req_builder =
175 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
176 }
177 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
178 local_var_req_builder = local_var_req_builder.basic_auth(
179 local_var_auth_conf.0.to_owned(),
180 local_var_auth_conf.1.to_owned(),
181 );
182 };
183 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
184 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
185 };
186 local_var_req_builder = local_var_req_builder.json(&body);
187
188 let local_var_req = local_var_req_builder.build()?;
189 let local_var_resp = local_var_client.execute(local_var_req)?;
190
191 let local_var_status = local_var_resp.status();
192 let local_var_content = local_var_resp.text()?;
193
194 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
195 Ok(())
196 } else {
197 let local_var_entity: Option<DeleteObjectFieldBatchError> =
198 serde_json::from_str(&local_var_content).ok();
199 let local_var_error = ResponseContent {
200 status: local_var_status,
201 content: local_var_content,
202 entity: local_var_entity,
203 };
204 Err(Error::ResponseError(local_var_error))
205 }
206}
207
208pub fn get_object_definition_by_external_reference_code_object_fields_page(
209 configuration: &configuration::Configuration,
210 external_reference_code: &str,
211 filter: Option<&str>,
212 page: Option<&str>,
213 page_size: Option<&str>,
214 search: Option<&str>,
215 sort: Option<&str>,
216) -> Result<Page<ObjectField>, Error<GetObjectDefinitionByExternalReferenceCodeObjectFieldsPageError>>
217{
218 let local_var_configuration = configuration;
219
220 let local_var_client = &local_var_configuration.client;
221
222 let local_var_uri_str = format!("{}/v1.0/object-definitions/by-external-reference-code/{externalReferenceCode}/object-fields", local_var_configuration.base_path, externalReferenceCode=crate::apis::urlencode(external_reference_code));
223 let mut local_var_req_builder =
224 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
225
226 if let Some(ref local_var_str) = filter {
227 local_var_req_builder =
228 local_var_req_builder.query(&[("filter", &local_var_str.to_string())]);
229 }
230 if let Some(ref local_var_str) = page {
231 local_var_req_builder =
232 local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
233 }
234 if let Some(ref local_var_str) = page_size {
235 local_var_req_builder =
236 local_var_req_builder.query(&[("pageSize", &local_var_str.to_string())]);
237 }
238 if let Some(ref local_var_str) = search {
239 local_var_req_builder =
240 local_var_req_builder.query(&[("search", &local_var_str.to_string())]);
241 }
242 if let Some(ref local_var_str) = sort {
243 local_var_req_builder =
244 local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
245 }
246 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
247 local_var_req_builder =
248 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
249 }
250 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
251 local_var_req_builder = local_var_req_builder.basic_auth(
252 local_var_auth_conf.0.to_owned(),
253 local_var_auth_conf.1.to_owned(),
254 );
255 };
256 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
257 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
258 };
259
260 let local_var_req = local_var_req_builder.build()?;
261 let local_var_resp = local_var_client.execute(local_var_req)?;
262
263 let local_var_status = local_var_resp.status();
264 let local_var_content = local_var_resp.text()?;
265
266 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
267 serde_json::from_str(&local_var_content).map_err(Error::from)
268 } else {
269 let local_var_entity: Option<
270 GetObjectDefinitionByExternalReferenceCodeObjectFieldsPageError,
271 > = serde_json::from_str(&local_var_content).ok();
272 let local_var_error = ResponseContent {
273 status: local_var_status,
274 content: local_var_content,
275 entity: local_var_entity,
276 };
277 Err(Error::ResponseError(local_var_error))
278 }
279}
280
281pub fn get_object_definition_object_fields_page(
282 configuration: &configuration::Configuration,
283 object_definition_id: &str,
284 filter: Option<&str>,
285 page: Option<&str>,
286 page_size: Option<&str>,
287 search: Option<&str>,
288 sort: Option<&str>,
289) -> Result<Page<ObjectField>, Error<GetObjectDefinitionObjectFieldsPageError>> {
290 let local_var_configuration = configuration;
291
292 let local_var_client = &local_var_configuration.client;
293
294 let local_var_uri_str = format!(
295 "{}/v1.0/object-definitions/{objectDefinitionId}/object-fields",
296 local_var_configuration.base_path,
297 objectDefinitionId = crate::apis::urlencode(object_definition_id)
298 );
299 let mut local_var_req_builder =
300 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
301
302 if let Some(ref local_var_str) = filter {
303 local_var_req_builder =
304 local_var_req_builder.query(&[("filter", &local_var_str.to_string())]);
305 }
306 if let Some(ref local_var_str) = page {
307 local_var_req_builder =
308 local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
309 }
310 if let Some(ref local_var_str) = page_size {
311 local_var_req_builder =
312 local_var_req_builder.query(&[("pageSize", &local_var_str.to_string())]);
313 }
314 if let Some(ref local_var_str) = search {
315 local_var_req_builder =
316 local_var_req_builder.query(&[("search", &local_var_str.to_string())]);
317 }
318 if let Some(ref local_var_str) = sort {
319 local_var_req_builder =
320 local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
321 }
322 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
323 local_var_req_builder =
324 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
325 }
326 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
327 local_var_req_builder = local_var_req_builder.basic_auth(
328 local_var_auth_conf.0.to_owned(),
329 local_var_auth_conf.1.to_owned(),
330 );
331 };
332 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
333 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
334 };
335
336 let local_var_req = local_var_req_builder.build()?;
337 let local_var_resp = local_var_client.execute(local_var_req)?;
338
339 let local_var_status = local_var_resp.status();
340 let local_var_content = local_var_resp.text()?;
341
342 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
343 serde_json::from_str(&local_var_content).map_err(Error::from)
344 } else {
345 let local_var_entity: Option<GetObjectDefinitionObjectFieldsPageError> =
346 serde_json::from_str(&local_var_content).ok();
347 let local_var_error = ResponseContent {
348 status: local_var_status,
349 content: local_var_content,
350 entity: local_var_entity,
351 };
352 Err(Error::ResponseError(local_var_error))
353 }
354}
355
356pub fn get_object_field(
357 configuration: &configuration::Configuration,
358 object_field_id: &str,
359) -> Result<crate::models::ObjectField, Error<GetObjectFieldError>> {
360 let local_var_configuration = configuration;
361
362 let local_var_client = &local_var_configuration.client;
363
364 let local_var_uri_str = format!(
365 "{}/v1.0/object-fields/{objectFieldId}",
366 local_var_configuration.base_path,
367 objectFieldId = crate::apis::urlencode(object_field_id)
368 );
369 let mut local_var_req_builder =
370 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
371
372 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
373 local_var_req_builder =
374 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
375 }
376 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
377 local_var_req_builder = local_var_req_builder.basic_auth(
378 local_var_auth_conf.0.to_owned(),
379 local_var_auth_conf.1.to_owned(),
380 );
381 };
382 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
383 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
384 };
385
386 let local_var_req = local_var_req_builder.build()?;
387 let local_var_resp = local_var_client.execute(local_var_req)?;
388
389 let local_var_status = local_var_resp.status();
390 let local_var_content = local_var_resp.text()?;
391
392 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
393 serde_json::from_str(&local_var_content).map_err(Error::from)
394 } else {
395 let local_var_entity: Option<GetObjectFieldError> =
396 serde_json::from_str(&local_var_content).ok();
397 let local_var_error = ResponseContent {
398 status: local_var_status,
399 content: local_var_content,
400 entity: local_var_entity,
401 };
402 Err(Error::ResponseError(local_var_error))
403 }
404}
405
406pub fn patch_object_field(
407 configuration: &configuration::Configuration,
408 object_field_id: &str,
409 object_field: Option<crate::models::ObjectField>,
410) -> Result<crate::models::ObjectField, Error<PatchObjectFieldError>> {
411 let local_var_configuration = configuration;
412
413 let local_var_client = &local_var_configuration.client;
414
415 let local_var_uri_str = format!(
416 "{}/v1.0/object-fields/{objectFieldId}",
417 local_var_configuration.base_path,
418 objectFieldId = crate::apis::urlencode(object_field_id)
419 );
420 let mut local_var_req_builder =
421 local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
422
423 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
424 local_var_req_builder =
425 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
426 }
427 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
428 local_var_req_builder = local_var_req_builder.basic_auth(
429 local_var_auth_conf.0.to_owned(),
430 local_var_auth_conf.1.to_owned(),
431 );
432 };
433 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
434 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
435 };
436 local_var_req_builder = local_var_req_builder.json(&object_field);
437
438 let local_var_req = local_var_req_builder.build()?;
439 let local_var_resp = local_var_client.execute(local_var_req)?;
440
441 let local_var_status = local_var_resp.status();
442 let local_var_content = local_var_resp.text()?;
443
444 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
445 serde_json::from_str(&local_var_content).map_err(Error::from)
446 } else {
447 let local_var_entity: Option<PatchObjectFieldError> =
448 serde_json::from_str(&local_var_content).ok();
449 let local_var_error = ResponseContent {
450 status: local_var_status,
451 content: local_var_content,
452 entity: local_var_entity,
453 };
454 Err(Error::ResponseError(local_var_error))
455 }
456}
457
458pub fn post_object_definition_by_external_reference_code_object_field(
459 configuration: &configuration::Configuration,
460 external_reference_code: &str,
461 object_field: Option<crate::models::ObjectField>,
462) -> Result<
463 crate::models::ObjectField,
464 Error<PostObjectDefinitionByExternalReferenceCodeObjectFieldError>,
465> {
466 let local_var_configuration = configuration;
467
468 let local_var_client = &local_var_configuration.client;
469
470 let local_var_uri_str = format!("{}/v1.0/object-definitions/by-external-reference-code/{externalReferenceCode}/object-fields", local_var_configuration.base_path, externalReferenceCode=crate::apis::urlencode(external_reference_code));
471 let mut local_var_req_builder =
472 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
473
474 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
475 local_var_req_builder =
476 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
477 }
478 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
479 local_var_req_builder = local_var_req_builder.basic_auth(
480 local_var_auth_conf.0.to_owned(),
481 local_var_auth_conf.1.to_owned(),
482 );
483 };
484 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
485 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
486 };
487 local_var_req_builder = local_var_req_builder.json(&object_field);
488
489 let local_var_req = local_var_req_builder.build()?;
490 let local_var_resp = local_var_client.execute(local_var_req)?;
491
492 let local_var_status = local_var_resp.status();
493 let local_var_content = local_var_resp.text()?;
494
495 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
496 serde_json::from_str(&local_var_content).map_err(Error::from)
497 } else {
498 let local_var_entity: Option<PostObjectDefinitionByExternalReferenceCodeObjectFieldError> =
499 serde_json::from_str(&local_var_content).ok();
500 let local_var_error = ResponseContent {
501 status: local_var_status,
502 content: local_var_content,
503 entity: local_var_entity,
504 };
505 Err(Error::ResponseError(local_var_error))
506 }
507}
508
509pub fn post_object_definition_object_field(
510 configuration: &configuration::Configuration,
511 object_definition_id: &str,
512 object_field: Option<crate::models::ObjectField>,
513) -> Result<crate::models::ObjectField, Error<PostObjectDefinitionObjectFieldError>> {
514 let local_var_configuration = configuration;
515
516 let local_var_client = &local_var_configuration.client;
517
518 let local_var_uri_str = format!(
519 "{}/v1.0/object-definitions/{objectDefinitionId}/object-fields",
520 local_var_configuration.base_path,
521 objectDefinitionId = crate::apis::urlencode(object_definition_id)
522 );
523 let mut local_var_req_builder =
524 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
525
526 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
527 local_var_req_builder =
528 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
529 }
530 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
531 local_var_req_builder = local_var_req_builder.basic_auth(
532 local_var_auth_conf.0.to_owned(),
533 local_var_auth_conf.1.to_owned(),
534 );
535 };
536 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
537 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
538 };
539 local_var_req_builder = local_var_req_builder.json(&object_field);
540
541 let local_var_req = local_var_req_builder.build()?;
542 let local_var_resp = local_var_client.execute(local_var_req)?;
543
544 let local_var_status = local_var_resp.status();
545 let local_var_content = local_var_resp.text()?;
546
547 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
548 serde_json::from_str(&local_var_content).map_err(Error::from)
549 } else {
550 let local_var_entity: Option<PostObjectDefinitionObjectFieldError> =
551 serde_json::from_str(&local_var_content).ok();
552 let local_var_error = ResponseContent {
553 status: local_var_status,
554 content: local_var_content,
555 entity: local_var_entity,
556 };
557 Err(Error::ResponseError(local_var_error))
558 }
559}
560
561pub fn post_object_definition_object_field_batch(
562 configuration: &configuration::Configuration,
563 object_definition_id: &str,
564 callback_url: Option<&str>,
565 body: Option<serde_json::Value>,
566) -> Result<(), Error<PostObjectDefinitionObjectFieldBatchError>> {
567 let local_var_configuration = configuration;
568
569 let local_var_client = &local_var_configuration.client;
570
571 let local_var_uri_str = format!(
572 "{}/v1.0/object-definitions/{objectDefinitionId}/object-fields/batch",
573 local_var_configuration.base_path,
574 objectDefinitionId = crate::apis::urlencode(object_definition_id)
575 );
576 let mut local_var_req_builder =
577 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
578
579 if let Some(ref local_var_str) = callback_url {
580 local_var_req_builder =
581 local_var_req_builder.query(&[("callbackURL", &local_var_str.to_string())]);
582 }
583 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
584 local_var_req_builder =
585 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
586 }
587 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
588 local_var_req_builder = local_var_req_builder.basic_auth(
589 local_var_auth_conf.0.to_owned(),
590 local_var_auth_conf.1.to_owned(),
591 );
592 };
593 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
594 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
595 };
596 local_var_req_builder = local_var_req_builder.json(&body);
597
598 let local_var_req = local_var_req_builder.build()?;
599 let local_var_resp = local_var_client.execute(local_var_req)?;
600
601 let local_var_status = local_var_resp.status();
602 let local_var_content = local_var_resp.text()?;
603
604 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
605 Ok(())
606 } else {
607 let local_var_entity: Option<PostObjectDefinitionObjectFieldBatchError> =
608 serde_json::from_str(&local_var_content).ok();
609 let local_var_error = ResponseContent {
610 status: local_var_status,
611 content: local_var_content,
612 entity: local_var_entity,
613 };
614 Err(Error::ResponseError(local_var_error))
615 }
616}
617
618pub fn put_object_field(
619 configuration: &configuration::Configuration,
620 object_field_id: &str,
621 object_field: Option<crate::models::ObjectField>,
622) -> Result<crate::models::ObjectField, Error<PutObjectFieldError>> {
623 let local_var_configuration = configuration;
624
625 let local_var_client = &local_var_configuration.client;
626
627 let local_var_uri_str = format!(
628 "{}/v1.0/object-fields/{objectFieldId}",
629 local_var_configuration.base_path,
630 objectFieldId = crate::apis::urlencode(object_field_id)
631 );
632 let mut local_var_req_builder =
633 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
634
635 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
636 local_var_req_builder =
637 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
638 }
639 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
640 local_var_req_builder = local_var_req_builder.basic_auth(
641 local_var_auth_conf.0.to_owned(),
642 local_var_auth_conf.1.to_owned(),
643 );
644 };
645 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
646 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
647 };
648 local_var_req_builder = local_var_req_builder.json(&object_field);
649
650 let local_var_req = local_var_req_builder.build()?;
651 let local_var_resp = local_var_client.execute(local_var_req)?;
652
653 let local_var_status = local_var_resp.status();
654 let local_var_content = local_var_resp.text()?;
655
656 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
657 serde_json::from_str(&local_var_content).map_err(Error::from)
658 } else {
659 let local_var_entity: Option<PutObjectFieldError> =
660 serde_json::from_str(&local_var_content).ok();
661 let local_var_error = ResponseContent {
662 status: local_var_status,
663 content: local_var_content,
664 entity: local_var_entity,
665 };
666 Err(Error::ResponseError(local_var_error))
667 }
668}
669
670pub fn put_object_field_batch(
671 configuration: &configuration::Configuration,
672 callback_url: Option<&str>,
673 body: Option<serde_json::Value>,
674) -> Result<(), Error<PutObjectFieldBatchError>> {
675 let local_var_configuration = configuration;
676
677 let local_var_client = &local_var_configuration.client;
678
679 let local_var_uri_str = format!(
680 "{}/v1.0/object-fields/batch",
681 local_var_configuration.base_path
682 );
683 let mut local_var_req_builder =
684 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
685
686 if let Some(ref local_var_str) = callback_url {
687 local_var_req_builder =
688 local_var_req_builder.query(&[("callbackURL", &local_var_str.to_string())]);
689 }
690 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
691 local_var_req_builder =
692 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
693 }
694 if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
695 local_var_req_builder = local_var_req_builder.basic_auth(
696 local_var_auth_conf.0.to_owned(),
697 local_var_auth_conf.1.to_owned(),
698 );
699 };
700 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
701 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
702 };
703 local_var_req_builder = local_var_req_builder.json(&body);
704
705 let local_var_req = local_var_req_builder.build()?;
706 let local_var_resp = local_var_client.execute(local_var_req)?;
707
708 let local_var_status = local_var_resp.status();
709 let local_var_content = local_var_resp.text()?;
710
711 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
712 Ok(())
713 } else {
714 let local_var_entity: Option<PutObjectFieldBatchError> =
715 serde_json::from_str(&local_var_content).ok();
716 let local_var_error = ResponseContent {
717 status: local_var_status,
718 content: local_var_content,
719 entity: local_var_entity,
720 };
721 Err(Error::ResponseError(local_var_error))
722 }
723}