twitch_api 0.7.2

Library for talking with the new Twitch API aka. "Helix", EventSub and more!
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
131

//! Gets a list of users who have editor permissions for a specific channel.
//! [`get-channel-editors`](https://dev.twitch.tv/docs/api/reference#get-channel-editors)
//!
//! # Accessing the endpoint
//!
//! ## Request: [GetChannelEditorsRequest]
//!
//! To use this endpoint, construct a [`GetChannelEditorsRequest`] with the [`GetChannelEditorsRequest::broadcaster_id()`] or [`GetChannelEditorsRequest::builder()`] method.
//!
//! ```rust
//! use twitch_api::helix::channels::get_channel_editors;
//! let request =
//!     get_channel_editors::GetChannelEditorsRequest::broadcaster_id("1234");
//! ```
//!
//! ## Response: [Editor]
//!
//!
//! Send the request to receive the response with [`HelixClient::req_get()`](helix::HelixClient::req_get).
//!
//!
//! ```rust, no_run
//! use twitch_api::helix::{self, channels::get_channel_editors};
//! # use twitch_api::client;
//! # #[tokio::main]
//! # async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
//! # let client: helix::HelixClient<'static, client::DummyHttpClient> = helix::HelixClient::default();
//! # let token = twitch_oauth2::AccessToken::new("validtoken".to_string());
//! # let token = twitch_oauth2::UserToken::from_existing(&client, token, None, None).await?;
//! let request = get_channel_editors::GetChannelEditorsRequest::broadcaster_id("1234");
//! let response: Vec<get_channel_editors::Editor> = client.req_get(request, &token).await?.data;
//! # Ok(())
//! # }
//! ```
//!
//! You can also get the [`http::Request`] with [`request.create_request(&token, &client_id)`](helix::RequestGet::create_request)
//! and parse the [`http::Response`] with [`GetChannelEditorsRequest::parse_response(None, &request.get_uri(), response)`](GetChannelEditorsRequest::parse_response)
use super::*;
use helix::RequestGet;

/// Query Parameters for [Get Channel Editors](super::get_channel_editors)
///
/// [`get-channel-editors`](https://dev.twitch.tv/docs/api/reference#get-channel-editors)
#[derive(PartialEq, Eq, Deserialize, Serialize, Clone, Debug)]
#[cfg_attr(feature = "typed-builder", derive(typed_builder::TypedBuilder))]
#[must_use]
#[non_exhaustive]
pub struct GetChannelEditorsRequest<'a> {
    /// Broadcaster’s user ID associated with the channel.
    #[cfg_attr(feature = "typed-builder", builder(setter(into)))]
    #[cfg_attr(feature = "deser_borrow", serde(borrow = "'a"))]
    pub broadcaster_id: Cow<'a, types::UserIdRef>,
}

impl<'a> GetChannelEditorsRequest<'a> {
    /// Get specified broadcasters channel editors
    ///
    /// # Examples
    ///
    /// ```rust
    /// use twitch_api::helix::channels::GetChannelEditorsRequest;
    /// let request = GetChannelEditorsRequest::broadcaster_id("1234");
    /// ```
    pub fn broadcaster_id(broadcaster_id: impl types::IntoCow<'a, types::UserIdRef> + 'a) -> Self {
        Self {
            broadcaster_id: broadcaster_id.into_cow(),
        }
    }
}

/// Return Values for [Get Channel Editors](super::get_channel_editors)
///
/// [`get-channel-editors`](https://dev.twitch.tv/docs/api/reference#get-channel-editors)
#[derive(PartialEq, Eq, Deserialize, Serialize, Debug, Clone)]
#[cfg_attr(feature = "deny_unknown_fields", serde(deny_unknown_fields))]
#[non_exhaustive]
pub struct Editor {
    /// User ID of the editor.
    pub user_id: types::UserId,
    /// Display name of the editor.
    pub user_name: types::DisplayName,
    /// Date and time the editor was given editor permissions.
    pub created_at: types::Timestamp,
}

impl Request for GetChannelEditorsRequest<'_> {
    type Response = Vec<Editor>;

    const PATH: &'static str = "channels/editors";
    #[cfg(feature = "twitch_oauth2")]
    const SCOPE: twitch_oauth2::Validator =
        twitch_oauth2::validator![twitch_oauth2::Scope::ChannelReadEditors];
}

impl RequestGet for GetChannelEditorsRequest<'_> {}

#[cfg(test)]
#[test]
fn test_request() {
    use helix::*;
    let req = GetChannelEditorsRequest::broadcaster_id("44445592");

    // From twitch docs
    let data = br#"
    {
        "data": [
          {
            "user_id": "182891647",
            "user_name": "mauerbac",
            "created_at": "2019-02-15T21:19:50.380833Z"
          },
          {
            "user_id": "135093069",
            "user_name": "BlueLava",
            "created_at": "2018-03-07T16:28:29.872937Z"
          }
        ]
      }
        "#
    .to_vec();

    let http_response = http::Response::builder().body(data).unwrap();

    let uri = req.get_uri().unwrap();
    assert_eq!(
        uri.to_string(),
        "https://api.twitch.tv/helix/channels/editors?broadcaster_id=44445592"
    );

    dbg!(GetChannelEditorsRequest::parse_response(Some(req), &uri, http_response).unwrap());
}