1use reqwest;
13
14use crate::apis::ResponseContent;
15use super::{Error, configuration};
16
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum AddPersonError {
22 UnknownValue(serde_json::Value),
23}
24
25#[derive(Debug, Clone, Serialize, Deserialize)]
27#[serde(untagged)]
28pub enum AddPersonFollowerError {
29 UnknownValue(serde_json::Value),
30}
31
32#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(untagged)]
35pub enum AddPersonPictureError {
36 UnknownValue(serde_json::Value),
37}
38
39#[derive(Debug, Clone, Serialize, Deserialize)]
41#[serde(untagged)]
42pub enum DeletePersonError {
43 UnknownValue(serde_json::Value),
44}
45
46#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum DeletePersonFollowerError {
50 UnknownValue(serde_json::Value),
51}
52
53#[derive(Debug, Clone, Serialize, Deserialize)]
55#[serde(untagged)]
56pub enum DeletePersonPictureError {
57 UnknownValue(serde_json::Value),
58}
59
60#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum DeletePersonsError {
64 UnknownValue(serde_json::Value),
65}
66
67#[derive(Debug, Clone, Serialize, Deserialize)]
69#[serde(untagged)]
70pub enum GetPersonError {
71 UnknownValue(serde_json::Value),
72}
73
74#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum GetPersonActivitiesError {
78 UnknownValue(serde_json::Value),
79}
80
81#[derive(Debug, Clone, Serialize, Deserialize)]
83#[serde(untagged)]
84pub enum GetPersonDealsError {
85 UnknownValue(serde_json::Value),
86}
87
88#[derive(Debug, Clone, Serialize, Deserialize)]
90#[serde(untagged)]
91pub enum GetPersonFilesError {
92 UnknownValue(serde_json::Value),
93}
94
95#[derive(Debug, Clone, Serialize, Deserialize)]
97#[serde(untagged)]
98pub enum GetPersonFollowersError {
99 UnknownValue(serde_json::Value),
100}
101
102#[derive(Debug, Clone, Serialize, Deserialize)]
104#[serde(untagged)]
105pub enum GetPersonMailMessagesError {
106 UnknownValue(serde_json::Value),
107}
108
109#[derive(Debug, Clone, Serialize, Deserialize)]
111#[serde(untagged)]
112pub enum GetPersonProductsError {
113 UnknownValue(serde_json::Value),
114}
115
116#[derive(Debug, Clone, Serialize, Deserialize)]
118#[serde(untagged)]
119pub enum GetPersonUpdatesError {
120 UnknownValue(serde_json::Value),
121}
122
123#[derive(Debug, Clone, Serialize, Deserialize)]
125#[serde(untagged)]
126pub enum GetPersonUsersError {
127 UnknownValue(serde_json::Value),
128}
129
130#[derive(Debug, Clone, Serialize, Deserialize)]
132#[serde(untagged)]
133pub enum GetPersonsError {
134 UnknownValue(serde_json::Value),
135}
136
137#[derive(Debug, Clone, Serialize, Deserialize)]
139#[serde(untagged)]
140pub enum GetPersonsCollectionError {
141 Status403(crate::models::FailResponse),
142 UnknownValue(serde_json::Value),
143}
144
145#[derive(Debug, Clone, Serialize, Deserialize)]
147#[serde(untagged)]
148pub enum MergePersonsError {
149 UnknownValue(serde_json::Value),
150}
151
152#[derive(Debug, Clone, Serialize, Deserialize)]
154#[serde(untagged)]
155pub enum SearchPersonsError {
156 UnknownValue(serde_json::Value),
157}
158
159#[derive(Debug, Clone, Serialize, Deserialize)]
161#[serde(untagged)]
162pub enum UpdatePersonError {
163 UnknownValue(serde_json::Value),
164}
165
166
167pub async fn add_person(configuration: &configuration::Configuration, add_person_request: Option<crate::models::AddPersonRequest>) -> Result<crate::models::AddPersonResponse200, Error<AddPersonError>> {
169 let local_var_configuration = configuration;
170
171 let local_var_client = &local_var_configuration.client;
172
173 let local_var_uri_str = format!("{}/persons", local_var_configuration.base_path);
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_apikey) = local_var_configuration.api_key {
177 let local_var_key = local_var_apikey.key.clone();
178 let local_var_value = match local_var_apikey.prefix {
179 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
180 None => local_var_key,
181 };
182 local_var_req_builder = local_var_req_builder.query(&[("api_token", local_var_value)]);
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_token) = local_var_configuration.oauth_access_token {
188 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
189 };
190 local_var_req_builder = local_var_req_builder.json(&add_person_request);
191
192 let local_var_req = local_var_req_builder.build()?;
193 let local_var_resp = local_var_client.execute(local_var_req).await?;
194
195 let local_var_status = local_var_resp.status();
196 let local_var_content = local_var_resp.text().await?;
197
198 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
199 serde_json::from_str(&local_var_content).map_err(Error::from)
200 } else {
201 let local_var_entity: Option<AddPersonError> = serde_json::from_str(&local_var_content).ok();
202 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
203 Err(Error::ResponseError(local_var_error))
204 }
205}
206
207pub async fn add_person_follower(configuration: &configuration::Configuration, id: i32, add_person_follower_request: Option<crate::models::AddPersonFollowerRequest>) -> Result<crate::models::AddPersonFollowerResponse200, Error<AddPersonFollowerError>> {
209 let local_var_configuration = configuration;
210
211 let local_var_client = &local_var_configuration.client;
212
213 let local_var_uri_str = format!("{}/persons/{id}/followers", local_var_configuration.base_path, id=id);
214 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
215
216 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
217 let local_var_key = local_var_apikey.key.clone();
218 let local_var_value = match local_var_apikey.prefix {
219 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
220 None => local_var_key,
221 };
222 local_var_req_builder = local_var_req_builder.query(&[("api_token", local_var_value)]);
223 }
224 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
225 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
226 }
227 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
228 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
229 };
230 local_var_req_builder = local_var_req_builder.json(&add_person_follower_request);
231
232 let local_var_req = local_var_req_builder.build()?;
233 let local_var_resp = local_var_client.execute(local_var_req).await?;
234
235 let local_var_status = local_var_resp.status();
236 let local_var_content = local_var_resp.text().await?;
237
238 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
239 serde_json::from_str(&local_var_content).map_err(Error::from)
240 } else {
241 let local_var_entity: Option<AddPersonFollowerError> = serde_json::from_str(&local_var_content).ok();
242 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
243 Err(Error::ResponseError(local_var_error))
244 }
245}
246
247pub async fn add_person_picture(configuration: &configuration::Configuration, id: i32, file: std::path::PathBuf, crop_x: Option<i32>, crop_y: Option<i32>, crop_width: Option<i32>, crop_height: Option<i32>) -> Result<crate::models::AddPersonPictureResponse200, Error<AddPersonPictureError>> {
249 let local_var_configuration = configuration;
250
251 let local_var_client = &local_var_configuration.client;
252
253 let local_var_uri_str = format!("{}/persons/{id}/picture", local_var_configuration.base_path, id=id);
254 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
255
256 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
257 let local_var_key = local_var_apikey.key.clone();
258 let local_var_value = match local_var_apikey.prefix {
259 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
260 None => local_var_key,
261 };
262 local_var_req_builder = local_var_req_builder.query(&[("api_token", local_var_value)]);
263 }
264 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
265 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
266 }
267 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
268 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
269 };
270 let mut local_var_form = reqwest::multipart::Form::new();
271 if let Some(local_var_param_value) = crop_x {
273 local_var_form = local_var_form.text("crop_x", local_var_param_value.to_string());
274 }
275 if let Some(local_var_param_value) = crop_y {
276 local_var_form = local_var_form.text("crop_y", local_var_param_value.to_string());
277 }
278 if let Some(local_var_param_value) = crop_width {
279 local_var_form = local_var_form.text("crop_width", local_var_param_value.to_string());
280 }
281 if let Some(local_var_param_value) = crop_height {
282 local_var_form = local_var_form.text("crop_height", local_var_param_value.to_string());
283 }
284 local_var_req_builder = local_var_req_builder.multipart(local_var_form);
285
286 let local_var_req = local_var_req_builder.build()?;
287 let local_var_resp = local_var_client.execute(local_var_req).await?;
288
289 let local_var_status = local_var_resp.status();
290 let local_var_content = local_var_resp.text().await?;
291
292 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
293 serde_json::from_str(&local_var_content).map_err(Error::from)
294 } else {
295 let local_var_entity: Option<AddPersonPictureError> = serde_json::from_str(&local_var_content).ok();
296 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
297 Err(Error::ResponseError(local_var_error))
298 }
299}
300
301pub async fn delete_person(configuration: &configuration::Configuration, id: i32) -> Result<crate::models::DeletePersonResponse200, Error<DeletePersonError>> {
303 let local_var_configuration = configuration;
304
305 let local_var_client = &local_var_configuration.client;
306
307 let local_var_uri_str = format!("{}/persons/{id}", local_var_configuration.base_path, id=id);
308 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
309
310 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
311 let local_var_key = local_var_apikey.key.clone();
312 let local_var_value = match local_var_apikey.prefix {
313 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
314 None => local_var_key,
315 };
316 local_var_req_builder = local_var_req_builder.query(&[("api_token", local_var_value)]);
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_token) = local_var_configuration.oauth_access_token {
322 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.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<DeletePersonError> = 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 delete_person_follower(configuration: &configuration::Configuration, id: i32, follower_id: i32) -> Result<crate::models::DeletePersonResponse200, Error<DeletePersonFollowerError>> {
342 let local_var_configuration = configuration;
343
344 let local_var_client = &local_var_configuration.client;
345
346 let local_var_uri_str = format!("{}/persons/{id}/followers/{follower_id}", local_var_configuration.base_path, id=id, follower_id=follower_id);
347 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
348
349 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
350 let local_var_key = local_var_apikey.key.clone();
351 let local_var_value = match local_var_apikey.prefix {
352 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
353 None => local_var_key,
354 };
355 local_var_req_builder = local_var_req_builder.query(&[("api_token", local_var_value)]);
356 }
357 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
358 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
359 }
360
361 let local_var_req = local_var_req_builder.build()?;
362 let local_var_resp = local_var_client.execute(local_var_req).await?;
363
364 let local_var_status = local_var_resp.status();
365 let local_var_content = local_var_resp.text().await?;
366
367 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
368 serde_json::from_str(&local_var_content).map_err(Error::from)
369 } else {
370 let local_var_entity: Option<DeletePersonFollowerError> = serde_json::from_str(&local_var_content).ok();
371 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
372 Err(Error::ResponseError(local_var_error))
373 }
374}
375
376pub async fn delete_person_picture(configuration: &configuration::Configuration, id: i32) -> Result<crate::models::DeletePersonResponse200, Error<DeletePersonPictureError>> {
378 let local_var_configuration = configuration;
379
380 let local_var_client = &local_var_configuration.client;
381
382 let local_var_uri_str = format!("{}/persons/{id}/picture", local_var_configuration.base_path, id=id);
383 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
384
385 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
386 let local_var_key = local_var_apikey.key.clone();
387 let local_var_value = match local_var_apikey.prefix {
388 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
389 None => local_var_key,
390 };
391 local_var_req_builder = local_var_req_builder.query(&[("api_token", local_var_value)]);
392 }
393 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
394 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
395 }
396 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
397 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
398 };
399
400 let local_var_req = local_var_req_builder.build()?;
401 let local_var_resp = local_var_client.execute(local_var_req).await?;
402
403 let local_var_status = local_var_resp.status();
404 let local_var_content = local_var_resp.text().await?;
405
406 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
407 serde_json::from_str(&local_var_content).map_err(Error::from)
408 } else {
409 let local_var_entity: Option<DeletePersonPictureError> = serde_json::from_str(&local_var_content).ok();
410 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
411 Err(Error::ResponseError(local_var_error))
412 }
413}
414
415pub async fn delete_persons(configuration: &configuration::Configuration, ids: &str) -> Result<crate::models::DeletePersonsResponse200, Error<DeletePersonsError>> {
417 let local_var_configuration = configuration;
418
419 let local_var_client = &local_var_configuration.client;
420
421 let local_var_uri_str = format!("{}/persons", local_var_configuration.base_path);
422 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
423
424 local_var_req_builder = local_var_req_builder.query(&[("ids", &ids.to_string())]);
425 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
426 let local_var_key = local_var_apikey.key.clone();
427 let local_var_value = match local_var_apikey.prefix {
428 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
429 None => local_var_key,
430 };
431 local_var_req_builder = local_var_req_builder.query(&[("api_token", local_var_value)]);
432 }
433 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
434 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
435 }
436 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
437 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
438 };
439
440 let local_var_req = local_var_req_builder.build()?;
441 let local_var_resp = local_var_client.execute(local_var_req).await?;
442
443 let local_var_status = local_var_resp.status();
444 let local_var_content = local_var_resp.text().await?;
445
446 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
447 serde_json::from_str(&local_var_content).map_err(Error::from)
448 } else {
449 let local_var_entity: Option<DeletePersonsError> = serde_json::from_str(&local_var_content).ok();
450 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
451 Err(Error::ResponseError(local_var_error))
452 }
453}
454
455pub async fn get_person(configuration: &configuration::Configuration, id: i32) -> Result<crate::models::GetPersonResponse200, Error<GetPersonError>> {
457 let local_var_configuration = configuration;
458
459 let local_var_client = &local_var_configuration.client;
460
461 let local_var_uri_str = format!("{}/persons/{id}", local_var_configuration.base_path, id=id);
462 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
463
464 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
465 let local_var_key = local_var_apikey.key.clone();
466 let local_var_value = match local_var_apikey.prefix {
467 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
468 None => local_var_key,
469 };
470 local_var_req_builder = local_var_req_builder.query(&[("api_token", local_var_value)]);
471 }
472 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
473 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
474 }
475 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
476 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
477 };
478
479 let local_var_req = local_var_req_builder.build()?;
480 let local_var_resp = local_var_client.execute(local_var_req).await?;
481
482 let local_var_status = local_var_resp.status();
483 let local_var_content = local_var_resp.text().await?;
484
485 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
486 serde_json::from_str(&local_var_content).map_err(Error::from)
487 } else {
488 let local_var_entity: Option<GetPersonError> = serde_json::from_str(&local_var_content).ok();
489 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
490 Err(Error::ResponseError(local_var_error))
491 }
492}
493
494pub async fn get_person_activities(configuration: &configuration::Configuration, id: i32, start: Option<i32>, limit: Option<i32>, done: Option<f32>, exclude: Option<&str>) -> Result<crate::models::GetAssociatedActivitiesResponse200, Error<GetPersonActivitiesError>> {
496 let local_var_configuration = configuration;
497
498 let local_var_client = &local_var_configuration.client;
499
500 let local_var_uri_str = format!("{}/persons/{id}/activities", local_var_configuration.base_path, id=id);
501 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
502
503 if let Some(ref local_var_str) = start {
504 local_var_req_builder = local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
505 }
506 if let Some(ref local_var_str) = limit {
507 local_var_req_builder = local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
508 }
509 if let Some(ref local_var_str) = done {
510 local_var_req_builder = local_var_req_builder.query(&[("done", &local_var_str.to_string())]);
511 }
512 if let Some(ref local_var_str) = exclude {
513 local_var_req_builder = local_var_req_builder.query(&[("exclude", &local_var_str.to_string())]);
514 }
515 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
516 let local_var_key = local_var_apikey.key.clone();
517 let local_var_value = match local_var_apikey.prefix {
518 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
519 None => local_var_key,
520 };
521 local_var_req_builder = local_var_req_builder.query(&[("api_token", local_var_value)]);
522 }
523 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
524 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
525 }
526 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
527 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
528 };
529
530 let local_var_req = local_var_req_builder.build()?;
531 let local_var_resp = local_var_client.execute(local_var_req).await?;
532
533 let local_var_status = local_var_resp.status();
534 let local_var_content = local_var_resp.text().await?;
535
536 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
537 serde_json::from_str(&local_var_content).map_err(Error::from)
538 } else {
539 let local_var_entity: Option<GetPersonActivitiesError> = serde_json::from_str(&local_var_content).ok();
540 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
541 Err(Error::ResponseError(local_var_error))
542 }
543}
544
545pub async fn get_person_deals(configuration: &configuration::Configuration, id: i32, start: Option<i32>, limit: Option<i32>, status: Option<&str>, sort: Option<&str>) -> Result<crate::models::GetAssociatedDealsResponse200, Error<GetPersonDealsError>> {
547 let local_var_configuration = configuration;
548
549 let local_var_client = &local_var_configuration.client;
550
551 let local_var_uri_str = format!("{}/persons/{id}/deals", local_var_configuration.base_path, id=id);
552 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
553
554 if let Some(ref local_var_str) = start {
555 local_var_req_builder = local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
556 }
557 if let Some(ref local_var_str) = limit {
558 local_var_req_builder = local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
559 }
560 if let Some(ref local_var_str) = status {
561 local_var_req_builder = local_var_req_builder.query(&[("status", &local_var_str.to_string())]);
562 }
563 if let Some(ref local_var_str) = sort {
564 local_var_req_builder = local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
565 }
566 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
567 let local_var_key = local_var_apikey.key.clone();
568 let local_var_value = match local_var_apikey.prefix {
569 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
570 None => local_var_key,
571 };
572 local_var_req_builder = local_var_req_builder.query(&[("api_token", local_var_value)]);
573 }
574 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
575 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
576 }
577 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
578 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
579 };
580
581 let local_var_req = local_var_req_builder.build()?;
582 let local_var_resp = local_var_client.execute(local_var_req).await?;
583
584 let local_var_status = local_var_resp.status();
585 let local_var_content = local_var_resp.text().await?;
586
587 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
588 serde_json::from_str(&local_var_content).map_err(Error::from)
589 } else {
590 let local_var_entity: Option<GetPersonDealsError> = serde_json::from_str(&local_var_content).ok();
591 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
592 Err(Error::ResponseError(local_var_error))
593 }
594}
595
596pub async fn get_person_files(configuration: &configuration::Configuration, id: i32, start: Option<i32>, limit: Option<i32>, sort: Option<&str>) -> Result<crate::models::GetAssociatedFilesResponse200, Error<GetPersonFilesError>> {
598 let local_var_configuration = configuration;
599
600 let local_var_client = &local_var_configuration.client;
601
602 let local_var_uri_str = format!("{}/persons/{id}/files", local_var_configuration.base_path, id=id);
603 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
604
605 if let Some(ref local_var_str) = start {
606 local_var_req_builder = local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
607 }
608 if let Some(ref local_var_str) = limit {
609 local_var_req_builder = local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
610 }
611 if let Some(ref local_var_str) = sort {
612 local_var_req_builder = local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
613 }
614 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
615 let local_var_key = local_var_apikey.key.clone();
616 let local_var_value = match local_var_apikey.prefix {
617 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
618 None => local_var_key,
619 };
620 local_var_req_builder = local_var_req_builder.query(&[("api_token", local_var_value)]);
621 }
622 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
623 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
624 }
625 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
626 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
627 };
628
629 let local_var_req = local_var_req_builder.build()?;
630 let local_var_resp = local_var_client.execute(local_var_req).await?;
631
632 let local_var_status = local_var_resp.status();
633 let local_var_content = local_var_resp.text().await?;
634
635 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
636 serde_json::from_str(&local_var_content).map_err(Error::from)
637 } else {
638 let local_var_entity: Option<GetPersonFilesError> = serde_json::from_str(&local_var_content).ok();
639 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
640 Err(Error::ResponseError(local_var_error))
641 }
642}
643
644pub async fn get_person_followers(configuration: &configuration::Configuration, id: i32) -> Result<crate::models::GetAssociatedFollowersResponse200, Error<GetPersonFollowersError>> {
646 let local_var_configuration = configuration;
647
648 let local_var_client = &local_var_configuration.client;
649
650 let local_var_uri_str = format!("{}/persons/{id}/followers", local_var_configuration.base_path, id=id);
651 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
652
653 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
654 let local_var_key = local_var_apikey.key.clone();
655 let local_var_value = match local_var_apikey.prefix {
656 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
657 None => local_var_key,
658 };
659 local_var_req_builder = local_var_req_builder.query(&[("api_token", local_var_value)]);
660 }
661 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
662 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
663 }
664 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
665 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
666 };
667
668 let local_var_req = local_var_req_builder.build()?;
669 let local_var_resp = local_var_client.execute(local_var_req).await?;
670
671 let local_var_status = local_var_resp.status();
672 let local_var_content = local_var_resp.text().await?;
673
674 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
675 serde_json::from_str(&local_var_content).map_err(Error::from)
676 } else {
677 let local_var_entity: Option<GetPersonFollowersError> = serde_json::from_str(&local_var_content).ok();
678 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
679 Err(Error::ResponseError(local_var_error))
680 }
681}
682
683pub async fn get_person_mail_messages(configuration: &configuration::Configuration, id: i32, start: Option<i32>, limit: Option<i32>) -> Result<crate::models::GetAssociatedMailMessagesResponse200, Error<GetPersonMailMessagesError>> {
685 let local_var_configuration = configuration;
686
687 let local_var_client = &local_var_configuration.client;
688
689 let local_var_uri_str = format!("{}/persons/{id}/mailMessages", local_var_configuration.base_path, id=id);
690 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
691
692 if let Some(ref local_var_str) = start {
693 local_var_req_builder = local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
694 }
695 if let Some(ref local_var_str) = limit {
696 local_var_req_builder = local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
697 }
698 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
699 let local_var_key = local_var_apikey.key.clone();
700 let local_var_value = match local_var_apikey.prefix {
701 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
702 None => local_var_key,
703 };
704 local_var_req_builder = local_var_req_builder.query(&[("api_token", local_var_value)]);
705 }
706 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
707 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
708 }
709 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
710 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
711 };
712
713 let local_var_req = local_var_req_builder.build()?;
714 let local_var_resp = local_var_client.execute(local_var_req).await?;
715
716 let local_var_status = local_var_resp.status();
717 let local_var_content = local_var_resp.text().await?;
718
719 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
720 serde_json::from_str(&local_var_content).map_err(Error::from)
721 } else {
722 let local_var_entity: Option<GetPersonMailMessagesError> = serde_json::from_str(&local_var_content).ok();
723 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
724 Err(Error::ResponseError(local_var_error))
725 }
726}
727
728pub async fn get_person_products(configuration: &configuration::Configuration, id: i32, start: Option<i32>, limit: Option<i32>) -> Result<crate::models::GetPersonProductsResponse200, Error<GetPersonProductsError>> {
730 let local_var_configuration = configuration;
731
732 let local_var_client = &local_var_configuration.client;
733
734 let local_var_uri_str = format!("{}/persons/{id}/products", local_var_configuration.base_path, id=id);
735 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
736
737 if let Some(ref local_var_str) = start {
738 local_var_req_builder = local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
739 }
740 if let Some(ref local_var_str) = limit {
741 local_var_req_builder = local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
742 }
743 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
744 let local_var_key = local_var_apikey.key.clone();
745 let local_var_value = match local_var_apikey.prefix {
746 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
747 None => local_var_key,
748 };
749 local_var_req_builder = local_var_req_builder.query(&[("api_token", local_var_value)]);
750 }
751 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
752 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
753 }
754
755 let local_var_req = local_var_req_builder.build()?;
756 let local_var_resp = local_var_client.execute(local_var_req).await?;
757
758 let local_var_status = local_var_resp.status();
759 let local_var_content = local_var_resp.text().await?;
760
761 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
762 serde_json::from_str(&local_var_content).map_err(Error::from)
763 } else {
764 let local_var_entity: Option<GetPersonProductsError> = serde_json::from_str(&local_var_content).ok();
765 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
766 Err(Error::ResponseError(local_var_error))
767 }
768}
769
770pub async fn get_person_updates(configuration: &configuration::Configuration, id: i32, start: Option<i32>, limit: Option<i32>, all_changes: Option<&str>, items: Option<&str>) -> Result<crate::models::GetAssociatedPersonUpdatesResponse200, Error<GetPersonUpdatesError>> {
772 let local_var_configuration = configuration;
773
774 let local_var_client = &local_var_configuration.client;
775
776 let local_var_uri_str = format!("{}/persons/{id}/flow", local_var_configuration.base_path, id=id);
777 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
778
779 if let Some(ref local_var_str) = start {
780 local_var_req_builder = local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
781 }
782 if let Some(ref local_var_str) = limit {
783 local_var_req_builder = local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
784 }
785 if let Some(ref local_var_str) = all_changes {
786 local_var_req_builder = local_var_req_builder.query(&[("all_changes", &local_var_str.to_string())]);
787 }
788 if let Some(ref local_var_str) = items {
789 local_var_req_builder = local_var_req_builder.query(&[("items", &local_var_str.to_string())]);
790 }
791 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
792 let local_var_key = local_var_apikey.key.clone();
793 let local_var_value = match local_var_apikey.prefix {
794 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
795 None => local_var_key,
796 };
797 local_var_req_builder = local_var_req_builder.query(&[("api_token", local_var_value)]);
798 }
799 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
800 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
801 }
802 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
803 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
804 };
805
806 let local_var_req = local_var_req_builder.build()?;
807 let local_var_resp = local_var_client.execute(local_var_req).await?;
808
809 let local_var_status = local_var_resp.status();
810 let local_var_content = local_var_resp.text().await?;
811
812 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
813 serde_json::from_str(&local_var_content).map_err(Error::from)
814 } else {
815 let local_var_entity: Option<GetPersonUpdatesError> = serde_json::from_str(&local_var_content).ok();
816 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
817 Err(Error::ResponseError(local_var_error))
818 }
819}
820
821pub async fn get_person_users(configuration: &configuration::Configuration, id: i32) -> Result<crate::models::ListPermittedUsersResponse2001, Error<GetPersonUsersError>> {
823 let local_var_configuration = configuration;
824
825 let local_var_client = &local_var_configuration.client;
826
827 let local_var_uri_str = format!("{}/persons/{id}/permittedUsers", local_var_configuration.base_path, id=id);
828 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
829
830 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
831 let local_var_key = local_var_apikey.key.clone();
832 let local_var_value = match local_var_apikey.prefix {
833 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
834 None => local_var_key,
835 };
836 local_var_req_builder = local_var_req_builder.query(&[("api_token", local_var_value)]);
837 }
838 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
839 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
840 }
841
842 let local_var_req = local_var_req_builder.build()?;
843 let local_var_resp = local_var_client.execute(local_var_req).await?;
844
845 let local_var_status = local_var_resp.status();
846 let local_var_content = local_var_resp.text().await?;
847
848 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
849 serde_json::from_str(&local_var_content).map_err(Error::from)
850 } else {
851 let local_var_entity: Option<GetPersonUsersError> = serde_json::from_str(&local_var_content).ok();
852 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
853 Err(Error::ResponseError(local_var_error))
854 }
855}
856
857pub async fn get_persons(configuration: &configuration::Configuration, user_id: Option<i32>, filter_id: Option<i32>, first_char: Option<&str>, start: Option<i32>, limit: Option<i32>, sort: Option<&str>) -> Result<crate::models::GetPersonsResponse200, Error<GetPersonsError>> {
859 let local_var_configuration = configuration;
860
861 let local_var_client = &local_var_configuration.client;
862
863 let local_var_uri_str = format!("{}/persons", local_var_configuration.base_path);
864 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
865
866 if let Some(ref local_var_str) = user_id {
867 local_var_req_builder = local_var_req_builder.query(&[("user_id", &local_var_str.to_string())]);
868 }
869 if let Some(ref local_var_str) = filter_id {
870 local_var_req_builder = local_var_req_builder.query(&[("filter_id", &local_var_str.to_string())]);
871 }
872 if let Some(ref local_var_str) = first_char {
873 local_var_req_builder = local_var_req_builder.query(&[("first_char", &local_var_str.to_string())]);
874 }
875 if let Some(ref local_var_str) = start {
876 local_var_req_builder = local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
877 }
878 if let Some(ref local_var_str) = limit {
879 local_var_req_builder = local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
880 }
881 if let Some(ref local_var_str) = sort {
882 local_var_req_builder = local_var_req_builder.query(&[("sort", &local_var_str.to_string())]);
883 }
884 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
885 let local_var_key = local_var_apikey.key.clone();
886 let local_var_value = match local_var_apikey.prefix {
887 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
888 None => local_var_key,
889 };
890 local_var_req_builder = local_var_req_builder.query(&[("api_token", local_var_value)]);
891 }
892 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
893 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
894 }
895 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
896 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
897 };
898
899 let local_var_req = local_var_req_builder.build()?;
900 let local_var_resp = local_var_client.execute(local_var_req).await?;
901
902 let local_var_status = local_var_resp.status();
903 let local_var_content = local_var_resp.text().await?;
904
905 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
906 serde_json::from_str(&local_var_content).map_err(Error::from)
907 } else {
908 let local_var_entity: Option<GetPersonsError> = serde_json::from_str(&local_var_content).ok();
909 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
910 Err(Error::ResponseError(local_var_error))
911 }
912}
913
914pub async fn get_persons_collection(configuration: &configuration::Configuration, cursor: Option<&str>, limit: Option<i32>, since: Option<&str>, until: Option<&str>, owner_id: Option<i32>, first_char: Option<&str>) -> Result<crate::models::GetPersonsCollection200Response, Error<GetPersonsCollectionError>> {
916 let local_var_configuration = configuration;
917
918 let local_var_client = &local_var_configuration.client;
919
920 let local_var_uri_str = format!("{}/persons/collection", local_var_configuration.base_path);
921 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
922
923 if let Some(ref local_var_str) = cursor {
924 local_var_req_builder = local_var_req_builder.query(&[("cursor", &local_var_str.to_string())]);
925 }
926 if let Some(ref local_var_str) = limit {
927 local_var_req_builder = local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
928 }
929 if let Some(ref local_var_str) = since {
930 local_var_req_builder = local_var_req_builder.query(&[("since", &local_var_str.to_string())]);
931 }
932 if let Some(ref local_var_str) = until {
933 local_var_req_builder = local_var_req_builder.query(&[("until", &local_var_str.to_string())]);
934 }
935 if let Some(ref local_var_str) = owner_id {
936 local_var_req_builder = local_var_req_builder.query(&[("owner_id", &local_var_str.to_string())]);
937 }
938 if let Some(ref local_var_str) = first_char {
939 local_var_req_builder = local_var_req_builder.query(&[("first_char", &local_var_str.to_string())]);
940 }
941 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
942 let local_var_key = local_var_apikey.key.clone();
943 let local_var_value = match local_var_apikey.prefix {
944 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
945 None => local_var_key,
946 };
947 local_var_req_builder = local_var_req_builder.query(&[("api_token", local_var_value)]);
948 }
949 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
950 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
951 }
952 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
953 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
954 };
955
956 let local_var_req = local_var_req_builder.build()?;
957 let local_var_resp = local_var_client.execute(local_var_req).await?;
958
959 let local_var_status = local_var_resp.status();
960 let local_var_content = local_var_resp.text().await?;
961
962 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
963 serde_json::from_str(&local_var_content).map_err(Error::from)
964 } else {
965 let local_var_entity: Option<GetPersonsCollectionError> = serde_json::from_str(&local_var_content).ok();
966 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
967 Err(Error::ResponseError(local_var_error))
968 }
969}
970
971pub async fn merge_persons(configuration: &configuration::Configuration, id: i32, merge_persons_request: Option<crate::models::MergePersonsRequest>) -> Result<crate::models::MergePersonsResponse200, Error<MergePersonsError>> {
973 let local_var_configuration = configuration;
974
975 let local_var_client = &local_var_configuration.client;
976
977 let local_var_uri_str = format!("{}/persons/{id}/merge", local_var_configuration.base_path, id=id);
978 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
979
980 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
981 let local_var_key = local_var_apikey.key.clone();
982 let local_var_value = match local_var_apikey.prefix {
983 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
984 None => local_var_key,
985 };
986 local_var_req_builder = local_var_req_builder.query(&[("api_token", local_var_value)]);
987 }
988 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
989 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
990 }
991 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
992 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
993 };
994 local_var_req_builder = local_var_req_builder.json(&merge_persons_request);
995
996 let local_var_req = local_var_req_builder.build()?;
997 let local_var_resp = local_var_client.execute(local_var_req).await?;
998
999 let local_var_status = local_var_resp.status();
1000 let local_var_content = local_var_resp.text().await?;
1001
1002 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1003 serde_json::from_str(&local_var_content).map_err(Error::from)
1004 } else {
1005 let local_var_entity: Option<MergePersonsError> = serde_json::from_str(&local_var_content).ok();
1006 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1007 Err(Error::ResponseError(local_var_error))
1008 }
1009}
1010
1011pub async fn search_persons(configuration: &configuration::Configuration, term: &str, fields: Option<&str>, exact_match: Option<bool>, organization_id: Option<i32>, include_fields: Option<&str>, start: Option<i32>, limit: Option<i32>) -> Result<crate::models::SearchPersonsResponse200, Error<SearchPersonsError>> {
1013 let local_var_configuration = configuration;
1014
1015 let local_var_client = &local_var_configuration.client;
1016
1017 let local_var_uri_str = format!("{}/persons/search", local_var_configuration.base_path);
1018 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1019
1020 local_var_req_builder = local_var_req_builder.query(&[("term", &term.to_string())]);
1021 if let Some(ref local_var_str) = fields {
1022 local_var_req_builder = local_var_req_builder.query(&[("fields", &local_var_str.to_string())]);
1023 }
1024 if let Some(ref local_var_str) = exact_match {
1025 local_var_req_builder = local_var_req_builder.query(&[("exact_match", &local_var_str.to_string())]);
1026 }
1027 if let Some(ref local_var_str) = organization_id {
1028 local_var_req_builder = local_var_req_builder.query(&[("organization_id", &local_var_str.to_string())]);
1029 }
1030 if let Some(ref local_var_str) = include_fields {
1031 local_var_req_builder = local_var_req_builder.query(&[("include_fields", &local_var_str.to_string())]);
1032 }
1033 if let Some(ref local_var_str) = start {
1034 local_var_req_builder = local_var_req_builder.query(&[("start", &local_var_str.to_string())]);
1035 }
1036 if let Some(ref local_var_str) = limit {
1037 local_var_req_builder = local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
1038 }
1039 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1040 let local_var_key = local_var_apikey.key.clone();
1041 let local_var_value = match local_var_apikey.prefix {
1042 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1043 None => local_var_key,
1044 };
1045 local_var_req_builder = local_var_req_builder.query(&[("api_token", local_var_value)]);
1046 }
1047 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1048 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1049 }
1050 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1051 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1052 };
1053
1054 let local_var_req = local_var_req_builder.build()?;
1055 let local_var_resp = local_var_client.execute(local_var_req).await?;
1056
1057 let local_var_status = local_var_resp.status();
1058 let local_var_content = local_var_resp.text().await?;
1059
1060 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1061 serde_json::from_str(&local_var_content).map_err(Error::from)
1062 } else {
1063 let local_var_entity: Option<SearchPersonsError> = serde_json::from_str(&local_var_content).ok();
1064 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1065 Err(Error::ResponseError(local_var_error))
1066 }
1067}
1068
1069pub async fn update_person(configuration: &configuration::Configuration, id: i32, update_person_request: Option<crate::models::UpdatePersonRequest>) -> Result<crate::models::UpdatePersonResponse200, Error<UpdatePersonError>> {
1071 let local_var_configuration = configuration;
1072
1073 let local_var_client = &local_var_configuration.client;
1074
1075 let local_var_uri_str = format!("{}/persons/{id}", local_var_configuration.base_path, id=id);
1076 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1077
1078 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
1079 let local_var_key = local_var_apikey.key.clone();
1080 let local_var_value = match local_var_apikey.prefix {
1081 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
1082 None => local_var_key,
1083 };
1084 local_var_req_builder = local_var_req_builder.query(&[("api_token", local_var_value)]);
1085 }
1086 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1087 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1088 }
1089 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1090 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1091 };
1092 local_var_req_builder = local_var_req_builder.json(&update_person_request);
1093
1094 let local_var_req = local_var_req_builder.build()?;
1095 let local_var_resp = local_var_client.execute(local_var_req).await?;
1096
1097 let local_var_status = local_var_resp.status();
1098 let local_var_content = local_var_resp.text().await?;
1099
1100 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1101 serde_json::from_str(&local_var_content).map_err(Error::from)
1102 } else {
1103 let local_var_entity: Option<UpdatePersonError> = serde_json::from_str(&local_var_content).ok();
1104 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1105 Err(Error::ResponseError(local_var_error))
1106 }
1107}
1108