mastodon 0.1.0

client api for interacting with mastodon instances
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

use std::env;

use hyper::{self, Client};
use hyper::client::response::Response;
use hyper::header::{Authorization, Bearer};

use serde_json;

use entities::*;

pub struct Mastodon {
    access_token: String,
    domain: String,
    client: Client,
}

impl Mastodon {
    /// create mastodon instance from access_token (as environment variable)
    pub fn from_access_token(envar: &str) -> Option<Self> {
        let token = env::var(envar).ok();

        token.map(|access| {
            Mastodon {
                access_token: access,
                domain: "mastodon.social".to_string(),
                client: Client::new()
            }
        })
    }

    fn _get_request(&self, endpoint: String, queryparams: Option<String>) -> hyper::Result<Response> {
        self.client.get(&format!("https://{}/api/v1{}", &self.domain, endpoint))
            .header( Authorization(
                        Bearer {
                            token: self.access_token.clone(),
                        }
            )).body(&queryparams.unwrap_or(String::new()))
            .send()
    }

    fn _post_request(&self, endpoint: String, queryparams: Option<String>) -> hyper::Result<Response> {
        self.client.post(&format!("https://{}/api/v1{}", &self.domain, endpoint))
            .header( Authorization(
                        Bearer {
                            token: self.access_token.clone(),
                        }
            )).body(&queryparams.unwrap_or(String::new()))
            .send()
    }

    /// get status object with id `id`
    pub fn get_status(&self, id: StatusId) -> Option<Status> {
        self._get_request(format!("/statuses/{}", id), None).ok().and_then(|r| {
            serde_json::from_reader(r).ok()
        })
    }

    /// get user object with id `id`
    pub fn get_account(&self, id: UserId) -> Option<Account> {
        self._get_request(format!("/accounts/{}", id), None).ok().and_then(|r| {
            serde_json::from_reader(r).ok()
        })
    }

    /// get latest 20 statuses for user `id`
    pub fn get_user_statuses(&self, id: UserId) -> Option<Vec<Status>> {
        self._get_request(format!("/accounts/{}/statuses", id), None).ok().and_then(|r| {
            serde_json::from_reader(r).ok()
        })
    }
    /// get users `id` is following
    pub fn get_following(&self, id: UserId) -> Option<Vec<Account>> {
        self._get_request(format!("/accounts/{}/following", id), None).ok().and_then(|r| {
            serde_json::from_reader(r).ok()
        })
    }
    /// get latest 20 statuses for `id`
    pub fn get_followers(&self, id: UserId) -> Option<Vec<Account>> {
        self._get_request(format!("/accounts/{}/followers", id), None).ok().and_then(|r| {
            serde_json::from_reader(r).ok()
        })
    }

    /// get latest statuses in home timeline
    pub fn home_timeline(&self) -> Option<Vec<Status>> {
        self._get_request(format!("/timelines/home"), None).ok().and_then(|r| {
            serde_json::from_reader(r).ok()
        })
    }

    /// get latest statuses in public timeline
    pub fn public_timeline(&self) -> Option<Vec<Status>> {
        self._get_request(format!("/timelines/public"), None).ok().and_then(|r| {
            serde_json::from_reader(r).ok()
        })
    }

    /// get latest 20 statuses for `id`
    pub fn mentions(&self) -> Option<Vec<Status>> {
        self._get_request(format!("/timelines/mentions"), None).ok().and_then(|r| {
            serde_json::from_reader(r).ok()
        })
    }

}