coinpaprika_api/exchanges/
mod.rs1use crate::client::{Client, Response};
2use crate::error::Error;
3use reqwest_middleware::RequestBuilder;
4use serde::{Deserialize, Serialize};
5use serde_json::Value;
6
7#[derive(Debug, Serialize, Deserialize)]
8pub struct Fiat {
10 pub name: String,
11 pub symbol: String,
12}
13
14#[derive(Debug, Serialize, Deserialize)]
15pub struct Exchange {
17 pub id: String,
18 pub name: String,
19 pub active: bool,
20 pub website_status: bool,
21 pub api_status: bool,
22 pub description: Option<String>,
23 pub message: Option<String>,
24 pub links: Value,
25 pub markets_data_fetched: bool,
26 pub adjusted_rank: Option<i32>,
27 pub reported_rank: Option<i32>,
28 pub currencies: i32,
29 pub markets: i32,
30 pub fiats: Vec<Fiat>,
31 pub quotes: Value,
32 pub last_updated: String,
33}
34
35#[derive(Debug, Serialize, Deserialize)]
36pub struct ExchangeMarket {
38 pub pair: String,
39 pub base_currency_id: String,
40 pub base_currency_name: String,
41 pub quote_currency_id: String,
42 pub quote_currency_name: String,
43 pub market_url: String,
44 pub category: String,
45 pub fee_type: String,
46 pub outlier: bool,
47 pub reported_volume_24h_share: f64,
48 pub quotes: Value,
49 pub last_updated: String,
50}
51
52pub struct GetExchangesRequest<'a> {
55 client: &'a Client,
56 quotes: Vec<String>,
57}
58
59impl<'a> GetExchangesRequest<'a> {
60 pub fn new(client: &'a Client) -> Self {
61 Self {
62 client,
63 quotes: vec![],
64 }
65 }
66
67 pub fn quotes(&mut self, quotes: Vec<&str>) -> &'a mut GetExchangesRequest {
72 self.quotes = quotes.iter().map(|&q| String::from(q)).collect();
73 self
74 }
75
76 pub async fn send(&self) -> Result<Vec<Exchange>, Error> {
77 let query = match self.quotes.len() {
78 0 => vec![],
79 _ => vec![("quotes", self.quotes.join(","))],
80 };
81
82 let request: RequestBuilder = self
83 .client
84 .client
85 .get(format!("{}/exchanges", self.client.api_url))
86 .query(&query);
87
88 let response: Response = self.client.request(request).await?;
89
90 let data: Vec<Exchange> = response.response.json().await?;
91
92 Ok(data)
93 }
94}
95
96pub struct GetExchangeRequest<'a> {
99 client: &'a Client,
100 exchange_id: String,
101 quotes: Vec<String>,
102}
103
104impl<'a> GetExchangeRequest<'a> {
105 pub fn new(client: &'a Client, exchange_id: &str) -> Self {
106 Self {
107 client,
108 exchange_id: String::from(exchange_id),
109 quotes: vec![],
110 }
111 }
112
113 pub fn quotes(&mut self, quotes: Vec<&str>) -> &'a mut GetExchangeRequest {
118 self.quotes = quotes.iter().map(|&q| String::from(q)).collect();
119 self
120 }
121
122 pub async fn send(&self) -> Result<Exchange, Error> {
123 let query = match self.quotes.len() {
124 0 => vec![],
125 _ => vec![("quotes", self.quotes.join(","))],
126 };
127
128 let request: RequestBuilder = self
129 .client
130 .client
131 .get(format!(
132 "{}/exchanges/{}",
133 self.client.api_url, self.exchange_id
134 ))
135 .query(&query);
136
137 let response: Response = self.client.request(request).await?;
138
139 let data: Exchange = response.response.json().await?;
140
141 Ok(data)
142 }
143}
144
145pub struct GetExchangeMarketsRequest<'a> {
148 client: &'a Client,
149 exchange_id: String,
150 quotes: Vec<String>,
151}
152
153impl<'a> GetExchangeMarketsRequest<'a> {
154 pub fn new(client: &'a Client, exchange_id: &str) -> Self {
155 Self {
156 client,
157 exchange_id: String::from(exchange_id),
158 quotes: vec![],
159 }
160 }
161
162 pub fn quotes(&mut self, quotes: Vec<&str>) -> &'a mut GetExchangeMarketsRequest {
167 self.quotes = quotes.iter().map(|&q| String::from(q)).collect();
168 self
169 }
170
171 pub async fn send(&self) -> Result<Vec<ExchangeMarket>, Error> {
172 let query = match self.quotes.len() {
173 0 => vec![],
174 _ => vec![("quotes", self.quotes.join(","))],
175 };
176
177 let request: RequestBuilder = self
178 .client
179 .client
180 .get(format!(
181 "{}/exchanges/{}/markets",
182 self.client.api_url, self.exchange_id
183 ))
184 .query(&query);
185
186 let response: Response = self.client.request(request).await?;
187
188 let data: Vec<ExchangeMarket> = response.response.json().await?;
189
190 Ok(data)
191 }
192}