toki/StartRNR
1
0
Fork 0
Code Issues Pull requests Activity

Various fixes

Browse source
This commit is contained in:
Kiana Sheibani 2023-09-30 04:37:10 -04:00
parent 0f71cfa3c5
commit 9feba1a136
Signed by: toki
GPG key ID: 6CB106C25E86A9F7
4 changed files with 74 additions and 84 deletions
Download patch file Download diff file Expand all files Collapse all files

126
src/queries/tournament_sets.rs
View file

@ -7,15 +7,17 @@ pub type Teams<T> = Vec<Vec<T>>;
// Variables
#[derive(cynic::QueryVariables, Debug)]
pub struct TournamentSetsVars<'a> {
pub struct TournamentSetsVars {
// HACK: This should really be an optional variable, but there seems to be a
// server-side bug that completely breaks everything when this isn't passed.
// We can use a dummy value of 1 when we don't want to filter by time.
pub last_query: Timestamp,
pub game_id: VideogameId,
pub country: Option<&'a str>,
pub state: Option<&'a str>,
pub tournament: i32,
pub event_limit: i32,
pub set_page: i32,
pub set_pagesize: i32,
}
// Query
@ -24,15 +26,13 @@ pub struct TournamentSetsVars<'a> {
#[cynic(graphql_type = "Query", variables = "TournamentSetsVars")]
pub struct TournamentSets {
#[arguments(query: {
page: 1,
page: $tournament,
perPage: 1,
sortBy: "endAt desc",
sortBy: "endAt asc",
filter: {
past: true,
afterDate: $last_query,
videogameIds: [$game_id],
countryCode: $country,
addrState: $state
}})]
tournaments: Option<TournamentConnection>,
}
@ -48,14 +48,15 @@ struct TournamentConnection {
#[cynic(variables = "TournamentSetsVars")]
struct Tournament {
name: Option<String>,
#[arguments(limit: 99999, filter: { videogameId: [$game_id] })]
#[arguments(limit: $event_limit, filter: { videogameId: [$game_id] })]
#[cynic(flatten)]
events: Vec<Event>,
}
#[derive(cynic::QueryFragment, Debug)]
#[cynic(variables = "TournamentSetsVars")]
struct Event {
#[arguments(page: 1, perPage: 999)]
#[arguments(page: $set_page, perPage: $set_pagesize)]
sets: Option<SetConnection>,
}
@ -111,67 +112,58 @@ pub struct SetData {
pub winner: usize,
}
impl<'a> QueryUnwrap<TournamentSetsVars<'a>> for TournamentSets {
type Unwrapped = Vec<TournamentData>;
impl QueryUnwrap<TournamentSetsVars> for TournamentSets {
type Unwrapped = TournamentData;
// This might be the most spaghetti code I've ever written
fn unwrap_response(response: GraphQlResponse<TournamentSets>) -> Option<Vec<TournamentData>> {
Some(
response
.data?
.tournaments?
.nodes
.into_iter()
.filter_map(|tour| {
let sets = tour
.events
fn unwrap_response(response: GraphQlResponse<TournamentSets>) -> Option<TournamentData> {
let tour = response.data?.tournaments?.nodes.into_iter().next()?;
let sets = tour
.events
.into_iter()
.filter_map(|event| {
Some(
event
.sets?
.nodes
.into_iter()
.filter_map(|event| {
Some(
event
.sets?
.nodes
.into_iter()
.filter_map(|set| {
let winner_id = set.winner_id?;
let winner = set.slots.iter().position(|slot| {
slot.entrant
.as_ref()
.and_then(|x| x.id)
.map(|id| id.0 == winner_id as u64)
.unwrap_or(false)
})?;
let teams = set
.slots
.into_iter()
.map(|slot| {
slot.entrant?
.participants
.into_iter()
.map(|p| {
let p_ = p.player?;
Some(PlayerData {
id: p_.id?,
name: p_.gamer_tag,
prefix: p_.prefix,
})
})
.try_collect()
.filter_map(|set| {
let winner_id = set.winner_id?;
let winner = set.slots.iter().position(|slot| {
slot.entrant
.as_ref()
.and_then(|x| x.id)
.map(|id| id.0 == winner_id as u64)
.unwrap_or(false)
})?;
let teams = set
.slots
.into_iter()
.map(|slot| {
slot.entrant?
.participants
.into_iter()
.map(|p| {
let p_ = p.player?;
Some(PlayerData {
id: p_.id?,
name: p_.gamer_tag,
prefix: p_.prefix,
})
.try_collect()?;
Some(SetData { teams, winner })
})
.collect::<Vec<_>>(),
)
})
.try_collect()
})
.try_collect()?;
Some(SetData { teams, winner })
})
.flatten()
.collect();
Some(TournamentData {
name: tour.name?,
sets,
})
})
.collect(),
)
.collect::<Vec<_>>(),
)
})
.flatten()
.collect();
Some(TournamentData {
name: tour.name?,
sets,
})
}
}