def get(self, event_key):
event = Event.get_by_id(event_key)
if not event:
self.abort(404)
event_future = EventQuery(event_key).fetch_async(return_updated=True)
matches_future = EventMatchesQuery(event_key).fetch_async(
return_updated=True)
event, _ = event_future.get_result()
matches, _ = matches_future.get_result()
cleaned_matches = MatchHelper.deleteInvalidMatches(matches, event)
matches = MatchHelper.organizeMatches(cleaned_matches)
bracket_table, playoff_advancement, _, _ = PlayoffAdvancementHelper.generatePlayoffAdvancement(
event, matches)
event_details = EventDetails(
id=event.key_name,
playoff_advancement={
'advancement': playoff_advancement,
'bracket': bracket_table,
},
)
EventDetailsManipulator.createOrUpdate(event_details)
self.response.out.write("New playoff advancement for {}\n{}".format(
event.key_name,
json.dumps(event_details.playoff_advancement,
indent=2,
sort_keys=True)))
def _render(self, event_key):
event_future = EventQuery(event_key).fetch_async(return_updated=True)
matches_future = EventMatchesQuery(event_key).fetch_async(return_updated=True)
event, event_updated = event_future.get_result()
matches, matches_updated = matches_future.get_result()
self._last_modified = max(event_updated, matches_updated)
cleaned_matches = MatchHelper.deleteInvalidMatches(matches, event)
matches = MatchHelper.organizeMatches(cleaned_matches)
bracket_table, playoff_advancement, _, _ = PlayoffAdvancementHelper.generatePlayoffAdvancement(event, matches)
output = []
for level in Match.ELIM_LEVELS:
level_ranks = []
if playoff_advancement and playoff_advancement.get(level):
if event.playoff_type == PlayoffType.AVG_SCORE_8_TEAM:
level_ranks = PlayoffAdvancementHelper.transform2015AdvancementLevelForApi(event, playoff_advancement, level)
else:
level_ranks = PlayoffAdvancementHelper.transformRoundRobinAdvancementLevelForApi(event, playoff_advancement, level)
elif bracket_table and bracket_table.get(level):
level_ranks = PlayoffAdvancementHelper.transformBracketLevelForApi(event, bracket_table, level)
output.extend(level_ranks)
return json.dumps(output, ensure_ascii=True, indent=2, sort_keys=True)
def test_match_updated(self):
affected_refs = {
'key':
{ndb.Key(Match, '2015casj_qm1'),
ndb.Key(Match, '2015casj_qm2')},
'event': {ndb.Key(Event, '2015casj'),
ndb.Key(Event, '2015cama')},
'team_keys': {ndb.Key(Team, 'frc254'),
ndb.Key(Team, 'frc604')},
'year': {2014, 2015},
}
cache_keys = [
q.cache_key
for q in get_affected_queries.match_updated(affected_refs)
]
self.assertEqual(len(cache_keys), 16)
self.assertTrue(MatchQuery('2015casj_qm1').cache_key in cache_keys)
self.assertTrue(MatchQuery('2015casj_qm2').cache_key in cache_keys)
self.assertTrue(
MatchGdcvDataQuery('2015casj_qm1').cache_key in cache_keys)
self.assertTrue(
MatchGdcvDataQuery('2015casj_qm2').cache_key in cache_keys)
self.assertTrue(EventMatchesQuery('2015casj').cache_key in cache_keys)
self.assertTrue(EventMatchesQuery('2015cama').cache_key in cache_keys)
self.assertTrue(
EventMatchesGdcvDataQuery('2015casj').cache_key in cache_keys)
self.assertTrue(
EventMatchesGdcvDataQuery('2015cama').cache_key in cache_keys)
self.assertTrue(
TeamEventMatchesQuery('frc254', '2015casj').cache_key in
cache_keys)
self.assertTrue(
TeamEventMatchesQuery('frc254', '2015cama').cache_key in
cache_keys)
self.assertTrue(
TeamEventMatchesQuery('frc604', '2015casj').cache_key in
cache_keys)
self.assertTrue(
TeamEventMatchesQuery('frc604', '2015cama').cache_key in
cache_keys)
self.assertTrue(
TeamYearMatchesQuery('frc254', 2014).cache_key in cache_keys)
self.assertTrue(
TeamYearMatchesQuery('frc254', 2015).cache_key in cache_keys)
self.assertTrue(
TeamYearMatchesQuery('frc604', 2014).cache_key in cache_keys)
self.assertTrue(
TeamYearMatchesQuery('frc604', 2015).cache_key in cache_keys)
def _render(self, event_key, model_type=None):
matches, self._last_modified = EventMatchesQuery(event_key).fetch(
dict_version=3, return_updated=True)
if model_type is not None:
matches = filter_match_properties(matches, model_type)
return json.dumps(matches, ensure_ascii=True, indent=2, sort_keys=True)
def match_updated(affected_refs):
event_keys = filter(None, affected_refs['event'])
team_keys = filter(None, affected_refs['team_keys'])
years = filter(None, affected_refs['year'])
queries_and_keys = []
for event_key in event_keys:
queries_and_keys.append((EventMatchesQuery(event_key.id())))
for team_key in team_keys:
queries_and_keys.append((TeamEventMatchesQuery(team_key.id(), event_key.id())))
for team_key in team_keys:
for year in years:
queries_and_keys.append((TeamYearMatchesQuery(team_key.id(), year)))
return queries_and_keys
def update_champ_numbers(cls):
events = Event.query(
Event.year == 2017,
Event.event_type_enum.IN(
[EventType.CMP_DIVISION, EventType.CMP_FINALS])).fetch()
matches_futures = []
for event in events:
matches_futures.append(
EventMatchesQuery(event.key.id()).fetch_async())
pressure = 0
rotors = 0
climbs = 0
for matches_future in matches_futures:
for match in matches_future.get_result():
if not match.has_been_played:
continue
for color in ['red', 'blue']:
pressure += match.score_breakdown[color][
'autoFuelPoints'] + match.score_breakdown[color][
'teleopFuelPoints']
if match.score_breakdown[color]['rotor4Engaged']:
rotors += 4
elif match.score_breakdown[color]['rotor3Engaged']:
rotors += 3
elif match.score_breakdown[color]['rotor2Engaged']:
rotors += 2
elif match.score_breakdown[color]['rotor1Engaged']:
rotors += 1
climbs += match.score_breakdown[color][
'teleopTakeoffPoints'] / 50
deferred.defer(cls._patch_data,
'champ_numbers',
json.dumps({
'kpa_accumulated': pressure,
'rotors_engaged': rotors,
'ready_for_takeoff': climbs,
}),
_queue="firebase")
def match_updated(affected_refs):
match_keys = _filter(affected_refs['key'])
event_keys = _filter(affected_refs['event'])
team_keys = _filter(affected_refs['team_keys'])
years = _filter(affected_refs['year'])
queries_and_keys = []
for match_key in match_keys:
queries_and_keys.append((MatchQuery(match_key.id())))
queries_and_keys.append((MatchGdcvDataQuery(match_key.id())))
for event_key in event_keys:
queries_and_keys.append((EventMatchesQuery(event_key.id())))
queries_and_keys.append((EventMatchesGdcvDataQuery(event_key.id())))
for team_key in team_keys:
queries_and_keys.append(
(TeamEventMatchesQuery(team_key.id(), event_key.id())))
for team_key in team_keys:
for year in years:
queries_and_keys.append((TeamYearMatchesQuery(team_key.id(),
year)))
return queries_and_keys
def generateTeamAtEventStatusAsync(cls, team_key, event):
"""
Generate Team@Event status items
:return: a tuple future <long summary string, qual record, qual ranking, playoff status>
"""
team_number = team_key[3:]
event.prep_details()
# We need all the event's playoff matches here to properly account for backup teams
matches = yield EventMatchesQuery(event.key.id()).fetch_async()
qual_match_count = 0
playoff_match_count = 0
playoff_matches = []
for match in matches:
if match.comp_level in Match.ELIM_LEVELS:
playoff_match_count += 1
playoff_matches.append(match)
else:
qual_match_count += 1
matches = MatchHelper.organizeMatches(playoff_matches)
team_status = cls.generate_team_at_event_status(
team_key, event, matches)
rank_status = team_status.get('rank', None)
alliance_status = team_status.get('alliance', None)
playoff_status = team_status.get('playoff', None)
# Playoff Status
status, short_playoff_status = cls._get_playoff_status_string(
team_key, alliance_status, playoff_status)
# Still in quals or team did not make it to elims
if not rank_status or rank_status.get('played', 0) == 0:
# No matches played yet
status = "Team {} has not played any matches yet.".format(
team_number) if not status else status
record = '?'
rank_str = '?'
else:
# Compute rank & num_teams
# Gets record from ranking data to account for surrogate matches
rank = rank_status.get('rank', '?')
ranking_points = rank_status.get('first_sort', '?')
record = rank_status.get('record', '?')
num_teams = rank_status.get('total', '?')
rank_str = "Rank {} with {} RP".format(rank, ranking_points)
alliance_name = alliance_status.get(
'name', '?') if alliance_status else '?'
# Compute final long status for nightbot, if one isn't already there
matches_per_team = qual_match_count // rank_status.get('total', 1)
if rank_status.get('played',
0) - matches_per_team > 0 and not status:
if rank is not None:
status = "Team {} is currently rank {}/{} with a record of {} and {} ranking points.".format(
team_number, rank, num_teams, record, ranking_points)
else:
status = "Team {} currently has a record of {}.".format(
team_number, record)
elif not status:
if alliance_status is None and playoff_match_count == 0:
status = "Team {} ended qualification matches at rank {}/{} with a record of {}.".format(
team_number, rank, num_teams, record)
elif alliance_status is None and playoff_match_count > 0:
status = "Team {} ended qualification matches at rank {}/{} with a record of {} and was not picked for playoff matches.".format(
team_number, rank, num_teams, record)
else:
status = "Team {} will be competing in the playoff matches on {}.".format(
team_number, alliance_name)
raise ndb.Return(status, record, rank_str, short_playoff_status)
