pipitor 0.2.2

A Twitter bot that gathers, filters and Retweets Tweets automatically.
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 futures::compat::{Future01CompatExt, Stream01CompatExt};
use futures::TryStreamExt;
use hyper::client::connect::Connect;
use hyper::header::AUTHORIZATION;
use hyper::{Client, Uri};
use oauth1::Credentials;

use super::{Error, Response, Result};

pub async fn request_token<'a, C>(
    client_credentials: Credentials<&'a str>,
    client: &'a Client<C>,
) -> Result<Response<Credentials>>
where
    C: Connect + Sync + 'static,
{
    const URI: &str = "https://api.twitter.com/oauth/request_token";

    let oauth1::Request { authorization, .. } =
        oauth1::Builder::new(client_credentials, oauth1::HmacSha1)
            .callback("oob")
            .post_form(URI, ());

    let mut req = hyper::Request::post(Uri::from_static(URI));
    req.header(AUTHORIZATION, authorization);

    let res = client
        .request(req.body(Default::default()).unwrap())
        .compat()
        .await
        .map_err(Error::Hyper)?;

    let status = res.status();
    let rate_limit = super::rate_limit(&res);
    let body = res
        .into_body()
        .compat()
        .try_concat()
        .await
        .map_err(Error::Hyper)?;

    #[derive(serde::Deserialize)]
    struct Token {
        oauth_token: String,
        oauth_token_secret: String,
    }

    super::make_response(status, rate_limit, &body, |body| {
        let Token {
            oauth_token: identifier,
            oauth_token_secret: secret,
        } = serde_urlencoded::from_bytes::<Token>(body).map_err(|_| Error::Unexpected)?;

        Ok(Credentials { identifier, secret })
    })
}

pub async fn access_token<'a, C>(
    oauth_verifier: &'a str,
    client_credentials: Credentials<&'a str>,
    temporary_credentials: Credentials<&'a str>,
    client: &'a Client<C>,
) -> Result<Response<(i64, Credentials)>>
where
    C: Connect + Sync + 'static,
{
    const URI: &str = "https://api.twitter.com/oauth/access_token";

    let oauth1::Request { authorization, .. } =
        oauth1::Builder::new(client_credentials, oauth1::HmacSha1)
            .token(temporary_credentials)
            .verifier(oauth_verifier)
            .post_form(URI, ());

    let mut req = hyper::Request::post(Uri::from_static(URI));
    req.header(AUTHORIZATION, authorization);

    let res = client
        .request(req.body(Default::default()).unwrap())
        .compat()
        .await
        .map_err(Error::Hyper)?;

    let status = res.status();
    let rate_limit = super::rate_limit(&res);
    let body = res
        .into_body()
        .compat()
        .try_concat()
        .await
        .map_err(Error::Hyper)?;

    #[derive(serde::Deserialize)]
    struct Token {
        oauth_token: String,
        oauth_token_secret: String,
        user_id: i64,
    }

    super::make_response(status, rate_limit, &body, |body| {
        let Token {
            oauth_token: identifier,
            oauth_token_secret: secret,
            user_id,
        } = serde_urlencoded::from_bytes::<Token>(body).map_err(|_| Error::Unexpected)?;

        Ok((user_id, Credentials { identifier, secret }))
    })
}