octocrab 0.51.0

A modern, extensible GitHub 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

//! GitHub Repository Events
use crate::{
    etag::{EntityTag, Etagged},
    models::events,
    repos::RepoHandler,
    FromResponse, Page,
};
use http::request::Builder;
use http::{header::HeaderMap, Method, StatusCode};

pub struct ListRepoEventsBuilder<'octo, 'handler> {
    handler: &'handler RepoHandler<'octo>,
    headers: Headers,
    params: Params,
}

struct Headers {
    etag: Option<EntityTag>,
}

#[derive(serde::Serialize)]
struct Params {
    #[serde(skip_serializing_if = "Option::is_none")]
    per_page: Option<u8>,
    #[serde(skip_serializing_if = "Option::is_none")]
    page: Option<u32>,
}

impl<'octo, 'handler> ListRepoEventsBuilder<'octo, 'handler> {
    pub(crate) fn new(handler: &'handler RepoHandler<'octo>) -> Self {
        Self {
            handler,
            headers: Headers { etag: None },
            params: Params {
                per_page: None,
                page: None,
            },
        }
    }

    /// Etag for this request.
    pub fn etag(mut self, etag: Option<EntityTag>) -> Self {
        self.headers.etag = etag;
        self
    }

    /// Results per page (max 100).
    pub fn per_page(mut self, per_page: impl Into<u8>) -> Self {
        self.params.per_page = Some(per_page.into());
        self
    }

    /// Page number of the results to fetch.
    pub fn page(mut self, page: impl Into<u32>) -> Self {
        self.params.page = Some(page.into());
        self
    }

    /// Sends the actual request.
    pub async fn send(self) -> crate::Result<Etagged<Page<events::Event>>> {
        let route = format!("/{}/events", self.handler.repo);

        let uri = self
            .handler
            .crab
            .parameterized_uri(route, Some(&self.params))?;

        let mut headers = HeaderMap::new();
        if let Some(etag) = self.headers.etag {
            EntityTag::insert_if_none_match_header(&mut headers, etag)?;
        }

        let mut request = Builder::new().uri(uri).method(Method::GET);
        for (key, value) in headers.iter() {
            request = request.header(key, value);
        }

        let request = self.handler.crab.build_request(request, None::<&()>)?;
        let response = self.handler.crab.execute(request).await?;
        let etag = EntityTag::extract_from_response(&response);
        if response.status() == StatusCode::NOT_MODIFIED {
            Ok(Etagged { etag, value: None })
        } else {
            <Page<events::Event>>::from_response(crate::map_github_error(response).await?)
                .await
                .map(|page| Etagged {
                    etag,
                    value: Some(page),
                })
        }
    }
}