exante 0.2.0

HTTP client for Exante REST API version 3.0
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use crate::api::account_summary::{GetAccountSummary, GetAccountSummaryByDate};
use crate::api::accounts::GetUserAccounts;
use crate::api::cross_rates::{GetAvailableCurrencies, GetCrossRate};
use crate::api::transactions::GetTransactions;
use crate::api::RequestBuilder;
use crate::middleware::Middle;
use crate::ClientError;
use rustify::clients::reqwest::Client as HTTPClient;
use rustify::Endpoint;

/// Exante account type.
pub enum AccountType {
    Demo,
    Live,
}

/// A Client for sending requests to Exante server.
/// Depending on account type, different server endpoint will be used for sending requests.
pub struct Client {
    http: HTTPClient,
    middle: Middle,
}

impl Clone for Client {
    fn clone(&self) -> Self {
        // Rustify Client does not implement Clone.
        let http_client = HTTPClient {
            http: self.http.http.clone(),
            base: self.http.base.clone(),
        };

        Self {
            http: http_client,
            middle: self.middle.clone(),
        }
    }
}

impl Client {
    /// Constructs a new client using provided account type and credentials.
    pub fn new(account_type: AccountType, api_key: &str, secret_key: &str) -> Self {
        let base = match account_type {
            AccountType::Demo => "https://api-demo.exante.eu",
            AccountType::Live => "https://api-live.exante.eu",
        };

        Self {
            http: HTTPClient::default(base),
            middle: Middle::new(api_key, secret_key),
        }
    }

    /// Executes request.
    pub async fn execute<R>(&self, request: R) -> Result<<R as Endpoint>::Response, ClientError>
    where
        R: Endpoint,
    {
        request
            .with_middleware(&self.middle)
            .exec(&self.http)
            .await?
            .parse()
    }

    /// Convenience method to make `GetUserAccounts` request.
    pub fn get_user_accounts(&self) -> RequestBuilder<GetUserAccounts> {
        let req = GetUserAccounts::new();
        RequestBuilder::new(self.clone(), req)
    }

    /// Convenience method to make `GetAvailableCurrencies` request.
    pub fn get_available_currencies(&self) -> RequestBuilder<GetAvailableCurrencies> {
        let req = GetAvailableCurrencies::new();
        RequestBuilder::new(self.clone(), req)
    }

    /// Convenience method to make `GetCrossRate` request.
    pub fn get_cross_rate(&self, from: String, to: String) -> RequestBuilder<GetCrossRate> {
        let req = GetCrossRate::new(from, to);
        RequestBuilder::new(self.clone(), req)
    }

    /// Convenience method to make `GetAccountSummary` request.
    pub fn get_account_summary(
        &self,
        account_id: String,
        currency: String,
    ) -> RequestBuilder<GetAccountSummary> {
        let req = GetAccountSummary::new(account_id, currency);
        RequestBuilder::new(self.clone(), req)
    }

    /// Convenience method to make `GetAccountSummaryByDate` request.
    pub fn get_account_summary_by_date(
        &self,
        account_id: String,
        currency: String,
        date: String,
    ) -> RequestBuilder<GetAccountSummaryByDate> {
        let req = GetAccountSummaryByDate::new(account_id, currency, date);
        RequestBuilder::new(self.clone(), req)
    }

    /// Convenience method to make `GetTransactions` request.
    pub fn get_transactions(&self) -> RequestBuilder<GetTransactions> {
        let req = GetTransactions::new();
        RequestBuilder::new(self.clone(), req)
    }
}