mailchimp/internal/
api.rs

1use reqwest::header::{HeaderMap, HeaderValue, CONTENT_TYPE};
2use reqwest::Url;
3use serde::de::DeserializeOwned;
4use serde::ser::Serialize;
5use serde_json;
6use std::collections::HashMap;
7
8use super::error_type::MailchimpErrorType;
9use super::request::{BasicAuth, HttpReq, MailchimpResult};
10
11///
12/// Definición del API Interno
13///
14#[derive(Debug, Clone)]
15pub struct Api<R>
16where
17    R: HttpReq,
18{
19    domain: String,
20    api_version: String,
21    api_key: String,
22    req: Box<R>,
23    basic_auth: Option<BasicAuth>,
24}
25
26impl<R> Api<R>
27where
28    R: HttpReq,
29{
30    ///
31    /// Devuelve la instancia del API para el acceso mediante el ACCESS_TOKEN
32    ///
33    /// Argumentos
34    ///     dc: Mailchimp Datacenter
35    ///     api_key: Mailchimp Access Token
36    ///     http_transport: Interfaz por donde se harían las peticiones Get y Post al servicio
37    ///
38    pub fn new<'a>(dc: &'a str, api_key: &'a str, http_transport: Box<R>) -> Self {
39        Api {
40            domain: format!("https://{}.api.mailchimp.com/", dc),
41            api_version: "3.0".to_string(),
42            api_key: api_key.to_string(),
43            req: http_transport,
44            basic_auth: Some(BasicAuth {
45                username: "".to_string(),
46                api_token: api_key.to_string(),
47            }),
48        }
49    }
50    ///
51    /// Devuelve una cadena de texto con el dominio
52    ///
53    pub fn domain(&self) -> String {
54        self.domain.clone()
55    }
56    ///
57    /// Devuelve una cadena de texto la versión del API
58    ///
59    pub fn api_version(&self) -> String {
60        self.api_version.clone()
61    }
62
63    ///
64    /// Función para darle forma a la url
65    ///
66    /// Argumentos
67    ///     endpoint: Endpoint desde donde se va a extraer los datos
68    ///     params: Parámetros de la url
69    ///
70    pub fn build_url<'a>(&self, endpoint: &'a str, params: &HashMap<String, String>) -> Url {
71        let mut api_url = Url::parse(&self.domain).unwrap();
72        let data = self.api_version.clone() + "/";
73        // Adiciona la versión del API
74        api_url = api_url.join(data.as_str()).unwrap();
75        // Adiciona Endpoint
76        api_url = api_url.join(endpoint).unwrap();
77        for (key, value) in params {
78            api_url
79                .query_pairs_mut()
80                .append_pair(key.as_str(), value.as_str());
81        }
82        api_url
83    }
84
85    ///
86    /// Conforma los headers para realizar la petición al servidor
87    ///
88    pub fn build_headers(&self) -> HeaderMap {
89        let mut headers = HeaderMap::new();
90        headers.insert(
91            CONTENT_TYPE,
92            HeaderValue::from_str("application/json").unwrap(),
93        );
94        headers
95    }
96
97    ///
98    ///
99    /// Argumentos
100    ///     endpoint: Endpoint desde donde se va a extraer los datos
101    ///     params: Parámetros de la url
102    ///     is_public: indica si el endpoint es public
103    ///
104    pub fn get_edge<'a, T>(
105        &self,
106        endpoint: &'a str,
107        params: HashMap<String, String>,
108    ) -> MailchimpResult<T>
109    where
110        T: DeserializeOwned,
111    {
112        let api_url = self.build_url(endpoint, &params);
113        let headers = self.build_headers();
114        let mut result = self.req.get(api_url, headers, &self.basic_auth)?;
115        if result.len() == 0 {
116            result = "{}".to_string();
117        }
118        match serde_json::from_str(&result) {
119            Ok(sr) => Ok(sr),
120            Err(e) => {
121                println!("{:?}", e);
122                Err(MailchimpErrorType::default())
123            }
124        }
125    }
126    ///
127    ///
128    /// Argumentos
129    ///     endpoint: Endpoint desde donde se va a extraer los datos
130    ///     params: Parámetros de la url
131    ///     is_public: indica si el endpoint es public
132    ///
133    pub fn delete_edge<'a, T>(
134        &self,
135        endpoint: &'a str,
136        params: HashMap<String, String>,
137    ) -> MailchimpResult<T>
138    where
139        T: DeserializeOwned,
140    {
141        let api_url = self.build_url(endpoint, &params);
142        let headers = self.build_headers();
143        let mut result = self.req.delete(api_url, headers, &self.basic_auth)?;
144        if result.len() == 0 {
145            result = "{}".to_string();
146        }
147        match serde_json::from_str(&result) {
148            Ok(sr) => Ok(sr),
149            Err(e) => {
150                println!("{:?}", e);
151                Err(MailchimpErrorType::default())
152            }
153        }
154    }
155
156    ///
157    ///
158    /// Argumentos
159    ///     endpoint: Endpoint hacia donde se van a enviar los datos
160    ///     payload: Dato a enviar
161    ///
162    ///
163    pub fn post_edge<'a, T, P>(&self, endpoint: &'a str, payload: P) -> MailchimpResult<T>
164    where
165        T: DeserializeOwned,
166        P: Serialize,
167    {
168        let api_url = self.build_url(endpoint, &HashMap::new());
169        let headers = self.build_headers();
170        let mut result = self
171            .req
172            .post::<P>(api_url, headers, payload, &self.basic_auth)?;
173        if result.len() == 0 {
174            result = "{}".to_string();
175        }
176        match serde_json::from_str(&result) {
177            Ok(sr) => Ok(sr),
178            Err(e) => {
179                println!("Post Edge {:?}", e);
180                Err(MailchimpErrorType::default())
181            }
182        }
183    }
184    ///
185    ///
186    /// Argumentos
187    ///     endpoint: Endpoint hacia donde se van a enviar los datos
188    ///     payload: Dato a enviar
189    ///
190    ///
191    pub fn patch_edge<'a, T, P>(&self, endpoint: &'a str, payload: P) -> MailchimpResult<T>
192    where
193        T: DeserializeOwned,
194        P: Serialize,
195    {
196        let api_url = self.build_url(endpoint, &HashMap::new());
197        let headers = self.build_headers();
198        let mut result = self
199            .req
200            .patch::<P>(api_url, headers, payload, &self.basic_auth)?;
201        if result.len() == 0 {
202            result = "{}".to_string();
203        }
204        match serde_json::from_str(&result) {
205            Ok(sr) => Ok(sr),
206            Err(e) => {
207                println!("Post Edge {:?}", e);
208                Err(MailchimpErrorType::default())
209            }
210        }
211    }
212    ///
213    ///
214    /// Argumentos
215    ///     endpoint: Endpoint hacia donde se van a enviar los datos
216    ///     payload: Dato a enviar
217    ///
218    ///
219    pub fn put_edge<'a, T, P>(&self, endpoint: &'a str, payload: P) -> MailchimpResult<T>
220    where
221        T: DeserializeOwned,
222        P: Serialize,
223    {
224        let api_url = self.build_url(endpoint, &HashMap::new());
225        let headers = self.build_headers();
226        let mut result = self
227            .req
228            .put::<P>(api_url, headers, payload, &self.basic_auth)?;
229        if result.len() == 0 {
230            result = "{}".to_string();
231        }
232        match serde_json::from_str(&result) {
233            Ok(sr) => Ok(sr),
234            Err(e) => {
235                println!("Post Edge {:?}", e);
236                Err(MailchimpErrorType::default())
237            }
238        }
239    }
240}
mailchimp/internal/api.rs

mailchimp/internal/
api.rs
