alphavantage 0.7.1

Alpha Vantage API client
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

#[cfg(feature = "blocking")]
use reqwest::blocking::Request as BlockingRequest;
use reqwest::{Method, Request, Url};
use std::convert::From;

const URL_ENDPOINT: &str = "https://www.alphavantage.co/query";

pub(crate) struct APIRequestBuilder {
    key: String,
}

impl APIRequestBuilder {
    pub(crate) fn new(key: &str) -> APIRequestBuilder {
        APIRequestBuilder {
            key: String::from(key),
        }
    }

    pub(crate) fn create<'a>(
        &'a self,
        function: &'a str,
        params: &'a [(&'a str, &'a str)],
    ) -> APIRequest<'a> {
        APIRequest::new(&self.key, function, params)
    }
}

pub(crate) struct APIRequest<'a> {
    key: &'a str,
    function: &'a str,
    params: &'a [(&'a str, &'a str)],
}

impl<'a> APIRequest<'a> {
    fn new(key: &'a str, function: &'a str, params: &'a [(&'a str, &'a str)]) -> APIRequest<'a> {
        APIRequest {
            key,
            function,
            params,
        }
    }

    fn url(&self) -> Url {
        let mut url = Url::parse(URL_ENDPOINT).unwrap();
        {
            let mut query = url.query_pairs_mut();
            query.append_pair("function", self.function);
            query.append_pair("apikey", self.key);
            for param in self.params {
                query.append_pair(param.0, param.1);
            }
        }
        url
    }
}

impl From<APIRequest<'_>> for Request {
    fn from(request: APIRequest) -> Self {
        reqwest::Request::new(Method::GET, request.url())
    }
}

#[cfg(feature = "blocking")]
impl<'a> From<APIRequest<'a>> for BlockingRequest {
    fn from(request: APIRequest) -> Self {
        reqwest::blocking::Request::new(Method::GET, request.url())
    }
}