use crate::helix::{parse_json, HelixRequestPatchError};
use super::*;
use helix::RequestPatch;
pub use types::PollStatus;
#[derive(PartialEq, typed_builder::TypedBuilder, Deserialize, Serialize, Clone, Debug, Default)]
#[non_exhaustive]
pub struct EndPollRequest {}
impl EndPollRequest {
pub fn new() -> Self { Self {} }
}
#[derive(PartialEq, typed_builder::TypedBuilder, Deserialize, Serialize, Clone, Debug)]
#[non_exhaustive]
pub struct EndPollBody {
#[builder(setter(into))]
pub broadcaster_id: String,
#[builder(setter(into))]
pub id: types::PollId,
pub status: PollStatus,
}
impl helix::private::SealedSerialize for EndPollBody {}
#[derive(PartialEq, Deserialize, Debug, Clone)]
#[cfg_attr(feature = "deny_unknown_fields", serde(deny_unknown_fields))]
#[non_exhaustive]
#[allow(clippy::large_enum_variant)]
pub enum EndPoll {
Success(Poll),
MissingQuery,
AuthFailed,
}
impl Request for EndPollRequest {
type Response = EndPoll;
const PATH: &'static str = "polls";
#[cfg(feature = "twitch_oauth2")]
const SCOPE: &'static [twitch_oauth2::Scope] = &[twitch_oauth2::Scope::ChannelManagePolls];
}
impl RequestPatch for EndPollRequest {
type Body = EndPollBody;
fn parse_inner_response(
request: Option<Self>,
uri: &http::Uri,
response: &str,
status: http::StatusCode,
) -> Result<helix::Response<Self, Self::Response>, helix::HelixRequestPatchError>
where
Self: Sized,
{
let resp = match status {
http::StatusCode::OK => {
let resp: helix::InnerResponse<Vec<Poll>> =
parse_json(response, true).map_err(|e| {
HelixRequestPatchError::DeserializeError(
response.to_string(),
e,
uri.clone(),
status,
)
})?;
EndPoll::Success(resp.data.into_iter().next().ok_or(
helix::HelixRequestPatchError::InvalidResponse {
reason: "expected at least one element in data",
response: response.to_string(),
status,
uri: uri.clone(),
},
)?)
}
http::StatusCode::BAD_REQUEST => EndPoll::MissingQuery,
http::StatusCode::UNAUTHORIZED => EndPoll::AuthFailed,
_ => {
return Err(helix::HelixRequestPatchError::InvalidResponse {
reason: "unexpected status code",
response: response.to_string(),
status,
uri: uri.clone(),
})
}
};
Ok(helix::Response {
data: resp,
pagination: None,
request,
total: None,
other: None,
})
}
}
#[cfg(test)]
#[test]
fn test_request() {
use helix::*;
let req = EndPollRequest::builder().build();
let body = EndPollBody::builder()
.broadcaster_id("274637212")
.id("92af127c-7326-4483-a52b-b0da0be61c01")
.status(PollStatus::Terminated)
.build();
dbg!(req.create_request(body, "token", "clientid").unwrap());
let data = br##"
{
"data": [
{
"id": "ed961efd-8a3f-4cf5-a9d0-e616c590cd2a",
"broadcaster_id": "141981764",
"broadcaster_name": "TwitchDev",
"broadcaster_login": "twitchdev",
"title": "Heads or Tails?",
"choices": [
{
"id": "4c123012-1351-4f33-84b7-43856e7a0f47",
"title": "Heads",
"votes": 0,
"channel_points_votes": 0,
"bits_votes": 0
},
{
"id": "279087e3-54a7-467e-bcd0-c1393fcea4f0",
"title": "Tails",
"votes": 0,
"channel_points_votes": 0,
"bits_votes": 0
}
],
"bits_voting_enabled": false,
"bits_per_vote": 0,
"channel_points_voting_enabled": true,
"channel_points_per_vote": 100,
"status": "TERMINATED",
"duration": 1800,
"started_at": "2021-03-19T06:08:33.871278372Z",
"ended_at": "2021-03-19T06:11:26.746889614Z"
}
]
}
"##
.to_vec();
let http_response = http::Response::builder().status(200).body(data).unwrap();
let uri = req.get_uri().unwrap();
assert_eq!(uri.to_string(), "https://api.twitch.tv/helix/polls?");
dbg!(EndPollRequest::parse_response(Some(req), &uri, http_response).unwrap());
}