1use reqwest;
12
13use super::{configuration, Error};
14use crate::apis::ResponseContent;
15
16#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum AddMessageStampError {
20 Status400(),
21 Status404(),
22 UnknownValue(serde_json::Value),
23}
24
25#[derive(Debug, Clone, Serialize, Deserialize)]
27#[serde(untagged)]
28pub enum ChangeStampImageError {
29 Status400(),
30 Status404(),
31 Status413(),
32 UnknownValue(serde_json::Value),
33}
34
35#[derive(Debug, Clone, Serialize, Deserialize)]
37#[serde(untagged)]
38pub enum CreateStampError {
39 Status400(),
40 Status409(),
41 Status413(),
42 UnknownValue(serde_json::Value),
43}
44
45#[derive(Debug, Clone, Serialize, Deserialize)]
47#[serde(untagged)]
48pub enum CreateStampPaletteError {
49 Status400(),
50 UnknownValue(serde_json::Value),
51}
52
53#[derive(Debug, Clone, Serialize, Deserialize)]
55#[serde(untagged)]
56pub enum DeleteStampError {
57 Status403(),
58 Status404(),
59 UnknownValue(serde_json::Value),
60}
61
62#[derive(Debug, Clone, Serialize, Deserialize)]
64#[serde(untagged)]
65pub enum DeleteStampPaletteError {
66 Status403(),
67 Status404(),
68 UnknownValue(serde_json::Value),
69}
70
71#[derive(Debug, Clone, Serialize, Deserialize)]
73#[serde(untagged)]
74pub enum EditStampError {
75 Status400(),
76 Status403(),
77 Status404(),
78 Status409(),
79 UnknownValue(serde_json::Value),
80}
81
82#[derive(Debug, Clone, Serialize, Deserialize)]
84#[serde(untagged)]
85pub enum EditStampPaletteError {
86 Status400(),
87 Status403(),
88 Status404(),
89 UnknownValue(serde_json::Value),
90}
91
92#[derive(Debug, Clone, Serialize, Deserialize)]
94#[serde(untagged)]
95pub enum GetMessageStampsError {
96 Status404(),
97 UnknownValue(serde_json::Value),
98}
99
100#[derive(Debug, Clone, Serialize, Deserialize)]
102#[serde(untagged)]
103pub enum GetMyStampHistoryError {
104 UnknownValue(serde_json::Value),
105}
106
107#[derive(Debug, Clone, Serialize, Deserialize)]
109#[serde(untagged)]
110pub enum GetStampError {
111 Status404(),
112 UnknownValue(serde_json::Value),
113}
114
115#[derive(Debug, Clone, Serialize, Deserialize)]
117#[serde(untagged)]
118pub enum GetStampImageError {
119 Status404(),
120 UnknownValue(serde_json::Value),
121}
122
123#[derive(Debug, Clone, Serialize, Deserialize)]
125#[serde(untagged)]
126pub enum GetStampPaletteError {
127 Status404(),
128 UnknownValue(serde_json::Value),
129}
130
131#[derive(Debug, Clone, Serialize, Deserialize)]
133#[serde(untagged)]
134pub enum GetStampPalettesError {
135 UnknownValue(serde_json::Value),
136}
137
138#[derive(Debug, Clone, Serialize, Deserialize)]
140#[serde(untagged)]
141pub enum GetStampStatsError {
142 Status404(),
143 UnknownValue(serde_json::Value),
144}
145
146#[derive(Debug, Clone, Serialize, Deserialize)]
148#[serde(untagged)]
149pub enum GetStampsError {
150 UnknownValue(serde_json::Value),
151}
152
153#[derive(Debug, Clone, Serialize, Deserialize)]
155#[serde(untagged)]
156pub enum RemoveMessageStampError {
157 Status404(),
158 UnknownValue(serde_json::Value),
159}
160
161pub async fn add_message_stamp(
163 configuration: &configuration::Configuration,
164 message_id: &str,
165 stamp_id: &str,
166 post_message_stamp_request: Option<crate::models::PostMessageStampRequest>,
167) -> Result<(), Error<AddMessageStampError>> {
168 let local_var_configuration = configuration;
169
170 let local_var_client = &local_var_configuration.client;
171
172 let local_var_uri_str = format!(
173 "{}/messages/{messageId}/stamps/{stampId}",
174 local_var_configuration.base_path,
175 messageId = crate::apis::urlencode(message_id),
176 stampId = crate::apis::urlencode(stamp_id)
177 );
178 let mut local_var_req_builder =
179 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
180
181 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
182 local_var_req_builder =
183 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
184 }
185 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
186 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
187 };
188 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
189 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
190 };
191 local_var_req_builder = local_var_req_builder.json(&post_message_stamp_request);
192
193 let local_var_req = local_var_req_builder.build()?;
194 let local_var_resp = local_var_client.execute(local_var_req).await?;
195
196 let local_var_status = local_var_resp.status();
197 let local_var_content = local_var_resp.text().await?;
198
199 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
200 Ok(())
201 } else {
202 let local_var_entity: Option<AddMessageStampError> =
203 serde_json::from_str(&local_var_content).ok();
204 let local_var_error = ResponseContent {
205 status: local_var_status,
206 content: local_var_content,
207 entity: local_var_entity,
208 };
209 Err(Error::ResponseError(local_var_error))
210 }
211}
212
213pub async fn change_stamp_image(
215 configuration: &configuration::Configuration,
216 stamp_id: &str,
217 _file: std::path::PathBuf,
218) -> Result<(), Error<ChangeStampImageError>> {
219 let local_var_configuration = configuration;
220
221 let local_var_client = &local_var_configuration.client;
222
223 let local_var_uri_str = format!(
224 "{}/stamps/{stampId}/image",
225 local_var_configuration.base_path,
226 stampId = crate::apis::urlencode(stamp_id)
227 );
228 let mut local_var_req_builder =
229 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
230
231 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
232 local_var_req_builder =
233 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
234 }
235 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
236 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
237 };
238 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
239 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
240 };
241 let local_var_form = reqwest::multipart::Form::new();
242 local_var_req_builder = local_var_req_builder.multipart(local_var_form);
244
245 let local_var_req = local_var_req_builder.build()?;
246 let local_var_resp = local_var_client.execute(local_var_req).await?;
247
248 let local_var_status = local_var_resp.status();
249 let local_var_content = local_var_resp.text().await?;
250
251 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
252 Ok(())
253 } else {
254 let local_var_entity: Option<ChangeStampImageError> =
255 serde_json::from_str(&local_var_content).ok();
256 let local_var_error = ResponseContent {
257 status: local_var_status,
258 content: local_var_content,
259 entity: local_var_entity,
260 };
261 Err(Error::ResponseError(local_var_error))
262 }
263}
264
265pub async fn create_stamp(
267 configuration: &configuration::Configuration,
268 name: &str,
269 _file: std::path::PathBuf,
270) -> Result<crate::models::Stamp, Error<CreateStampError>> {
271 let local_var_configuration = configuration;
272
273 let local_var_client = &local_var_configuration.client;
274
275 let local_var_uri_str = format!("{}/stamps", local_var_configuration.base_path);
276 let mut local_var_req_builder =
277 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
278
279 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
280 local_var_req_builder =
281 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
282 }
283 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
284 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
285 };
286 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
287 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
288 };
289 let mut local_var_form = reqwest::multipart::Form::new();
290 local_var_form = local_var_form.text("name", name.to_string());
291 local_var_req_builder = local_var_req_builder.multipart(local_var_form);
293
294 let local_var_req = local_var_req_builder.build()?;
295 let local_var_resp = local_var_client.execute(local_var_req).await?;
296
297 let local_var_status = local_var_resp.status();
298 let local_var_content = local_var_resp.text().await?;
299
300 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
301 serde_json::from_str(&local_var_content).map_err(Error::from)
302 } else {
303 let local_var_entity: Option<CreateStampError> =
304 serde_json::from_str(&local_var_content).ok();
305 let local_var_error = ResponseContent {
306 status: local_var_status,
307 content: local_var_content,
308 entity: local_var_entity,
309 };
310 Err(Error::ResponseError(local_var_error))
311 }
312}
313
314pub async fn create_stamp_palette(
316 configuration: &configuration::Configuration,
317 post_stamp_palette_request: Option<crate::models::PostStampPaletteRequest>,
318) -> Result<crate::models::StampPalette, Error<CreateStampPaletteError>> {
319 let local_var_configuration = configuration;
320
321 let local_var_client = &local_var_configuration.client;
322
323 let local_var_uri_str = format!("{}/stamp-palettes", local_var_configuration.base_path);
324 let mut local_var_req_builder =
325 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
326
327 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
328 local_var_req_builder =
329 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
330 }
331 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
332 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
333 };
334 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
335 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
336 };
337 local_var_req_builder = local_var_req_builder.json(&post_stamp_palette_request);
338
339 let local_var_req = local_var_req_builder.build()?;
340 let local_var_resp = local_var_client.execute(local_var_req).await?;
341
342 let local_var_status = local_var_resp.status();
343 let local_var_content = local_var_resp.text().await?;
344
345 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
346 serde_json::from_str(&local_var_content).map_err(Error::from)
347 } else {
348 let local_var_entity: Option<CreateStampPaletteError> =
349 serde_json::from_str(&local_var_content).ok();
350 let local_var_error = ResponseContent {
351 status: local_var_status,
352 content: local_var_content,
353 entity: local_var_entity,
354 };
355 Err(Error::ResponseError(local_var_error))
356 }
357}
358
359pub async fn delete_stamp(
361 configuration: &configuration::Configuration,
362 stamp_id: &str,
363) -> Result<(), Error<DeleteStampError>> {
364 let local_var_configuration = configuration;
365
366 let local_var_client = &local_var_configuration.client;
367
368 let local_var_uri_str = format!(
369 "{}/stamps/{stampId}",
370 local_var_configuration.base_path,
371 stampId = crate::apis::urlencode(stamp_id)
372 );
373 let mut local_var_req_builder =
374 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
375
376 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
377 local_var_req_builder =
378 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
379 }
380 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
381 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
382 };
383 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
384 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
385 };
386
387 let local_var_req = local_var_req_builder.build()?;
388 let local_var_resp = local_var_client.execute(local_var_req).await?;
389
390 let local_var_status = local_var_resp.status();
391 let local_var_content = local_var_resp.text().await?;
392
393 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
394 Ok(())
395 } else {
396 let local_var_entity: Option<DeleteStampError> =
397 serde_json::from_str(&local_var_content).ok();
398 let local_var_error = ResponseContent {
399 status: local_var_status,
400 content: local_var_content,
401 entity: local_var_entity,
402 };
403 Err(Error::ResponseError(local_var_error))
404 }
405}
406
407pub async fn delete_stamp_palette(
409 configuration: &configuration::Configuration,
410 palette_id: &str,
411) -> Result<(), Error<DeleteStampPaletteError>> {
412 let local_var_configuration = configuration;
413
414 let local_var_client = &local_var_configuration.client;
415
416 let local_var_uri_str = format!(
417 "{}/stamp-palettes/{paletteId}",
418 local_var_configuration.base_path,
419 paletteId = crate::apis::urlencode(palette_id)
420 );
421 let mut local_var_req_builder =
422 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
423
424 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
425 local_var_req_builder =
426 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
427 }
428 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
429 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
430 };
431 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
432 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
433 };
434
435 let local_var_req = local_var_req_builder.build()?;
436 let local_var_resp = local_var_client.execute(local_var_req).await?;
437
438 let local_var_status = local_var_resp.status();
439 let local_var_content = local_var_resp.text().await?;
440
441 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
442 Ok(())
443 } else {
444 let local_var_entity: Option<DeleteStampPaletteError> =
445 serde_json::from_str(&local_var_content).ok();
446 let local_var_error = ResponseContent {
447 status: local_var_status,
448 content: local_var_content,
449 entity: local_var_entity,
450 };
451 Err(Error::ResponseError(local_var_error))
452 }
453}
454
455pub async fn edit_stamp(
457 configuration: &configuration::Configuration,
458 stamp_id: &str,
459 patch_stamp_request: Option<crate::models::PatchStampRequest>,
460) -> Result<(), Error<EditStampError>> {
461 let local_var_configuration = configuration;
462
463 let local_var_client = &local_var_configuration.client;
464
465 let local_var_uri_str = format!(
466 "{}/stamps/{stampId}",
467 local_var_configuration.base_path,
468 stampId = crate::apis::urlencode(stamp_id)
469 );
470 let mut local_var_req_builder =
471 local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
472
473 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
474 local_var_req_builder =
475 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
476 }
477 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
478 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
479 };
480 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
481 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
482 };
483 local_var_req_builder = local_var_req_builder.json(&patch_stamp_request);
484
485 let local_var_req = local_var_req_builder.build()?;
486 let local_var_resp = local_var_client.execute(local_var_req).await?;
487
488 let local_var_status = local_var_resp.status();
489 let local_var_content = local_var_resp.text().await?;
490
491 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
492 Ok(())
493 } else {
494 let local_var_entity: Option<EditStampError> =
495 serde_json::from_str(&local_var_content).ok();
496 let local_var_error = ResponseContent {
497 status: local_var_status,
498 content: local_var_content,
499 entity: local_var_entity,
500 };
501 Err(Error::ResponseError(local_var_error))
502 }
503}
504
505pub async fn edit_stamp_palette(
507 configuration: &configuration::Configuration,
508 palette_id: &str,
509 patch_stamp_palette_request: Option<crate::models::PatchStampPaletteRequest>,
510) -> Result<(), Error<EditStampPaletteError>> {
511 let local_var_configuration = configuration;
512
513 let local_var_client = &local_var_configuration.client;
514
515 let local_var_uri_str = format!(
516 "{}/stamp-palettes/{paletteId}",
517 local_var_configuration.base_path,
518 paletteId = crate::apis::urlencode(palette_id)
519 );
520 let mut local_var_req_builder =
521 local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
522
523 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
524 local_var_req_builder =
525 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
526 }
527 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
528 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
529 };
530 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
531 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
532 };
533 local_var_req_builder = local_var_req_builder.json(&patch_stamp_palette_request);
534
535 let local_var_req = local_var_req_builder.build()?;
536 let local_var_resp = local_var_client.execute(local_var_req).await?;
537
538 let local_var_status = local_var_resp.status();
539 let local_var_content = local_var_resp.text().await?;
540
541 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
542 Ok(())
543 } else {
544 let local_var_entity: Option<EditStampPaletteError> =
545 serde_json::from_str(&local_var_content).ok();
546 let local_var_error = ResponseContent {
547 status: local_var_status,
548 content: local_var_content,
549 entity: local_var_entity,
550 };
551 Err(Error::ResponseError(local_var_error))
552 }
553}
554
555pub async fn get_message_stamps(
557 configuration: &configuration::Configuration,
558 message_id: &str,
559) -> Result<Vec<crate::models::MessageStamp>, Error<GetMessageStampsError>> {
560 let local_var_configuration = configuration;
561
562 let local_var_client = &local_var_configuration.client;
563
564 let local_var_uri_str = format!(
565 "{}/messages/{messageId}/stamps",
566 local_var_configuration.base_path,
567 messageId = crate::apis::urlencode(message_id)
568 );
569 let mut local_var_req_builder =
570 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
571
572 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
573 local_var_req_builder =
574 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
575 }
576 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
577 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
578 };
579 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
580 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
581 };
582
583 let local_var_req = local_var_req_builder.build()?;
584 let local_var_resp = local_var_client.execute(local_var_req).await?;
585
586 let local_var_status = local_var_resp.status();
587 let local_var_content = local_var_resp.text().await?;
588
589 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
590 serde_json::from_str(&local_var_content).map_err(Error::from)
591 } else {
592 let local_var_entity: Option<GetMessageStampsError> =
593 serde_json::from_str(&local_var_content).ok();
594 let local_var_error = ResponseContent {
595 status: local_var_status,
596 content: local_var_content,
597 entity: local_var_entity,
598 };
599 Err(Error::ResponseError(local_var_error))
600 }
601}
602
603pub async fn get_my_stamp_history(
605 configuration: &configuration::Configuration,
606 limit: Option<i32>,
607) -> Result<Vec<crate::models::StampHistoryEntry>, Error<GetMyStampHistoryError>> {
608 let local_var_configuration = configuration;
609
610 let local_var_client = &local_var_configuration.client;
611
612 let local_var_uri_str = format!(
613 "{}/users/me/stamp-history",
614 local_var_configuration.base_path
615 );
616 let mut local_var_req_builder =
617 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
618
619 if let Some(ref local_var_str) = limit {
620 local_var_req_builder =
621 local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
622 }
623 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
624 local_var_req_builder =
625 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
626 }
627 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
628 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
629 };
630 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
631 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
632 };
633
634 let local_var_req = local_var_req_builder.build()?;
635 let local_var_resp = local_var_client.execute(local_var_req).await?;
636
637 let local_var_status = local_var_resp.status();
638 let local_var_content = local_var_resp.text().await?;
639
640 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
641 serde_json::from_str(&local_var_content).map_err(Error::from)
642 } else {
643 let local_var_entity: Option<GetMyStampHistoryError> =
644 serde_json::from_str(&local_var_content).ok();
645 let local_var_error = ResponseContent {
646 status: local_var_status,
647 content: local_var_content,
648 entity: local_var_entity,
649 };
650 Err(Error::ResponseError(local_var_error))
651 }
652}
653
654pub async fn get_stamp(
656 configuration: &configuration::Configuration,
657 stamp_id: &str,
658) -> Result<crate::models::Stamp, Error<GetStampError>> {
659 let local_var_configuration = configuration;
660
661 let local_var_client = &local_var_configuration.client;
662
663 let local_var_uri_str = format!(
664 "{}/stamps/{stampId}",
665 local_var_configuration.base_path,
666 stampId = crate::apis::urlencode(stamp_id)
667 );
668 let mut local_var_req_builder =
669 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
670
671 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
672 local_var_req_builder =
673 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
674 }
675 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
676 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
677 };
678 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
679 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
680 };
681
682 let local_var_req = local_var_req_builder.build()?;
683 let local_var_resp = local_var_client.execute(local_var_req).await?;
684
685 let local_var_status = local_var_resp.status();
686 let local_var_content = local_var_resp.text().await?;
687
688 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
689 serde_json::from_str(&local_var_content).map_err(Error::from)
690 } else {
691 let local_var_entity: Option<GetStampError> = serde_json::from_str(&local_var_content).ok();
692 let local_var_error = ResponseContent {
693 status: local_var_status,
694 content: local_var_content,
695 entity: local_var_entity,
696 };
697 Err(Error::ResponseError(local_var_error))
698 }
699}
700
701pub async fn get_stamp_image(
703 configuration: &configuration::Configuration,
704 stamp_id: &str,
705) -> Result<std::path::PathBuf, Error<GetStampImageError>> {
706 let local_var_configuration = configuration;
707
708 let local_var_client = &local_var_configuration.client;
709
710 let local_var_uri_str = format!(
711 "{}/stamps/{stampId}/image",
712 local_var_configuration.base_path,
713 stampId = crate::apis::urlencode(stamp_id)
714 );
715 let mut local_var_req_builder =
716 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
717
718 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
719 local_var_req_builder =
720 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
721 }
722 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
723 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
724 };
725 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
726 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
727 };
728
729 let local_var_req = local_var_req_builder.build()?;
730 let local_var_resp = local_var_client.execute(local_var_req).await?;
731
732 let local_var_status = local_var_resp.status();
733 let local_var_content = local_var_resp.text().await?;
734
735 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
736 serde_json::from_str(&local_var_content).map_err(Error::from)
737 } else {
738 let local_var_entity: Option<GetStampImageError> =
739 serde_json::from_str(&local_var_content).ok();
740 let local_var_error = ResponseContent {
741 status: local_var_status,
742 content: local_var_content,
743 entity: local_var_entity,
744 };
745 Err(Error::ResponseError(local_var_error))
746 }
747}
748
749pub async fn get_stamp_palette(
751 configuration: &configuration::Configuration,
752 palette_id: &str,
753) -> Result<crate::models::StampPalette, Error<GetStampPaletteError>> {
754 let local_var_configuration = configuration;
755
756 let local_var_client = &local_var_configuration.client;
757
758 let local_var_uri_str = format!(
759 "{}/stamp-palettes/{paletteId}",
760 local_var_configuration.base_path,
761 paletteId = crate::apis::urlencode(palette_id)
762 );
763 let mut local_var_req_builder =
764 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
765
766 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
767 local_var_req_builder =
768 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
769 }
770 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
771 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
772 };
773 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
774 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
775 };
776
777 let local_var_req = local_var_req_builder.build()?;
778 let local_var_resp = local_var_client.execute(local_var_req).await?;
779
780 let local_var_status = local_var_resp.status();
781 let local_var_content = local_var_resp.text().await?;
782
783 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
784 serde_json::from_str(&local_var_content).map_err(Error::from)
785 } else {
786 let local_var_entity: Option<GetStampPaletteError> =
787 serde_json::from_str(&local_var_content).ok();
788 let local_var_error = ResponseContent {
789 status: local_var_status,
790 content: local_var_content,
791 entity: local_var_entity,
792 };
793 Err(Error::ResponseError(local_var_error))
794 }
795}
796
797pub async fn get_stamp_palettes(
799 configuration: &configuration::Configuration,
800) -> Result<Vec<crate::models::StampPalette>, Error<GetStampPalettesError>> {
801 let local_var_configuration = configuration;
802
803 let local_var_client = &local_var_configuration.client;
804
805 let local_var_uri_str = format!("{}/stamp-palettes", local_var_configuration.base_path);
806 let mut local_var_req_builder =
807 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
808
809 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
810 local_var_req_builder =
811 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
812 }
813 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
814 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
815 };
816 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
817 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
818 };
819
820 let local_var_req = local_var_req_builder.build()?;
821 let local_var_resp = local_var_client.execute(local_var_req).await?;
822
823 let local_var_status = local_var_resp.status();
824 let local_var_content = local_var_resp.text().await?;
825
826 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
827 serde_json::from_str(&local_var_content).map_err(Error::from)
828 } else {
829 let local_var_entity: Option<GetStampPalettesError> =
830 serde_json::from_str(&local_var_content).ok();
831 let local_var_error = ResponseContent {
832 status: local_var_status,
833 content: local_var_content,
834 entity: local_var_entity,
835 };
836 Err(Error::ResponseError(local_var_error))
837 }
838}
839
840pub async fn get_stamp_stats(
842 configuration: &configuration::Configuration,
843 stamp_id: &str,
844) -> Result<crate::models::StampStats, Error<GetStampStatsError>> {
845 let local_var_configuration = configuration;
846
847 let local_var_client = &local_var_configuration.client;
848
849 let local_var_uri_str = format!(
850 "{}/stamps/{stampId}/stats",
851 local_var_configuration.base_path,
852 stampId = crate::apis::urlencode(stamp_id)
853 );
854 let mut local_var_req_builder =
855 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
856
857 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
858 local_var_req_builder =
859 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
860 }
861 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
862 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
863 };
864 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
865 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
866 };
867
868 let local_var_req = local_var_req_builder.build()?;
869 let local_var_resp = local_var_client.execute(local_var_req).await?;
870
871 let local_var_status = local_var_resp.status();
872 let local_var_content = local_var_resp.text().await?;
873
874 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
875 serde_json::from_str(&local_var_content).map_err(Error::from)
876 } else {
877 let local_var_entity: Option<GetStampStatsError> =
878 serde_json::from_str(&local_var_content).ok();
879 let local_var_error = ResponseContent {
880 status: local_var_status,
881 content: local_var_content,
882 entity: local_var_entity,
883 };
884 Err(Error::ResponseError(local_var_error))
885 }
886}
887
888pub async fn get_stamps(
890 configuration: &configuration::Configuration,
891 include_unicode: Option<bool>,
892 r#type: Option<&str>,
893) -> Result<Vec<crate::models::StampWithThumbnail>, Error<GetStampsError>> {
894 let local_var_configuration = configuration;
895
896 let local_var_client = &local_var_configuration.client;
897
898 let local_var_uri_str = format!("{}/stamps", local_var_configuration.base_path);
899 let mut local_var_req_builder =
900 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
901
902 if let Some(ref local_var_str) = include_unicode {
903 local_var_req_builder =
904 local_var_req_builder.query(&[("include-unicode", &local_var_str.to_string())]);
905 }
906 if let Some(ref local_var_str) = r#type {
907 local_var_req_builder =
908 local_var_req_builder.query(&[("type", &local_var_str.to_string())]);
909 }
910 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
911 local_var_req_builder =
912 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
913 }
914 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
915 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
916 };
917 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
918 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
919 };
920
921 let local_var_req = local_var_req_builder.build()?;
922 let local_var_resp = local_var_client.execute(local_var_req).await?;
923
924 let local_var_status = local_var_resp.status();
925 let local_var_content = local_var_resp.text().await?;
926
927 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
928 serde_json::from_str(&local_var_content).map_err(Error::from)
929 } else {
930 let local_var_entity: Option<GetStampsError> =
931 serde_json::from_str(&local_var_content).ok();
932 let local_var_error = ResponseContent {
933 status: local_var_status,
934 content: local_var_content,
935 entity: local_var_entity,
936 };
937 Err(Error::ResponseError(local_var_error))
938 }
939}
940
941pub async fn remove_message_stamp(
943 configuration: &configuration::Configuration,
944 message_id: &str,
945 stamp_id: &str,
946) -> Result<(), Error<RemoveMessageStampError>> {
947 let local_var_configuration = configuration;
948
949 let local_var_client = &local_var_configuration.client;
950
951 let local_var_uri_str = format!(
952 "{}/messages/{messageId}/stamps/{stampId}",
953 local_var_configuration.base_path,
954 messageId = crate::apis::urlencode(message_id),
955 stampId = crate::apis::urlencode(stamp_id)
956 );
957 let mut local_var_req_builder =
958 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
959
960 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
961 local_var_req_builder =
962 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
963 }
964 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
965 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
966 };
967 if let Some(ref local_var_token) = local_var_configuration.bearer_access_token {
968 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
969 };
970
971 let local_var_req = local_var_req_builder.build()?;
972 let local_var_resp = local_var_client.execute(local_var_req).await?;
973
974 let local_var_status = local_var_resp.status();
975 let local_var_content = local_var_resp.text().await?;
976
977 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
978 Ok(())
979 } else {
980 let local_var_entity: Option<RemoveMessageStampError> =
981 serde_json::from_str(&local_var_content).ok();
982 let local_var_error = ResponseContent {
983 status: local_var_status,
984 content: local_var_content,
985 entity: local_var_entity,
986 };
987 Err(Error::ResponseError(local_var_error))
988 }
989}