peertube 0.2.0

Peertube 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
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

mod blocklist;
mod redundancy;

pub use blocklist::Blocklist;
pub use redundancy::Redundancy;

pub struct Server {
    config: crate::Config,
    pub blocklist: Blocklist,
    pub redundancy: Redundancy,
}

impl Server {
    pub(crate) fn new(config: &crate::Config) -> Self {
        Self {
            config: config.clone(),
            blocklist: Blocklist::new(config),
            redundancy: Redundancy::new(config),
        }
    }

    /**
     * Unfollow a server.
     */
    pub async fn unfollow(&self, auth: &crate::data::Token, host: &str) -> crate::Result<()> {
        let request = crate::Request {
            path: format!("/server/following/{host}"),
            params: crate::Params::none(),
            auth: Some(auth.clone()),
        };

        crate::Api::delete(&self.config, request).await
    }

    /**
     * List instances followed by the server.
     */
    pub async fn followings(
        &self,
        pagination: &crate::param::Followings,
    ) -> crate::Result<crate::Pager<crate::data::Follow>> {
        let request = crate::Request {
            path: "/server/following".to_string(),
            params: crate::Params::Query(pagination),
            auth: None,
        };

        crate::Api::get(&self.config, request).await
    }

    /**
     * List instance followers.
     */
    pub async fn followers(
        &self,
        pagination: &crate::param::Pagination,
    ) -> crate::Result<crate::Pager<crate::data::Follow>> {
        let request = crate::Request {
            path: "/server/followers".to_string(),
            params: crate::Params::Query(pagination),
            auth: None,
        };

        crate::Api::get(&self.config, request).await
    }

    /**
     * Follow a server.
     */
    pub async fn follow(&self, auth: &crate::data::Token, host: &str) -> crate::Result<()> {
        let params = crate::param::Following {
            host: host.to_string(),
        };

        let request = crate::Request {
            path: "/server/following".to_string(),
            params: crate::Params::Json(params),
            auth: Some(auth.clone()),
        };

        crate::Api::post::<crate::data::Empty, _>(&self.config, request)
            .await?
            .into()
    }
}

#[cfg(test)]
mod test {
    #[tokio::test]
    async fn unfollow() {
        let (api, token) = crate::test::api().await;

        let status = api.server.unfollow(&token, "example.org").await;

        assert!(status.is_ok());
    }

    #[tokio::test]
    async fn followings() {
        let (api, _) = crate::test::api().await;

        let followings = api
            .server
            .followings(&crate::param::Followings::default())
            .await;

        assert!(followings.is_ok());
    }

    #[tokio::test]
    async fn followers() {
        let (api, _) = crate::test::api().await;

        let followers = api
            .server
            .followers(&crate::param::Pagination::default())
            .await;

        assert!(followers.is_ok());
    }

    #[tokio::test]
    async fn follow() {
        let (api, token) = crate::test::api().await;

        let status = api.server.follow(&token, "example.org").await;

        assert!(status.is_ok());
    }
}