pinterest_api/
api.rs

1use reqwest::{RequestBuilder, StatusCode};
2use serde::de::DeserializeOwned;
3use std::collections::HashMap;
4
5use crate::error::{Error, ErrorResponse};
6
7pub mod delete_boards_board_id;
8pub mod delete_boards_board_id_sections_section_id;
9pub mod delete_pins_pin_id;
10pub mod get_boards;
11pub mod get_boards_board_id;
12pub mod get_boards_board_id_pins;
13pub mod get_boards_board_id_sections;
14pub mod get_boards_board_id_sections_section_id_pins;
15pub mod get_media;
16pub mod get_media_media_id;
17pub mod get_pins;
18pub mod get_pins_pin_id;
19pub mod get_pins_pin_id_analytics;
20pub mod get_user_account;
21pub mod patch_boards_board_id;
22pub mod patch_boards_board_id_sections_section_id;
23pub mod patch_pins_pid_id;
24pub mod post_boards;
25pub mod post_boards_board_id_sections;
26pub mod post_media;
27pub mod post_pins;
28pub mod post_pins_pid_id_save;
29
30#[derive(Debug)]
31pub struct ApiResponse<T> {
32    pub body: T,
33    pub status_code: StatusCode,
34    pub header: HashMap<String, String>,
35}
36
37pub async fn execute_api<T>(builder: RequestBuilder) -> Result<ApiResponse<T>, Error>
38where
39    T: DeserializeOwned,
40{
41    let response = builder.send().await?;
42    let status_code = response.status();
43    let header = response
44        .headers()
45        .iter()
46        .map(|(k, v)| (k.to_string(), v.to_str().unwrap().to_string()))
47        .collect();
48    let text = match response.text().await {
49        Ok(text) => text,
50        Err(err) => return Err(Error::Other(format!("{:?}", err), status_code)),
51    };
52    let json = match serde_json::from_str::<serde_json::Value>(&text) {
53        Ok(json) => json,
54        Err(_err) => return Err(Error::Other(text, status_code)),
55    };
56    if let Some(code) = json["code"].as_i64() {
57        return Err(Error::Api(
58            ErrorResponse {
59                code,
60                message: json["message"].as_str().unwrap_or_default().to_owned(),
61            },
62            status_code,
63        ));
64    }
65    match serde_json::from_value::<T>(json) {
66        Ok(json) => Ok(ApiResponse {
67            body: json,
68            status_code,
69            header,
70        }),
71        Err(err) => Err(Error::Other(format!("{:?},{}", err, text), status_code)),
72    }
73}
74
75#[derive(Debug)]
76pub struct ApiEmptyResponse {
77    pub status_code: StatusCode,
78    pub header: HashMap<String, String>,
79}
80
81pub async fn execute_empty_api(builder: RequestBuilder) -> Result<ApiEmptyResponse, Error> {
82    let response = builder.send().await?;
83    let status_code = response.status();
84    let header = response
85        .headers()
86        .iter()
87        .map(|(k, v)| (k.to_string(), v.to_str().unwrap().to_string()))
88        .collect();
89    let text = match response.text().await {
90        Ok(text) => text,
91        Err(err) => return Err(Error::Other(format!("{:?}", err), status_code)),
92    };
93    if text.is_empty() {
94        return Ok(ApiEmptyResponse {
95            status_code,
96            header,
97        });
98    }
99    let json = match serde_json::from_str::<serde_json::Value>(&text) {
100        Ok(json) => json,
101        Err(_err) => return Err(Error::Other(text, status_code)),
102    };
103    if let Some(code) = json["code"].as_i64() {
104        return Err(Error::Api(
105            ErrorResponse {
106                code,
107                message: json["message"].as_str().unwrap_or_default().to_owned(),
108            },
109            status_code,
110        ));
111    }
112    Err(Error::Other(text, status_code))
113}