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

Add better error messages

Browse source
This commit is contained in:
Kiana Sheibani 2023-10-01 14:55:15 -04:00
parent e16b0be447
commit a4f130b36e
Signed by: toki
GPG key ID: 6CB106C25E86A9F7
8 changed files with 309 additions and 117 deletions
Download patch file Download diff file Expand all files Collapse all files

101
src/queries/event_sets.rs
View file

@ -6,10 +6,10 @@ pub type Teams<T> = Vec<Vec<T>>;
// Variables
#[derive(cynic::QueryVariables, Debug)]
#[derive(cynic::QueryVariables, Debug, Clone)]
pub struct EventSetsVars {
pub event: EventId,
pub sets_page: i32,
pub page: i32,
}
// Query
@ -24,16 +24,22 @@ pub struct EventSets {
#[derive(cynic::QueryFragment, Debug)]
#[cynic(variables = "EventSetsVars")]
struct Event {
#[arguments(page: $sets_page, perPage: 11)]
#[arguments(page: $page, perPage: 50)]
sets: Option<SetConnection>,
}
#[derive(cynic::QueryFragment, Debug)]
struct SetConnection {
page_info: Option<PageInfo>,
#[cynic(flatten)]
nodes: Vec<Set>,
}
#[derive(cynic::QueryFragment, Debug)]
struct PageInfo {
total_pages: Option<i32>,
}
#[derive(cynic::QueryFragment, Debug)]
struct Set {
#[arguments(includeByes: true)]
@ -68,53 +74,60 @@ struct Player {
// Unwrap
pub struct EventSetsResponse {
pub pages: u64,
pub sets: Vec<SetData>,
}
pub struct SetData {
teams: Teams<PlayerData>,
winner: usize,
pub teams: Teams<PlayerData>,
pub winner: usize,
}
impl QueryUnwrap<EventSetsVars> for EventSets {
type Unwrapped = Vec<SetData>;
type Unwrapped = EventSetsResponse;
// This might be the most spaghetti code I've ever written
fn unwrap_response(response: GraphQlResponse<EventSets>) -> Option<Vec<SetData>> {
Some(
response
.data?
.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,
})
fn unwrap_response(response: GraphQlResponse<EventSets>) -> Option<EventSetsResponse> {
let response_sets = response.data?.event?.sets?;
let sets = response_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()
})
.try_collect()?;
Some(SetData { teams, winner })
})
.collect::<Vec<_>>(),
)
})
.try_collect()
})
.try_collect()?;
Some(SetData { teams, winner })
})
.collect::<Vec<_>>();
Some(EventSetsResponse {
pages: response_sets.page_info?.total_pages? as u64,
sets,
})
}
}

2
src/queries/player_info.rs
View file

@ -4,7 +4,7 @@ use schema::schema;
// Variables
#[derive(cynic::QueryVariables, Debug)]
#[derive(cynic::QueryVariables, Debug, Clone)]
pub struct PlayerInfoVars {
pub id: PlayerId,
}

2
src/queries/search_games.rs
View file

@ -4,7 +4,7 @@ use schema::schema;
// Variables
#[derive(cynic::QueryVariables)]
#[derive(cynic::QueryVariables, Clone)]
pub struct VideogameSearchVars<'a> {
pub name: &'a str,
}

70
src/queries/tournament_events.rs
View file

@ -5,14 +5,16 @@ use schema::schema;
// Variables
#[derive(cynic::QueryVariables, Debug)]
pub struct TournamentEventsVars {
#[derive(cynic::QueryVariables, Debug, Clone)]
pub struct TournamentEventsVars<'a> {
// 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 last_sync: Timestamp,
pub game_id: VideogameId,
pub page: i32,
pub state: Option<&'a str>,
}
// Query
@ -22,12 +24,13 @@ pub struct TournamentEventsVars {
pub struct TournamentEvents {
#[arguments(query: {
page: $page,
perPage: 300,
perPage: 250,
sortBy: "endAt asc",
filter: {
past: true,
afterDate: $last_query,
afterDate: $last_sync,
videogameIds: [$game_id],
addrState: $state
}})]
tournaments: Option<TournamentConnection>,
}
@ -35,10 +38,16 @@ pub struct TournamentEvents {
#[derive(cynic::QueryFragment, Debug)]
#[cynic(variables = "TournamentEventsVars")]
struct TournamentConnection {
page_info: Option<PageInfo>,
#[cynic(flatten)]
nodes: Vec<Tournament>,
}
#[derive(cynic::QueryFragment, Debug)]
struct PageInfo {
total_pages: Option<i32>,
}
#[derive(cynic::QueryFragment, Debug)]
#[cynic(variables = "TournamentEventsVars")]
struct Tournament {
@ -56,33 +65,44 @@ struct Event {
// Unwrap
#[derive(Debug, Clone)]
pub struct TournamentEventResponse {
pub pages: i32,
pub tournaments: Vec<TournamentData>,
}
#[derive(Debug, Clone)]
pub struct TournamentData {
pub name: String,
pub events: Vec<EventId>,
}
impl QueryUnwrap<TournamentEventsVars> for TournamentEvents {
type Unwrapped = Vec<TournamentData>;
impl<'a> QueryUnwrap<TournamentEventsVars<'a>> for TournamentEvents {
type Unwrapped = TournamentEventResponse;
fn unwrap_response(response: GraphQlResponse<TournamentEvents>) -> Option<Vec<TournamentData>> {
Some(
response
.data?
.tournaments?
.nodes
.into_iter()
.filter_map(|tour| {
Some(TournamentData {
name: tour.name?,
events: tour
.events
.into_iter()
.filter_map(|event| event.id)
.collect(),
})
fn unwrap_response(
response: GraphQlResponse<TournamentEvents>,
) -> Option<TournamentEventResponse> {
let response_tournaments = response.data?.tournaments?;
let tournaments = response_tournaments
.nodes
.into_iter()
.filter_map(|tour| {
Some(TournamentData {
name: tour.name?,
events: tour
.events
.into_iter()
.filter_map(|event| event.id)
.collect(),
})
.collect(),
)
})
.collect::<Vec<_>>();
Some(TournamentEventResponse {
pages: response_tournaments.page_info?.total_pages?,
tournaments,
})
}
}